gcc/testsuite/gcc.target/powerpc/swaps-p8-45.c

   1 /* { dg-do compile { target { powerpc64le-*-* } } } */
   2 /* { dg-require-effective-target powerpc_p8vector_ok } */
   3 /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
   4 /* { dg-options "-mcpu=power8 -O3 " } */
   5
   6 /* Previous versions of this test required that the assembler does not
   7    contain xxpermdi or xxswapd.  However, with the more sophisticated
   8    code generation used today, it is now possible that xxpermdi (aka
   9    xxswapd) show up without being part of a lxvd2x or stxvd2x
  10    sequence.  */
  11
  12 #include <altivec.h>
  13
  14 extern void abort (void);
  15
  16 vector double x;
  17 const vector double y = { 0.1, 0.2 };
  18 vector double z;
  19
  20 vector double
  21 foo (void)
  22 {
  23   return y;                     /* Remove 1 swap and use lvx.  */
  24 }
  25
  26 vector double
  27 foo1 (void)
  28 {
  29   x = y;                        /* Remove 2 redundant swaps here.  */
  30   return x;                     /* Remove 1 swap and use lvx.  */
  31 }
  32
  33 void __attribute__ ((noinline))
  34 fill_local (vector double *vp)
  35 {
  36   *vp = x;                      /* Remove 2 redundant swaps here.  */
  37 }
  38
  39 /* Test aligned load from local.  */
  40 vector double
  41 foo2 (void)
  42 {
  43   vector double v;
  44
  45   /* Need to be clever here because v will normally reside in a
  46      register rather than memory.  */
  47   fill_local (&v);
  48   return v;                     /* Remove 1 swap and use lvx.  */
  49 }
  50
  51
  52 /* Test aligned load from pointer.  */
  53 vector double
  54 foo3 (vector double *arg)
  55 {
  56   return *arg;                  /* Remove 1 swap and use lvx.  */
  57 }
  58
  59 /* In this structure, the compiler should insert padding to assure
  60    that a_vector is properly aligned.  */
  61 struct bar {
  62   short a_field;
  63   vector double a_vector;
  64 };
  65
  66 vector double
  67 foo4 (struct bar *bp)
  68 {
  69   return bp->a_vector;          /* Remove 1 swap and use lvx.  */
  70 }
  71
  72 /* Test aligned store to global.  */
  73 void
  74 baz (vector double arg)
  75 {
  76   x = arg;                      /* Remove 1 swap and use stvx.  */
  77 }
  78
  79 void __attribute__ ((noinline))
  80 copy_local (vector double *arg)
  81 {
  82   x = *arg;                     /* Remove 2 redundant swaps.  */
  83 }
  84
  85
  86 /* Test aligned store to local.  */
  87 void
  88 baz1 (vector double arg)
  89 {
  90   vector double v;
  91
  92   /* Need cleverness, because v will normally reside in a register
  93      rather than memory.  */
  94   v = arg;                      /* Aligned store to local: remove 1
  95                                    swap and use stvx.  */
  96   copy_local (&v);
  97 }
  98
  99 /* Test aligned store to pointer.  */
 100 void
 101 baz2 (vector double *arg1, vector double arg2)
 102 {
 103   /* Assume arg2 resides in register.  */
 104   *arg1 = arg2;                 /* Remove 1 swap and use stvx.  */
 105 }
 106
 107 void
 108 baz3 (struct bar *bp, vector double v)
 109 {
 110   /* Assume v resides in register.  */
 111   bp->a_vector = v;             /* Remove 1 swap and use stvx.  */
 112 }
 113
 114 int
 115 main (double argc, double *argv[])
 116 {
 117   vector double fetched_value = foo ();
 118   if (fetched_value[0] != 0.1 || fetched_value[1] != 0.2)
 119     abort ();
 120
 121   fetched_value = foo1 ();
 122   if (fetched_value[1] != 0.2 || fetched_value[0] != 0.1)
 123     abort ();
 124
 125   fetched_value = foo2 ();
 126   if (fetched_value[0] != 0.1 || fetched_value[1] != 0.2)
 127     abort ();
 128
 129   fetched_value = foo3 (&x);
 130   if (fetched_value[1] != 0.2 || fetched_value[0] != 0.1)
 131     abort ();
 132
 133   struct bar a_struct;
 134   a_struct.a_vector = x;        /* Remove 2 redundant swaps.  */
 135   fetched_value = foo4 (&a_struct);
 136   if (fetched_value[1] != 0.2 || fetched_value[0] != 0.1)
 137     abort ();
 138
 139   z[0] = 0.7;
 140   z[1] = 0.6;
 141
 142   baz (z);
 143   if (x[0] != 0.7 || x[1] != 0.6)
 144     abort ();
 145
 146   vector double source = { 0.8, 0.7 };
 147
 148   baz1 (source);
 149   if (x[0] != 0.8 || x[1] != 0.7)
 150     abort ();
 151
 152   vector double dest;
 153   baz2 (&dest, source);
 154   if (dest[0] != 0.8 || dest[1] != 0.7)
 155     abort ();
 156
 157   baz3 (&a_struct, source);
 158   if (a_struct.a_vector[1] != 0.7 || a_struct.a_vector[0] != 0.8)
 159     abort ();
 160
 161   return 0;
 162 }