gcc/testsuite/gcc.target/powerpc/p8vector-int128-2.c

   1 /* { dg-do run { target { powerpc*-*-linux* && lp64 } } } */
   2 /* { dg-skip-if "" { powerpc*-*-darwin* } } */
   3 /* { dg-skip-if "" { powerpc*-*-*spe* } } */
   4 /* { dg-require-effective-target p8vector_hw } */
   5 /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
   6 /* { dg-options "-mcpu=power8 -O2" } */
   7
   8 #include <stddef.h>
   9 #include <stdlib.h>
  10 #include <altivec.h>
  11
  12 #ifdef DEBUG
  13 #include <stdio.h>
  14 #define UNUSED
  15
  16 #ifdef __LITTLE_ENDIAN__
  17 #define HI_WORD 1
  18 #define LO_WORD 0
  19 #else
  20 #define HI_WORD 0
  21 #define LO_WORD 1
  22 #endif
  23
  24 #else
  25 #define UNUSED __attribute__((__unused__))
  26 #endif
  27
  28 #ifndef S_TYPE
  29 #define S_TYPE __uint128_t
  30 #endif
  31
  32 #ifndef V_TYPE
  33 #define V_TYPE vector S_TYPE
  34 #endif
  35
  36 static int compare (S_TYPE, V_TYPE, const char *, const char *)
  37   __attribute__((__noinline__));
  38
  39 static int
  40 compare (S_TYPE scalar,
  41          V_TYPE vect,
  42          const char *nl    UNUSED,
  43          const char *which UNUSED)
  44 {
  45   unsigned long scalar_lo = (unsigned long) scalar;
  46   unsigned long scalar_hi = (unsigned long) (scalar >> 64);
  47   unsigned long vect_lo;
  48   unsigned long vect_hi;
  49   vector long long tmp;
  50   int ret;
  51
  52   __asm__ ("mfvsrd %0,%x3\n\t"
  53            "xxpermdi %x2,%x3,%x3,3\n\t"
  54            "mfvsrd %1,%x2"
  55            : "=r" (vect_hi),
  56              "=r" (vect_lo),
  57              "=wa" (tmp)
  58            : "wa" (vect));
  59
  60   ret = (scalar_lo != vect_lo) || (scalar_hi != vect_hi);
  61
  62 #ifdef DEBUG
  63   printf ("%s%s: 0x%.16lx %.16lx %s 0x%.16lx %.16lx\n",
  64           nl, which,
  65           scalar_hi, scalar_lo,
  66           (ret) ? "!=" : "==",
  67           vect_hi, vect_lo);
  68
  69   fflush (stdout);
  70 #endif
  71
  72   return ret;
  73 }
  74
  75 static void convert_via_mem (V_TYPE *, S_TYPE *)
  76   __attribute__((__noinline__));
  77
  78 static void
  79 convert_via_mem (V_TYPE *v, S_TYPE *s)
  80 {
  81   *v = (V_TYPE) { *s };
  82   __asm__ volatile ("nop"
  83                     : "+m" (*s), "+m" (*v)
  84                     :
  85                     : "memory");
  86
  87 }
  88
  89
  90 /* Check if vadduqm returns the same values as normal 128-bit add.  */
  91
  92 /* Values to add together.  */
  93 const static struct {
  94   unsigned long hi_1;
  95   unsigned long lo_1;
  96   unsigned long hi_2;
  97   unsigned long lo_2;
  98 } values[] = {
  99   { 0x0000000000000000UL, 0xfffffffffffffffeUL,
 100     0x0000000000000000UL, 0x0000000000000002UL },
 101   { 0x0000000000000000UL, 0x0000000000000002UL,
 102     0x0000000000000000UL, 0xfffffffffffffffeUL },
 103   { 0xffffffffffffffffUL, 0xfffffffffffffffeUL,
 104     0x0000000000000000UL, 0x0000000000000002UL },
 105   { 0xfffffffffffffff2UL, 0xffffffffffffffffUL,
 106     0x0000000000000002UL, 0x0000000000000000UL },
 107   { 0x7fffffffffffffffUL, 0xfffffffffffffffeUL,
 108     0x0000000000000000UL, 0x0000000000000002UL },
 109   { 0x7ffffffffffffff2UL, 0xffffffffffffffffUL,
 110     0x0000000000000002UL, 0x0000000000000000UL },
 111 };
 112
 113 int
 114 main (void)
 115 {
 116   int reg_errors = 0;
 117   int mem_errors = 0;
 118   size_t i;
 119   const char *nl = "";
 120
 121   for (i = 0; i < sizeof (values) / sizeof (values[0]); i++)
 122     {
 123       S_TYPE s_reg_res, s_reg_in1, s_reg_in2, s_mem_res, s_mem_in1, s_mem_in2;
 124       V_TYPE v_reg_res, v_reg_in1, v_reg_in2, v_mem_res, v_mem_in1, v_mem_in2;
 125
 126       s_reg_in1 = ((((S_TYPE)values[i].hi_1 << 64)) + ((S_TYPE)values[i].lo_1));
 127       reg_errors += compare (s_reg_in1, (V_TYPE) { s_reg_in1 }, nl, "reg, in1");
 128
 129       s_reg_in2 = ((((S_TYPE)values[i].hi_2 << 64)) + ((S_TYPE)values[i].lo_2));
 130       reg_errors += compare (s_reg_in2, (V_TYPE) { s_reg_in2 }, "", "reg, in2");
 131
 132       s_reg_res = s_reg_in1 + s_reg_in2;
 133
 134       v_reg_in1 = (V_TYPE) { s_reg_in1 };
 135       v_reg_in2 = (V_TYPE) { s_reg_in2 };
 136       v_reg_res = vec_vadduqm (v_reg_in1, v_reg_in2);
 137       reg_errors += compare (s_reg_res, v_reg_res, "", "reg, res");
 138
 139       s_mem_in1 = s_reg_in1;
 140       convert_via_mem (&v_mem_in1, &s_mem_in1);
 141       mem_errors += compare (s_mem_in1, (V_TYPE) { s_mem_in1 }, "\n", "mem, in1");
 142
 143       s_mem_in2 = s_reg_in2;
 144       convert_via_mem (&v_mem_in2, &s_mem_in2);
 145       mem_errors += compare (s_mem_in2, (V_TYPE) { s_mem_in2 }, "", "mem, in2");
 146
 147       s_mem_res = s_mem_in1 + s_mem_in2;
 148       v_mem_res = vec_vadduqm (v_mem_in1, v_mem_in2);
 149       mem_errors += compare (s_mem_res, v_mem_res, "", "mem, res");
 150
 151       nl = "\n";
 152     }
 153
 154 #ifdef DEBUG
 155   putchar ('\n');
 156
 157   if (!reg_errors)
 158     fputs ("no errors found on register operations\n", stdout);
 159   else
 160     printf ("%d error%s found on register operations\n",
 161             reg_errors,
 162             (reg_errors == 1) ? "s" : "");
 163
 164   if (!mem_errors)
 165     fputs ("no errors found on memory operations\n", stdout);
 166   else
 167     printf ("%d error%s found on memory operations\n",
 168             mem_errors,
 169             (mem_errors == 1) ? "s" : "");
 170
 171   fflush (stdout);
 172 #endif
 173
 174   if ((reg_errors + mem_errors) != 0)
 175     abort ();
 176
 177   return 0;
 178 }