Home | History | Annotate | Download | only in CodeGen
      1 // REQUIRES: systemz-registered-target
      2 // RUN: %clang_cc1 -target-cpu z13 -triple s390x-linux-gnu \
      3 // RUN: -fzvector -fno-lax-vector-conversions \
      4 // RUN: -Wall -Wno-unused -Werror -fsyntax-only -verify %s
      5 
      6 #include <vecintrin.h>
      7 
      8 volatile vector signed char vsc;
      9 volatile vector signed short vss;
     10 volatile vector signed int vsi;
     11 volatile vector signed long long vsl;
     12 volatile vector unsigned char vuc;
     13 volatile vector unsigned short vus;
     14 volatile vector unsigned int vui;
     15 volatile vector unsigned long long vul;
     16 volatile vector bool char vbc;
     17 volatile vector bool short vbs;
     18 volatile vector bool int vbi;
     19 volatile vector bool long long vbl;
     20 volatile vector double vd;
     21 
     22 volatile signed char sc;
     23 volatile signed short ss;
     24 volatile signed int si;
     25 volatile signed long long sl;
     26 volatile unsigned char uc;
     27 volatile unsigned short us;
     28 volatile unsigned int ui;
     29 volatile unsigned long long ul;
     30 volatile double d;
     31 
     32 const void * volatile cptr;
     33 const signed char * volatile cptrsc;
     34 const signed short * volatile cptrss;
     35 const signed int * volatile cptrsi;
     36 const signed long long * volatile cptrsl;
     37 const unsigned char * volatile cptruc;
     38 const unsigned short * volatile cptrus;
     39 const unsigned int * volatile cptrui;
     40 const unsigned long long * volatile cptrul;
     41 const float * volatile cptrf;
     42 const double * volatile cptrd;
     43 
     44 void * volatile ptr;
     45 signed char * volatile ptrsc;
     46 signed short * volatile ptrss;
     47 signed int * volatile ptrsi;
     48 signed long long * volatile ptrsl;
     49 unsigned char * volatile ptruc;
     50 unsigned short * volatile ptrus;
     51 unsigned int * volatile ptrui;
     52 unsigned long long * volatile ptrul;
     53 float * volatile ptrf;
     54 double * volatile ptrd;
     55 
     56 volatile unsigned int len;
     57 volatile int idx;
     58 int cc;
     59 
     60 void test_core(void) {
     61   len = __lcbb(cptr, idx);   // expected-error {{no matching function}}
     62                              // expected-note (at) vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
     63   len = __lcbb(cptr, 200);   // expected-error {{no matching function}}
     64                              // expected-note (at) vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
     65   len = __lcbb(cptr, 32);    // expected-error {{no matching function}}
     66                              // expected-note (at) vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
     67   len = __lcbb(cptr, 8192);  // expected-error {{no matching function}}
     68                              // expected-note (at) vecintrin.h:* {{must be a constant power of 2 from 64 to 4096}}
     69 
     70   vsl = vec_permi(vsl, vsl, idx); // expected-error {{no matching function}}
     71                                   // expected-note (at) vecintrin.h:* 3 {{candidate function not viable}}
     72                                   // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
     73   vsl = vec_permi(vsl, vsl, -1);  // expected-error {{no matching function}}
     74                                   // expected-note (at) vecintrin.h:* 3 {{candidate function not viable}}
     75                                   // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
     76   vsl = vec_permi(vsl, vsl, 4);   // expected-error {{no matching function}}
     77                                   // expected-note (at) vecintrin.h:* 3 {{candidate function not viable}}
     78                                   // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
     79   vul = vec_permi(vul, vul, idx); // expected-error {{no matching function}}
     80                                   // expected-note (at) vecintrin.h:* 2 {{candidate function not viable}}
     81                                   // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
     82   vul = vec_permi(vul, vul, -1);  // expected-error {{no matching function}}
     83                                   // expected-note (at) vecintrin.h:* 2 {{candidate function not viable}}
     84                                   // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
     85   vul = vec_permi(vul, vul, 4);   // expected-error {{no matching function}}
     86                                   // expected-note (at) vecintrin.h:* 2 {{candidate function not viable}}
     87                                   // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
     88   vbl = vec_permi(vbl, vbl, idx); // expected-error {{no matching function}}
     89                                   // expected-note (at) vecintrin.h:* 2 {{candidate function not viable}}
     90                                   // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
     91   vbl = vec_permi(vbl, vbl, -1);  // expected-error {{no matching function}}
     92                                   // expected-note (at) vecintrin.h:* 2 {{candidate function not viable}}
     93                                   // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
     94   vbl = vec_permi(vbl, vbl, 4);   // expected-error {{no matching function}}
     95                                   // expected-note (at) vecintrin.h:* 2 {{candidate function not viable}}
     96                                   // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
     97   vd = vec_permi(vd, vd, idx);    // expected-error {{no matching function}}
     98                                   // expected-note (at) vecintrin.h:* 3 {{candidate function not viable}}
     99                                   // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    100   vd = vec_permi(vd, vd, -1);     // expected-error {{no matching function}}
    101                                   // expected-note (at) vecintrin.h:* 3 {{candidate function not viable}}
    102                                   // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    103   vd = vec_permi(vd, vd, 4);      // expected-error {{no matching function}}
    104                                   // expected-note (at) vecintrin.h:* 3 {{candidate function not viable}}
    105                                   // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    106 
    107   vsi = vec_gather_element(vsi, vui, cptrsi, idx); // expected-error {{no matching function}}
    108                                                    // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    109                                                    // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    110   vsi = vec_gather_element(vsi, vui, cptrsi, -1);  // expected-error {{no matching function}}
    111                                                    // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    112                                                    // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    113   vsi = vec_gather_element(vsi, vui, cptrsi, 4);   // expected-error {{no matching function}}
    114                                                    // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    115                                                    // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    116   vui = vec_gather_element(vui, vui, cptrui, idx); // expected-error {{no matching function}}
    117                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    118                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    119   vui = vec_gather_element(vui, vui, cptrui, -1);  // expected-error {{no matching function}}
    120                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    121                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    122   vui = vec_gather_element(vui, vui, cptrui, 4);   // expected-error {{no matching function}}
    123                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    124                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    125   vbi = vec_gather_element(vbi, vui, cptrui, idx); // expected-error {{no matching function}}
    126                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    127                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    128   vbi = vec_gather_element(vbi, vui, cptrui, -1);  // expected-error {{no matching function}}
    129                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    130                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    131   vbi = vec_gather_element(vbi, vui, cptrui, 4);   // expected-error {{no matching function}}
    132                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    133                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    134   vsl = vec_gather_element(vsl, vul, cptrsl, idx); // expected-error {{no matching function}}
    135                                                    // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    136                                                    // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    137   vsl = vec_gather_element(vsl, vul, cptrsl, -1);  // expected-error {{no matching function}}
    138                                                    // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    139                                                    // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    140   vsl = vec_gather_element(vsl, vul, cptrsl, 2);   // expected-error {{no matching function}}
    141                                                    // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    142                                                    // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    143   vul = vec_gather_element(vul, vul, cptrul, idx); // expected-error {{no matching function}}
    144                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    145                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    146   vul = vec_gather_element(vul, vul, cptrul, -1);  // expected-error {{no matching function}}
    147                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    148                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    149   vul = vec_gather_element(vul, vul, cptrul, 2);   // expected-error {{no matching function}}
    150                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    151                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    152   vbl = vec_gather_element(vbl, vul, cptrul, idx); // expected-error {{no matching function}}
    153                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    154                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    155   vbl = vec_gather_element(vbl, vul, cptrul, -1);  // expected-error {{no matching function}}
    156                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    157                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    158   vbl = vec_gather_element(vbl, vul, cptrul, 2);   // expected-error {{no matching function}}
    159                                                    // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    160                                                    // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    161   vd = vec_gather_element(vd, vul, cptrd, idx);    // expected-error {{no matching function}}
    162                                                    // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    163                                                    // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    164   vd = vec_gather_element(vd, vul, cptrd, -1);     // expected-error {{no matching function}}
    165                                                    // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    166                                                    // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    167   vd = vec_gather_element(vd, vul, cptrd, 2);      // expected-error {{no matching function}}
    168                                                    // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    169                                                    // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    170 
    171   vec_scatter_element(vsi, vui, ptrsi, idx); // expected-error {{no matching function}}
    172                                              // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    173                                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    174   vec_scatter_element(vsi, vui, ptrsi, -1);  // expected-error {{no matching function}}
    175                                              // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    176                                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    177   vec_scatter_element(vsi, vui, ptrsi, 4);   // expected-error {{no matching function}}
    178                                              // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    179                                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    180   vec_scatter_element(vui, vui, ptrui, idx); // expected-error {{no matching function}}
    181                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    182                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    183   vec_scatter_element(vui, vui, ptrui, -1);  // expected-error {{no matching function}}
    184                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    185                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    186   vec_scatter_element(vui, vui, ptrui, 4);   // expected-error {{no matching function}}
    187                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    188                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    189   vec_scatter_element(vbi, vui, ptrui, idx); // expected-error {{no matching function}}
    190                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    191                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    192   vec_scatter_element(vbi, vui, ptrui, -1);  // expected-error {{no matching function}}
    193                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    194                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    195   vec_scatter_element(vbi, vui, ptrui, 4);   // expected-error {{no matching function}}
    196                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    197                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    198   vec_scatter_element(vsl, vul, ptrsl, idx); // expected-error {{no matching function}}
    199                                              // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    200                                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    201   vec_scatter_element(vsl, vul, ptrsl, -1);  // expected-error {{no matching function}}
    202                                              // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    203                                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    204   vec_scatter_element(vsl, vul, ptrsl, 2);   // expected-error {{no matching function}}
    205                                              // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    206                                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    207   vec_scatter_element(vul, vul, ptrul, idx); // expected-error {{no matching function}}
    208                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    209                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    210   vec_scatter_element(vul, vul, ptrul, -1);  // expected-error {{no matching function}}
    211                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    212                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    213   vec_scatter_element(vul, vul, ptrul, 2);   // expected-error {{no matching function}}
    214                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    215                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    216   vec_scatter_element(vbl, vul, ptrul, idx); // expected-error {{no matching function}}
    217                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    218                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    219   vec_scatter_element(vbl, vul, ptrul, -1);  // expected-error {{no matching function}}
    220                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    221                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    222   vec_scatter_element(vbl, vul, ptrul, 2);   // expected-error {{no matching function}}
    223                                              // expected-note (at) vecintrin.h:* 5 {{candidate function not viable}}
    224                                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    225   vec_scatter_element(vd, vul, ptrd, idx);   // expected-error {{no matching function}}
    226                                              // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    227                                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    228   vec_scatter_element(vd, vul, ptrd, -1);    // expected-error {{no matching function}}
    229                                              // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    230                                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    231   vec_scatter_element(vd, vul, ptrd, 2);     // expected-error {{no matching function}}
    232                                              // expected-note (at) vecintrin.h:* 6 {{candidate function not viable}}
    233                                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    234 
    235   vsc = vec_load_bndry(cptrsc, idx);   // expected-error {{no matching function}}
    236                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    237                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    238   vsc = vec_load_bndry(cptrsc, 200);   // expected-error {{no matching function}}
    239                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    240                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    241   vsc = vec_load_bndry(cptrsc, 32);    // expected-error {{no matching function}}
    242                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    243                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    244   vsc = vec_load_bndry(cptrsc, 8192);  // expected-error {{no matching function}}
    245                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    246                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    247   vuc = vec_load_bndry(cptruc, idx);   // expected-error {{no matching function}}
    248                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    249                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    250   vss = vec_load_bndry(cptrss, idx);   // expected-error {{no matching function}}
    251                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    252                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    253   vus = vec_load_bndry(cptrus, idx);   // expected-error {{no matching function}}
    254                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    255                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    256   vsi = vec_load_bndry(cptrsi, idx);   // expected-error {{no matching function}}
    257                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    258                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    259   vui = vec_load_bndry(cptrui, idx);   // expected-error {{no matching function}}
    260                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    261                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    262   vsl = vec_load_bndry(cptrsl, idx);   // expected-error {{no matching function}}
    263                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    264                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    265   vul = vec_load_bndry(cptrul, idx);   // expected-error {{no matching function}}
    266                                        // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    267                                        // expected-note (at) vecintrin.h:* 1 {{must be a constant power of 2 from 64 to 4096}}
    268 
    269   vuc = vec_genmask(idx);  // expected-error {{no matching function}}
    270                            // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    271 
    272   vuc = vec_genmasks_8(0, idx);    // expected-error {{no matching function}}
    273                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    274   vuc = vec_genmasks_8(idx, 0);    // expected-error {{no matching function}}
    275                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    276   vuc = vec_genmasks_8(idx, idx);  // expected-error {{no matching function}}
    277                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    278   vus = vec_genmasks_16(0, idx);   // expected-error {{no matching function}}
    279                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    280   vus = vec_genmasks_16(idx, 0);   // expected-error {{no matching function}}
    281                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    282   vus = vec_genmasks_16(idx, idx); // expected-error {{no matching function}}
    283                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    284   vui = vec_genmasks_32(0, idx);   // expected-error {{no matching function}}
    285                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    286   vui = vec_genmasks_32(idx, 0);   // expected-error {{no matching function}}
    287                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    288   vui = vec_genmasks_32(idx, idx); // expected-error {{no matching function}}
    289                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    290   vul = vec_genmasks_64(0, idx);   // expected-error {{no matching function}}
    291                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    292   vul = vec_genmasks_64(idx, 0);   // expected-error {{no matching function}}
    293                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    294   vul = vec_genmasks_64(idx, idx); // expected-error {{no matching function}}
    295                                    // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    296 
    297   vsc = vec_splat(vsc, idx); // expected-error {{no matching function}}
    298                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    299                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    300   vsc = vec_splat(vsc, -1);  // expected-error {{no matching function}}
    301                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    302                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    303   vsc = vec_splat(vsc, 16);  // expected-error {{no matching function}}
    304                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    305                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    306   vuc = vec_splat(vuc, idx); // expected-error {{no matching function}}
    307                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    308                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
    309   vuc = vec_splat(vuc, -1);  // expected-error {{no matching function}}
    310                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    311                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
    312   vuc = vec_splat(vuc, 16);  // expected-error {{no matching function}}
    313                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    314                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
    315   vbc = vec_splat(vbc, idx); // expected-error {{no matching function}}
    316                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    317                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
    318   vbc = vec_splat(vbc, -1);  // expected-error {{no matching function}}
    319                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    320                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
    321   vbc = vec_splat(vbc, 16);  // expected-error {{no matching function}}
    322                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    323                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 15}}
    324   vss = vec_splat(vss, idx); // expected-error {{no matching function}}
    325                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    326                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
    327   vss = vec_splat(vss, -1);  // expected-error {{no matching function}}
    328                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    329                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
    330   vss = vec_splat(vss, 8);   // expected-error {{no matching function}}
    331                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    332                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 7}}
    333   vus = vec_splat(vus, idx); // expected-error {{no matching function}}
    334                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    335                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
    336   vus = vec_splat(vus, -1);  // expected-error {{no matching function}}
    337                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    338                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
    339   vus = vec_splat(vus, 8);   // expected-error {{no matching function}}
    340                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    341                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
    342   vbs = vec_splat(vbs, idx); // expected-error {{no matching function}}
    343                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    344                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
    345   vbs = vec_splat(vbs, -1);  // expected-error {{no matching function}}
    346                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    347                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
    348   vbs = vec_splat(vbs, 8);   // expected-error {{no matching function}}
    349                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    350                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 7}}
    351   vsi = vec_splat(vsi, idx); // expected-error {{no matching function}}
    352                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    353                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    354   vsi = vec_splat(vsi, -1);  // expected-error {{no matching function}}
    355                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    356                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    357   vsi = vec_splat(vsi, 4);   // expected-error {{no matching function}}
    358                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    359                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    360   vui = vec_splat(vui, idx); // expected-error {{no matching function}}
    361                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    362                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    363   vui = vec_splat(vui, -1);  // expected-error {{no matching function}}
    364                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    365                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    366   vui = vec_splat(vui, 4);   // expected-error {{no matching function}}
    367                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    368                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    369   vbi = vec_splat(vbi, idx); // expected-error {{no matching function}}
    370                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    371                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    372   vbi = vec_splat(vbi, -1);  // expected-error {{no matching function}}
    373                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    374                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    375   vbi = vec_splat(vbi, 4);   // expected-error {{no matching function}}
    376                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    377                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 3}}
    378   vsl = vec_splat(vsl, idx); // expected-error {{no matching function}}
    379                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    380                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    381   vsl = vec_splat(vsl, -1);  // expected-error {{no matching function}}
    382                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    383                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    384   vsl = vec_splat(vsl, 2);   // expected-error {{no matching function}}
    385                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    386                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    387   vul = vec_splat(vul, idx); // expected-error {{no matching function}}
    388                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    389                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    390   vul = vec_splat(vul, -1);  // expected-error {{no matching function}}
    391                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    392                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    393   vul = vec_splat(vul, 2);   // expected-error {{no matching function}}
    394                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    395                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    396   vbl = vec_splat(vbl, idx); // expected-error {{no matching function}}
    397                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    398                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    399   vbl = vec_splat(vbl, -1);  // expected-error {{no matching function}}
    400                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    401                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    402   vbl = vec_splat(vbl, 2);   // expected-error {{no matching function}}
    403                              // expected-note (at) vecintrin.h:* 11 {{candidate function not viable}}
    404                              // expected-note (at) vecintrin.h:* 2 {{must be a constant integer from 0 to 1}}
    405   vd = vec_splat(vd, idx);   // expected-error {{no matching function}}
    406                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    407                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    408   vd = vec_splat(vd, -1);    // expected-error {{no matching function}}
    409                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    410                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    411   vd = vec_splat(vd, 2);     // expected-error {{no matching function}}
    412                              // expected-note (at) vecintrin.h:* 12 {{candidate function not viable}}
    413                              // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 1}}
    414 
    415   vsc = vec_splat_s8(idx);  // expected-error {{no matching function}}
    416                             // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    417   vuc = vec_splat_u8(idx);  // expected-error {{no matching function}}
    418                             // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    419   vss = vec_splat_s16(idx); // expected-error {{no matching function}}
    420                             // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    421   vus = vec_splat_u16(idx); // expected-error {{no matching function}}
    422                             // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    423   vsi = vec_splat_s32(idx); // expected-error {{no matching function}}
    424                             // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    425   vui = vec_splat_u32(idx); // expected-error {{no matching function}}
    426                             // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    427   vsl = vec_splat_s64(idx); // expected-error {{no matching function}}
    428                             // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    429   vul = vec_splat_u64(idx); // expected-error {{no matching function}}
    430                             // expected-note (at) vecintrin.h:* {{must be a constant integer}}
    431 }
    432 
    433 void test_integer(void) {
    434   vsc = vec_rl_mask(vsc, vuc, idx); // expected-error {{no matching function}}
    435                                     // expected-note (at) vecintrin.h:* 7 {{candidate function not viable}}
    436                                     // expected-note (at) vecintrin.h:* 1 {{must be a constant integer}}
    437   vuc = vec_rl_mask(vuc, vuc, idx); // expected-error {{no matching function}}
    438                                     // expected-note (at) vecintrin.h:* 7 {{candidate function not viable}}
    439                                     // expected-note (at) vecintrin.h:* 1 {{must be a constant integer}}
    440   vss = vec_rl_mask(vss, vus, idx); // expected-error {{no matching function}}
    441                                     // expected-note (at) vecintrin.h:* 7 {{candidate function not viable}}
    442                                     // expected-note (at) vecintrin.h:* 1 {{must be a constant integer}}
    443   vus = vec_rl_mask(vus, vus, idx); // expected-error {{no matching function}}
    444                                     // expected-note (at) vecintrin.h:* 7 {{candidate function not viable}}
    445                                     // expected-note (at) vecintrin.h:* 1 {{must be a constant integer}}
    446   vsi = vec_rl_mask(vsi, vui, idx); // expected-error {{no matching function}}
    447                                     // expected-note (at) vecintrin.h:* 7 {{candidate function not viable}}
    448                                     // expected-note (at) vecintrin.h:* 1 {{must be a constant integer}}
    449   vui = vec_rl_mask(vui, vui, idx); // expected-error {{no matching function}}
    450                                     // expected-note (at) vecintrin.h:* 7 {{candidate function not viable}}
    451                                     // expected-note (at) vecintrin.h:* 1 {{must be a constant integer}}
    452   vsl = vec_rl_mask(vsl, vul, idx); // expected-error {{no matching function}}
    453                                     // expected-note (at) vecintrin.h:* 7 {{candidate function not viable}}
    454                                     // expected-note (at) vecintrin.h:* 1 {{must be a constant integer}}
    455   vul = vec_rl_mask(vul, vul, idx); // expected-error {{no matching function}}
    456                                     // expected-note (at) vecintrin.h:* 7 {{candidate function not viable}}
    457                                     // expected-note (at) vecintrin.h:* 1 {{must be a constant integer}}
    458 
    459   vsc = vec_sld(vsc, vsc, idx); // expected-error {{no matching function}}
    460                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    461                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    462   vsc = vec_sld(vsc, vsc, -1);  // expected-error {{no matching function}}
    463                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    464                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    465   vsc = vec_sld(vsc, vsc, 16);  // expected-error {{no matching function}}
    466                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    467                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    468   vuc = vec_sld(vuc, vuc, idx); // expected-error {{no matching function}}
    469                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    470                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    471   vuc = vec_sld(vuc, vuc, -1);  // expected-error {{no matching function}}
    472                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    473                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    474   vuc = vec_sld(vuc, vuc, 16);  // expected-error {{no matching function}}
    475                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    476                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    477   vss = vec_sld(vss, vss, idx); // expected-error {{no matching function}}
    478                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    479                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    480   vus = vec_sld(vus, vus, idx); // expected-error {{no matching function}}
    481                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    482                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    483   vsi = vec_sld(vsi, vsi, idx); // expected-error {{no matching function}}
    484                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    485                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    486   vui = vec_sld(vui, vui, idx); // expected-error {{no matching function}}
    487                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    488                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    489   vsl = vec_sld(vsl, vsl, idx); // expected-error {{no matching function}}
    490                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    491                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    492   vul = vec_sld(vul, vul, idx); // expected-error {{no matching function}}
    493                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    494                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    495   vd = vec_sld(vd, vd, idx);    // expected-error {{no matching function}}
    496                                 // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    497                                 // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 15}}
    498 
    499   vsc = vec_sldw(vsc, vsc, idx); // expected-error {{no matching function}}
    500                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    501                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    502   vsc = vec_sldw(vsc, vsc, -1);  // expected-error {{no matching function}}
    503                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    504                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    505   vsc = vec_sldw(vsc, vsc, 4);   // expected-error {{no matching function}}
    506                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    507                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    508   vuc = vec_sldw(vuc, vuc, idx); // expected-error {{no matching function}}
    509                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    510                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    511   vuc = vec_sldw(vuc, vuc, -1);  // expected-error {{no matching function}}
    512                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    513                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    514   vuc = vec_sldw(vuc, vuc, 4);   // expected-error {{no matching function}}
    515                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    516                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    517   vss = vec_sldw(vss, vss, idx); // expected-error {{no matching function}}
    518                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    519                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    520   vus = vec_sldw(vus, vus, idx); // expected-error {{no matching function}}
    521                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    522                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    523   vsi = vec_sldw(vsi, vsi, idx); // expected-error {{no matching function}}
    524                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    525                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    526   vui = vec_sldw(vui, vui, idx); // expected-error {{no matching function}}
    527                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    528                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    529   vsl = vec_sldw(vsl, vsl, idx); // expected-error {{no matching function}}
    530                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    531                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    532   vul = vec_sldw(vul, vul, idx); // expected-error {{no matching function}}
    533                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    534                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    535   vd = vec_sldw(vd, vd, idx);    // expected-error {{no matching function}}
    536                                  // expected-note (at) vecintrin.h:* 8 {{candidate function not viable}}
    537                                  // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 3}}
    538 }
    539 
    540 void test_float(void) {
    541   vd = vec_ctd(vsl, idx); // expected-error {{no matching function}}
    542                           // expected-note (at) vecintrin.h:* 1 {{candidate function not viable}}
    543                           // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    544   vd = vec_ctd(vsl, -1);  // expected-error {{no matching function}}
    545                           // expected-note (at) vecintrin.h:* 1 {{candidate function not viable}}
    546                           // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    547   vd = vec_ctd(vsl, 32);  // expected-error {{no matching function}}
    548                           // expected-note (at) vecintrin.h:* 1 {{candidate function not viable}}
    549                           // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    550   vd = vec_ctd(vul, idx); // expected-error {{no matching function}}
    551                           // expected-note (at) vecintrin.h:* 1 {{candidate function not viable}}
    552                           // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    553   vd = vec_ctd(vul, -1);  // expected-error {{no matching function}}
    554                           // expected-note (at) vecintrin.h:* 1 {{candidate function not viable}}
    555                           // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    556   vd = vec_ctd(vul, 32);  // expected-error {{no matching function}}
    557                           // expected-note (at) vecintrin.h:* 1 {{candidate function not viable}}
    558                           // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    559 
    560   vsl = vec_ctsl(vd, idx); // expected-error {{no matching function}}
    561                            // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    562   vsl = vec_ctsl(vd, -1);  // expected-error {{no matching function}}
    563                            // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    564   vsl = vec_ctsl(vd, 32);  // expected-error {{no matching function}}
    565                            // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    566   vul = vec_ctul(vd, idx); // expected-error {{no matching function}}
    567                            // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    568   vul = vec_ctul(vd, -1);  // expected-error {{no matching function}}
    569                            // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    570   vul = vec_ctul(vd, 32);  // expected-error {{no matching function}}
    571                            // expected-note (at) vecintrin.h:* 1 {{must be a constant integer from 0 to 31}}
    572 
    573   vbl = vec_fp_test_data_class(vd, idx, &cc);  // expected-error {{must be a constant integer}}
    574   vbl = vec_fp_test_data_class(vd, -1, &cc);   // expected-error {{should be a value from 0 to 4095}}
    575   vbl = vec_fp_test_data_class(vd, 4096, &cc); // expected-error {{should be a value from 0 to 4095}}
    576 }
    577