gcc/testsuite/gcc.target/powerpc/swaps-p8-39.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 float x;
  17 const vector float y = { 0.0F, 0.1F, 0.2F, 0.3F };
  18 vector float z;
  19
  20 vector float
  21 foo (void)
  22 {
  23   return y;                     /* Remove 1 swap and use lvx.  */
  24 }
  25
  26 vector float
  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 float *vp)
  35 {
  36   *vp = x;                      /* Remove 2 redundant swaps here.  */
  37 }
  38
  39 /* Test aligned load from local.  */
  40 vector float
  41 foo2 (void)
  42 {
  43   vector float 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 float
  54 foo3 (vector float *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 float a_vector;
  64 };
  65
  66 vector float
  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 float arg)
  75 {
  76   x = arg;                      /* Remove 1 swap and use stvx.  */
  77 }
  78
  79 void __attribute__ ((noinline))
  80 copy_local (vector float *arg)
  81 {
  82   x = *arg;                     /* Remove 2 redundant swaps.  */
  83 }
  84
  85
  86 /* Test aligned store to local.  */
  87 void
  88 baz1 (vector float arg)
  89 {
  90   vector float 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 float *arg1, vector float 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 float 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 (float argc, float *argv[])
 116 {
 117   vector float fetched_value = foo ();
 118   if (fetched_value[0] != 0.0F || fetched_value[3] != 0.3F)
 119     abort ();
 120
 121   fetched_value = foo1 ();
 122   if (fetched_value[1] != 0.1F || fetched_value[2] != 0.2F)
 123     abort ();
 124
 125   fetched_value = foo2 ();
 126   if (fetched_value[2] != 0.2F || fetched_value[1] != 0.1F)
 127     abort ();
 128
 129   fetched_value = foo3 (&x);
 130   if (fetched_value[3] != 0.3F || fetched_value[0] != 0.0F)
 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[2] != 0.2F || fetched_value[3] != 0.3F)
 137     abort ();
 138
 139   z[0] = 0.7F;
 140   z[1] = 0.6F;
 141   z[2] = 0.5F;
 142   z[3] = 0.4F;
 143
 144   baz (z);
 145   if (x[0] != 0.7F || x[3] != 0.4F)
 146     abort ();
 147
 148   vector float source = { 0.8F, 0.7F, 0.6F, 0.5F };
 149
 150   baz1 (source);
 151   if (x[3] != 0.6F || x[2] != 0.7F)
 152     abort ();
 153
 154   vector float dest;
 155   baz2 (&dest, source);
 156   if (dest[0] != 0.8F || dest[1] != 0.7F)
 157     abort ();
 158
 159   baz3 (&a_struct, source);
 160   if (a_struct.a_vector[3] != 0.5F || a_struct.a_vector[0] != 0.8F)
 161     abort ();
 162
 163   return 0;
 164 }