1  /* { dg-do compile } */
       2  /* { dg-require-effective-target vect_int } */
       3  /* { dg-require-effective-target vect_float } */
       4  
       5  #define N 16
       6  
       7  void fbar (float *);
       8  void ibar (int *);
       9  void sbar (short *);
      10  
      11  /* multiple loops */
      12  
      13  void
      14  foo (int n)
      15  {
      16    float a[N+1];
      17    float b[N];
      18    float c[N];
      19    float d[N];
      20    int ia[N];
      21    int ib[N];
      22    int ic[N];
      23    int i,j;
      24    int diff = 0;
      25    char cb[N];
      26    char cc[N];
      27    char image[N][N];
      28    char block[N][N];
      29  
      30    /* Vectorizable.  */
      31    diff = 0;
      32    for (i = 0; i < N; i++) {
      33      diff += (cb[i] - cc[i]);
      34    }
      35    ibar (&diff);
      36  
      37  
      38    /* Vectorizable.  */
      39    diff = 0;
      40    for (i = 0; i < N; i++) {
      41      for (j = 0; j < N; j++) {
      42        diff += (image[i][j] - block[i][j]);
      43      }
      44    }
      45    ibar (&diff);
      46  
      47  
      48    /* Vectorizable.  */
      49    for (i = 0; i < N; i++){
      50      a[i] = b[i];
      51    }
      52    fbar (a);
      53  
      54  
      55    /* Vectorizable.  */
      56    for (i = 0; i < N; i++){
      57      a[i] = b[i] + c[i] + d[i];
      58    }
      59    fbar (a);
      60  
      61  
      62    /* Strided access. Vectorizable on platforms that support load of strided 
      63       accesses (extract of even/odd vector elements).  */
      64    for (i = 0; i < N/2; i++){
      65      a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
      66      d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
      67    }
      68    fbar (a);
      69  
      70  
      71    /* Vectorizable.  */
      72    for (i = 0; i < N; i++){
      73      a[i] = b[i] + c[i];
      74      d[i] = b[i] + c[i];
      75      ia[i] = ib[i] + ic[i];
      76    }
      77    ibar (ia);
      78    fbar (a);
      79    fbar (d);
      80  
      81    /* Not vetorizable yet (too conservative dependence test).  */
      82    for (i = 0; i < N; i++){
      83      a[i] = b[i] + c[i];
      84      a[i+1] = b[i] + c[i];
      85    }
      86    fbar (a);
      87  }
      88  
      89  /* { dg-final { scan-tree-dump-times "vectorized 6 loops" 1 "vect" { target vect_strided2 } } } */
      90  /* { dg-final { scan-tree-dump-times "vectorized 5 loops" 1 "vect" { xfail vect_strided2 } } } */