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

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