/*This section is a complete, compilable program. Assume that it is placed in a
file named ex.c and compiled with the following command:
cc -c -h report=v ex.c
The compiler writes vectorization information to stdout.

Compile this on the Cray.

In order for the report on vectorization information to be written to a file,
use:  cc -c -h report=vf ex.c

This writes the information to ex.V
(for more information: "man cc")

*/

#include <stdlib.h>
extern int a[], b[], c[], d[], n;

extern int a2[][100];

extern char s, t[], u[];

extern struct stack {
    int a[100];
    int n;
} sa, sb;

extern struct point {

    double x, y;
} p1[], p2[], * pp;

extern struct vector {
    double x, y;
} * pv;

extern struct packed {
    int a:32;
    int b:32;
} sc[], * ps;

int *p;
int *q;
int *restrict rp, * restrict rq;
/*
int *rp;
int *rq;
*/

#pragma _CRI vfunction vf

extern int vf(int i, int j);

int f(int i, int j) {
    return(i + j);
}

void examples() {
    int i, j, k;
/* Vectorization of innermost loops: */
/* The innermost loop (do-while loop) vectorizes, */
/* the outer two loops (while loop and for loop) */
/* are not candidates for vectorization. */
    i = 0;
    while (i<10) {
        for (j=0; j<n; j++) {
            k = 0;
            do { /* Vectorized */
               a[k] = c[j];
            }
            while (++k<n);
        }
        i++;
    }

/* Trip count calculation: */
/* The trip count for the first loop can be */
/* calculated at compile time, giving a "short" */
/* vector loop, with minimal overhead. */
/* The trip count for the second loop must be */
/* calculated at run time: trip count = n-j+1. */
/* A trip count loop cannot be calculated prior */
/* to entering the third loop, and so it is */
/* vectorized as a "search", with more overhead */
/* than the first two loops. */

    for (i=0; i<64; i++) { /* Vectorized */
        a[i] = 0;
    }

    for (i=j; i<=n; i++) { /* Vectorized */
        a[i] = 0;
    }

    for (i=0; b[i]!=0; i++) { /* Vectorized */
        a[i] = b[i];
    }

/* Function calls within loops: */
/* The first loop does not vectorize, because of */
/* call to the function "f". */
/* The second loop does vectorize, since the call */
/* is inlined. */
/* The third loop also vectorizes, since the call */
/* is to a "vfunction" written in CAL. */

    for (i=0; i<n; i++) { /* Not vectorized */
        a[i] = f(b[i], c[i]);
    }
    
    for (i=0; i<n; i++) { /* Vectorized */
        #pragma _CRI inline f
        a[i] = f(b[i], c[i]);
    }

    for (i=0; i<n; i++) { /* Vectorized */
        a[i] = vf(b[i], c[i]);
    }

/* Recurrences: */
/* The first two loops do not vectorize because */
/* of recurrences. */
/* The third loop vectorizes because the */
/* recurrence is effectively eliminated when its */
/* threshold (or safe vector length) is 64. */
/* The fourth loop can vectorize with a vector */
/* length of 32. */

    for (i=0; i<a[10]; i++) { /* Not vectorized */
        a[i] = b[i];
    }

    for (i=1; i<200; i++) { /* Not vectorized */
        a[i] = a[i-1];
    }

    for (i=64; i<200; i++) { /* Vectorized */
        a[i] = a[i-64];
    }

    for (i=32; i<200; i++) { /* Vectorized */
        a[i] = a[i-32];
    }

/* Branches: */
/* The first loop cannot be vectorized because */
/* there is a branch into the loop. */
/* The second loop cannot be vectorized because */
/* there is a backward branch within the loop. */

    i = 0;
    if (n) goto lab;

    while (i<100) { /* Not vectorized */
        b[i] = a[i];
        lab:
           a[i++] = 0;
    }

    for (i=0; i<n; i++) { /* Not vectorized */
       lab1:
         a[i] += b[i];
         if (a[i]<0) goto lab1;
    }

/* Search loops: */
/* The first loop vectorizes. */
/* The second loop does not vectorize, because */
/* the exit from the loop is preceded by a */
/* conditional assignment. */

    for (i=0; i<n; i++) { /* Vectorized */
        if (a[i] > 0)
          break;
    }

    for (i=0; i<n; i++) { /* Not vectorized */
        if (a[i] < 0) {
           a[i] = 0;
        }

        if (b[i] > 0) {
           break;
        }
    }

/* Gather/Scatter: */
/* The first loop vectorizes, with a gather from */
/* a and a scatter to b. */
/* The second loop vectorizes, with scalar code */
/* to accommodate the potential recurrences. */
/* The third loop does not vectorize because */
/* of the potential output dependence on d. */

    for (i=0; i<n; i++) { /* Vectorized */
        d[i] = a[c[i]];
        b[c[i]] = d[i];
    }

    for (i=0; i<n; i++) { /* Vectorized */
        d[a[i]] += c[i];
    }

    for (i=0; i<n; i++) { /* Not vectorized */
       d[i] = b[i] + c[i];
       d[a[i]] = 1;
    }

/* Structures: */
/* The first two loops vectorize because they */
/* reference objects with a basic type. */
/* The third loop vectorizes like the second loop */
/* because the structure is smaller than 16 words.*/

    for (i=0; i<n; i++) { /* Vectorized */
       sa.a[i] = sb.a[i];
    }

    for (i=0; i<n; i++) { /* Vectorized */
        sc[i].a = sc[i].b;
    }

    for (i=0; i<n; i++) { /* Vectorized */
       p1[i].x = p2[i].y;
       p1[i].y = p2[i].x;
    }

    for (i=0; i<n; i++) { /* Vectorized */
       p1[i] = p2[i];
    }

/* Pointers: */
/* The first loop does not vectorize because the */
/* pointer is incremented by a value which is not */
/* not a loop invariant. */
/* The second loop vectorizes with a run-time */
/* computation of a safe vector length. If that */
/* length turns out to be 1, the loop runs slower */
/* than if it were not vectorized. */
/* The third loop vectorizes unconditionally */
/* because the pragma asserts that the safe */
/* vector length is at least 64. */
/* The fourth loop vectorizes unconditionally */
/* because the use of restricted pointers asserts */
/* that there is no recurrence. (It is somewhat */
/* faster than the third loop, which has a CMR.) */
    p = a;
    for (i=0; i<n; i++) { /* Not vectorized */
        *p = 0;
        p += c[i];
    }

    p = a; q = b;
    for (i=0; i<n; i++) { /* Vectorized */
        *p++ = *q++;
    } /* ... with computed safe vector length */

    p = a; q = b;

    #pragma _CRI ivdep

    for (i=0; i<n; i++) { /* Vectorized */
        *p++ = *q++;
    }

    rp = a; rq = b;

    for (i=0; i<n; i++, rp++, rq++) { /* Vectorized */
        *rp = *rq;
    }

/* Arrays of characters: */
/* The first loop vectorizes. */
/* The second loop does not vectorize because the */
/* stride is not known to be +1 at compile time. */
/* The third loop does not vectorize because it */
/* references an array not of character type. */
/* The fourth loop does not vectorize because it */
/* uses an operator which is not supported. */
/* The fifth loop does not vectorize because it */
/* is a reduction. */
/* The sixth loop vectorizes because it is a */
/* straightforward search. */

    for (i=0; i<n; i++) { /* Vectorized */
        t[i] += u[i];
    }

    for (i=0; i<n; i+=k) { /* Not vectorized */
        t[i] = 0;
    }

    for (i=0; i<n; i++) { /* Not vectorized */
        t[i] = a[i];
    }

    for (i=0; i<n; i++) { /* Not vectorized */
        t[i] = u[i] % 16;
    }

    s = 0;

    for (i=0; i<n; i++) { /* Not vectorized */
        s += u[i];
    }

    for (i=0; i<n; i++) { /* Vectorized */
        if (t[i] == 0) break;
    }

/* Capabilities enabled by -h vector3 include: */
/* Reordering statements to eliminate dependences */
/* Splitting loops to allow partial vectorization */
/* Improved dependence analysis, based on better: */
/* Analysis of index expressions */
/* Forward substitution of constant values */
/* Tracking of objects to which pointers point */
/* Recognition that objects allocated with */
/* malloc are disjoint from all other objects */
/* Recognition that different members of the */
/* same structure are disjoint */
/* Recognition that objects with different */
/* types are disjoint */

    for (i=0; i<n; i++) { /* Vectorized */
        a[i] = b[i]; /* if vector3 */
        c[i] = a[i+1] + 1;
    } /* ... with statements reversed */

    for (i=0; i<n; i++) { /* Partially vectorized */
        a[i] = a[i-1]; /* if vector3 */
        b[i] = b[i] + 1;
    }/* a into a separate, scalar loop */

    for (i=0; i<n; i++) { /* Vectorized */
        t[i] = u[i]; /* if vector3 */
        b[i] = b[i] * 2.0;
    } /* ... by splitting the two assignments into */

/* separate loops, which are both vectorized */

    for (i=0; i<n; i+=2) { /* Vectorized */
        a[i] = a[3] * b[i]; /* if vector3 */
    } /* ... by improved dependence analysis */

    for (i=0; i<n; i++) { /* Vectorized */
        a2[i][i] = a2[i][n-1] * b[i]; /* if vector3 */
    } /* ... by improved dependence analysis */

    for (i=0; i<n; i++) { /* Vectorized */
        sa.a[i] = sa.n; /* if vector3 */
    } /* ... by improved dependence analysis */

    k = n/2;

    for (i=0; i<n/2; i++) { /* Vectorized */
        a[i] = a[i+k]; /* if vector3 */
    } /* ... by forward substitution of value of k */
 
    p = a;
    q = b;

    for (i=0; i<n; i++) { /* Vectorized */
        *p++ = *q++; /* if vector3 */
    } /* ... by improved pointer tracking */

    p = malloc( n * sizeof(int) );

    for (i=0; i<n; i++) { /* Vectorized */
        p[i] = a[i]; /* if vector3 */
    } /* ... by knowledge of malloc */

    for (i=0; i<n; i++) { /* Vectorized */
        pv[i].x = pp[i].x; /* if vector3 */
        pv[i].y = pp[i].y;
    } /* ... by improved alias analysis */

 /* ... by splitting the recurrence on */

/* a into a separate, scalar loop */
    for (i=0; i<n; i++) { /* Vectorized */
        t[i] = u[i]; /* if vector3 */
        b[i] = b[i] * 2.0;
    } /* ... by splitting the two assignments into */

/* separate loops, which are both vectorized */
    for (i=0; i<n; i+=2) { /* Vectorized */
        a[i] = a[3] * b[i]; /* if vector3 */
    } /* ... by improved dependence analysis */

    for (i=0; i<n; i++) { /* Vectorized */
        a2[i][i] = a2[i][n-1] * b[i]; /* if vector3 */
    } /* ... by improved dependence analysis */

    for (i=0; i<n; i++) { /* Vectorized */
        sa.a[i] = sa.n; /* if vector3 */
    } /* ... by improved dependence analysis */
    
    k = n/2;

    for (i=0; i<n/2; i++) { /* Vectorized */
        a[i] = a[i+k]; /* if vector3 */
    } /* ... by forward substitution of value of k */

    p = a;
    q = b;

    for (i=0; i<n; i++) { /* Vectorized */
        *p++ = *q++; /* if vector3 */
    } /* ... by improved pointer tracking */

    p = malloc( n * sizeof(int) );

    for (i=0; i<n; i++) { /* Vectorized */
        p[i] = a[i]; /* if vector3 */
    } /* ... by knowledge of malloc */

    for (i=0; i<n; i++) { /* Vectorized */
        pv[i].x = pp[i].x; /* if vector3 */
        pv[i].y = pp[i].y;
    } /* ... by improved alias analysis */
}