gcc/testsuite/gcc.target/powerpc/builtins-revb-runnable.c

   1 /* { dg-do run { target { powerpc*-*-* && p8vector_hw } } } */
   2 /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
   3 /* { dg-options "-mcpu=power8  -O3" } */
   4
   5 #include <altivec.h>
   6
   7 #ifdef DEBUG
   8 #include <stdio.h>
   9 #endif
  10
  11 void abort (void);
  12
  13 /* Verify vec_revb builtins */
  14
  15 int
  16 main()
  17 {
  18   int i;
  19   vector bool char arg_bc, result_bc, expected_bc;
  20   vector unsigned char arg_uc, result_uc, expected_uc;
  21   vector signed char arg_sc, result_sc, expected_sc;
  22
  23   vector bool short int arg_bsi, result_bsi, expected_bsi;
  24   vector unsigned short int arg_usi, result_usi, expected_usi;
  25   vector short int arg_si, result_si, expected_si;
  26
  27   vector bool int arg_bi, result_bi, expected_bi;
  28   vector unsigned int arg_ui, result_ui, expected_ui;
  29   vector int arg_int, result_int, expected_int;
  30
  31   vector bool long long int arg_blli, result_blli, expected_blli;
  32   vector unsigned long long int arg_ulli, result_ulli, expected_ulli;
  33   vector long long int arg_lli, result_lli, expected_lli;
  34
  35   vector __uint128_t arg_uint128, result_uint128, expected_uint128;
  36   vector __int128_t arg_int128, result_int128, expected_int128;
  37
  38   vector float arg_f, result_f, expected_f;
  39   vector double arg_d, result_d, expected_d;
  40
  41   /* 8-bit ints */
  42   /* The element is a byte.  Reversing the byte in each byte element
  43      gives the same value.  */
  44   arg_bc = (vector bool char) {0x01, 0x23, 0x45, 0x67,
  45                                0x7E, 0x7C, 0x7A, 0x78,
  46                                0x02, 0x46, 0x7A, 0x7E,
  47                                0x13, 0x57, 0x7B, 0x7F};
  48   expected_bc = arg_bc;
  49
  50   result_bc = vec_revb (arg_bc);
  51
  52   for (i = 0; i < 16; i++) {
  53     if (result_bc[i] != expected_bc[i])
  54 #ifdef DEBUG
  55        printf("arg_bc[%d] = 0x%x, result_bc[%d] = 0x%x, expected_bc[%d] = 0x%x\n",
  56               i, arg_bc[i], i, result_bc[i], i, expected_bc[i]);
  57 #else
  58     abort();
  59 #endif
  60   }
  61
  62   arg_uc = (vector unsigned char) {0x01, 0x23, 0x45, 0x67,
  63                                    0x7E, 0x7C, 0x7A, 0x78,
  64                                    0x02, 0x46, 0x7A, 0x7E,
  65                                    0x13, 0x57, 0x7B, 0x7F};
  66   expected_uc = arg_uc;
  67
  68   result_uc = vec_revb (arg_uc);
  69
  70   for (i = 0; i < 16; i++) {
  71     if (result_uc[i] != expected_uc[i])
  72 #ifdef DEBUG
  73        printf("arg_uc[%d] = 0x%x, result_uc[%d] = 0x%x, expected_uc[%d] = 0x%x\n",
  74               i, arg_uc[i], i, result_uc[i], i, expected_uc[i]);
  75 #else
  76     abort();
  77 #endif
  78   }
  79
  80   arg_sc = (vector signed char) {0x01, 0x23, 0x45, 0x67,
  81                                  0x7E, 0x7C, 0x7A, 0x78,
  82                                  0x02, 0x46, 0x7A, 0x7E,
  83                                  0x13, 0x57, 0x7B, 0x7F};
  84   expected_sc = arg_sc;
  85
  86   result_sc = vec_revb (arg_sc);
  87
  88   for (i = 0; i < 16; i++) {
  89     if (result_sc[i] != expected_sc[i])
  90 #ifdef DEBUG
  91       printf("arg_sc[%d] = 0x%x, result_sc[%d] = 0x%x, expected_sc[%d] = 0x%x\n",
  92              i, arg_sc[i], i, result_sc[i], i, expected_sc[i]);
  93 #else
  94     abort();
  95 #endif
  96   }
  97
  98   /* 16-bit ints */
  99   arg_bsi = (vector bool short int) {0x0123, 0x4567, 0xFEDC, 0xBA98, 0x0246,
 100                                      0x8ACE, 0x1357, 0x9BDF};
 101   expected_bsi = (vector bool short int) {0x2301, 0x6745, 0xDCFE, 0x98BA,
 102                                           0x4602, 0xCE8A, 0x5713, 0xDF9B};
 103
 104   result_bsi = vec_revb (arg_bsi);
 105
 106   for (i = 0; i < 8; i++) {
 107     if (result_bsi[i] != expected_bsi[i])
 108 #ifdef DEBUG
 109        printf("arg_bsi[%d] = 0x%x, result_bsi[%d] = 0x%x, expected_bsi[%d] = 0x%x\n",
 110               i, arg_bsi[i], i, result_bsi[i], i, expected_bsi[i]);
 111 #else
 112     abort();
 113 #endif
 114   }
 115
 116   arg_usi = (vector unsigned short int) {0x0123, 0x4567, 0xFEDC, 0xBA98,
 117                                          0x0246, 0x8ACE, 0x1357, 0x9BDF};
 118   expected_usi = (vector unsigned short int) {0x2301, 0x6745, 0xDCFE, 0x98BA,
 119                                               0x4602, 0xCE8A, 0x5713, 0xDF9B};
 120
 121   result_usi = vec_revb (arg_usi);
 122
 123   for (i = 0; i < 8; i++) {
 124     if (result_usi[i] != expected_usi[i])
 125 #ifdef DEBUG
 126       printf("arg_usi[%d] = 0x%x, result_usi[%d] = 0x%x, expected_usi[%d] = 0x%x\n",
 127              i, arg_usi[i], i, result_usi[i], i, expected_usi[i]);
 128 #else
 129     abort();
 130 #endif
 131   }
 132
 133   arg_si = (vector short int) {0x0123, 0x4567, 0xFEDC, 0xBA98, 0x0246, 0x8ACE,
 134                                0x1357, 0x9BDF};
 135   expected_si = (vector short int) {0x2301, 0x6745, 0xDCFE, 0x98BA, 0x4602,
 136                                     0xCE8A, 0x5713, 0xDF9B};
 137
 138   result_si = vec_revb (arg_si);
 139
 140   for (i = 0; i < 8; i++) {
 141     if (result_si[i] != expected_si[i])
 142 #ifdef DEBUG
 143        printf("arg_si[%d] = 0x%x, result_si[%d] = 0x%x, expected_si[%d] = 0x%x\n",
 144               i, arg_si[i], i, result_si[i], i, expected_si[i]);
 145 #else
 146     abort();
 147 #endif
 148   }
 149
 150   /* 32-bit ints */
 151   arg_bi = (vector bool int) {0x01234567, 0xFEDCBA98, 0x02468ACE, 0x13579BDF};
 152   expected_bi = (vector bool int) {0x67452301, 0x98BADCFE, 0xCE8A4602,
 153                                    0xDF9B5713};
 154
 155   result_bi = vec_revb (arg_bi);
 156
 157   for (i = 0; i < 4; i++) {
 158     if (result_bi[i] != expected_bi[i])
 159 #ifdef DEBUG
 160       printf("arg_bi[%d] = 0x%x, result_bi[%d] = 0x%x, expected_bi[%d] = 0x%x\n",
 161              i, arg_bi[i], i, result_bi[i], i, expected_bi[i]);
 162 #else
 163     abort();
 164 #endif
 165   }
 166
 167   arg_ui = (vector unsigned int) {0x01234567, 0xFEDCBA98, 0x02468ACE,
 168                                   0x13579BDF};
 169   expected_ui = (vector unsigned int) {0x67452301, 0x98BADCFE, 0xCE8A4602,
 170                                        0xDF9B5713};
 171
 172   result_ui = vec_revb (arg_ui);
 173
 174   for (i = 0; i < 4; i++) {
 175     if (result_ui[i] != expected_ui[i])
 176 #ifdef DEBUG
 177       printf("arg_ui[%d] = 0x%x, result_ui[%d] = 0x%x, expected_ui[%d] = 0x%x\n",
 178              i, arg_ui[i], i, result_ui[i], i, expected_ui[i]);
 179 #else
 180     abort();
 181 #endif
 182   }
 183
 184   arg_int = (vector int) {0x01234567, 0xFEDCBA98, 0x02468ACE, 0x13579BDF};
 185   expected_int = (vector int) {0x67452301, 0x98BADCFE, 0xCE8A4602, 0xDF9B5713};
 186
 187   result_int = vec_revb (arg_int);
 188
 189   for (i = 0; i < 4; i++) {
 190     if (result_int[i] != expected_int[i])
 191 #ifdef DEBUG
 192       printf("arg_int[%d] = 0x%x, result_int[%d] = 0x%x, expected_int[%d] = 0x%x\n",
 193              i, arg_int[i], i, result_int[i], i, expected_int[i]);
 194 #else
 195     abort();
 196 #endif
 197   }
 198
 199   /* 64-bit ints */
 200   arg_blli = (vector bool long long int) {0x01234567FEDCBA98,
 201                                           0x02468ACE13579BDF};
 202   expected_blli = (vector bool long long int) {0x98BADCFE67452301,
 203                                                0xDF9B5713CE8A4602};
 204
 205   result_blli = vec_revb (arg_blli);
 206
 207   for (i = 0; i < 2; i++) {
 208     if (result_blli[i] != expected_blli[i])
 209 #ifdef DEBUG
 210       printf("arg_blli[%d] = 0x%x, result_blli[%d] = 0x%llx, expected_blli[%d] = 0x%llx\n",
 211              i, arg_blli[i], i, result_blli[i], i, expected_blli[i]);
 212 #else
 213     abort();
 214 #endif
 215   }
 216
 217   arg_ulli = (vector unsigned long long int) {0x01234567FEDCBA98,
 218                                               0x02468ACE13579BDF};
 219   expected_ulli = (vector unsigned long long int) {0x98BADCFE67452301,
 220                                                    0xDF9B5713CE8A4602};
 221
 222   result_ulli = vec_revb (arg_ulli);
 223
 224   for (i = 0; i < 2; i++) {
 225     if (result_ulli[i] != expected_ulli[i])
 226 #ifdef DEBUG
 227       printf("arg_ulli[%d] = 0x%x, result_ulli[%d] = 0x%llx, expected_ulli[%d] = 0x%llx\n",
 228              i, arg_ulli[i], i, result_ulli[i], i, expected_ulli[i]);
 229 #else
 230     abort();
 231 #endif
 232   }
 233
 234   arg_lli = (vector long long int) {0x01234567FEDCBA98, 0x02468ACE13579BDF};
 235   expected_lli = (vector long long int) {0x98BADCFE67452301,
 236                                          0xDF9B5713CE8A4602};
 237
 238   result_lli = vec_revb (arg_lli);
 239
 240   for (i = 0; i < 2; i++) {
 241     if (result_lli[i] != expected_lli[i])
 242 #ifdef DEBUG
 243       printf("arg_lli[%d] = 0x%x, result_lli[%d] = 0x%llx, expected_lli[%d] = 0x%llx\n",
 244              i, arg_lli[i], i, result_lli[i], i, expected_lli[i]);
 245 #else
 246     abort();
 247 #endif
 248   }
 249
 250   /* 128-bit ints */
 251   arg_uint128[0] = 0x1627384950617243;
 252   arg_uint128[0] = arg_uint128[0] << 64;
 253   arg_uint128[0] |= 0x9405182930415263;
 254   expected_uint128[0] = 0x6352413029180594;
 255   expected_uint128[0] = expected_uint128[0] << 64;
 256   expected_uint128[0] |= 0x4372615049382716;
 257
 258   result_uint128 = vec_revb (arg_uint128);
 259
 260   if (result_uint128[0] != expected_uint128[0])
 261     {
 262 #ifdef DEBUG
 263        printf("result_uint128[0] doesn't match expected_u128[0]\n");
 264        printf("arg_uint128[0] =  %llx ", arg_uint128[0] >> 64);
 265        printf(" %llx\n",         arg_uint128[0] & 0xFFFFFFFFFFFFFFFF);
 266
 267        printf("result_uint128[0] =  %llx ", result_uint128[0] >> 64);
 268        printf(" %llx\n", result_uint128[0] & 0xFFFFFFFFFFFFFFFF);
 269
 270        printf("expected_uint128[0] =  %llx ", expected_uint128[0] >> 64);
 271        printf(" %llx\n", expected_uint128[0] & 0xFFFFFFFFFFFFFFFF);
 272 #else
 273     abort();
 274 #endif
 275     }
 276
 277   arg_int128[0] = 0x1627384950617283;
 278   arg_int128[0] = arg_int128[0] << 64;
 279   arg_int128[0] |= 0x9405182930415263;
 280   expected_int128[0] = 0x6352413029180594;
 281   expected_int128[0] = expected_int128[0] << 64;
 282   expected_int128[0] |= 0x8372615049382716;;
 283
 284   result_int128 = vec_revb (arg_int128);
 285
 286   if (result_int128[0] != expected_int128[0])
 287     {
 288 #ifdef DEBUG
 289        printf("result_int128[0] doesn't match expected128[0]\n");
 290        printf("arg_int128[0] =  %llx ", arg_int128[0] >> 64);
 291        printf(" %llx\n",         arg_int128[0] & 0xFFFFFFFFFFFFFFFF);
 292
 293        printf("result_int128[0] =  %llx ", result_int128[0] >> 64);
 294        printf(" %llx\n", result_int128[0] & 0xFFFFFFFFFFFFFFFF);
 295
 296        printf("expected_int128[0] =  %llx ", expected_int128[0] >> 64);
 297        printf(" %llx\n", expected_int128[0] & 0xFFFFFFFFFFFFFFFF);
 298 #else
 299     abort();
 300 #endif
 301     }
 302
 303   /* 32-bit floats */
 304   /* 0x42f7224e, 0x43e471ec, 0x49712062, 0x4a0f2b38 */
 305   arg_f = (vector float) {123.567, 456.89, 987654.123456, 2345678.0};
 306   /* 0x4e22F742, 0xec71e443, 0x62207149, 0x382b0f4a */
 307   expected_f = (vector float) {683528320.0,
 308                                -1169716232068291395011477504.0,
 309                                739910526898278498304.0,
 310                                0.0000407838160754181444644927978515625};
 311
 312   result_f = vec_revb (arg_f);
 313
 314   for (i = 0; i < 4; i++) {
 315     if (result_f[i] != expected_f[i])
 316       {
 317 #ifdef DEBUG
 318         printf("    arg_f[%d] = %f, result_f[%d] = %f, expected_f[%d] = %f\n",
 319                i, arg_f[i], i, result_f[i], i, expected_f[i]);
 320 #else
 321         abort();
 322 #endif
 323       }
 324   }
 325
 326   /* 64-bit floats */
 327   /* 0x419D6F34547E6B75   0x4194E5FEC781948B */
 328   arg_d = (vector double) {123456789.123456789, 87654321.87654321};
 329   /* 0x756B7E54346F9D41   0x8B9481C7FEE59441 */
 330   expected_d = (vector double) {4.12815412905659550518671402044E257,
 331                                 -6.99269992046390236552018719554E-253};
 332
 333   result_d = vec_revb (arg_d);
 334
 335   for (i = 0; i < 2; i++) {
 336     if (result_d[i] != expected_d[i])
 337 #ifdef DEBUG
 338       printf("arg_d[%d] = %f, result_d[%d] = %f, expected_d[%d] = %f\n",
 339              i, arg_d[i], i, result_d[i], i, expected_d[i]);
 340 #else
 341     abort();
 342 #endif
 343   }
 344 }