gnu/dist/gcc4/gcc/testsuite/gcc.dg/vect/vect-all.c

   1 /* { dg-require-effective-target vect_int } */
   2 /* { dg-require-effective-target vect_float } */
   3
   4 #include <stdarg.h>
   5 #include "tree-vect.h"
   6
   7 #define N 16
   8
   9 int iadd_results[N] = {0,6,12,18,24,30,36,42,48,54,60,66,72,78,84,90};
  10 float fadd_results[N] = {0.0,6.0,12.0,18.0,24.0,30.0,36.0,42.0,48.0,54.0,60.0,66.0,72.0,78.0,84.0,90.0};
  11 float fmul_results[N] = {0.0,3.0,12.0,27.0,48.0,75.0,108.0,147.0,192.0,243.0,300.0,363.0,432.0,507.0,588.0,675.0};
  12 float fresults1[N] = {192.00,240.00,288.00,336.00,384.00,432.00,480.00,528.00,48.00,54.00,60.00,66.00,72.00,78.00,84.00,90.00};
  13 float fresults2[N] = {0.00,6.00,12.00,18.00,24.00,30.00,36.00,42.00,0.00,54.00,120.00,198.00,288.00,390.00,504.00,630.00};
  14
  15 /****************************************************/
  16 void icheck_results (int *a, int *results)
  17 {
  18   int i;
  19   for (i = 0; i < N; i++)
  20     {
  21       if (a[i] != results[i])
  22         abort ();
  23     }
  24 }
  25
  26 void fcheck_results (float *a, float *results)
  27 {
  28   int i;
  29   for (i = 0; i < N; i++)
  30     {
  31       if (a[i] != results[i])
  32         abort ();
  33     }
  34 }
  35
  36 void
  37 fbar_mul (float *a)
  38 {
  39   fcheck_results (a, fmul_results);
  40 }
  41
  42 void
  43 fbar_add (float *a)
  44 {
  45   fcheck_results (a, fadd_results);
  46 }
  47
  48 void
  49 ibar_add (int *a)
  50 {
  51   icheck_results (a, iadd_results);
  52 }
  53
  54 void
  55 fbar1 (float *a)
  56 {
  57   fcheck_results (a, fresults1);
  58 }
  59
  60 void
  61 fbar2 (float *a)
  62 {
  63   fcheck_results (a, fresults2);
  64 }
  65
  66
  67 /* All of the loops below are currently vectorizable.  */
  68
  69 int
  70 main1 ()
  71 {
  72   int i,j;
  73   float a[N];
  74   float e[N];
  75   float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
  76   float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  77   float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
  78   int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
  79   int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
  80   int ia[N];
  81   char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
  82   char ca[N];
  83   short sa[N];
  84
  85   /* Test 1: copy chars.  */
  86   for (i = 0; i < N; i++)
  87     {
  88       ca[i] = cb[i];
  89     }
  90   /* check results:  */
  91   for (i = 0; i < N; i++)
  92     {
  93       if (ca[i] != cb[i])
  94         abort ();
  95     }
  96
  97
  98   /* Test 2: fp mult.  */
  99   for (i = 0; i < N; i++)
 100     {
 101       a[i] = b[i] * c[i];
 102     }
 103   fbar_mul (a);
 104
 105
 106   /* Test 3: mixed types (int, fp), same nunits in vector.  */
 107   for (i = 0; i < N; i++)
 108     {
 109       a[i] = b[i] + c[i] + d[i];
 110       e[i] = b[i] + c[i] + d[i];
 111       ia[i] = ib[i] + ic[i];
 112     }
 113   ibar_add (ia);
 114   fbar_add (a);
 115   fbar_add (e);
 116
 117
 118   /* Test 4: access with offset.  */
 119   for (i = 0; i < N/2; i++)
 120     {
 121       a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
 122       e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
 123     }
 124   fbar1 (a);
 125   fbar2 (e);
 126
 127
 128   /* Test 5: access with offset */
 129   for (i = 1; i <=N-4; i++)
 130     {
 131       a[i+3] = b[i-1];
 132     }
 133   /* check results:  */
 134   for (i = 1; i <=N-4; i++)
 135     {
 136       if (a[i+3] != b[i-1])
 137         abort ();
 138     }
 139
 140
 141   /* Test 6 - loop induction with stride != 1.  */
 142   i = 0;
 143   j = 0;
 144   while (i < 5*N)
 145     {
 146       a[j] = c[j];
 147       i += 5;
 148       j++;
 149     }
 150   /* check results:  */
 151   for (i = 0; i <N; i++)
 152     {
 153       if (a[i] != c[i])
 154         abort ();
 155     }
 156
 157
 158   /* Test 7 - reverse access.  */
 159   for (i = N; i > 0; i--)
 160     {
 161       a[N-i] = d[N-i];
 162     }
 163   /* check results:  */
 164   for (i = 0; i <N; i++)
 165     {
 166       if (a[i] != d[i])
 167         abort ();
 168     }
 169
 170
 171   /* Tests 8,9,10 - constants.  */
 172   for (i = 0; i < N; i++)
 173     {
 174       a[i] = 5.0;
 175     }
 176   /* check results:  */
 177   for (i = 0; i < N; i++)
 178     {
 179       if (a[i] != 5.0)
 180         abort ();
 181     }
 182
 183   for (i = 0; i < N; i++)
 184     {
 185       sa[i] = 5;
 186     }
 187   /* check results:  */
 188   for (i = 0; i < N; i++)
 189     {
 190       if (sa[i] != 5)
 191         abort ();
 192     }
 193
 194   for (i = 0; i < N; i++)
 195     {
 196       ia[i] = ib[i] + 5;
 197     }
 198   /* check results:  */
 199   for (i = 0; i < N; i++)
 200     {
 201       if (ia[i] != ib[i] + 5)
 202         abort ();
 203     }
 204
 205   return 0;
 206 }
 207
 208 int main (void)
 209 {
 210   check_vect ();
 211
 212   return main1 ();
 213 }
 214
 215 /* { dg-final { scan-tree-dump-times "vectorized 10 loops" 1 "vect" } } */
 216 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
 217 /* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
 218 /* { dg-final { cleanup-tree-dump "vect" } } */