[test] Add ext_vector_type tests for C

[porglezomp]

Summary

Test that all vector-vs-scalar builtin operators type check
successfully.

[porglezomp]

See also: very similar baseline tests for C++: D151059

I'm interested in any feedback about the correct semantics for this.
I started writing these tests while investigating the behavior of vector vs scalar operations in C++ for D151060 and finding a lot of that inconsistent.
I want to get down checks that these cases are all appropriately accepted.
Interested in feedback from anyone working with the ext_vector_types.

[fhahn]

Thanks for texting the test coverage!

clang/test/Sema/ext_vector_ops.c

30

Not sure if vs is the right connector here, maybe something like Operators with one integer vector and scalar.. Period at end of These will splat

[aaron.ballman]

Thank you for the additional test coverage! The changes LGTM modulo the suggestion from @fhahn on how to improve the comments. (Note, given your goal of verifying that operations work, you might want to consider adding similar coverage for CodeGen tests to verify that we emit sensible LLVM IR for each of these operations as well, if we don't already have sufficient coverage for it.)

[porglezomp]

Address the comment suggestions

[fhahn]

LGTM, thanks!

clang/test/Sema/ext_vector_ops.c

void test1(v2u v2ua, v2s v2sa, v2f v2fa) {
   int array1[v2ua]; // expected-error{{size of array has non-integer type 'v2u' (vector of 2 'unsigned int' values}}
   int array2[17];
   // FIXME: error message below needs type!
   (void)(array2[v2ua]); // expected-error{{array subscript is not an integer}}
 
   v2u *v2u_ptr = 0;
   v2s *v2s_ptr;
 }
+
+void test_int_vector_scalar(unsigned int ua, v2u v2ua) {
+  // Operations with one integer vector and one scalar. These splat the scalar.
+  (void)(v2ua + ua);
+  (void)(ua + v2ua);
+  (void)(v2ua - ua);
+  (void)(ua - v2ua);
+  (void)(v2ua * ua);
+  (void)(ua * v2ua);
+  (void)(v2ua / ua);
+  (void)(ua / v2ua);
+  (void)(v2ua % ua);
+  (void)(ua % v2ua);
+
+  (void)(v2ua == ua);
+  (void)(ua == v2ua);
+  (void)(v2ua != ua);
+  (void)(ua != v2ua);
+  (void)(v2ua <= ua);
+  (void)(ua <= v2ua);
+  (void)(v2ua >= ua);
+  (void)(ua >= v2ua);
+  (void)(v2ua < ua);
+  (void)(ua < v2ua);
+  (void)(v2ua > ua);
+  (void)(ua > v2ua);
+  (void)(v2ua && ua);
+  (void)(ua && v2ua);
+  (void)(v2ua || ua);
+  (void)(ua || v2ua);
+
+  (void)(v2ua & ua);
+  (void)(ua & v2ua);
+  (void)(v2ua | ua);
+  (void)(ua | v2ua);
+  (void)(v2ua ^ ua);
+  (void)(ua ^ v2ua);
+  (void)(v2ua << ua);
+  (void)(ua << v2ua);
+  (void)(v2ua >> ua);
+  (void)(ua >> v2ua);
+
+  v2ua += ua;
+  v2ua -= ua;
+  v2ua *= ua;
+  v2ua /= ua;
+  v2ua %= ua;
+  v2ua &= ua;
+  v2ua |= ua;
+  v2ua ^= ua;
+  v2ua >>= ua;
+  v2ua <<= ua;
+
+  ua += v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua -= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua *= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua /= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua %= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua &= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua |= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua ^= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua >>= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua <<= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+}
+
+void test_float_vector_scalar(float fa, unsigned int ua, v2f v2fa) {
+  // Operations with one float vector and one scalar. These splat the scalar.
+  (void)(v2fa + fa);
+  (void)(fa + v2fa);
+  (void)(v2fa - fa);
+  (void)(fa - v2fa);
+  (void)(v2fa * fa);
+  (void)(fa * v2fa);
+  (void)(v2fa / fa);
+  (void)(fa / v2fa);
+  (void)(v2fa % fa); // expected-error{{invalid operands to binary expression}}
+  (void)(fa % v2fa); // expected-error{{invalid operands to binary expression}}
+
+  (void)(v2fa == fa);
+  (void)(fa == v2fa);
+  (void)(v2fa != fa);
+  (void)(fa != v2fa);
+  (void)(v2fa <= fa);
+  (void)(fa <= v2fa);
+  (void)(v2fa >= fa);
+  (void)(fa >= v2fa);
+  (void)(v2fa < fa);
+  (void)(fa < v2fa);
+  (void)(v2fa > fa);
+  (void)(fa > v2fa);
+  (void)(v2fa && fa);
+  (void)(fa && v2fa);
+  (void)(v2fa || fa);
+  (void)(fa || v2fa);
+
+  (void)(v2fa & fa); // expected-error{{invalid operands to binary expression}}
+  (void)(fa & v2fa); // expected-error{{invalid operands to binary expression}}
+  (void)(v2fa | fa); // expected-error{{invalid operands to binary expression}}
+  (void)(fa | v2fa); // expected-error{{invalid operands to binary expression}}
+  (void)(v2fa ^ fa); // expected-error{{invalid operands to binary expression}}
+  (void)(fa ^ v2fa); // expected-error{{invalid operands to binary expression}}
+  (void)(v2fa << fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+  (void)(v2fa << ua); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+  (void)(fa << v2fa); // expected-error{{used type 'float' where integer is required}}
+  (void)(ua << v2fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+  (void)(v2fa >> fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+  (void)(v2fa >> ua); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+  (void)(fa >> v2fa); // expected-error{{used type 'float' where integer is required}}
+  (void)(ua >> v2fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+
+  v2fa += fa;
+  v2fa -= fa;
+  v2fa *= fa;
+  v2fa /= fa;
+  v2fa %= fa; // expected-error{{invalid operands to binary expression}}
+  v2fa &= fa; // expected-error{{invalid operands to binary expression}}
+  v2fa |= fa; // expected-error{{invalid operands to binary expression}}
+  v2fa ^= fa; // expected-error{{invalid operands to binary expression}}
+  v2fa >>= fa; // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+  v2fa <<= fa; // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+
+  fa += v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}}
+  fa -= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}}
+  fa *= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}}
+  fa /= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}}
+  fa %= v2fa; // expected-error{{invalid operands to binary expression}}
+  fa &= v2fa; // expected-error{{invalid operands to binary expression}}
+  fa |= v2fa; // expected-error{{invalid operands to binary expression}}
+  fa ^= v2fa; // expected-error{{invalid operands to binary expression}}
+  fa >>= v2fa; // expected-error{{used type 'float' where integer is required}}
+  fa <<= v2fa; // expected-error{{used type 'float' where integer is required}}
+}
+
+enum Enum { ENUM };
+
+void test_enum_vector_scalar(enum Enum ea, v2u v2ua) {
+  // Operations with one integer vector and one enum scalar.
+  // These splat the scalar and do implicit integral conversions.
+  (void)(v2ua + ea);
+  (void)(ea + v2ua);
+  (void)(v2ua - ea);
+  (void)(ea - v2ua);
+  (void)(v2ua * ea);
+  (void)(ea * v2ua);
+  (void)(v2ua / ea);
+  (void)(ea / v2ua);
+  (void)(v2ua % ea);
+  (void)(ea % v2ua);
+
+  (void)(v2ua == ea);
+  (void)(ea == v2ua);
+  (void)(v2ua != ea);
+  (void)(ea != v2ua);
+  (void)(v2ua <= ea);
+  (void)(ea <= v2ua);
+  (void)(v2ua >= ea);
+  (void)(ea >= v2ua);
+  (void)(v2ua < ea);
+  (void)(ea < v2ua);
+  (void)(v2ua > ea);
+  (void)(ea > v2ua);
+  (void)(v2ua && ea);
+  (void)(ea && v2ua);
+  (void)(v2ua || ea);
+  (void)(ea || v2ua);
+
+  (void)(v2ua & ea);
+  (void)(ea & v2ua);
+  (void)(v2ua | ea);
+  (void)(ea | v2ua);
+  (void)(v2ua ^ ea);
+  (void)(ea ^ v2ua);
+  (void)(v2ua << ea);
+  (void)(ea << v2ua);
+  (void)(v2ua >> ea);
+  (void)(ea >> v2ua);
+
+  v2ua += ea;
+  v2ua -= ea;
+  v2ua *= ea;
+  v2ua /= ea;
+  v2ua %= ea;
+  v2ua &= ea;
+  v2ua |= ea;
+  v2ua ^= ea;
+  v2ua >>= ea;
+  v2ua <<= ea;
+
+  ea += v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+  ea -= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+  ea *= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+  ea /= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+  ea %= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+  ea &= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+  ea |= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+  ea ^= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+  ea >>= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+  ea <<= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
+}
+
+
+// An incomplete enum type doesn't count as an integral type.
+enum Enum2;
+
+void test_incomplete_enum(enum Enum2 *ea, v2u v2ua) {
+  (void)(v2ua + *ea); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(*ea + v2ua); // expected-error{{cannot convert between vector and non-scalar values}}
+}

clang/test/Sema/vecshift.c

void foo(void) {
 
   vc8 = c << vc8;
   vuc8 = i << vuc8;
   vi8 = uc << vi8;
   vui8 = us << vui8;
   vs8 = ui << vs8;
   vus8 = 1 << vus8;
 
+  vc8 = vc8 << c;
+  vuc8 = vuc8 << uc;
+  vs8 = vs8 << s;
+  vus8 = vus8 << us;
+  vi8 = vi8 << i;
+  vui8 = vui8 << ui;
+
+  vc8 = vc8 << i;
+  vuc8 = vuc8 << i;
+  vs8 = vs8 << i;
+  vus8 = vus8 << i;
+  vi8 = vi8 << i;
+  vui8 = vui8 << i;
+
   vc8 = vc8 << vc8;
 #ifdef ERR
   vi8 = vi8 << vuc8; // expected-error {{vector operands do not have the same elements sizes}}
   vuc8 = vuc8 << vi8; // expected-error {{vector operands do not have the same elements sizes}}
   vus8 = vus8 << vui8; // expected-error {{vector operands do not have the same elements sizes}}
   vui8 = vui8 << vs8; // expected-error {{vector operands do not have the same elements sizes}}
 #else
   vi8 = vi8 << vuc8; // expected-warning {{vector operands do not have the same elements sizes}}