Author: Cassie Jones Date: 2023-05-22T15:08:14-07:00 New Revision: b5b689679e1e435b5c82832f468ed939c7b72021
URL: https://github.com/llvm/llvm-project/commit/b5b689679e1e435b5c82832f468ed939c7b72021 DIFF: https://github.com/llvm/llvm-project/commit/b5b689679e1e435b5c82832f468ed939c7b72021.diff LOG: [test] Add more ext_vector_type tests for C Test that all builtin operators type check successfully with one vector operand and one scalar operand. Reviewed By: fhahn Differential Revision: https://reviews.llvm.org/D151061 Added: Modified: clang/test/Sema/ext_vector_ops.c clang/test/Sema/vecshift.c Removed: ################################################################################ diff --git a/clang/test/Sema/ext_vector_ops.c b/clang/test/Sema/ext_vector_ops.c index af4df07e14da9..5dc3047e145f1 100644 --- a/clang/test/Sema/ext_vector_ops.c +++ b/clang/test/Sema/ext_vector_ops.c @@ -25,3 +25,211 @@ void test1(v2u v2ua, v2s v2sa, v2f v2fa) { 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}} +} diff --git a/clang/test/Sema/vecshift.c b/clang/test/Sema/vecshift.c index bf16ebc24d032..429be9d4a4d59 100644 --- a/clang/test/Sema/vecshift.c +++ b/clang/test/Sema/vecshift.c @@ -65,6 +65,20 @@ void foo(void) { 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}} _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
