gcc/testsuite/gcc.target/powerpc/builtins-3-vec_reve-runnable.c

   1 /* { dg-do run { target { vsx_hw } } } */
   2 /* { dg-options "-O2 -mvsx -mcpu=power7" } */
   3
   4 #include <altivec.h> // vector
   5
   6 #ifdef DEBUG
   7 #include <stdio.h>
   8 #endif
   9
  10 #define VBC   0
  11 #define VSC   1
  12 #define VUC   2
  13 #define VBS   3
  14 #define VSS   4
  15 #define VUS   5
  16 #define VBI   6
  17 #define VI    7
  18 #define VUI   8
  19 #define VLLB  9
  20 #define VLLI  10
  21 #define VLLUI 11
  22 #define VF    12
  23 #define VD    13
  24
  25 union vector_value
  26 {
  27   vector bool char vbc;
  28   vector signed char vsc;
  29   vector unsigned char vuc;
  30   vector bool short vbs;
  31   vector signed short vss;
  32   vector unsigned short vus;
  33   vector bool int vbi;
  34   vector signed int vi;
  35   vector unsigned int vui;
  36   vector bool long long vllb;
  37   vector long long signed int vlli;
  38   vector long long unsigned int vllui;
  39   vector float vf;
  40   vector double vd;
  41 } vec_element;
  42
  43 struct vector_struct
  44 {
  45   int vector_id;
  46   int element_size;  // element size in bytes
  47   union vector_value vec;
  48 } vec;
  49
  50 void abort (void);
  51
  52 void test_results(struct vector_struct *vec_result,
  53                   struct vector_struct *vec_expected)
  54 {
  55   int i;
  56   int num_elements;
  57   if (vec_result->element_size != vec_expected->element_size)
  58 #ifdef DEBUG
  59     printf("vec_result->element_size != vec_expected->element_size\n");
  60 #else
  61     abort();
  62 #endif
  63
  64   if (vec_result->vector_id != vec_expected->vector_id)
  65 #ifdef DEBUG
  66     printf("vec_result->vector_id != vec_expected->vector_id\n");
  67 #else
  68     abort();
  69 #endif
  70
  71    num_elements = 16 / vec_result->element_size;
  72
  73   for (i = 0; i<num_elements; i++) {
  74     switch (vec_result->vector_id) {
  75       case VBC:
  76         if (vec_result->vec.vbc[i] != vec_expected->vec.vbc[i])
  77           {
  78 #ifdef DEBUG
  79              printf("vec_result->vec.vbc[%d] (%d) != ",
  80                     i, vec_result->vec.vbc[i]);
  81              printf("vec_expected->vec.vbc[%d] (%d)\n",
  82                     i, vec_expected->vec.vbc[i]);
  83 #else
  84              abort();
  85 #endif
  86           }
  87         break;
  88
  89       case VSC:
  90         if (vec_result->vec.vsc[i] != vec_expected->vec.vsc[i])
  91           {
  92 #ifdef DEBUG
  93              printf("vec_result->vec.vsc[%d] (%d) != ",
  94                     i, vec_result->vec.vsc[i]);
  95              printf("vec_expected->vec.vsc[%d] (%d)\n",
  96                     i, vec_expected->vec.vsc[i]);
  97 #else
  98              abort();
  99 #endif
 100           }
 101         break;
 102
 103       case VUC:
 104         if (vec_result->vec.vuc[i] != vec_expected->vec.vuc[i])
 105           {
 106 #ifdef DEBUG
 107              printf("vec_result->vec.vuc[%d] (%d) != ",
 108                     i, vec_result->vec.vuc[i]);
 109              printf("vec_expected->vec.vuc[%d] (%d)\n",
 110                     i, vec_expected->vec.vuc[i]);
 111 #else
 112              abort();
 113 #endif
 114           }
 115         break;
 116
 117       case VBS:
 118         if (vec_result->vec.vbs[i] != vec_expected->vec.vbs[i])
 119           {
 120 #ifdef DEBUG
 121              printf("vec_result->vec.vbs[%d] (%d) != ",
 122                     i, vec_result->vec.vbs[i]);
 123              printf("vec_expected->vec.vbs[%d] (%d)\n",
 124                     i, vec_expected->vec.vbs[i]);
 125 #else
 126             abort();
 127 #endif
 128           }
 129         break;
 130
 131       case VSS:
 132         if (vec_result->vec.vss[i] != vec_expected->vec.vss[i])
 133           {
 134 #ifdef DEBUG
 135             printf("vec_result->vec.vss[%d] (%d) != ",
 136                     i, vec_result->vec.vss[i]);
 137             printf("vec_expected->vec.vss[%d] (%d)\n",
 138                     i, vec_expected->vec.vss[i]);
 139 #else
 140             abort();
 141 #endif
 142           }
 143         break;
 144
 145       case VUS:
 146         if (vec_result->vec.vus[i] != vec_expected->vec.vus[i])
 147           {
 148 #ifdef DEBUG
 149              printf("vec_result->vec.vus[%d] (%d) != ",
 150                     i, vec_expected->vec.vus[i]);
 151              printf("vec_expected->vec.vus[%d] (%d)\n",
 152                     i, vec_expected->vec.vus[i]);
 153 #else
 154              abort();
 155 #endif
 156           }
 157         break;
 158
 159       case VBI:
 160         if (vec_result->vec.vbi[i] != vec_expected->vec.vbi[i])
 161           {
 162 #ifdef DEBUG
 163             printf("vec_result->vec.vbi[%d] (%d) != ",
 164                    i, vec_result->vec.vbi[i]);
 165             printf("vec_expected->vec.vbi[%d] (%d)\n",
 166                    i, vec_expected->vec.vbi[i]);
 167 #else
 168             abort();
 169 #endif
 170           }
 171         break;
 172
 173       case VI:
 174         if (vec_result->vec.vi[i] != vec_expected->vec.vi[i])
 175           {
 176 #ifdef DEBUG
 177             printf("vec_result->vec.vi[%d] (%d) != ",
 178                    i, vec_result->vec.vi[i]);
 179             printf("vec_expected->vec.vi[%d] (%d)\n",
 180                    i, vec_expected->vec.vi[i]);
 181 #else
 182             abort();
 183 #endif
 184           }
 185         break;
 186
 187       case VUI:
 188         if (vec_result->vec.vui[i] != vec_expected->vec.vui[i])
 189           {
 190 #ifdef DEBUG
 191             printf("vec_result->vec.vui[%d] (%u) != ",
 192                    i, vec_result->vec.vui[i]);
 193             printf("vec_expected->vec.vui[%u] (%d)\n",
 194                    i, vec_expected->vec.vui[i]);
 195 #else
 196             abort();
 197 #endif
 198           }
 199         break;
 200
 201       case VLLB:
 202         if (vec_result->vec.vllb[i] != vec_expected->vec.vllb[i])
 203           {
 204 #ifdef DEBUG
 205             printf("vec_result->vec.vllb[%d] (%lld != ",
 206                    i, vec_result->vec.vllb[i]);
 207             printf("vec_expected->vec.vllb[%lld] (%d)\n",
 208                    i, vec_expected->vec.vllb[i]);
 209 #else
 210             abort();
 211 #endif
 212           }
 213         break;
 214
 215       case VLLI:
 216         if (vec_result->vec.vlli[i] != vec_expected->vec.vlli[i])
 217           {
 218 #ifdef DEBUG
 219             printf("vec_result->vec.vlli[%d] (%d) != ",
 220                    i, vec_result->vec.vlli[i]);
 221             printf("vec_expected->vec.vlli[%d] (%d)\n",
 222                    i, vec_expected->vec.vlli[i]);
 223 #else
 224             abort();
 225 #endif
 226           }
 227         break;
 228
 229       case VLLUI:
 230         if (vec_result->vec.vllui[i] != vec_expected->vec.vllui[i])
 231           {
 232 #ifdef DEBUG
 233             printf("vec_result->vec.vllui[%d] (%llu) != ",
 234                    i, vec_result->vec.vllui[i]);
 235             printf("vec_expected->vec.vllui[%d] (%llu)\n",
 236                    i, vec_expected->vec.vllui[i]);
 237 #else
 238             abort();
 239 #endif
 240           }
 241         break;
 242
 243       case VF:
 244         if (vec_result->vec.vf[i] != vec_expected->vec.vf[i])
 245           {
 246 #ifdef DEBUG
 247             printf("vec_result->vec.vf[%d] (%f) != ",
 248                    i, vec_result->vec.vf[i]);
 249             printf("vec_expected->vec.vf[%d] (%f)\n",
 250                    i, vec_expected->vec.vf[i]);
 251 #else
 252             abort();
 253 #endif
 254           }
 255         break;
 256
 257       case VD:
 258         if (vec_result->vec.vd[i] != vec_expected->vec.vd[i])
 259           {
 260 #ifdef DEBUG
 261             printf("vec_result->vec.vd[%d] (%f) != ",
 262                    i, vec_result->vec.vd[i]);
 263             printf("vec_expected->vec.vd[%d] (%f)\n",
 264                    i, vec_expected->vec.vd[i]);
 265 #else
 266             abort();
 267 #endif
 268           }
 269            break;
 270
 271       default:
 272 #ifdef DEBUG
 273         printf("Unknown case.\n");
 274 #else
 275         abort();
 276 #endif
 277       }
 278    }
 279 }
 280
 281 int main()
 282 {
 283   int i;
 284   struct vector_struct vec_src, vec_expected, vec_result;
 285
 286   vec_src.vec.vbc = (vector bool char){ 0, 1, 0, 0, 1, 1, 0, 0,
 287                                         0, 1, 1, 1, 0, 0, 0, 0 };
 288   vec_expected.vec.vbc = (vector bool char){ 0, 0, 0, 0, 1, 1, 1, 0,
 289                                              0, 0, 1, 1, 0, 0, 1, 0 };
 290   vec_result.element_size = vec_expected.element_size = 1;
 291   vec_result.vector_id = vec_expected.vector_id = VBC;
 292   vec_result.vec.vbc = vec_reve (vec_src.vec.vbc);
 293   test_results(&vec_result, &vec_expected);
 294
 295   vec_src.vec.vsc = (vector signed char){ 0, 1, -2, -3, 4, 5, -6, -7, 8,
 296                                           9, -10, -11, 12, 13, -14, -15 };
 297   vec_expected.vec.vsc = (vector signed char){ -15, -14, 13, 12, -11, -10,
 298                                                9, 8, -7, -6, 5, 4, -3, -2,
 299                                                1, 0 };
 300   vec_result.element_size = vec_expected.element_size = 1;
 301   vec_result.vector_id = vec_expected.vector_id = VSC;
 302   vec_result.vec.vsc = vec_reve (vec_src.vec.vsc);
 303   test_results (&vec_result, &vec_expected);
 304
 305   vec_src.vec.vuc = (vector unsigned char){ 10, 11, 12, 13, 14, 15, 16, 17,
 306                                             18, 19, 20, 21, 22, 23, 24, 25 };
 307   vec_expected.vec.vuc = (vector unsigned char){ 25, 24, 23, 22, 21, 20,
 308                                                  19, 18, 17, 16, 15, 14, 13,
 309                                                  12, 11, 10 };
 310   vec_result.element_size = vec_expected.element_size = 1;
 311   vec_result.vector_id = vec_expected.vector_id = VUC;
 312   vec_result.vec.vuc = vec_reve (vec_src.vec.vuc);
 313   test_results (&vec_result, &vec_expected);
 314
 315   vec_src.vec.vbs = (vector bool short){ 0, 0, 1, 1, 0, 1, 0, 1 };
 316   vec_expected.vec.vbs = (vector bool short){ 1, 0, 1, 0, 1, 1, 0, 0 };
 317   vec_result.element_size = vec_expected.element_size = 2;
 318   vec_result.vector_id = vec_expected.vector_id = VBS;
 319   vec_result.vec.vbs = vec_reve (vec_src.vec.vbs);
 320   test_results (&vec_result, &vec_expected);
 321
 322   vec_src.vec.vss = (vector signed short){ -1, -2, 3, 4, -5, -6, 7, 8 };
 323   vec_expected.vec.vss = (vector signed short){ 8, 7, -6, -5, 4, 3, -2, -1 };
 324   vec_result.element_size = vec_expected.element_size = 2;
 325   vec_result.vector_id = vec_expected.vector_id = VSS;
 326   vec_result.vec.vss = vec_reve (vec_src.vec.vss);
 327   test_results (&vec_result, &vec_expected);
 328
 329   vec_src.vec.vus = (vector unsigned short){ 11, 22, 33, 44, 55, 66, 77, 88 };
 330   vec_expected.vec.vus = (vector unsigned short){ 88, 77, 66, 55,
 331                                                   44, 33, 22, 11 };
 332   vec_result.element_size = vec_expected.element_size = 2;
 333   vec_result.vector_id = vec_expected.vector_id = VUS;
 334   vec_result.vec.vus = vec_reve (vec_src.vec.vus);
 335   test_results (&vec_result, &vec_expected);
 336
 337   vec_src.vec.vbi = (vector bool int){ 0, 1, 1, 1 };
 338   vec_expected.vec.vbi = (vector bool int){ 1, 1, 1, 0 };
 339   vec_result.element_size = vec_expected.element_size = 4;
 340   vec_result.vector_id = vec_expected.vector_id = VBI;
 341   vec_result.vec.vbi = vec_reve (vec_src.vec.vbi);
 342   test_results (&vec_result, &vec_expected);
 343
 344   vec_src.vec.vi = (vector signed int){ -1, 3, -5, 1234567 };
 345   vec_expected.vec.vi = (vector signed int){1234567, -5, 3, -1};
 346   vec_result.element_size = vec_expected.element_size = 4;
 347   vec_result.vector_id = vec_expected.vector_id = VI;
 348   vec_result.vec.vi = vec_reve (vec_src.vec.vi);
 349   test_results (&vec_result, &vec_expected);
 350
 351   vec_src.vec.vui = (vector unsigned int){ 9, 11, 15, 2468013579 };
 352   vec_expected.vec.vui = (vector unsigned int){2468013579, 15, 11, 9};
 353   vec_result.element_size = vec_expected.element_size = 4;
 354   vec_result.vector_id = vec_expected.vector_id = VUI;
 355   vec_result.vec.vui = vec_reve (vec_src.vec.vui);
 356   test_results (&vec_result, &vec_expected);
 357
 358   vec_src.vec.vllb = (vector bool long long ){ 0, 1 };
 359   vec_expected.vec.vllb = (vector bool long long){1, 0};
 360   vec_result.element_size = vec_expected.element_size = 8;
 361   vec_result.vector_id = vec_expected.vector_id = VLLB;
 362   vec_result.vec.vllb = vec_reve (vec_src.vec.vllb);
 363   test_results (&vec_result, &vec_expected);
 364
 365   vec_src.vec.vlli = (vector long long int){ -12, -12345678901234 };
 366   vec_expected.vec.vlli = (vector long long int){-12345678901234, -12};
 367   vec_result.element_size = vec_expected.element_size = 8;
 368   vec_result.vector_id = vec_expected.vector_id = VLLI;
 369   vec_result.vec.vlli = vec_reve (vec_src.vec.vlli);
 370   test_results (&vec_result, &vec_expected);
 371
 372   vec_src.vec.vllui = (vector unsigned long long int){ 102, 9753108642 };
 373   vec_expected.vec.vllui = (vector unsigned long long int){9753108642, 102};
 374   vec_result.element_size = vec_expected.element_size = 8;
 375   vec_result.vector_id = vec_expected.vector_id = VLLUI;
 376   vec_result.vec.vllui = vec_reve (vec_src.vec.vllui);
 377   test_results (&vec_result, &vec_expected);
 378
 379   vec_src.vec.vf = (vector float){ -21., 3.5, -53., 78. };
 380   vec_expected.vec.vf = (vector float){78., -53, 3.5, -21};
 381   vec_result.element_size = vec_expected.element_size = 4;
 382   vec_result.vector_id = vec_expected.vector_id = VF;
 383   vec_result.vec.vf = vec_reve (vec_src.vec.vf);
 384   test_results (&vec_result, &vec_expected);
 385
 386   vec_src.vec.vd = (vector double){ 34.0, 97.0 };
 387   vec_expected.vec.vd = (vector double){97.0, 34.0};
 388   vec_result.element_size = vec_expected.element_size = 8;
 389   vec_result.vector_id = vec_expected.vector_id = VD;
 390   vec_result.vec.vd = vec_reve (vec_src.vec.vd);
 391   test_results (&vec_result, &vec_expected);
 392 }