porglezomp created this revision.
porglezomp added reviewers: aaron.ballman, fhahn.
Herald added a subscriber: StephenFan.
Herald added a project: All.
porglezomp requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
Test that all vector-vs-scalar builtin operators type check
successfully.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D151061
Files:
clang/test/Sema/ext_vector_ops.c
clang/test/Sema/vecshift.c
Index: clang/test/Sema/vecshift.c
===================================================================
--- clang/test/Sema/vecshift.c
+++ clang/test/Sema/vecshift.c
@@ -65,6 +65,20 @@
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}}
Index: clang/test/Sema/ext_vector_ops.c
===================================================================
--- clang/test/Sema/ext_vector_ops.c
+++ clang/test/Sema/ext_vector_ops.c
@@ -25,3 +25,210 @@
v2u *v2u_ptr = 0;
v2s *v2s_ptr;
}
+
+void test_int_vector_scalar(unsigned int ua, v2u v2ua) {
+ // Integer vector vs integer operators. These will splat
+ (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) {
+ // Float vector vs float operators. These will splat
+ (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) {
+ // Integer vector vs enum operators, testing scalar promotion. These will splat
+ (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}}
+}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
