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
  80   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
  81   ext = __builtin_elementwise_add_sat(ext, ext);
  82
  83   const int ci;
  84   i = __builtin_elementwise_add_sat(ci, i);
  85   i = __builtin_elementwise_add_sat(i, ci);
  86   i = __builtin_elementwise_add_sat(ci, ci);
  87
  88   i = __builtin_elementwise_add_sat(i, int_as_one); // ok (attributes don't match)?
  89   i = __builtin_elementwise_add_sat(i, b);          // ok (sugar doesn't match)?
  90
  91   int A[10];
  92   A = __builtin_elementwise_add_sat(A, A);
  93   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
  94
  95   int(ii);
  96   int j;
  97   j = __builtin_elementwise_add_sat(i, j);
  98
  99   _Complex float c1, c2;
 100   c1 = __builtin_elementwise_add_sat(c1, c2);
 101   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 102 }
 103
 104 void test_builtin_elementwise_sub_sat(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 105   i = __builtin_elementwise_sub_sat(p, d);
 106   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 107
 108   struct Foo foo = __builtin_elementwise_sub_sat(i, i);
 109   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 110
 111   i = __builtin_elementwise_sub_sat(i);
 112   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 113
 114   i = __builtin_elementwise_sub_sat();
 115   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 116
 117   i = __builtin_elementwise_sub_sat(i, i, i);
 118   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 119
 120   i = __builtin_elementwise_sub_sat(v, iv);
 121   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 122
 123   i = __builtin_elementwise_sub_sat(uv, iv);
 124   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 125
 126   v = __builtin_elementwise_sub_sat(v, v);
 127   // expected-error@-1 {{1st argument must be a vector of integers (was 'float4' (vector of 4 'float' values))}}
 128
 129   s = __builtin_elementwise_sub_sat(i, s);
 130
 131   enum e { one,
 132            two };
 133   i = __builtin_elementwise_sub_sat(one, two);
 134
 135   enum f { three };
 136   enum f x = __builtin_elementwise_sub_sat(one, three);
 137
 138   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
 139   ext = __builtin_elementwise_sub_sat(ext, ext);
 140
 141   const int ci;
 142   i = __builtin_elementwise_sub_sat(ci, i);
 143   i = __builtin_elementwise_sub_sat(i, ci);
 144   i = __builtin_elementwise_sub_sat(ci, ci);
 145
 146   i = __builtin_elementwise_sub_sat(i, int_as_one); // ok (attributes don't match)?
 147   i = __builtin_elementwise_sub_sat(i, b);          // ok (sugar doesn't match)?
 148
 149   int A[10];
 150   A = __builtin_elementwise_sub_sat(A, A);
 151   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
 152
 153   int(ii);
 154   int j;
 155   j = __builtin_elementwise_sub_sat(i, j);
 156
 157   _Complex float c1, c2;
 158   c1 = __builtin_elementwise_sub_sat(c1, c2);
 159   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 160 }
 161
 162 void test_builtin_elementwise_max(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 163   i = __builtin_elementwise_max(p, d);
 164   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 165
 166   struct Foo foo = __builtin_elementwise_max(i, i);
 167   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 168
 169   i = __builtin_elementwise_max(i);
 170   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 171
 172   i = __builtin_elementwise_max();
 173   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 174
 175   i = __builtin_elementwise_max(i, i, i);
 176   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 177
 178   i = __builtin_elementwise_max(v, iv);
 179   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 180
 181   i = __builtin_elementwise_max(uv, iv);
 182   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 183
 184   s = __builtin_elementwise_max(i, s);
 185
 186   enum e { one,
 187            two };
 188   i = __builtin_elementwise_max(one, two);
 189
 190   enum f { three };
 191   enum f x = __builtin_elementwise_max(one, three);
 192
 193   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
 194   ext = __builtin_elementwise_max(ext, ext);
 195
 196   const int ci;
 197   i = __builtin_elementwise_max(ci, i);
 198   i = __builtin_elementwise_max(i, ci);
 199   i = __builtin_elementwise_max(ci, ci);
 200
 201   i = __builtin_elementwise_max(i, int_as_one); // ok (attributes don't match)?
 202   i = __builtin_elementwise_max(i, b);          // ok (sugar doesn't match)?
 203
 204   int A[10];
 205   A = __builtin_elementwise_max(A, A);
 206   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
 207
 208   int(ii);
 209   int j;
 210   j = __builtin_elementwise_max(i, j);
 211
 212   _Complex float c1, c2;
 213   c1 = __builtin_elementwise_max(c1, c2);
 214   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 215 }
 216
 217 void test_builtin_elementwise_min(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 218   i = __builtin_elementwise_min(p, d);
 219   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 220
 221   struct Foo foo = __builtin_elementwise_min(i, i);
 222   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 223
 224   i = __builtin_elementwise_min(i);
 225   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 226
 227   i = __builtin_elementwise_min();
 228   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 229
 230   i = __builtin_elementwise_min(i, i, i);
 231   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 232
 233   i = __builtin_elementwise_min(v, iv);
 234   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 235
 236   i = __builtin_elementwise_min(uv, iv);
 237   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 238
 239   s = __builtin_elementwise_min(i, s);
 240
 241   enum e { one,
 242            two };
 243   i = __builtin_elementwise_min(one, two);
 244
 245   enum f { three };
 246   enum f x = __builtin_elementwise_min(one, three);
 247
 248   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
 249   ext = __builtin_elementwise_min(ext, ext);
 250
 251   const int ci;
 252   i = __builtin_elementwise_min(ci, i);
 253   i = __builtin_elementwise_min(i, ci);
 254   i = __builtin_elementwise_min(ci, ci);
 255
 256   i = __builtin_elementwise_min(i, int_as_one); // ok (attributes don't match)?
 257   i = __builtin_elementwise_min(i, b);          // ok (sugar doesn't match)?
 258
 259   int A[10];
 260   A = __builtin_elementwise_min(A, A);
 261   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
 262
 263   int(ii);
 264   int j;
 265   j = __builtin_elementwise_min(i, j);
 266
 267   _Complex float c1, c2;
 268   c1 = __builtin_elementwise_min(c1, c2);
 269   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 270 }
 271
 272 void test_builtin_elementwise_bitreverse(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 273
 274   struct Foo s = __builtin_elementwise_ceil(f);
 275   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 276
 277   i = __builtin_elementwise_bitreverse();
 278   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 279
 280   i = __builtin_elementwise_bitreverse(f);
 281   // expected-error@-1 {{1st argument must be a vector of integers (was 'float')}}
 282
 283   i = __builtin_elementwise_bitreverse(f, f);
 284   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 285
 286   u = __builtin_elementwise_bitreverse(d);
 287   // expected-error@-1 {{1st argument must be a vector of integers (was 'double')}}
 288
 289   v = __builtin_elementwise_bitreverse(v);
 290   // expected-error@-1 {{1st argument must be a vector of integers (was 'float4' (vector of 4 'float' values))}}
 291 }
 292
 293 void test_builtin_elementwise_ceil(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 294
 295   struct Foo s = __builtin_elementwise_ceil(f);
 296   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 297
 298   i = __builtin_elementwise_ceil();
 299   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 300
 301   i = __builtin_elementwise_ceil(i);
 302   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 303
 304   i = __builtin_elementwise_ceil(f, f);
 305   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 306
 307   u = __builtin_elementwise_ceil(u);
 308   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 309
 310   uv = __builtin_elementwise_ceil(uv);
 311   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 312 }
 313
 314 void test_builtin_elementwise_cos(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 315
 316   struct Foo s = __builtin_elementwise_cos(f);
 317   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 318
 319   i = __builtin_elementwise_cos();
 320   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 321
 322   i = __builtin_elementwise_cos(i);
 323   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 324
 325   i = __builtin_elementwise_cos(f, f);
 326   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 327
 328   u = __builtin_elementwise_cos(u);
 329   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 330
 331   uv = __builtin_elementwise_cos(uv);
 332   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 333 }
 334
 335 void test_builtin_elementwise_exp(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 336
 337   struct Foo s = __builtin_elementwise_exp(f);
 338   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 339
 340   i = __builtin_elementwise_exp();
 341   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 342
 343   i = __builtin_elementwise_exp(i);
 344   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 345
 346   i = __builtin_elementwise_exp(f, f);
 347   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 348
 349   u = __builtin_elementwise_exp(u);
 350   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 351
 352   uv = __builtin_elementwise_exp(uv);
 353   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 354 }
 355
 356 void test_builtin_elementwise_exp2(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 357
 358   struct Foo s = __builtin_elementwise_exp2(f);
 359   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 360
 361   i = __builtin_elementwise_exp2();
 362   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 363
 364   i = __builtin_elementwise_exp2(i);
 365   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 366
 367   i = __builtin_elementwise_exp2(f, f);
 368   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 369
 370   u = __builtin_elementwise_exp2(u);
 371   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 372
 373   uv = __builtin_elementwise_exp2(uv);
 374   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 375 }
 376
 377
 378 void test_builtin_elementwise_floor(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 379
 380   struct Foo s = __builtin_elementwise_floor(f);
 381   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 382
 383   i = __builtin_elementwise_floor();
 384   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 385
 386   i = __builtin_elementwise_floor(i);
 387   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 388
 389   i = __builtin_elementwise_floor(f, f);
 390   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 391
 392   u = __builtin_elementwise_floor(u);
 393   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 394
 395   uv = __builtin_elementwise_floor(uv);
 396   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 397 }
 398
 399 void test_builtin_elementwise_log(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 400
 401   struct Foo s = __builtin_elementwise_log(f);
 402   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 403
 404   i = __builtin_elementwise_log();
 405   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 406
 407   i = __builtin_elementwise_log(i);
 408   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 409
 410   i = __builtin_elementwise_log(f, f);
 411   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 412
 413   u = __builtin_elementwise_log(u);
 414   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 415
 416   uv = __builtin_elementwise_log(uv);
 417   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 418 }
 419
 420 void test_builtin_elementwise_log10(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 421
 422   struct Foo s = __builtin_elementwise_log10(f);
 423   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 424
 425   i = __builtin_elementwise_log10();
 426   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 427
 428   i = __builtin_elementwise_log10(i);
 429   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 430
 431   i = __builtin_elementwise_log10(f, f);
 432   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 433
 434   u = __builtin_elementwise_log10(u);
 435   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 436
 437   uv = __builtin_elementwise_log10(uv);
 438   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 439 }
 440
 441 void test_builtin_elementwise_log2(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 442
 443   struct Foo s = __builtin_elementwise_log2(f);
 444   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 445
 446   i = __builtin_elementwise_log2();
 447   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 448
 449   i = __builtin_elementwise_log2(i);
 450   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 451
 452   i = __builtin_elementwise_log2(f, f);
 453   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 454
 455   u = __builtin_elementwise_log2(u);
 456   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 457
 458   uv = __builtin_elementwise_log2(uv);
 459   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 460 }
 461
 462 void test_builtin_elementwise_pow(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 463   i = __builtin_elementwise_pow(p, d);
 464   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 465
 466   struct Foo foo = __builtin_elementwise_pow(i, i);
 467   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 468
 469   i = __builtin_elementwise_pow(i);
 470   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 471
 472   i = __builtin_elementwise_pow();
 473   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 474
 475   i = __builtin_elementwise_pow(i, i, i);
 476   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 477
 478   i = __builtin_elementwise_pow(v, iv);
 479   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 480
 481   i = __builtin_elementwise_pow(uv, iv);
 482   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 483
 484 }
 485
 486
 487 void test_builtin_elementwise_roundeven(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 488
 489   struct Foo s = __builtin_elementwise_roundeven(f);
 490   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 491
 492   i = __builtin_elementwise_roundeven();
 493   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 494
 495   i = __builtin_elementwise_roundeven(i);
 496   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 497
 498   i = __builtin_elementwise_roundeven(f, f);
 499   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 500
 501   u = __builtin_elementwise_roundeven(u);
 502   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 503
 504   uv = __builtin_elementwise_roundeven(uv);
 505   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 506 }
 507
 508 void test_builtin_elementwise_round(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 509   struct Foo s = __builtin_elementwise_round(f);
 510   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 511
 512   i = __builtin_elementwise_round();
 513   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 514
 515   i = __builtin_elementwise_round(i);
 516   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 517
 518   i = __builtin_elementwise_round(f, f);
 519   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 520
 521   u = __builtin_elementwise_round(u);
 522   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 523
 524   uv = __builtin_elementwise_round(uv);
 525   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 526
 527   // FIXME: Error should not mention integer
 528   _Complex float c1, c2;
 529   c1 = __builtin_elementwise_round(c1);
 530   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 531 }
 532
 533 void test_builtin_elementwise_rint(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 534   struct Foo s = __builtin_elementwise_rint(f);
 535   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 536
 537   i = __builtin_elementwise_rint();
 538   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 539
 540   i = __builtin_elementwise_rint(i);
 541   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 542
 543   i = __builtin_elementwise_rint(f, f);
 544   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 545
 546   u = __builtin_elementwise_rint(u);
 547   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 548
 549   uv = __builtin_elementwise_rint(uv);
 550   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 551
 552   // FIXME: Error should not mention integer
 553   _Complex float c1, c2;
 554   c1 = __builtin_elementwise_rint(c1);
 555   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 556 }
 557
 558 void test_builtin_elementwise_nearbyint(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 559   struct Foo s = __builtin_elementwise_nearbyint(f);
 560   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 561
 562   i = __builtin_elementwise_nearbyint();
 563   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 564
 565   i = __builtin_elementwise_nearbyint(i);
 566   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 567
 568   i = __builtin_elementwise_nearbyint(f, f);
 569   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 570
 571   u = __builtin_elementwise_nearbyint(u);
 572   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 573
 574   uv = __builtin_elementwise_nearbyint(uv);
 575   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 576
 577   // FIXME: Error should not mention integer
 578   _Complex float c1, c2;
 579   c1 = __builtin_elementwise_nearbyint(c1);
 580   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 581 }
 582
 583 void test_builtin_elementwise_sin(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 584
 585   struct Foo s = __builtin_elementwise_sin(f);
 586   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 587
 588   i = __builtin_elementwise_sin();
 589   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 590
 591   i = __builtin_elementwise_sin(i);
 592   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 593
 594   i = __builtin_elementwise_sin(f, f);
 595   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 596
 597   u = __builtin_elementwise_sin(u);
 598   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 599
 600   uv = __builtin_elementwise_sin(uv);
 601   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 602 }
 603
 604 void test_builtin_elementwise_sqrt(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 605
 606   struct Foo s = __builtin_elementwise_sqrt(f);
 607   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 608
 609   i = __builtin_elementwise_sqrt();
 610   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 611
 612   i = __builtin_elementwise_sqrt(i);
 613   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 614
 615   i = __builtin_elementwise_sqrt(f, f);
 616   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 617
 618   u = __builtin_elementwise_sqrt(u);
 619   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 620
 621   uv = __builtin_elementwise_sqrt(uv);
 622   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 623 }
 624
 625 void test_builtin_elementwise_trunc(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 626
 627   struct Foo s = __builtin_elementwise_trunc(f);
 628   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 629
 630   i = __builtin_elementwise_trunc();
 631   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 632
 633   i = __builtin_elementwise_trunc(i);
 634   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 635
 636   i = __builtin_elementwise_trunc(f, f);
 637   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 638
 639   u = __builtin_elementwise_trunc(u);
 640   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 641
 642   uv = __builtin_elementwise_trunc(uv);
 643   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 644 }
 645
 646 void test_builtin_elementwise_canonicalize(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 647
 648   struct Foo s = __builtin_elementwise_canonicalize(f);
 649   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 650
 651   i = __builtin_elementwise_canonicalize();
 652   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 653
 654   i = __builtin_elementwise_canonicalize(i);
 655   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 656
 657   i = __builtin_elementwise_canonicalize(f, f);
 658   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 659
 660   u = __builtin_elementwise_canonicalize(u);
 661   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 662
 663   uv = __builtin_elementwise_canonicalize(uv);
 664   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 665 }
 666
 667 void test_builtin_elementwise_copysign(int i, short s, double d, float f, float4 v, int3 iv, unsigned3 uv, int *p) {
 668   i = __builtin_elementwise_copysign(p, d);
 669   // expected-error@-1 {{1st argument must be a floating point type (was 'int *')}}
 670
 671   i = __builtin_elementwise_copysign(i, i);
 672   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 673
 674   i = __builtin_elementwise_copysign(i);
 675   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 676
 677   i = __builtin_elementwise_copysign();
 678   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 679
 680   i = __builtin_elementwise_copysign(i, i, i);
 681   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 682
 683   i = __builtin_elementwise_copysign(v, iv);
 684   // expected-error@-1 {{2nd argument must be a floating point type (was 'int3' (vector of 3 'int' values))}}
 685
 686   i = __builtin_elementwise_copysign(uv, iv);
 687   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned3' (vector of 3 'unsigned int' values))}}
 688
 689   s = __builtin_elementwise_copysign(i, s);
 690   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 691
 692   f = __builtin_elementwise_copysign(f, i);
 693   // expected-error@-1 {{2nd argument must be a floating point type (was 'int')}}
 694
 695   f = __builtin_elementwise_copysign(i, f);
 696   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 697
 698   enum e { one,
 699            two };
 700   i = __builtin_elementwise_copysign(one, two);
 701   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 702
 703   enum f { three };
 704   enum f x = __builtin_elementwise_copysign(one, three);
 705   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 706
 707   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
 708   ext = __builtin_elementwise_copysign(ext, ext);
 709   // expected-error@-1 {{1st argument must be a floating point type (was '_BitInt(32)')}}
 710
 711   const float cf32;
 712   f = __builtin_elementwise_copysign(cf32, f);
 713   f = __builtin_elementwise_copysign(f, cf32);
 714   f = __builtin_elementwise_copysign(cf32, f);
 715
 716   f = __builtin_elementwise_copysign(f, float_as_one); // ok (attributes don't match)?
 717   f = __builtin_elementwise_copysign(f, waf);          // ok (sugar doesn't match)?
 718
 719   float A[10];
 720   A = __builtin_elementwise_copysign(A, A);
 721   // expected-error@-1 {{1st argument must be a floating point type (was 'float *')}}
 722
 723   float(ii);
 724   float j;
 725   j = __builtin_elementwise_copysign(f, j);
 726
 727   _Complex float c1, c2;
 728   c1 = __builtin_elementwise_copysign(c1, c2);
 729   // expected-error@-1 {{1st argument must be a floating point type (was '_Complex float')}}
 730
 731   double f64 = 0.0;
 732   double tmp0 = __builtin_elementwise_copysign(f64, f);
 733   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
 734
 735   float tmp1 = __builtin_elementwise_copysign(f, f64);
 736   //expected-error@-1 {{arguments are of different types ('float' vs 'double')}}
 737
 738   float4 v4f32 = 0.0f;
 739   float4 tmp2 = __builtin_elementwise_copysign(v4f32, f);
 740   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'float')}}
 741
 742   float tmp3 = __builtin_elementwise_copysign(f, v4f32);
 743   // expected-error@-1 {{arguments are of different types ('float' vs 'float4' (vector of 4 'float' values))}}
 744
 745   float2 v2f32 = 0.0f;
 746   double4 v4f64 = 0.0;
 747   double4 tmp4 = __builtin_elementwise_copysign(v4f64, v4f32);
 748   // expected-error@-1 {{arguments are of different types ('double4' (vector of 4 'double' values) vs 'float4' (vector of 4 'float' values))}}
 749
 750   float4 tmp6 = __builtin_elementwise_copysign(v4f32, v4f64);
 751   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'double4' (vector of 4 'double' values))}}
 752
 753   float4 tmp7 = __builtin_elementwise_copysign(v4f32, v2f32);
 754   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'float2' (vector of 2 'float' values))}}
 755
 756   float2 tmp8 = __builtin_elementwise_copysign(v2f32, v4f32);
 757   // expected-error@-1 {{arguments are of different types ('float2' (vector of 2 'float' values) vs 'float4' (vector of 4 'float' values))}}
 758
 759   float2 tmp9 = __builtin_elementwise_copysign(v4f32, v4f32);
 760   // expected-error@-1 {{initializing 'float2' (vector of 2 'float' values) with an expression of incompatible type 'float4' (vector of 4 'float' values)}}
 761 }
 762
 763 void test_builtin_elementwise_fma(int i32, int2 v2i32, short i16,
 764                                   double f64, double2 v2f64, double2 v3f64,
 765                                   float f32, float2 v2f32, float v3f32, float4 v4f32,
 766                                   const float4 c_v4f32,
 767                                   int3 v3i32, int *ptr) {
 768
 769   f32 = __builtin_elementwise_fma();
 770   // expected-error@-1 {{too few arguments to function call, expected 3, have 0}}
 771
 772   f32 = __builtin_elementwise_fma(f32);
 773   // expected-error@-1 {{too few arguments to function call, expected 3, have 1}}
 774
 775   f32 = __builtin_elementwise_fma(f32, f32);
 776   // expected-error@-1 {{too few arguments to function call, expected 3, have 2}}
 777
 778   f32 = __builtin_elementwise_fma(f32, f32, f32, f32);
 779   // expected-error@-1 {{too many arguments to function call, expected 3, have 4}}
 780
 781   f32 = __builtin_elementwise_fma(f64, f32, f32);
 782   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
 783
 784   f32 = __builtin_elementwise_fma(f32, f64, f32);
 785   // expected-error@-1 {{arguments are of different types ('float' vs 'double')}}
 786
 787   f32 = __builtin_elementwise_fma(f32, f32, f64);
 788   // expected-error@-1 {{arguments are of different types ('float' vs 'double')}}
 789
 790   f32 = __builtin_elementwise_fma(f32, f32, f64);
 791   // expected-error@-1 {{arguments are of different types ('float' vs 'double')}}
 792
 793   f64 = __builtin_elementwise_fma(f64, f32, f32);
 794   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
 795
 796   f64 = __builtin_elementwise_fma(f64, f64, f32);
 797   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
 798
 799   f64 = __builtin_elementwise_fma(f64, f32, f64);
 800   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
 801
 802   v2f64 = __builtin_elementwise_fma(v2f32, f64, f64);
 803   // expected-error@-1 {{arguments are of different types ('float2' (vector of 2 'float' values) vs 'double'}}
 804
 805   v2f64 = __builtin_elementwise_fma(v2f32, v2f64, f64);
 806   // expected-error@-1 {{arguments are of different types ('float2' (vector of 2 'float' values) vs 'double2' (vector of 2 'double' values)}}
 807
 808   v2f64 = __builtin_elementwise_fma(v2f32, f64, v2f64);
 809   // expected-error@-1 {{arguments are of different types ('float2' (vector of 2 'float' values) vs 'double'}}
 810
 811   v2f64 = __builtin_elementwise_fma(f64, v2f32, v2f64);
 812   // expected-error@-1 {{arguments are of different types ('double' vs 'float2' (vector of 2 'float' values)}}
 813
 814   v2f64 = __builtin_elementwise_fma(f64, v2f64, v2f64);
 815   // expected-error@-1 {{arguments are of different types ('double' vs 'double2' (vector of 2 'double' values)}}
 816
 817   i32 = __builtin_elementwise_fma(i32, i32, i32);
 818   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 819
 820   v2i32 = __builtin_elementwise_fma(v2i32, v2i32, v2i32);
 821   // expected-error@-1 {{1st argument must be a floating point type (was 'int2' (vector of 2 'int' values))}}
 822
 823   f32 = __builtin_elementwise_fma(f32, f32, i32);
 824   // expected-error@-1 {{3rd argument must be a floating point type (was 'int')}}
 825
 826   f32 = __builtin_elementwise_fma(f32, i32, f32);
 827   // expected-error@-1 {{2nd argument must be a floating point type (was 'int')}}
 828
 829   f32 = __builtin_elementwise_fma(f32, f32, i32);
 830   // expected-error@-1 {{3rd argument must be a floating point type (was 'int')}}
 831
 832
 833   _Complex float c1, c2, c3;
 834   c1 = __builtin_elementwise_fma(c1, f32, f32);
 835   // expected-error@-1 {{1st argument must be a floating point type (was '_Complex float')}}
 836
 837   c2 = __builtin_elementwise_fma(f32, c2, f32);
 838   // expected-error@-1 {{2nd argument must be a floating point type (was '_Complex float')}}
 839
 840   c3 = __builtin_elementwise_fma(f32, f32, c3);
 841   // expected-error@-1 {{3rd argument must be a floating point type (was '_Complex float')}}
 842 }