Skip to content

Commit

Permalink
[test] Add more ext_vector_type tests for C
Browse files Browse the repository at this point in the history 
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
  • Loading branch information
@porglezomp
porglezomp committed May 22, 2023
1 parent 9efe158 commit b5b6896
Show file tree
Hide file tree
Showing 2 changed files with 222 additions and 0 deletions.
208 changes: 208 additions & 0 deletions clang/test/Sema/ext_vector_ops.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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}}
}
14 changes: 14 additions & 0 deletions clang/test/Sema/vecshift.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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}}
Expand Down

0 comments on commit b5b6896

Please sign in to comment.