[Sema] Add signed/unsigned integer mismatch tests for min/max elementwise builtins

[RKSimon]

Summary

As suggested on D117898

[aaron.ballman]

LGTM assuming that CI passes.

[fhahn]

LGTM, thanks!

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

 // RUN: %clang_cc1 -std=c99 %s -pedantic -verify -triple=x86_64-apple-darwin9
 
 typedef float float4 __attribute__((ext_vector_type(4)));
 typedef int int3 __attribute__((ext_vector_type(3)));
+typedef unsigned unsigned3 __attribute__((ext_vector_type(3)));
 typedef unsigned unsigned4 __attribute__((ext_vector_type(4)));
 
 struct Foo {
   char *p;
 };
 
 __attribute__((address_space(1))) int int_as_one;
 typedef int bar;
void test_builtin_elementwise_abs(int i, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 
   u = __builtin_elementwise_abs(u);
   // expected-error@-1 {{1st argument must be a signed integer or floating point type (was 'unsigned int')}}
 
   uv = __builtin_elementwise_abs(uv);
   // expected-error@-1 {{1st argument must be a signed integer or floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 }
 
-void test_builtin_elementwise_max(int i, short s, double d, float4 v, int3 iv, int *p) {
+void test_builtin_elementwise_max(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
   i = __builtin_elementwise_max(p, d);
   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 
   struct Foo foo = __builtin_elementwise_max(i, i);
   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 
   i = __builtin_elementwise_max(i);
   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 
   i = __builtin_elementwise_max();
   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 
   i = __builtin_elementwise_max(i, i, i);
   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 
   i = __builtin_elementwise_max(v, iv);
   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 
+  i = __builtin_elementwise_max(uv, iv);
+  // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
+
   s = __builtin_elementwise_max(i, s);
 
   enum e { one,
            two };
   i = __builtin_elementwise_max(one, two);
 
   enum f { three };
   enum f x = __builtin_elementwise_max(one, three);
void test_builtin_elementwise_max(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
   int j;
   j = __builtin_elementwise_max(i, j);
 
   _Complex float c1, c2;
   c1 = __builtin_elementwise_max(c1, c2);
   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 }
 
-void test_builtin_elementwise_min(int i, short s, double d, float4 v, int3 iv, int *p) {
+void test_builtin_elementwise_min(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
   i = __builtin_elementwise_min(p, d);
   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 
   struct Foo foo = __builtin_elementwise_min(i, i);
   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 
   i = __builtin_elementwise_min(i);
   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 
   i = __builtin_elementwise_min();
   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 
   i = __builtin_elementwise_min(i, i, i);
   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 
   i = __builtin_elementwise_min(v, iv);
   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 
+  i = __builtin_elementwise_min(uv, iv);
+  // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
+
   s = __builtin_elementwise_min(i, s);
 
   enum e { one,
            two };
   i = __builtin_elementwise_min(one, two);
 
   enum f { three };
   enum f x = __builtin_elementwise_min(one, three);