gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op-run.c

   1 /* { dg-do run { target lp64 } } */
   2 /* { dg-require-effective-target vsx_hw } */
   3 /* { dg-options "-O2 -mvsx" } */
   4
   5 #define DEBUG 0
   6
   7 /* Functional test of the one operand vector builtins.  */
   8 #include "vsx-vector-6-func-3op.h"
   9
  10 /* Macros to check the results of the builtin tests.  */
  11 #define FLOAT_CHECK(NAME)                                                 \
  12   f_result = vec_##NAME (f_src_a, f_src_b, f_src_c);                      \
  13                                                                           \
  14   if ((f_result[0] != f_##NAME##_expected[0])                             \
  15       || (f_result[1] != f_##NAME##_expected[1])                          \
  16       || (f_result[2] != f_##NAME##_expected[2])                          \
  17       || (f_result[3] != f_##NAME##_expected[3]))                         \
  18     {                                                                     \
  19       if (DEBUG)                                                          \
  20         {                                                                 \
  21           printf("ERROR: vec_%s (float) expected value does not match\n", \
  22                  #NAME);                                                  \
  23           printf("   expected[0] = %f; result[0] = %f\n",                 \
  24                  f_##NAME##_expected[0], f_result[0]);                    \
  25           printf("   expected[1] = %f; result[1] = %f\n",                 \
  26                  f_##NAME##_expected[1], f_result[1]);                    \
  27           printf("   expected[2] = %f; result[2] = %f\n",                 \
  28                  f_##NAME##_expected[2], f_result[2]);                    \
  29           printf("   expected[3] = %f; result[3] = %f\n",                 \
  30                  f_##NAME##_expected[3], f_result[3]);                    \
  31         }                                                                 \
  32       else                                                                \
  33         abort();                                                          \
  34     }
  35
  36 #define DOUBLE_CHECK(NAME)                                                 \
  37   d_result = vec_##NAME (d_src_a, d_src_b, d_src_c);                       \
  38                                                                            \
  39   if ((d_result[0] != d_##NAME##_expected[0])                              \
  40       || (d_result[1] != d_##NAME##_expected[1]))                          \
  41     {                                                                      \
  42       if (DEBUG)                                                           \
  43         {                                                                  \
  44           printf("ERROR: vec_%s (double) expected value does not match\n", \
  45                  #NAME);                                                   \
  46           printf("   expected[0] = %f; result[0] = %f\n",                  \
  47                  d_##NAME##_expected[0], d_result[0]);                     \
  48           printf("   expected[1] = %f; result[1] = %f\n",                  \
  49                  d_##NAME##_expected[1], d_result[1]);                     \
  50         }                                                                  \
  51       else                                                                 \
  52         abort();                                                           \
  53     }
  54
  55 void __attribute__ ((noipa))
  56 short_tests (vector short ss_src_a, vector short ss_src_b, vector int si_src_c,
  57              vector unsigned short us_src_a, vector unsigned short us_src_b,
  58              vector unsigned int ui_src_c, vector int si_expected,
  59              vector unsigned int ui_expected)
  60 {
  61   /* These tests were put into a function to ensure the compiler doesn't try to
  62      compute the results at compile time.  */
  63   vector int si_result;
  64   vector unsigned int ui_result;
  65
  66   /* Vector multiply-sum saturated */
  67   ui_result = short_msums_unsigned (us_src_a, us_src_b, ui_src_c);
  68   if ((ui_result[0] != ui_expected[0])
  69       || (ui_result[1] != ui_expected[1])
  70       || (ui_result[2] != ui_expected[2])
  71       || (ui_result[3] != ui_expected[3]))
  72 #if DEBUG
  73     {
  74       printf("ERROR: vec_msums (unsigned) expected value does not match\n");
  75       printf("   expected[0] = %d; result[0] = %d\n",
  76              ui_expected[0], ui_result[0]);
  77       printf("   expected[1] = %d; result[1] = %d\n",
  78              ui_expected[1], ui_result[1]);
  79       printf("   expected[2] = %d; result[2] = %d\n",
  80              ui_expected[2], ui_result[2]);
  81       printf("   expected[3] = %d; result[3] = %d\n",
  82              ui_expected[3], ui_result[3]);
  83     }
  84 #else
  85   abort();
  86 #endif
  87
  88   si_result = short_msums_signed (ss_src_a, ss_src_b, si_src_c);
  89   if ((si_result[0] != si_expected[0])
  90       || (si_result[1] != si_expected[1])
  91       || (si_result[2] != si_expected[2])
  92       || (si_result[3] != si_expected[3]))
  93 #if DEBUG
  94     {
  95       printf("ERROR: vec_msums (signed) expected value does not match\n");
  96       printf("   expected[0] = %d; result[0] = %d\n",
  97              si_expected[0], si_result[0]);
  98       printf("   expected[1] = %d; result[1] = %d\n",
  99              si_expected[1], si_result[1]);
 100       printf("   expected[2] = %d; result[2] = %d\n",
 101              si_expected[2], si_result[2]);
 102       printf("   expected[3] = %d; result[3] = %d\n",
 103              si_expected[3], si_result[3]);
 104     }
 105 #else
 106   abort();
 107 #endif
 108 }
 109
 110 void __attribute__ ((noipa))
 111 vector_sel_test (vector double d_src_a, vector double d_src_b,
 112                  vector unsigned long long ull_src_c,
 113                  vector bool long long bll_src_c ,
 114                  vector double d_selectb_expected,
 115                  vector double d_selectu_expected)
 116 {
 117   vector double d_result;
 118
 119   /* Vector select */
 120   d_result = double_sel_test (d_src_a, d_src_b, ull_src_c);
 121
 122   if ((d_result[0] != d_selectu_expected[0])
 123       || (d_result[1] != d_selectu_expected[1]))
 124 #if DEBUG
 125     {
 126       printf("ERROR: vec_sel (double, unsigned long long) expected value does not match\n");
 127       printf("   expected[0] = %f; result[0] = %f\n",
 128              d_selectu_expected[0], d_result[0]);
 129       printf("   expected[1] = %f; result[1] = %f\n",
 130              d_selectu_expected[1], d_result[1]);
 131     }
 132 #else
 133   abort();
 134 #endif
 135
 136   d_result = bool_sel_test (d_src_a, d_src_b, bll_src_c);
 137
 138   if ((d_result[0] != d_selectb_expected[0])
 139       || (d_result[1] != d_selectb_expected[1]))
 140 #if DEBUG
 141     {
 142       printf("ERROR: vec_sel (double, bool long long) expected value does not match\n");
 143       printf("   expected[0] = %f; result[0] = %f\n",
 144              d_selectb_expected[0], d_result[0]);
 145       printf("   expected[1] = %f; result[1] = %f\n",
 146              d_selectb_expected[1], d_result[1]);
 147     }
 148 #else
 149   abort();
 150 #endif
 151 }
 152
 153 void __attribute__ ((noipa))
 154 vector_permute_test (vector double d_src_a, vector double d_src_b,
 155                      vector unsigned char uc_src_c,
 156                      vector double d_perm_expected)
 157 {
 158   vector double d_result;
 159
 160   /* Vector permute */
 161   d_result = double_permute_test (d_src_a, d_src_b, uc_src_c);
 162
 163   if ((d_result[0] != d_perm_expected[0])
 164       || (d_result[1] != d_perm_expected[1]))
 165 #if DEBUG
 166     {
 167       printf("ERROR: vec_perm (double, unsigned char) expected value does not match\n");
 168       printf("   expected[0] = %f; result[0] = %f\n",
 169              d_perm_expected[0], d_result[0]);
 170       printf("   expected[1] = %f; result[1] = %f\n",
 171              d_perm_expected[1], d_result[1]);
 172     }
 173 #else
 174   abort();
 175 #endif
 176
 177 }
 178
 179 int
 180 main () {
 181   int i;
 182
 183   vector unsigned char uc_src_c = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
 184                                    0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
 185   vector short ss_src_a = { 1, 2, 3, 4, 5, 6, 7, 8};
 186   vector short ss_src_b = { -10, 20, 30, 40, 50, 60, 70, 80};
 187   vector int   si_src_c = { 13, -27, 39, 48};
 188   vector int   si_expected = {43, 223, 649, 1178};
 189   vector unsigned short us_src_a = { 31, 32, 33, 34, 1, 2, 3, 4};
 190   vector unsigned short us_src_b = { 11, 7, 30, 90, 39, 48, 28, 64};
 191   vector unsigned int   ui_src_c = { 13, 17, 39, 91};
 192
 193   vector unsigned int   ui_expected = {578, 4067, 174, 431};
 194   vector float f_src_a = { 126.0, 23.0, -338.0, 17.0};
 195   vector float f_src_b = { 2.0, -4.0, 1.0, 4.0};
 196   vector float f_src_c = { 6.0, -8.0, 7.0, 5.0};
 197   vector float f_madd_expected = {  258.0, -100.0, -331.0, 73.0};
 198   vector float f_msub_expected = { 246.0, -84.0, -345.0, 63.0};
 199   vector float f_result;
 200
 201   vector unsigned long long ull_src_c = {0xFFFFFFFFFFFFFFFF,
 202                                          0xFFFFFFFFFFFFFFFF};
 203   vector bool long long bll_src_c = {0, 0};
 204   vector double d_src_a = { 125.44, -338.56};
 205   vector double d_src_b = { 4.0, -2.0};
 206   vector double d_src_c = { 7.0, -3.0};
 207   vector double d_madd_expected = { 508.76, 674.12};
 208   vector double d_msub_expected = { 494.76, 680.12};
 209   vector double d_selectb_expected = { 125.44, -338.56};
 210   vector double d_selectu_expected = { 4.0, -2.0};
 211   vector double d_perm_expected = { 125.44, -338.56};
 212   vector double d_result;
 213
 214   /* Run tests.  */
 215   short_tests (ss_src_a, ss_src_b, si_src_c, us_src_a, us_src_b,
 216                ui_src_c, si_expected, ui_expected);
 217
 218   FLOAT_CHECK (madd)
 219   FLOAT_CHECK (msub)
 220
 221   DOUBLE_CHECK (madd)
 222   DOUBLE_CHECK (msub)
 223
 224   vector_sel_test (d_src_a, d_src_b, ull_src_c, bll_src_c, d_selectb_expected,
 225                    d_selectu_expected);
 226   vector_permute_test (d_src_a, d_src_b, uc_src_c, d_perm_expected);
 227
 228   return 0;
 229 }