gcc/testsuite/gcc.dg/vect/vect-all-big-array.c

   1 /* { dg-require-effective-target vect_int } */
   2 /* { dg-require-effective-target vect_float } */
   3 /* { dg-add-options bind_pic_locally } */
   4
   5 #include <stdarg.h>
   6 #include "tree-vect.h"
   7
   8 #define N 128
   9
  10 int iadd_results[N];
  11 float fadd_results[N];
  12 float fmul_results[N];
  13 float fresults1[N];
  14 float fresults2[N];
  15
  16 /****************************************************/
  17 __attribute__ ((noinline))
  18 void icheck_results (int *a, int *results)
  19 {
  20   int i;
  21   for (i = 0; i < N; i++)
  22     {
  23       if (a[i] != results[i])
  24         abort ();
  25     }
  26 }
  27
  28 __attribute__ ((noinline))
  29 void fcheck_results (float *a, float *results)
  30 {
  31   int i;
  32   for (i = 0; i < N; i++)
  33     {
  34       if (a[i] != results[i])
  35         abort ();
  36     }
  37 }
  38
  39 __attribute__ ((noinline)) void
  40 fbar_mul (float *a)
  41 {
  42   fcheck_results (a, fmul_results);
  43 }
  44
  45 __attribute__ ((noinline)) void
  46 fbar_add (float *a)
  47 {
  48   fcheck_results (a, fadd_results);
  49 }
  50
  51 __attribute__ ((noinline)) void
  52 ibar_add (int *a)
  53 {
  54   icheck_results (a, iadd_results);
  55 }
  56
  57 __attribute__ ((noinline)) void
  58 fbar1 (float *a)
  59 {
  60   fcheck_results (a, fresults1);
  61 }
  62
  63 __attribute__ ((noinline)) void
  64 fbar2 (float *a)
  65 {
  66   fcheck_results (a, fresults2);
  67 }
  68
  69 float a[N];
  70 float e[N];
  71 float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
  72 float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  73 float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
  74 int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
  75 int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
  76 int ia[N];
  77 char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
  78 char ca[N];
  79 short sa[N];
  80
  81 /* All of the loops below are currently vectorizable, except
  82    initialization ones.  */
  83
  84 __attribute__ ((noinline)) int
  85 main1 ()
  86 {
  87   int i,j;
  88   /* Initialization.  */
  89   for (i = 0; i < N; i++)
  90     {
  91       b[i] = i*3;
  92       c[i] = i;
  93       d[i] = i*2;
  94       ic[i] = i*3;
  95       ib[i] = i*3;
  96       cb[i] = i*3;
  97       fadd_results[i] = b[i] + c[i] + d[i];
  98       iadd_results[i] = ib[i] + ic[i];
  99       fmul_results[i] = b[i] * c[i];
 100       fresults1[i] = 0;
 101       fresults2[i] = 0;
 102       asm volatile ("" ::: "memory");
 103     }
 104
 105   /* Test 1: copy chars.  */
 106   for (i = 0; i < N; i++)
 107     {
 108       ca[i] = cb[i];
 109     }
 110   /* check results:  */
 111   for (i = 0; i < N; i++)
 112     {
 113       if (ca[i] != cb[i])
 114         abort ();
 115     }
 116
 117
 118   /* Test 2: fp mult.  */
 119   for (i = 0; i < N; i++)
 120     {
 121       a[i] = b[i] * c[i];
 122     }
 123   fbar_mul (a);
 124
 125
 126   /* Test 3: mixed types (int, fp), same nunits in vector.  */
 127   for (i = 0; i < N; i++)
 128     {
 129       a[i] = b[i] + c[i] + d[i];
 130       e[i] = b[i] + c[i] + d[i];
 131       ia[i] = ib[i] + ic[i];
 132     }
 133   ibar_add (ia);
 134   fbar_add (a);
 135   fbar_add (e);
 136
 137   /* Initialization.  */
 138   for (i = 0; i < N; i++)
 139     {
 140       fresults1[i] = a[i];
 141       fresults2[i] = e[i];
 142       asm volatile ("" ::: "memory");
 143     }
 144   for (i = 0; i < N/2; i++)
 145     {
 146       fresults1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
 147       fresults2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
 148       asm volatile ("" ::: "memory");
 149     }
 150   /* Test 4: access with offset.  */
 151   for (i = 0; i < N/2; i++)
 152     {
 153       a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
 154       e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
 155     }
 156   fbar1 (a);
 157   fbar2 (e);
 158
 159
 160   /* Test 5: access with offset.  */
 161   for (i = 1; i <=N-4; i++)
 162     {
 163       a[i+3] = b[i-1];
 164     }
 165   /* check results:  */
 166   for (i = 1; i <=N-4; i++)
 167     {
 168       if (a[i+3] != b[i-1])
 169         abort ();
 170     }
 171
 172
 173   /* Test 6 - loop induction with stride != 1.  */
 174   i = 0;
 175   j = 0;
 176   while (i < 5*N)
 177     {
 178       a[j] = c[j];
 179       i += 5;
 180       j++;
 181     }
 182   /* check results:  */
 183   for (i = 0; i <N; i++)
 184     {
 185       if (a[i] != c[i])
 186         abort ();
 187     }
 188
 189
 190   /* Test 7 - reverse access.  */
 191   for (i = N; i > 0; i--)
 192     {
 193       a[N-i] = d[N-i];
 194     }
 195   /* check results:  */
 196   for (i = 0; i <N; i++)
 197     {
 198       if (a[i] != d[i])
 199         abort ();
 200     }
 201
 202
 203   /* Tests 8,9,10 - constants.  */
 204   for (i = 0; i < N; i++)
 205     {
 206       a[i] = 5.0;
 207     }
 208   /* check results:  */
 209   for (i = 0; i < N; i++)
 210     {
 211       if (a[i] != 5.0)
 212         abort ();
 213     }
 214
 215   for (i = 0; i < N; i++)
 216     {
 217       sa[i] = 5;
 218     }
 219   /* check results:  */
 220   for (i = 0; i < N; i++)
 221     {
 222       if (sa[i] != 5)
 223         abort ();
 224     }
 225
 226   for (i = 0; i < N; i++)
 227     {
 228       ia[i] = ib[i] + 5;
 229     }
 230   /* check results:  */
 231   for (i = 0; i < N; i++)
 232     {
 233       if (ia[i] != ib[i] + 5)
 234         abort ();
 235     }
 236
 237   return 0;
 238 }
 239
 240 int main (void)
 241 {
 242   check_vect ();
 243
 244   return main1 ();
 245 }
 246
 247 /* { dg-final { scan-tree-dump-times "vectorized 10 loops" 1 "vect" } } */
 248 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" { target { { vect_aligned_arrays } && {! vect_sizes_32B_16B} } } } } */
 249 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { target { {! vect_aligned_arrays } && {vect_sizes_32B_16B} } } } } */
 250 /* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */