llvm-for-llvmta/tools/clang/test/Sema/zvector.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);
}