Page MenuHomePhabricator
Differential D11001 Diff 29337 test/Sema/zvector.c

Changeset View

Standalone View

View Options

test/Sema/zvector.c

// RUN: %clang_cc1 -triple s390x-linux-gnu -fzvector \
// RUN: -fno-lax-vector-conversions -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;
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 {{can't convert}}
sc = uc + sc2; // expected-error {{can't convert}}
sc = sc + bc2;
sc = bc + sc2;
uc = uc + uc2;
uc = sc + uc2; // expected-error {{can't convert}}
uc = uc + sc2; // expected-error {{can't 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; // expected-error {{can't convert}}
sc = sc + uc_scalar; // expected-error {{can't convert}}
sc = sc_scalar + sc; // expected-error {{can't convert}}
sc = uc_scalar + sc; // expected-error {{can't convert}}
uc = uc + sc_scalar; // expected-error {{can't convert}}
uc = uc + uc_scalar; // expected-error {{can't convert}}
uc = sc_scalar + uc; // expected-error {{can't convert}}
uc = uc_scalar + uc; // expected-error {{can't convert}}
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 {{can't convert}}
fd = sl + fd2; // expected-error {{can't convert}}
sc += sc2;
sc += uc2; // expected-error {{can't convert}}
sc += bc2;
uc += uc2;
uc += sc2; // expected-error {{can't convert}}
uc += bc2;
bc += bc2; // expected-error {{invalid operands}}
bc += sc2; // expected-error {{can't convert}}
bc += uc2; // expected-error {{can't convert}}
sc += ss2; // expected-error {{can't convert}}
sc += si2; // expected-error {{can't convert}}
sc += sl2; // expected-error {{can't convert}}
sc += fd2; // expected-error {{can't convert}}
sc += sc_scalar; // expected-error {{can't convert}}
sc += uc_scalar; // expected-error {{can't convert}}
uc += sc_scalar; // expected-error {{can't convert}}
uc += uc_scalar; // expected-error {{can't 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 binary - too.
// -------------------------------------------------------------------------
sc = sc - sc2;
uc = uc - uc2;
bc = bc - bc2; // expected-error {{invalid operands}}
sc = uc - sc2; // expected-error {{can't convert}}
sc = sc - bc2;
uc = bc - uc2;
sc -= sc2;
uc -= uc2;
bc -= bc2; // expected-error {{invalid operands}}
sc -= uc2; // expected-error {{can't convert}}
uc -= bc2;
bc -= sc2; // expected-error {{can't 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 {{can't convert}}
sc = sc * bc2; // expected-error {{can't convert}}
uc = bc * uc2; // expected-error {{can't convert}}
sc *= sc2;
uc *= uc2;
bc *= bc2; // expected-error {{invalid operands}}
sc *= uc2; // expected-error {{can't convert}}
uc *= bc2; // expected-error {{can't convert}}
bc *= sc2; // expected-error {{can't 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 {{can't convert}}
sc = sc / bc2; // expected-error {{can't convert}}
uc = bc / uc2; // expected-error {{can't convert}}
sc /= sc2;
uc /= uc2;
bc /= bc2; // expected-error {{invalid operands}}
sc /= uc2; // expected-error {{can't convert}}
uc /= bc2; // expected-error {{can't convert}}
bc /= sc2; // expected-error {{can't 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 {{can't convert}}
sc = sc % bc2; // expected-error {{can't convert}}
uc = bc % uc2; // expected-error {{can't convert}}
sc %= sc2;
uc %= uc2;
bc %= bc2; // expected-error {{invalid operands}}
sc %= uc2; // expected-error {{can't convert}}
uc %= bc2; // expected-error {{can't convert}}
bc %= sc2; // expected-error {{can't 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 {{can't convert}}
sc = uc & sc2; // expected-error {{can't convert}}
sc = sc & bc2;
sc = bc & sc2;
uc = uc & uc2;
uc = sc & uc2; // expected-error {{can't convert}}
uc = uc & sc2; // expected-error {{can't 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 {{can't convert}}
sc &= bc2;
uc &= uc2;
uc &= sc2; // expected-error {{can't convert}}
uc &= bc2;
bc &= bc2;
bc &= sc2; // expected-error {{can't convert}}
bc &= uc2; // expected-error {{can't convert}}
sc &= ss2; // expected-error {{can't convert}}
sc &= si2; // expected-error {{can't convert}}
sc &= sl2; // expected-error {{can't convert}}
sc &= fd2; // expected-error {{invalid operands}}
us &= bc2; // expected-error {{can't convert}}
ui &= bc2; // expected-error {{can't convert}}
ul &= bc2; // expected-error {{can't 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 {{can't convert}}
sc = sc | bc2;
uc = uc | uc2;
uc = sc | uc2; // expected-error {{can't 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 {{can't convert}}
sc = sc ^ bc2;
uc = uc ^ uc2;
uc = sc ^ uc2; // expected-error {{can't 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 {{can't convert}}
(void)(sc == bc);
(void)(uc == sc); // expected-error {{can't 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 {{can't convert}}
(void)(ul == fd); // expected-error {{can't convert}}
// -------------------------------------------------------------------------
// Test that == rules apply to != too.
// -------------------------------------------------------------------------
(void)(sc != sc2);
(void)(uc != uc2);
(void)(bc != bc2);
(void)(sc != uc); // expected-error {{can't 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 {{can't 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 {{can't 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 {{can't 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 {{can't 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);
}