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

   1 /* { dg-do run { target { powerpc*-*-linux* } } } */
   2 /* { dg-require-effective-target vsx_hw } */
   3 /* { dg-options "-O2 -mvsx -mcpu=power8" } */
   4 /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=power8" } } */
   5
   6 #include <altivec.h> // vector
   7
   8 #ifdef DEBUG
   9 #include <stdio.h>
  10 #endif
  11
  12 #define ALL  1
  13 #define EVEN 2
  14 #define ODD  3
  15
  16 void abort (void);
  17
  18 void test_int_result(int check, vector int vec_result, vector int vec_expected)
  19 {
  20         int i;
  21
  22         for (i = 0; i < 4; i++) {
  23                 switch (check) {
  24                 case ALL:
  25                         break;
  26                 case EVEN:
  27                         if (i%2 == 0)
  28                                 break;
  29                         else
  30                                 continue;
  31                 case ODD:
  32                         if (i%2 != 0)
  33                                 break;
  34                         else
  35                                 continue;
  36                 }
  37
  38                 if (vec_result[i] != vec_expected[i]) {
  39 #ifdef DEBUG
  40                         printf("Test_int_result: ");
  41                         printf("vec_result[%d] (%d) != vec_expected[%d] (%d)\n",
  42                                i, vec_result[i], i, vec_expected[i]);
  43 #else
  44                         abort();
  45 #endif
  46                 }
  47         }
  48 }
  49
  50 void test_unsigned_int_result(int check, vector unsigned int vec_result,
  51                               vector unsigned int vec_expected)
  52 {
  53         int i;
  54
  55         for (i = 0; i < 4; i++) {
  56                 switch (check) {
  57                 case ALL:
  58                         break;
  59                 case EVEN:
  60                         if (i%2 == 0)
  61                                 break;
  62                         else
  63                                 continue;
  64                 case ODD:
  65                         if (i%2 != 0)
  66                                 break;
  67                         else
  68                                 continue;
  69                 }
  70
  71                 if (vec_result[i] != vec_expected[i]) {
  72 #ifdef DEBUG
  73                         printf("Test_unsigned int_result: ");
  74                         printf("vec_result[%d] (%d) != vec_expected[%d] (%d)\n",
  75                                i, vec_result[i], i, vec_expected[i]);
  76 #else
  77                         abort();
  78 #endif
  79                 }
  80
  81         }
  82 }
  83
  84 void test_ll_int_result(vector long long int vec_result,
  85                         vector long long int vec_expected)
  86 {
  87         int i;
  88
  89         for (i = 0; i < 2; i++)
  90                 if (vec_result[i] != vec_expected[i]) {
  91 #ifdef DEBUG
  92                         printf("Test_ll_int_result: ");
  93                         printf("vec_result[%d] (%lld) != vec_expected[%d] (%lld)\n",
  94                                i, vec_result[i], i, vec_expected[i]);
  95 #else
  96                         abort();
  97 #endif
  98                 }
  99 }
 100
 101 void test_ll_unsigned_int_result(vector long long unsigned int vec_result,
 102                                  vector long long unsigned int vec_expected)
 103 {
 104         int i;
 105
 106         for (i = 0; i < 2; i++)
 107                 if (vec_result[i] != vec_expected[i]) {
 108 #ifdef DEBUG
 109                         printf("Test_ll_unsigned_int_result: ");
 110                         printf("vec_result[%d] (%lld) != vec_expected[%d] (%lld)\n",
 111                                i, vec_result[i], i, vec_expected[i]);
 112 #else
 113                         abort();
 114 #endif
 115                 }
 116 }
 117
 118 void test_result_sp(int check, vector float vec_result,
 119                     vector float vec_expected)
 120 {
 121         int i;
 122         for(i = 0; i<4; i++) {
 123
 124                 switch (check) {
 125                 case ALL:
 126                         break;
 127                 case EVEN:
 128                         if (i%2 == 0)
 129                                 break;
 130                         else
 131                                 continue;
 132                 case ODD:
 133                         if (i%2 != 0)
 134                                 break;
 135                         else
 136                                 continue;
 137                 }
 138
 139                 if (vec_result[i] != vec_expected[i]) {
 140 #ifdef DEBUG
 141                         printf("Test_result_sp: ");
 142                         printf("vec_result[%d] (%f) != vec_expected[%d] (%f)\n",
 143                                i, vec_result[i], i, vec_expected[i]);
 144 #else
 145                         abort();
 146 #endif
 147                 }
 148         }
 149 }
 150
 151 void test_result_dp(vector double vec_result, vector double vec_expected)
 152 {
 153         if (vec_result[0] != vec_expected[0]) {
 154 #ifdef DEBUG
 155                 printf("Test_result_dp: ");
 156                 printf("vec_result[0] (%f) != vec_expected[0] (%f)\n",
 157                        vec_result[0], vec_expected[0]);
 158 #else
 159                 abort();
 160 #endif
 161         }
 162
 163         if (vec_result[1] != vec_expected[1]) {
 164 #ifdef DEBUG
 165                 printf("Test_result_dp: ");
 166                 printf("vec_result[1] (%lld) != vec_expected[1] (%lld)\n",
 167                        vec_result[1], vec_expected[1]);
 168 #else
 169                 abort();
 170 #endif
 171         }
 172 }
 173
 174 int main()
 175 {
 176         int i;
 177         vector unsigned int vec_unint, vec_uns_int_expected, vec_uns_int_result;
 178         vector signed int vec_int, vec_int_expected, vec_int_result;
 179         vector long long int vec_ll_int0, vec_ll_int1;
 180         vector long long int vec_ll_int_expected, vec_ll_int_result;
 181         vector long long unsigned int vec_ll_uns_int0, vec_ll_uns_int1;
 182         vector long long unsigned int vec_ll_uns_int_expected, vec_ll_uns_int_result;
 183         vector float  vec_flt, vec_flt_result, vec_flt_expected;
 184         vector double vec_dble0, vec_dble1, vec_dble_result, vec_dble_expected;
 185
 186         vec_int = (vector signed int){ -1, 3, -5, 1234567 };
 187         vec_ll_int0 = (vector long long int){ -12, -12345678901234 };
 188         vec_ll_int1 = (vector long long int){ 12, 9876543210 };
 189         vec_unint = (vector unsigned int){ 9, 11, 15, 2468013579 };
 190         vec_ll_uns_int0 = (vector unsigned long long int){ 102, 9753108642 };
 191         vec_ll_uns_int1 = (vector unsigned long long int){ 23, 29 };
 192         vec_flt = (vector float){ -21., 3.5, -53., 78. };
 193         vec_dble0 = (vector double){ 34.0, 97.0 };
 194         vec_dble1 = (vector double){ 214.0, -5.5 };
 195
 196         /* conversion of words 0 and 2 */
 197         vec_dble_expected = (vector double){-1.000000, -5.000000};
 198         vec_dble_result = vec_doublee (vec_int);
 199         test_result_dp(vec_dble_result, vec_dble_expected);
 200
 201         vec_dble_expected = (vector double){9.000000, 15.000000};
 202         vec_dble_result = vec_doublee (vec_unint);
 203         test_result_dp(vec_dble_result, vec_dble_expected);
 204
 205         vec_dble_expected = (vector double){-21.000000, -53.000000};
 206         vec_dble_result = vec_doublee (vec_flt);
 207         test_result_dp(vec_dble_result, vec_dble_expected);
 208
 209
 210         /* conversion of words 1 and 3 */
 211         vec_dble_expected = (vector double){3.000000, 1234567.000000};
 212         vec_dble_result = vec_doubleo (vec_int);
 213         test_result_dp(vec_dble_result, vec_dble_expected);
 214
 215         vec_dble_expected = (vector double){11.000000, 2468013579.000000};
 216         vec_dble_result = vec_doubleo (vec_unint);
 217         test_result_dp(vec_dble_result, vec_dble_expected);
 218
 219         vec_dble_expected = (vector double){3.500000, 78.000000};
 220         vec_dble_result = vec_doubleo (vec_flt);
 221         test_result_dp(vec_dble_result, vec_dble_expected);
 222
 223
 224         /* conversion of words 0 and 1 */
 225         vec_dble_expected = (vector double){-5.000000, 1234567.000000};
 226         vec_dble_result = vec_doublel (vec_int);
 227         test_result_dp(vec_dble_result, vec_dble_expected);
 228
 229         vec_dble_expected = (vector double){15.000000, 2468013579.000000};
 230         vec_dble_result = vec_doublel (vec_unint);
 231         test_result_dp(vec_dble_result, vec_dble_expected);
 232
 233         vec_dble_expected = (vector double){-53.000000, 78.000000};
 234         vec_dble_result = vec_doublel (vec_flt);
 235         test_result_dp(vec_dble_result, vec_dble_expected);
 236
 237
 238         /* conversion of words 2 and 3 */
 239         vec_dble_expected = (vector double){-1.000000, 3.000000};
 240         vec_dble_result = vec_doubleh (vec_int);
 241         test_result_dp(vec_dble_result, vec_dble_expected);
 242
 243         vec_dble_expected = (vector double){9.000000, 11.000000};
 244         vec_dble_result = vec_doubleh (vec_unint);
 245         test_result_dp(vec_dble_result, vec_dble_expected);
 246
 247         vec_dble_expected = (vector double){-21.000000, 3.500000};
 248         vec_dble_result = vec_doubleh (vec_flt);
 249         test_result_dp(vec_dble_result, vec_dble_expected);
 250
 251         /* conversion of integer vector to single precision float vector */
 252         vec_flt_expected = (vector float){-1.00, 3.00, -5.00, 1234567.00};
 253         vec_flt_result = vec_float (vec_int);
 254         test_result_sp(ALL, vec_flt_result, vec_flt_expected);
 255
 256         vec_flt_expected = (vector float){9.00, 11.00, 15.00, 2468013579.0};
 257         vec_flt_result = vec_float (vec_unint);
 258         test_result_sp(ALL, vec_flt_result, vec_flt_expected);
 259
 260         /* conversion of two double precision vectors to single precision vector */
 261         vec_flt_expected = (vector float){-12.00, -12345678901234.00, 12.00, 9876543210.00};
 262         vec_flt_result = vec_float2 (vec_ll_int0, vec_ll_int1);
 263         test_result_sp(ALL, vec_flt_result, vec_flt_expected);
 264
 265         vec_flt_expected = (vector float){102.00, 9753108642.00, 23.00, 29.00};
 266         vec_flt_result = vec_float2 (vec_ll_uns_int0, vec_ll_uns_int1);
 267         test_result_sp(ALL, vec_flt_result, vec_flt_expected);
 268
 269         vec_flt_expected = (vector float){34.0, 97.0, 214.0, -5.5};
 270         vec_flt_result = vec_float2 (vec_dble0, vec_dble1);
 271         test_result_sp(ALL, vec_flt_result, vec_flt_expected);
 272
 273         /* conversion of even words in double precision vector to single precision vector */
 274         vec_flt_expected = (vector float){-12.00, 00.00, -12345678901234.00, 0.00};
 275         vec_flt_result = vec_floate (vec_ll_int0);
 276         test_result_sp(EVEN, vec_flt_result, vec_flt_expected);
 277
 278         vec_flt_expected = (vector float){102.00, 0.00, 9753108642.00, 0.00};
 279         vec_flt_result = vec_floate (vec_ll_uns_int0);
 280         test_result_sp(EVEN, vec_flt_result, vec_flt_expected);
 281
 282         vec_flt_expected = (vector float){34.00, 0.00, 97.00, 0.00};
 283         vec_flt_result = vec_floate (vec_dble0);
 284         test_result_sp(EVEN, vec_flt_result, vec_flt_expected);
 285
 286         /* conversion of odd words in double precision vector to single precision vector */
 287         vec_flt_expected = (vector float){0.00, -12.00, 00.00, -12345678901234.00};
 288         vec_flt_result = vec_floato (vec_ll_int0);
 289         test_result_sp(ODD, vec_flt_result, vec_flt_expected);
 290
 291         vec_flt_expected = (vector float){0.00, 102.00, 0.00, 9753108642.00};
 292         vec_flt_result = vec_floato (vec_ll_uns_int0);
 293         test_result_sp(ODD, vec_flt_result, vec_flt_expected);
 294
 295         vec_flt_expected = (vector float){0.00, 34.00, 0.00, 97.00};
 296         vec_flt_result = vec_floato (vec_dble0);
 297         test_result_sp(ODD, vec_flt_result, vec_flt_expected);
 298
 299         /* Convert single precision float to int */
 300         vec_flt = (vector float){-14.30, 34.00, 22.00, 97.00};
 301         vec_int_expected = (vector signed int){-14, 34, 22, 97};
 302         vec_int_result = vec_signed (vec_flt);
 303         test_int_result (ALL, vec_int_result, vec_int_expected);
 304
 305         /* Convert double precision float to long long int */
 306         vec_dble0 = (vector double){-124.930, 81234.49};
 307         vec_ll_int_expected = (vector long long signed int){-124, 81234};
 308         vec_ll_int_result = vec_signed (vec_dble0);
 309         test_ll_int_result (vec_ll_int_result, vec_ll_int_expected);
 310
 311         /* Convert two double precision vector float to vector int */
 312         vec_dble0 = (vector double){-124.930, 81234.49};
 313         vec_dble1 = (vector double){-24.370, 8354.99};
 314         vec_int_expected = (vector signed int){-124, 81234, -24, 8354};
 315         vec_int_result = vec_signed2 (vec_dble0, vec_dble1);
 316         test_int_result (ALL, vec_int_result, vec_int_expected);
 317
 318         /* Convert double precision vector float to vector int, even words */
 319         vec_dble0 = (vector double){-124.930, 81234.49};
 320         vec_int_expected = (vector signed int){-124, 0, 81234, 0};
 321         vec_int_result = vec_signede (vec_dble0);
 322         test_int_result (EVEN, vec_int_result, vec_int_expected);
 323
 324         /* Convert double precision vector float to vector int, odd words */
 325         vec_dble0 = (vector double){-124.930, 81234.49};
 326         vec_int_expected = (vector signed int){0, -124, 0, 81234};
 327         vec_int_result = vec_signedo (vec_dble0);
 328         test_int_result (ODD, vec_int_result, vec_int_expected);
 329
 330         /* Convert double precision float to long long unsigned int */
 331         vec_dble0 = (vector double){124.930, 8134.49};
 332         vec_ll_uns_int_expected = (vector long long unsigned int){124, 8134};
 333         vec_ll_uns_int_result = vec_unsigned (vec_dble0);
 334         test_ll_unsigned_int_result (vec_ll_uns_int_result,
 335                                      vec_ll_uns_int_expected);
 336
 337         /* Convert two double precision vector float to vector unsigned int */
 338         vec_dble0 = (vector double){124.930, 8134.49};
 339         vec_dble1 = (vector double){24.370, 834.99};
 340         vec_uns_int_expected = (vector unsigned int){124, 8134, 24, 834};
 341         vec_uns_int_result = vec_unsigned2 (vec_dble0, vec_dble1);
 342         test_unsigned_int_result (ALL, vec_uns_int_result,
 343                                   vec_uns_int_expected);
 344
 345         /* Convert double precision vector float to vector unsigned int,
 346            even words */
 347         vec_dble0 = (vector double){3124.930, 8234.49};
 348         vec_uns_int_expected = (vector unsigned int){3124, 0, 8234, 0};
 349         vec_uns_int_result = vec_unsignede (vec_dble0);
 350         test_unsigned_int_result (EVEN, vec_uns_int_result,
 351                                   vec_uns_int_expected);
 352
 353         /* Convert double precision vector float to vector unsigned int,
 354            odd words */
 355         vec_dble0 = (vector double){1924.930, 81234.49};
 356         vec_uns_int_expected = (vector unsigned int){0, 1924, 0, 81234};
 357         vec_uns_int_result = vec_unsignedo (vec_dble0);
 358         test_unsigned_int_result (ODD, vec_uns_int_result,
 359                                   vec_uns_int_expected);
 360 }
 361