1053 lines
29 KiB
C
1053 lines
29 KiB
C
// RUN: %clang_cc1 -triple s390x-linux-gnu -fzvector \
|
|
// RUN: -flax-vector-conversions=none -W -Wall -Wconversion \
|
|
// RUN: -Werror -fsyntax-only -verify %s
|
|
|
|
vector signed char sc, sc2;
|
|
vector unsigned char uc, uc2;
|
|
vector bool char bc, bc2;
|
|
|
|
vector signed short ss, ss2;
|
|
vector unsigned short us, us2;
|
|
vector bool short bs, bs2;
|
|
|
|
vector signed int si, si2;
|
|
vector unsigned int ui, ui2;
|
|
vector bool int bi, bi2;
|
|
|
|
vector signed long long sl, sl2;
|
|
vector unsigned long long ul, ul2;
|
|
vector bool long long bl, bl2;
|
|
|
|
vector double fd, fd2;
|
|
|
|
vector long ll; // expected-error {{cannot use 'long' with '__vector'}}
|
|
vector float ff; // expected-error {{cannot use 'float' with '__vector'}}
|
|
|
|
signed char sc_scalar;
|
|
unsigned char uc_scalar;
|
|
|
|
signed short ss_scalar;
|
|
unsigned short us_scalar;
|
|
|
|
signed int si_scalar;
|
|
unsigned int ui_scalar;
|
|
|
|
signed long sl_scalar;
|
|
unsigned long ul_scalar;
|
|
|
|
double fd_scalar;
|
|
|
|
// Verify that __vector is also recognized
|
|
__vector signed char sc3;
|
|
__vector unsigned char uc3;
|
|
__vector bool char bc3;
|
|
__vector signed short ss3;
|
|
__vector unsigned short us3;
|
|
__vector bool short bs3;
|
|
__vector signed int si3;
|
|
__vector unsigned int ui3;
|
|
__vector bool int bi3;
|
|
__vector signed long long sl3;
|
|
__vector unsigned long long ul3;
|
|
__vector bool long long bl3;
|
|
__vector double fd3;
|
|
__vector long ll3; // expected-error {{cannot use 'long' with '__vector'}}
|
|
__vector float ff3; // expected-error {{cannot use 'float' with '__vector'}}
|
|
|
|
// Likewise for __bool
|
|
vector __bool char bc4;
|
|
vector __bool short bs4;
|
|
vector __bool int bi4;
|
|
vector __bool long long bl4;
|
|
__vector __bool char bc5;
|
|
__vector __bool short bs5;
|
|
__vector __bool int bi5;
|
|
__vector __bool long long bl5;
|
|
|
|
// Verify operation of vec_step
|
|
int res_sc[vec_step(sc) == 16 ? 1 : -1];
|
|
int res_uc[vec_step(uc) == 16 ? 1 : -1];
|
|
int res_bc[vec_step(bc) == 16 ? 1 : -1];
|
|
int res_ss[vec_step(ss) == 8 ? 1 : -1];
|
|
int res_us[vec_step(us) == 8 ? 1 : -1];
|
|
int res_bs[vec_step(bs) == 8 ? 1 : -1];
|
|
int res_si[vec_step(si) == 4 ? 1 : -1];
|
|
int res_ui[vec_step(ui) == 4 ? 1 : -1];
|
|
int res_bi[vec_step(bi) == 4 ? 1 : -1];
|
|
int res_sl[vec_step(sl) == 2 ? 1 : -1];
|
|
int res_ul[vec_step(ul) == 2 ? 1 : -1];
|
|
int res_bl[vec_step(bl) == 2 ? 1 : -1];
|
|
int res_fd[vec_step(fd) == 2 ? 1 : -1];
|
|
|
|
|
|
void foo(void)
|
|
{
|
|
// -------------------------------------------------------------------------
|
|
// Test assignment.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc2;
|
|
uc = uc2;
|
|
bc = bc2;
|
|
|
|
ss = ss2;
|
|
us = us2;
|
|
bs = bs2;
|
|
|
|
si = si2;
|
|
ui = ui2;
|
|
bi = bi2;
|
|
|
|
sl = sl2;
|
|
ul = ul2;
|
|
bl = bl2;
|
|
fd = fd2;
|
|
|
|
sc = uc2; // expected-error {{incompatible type}}
|
|
sc = bc2; // expected-error {{incompatible type}}
|
|
uc = sc2; // expected-error {{incompatible type}}
|
|
uc = bc2; // expected-error {{incompatible type}}
|
|
bc = sc2; // expected-error {{incompatible type}}
|
|
bc = uc2; // expected-error {{incompatible type}}
|
|
|
|
sc = sc_scalar; // expected-error {{incompatible type}}
|
|
sc = uc_scalar; // expected-error {{incompatible type}}
|
|
uc = sc_scalar; // expected-error {{incompatible type}}
|
|
uc = uc_scalar; // expected-error {{incompatible type}}
|
|
bc = sc_scalar; // expected-error {{incompatible type}}
|
|
bc = uc_scalar; // expected-error {{incompatible type}}
|
|
|
|
sc = ss2; // expected-error {{incompatible type}}
|
|
sc = si2; // expected-error {{incompatible type}}
|
|
sc = sl2; // expected-error {{incompatible type}}
|
|
sc = fd2; // expected-error {{incompatible type}}
|
|
|
|
ss = sc2; // expected-error {{incompatible type}}
|
|
si = sc2; // expected-error {{incompatible type}}
|
|
sl = sc2; // expected-error {{incompatible type}}
|
|
fd = sc2; // expected-error {{incompatible type}}
|
|
|
|
uc = us2; // expected-error {{incompatible type}}
|
|
uc = ui2; // expected-error {{incompatible type}}
|
|
uc = ul2; // expected-error {{incompatible type}}
|
|
uc = fd2; // expected-error {{incompatible type}}
|
|
|
|
us = uc2; // expected-error {{incompatible type}}
|
|
ui = uc2; // expected-error {{incompatible type}}
|
|
ul = uc2; // expected-error {{incompatible type}}
|
|
fd = uc2; // expected-error {{incompatible type}}
|
|
|
|
bc = us2; // expected-error {{incompatible type}}
|
|
bc = ui2; // expected-error {{incompatible type}}
|
|
bc = ul2; // expected-error {{incompatible type}}
|
|
bc = fd2; // expected-error {{incompatible type}}
|
|
|
|
bs = bc2; // expected-error {{incompatible type}}
|
|
bi = bc2; // expected-error {{incompatible type}}
|
|
bl = bc2; // expected-error {{incompatible type}}
|
|
fd = bc2; // expected-error {{incompatible type}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test casts to same element width.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = (vector signed char)bc2;
|
|
bc = (vector bool char)uc2;
|
|
uc = (vector unsigned char)sc2;
|
|
|
|
ss = (vector signed short)bs2;
|
|
bs = (vector bool short)us2;
|
|
us = (vector unsigned short)ss2;
|
|
|
|
si = (vector signed int)bi2;
|
|
bi = (vector bool int)ui2;
|
|
ui = (vector unsigned int)si2;
|
|
|
|
sl = (vector signed long long)bl2;
|
|
bl = (vector bool long long)ul2;
|
|
ul = (vector unsigned long long)fd2;
|
|
fd = (vector double)sl2;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test casts to different element width.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = (vector signed char)bs2;
|
|
bc = (vector bool char)us2;
|
|
uc = (vector unsigned char)fd2;
|
|
|
|
ss = (vector signed short)bi2;
|
|
bs = (vector bool short)ui2;
|
|
us = (vector unsigned short)fd2;
|
|
|
|
si = (vector signed int)bl2;
|
|
bi = (vector bool int)ul2;
|
|
ui = (vector unsigned int)fd2;
|
|
|
|
sl = (vector signed long long)bc2;
|
|
bl = (vector bool long long)uc2;
|
|
ul = (vector unsigned long long)sc2;
|
|
fd = (vector double)sc2;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test ++.
|
|
// -------------------------------------------------------------------------
|
|
|
|
++sc2;
|
|
++uc2;
|
|
++bc2; // expected-error {{cannot increment}}
|
|
|
|
++ss2;
|
|
++us2;
|
|
++bs2; // expected-error {{cannot increment}}
|
|
|
|
++si2;
|
|
++ui2;
|
|
++bi2; // expected-error {{cannot increment}}
|
|
|
|
++sl2;
|
|
++ul2;
|
|
++bl2; // expected-error {{cannot increment}}
|
|
|
|
++fd2;
|
|
|
|
sc++;
|
|
uc++;
|
|
bc++; // expected-error {{cannot increment}}
|
|
|
|
ss++;
|
|
us++;
|
|
bs++; // expected-error {{cannot increment}}
|
|
|
|
si++;
|
|
ui++;
|
|
bi++; // expected-error {{cannot increment}}
|
|
|
|
sl++;
|
|
ul++;
|
|
bl++; // expected-error {{cannot increment}}
|
|
|
|
fd++;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test --.
|
|
// -------------------------------------------------------------------------
|
|
|
|
--sc2;
|
|
--uc2;
|
|
--bc2; // expected-error {{cannot decrement}}
|
|
|
|
--ss2;
|
|
--us2;
|
|
--bs2; // expected-error {{cannot decrement}}
|
|
|
|
--si2;
|
|
--ui2;
|
|
--bi2; // expected-error {{cannot decrement}}
|
|
|
|
--sl2;
|
|
--ul2;
|
|
--bl2; // expected-error {{cannot decrement}}
|
|
|
|
--fd2;
|
|
|
|
sc--;
|
|
uc--;
|
|
bc--; // expected-error {{cannot decrement}}
|
|
|
|
ss--;
|
|
us--;
|
|
bs--; // expected-error {{cannot decrement}}
|
|
|
|
si--;
|
|
ui--;
|
|
bi--; // expected-error {{cannot decrement}}
|
|
|
|
sl--;
|
|
ul--;
|
|
bl--; // expected-error {{cannot decrement}}
|
|
|
|
fd--;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test unary +.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = +sc2;
|
|
uc = +uc2;
|
|
bc = +bc2; // expected-error {{invalid argument type}}
|
|
|
|
ss = +ss2;
|
|
us = +us2;
|
|
bs = +bs2; // expected-error {{invalid argument type}}
|
|
|
|
si = +si2;
|
|
ui = +ui2;
|
|
bi = +bi2; // expected-error {{invalid argument type}}
|
|
|
|
sl = +sl2;
|
|
ul = +ul2;
|
|
bl = +bl2; // expected-error {{invalid argument type}}
|
|
|
|
fd = +fd2;
|
|
|
|
sc = +si2; // expected-error {{assigning to}}
|
|
ui = +si2; // expected-error {{assigning to}}
|
|
ui = +bi2; // expected-error {{invalid argument type}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test unary -.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = -sc2;
|
|
uc = -uc2;
|
|
bc = -bc2; // expected-error {{invalid argument type}}
|
|
|
|
ss = -ss2;
|
|
us = -us2;
|
|
bs = -bs2; // expected-error {{invalid argument type}}
|
|
|
|
si = -si2;
|
|
ui = -ui2;
|
|
bi = -bi2; // expected-error {{invalid argument type}}
|
|
|
|
sl = -sl2;
|
|
ul = -ul2;
|
|
bl = -bl2; // expected-error {{invalid argument type}}
|
|
|
|
fd = -fd2;
|
|
|
|
sc = -si2; // expected-error {{assigning to}}
|
|
ui = -si2; // expected-error {{assigning to}}
|
|
ui = -bi2; // expected-error {{invalid argument type}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test ~.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = ~sc2;
|
|
uc = ~uc2;
|
|
bc = ~bc2;
|
|
|
|
ss = ~ss2;
|
|
us = ~us2;
|
|
bs = ~bs2;
|
|
|
|
si = ~si2;
|
|
ui = ~ui2;
|
|
bi = ~bi2;
|
|
|
|
sl = ~sl2;
|
|
ul = ~ul2;
|
|
bl = ~bl2;
|
|
|
|
fd = ~fd2; // expected-error {{invalid argument}}
|
|
|
|
sc = ~si2; // expected-error {{assigning to}}
|
|
ui = ~si2; // expected-error {{assigning to}}
|
|
ui = ~bi2; // expected-error {{assigning to}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test binary +.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc + sc2;
|
|
sc = sc + uc2; // expected-error {{cannot convert}}
|
|
sc = uc + sc2; // expected-error {{cannot convert}}
|
|
sc = sc + bc2;
|
|
sc = bc + sc2;
|
|
|
|
uc = uc + uc2;
|
|
uc = sc + uc2; // expected-error {{cannot convert}}
|
|
uc = uc + sc2; // expected-error {{cannot convert}}
|
|
uc = bc + uc2;
|
|
uc = uc + bc2;
|
|
|
|
bc = bc + bc2; // expected-error {{invalid operands}}
|
|
bc = bc + uc2; // expected-error {{incompatible type}}
|
|
bc = uc + bc2; // expected-error {{incompatible type}}
|
|
bc = bc + sc2; // expected-error {{incompatible type}}
|
|
bc = sc + bc2; // expected-error {{incompatible type}}
|
|
|
|
sc = sc + sc_scalar;
|
|
sc = sc + uc_scalar; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation}}
|
|
sc = sc_scalar + sc;
|
|
sc = uc_scalar + sc; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation}}
|
|
uc = uc + sc_scalar; // expected-error {{implicit conversion changes signedness: 'signed char' to '__vector unsigned char' (vector of 16 'unsigned char' values)}}
|
|
uc = uc + uc_scalar;
|
|
uc = sc_scalar + uc; // expected-error {{implicit conversion changes signedness: 'signed char' to '__vector unsigned char' (vector of 16 'unsigned char' values)}}
|
|
uc = uc_scalar + uc;
|
|
|
|
ss = ss + ss2;
|
|
us = us + us2;
|
|
bs = bs + bs2; // expected-error {{invalid operands}}
|
|
|
|
si = si + si2;
|
|
ui = ui + ui2;
|
|
bi = bi + bi2; // expected-error {{invalid operands}}
|
|
|
|
sl = sl + sl2;
|
|
ul = ul + ul2;
|
|
bl = bl + bl2; // expected-error {{invalid operands}}
|
|
|
|
fd = fd + fd2;
|
|
fd = fd + ul2; // expected-error {{cannot convert}}
|
|
fd = sl + fd2; // expected-error {{cannot convert}}
|
|
|
|
sc += sc2;
|
|
sc += uc2; // expected-error {{cannot convert}}
|
|
sc += bc2;
|
|
|
|
uc += uc2;
|
|
uc += sc2; // expected-error {{cannot convert}}
|
|
uc += bc2;
|
|
|
|
bc += bc2; // expected-error {{invalid operands}}
|
|
bc += sc2; // expected-error {{cannot convert}}
|
|
bc += uc2; // expected-error {{cannot convert}}
|
|
|
|
sc += ss2; // expected-error {{cannot convert}}
|
|
sc += si2; // expected-error {{cannot convert}}
|
|
sc += sl2; // expected-error {{cannot convert}}
|
|
sc += fd2; // expected-error {{cannot convert}}
|
|
|
|
sc += sc_scalar;
|
|
sc += uc_scalar; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation}}
|
|
uc += sc_scalar; // expected-error {{implicit conversion changes signedness: 'signed char' to '__vector unsigned char' (vector of 16 'unsigned char' values)}}
|
|
uc += uc_scalar;
|
|
|
|
ss += ss2;
|
|
us += us2;
|
|
bs += bs2; // expected-error {{invalid operands}}
|
|
|
|
si += si2;
|
|
ui += ui2;
|
|
bi += bi2; // expected-error {{invalid operands}}
|
|
|
|
sl += sl2;
|
|
ul += ul2;
|
|
bl += bl2; // expected-error {{invalid operands}}
|
|
|
|
fd += fd2;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that binary + rules apply to binary - too.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc - sc2;
|
|
uc = uc - uc2;
|
|
bc = bc - bc2; // expected-error {{invalid operands}}
|
|
|
|
sc = uc - sc2; // expected-error {{cannot convert}}
|
|
sc = sc - bc2;
|
|
uc = bc - uc2;
|
|
|
|
sc -= sc2;
|
|
uc -= uc2;
|
|
bc -= bc2; // expected-error {{invalid operands}}
|
|
|
|
sc -= uc2; // expected-error {{cannot convert}}
|
|
uc -= bc2;
|
|
bc -= sc2; // expected-error {{cannot convert}}
|
|
|
|
ss -= ss2;
|
|
us -= us2;
|
|
bs -= bs2; // expected-error {{invalid operands}}
|
|
|
|
si -= si2;
|
|
ui -= ui2;
|
|
bi -= bi2; // expected-error {{invalid operands}}
|
|
|
|
sl -= sl2;
|
|
ul -= ul2;
|
|
bl -= bl2; // expected-error {{invalid operands}}
|
|
|
|
fd -= fd2;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that binary + rules apply to * too. 64-bit integer multiplication
|
|
// is not required by the spec and so isn't tested here.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc * sc2;
|
|
uc = uc * uc2;
|
|
bc = bc * bc2; // expected-error {{invalid operands}}
|
|
|
|
sc = uc * sc2; // expected-error {{cannot convert}}
|
|
sc = sc * bc2; // expected-error {{cannot convert}}
|
|
uc = bc * uc2; // expected-error {{cannot convert}}
|
|
|
|
sc *= sc2;
|
|
uc *= uc2;
|
|
bc *= bc2; // expected-error {{invalid operands}}
|
|
|
|
sc *= uc2; // expected-error {{cannot convert}}
|
|
uc *= bc2; // expected-error {{cannot convert}}
|
|
bc *= sc2; // expected-error {{cannot convert}}
|
|
|
|
ss *= ss2;
|
|
us *= us2;
|
|
bs *= bs2; // expected-error {{invalid operands}}
|
|
|
|
si *= si2;
|
|
ui *= ui2;
|
|
bi *= bi2; // expected-error {{invalid operands}}
|
|
|
|
sl *= sl2;
|
|
ul *= ul2;
|
|
bl *= bl2; // expected-error {{invalid operands}}
|
|
|
|
fd *= fd2;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that * rules apply to / too.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc / sc2;
|
|
uc = uc / uc2;
|
|
bc = bc / bc2; // expected-error {{invalid operands}}
|
|
|
|
sc = uc / sc2; // expected-error {{cannot convert}}
|
|
sc = sc / bc2; // expected-error {{cannot convert}}
|
|
uc = bc / uc2; // expected-error {{cannot convert}}
|
|
|
|
sc /= sc2;
|
|
uc /= uc2;
|
|
bc /= bc2; // expected-error {{invalid operands}}
|
|
|
|
sc /= uc2; // expected-error {{cannot convert}}
|
|
uc /= bc2; // expected-error {{cannot convert}}
|
|
bc /= sc2; // expected-error {{cannot convert}}
|
|
|
|
ss /= ss2;
|
|
us /= us2;
|
|
bs /= bs2; // expected-error {{invalid operands}}
|
|
|
|
si /= si2;
|
|
ui /= ui2;
|
|
bi /= bi2; // expected-error {{invalid operands}}
|
|
|
|
sl /= sl2;
|
|
ul /= ul2;
|
|
bl /= bl2; // expected-error {{invalid operands}}
|
|
|
|
fd /= fd2;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that / rules apply to % too, except that doubles are not allowed.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc % sc2;
|
|
uc = uc % uc2;
|
|
bc = bc % bc2; // expected-error {{invalid operands}}
|
|
|
|
sc = uc % sc2; // expected-error {{cannot convert}}
|
|
sc = sc % bc2; // expected-error {{cannot convert}}
|
|
uc = bc % uc2; // expected-error {{cannot convert}}
|
|
|
|
sc %= sc2;
|
|
uc %= uc2;
|
|
bc %= bc2; // expected-error {{invalid operands}}
|
|
|
|
sc %= uc2; // expected-error {{cannot convert}}
|
|
uc %= bc2; // expected-error {{cannot convert}}
|
|
bc %= sc2; // expected-error {{cannot convert}}
|
|
|
|
ss %= ss2;
|
|
us %= us2;
|
|
bs %= bs2; // expected-error {{invalid operands}}
|
|
|
|
si %= si2;
|
|
ui %= ui2;
|
|
bi %= bi2; // expected-error {{invalid operands}}
|
|
|
|
sl %= sl2;
|
|
ul %= ul2;
|
|
bl %= bl2; // expected-error {{invalid operands}}
|
|
|
|
fd %= fd2; // expected-error {{invalid operands}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test &.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc & sc2;
|
|
sc = sc & uc2; // expected-error {{cannot convert}}
|
|
sc = uc & sc2; // expected-error {{cannot convert}}
|
|
sc = sc & bc2;
|
|
sc = bc & sc2;
|
|
|
|
uc = uc & uc2;
|
|
uc = sc & uc2; // expected-error {{cannot convert}}
|
|
uc = uc & sc2; // expected-error {{cannot convert}}
|
|
uc = bc & uc2;
|
|
uc = uc & bc2;
|
|
|
|
bc = bc & bc2;
|
|
bc = bc & uc2; // expected-error {{incompatible type}}
|
|
bc = uc & bc2; // expected-error {{incompatible type}}
|
|
bc = bc & sc2; // expected-error {{incompatible type}}
|
|
bc = sc & bc2; // expected-error {{incompatible type}}
|
|
|
|
fd = fd & fd2; // expected-error {{invalid operands}}
|
|
fd = bl & fd2; // expected-error {{invalid operands}}
|
|
fd = fd & bl2; // expected-error {{invalid operands}}
|
|
fd = fd & sl2; // expected-error {{invalid operands}}
|
|
fd = fd & ul2; // expected-error {{invalid operands}}
|
|
|
|
sc &= sc2;
|
|
sc &= uc2; // expected-error {{cannot convert}}
|
|
sc &= bc2;
|
|
|
|
uc &= uc2;
|
|
uc &= sc2; // expected-error {{cannot convert}}
|
|
uc &= bc2;
|
|
|
|
bc &= bc2;
|
|
bc &= sc2; // expected-error {{cannot convert}}
|
|
bc &= uc2; // expected-error {{cannot convert}}
|
|
|
|
sc &= ss2; // expected-error {{cannot convert}}
|
|
sc &= si2; // expected-error {{cannot convert}}
|
|
sc &= sl2; // expected-error {{cannot convert}}
|
|
sc &= fd2; // expected-error {{invalid operands}}
|
|
|
|
us &= bc2; // expected-error {{cannot convert}}
|
|
ui &= bc2; // expected-error {{cannot convert}}
|
|
ul &= bc2; // expected-error {{cannot convert}}
|
|
fd &= bc2; // expected-error {{invalid operands}}
|
|
|
|
ss &= ss2;
|
|
us &= us2;
|
|
bs &= bs2;
|
|
|
|
si &= si2;
|
|
ui &= ui2;
|
|
bi &= bi2;
|
|
|
|
sl &= sl2;
|
|
ul &= ul2;
|
|
bl &= bl2;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that & rules apply to | too.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc | sc2;
|
|
sc = sc | uc2; // expected-error {{cannot convert}}
|
|
sc = sc | bc2;
|
|
|
|
uc = uc | uc2;
|
|
uc = sc | uc2; // expected-error {{cannot convert}}
|
|
uc = bc | uc2;
|
|
|
|
bc = bc | bc2;
|
|
bc = uc | bc2; // expected-error {{incompatible type}}
|
|
bc = bc | sc2; // expected-error {{incompatible type}}
|
|
|
|
fd = fd | fd2; // expected-error {{invalid operands}}
|
|
fd = bl | fd2; // expected-error {{invalid operands}}
|
|
|
|
ss |= ss2;
|
|
us |= us2;
|
|
bs |= bs2;
|
|
|
|
si |= si2;
|
|
ui |= ui2;
|
|
bi |= bi2;
|
|
|
|
sl |= sl2;
|
|
ul |= ul2;
|
|
bl |= bl2;
|
|
|
|
fd |= bl2; // expected-error {{invalid operands}}
|
|
fd |= fd2; // expected-error {{invalid operands}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that & rules apply to ^ too.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc ^ sc2;
|
|
sc = sc ^ uc2; // expected-error {{cannot convert}}
|
|
sc = sc ^ bc2;
|
|
|
|
uc = uc ^ uc2;
|
|
uc = sc ^ uc2; // expected-error {{cannot convert}}
|
|
uc = bc ^ uc2;
|
|
|
|
bc = bc ^ bc2;
|
|
bc = uc ^ bc2; // expected-error {{incompatible type}}
|
|
bc = bc ^ sc2; // expected-error {{incompatible type}}
|
|
|
|
fd = fd ^ fd2; // expected-error {{invalid operands}}
|
|
fd = bl ^ fd2; // expected-error {{invalid operands}}
|
|
|
|
ss ^= ss2;
|
|
us ^= us2;
|
|
bs ^= bs2;
|
|
|
|
si ^= si2;
|
|
ui ^= ui2;
|
|
bi ^= bi2;
|
|
|
|
sl ^= sl2;
|
|
ul ^= ul2;
|
|
bl ^= bl2;
|
|
|
|
fd ^= bl2; // expected-error {{invalid operands}}
|
|
fd ^= fd2; // expected-error {{invalid operands}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test <<.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc << sc2;
|
|
sc = sc << uc2;
|
|
sc = uc << sc2; // expected-error {{incompatible type}}
|
|
sc = sc << bc2; // expected-error {{invalid operands}}
|
|
sc = bc << sc2; // expected-error {{invalid operands}}
|
|
|
|
uc = uc << uc2;
|
|
uc = sc << uc2; // expected-error {{assigning to}}
|
|
uc = uc << sc2;
|
|
uc = bc << uc2; // expected-error {{invalid operands}}
|
|
uc = uc << bc2; // expected-error {{invalid operands}}
|
|
|
|
bc = bc << bc2; // expected-error {{invalid operands}}
|
|
bc = bc << uc2; // expected-error {{invalid operands}}
|
|
bc = uc << bc2; // expected-error {{invalid operands}}
|
|
bc = bc << sc2; // expected-error {{invalid operands}}
|
|
bc = sc << bc2; // expected-error {{invalid operands}}
|
|
|
|
sc = sc << 1;
|
|
sc = sc << 1.0f; // expected-error {{integer is required}}
|
|
sc = sc << sc_scalar;
|
|
sc = sc << uc_scalar;
|
|
sc = sc << ss_scalar;
|
|
sc = sc << us_scalar;
|
|
sc = sc << si_scalar;
|
|
sc = sc << ui_scalar;
|
|
sc = sc << sl_scalar;
|
|
sc = sc << ul_scalar;
|
|
sc = sc_scalar << sc; // expected-error {{first operand is not a vector}}
|
|
sc = uc_scalar << sc; // expected-error {{first operand is not a vector}}
|
|
uc = uc << sc_scalar;
|
|
uc = uc << uc_scalar;
|
|
uc = sc_scalar << uc; // expected-error {{first operand is not a vector}}
|
|
uc = uc_scalar << uc; // expected-error {{first operand is not a vector}}
|
|
|
|
ss = ss << ss2;
|
|
ss = ss << ss_scalar;
|
|
us = us << us2;
|
|
us = us << us_scalar;
|
|
bs = bs << bs2; // expected-error {{invalid operands}}
|
|
|
|
si = si << si2;
|
|
si = si << si_scalar;
|
|
ui = ui << ui2;
|
|
ui = ui << ui_scalar;
|
|
bi = bi << bi2; // expected-error {{invalid operands}}
|
|
|
|
sl = sl << sl2;
|
|
sl = sl << sl_scalar;
|
|
ul = ul << ul2;
|
|
ul = ul << ul_scalar;
|
|
bl = bl << bl2; // expected-error {{invalid operands}}
|
|
|
|
fd = fd << fd2; // expected-error {{integer is required}}
|
|
fd = fd << ul2; // expected-error {{integer is required}}
|
|
fd = sl << fd2; // expected-error {{integer is required}}
|
|
|
|
sc <<= sc2;
|
|
sc <<= uc2;
|
|
sc <<= bc2; // expected-error {{invalid operands}}
|
|
sc <<= sc_scalar;
|
|
|
|
uc <<= uc2;
|
|
uc <<= sc2;
|
|
uc <<= bc2; // expected-error {{invalid operands}}
|
|
uc <<= uc_scalar;
|
|
|
|
bc <<= bc2; // expected-error {{invalid operands}}
|
|
bc <<= sc2; // expected-error {{invalid operands}}
|
|
bc <<= uc2; // expected-error {{invalid operands}}
|
|
|
|
sc <<= ss2; // expected-error {{vector operands do not have the same number of elements}}
|
|
sc <<= si2; // expected-error {{vector operands do not have the same number of elements}}
|
|
sc <<= sl2; // expected-error {{vector operands do not have the same number of elements}}
|
|
sc <<= fd2; // expected-error {{integer is required}}
|
|
|
|
ss <<= ss2;
|
|
ss <<= ss_scalar;
|
|
us <<= us2;
|
|
us <<= us_scalar;
|
|
bs <<= bs2; // expected-error {{invalid operands}}
|
|
|
|
si <<= si2;
|
|
si <<= si_scalar;
|
|
ui <<= ui2;
|
|
ui <<= ui_scalar;
|
|
bi <<= bi2; // expected-error {{invalid operands}}
|
|
|
|
sl <<= sl2;
|
|
sl <<= sl_scalar;
|
|
ul <<= ul2;
|
|
ul <<= ul_scalar;
|
|
bl <<= bl2; // expected-error {{invalid operands}}
|
|
|
|
fd <<= fd2; // expected-error {{integer is required}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test >>.
|
|
// -------------------------------------------------------------------------
|
|
|
|
sc = sc >> sc2;
|
|
sc = sc >> uc2;
|
|
sc = uc >> sc2; // expected-error {{incompatible type}}
|
|
sc = sc >> bc2; // expected-error {{invalid operands}}
|
|
sc = bc >> sc2; // expected-error {{invalid operands}}
|
|
|
|
uc = uc >> uc2;
|
|
uc = sc >> uc2; // expected-error {{assigning to}}
|
|
uc = uc >> sc2;
|
|
uc = bc >> uc2; // expected-error {{invalid operands}}
|
|
uc = uc >> bc2; // expected-error {{invalid operands}}
|
|
|
|
bc = bc >> bc2; // expected-error {{invalid operands}}
|
|
bc = bc >> uc2; // expected-error {{invalid operands}}
|
|
bc = uc >> bc2; // expected-error {{invalid operands}}
|
|
bc = bc >> sc2; // expected-error {{invalid operands}}
|
|
bc = sc >> bc2; // expected-error {{invalid operands}}
|
|
|
|
sc = sc >> 1;
|
|
sc = sc >> 1.0f; // expected-error {{integer is required}}
|
|
sc = sc >> sc_scalar;
|
|
sc = sc >> uc_scalar;
|
|
sc = sc >> ss_scalar;
|
|
sc = sc >> us_scalar;
|
|
sc = sc >> si_scalar;
|
|
sc = sc >> ui_scalar;
|
|
sc = sc >> sl_scalar;
|
|
sc = sc >> ul_scalar;
|
|
sc = sc_scalar >> sc; // expected-error {{first operand is not a vector}}
|
|
sc = uc_scalar >> sc; // expected-error {{first operand is not a vector}}
|
|
uc = uc >> sc_scalar;
|
|
uc = uc >> uc_scalar;
|
|
uc = sc_scalar >> uc; // expected-error {{first operand is not a vector}}
|
|
uc = uc_scalar >> uc; // expected-error {{first operand is not a vector}}
|
|
|
|
ss = ss >> ss2;
|
|
ss = ss >> ss_scalar;
|
|
us = us >> us2;
|
|
us = us >> us_scalar;
|
|
bs = bs >> bs2; // expected-error {{invalid operands}}
|
|
|
|
si = si >> si2;
|
|
si = si >> si_scalar;
|
|
ui = ui >> ui2;
|
|
ui = ui >> ui_scalar;
|
|
bi = bi >> bi2; // expected-error {{invalid operands}}
|
|
|
|
sl = sl >> sl2;
|
|
sl = sl >> sl_scalar;
|
|
ul = ul >> ul2;
|
|
ul = ul >> ul_scalar;
|
|
bl = bl >> bl2; // expected-error {{invalid operands}}
|
|
|
|
fd = fd >> fd2; // expected-error {{integer is required}}
|
|
fd = fd >> ul2; // expected-error {{integer is required}}
|
|
fd = sl >> fd2; // expected-error {{integer is required}}
|
|
|
|
sc >>= sc2;
|
|
sc >>= uc2;
|
|
sc >>= bc2; // expected-error {{invalid operands}}
|
|
sc >>= sc_scalar;
|
|
|
|
uc >>= uc2;
|
|
uc >>= sc2;
|
|
uc >>= bc2; // expected-error {{invalid operands}}
|
|
uc >>= uc_scalar;
|
|
|
|
bc >>= bc2; // expected-error {{invalid operands}}
|
|
bc >>= sc2; // expected-error {{invalid operands}}
|
|
bc >>= uc2; // expected-error {{invalid operands}}
|
|
|
|
sc >>= ss2; // expected-error {{vector operands do not have the same number of elements}}
|
|
sc >>= si2; // expected-error {{vector operands do not have the same number of elements}}
|
|
sc >>= sl2; // expected-error {{vector operands do not have the same number of elements}}
|
|
sc >>= fd2; // expected-error {{integer is required}}
|
|
|
|
ss >>= ss2;
|
|
ss >>= ss_scalar;
|
|
us >>= us2;
|
|
us >>= us_scalar;
|
|
bs >>= bs2; // expected-error {{invalid operands}}
|
|
|
|
si >>= si2;
|
|
si >>= si_scalar;
|
|
ui >>= ui2;
|
|
ui >>= ui_scalar;
|
|
bi >>= bi2; // expected-error {{invalid operands}}
|
|
|
|
sl >>= sl2;
|
|
sl >>= sl_scalar;
|
|
ul >>= ul2;
|
|
ul >>= ul_scalar;
|
|
bl >>= bl2; // expected-error {{invalid operands}}
|
|
|
|
fd >>= fd2; // expected-error {{integer is required}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test ==.
|
|
// -------------------------------------------------------------------------
|
|
|
|
(void)(sc == sc2);
|
|
(void)(uc == uc2);
|
|
(void)(bc == bc2);
|
|
|
|
(void)(sc == uc); // expected-error {{cannot convert}}
|
|
(void)(sc == bc);
|
|
|
|
(void)(uc == sc); // expected-error {{cannot convert}}
|
|
(void)(uc == bc);
|
|
|
|
(void)(bc == sc);
|
|
(void)(bc == uc);
|
|
|
|
(void)(ss == ss2);
|
|
(void)(us == us2);
|
|
(void)(bs == bs2);
|
|
|
|
(void)(si == si2);
|
|
(void)(ui == ui2);
|
|
(void)(bi == bi2);
|
|
|
|
(void)(sl == sl2);
|
|
(void)(ul == ul2);
|
|
(void)(bl == bl2);
|
|
(void)(fd == fd2);
|
|
|
|
(void)(fd == ul); // expected-error {{cannot convert}}
|
|
(void)(ul == fd); // expected-error {{cannot convert}}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that == rules apply to != too.
|
|
// -------------------------------------------------------------------------
|
|
|
|
(void)(sc != sc2);
|
|
(void)(uc != uc2);
|
|
(void)(bc != bc2);
|
|
|
|
(void)(sc != uc); // expected-error {{cannot convert}}
|
|
(void)(sc != bc);
|
|
|
|
(void)(ss != ss2);
|
|
(void)(us != us2);
|
|
(void)(bs != bs2);
|
|
|
|
(void)(si != si2);
|
|
(void)(ui != ui2);
|
|
(void)(bi != bi2);
|
|
|
|
(void)(sl != sl2);
|
|
(void)(ul != ul2);
|
|
(void)(bl != bl2);
|
|
(void)(fd != fd2);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that == rules apply to <= too.
|
|
// -------------------------------------------------------------------------
|
|
|
|
(void)(sc <= sc2);
|
|
(void)(uc <= uc2);
|
|
(void)(bc <= bc2);
|
|
|
|
(void)(sc <= uc); // expected-error {{cannot convert}}
|
|
(void)(sc <= bc);
|
|
|
|
(void)(ss <= ss2);
|
|
(void)(us <= us2);
|
|
(void)(bs <= bs2);
|
|
|
|
(void)(si <= si2);
|
|
(void)(ui <= ui2);
|
|
(void)(bi <= bi2);
|
|
|
|
(void)(sl <= sl2);
|
|
(void)(ul <= ul2);
|
|
(void)(bl <= bl2);
|
|
(void)(fd <= fd2);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that == rules apply to >= too.
|
|
// -------------------------------------------------------------------------
|
|
|
|
(void)(sc >= sc2);
|
|
(void)(uc >= uc2);
|
|
(void)(bc >= bc2);
|
|
|
|
(void)(sc >= uc); // expected-error {{cannot convert}}
|
|
(void)(sc >= bc);
|
|
|
|
(void)(ss >= ss2);
|
|
(void)(us >= us2);
|
|
(void)(bs >= bs2);
|
|
|
|
(void)(si >= si2);
|
|
(void)(ui >= ui2);
|
|
(void)(bi >= bi2);
|
|
|
|
(void)(sl >= sl2);
|
|
(void)(ul >= ul2);
|
|
(void)(bl >= bl2);
|
|
(void)(fd >= fd2);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that == rules apply to < too.
|
|
// -------------------------------------------------------------------------
|
|
|
|
(void)(sc < sc2);
|
|
(void)(uc < uc2);
|
|
(void)(bc < bc2);
|
|
|
|
(void)(sc < uc); // expected-error {{cannot convert}}
|
|
(void)(sc < bc);
|
|
|
|
(void)(ss < ss2);
|
|
(void)(us < us2);
|
|
(void)(bs < bs2);
|
|
|
|
(void)(si < si2);
|
|
(void)(ui < ui2);
|
|
(void)(bi < bi2);
|
|
|
|
(void)(sl < sl2);
|
|
(void)(ul < ul2);
|
|
(void)(bl < bl2);
|
|
(void)(fd < fd2);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Test that == rules apply to > too.
|
|
// -------------------------------------------------------------------------
|
|
|
|
(void)(sc > sc2);
|
|
(void)(uc > uc2);
|
|
(void)(bc > bc2);
|
|
|
|
(void)(sc > uc); // expected-error {{cannot convert}}
|
|
(void)(sc > bc);
|
|
|
|
(void)(ss > ss2);
|
|
(void)(us > us2);
|
|
(void)(bs > bs2);
|
|
|
|
(void)(si > si2);
|
|
(void)(ui > ui2);
|
|
(void)(bi > bi2);
|
|
|
|
(void)(sl > sl2);
|
|
(void)(ul > ul2);
|
|
(void)(bl > bl2);
|
|
(void)(fd > fd2);
|
|
}
|