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

   1 /* { dg-do run } */
   2 /* { dg-require-effective-target p8vector_hw } */
   3 /* { dg-options "-mdejagnu-cpu=power8 -O2" } */
   4
   5 #include <stdint.h>
   6 #include <stdio.h>
   7 #include <math.h>
   8 #include <altivec.h>
   9
  10 #ifdef DEBUG
  11 #include <stdio.h>
  12 #endif
  13
  14 void abort (void);
  15
  16 int main()
  17   {
  18     int i;
  19     vector float f_arg1;
  20     vector double d_arg1;
  21
  22     vector float vec_f_expected1, vec_f_result1, vec_f_error;
  23     vector double vec_d_expected1, vec_d_result1, vec_d_error;
  24
  25     /* vec_expte: float args, result */
  26     f_arg1 = (vector float){1.0, 2.0, 3.0, 4.0};
  27     vec_f_expected1 = (vector float){2.0, 4.0, 8.0, 16.0};
  28
  29     vec_f_result1 = vec_expte (f_arg1);
  30
  31     for (i = 0; i < 4; i++)
  32       {
  33         if (vec_f_expected1[i] != vec_f_result1[i])
  34 #ifdef DEBUG
  35            printf("ERROR vec_expte (f) result[%d]=%f != expected[%d]=%f\n",
  36                   i, vec_f_result1[i],  i, vec_f_expected1[i]);
  37 #else
  38         abort();
  39 #endif
  40       }
  41
  42     /* vec_loge: float args, result */
  43     f_arg1 = (vector float){4.0, 8.0, 16.0, 64};
  44     vec_f_expected1 = (vector float){2.0, 3.0, 4.0, 6.0};
  45
  46     vec_f_result1 = vec_loge (f_arg1);
  47
  48     for (i = 0; i < 4; i++)
  49       {
  50         if (vec_f_expected1[i] != vec_f_result1[i])
  51 #ifdef DEBUG
  52           printf("ERROR vec_loge (f) result[%d]=%f != expected[%d]=%f\n",
  53                  i, vec_f_result1[i],  i, vec_f_expected1[i]);
  54 #else
  55           abort();
  56 #endif
  57     }
  58
  59     /* vec_re: float args, result  (calculate approximate reciprocal)  */
  60     f_arg1 = (vector float){1.0, 5.0, 4.0, 8.0};
  61     vec_f_expected1 = (vector float){1.0, 0.2, 0.25, 0.125};
  62     vec_f_error = (vector float){1.0, 0.2, 0.25, 0.125};
  63
  64     vec_f_result1 = vec_re (f_arg1);
  65
  66     for (i = 0; i < 4; i++)
  67       {
  68         vec_f_error[i] = fabs(vec_f_expected1[i] - vec_f_result1[i]);
  69
  70         if (vec_f_error[i] >=  0.0001)
  71 #ifdef DEBUG
  72            printf("ERROR vec_re (f) result[%d]=%f != expected[%d]=%f\n",
  73                   i, vec_f_result1[i],  i, vec_f_expected1[i]);
  74 #else
  75         abort();
  76 #endif
  77       }
  78
  79     /* vec_re: double args, result  (calculate approximate reciprocal)  */
  80     d_arg1 = (vector double){1.0, 8.0};
  81     vec_d_expected1 = (vector double){1.0, 0.125};
  82     vec_d_error = (vector double){1.0, 0.125};
  83
  84     vec_d_result1 = vec_re (d_arg1);
  85
  86     for (i = 0; i < 2; i++)
  87       {
  88          vec_d_error[i] = fabs(vec_d_expected1[i] - vec_d_result1[i]);
  89
  90          if (vec_d_error[i] >=  0.0001)
  91 #ifdef DEBUG
  92            printf("ERROR vec_re (d) result[%d]=%f != expected[%d]=%f\n",
  93                   i, vec_d_result1[i],  i, vec_d_expected1[i]);
  94 #else
  95           abort();
  96 #endif
  97       }
  98   }