* gcc.dg/vect/slp-13.c: Increase array size, add initialization.
* gcc.dg/vect/slp-24.c: Ditto.
* gcc.dg/vect/slp-3.c: Likewise and fix scans.
* gcc.dg/vect/slp-34.c: Ditto.
* gcc.dg/vect/slp-4.c: Ditto.
* gcc.dg/vect/slp-cond-2.c: Ditto.
* gcc.dg/vect/slp-multitypes-11.c: Ditto.
* gcc.dg/vect/vect-1.c: Ditto.
* gcc.dg/vect/vect-10.c: Ditto.
* gcc.dg/vect/vect-105.c: Ditto.
* gcc.dg/vect/vect-112.c: Ditto.
* gcc.dg/vect/vect-15.c: Ditto.
* gcc.dg/vect/vect-2.c: Ditto.
* gcc.dg/vect/vect-31.c: Ditto.
* gcc.dg/vect/vect-32.c: Ditto.
* gcc.dg/vect/vect-33.c: Ditto.
* gcc.dg/vect/vect-34.c: Ditto.
* gcc.dg/vect/vect-35.c: Ditto.
* gcc.dg/vect/vect-36.c: Ditto.
* gcc.dg/vect/vect-6.c: Ditto.
* gcc.dg/vect/vect-73.c: Ditto.
* gcc.dg/vect/vect-74.c: Ditto.
* gcc.dg/vect/vect-75.c: Ditto.
* gcc.dg/vect/vect-76.c: Ditto.
* gcc.dg/vect/vect-80.c: Ditto.
* gcc.dg/vect/vect-85.c: Ditto.
* gcc.dg/vect/vect-89.c: Ditto.
* gcc.dg/vect/vect-97.c: Ditto.
* gcc.dg/vect/vect-98.c: Ditto.
* gcc.dg/vect/vect-all.c: Ditto.
* gcc.dg/vect/vect-double-reduc-6.c: Ditto.
* gcc.dg/vect/vect-iv-8.c: Ditto.
* gcc.dg/vect/vect-iv-8a.c: Ditto.
* gcc.dg/vect/vect-outer-1.c: Ditto.
* gcc.dg/vect/vect-outer-1a.c: Ditto.
* gcc.dg/vect/vect-outer-1b.c: Ditto.
* gcc.dg/vect/vect-outer-2.c: Ditto.
* gcc.dg/vect/vect-outer-2a.c: Ditto.
* gcc.dg/vect/vect-outer-2c.c: Ditto.
* gcc.dg/vect/vect-outer-3.c: Ditto.
* gcc.dg/vect/vect-outer-3a.c: Ditto.
* gcc.dg/vect/vect-outer-4a.c: Ditto.
* gcc.dg/vect/vect-outer-4b.c: Ditto.
* gcc.dg/vect/vect-outer-4c.c: Ditto.
* gcc.dg/vect/vect-outer-4d.c: Ditto.
* gcc.dg/vect/vect-outer-4m.c: Ditto.
* gcc.dg/vect/vect-outer-fir-lb.c: Ditto.
* gcc.dg/vect/vect-outer-fir.c: Ditto.
* gcc.dg/vect/vect-over-widen-1.c: Ditto.
* gcc.dg/vect/vect-over-widen-2.c: Ditto.
* gcc.dg/vect/vect-over-widen-3.c: Ditto.
* gcc.dg/vect/vect-over-widen-4.c: Ditto.
* gcc.dg/vect/vect-reduc-1char.c: Ditto.
* gcc.dg/vect/vect-reduc-2char.c: Ditto.
* gcc.dg/vect/vect-reduc-pattern-1b.c: Ditto.
* gcc.dg/vect/vect-reduc-pattern-1c.c: Ditto.
* gcc.dg/vect/vect-reduc-pattern-2b.c: Ditto.
* gcc.dg/vect/vect-shift-2.c: Ditto.
* gcc.dg/vect/vect-strided-a-u8-i8-gap2.c: Ditto.
* gcc.dg/vect/vect-strided-a-u8-i8-gap7.c: Ditto.
* gcc.dg/vect/vect-strided-u8-i8-gap2.c: Ditto.
* gcc.dg/vect/vect-strided-u8-i8-gap4.c: Ditto.
* gcc.dg/vect/vect-strided-u8-i8-gap7.c: Ditto.
From-SVN: r182165
+2011-12-09 Michael Zolotukhin <michael.v.zolotukhin@intel.com>
+
+ * gcc.dg/vect/slp-13.c: Array size increase reverted.
+ * gcc.dg/vect/slp-24.c: Ditto.
+ * gcc.dg/vect/slp-3.c: Ditto.
+ * gcc.dg/vect/slp-34.c: Ditto.
+ * gcc.dg/vect/slp-4.c: Ditto.
+ * gcc.dg/vect/slp-cond-2.c: Ditto.
+ * gcc.dg/vect/slp-multitypes-11.c: Ditto.
+ * gcc.dg/vect/vect-1.c: Ditto.
+ * gcc.dg/vect/vect-10.c: Ditto.
+ * gcc.dg/vect/vect-105.c: Ditto.
+ * gcc.dg/vect/vect-112.c: Ditto.
+ * gcc.dg/vect/vect-15.c: Ditto.
+ * gcc.dg/vect/vect-2.c: Ditto.
+ * gcc.dg/vect/vect-31.c: Ditto.
+ * gcc.dg/vect/vect-32.c: Ditto.
+ * gcc.dg/vect/vect-33.c: Ditto.
+ * gcc.dg/vect/vect-34.c: Ditto.
+ * gcc.dg/vect/vect-35.c: Ditto.
+ * gcc.dg/vect/vect-36.c: Ditto.
+ * gcc.dg/vect/vect-6.c: Ditto.
+ * gcc.dg/vect/vect-73.c: Ditto.
+ * gcc.dg/vect/vect-74.c: Ditto.
+ * gcc.dg/vect/vect-75.c: Ditto.
+ * gcc.dg/vect/vect-76.c: Ditto.
+ * gcc.dg/vect/vect-80.c: Ditto.
+ * gcc.dg/vect/vect-85.c: Ditto.
+ * gcc.dg/vect/vect-89.c: Ditto.
+ * gcc.dg/vect/vect-97.c: Ditto.
+ * gcc.dg/vect/vect-98.c: Ditto.
+ * gcc.dg/vect/vect-all.c: Ditto.
+ * gcc.dg/vect/vect-double-reduc-6.c: Ditto.
+ * gcc.dg/vect/vect-iv-8.c: Ditto.
+ * gcc.dg/vect/vect-iv-8a.c: Ditto.
+ * gcc.dg/vect/vect-outer-1.c: Ditto.
+ * gcc.dg/vect/vect-outer-1a.c: Ditto.
+ * gcc.dg/vect/vect-outer-1b.c: Ditto.
+ * gcc.dg/vect/vect-outer-2.c: Ditto.
+ * gcc.dg/vect/vect-outer-2a.c: Ditto.
+ * gcc.dg/vect/vect-outer-2c.c: Ditto.
+ * gcc.dg/vect/vect-outer-3.c: Ditto.
+ * gcc.dg/vect/vect-outer-3a.c: Ditto.
+ * gcc.dg/vect/vect-outer-4a.c: Ditto.
+ * gcc.dg/vect/vect-outer-4b.c: Ditto.
+ * gcc.dg/vect/vect-outer-4c.c: Ditto.
+ * gcc.dg/vect/vect-outer-4d.c: Ditto.
+ * gcc.dg/vect/vect-outer-4m.c: Ditto.
+ * gcc.dg/vect/vect-outer-fir-lb.c: Ditto.
+ * gcc.dg/vect/vect-outer-fir.c: Ditto.
+ * gcc.dg/vect/vect-over-widen-1.c: Ditto.
+ * gcc.dg/vect/vect-over-widen-2.c: Ditto.
+ * gcc.dg/vect/vect-over-widen-3.c: Ditto.
+ * gcc.dg/vect/vect-over-widen-4.c: Ditto.
+ * gcc.dg/vect/vect-reduc-1char.c: Ditto.
+ * gcc.dg/vect/vect-reduc-2char.c: Ditto.
+ * gcc.dg/vect/vect-reduc-pattern-1b.c: Ditto.
+ * gcc.dg/vect/vect-reduc-pattern-1c.c: Ditto.
+ * gcc.dg/vect/vect-reduc-pattern-2b.c: Ditto.
+ * gcc.dg/vect/vect-shift-2.c: Ditto.
+ * gcc.dg/vect/vect-strided-a-u8-i8-gap2.c: Ditto.
+ * gcc.dg/vect/vect-strided-a-u8-i8-gap7.c: Ditto.
+ * gcc.dg/vect/vect-strided-u8-i8-gap2.c: Ditto.
+ * gcc.dg/vect/vect-strided-u8-i8-gap4.c: Ditto.
+ * gcc.dg/vect/vect-strided-u8-i8-gap7.c: Ditto.
+ * gcc.dg/vect/slp-13-big-array.c: New test.
+ * gcc.dg/vect/slp-24-big-array.c: Ditto.
+ * gcc.dg/vect/slp-3-big-array.c: Ditto.
+ * gcc.dg/vect/slp-34-big-array.c: Ditto.
+ * gcc.dg/vect/slp-4-big-array.c: Ditto.
+ * gcc.dg/vect/slp-cond-2-big-array.c: Ditto.
+ * gcc.dg/vect/slp-multitypes-11-big-array.c: Ditto.
+ * gcc.dg/vect/vect-1-big-array.c: Ditto.
+ * gcc.dg/vect/vect-10-big-array.c: Ditto.
+ * gcc.dg/vect/vect-105-big-array.c: Ditto.
+ * gcc.dg/vect/vect-112-big-array.c: Ditto.
+ * gcc.dg/vect/vect-15-big-array.c: Ditto.
+ * gcc.dg/vect/vect-2-big-array.c: Ditto.
+ * gcc.dg/vect/vect-31-big-array.c: Ditto.
+ * gcc.dg/vect/vect-32-big-array.c: Ditto.
+ * gcc.dg/vect/vect-33-big-array.c: Ditto.
+ * gcc.dg/vect/vect-34-big-array.c: Ditto.
+ * gcc.dg/vect/vect-35-big-array.c: Ditto.
+ * gcc.dg/vect/vect-36-big-array.c: Ditto.
+ * gcc.dg/vect/vect-6-big-array.c: Ditto.
+ * gcc.dg/vect/vect-73-big-array.c: Ditto.
+ * gcc.dg/vect/vect-74-big-array.c: Ditto.
+ * gcc.dg/vect/vect-75-big-array.c: Ditto.
+ * gcc.dg/vect/vect-76-big-array.c: Ditto.
+ * gcc.dg/vect/vect-80-big-array.c: Ditto.
+ * gcc.dg/vect/vect-85-big-array.c: Ditto.
+ * gcc.dg/vect/vect-89-big-array.c: Ditto.
+ * gcc.dg/vect/vect-97-big-array.c: Ditto.
+ * gcc.dg/vect/vect-98-big-array.c: Ditto.
+ * gcc.dg/vect/vect-all-big-array.c: Ditto.
+ * gcc.dg/vect/vect-double-reduc-6-big-array.c: Ditto.
+ * gcc.dg/vect/vect-iv-8-big-array.c: Ditto.
+ * gcc.dg/vect/vect-iv-8a-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-1-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-1a-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-1b-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-2-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-2a-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-2c-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-3-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-3a-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-4a-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-4b-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-4c-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-4d-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-4m-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-fir-lb-big-array.c: Ditto.
+ * gcc.dg/vect/vect-outer-fir-big-array.c: Ditto.
+ * gcc.dg/vect/vect-over-widen-1-big-array.c: Ditto.
+ * gcc.dg/vect/vect-over-widen-2-big-array.c: Ditto.
+ * gcc.dg/vect/vect-over-widen-3-big-array.c: Ditto.
+ * gcc.dg/vect/vect-over-widen-4-big-array.c: Ditto.
+ * gcc.dg/vect/vect-reduc-1char-big-array.c: Ditto.
+ * gcc.dg/vect/vect-reduc-2char-big-array.c: Ditto.
+ * gcc.dg/vect/vect-reduc-pattern-1b-big-array.c: Ditto.
+ * gcc.dg/vect/vect-reduc-pattern-1c-big-array.c: Ditto.
+ * gcc.dg/vect/vect-reduc-pattern-2b-big-array.c: Ditto.
+ * gcc.dg/vect/vect-shift-2-big-array.c: Ditto.
+ * gcc.dg/vect/vect-strided-a-u8-i8-gap2-big-array.c: Ditto.
+ * gcc.dg/vect/vect-strided-a-u8-i8-gap7-big-array.c: Ditto.
+ * gcc.dg/vect/vect-strided-u8-i8-gap2-big-array.c: Ditto.
+ * gcc.dg/vect/vect-strided-u8-i8-gap4-big-array.c: Ditto.
+ * gcc.dg/vect/vect-strided-u8-i8-gap7-big-array.c: Ditto.
+
2011-12-09 Richard Guenther <rguenther@suse.de>
PR lto/48042
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+volatile int y = 0;
+
+int
+main1 ()
+{
+ int i;
+ unsigned short out[N*8];
+ unsigned short in[N*8];
+ unsigned int in2[N*8];
+ unsigned int out2[N*8];
+
+ for (i = 0; i < N*8; i++)
+ {
+ in[i] = in2[i] = i;
+ if (y) /* Avoid vectorization. */
+ abort ();
+ }
+
+ /* Induction is not SLPable yet. */
+ for (i = 0; i < N; i++)
+ {
+ out[i*8] = in[i*8] + i;
+ out[i*8 + 1] = in[i*8 + 1] + i;
+ out[i*8 + 2] = in[i*8 + 2] + i;
+ out[i*8 + 3] = in[i*8 + 3] + i;
+ out[i*8 + 4] = in[i*8 + 4] + i;
+ out[i*8 + 5] = in[i*8 + 5] + i;
+ out[i*8 + 6] = in[i*8 + 6] + i;
+ out[i*8 + 7] = in[i*8 + 7] + i;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (out[i*8] != in[i*8] + i
+ || out[i*8 + 1] != in[i*8 + 1] + i
+ || out[i*8 + 2] != in[i*8 + 2] + i
+ || out[i*8 + 3] != in[i*8 + 3] + i
+ || out[i*8 + 4] != in[i*8 + 4] + i
+ || out[i*8 + 5] != in[i*8 + 5] + i
+ || out[i*8 + 6] != in[i*8 + 6] + i
+ || out[i*8 + 7] != in[i*8 + 7] + i)
+ abort ();
+ }
+
+ /* Induction is not SLPable yet and strided group size must be a power of 2
+ to get vectorized. */
+ for (i = 0; i < N/2; i++)
+ {
+ out2[i*12] = in2[i*12] + i;
+ out2[i*12 + 1] = in2[i*12 + 1] + i;
+ out2[i*12 + 2] = in2[i*12 + 2] + i;
+ out2[i*12 + 3] = in2[i*12 + 3] + i;
+ out2[i*12 + 4] = in2[i*12 + 4] + i;
+ out2[i*12 + 5] = in2[i*12 + 5] + i;
+ out2[i*12 + 6] = in2[i*12 + 6] + i;
+ out2[i*12 + 7] = in2[i*12 + 7] + i;
+ out2[i*12 + 8] = in2[i*12 + 8] + i;
+ out2[i*12 + 9] = in2[i*12 + 9] + i;
+ out2[i*12 + 10] = in2[i*12 + 10] + i;
+ out2[i*12 + 11] = in2[i*12 + 11] + i;
+ }
+
+ /* check results: */
+ for (i = 0; i < N/2; i++)
+ {
+ if (out2[i*12] != in2[i*12] + i
+ || out2[i*12 + 1] != in2[i*12 + 1] + i
+ || out2[i*12 + 2] != in2[i*12 + 2] + i
+ || out2[i*12 + 3] != in2[i*12 + 3] + i
+ || out2[i*12 + 4] != in2[i*12 + 4] + i
+ || out2[i*12 + 5] != in2[i*12 + 5] + i
+ || out2[i*12 + 6] != in2[i*12 + 6] + i
+ || out2[i*12 + 7] != in2[i*12 + 7] + i
+ || out2[i*12 + 8] != in2[i*12 + 8] + i
+ || out2[i*12 + 9] != in2[i*12 + 9] + i
+ || out2[i*12 + 10] != in2[i*12 + 10] + i
+ || out2[i*12 + 11] != in2[i*12 + 11] + i)
+ abort ();
+ }
+
+ /* Not power of 2 but SLPable. */
+ for (i = 0; i < N/2; i++)
+ {
+ out2[i*12] = in2[i*12] + 1;
+ out2[i*12 + 1] = in2[i*12 + 1] + 2;
+ out2[i*12 + 2] = in2[i*12 + 2] + 3;
+ out2[i*12 + 3] = in2[i*12 + 3] + 4;
+ out2[i*12 + 4] = in2[i*12 + 4] + 5;
+ out2[i*12 + 5] = in2[i*12 + 5] + 6;
+ out2[i*12 + 6] = in2[i*12 + 6] + 7;
+ out2[i*12 + 7] = in2[i*12 + 7] + 8;
+ out2[i*12 + 8] = in2[i*12 + 8] + 9;
+ out2[i*12 + 9] = in2[i*12 + 9] + 10;
+ out2[i*12 + 10] = in2[i*12 + 10] + 11;
+ out2[i*12 + 11] = in2[i*12 + 11] + 12;
+ }
+
+ /* check results: */
+ for (i = 0; i < N/2; i++)
+ {
+ if (out2[i*12] != in2[i*12] + 1
+ || out2[i*12 + 1] != in2[i*12 + 1] + 2
+ || out2[i*12 + 2] != in2[i*12 + 2] + 3
+ || out2[i*12 + 3] != in2[i*12 + 3] + 4
+ || out2[i*12 + 4] != in2[i*12 + 4] + 5
+ || out2[i*12 + 5] != in2[i*12 + 5] + 6
+ || out2[i*12 + 6] != in2[i*12 + 6] + 7
+ || out2[i*12 + 7] != in2[i*12 + 7] + 8
+ || out2[i*12 + 8] != in2[i*12 + 8] + 9
+ || out2[i*12 + 9] != in2[i*12 + 9] + 10
+ || out2[i*12 + 10] != in2[i*12 + 10] + 11
+ || out2[i*12 + 11] != in2[i*12 + 11] + 12)
+ abort ();
+ }
+
+
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 64
-volatile int y = 0;
+#define N 8
int
main1 ()
{
int i;
unsigned short out[N*8];
- unsigned short in[N*8];
- unsigned int in2[N*8];
+ unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+ unsigned int in2[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
unsigned int out2[N*8];
- for (i = 0; i < N*8; i++)
- {
- in[i] = in2[i] = i;
- if (y) /* Avoid vectorization. */
- abort ();
- }
-
/* Induction is not SLPable yet. */
for (i = 0; i < N; i++)
{
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+typedef struct {
+ unsigned char a;
+ unsigned char b;
+ unsigned char c;
+ unsigned char d;
+} s;
+
+unsigned char ub[N*2];
+unsigned char uc[N];
+
+volatile int y = 0;
+unsigned char check_diff = 2;
+
+void
+main1 (unsigned char x, unsigned char max_result, unsigned char min_result, s *arr)
+{
+ int i;
+ unsigned char udiff = 2;
+ unsigned char umax = x;
+ unsigned char umin = x;
+ unsigned char ua1[N*2];
+ s *pIn = arr;
+ s out[N];
+
+ for (i = 0; i < N; i++) {
+ udiff += (unsigned char) (ub[i] - uc[i]);
+
+ ua1[2*i+1] = ub[2*i+1];
+ ua1[2*i] = ub[2*i];
+
+ out[i].d = pIn->d - 1;
+ out[i].b = pIn->b - 4;
+ out[i].c = pIn->c - 8;
+ out[i].a = pIn->a - 3;
+
+ pIn++;
+ }
+
+ for (i = 0; i < N; i++) {
+ if (ua1[2*i] != ub[2*i]
+ || ua1[2*i+1] != ub[2*i+1]
+ || out[i].a != arr[i].a - 3
+ || out[i].b != arr[i].b - 4
+ || out[i].c != arr[i].c - 8
+ || out[i].d != arr[i].d - 1)
+ abort ();
+ }
+
+ /* check results: */
+ if (udiff != check_diff)
+ abort ();
+}
+
+int main (void)
+{
+ int i;
+ s arr[N];
+
+ check_diff = 2;
+ ub[0] = uc[0] = 1;
+ for (i = 1; i < N; i++) {
+ ub[i] = (i%5 == 0)?i*3:i;
+ uc[i] = i;
+ check_diff += (unsigned char) (ub[i] - uc[i]);
+ if (y) /* Avoid vectorization. */
+ abort ();
+ }
+ for (; i < 2*N; i++) {
+ ub[i] = 0;
+ if (y) /* Avoid vectorization. */
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ arr[i].a = i + 9;
+ arr[i].b = i * 2 + 10;
+ arr[i].c = 17;
+ arr[i].d = i+34;
+ if (arr[i].a == 178)
+ abort ();
+ }
+ check_vect ();
+
+ main1 (100, 100, 1, arr);
+ main1 (0, 15, 0, arr);
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail { vect_no_align && ilp32 } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { xfail { vect_no_align && ilp32 } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 64
+#define N 16
+#define DIFF 242
typedef struct {
unsigned char a;
unsigned char d;
} s;
-unsigned char ub[N*2];
-unsigned char uc[N];
-
-volatile int y = 0;
-unsigned char check_diff = 2;
+unsigned char ub[N*2] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned char uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
void
main1 (unsigned char x, unsigned char max_result, unsigned char min_result, s *arr)
s out[N];
for (i = 0; i < N; i++) {
- udiff += (unsigned char) (ub[i] - uc[i]);
+ udiff += (unsigned char)(ub[i] - uc[i]);
ua1[2*i+1] = ub[2*i+1];
ua1[2*i] = ub[2*i];
}
/* check results: */
- if (udiff != check_diff)
+ if (udiff != DIFF)
abort ();
}
int i;
s arr[N];
- check_diff = 2;
- ub[0] = uc[0] = 1;
- for (i = 1; i < N; i++) {
- ub[i] = (i%5 == 0)?i*3:i;
- uc[i] = i;
- check_diff += (unsigned char) (ub[i] - uc[i]);
- if (y) /* Avoid vectorization. */
- abort ();
- }
- for (; i < 2*N; i++) {
- ub[i] = 0;
- if (y) /* Avoid vectorization. */
- abort ();
- }
-
for (i = 0; i < N; i++)
{
arr[i].a = i + 9;
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 96
+
+unsigned short in[N*8];
+volatile int y = 0;
+
+int
+main1 ()
+{
+ int i;
+ unsigned short out[N*8];
+
+ for (i = 0; i < N*8; i++)
+ {
+ in[i] = i&63;
+ if (y) /* Avoid vectorization. */
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ out[i*8] = in[i*8];
+ out[i*8 + 1] = in[i*8 + 1];
+ out[i*8 + 2] = in[i*8 + 2];
+ out[i*8 + 3] = in[i*8 + 3];
+ out[i*8 + 4] = in[i*8 + 4];
+ out[i*8 + 5] = in[i*8 + 5];
+ out[i*8 + 6] = in[i*8 + 6];
+ out[i*8 + 7] = in[i*8 + 7];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (out[i*8] != in[i*8]
+ || out[i*8 + 1] != in[i*8 + 1]
+ || out[i*8 + 2] != in[i*8 + 2]
+ || out[i*8 + 3] != in[i*8 + 3]
+ || out[i*8 + 4] != in[i*8 + 4]
+ || out[i*8 + 5] != in[i*8 + 5]
+ || out[i*8 + 6] != in[i*8 + 6]
+ || out[i*8 + 7] != in[i*8 + 7])
+ abort ();
+ }
+
+ for (i = 0; i < N*2; i++)
+ {
+ out[i*4] = in[i*4];
+ out[i*4 + 1] = in[i*4 + 1];
+ out[i*4 + 2] = in[i*4 + 2];
+ out[i*4 + 3] = in[i*4 + 3];
+ }
+
+ /* check results: */
+ for (i = 0; i < N*2; i++)
+ {
+ if (out[i*4] != in[i*4]
+ || out[i*4 + 1] != in[i*4 + 1]
+ || out[i*4 + 2] != in[i*4 + 2]
+ || out[i*4 + 3] != in[i*4 + 3])
+ abort ();
+ }
+
+ for (i = 0; i < N/2; i++)
+ {
+ out[i*16] = in[i*16];
+ out[i*16 + 1] = in[i*16 + 1];
+ out[i*16 + 2] = in[i*16 + 2];
+ out[i*16 + 3] = in[i*16 + 3];
+ out[i*16 + 4] = in[i*16 + 4];
+ out[i*16 + 5] = in[i*16 + 5];
+ out[i*16 + 6] = in[i*16 + 6];
+ out[i*16 + 7] = in[i*16 + 7];
+ out[i*16 + 8] = in[i*16 + 8];
+ out[i*16 + 9] = in[i*16 + 9];
+ out[i*16 + 10] = in[i*16 + 10];
+ out[i*16 + 11] = in[i*16 + 11];
+ out[i*16 + 12] = in[i*16 + 12];
+ out[i*16 + 13] = in[i*16 + 13];
+ out[i*16 + 14] = in[i*16 + 14];
+ out[i*16 + 15] = in[i*16 + 15];
+ }
+
+ /* check results: */
+ for (i = 0; i < N/2; i++)
+ {
+ if (out[i*16] != in[i*16]
+ || out[i*16 + 1] != in[i*16 + 1]
+ || out[i*16 + 2] != in[i*16 + 2]
+ || out[i*16 + 3] != in[i*16 + 3]
+ || out[i*16 + 4] != in[i*16 + 4]
+ || out[i*16 + 5] != in[i*16 + 5]
+ || out[i*16 + 6] != in[i*16 + 6]
+ || out[i*16 + 7] != in[i*16 + 7]
+ || out[i*16 + 8] != in[i*16 + 8]
+ || out[i*16 + 9] != in[i*16 + 9]
+ || out[i*16 + 10] != in[i*16 + 10]
+ || out[i*16 + 11] != in[i*16 + 11]
+ || out[i*16 + 12] != in[i*16 + 12]
+ || out[i*16 + 13] != in[i*16 + 13]
+ || out[i*16 + 14] != in[i*16 + 14]
+ || out[i*16 + 15] != in[i*16 + 15])
+ abort ();
+ }
+
+ /* SLP with unrolling by 8. */
+ for (i = 0; i < N/4; i++)
+ {
+ out[i*9] = in[i*9];
+ out[i*9 + 1] = in[i*9 + 1];
+ out[i*9 + 2] = in[i*9 + 2];
+ out[i*9 + 3] = in[i*9 + 3];
+ out[i*9 + 4] = in[i*9 + 4];
+ out[i*9 + 5] = in[i*9 + 5];
+ out[i*9 + 6] = in[i*9 + 6];
+ out[i*9 + 7] = in[i*9 + 7];
+ out[i*9 + 8] = in[i*9 + 8];
+ }
+
+ /* check results: */
+ for (i = 0; i < N/4; i++)
+ {
+ if (out[i*9] != in[i*9]
+ || out[i*9 + 1] != in[i*9 + 1]
+ || out[i*9 + 2] != in[i*9 + 2]
+ || out[i*9 + 3] != in[i*9 + 3]
+ || out[i*9 + 4] != in[i*9 + 4]
+ || out[i*9 + 5] != in[i*9 + 5]
+ || out[i*9 + 6] != in[i*9 + 6]
+ || out[i*9 + 7] != in[i*9 + 7]
+ || out[i*9 + 8] != in[i*9 + 8])
+ abort ();
+ }
+
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 4 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 96
+#define N 12
-unsigned short in[N*8];
-volatile int y = 0;
+unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
int
main1 ()
int i;
unsigned short out[N*8];
- for (i = 0; i < N*8; i++)
- {
- in[i] = i&63;
- if (y) /* Avoid vectorization. */
- abort ();
- }
-
for (i = 0; i < N; i++)
{
out[i*8] = in[i*8];
return 0;
}
-/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 4 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" } } */
/* { dg-final { cleanup-tree-dump "vect" } } */
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned short in[N*8];
+unsigned short in2[N*8];
+volatile int y = 0;
+
+int
+main1 ()
+{
+ int i;
+ unsigned short out[N*8];
+ unsigned short out2[N*8];
+
+ for (i = 0; i < N*8; i++)
+ {
+ in[i] = in2[i] = i;
+ if (y) /* Avoid vectorization. */
+ abort ();
+ }
+
+ /* SLP with unrolling by 8. */
+ for (i = 0; i < N; i++)
+ {
+ out[i*3] = in[i*3] + 5;
+ out[i*3 + 1] = in[i*3 + 1] + 6;
+ out[i*3 + 2] = in[i*3 + 2] + 16;
+
+ out2[i*5] = in2[i*5] + 2;
+ out2[i*5 + 1] = in2[i*5 + 1] + 2;
+ out2[i*5 + 2] = in2[i*5 + 2] + 1;
+ out2[i*5 + 3] = in2[i*5 + 3] + 3;
+ out2[i*5 + 4] = in2[i*5 + 4] + 13;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (out[i*3] != in[i*3] + 5
+ || out[i*3 + 1] != in[i*3 + 1] + 6
+ || out[i*3 + 2] != in[i*3 + 2] + 16
+ || out2[i*5] != in2[i*5] + 2
+ || out2[i*5 + 1] != in2[i*5 + 1] + 2
+ || out2[i*5 + 2] != in2[i*5 + 2] + 1
+ || out2[i*5 + 3] != in2[i*5 + 3] + 3
+ || out2[i*5 + 4] != in2[i*5 + 4] + 13)
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 64
+#define N 8
-unsigned short in[N*8];
-unsigned short in2[N*8];
-volatile int y = 0;
+unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
+unsigned short in2[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
int
main1 ()
unsigned short out[N*8];
unsigned short out2[N*8];
- for (i = 0; i < N*8; i++)
- {
- in[i] = in2[i] = i;
- if (y) /* Avoid vectorization. */
- abort ();
- }
-
/* SLP with unrolling by 8. */
for (i = 0; i < N; i++)
{
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+volatile int y = 0;
+
+int
+main1 ()
+{
+ int i;
+ unsigned short out[N*8];
+ unsigned short in[N*8];
+ unsigned int ia[N*2];
+
+ for (i = 0; i < N*8; i++)
+ {
+ in[i] = i;
+ if (y) /* Avoid vectorization. */
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ out[i*8] = in[i*8];
+ out[i*8 + 1] = in[i*8 + 1];
+ out[i*8 + 2] = in[i*8 + 2];
+ out[i*8 + 3] = in[i*8 + 3];
+ out[i*8 + 4] = in[i*8 + 4];
+ out[i*8 + 5] = in[i*8 + 5];
+ out[i*8 + 6] = in[i*8 + 6];
+ out[i*8 + 7] = in[i*8 + 7];
+
+ ia[i] = 7;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (out[i*8] != in[i*8]
+ || out[i*8 + 1] != in[i*8 + 1]
+ || out[i*8 + 2] != in[i*8 + 2]
+ || out[i*8 + 3] != in[i*8 + 3]
+ || out[i*8 + 4] != in[i*8 + 4]
+ || out[i*8 + 5] != in[i*8 + 5]
+ || out[i*8 + 6] != in[i*8 + 6]
+ || out[i*8 + 7] != in[i*8 + 7]
+ || ia[i] != 7)
+ abort ();
+ }
+
+ for (i = 0; i < N*2; i++)
+ {
+ out[i*4] = in[i*4];
+ out[i*4 + 1] = in[i*4 + 1];
+ out[i*4 + 2] = in[i*4 + 2];
+ out[i*4 + 3] = in[i*4 + 3];
+
+ ia[i] = 12;
+ }
+
+ /* check results: */
+ for (i = 0; i < N*2; i++)
+ {
+ if (out[i*4] != in[i*4]
+ || out[i*4 + 1] != in[i*4 + 1]
+ || out[i*4 + 2] != in[i*4 + 2]
+ || out[i*4 + 3] != in[i*4 + 3]
+ || ia[i] != 12)
+ abort ();
+ }
+
+ for (i = 0; i < N/2; i++)
+ {
+ out[i*16] = in[i*16];
+ out[i*16 + 1] = in[i*16 + 1];
+ out[i*16 + 2] = in[i*16 + 2];
+ out[i*16 + 3] = in[i*16 + 3];
+ out[i*16 + 4] = in[i*16 + 4];
+ out[i*16 + 5] = in[i*16 + 5];
+ out[i*16 + 6] = in[i*16 + 6];
+ out[i*16 + 7] = in[i*16 + 7];
+ out[i*16 + 8] = in[i*16 + 8];
+ out[i*16 + 9] = in[i*16 + 9];
+ out[i*16 + 10] = in[i*16 + 10];
+ out[i*16 + 11] = in[i*16 + 11];
+ out[i*16 + 12] = in[i*16 + 12];
+ out[i*16 + 13] = in[i*16 + 13];
+ out[i*16 + 14] = in[i*16 + 14];
+ out[i*16 + 15] = in[i*16 + 15];
+
+ ia[i] = 21;
+ }
+
+ /* check results: */
+ for (i = 0; i < N/2; i++)
+ {
+ if (out[i*16] != in[i*16]
+ || out[i*16 + 1] != in[i*16 + 1]
+ || out[i*16 + 2] != in[i*16 + 2]
+ || out[i*16 + 3] != in[i*16 + 3]
+ || out[i*16 + 4] != in[i*16 + 4]
+ || out[i*16 + 5] != in[i*16 + 5]
+ || out[i*16 + 6] != in[i*16 + 6]
+ || out[i*16 + 7] != in[i*16 + 7]
+ || out[i*16 + 8] != in[i*16 + 8]
+ || out[i*16 + 9] != in[i*16 + 9]
+ || out[i*16 + 10] != in[i*16 + 10]
+ || out[i*16 + 11] != in[i*16 + 11]
+ || out[i*16 + 12] != in[i*16 + 12]
+ || out[i*16 + 13] != in[i*16 + 13]
+ || out[i*16 + 14] != in[i*16 + 14]
+ || out[i*16 + 15] != in[i*16 + 15]
+ || ia[i] != 21)
+ abort ();
+ }
+
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
-volatile int y = 0;
+#define N 16
int
main1 ()
{
int i;
unsigned short out[N*8];
- unsigned short in[N*8];
+ unsigned short in[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
unsigned int ia[N*2];
- for (i = 0; i < N*8; i++)
- {
- in[i] = i;
- if (y) /* Avoid vectorization. */
- abort ();
- }
-
for (i = 0; i < N; i++)
{
out[i*8] = in[i*8];
--- /dev/null
+/* { dg-require-effective-target vect_cond_mixed } */
+#include "tree-vect.h"
+
+#define N 128
+int d[N], e[N], f[N];
+unsigned char k[N];
+float a[N], b[N];
+
+__attribute__((noinline, noclone)) void
+f1 (void)
+{
+ int i;
+ for (i = 0; i < N/4; i++)
+ {
+ k[4*i] = a[4*i] < b[4*i] ? 17 : 0;
+ k[4*i+1] = a[4*i+1] < b[4*i+1] ? 17 : 0;
+ k[4*i+2] = a[4*i+2] < b[4*i+2] ? 17 : 0;
+ k[4*i+3] = a[4*i+3] < b[4*i+3] ? 17 : 0;
+ }
+}
+
+__attribute__((noinline, noclone)) void
+f2 (void)
+{
+ int i;
+ for (i = 0; i < N/2; ++i)
+ {
+ k[2*i] = a[2*i] < b[2*i] ? 0 : 24;
+ k[2*i+1] = a[2*i+1] < b[2*i+1] ? 7 : 4;
+ }
+}
+
+__attribute__((noinline, noclone)) void
+f3 (void)
+{
+ int i;
+ for (i = 0; i < N/2; ++i)
+ {
+ k[2*i] = a[2*i] < b[2*i] ? 51 : 12;
+ k[2*i+1] = a[2*i+1] > b[2*i+1] ? 51 : 12;
+ }
+}
+
+__attribute__((noinline, noclone)) void
+f4 (void)
+{
+ int i;
+ for (i = 0; i < N/2; ++i)
+ {
+ int d0 = d[2*i], e0 = e[2*i];
+ int d1 = d[2*i+1], e1 = e[2*i+1];
+ f[2*i] = a[2*i] >= b[2*i] ? d0 : e0;
+ f[2*i+1] = a[2*i+1] >= b[2*i+1] ? d1 : e1;
+ }
+}
+
+int
+main ()
+{
+ int i;
+
+ check_vect ();
+
+ for (i = 0; i < N; i++)
+ {
+ switch (i % 9)
+ {
+ case 0: asm (""); a[i] = - i - 1; b[i] = i + 1; break;
+ case 1: a[i] = 0; b[i] = 0; break;
+ case 2: a[i] = i + 1; b[i] = - i - 1; break;
+ case 3: a[i] = i; b[i] = i + 7; break;
+ case 4: a[i] = i; b[i] = i; break;
+ case 5: a[i] = i + 16; b[i] = i + 3; break;
+ case 6: a[i] = - i - 5; b[i] = - i; break;
+ case 7: a[i] = - i; b[i] = - i; break;
+ case 8: a[i] = - i; b[i] = - i - 7; break;
+ }
+ d[i] = i;
+ e[i] = 2 * i;
+ }
+
+ f1 ();
+ for (i = 0; i < N; i++)
+ if (k[i] != ((i % 3) == 0 ? 17 : 0))
+ abort ();
+
+ f2 ();
+ for (i = 0; i < N; i++)
+ {
+ switch (i % 9)
+ {
+ case 0:
+ case 6:
+ if (k[i] != ((i/9 % 2) == 0 ? 0 : 7))
+ abort ();
+ break;
+ case 1:
+ case 5:
+ case 7:
+ if (k[i] != ((i/9 % 2) == 0 ? 4 : 24))
+ abort ();
+ break;
+ case 2:
+ case 4:
+ case 8:
+ if (k[i] != ((i/9 % 2) == 0 ? 24 : 4))
+ abort ();
+ break;
+ case 3:
+ if (k[i] != ((i/9 % 2) == 0 ? 7 : 0))
+ abort ();
+ break;
+ }
+ }
+
+ f3 ();
+
+ f4 ();
+ for (i = 0; i < N; i++)
+ if (f[i] != ((i % 3) == 0 ? e[i] : d[i]))
+ abort ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
/* { dg-require-effective-target vect_cond_mixed } */
#include "tree-vect.h"
-#define N 128
+#define N 32
int d[N], e[N], f[N];
unsigned char k[N];
float a[N], b[N];
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 144
+
+struct s
+{
+ int a;
+ int b;
+ int c;
+};
+
+char in[N*3];
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+ int i;
+ struct s out[N];
+
+ for (i = 0; i < N; i++)
+ {
+ in[i] = i&127;
+ if (y) /* Avoid vectorization. */
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ out[i].a = (int) in[i*3] + 1;
+ out[i].b = (int) in[i*3 + 1] + 2;
+ out[i].c = (int) in[i*3 + 2] + 3;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (out[i].a != (int) in[i*3] + 1
+ || out[i].b != (int) in[i*3 + 1] + 2
+ || out[i].c != (int) in[i*3 + 2] + 3)
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 144
+#define N 18
struct s
{
int c;
};
-char in[N*3];
-volatile int y = 0;
+char in[N*3] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53};
__attribute__ ((noinline)) int
main1 ()
int i;
struct s out[N];
- for (i = 0; i < N; i++)
- {
- in[i] = i&127;
- if (y) /* Avoid vectorization. */
- abort ();
- }
-
for (i = 0; i < N; i++)
{
out[i].a = (int) in[i*3] + 1;
--- /dev/null
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_float } */
+
+#define N 128
+
+void fbar (float *);
+void ibar (int *);
+void sbar (short *);
+
+/* multiple loops */
+
+foo (int n)
+{
+ float a[N+1];
+ float b[N];
+ float c[N];
+ float d[N];
+ int ia[N];
+ int ib[N];
+ int ic[N];
+ int i,j;
+ int diff = 0;
+ char cb[N];
+ char cc[N];
+ char image[N][N];
+ char block[N][N];
+
+ /* Vectorizable. */
+ diff = 0;
+ for (i = 0; i < N; i++) {
+ diff += (cb[i] - cc[i]);
+ }
+ ibar (&diff);
+
+
+ /* Vectorizable. */
+ diff = 0;
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j++) {
+ diff += (image[i][j] - block[i][j]);
+ }
+ }
+ ibar (&diff);
+
+
+ /* Vectorizable. */
+ for (i = 0; i < N; i++){
+ a[i] = b[i];
+ }
+ fbar (a);
+
+
+ /* Vectorizable. */
+ for (i = 0; i < N; i++){
+ a[i] = b[i] + c[i] + d[i];
+ }
+ fbar (a);
+
+
+ /* Strided access. Vectorizable on platforms that support load of strided
+ accesses (extract of even/odd vector elements). */
+ for (i = 0; i < N/2; i++){
+ a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
+ d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
+ }
+ fbar (a);
+
+
+ /* Vectorizable. */
+ for (i = 0; i < N; i++){
+ a[i] = b[i] + c[i];
+ d[i] = b[i] + c[i];
+ ia[i] = ib[i] + ic[i];
+ }
+ ibar (ia);
+ fbar (a);
+ fbar (d);
+
+ /* Not vetorizable yet (too conservative dependence test). */
+ for (i = 0; i < N; i++){
+ a[i] = b[i] + c[i];
+ a[i+1] = b[i] + c[i];
+ }
+ fbar (a);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 6 loops" 1 "vect" { target vect_strided2 } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 5 loops" 1 "vect" { xfail vect_strided2 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
/* { dg-require-effective-target vect_int } */
/* { dg-require-effective-target vect_float } */
-#define N 128
+#define N 16
void fbar (float *);
void ibar (int *);
--- /dev/null
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+#include <stdlib.h>
+
+#define N 128
+
+short a[N];
+short d[N];
+
+volatile int y = 0;
+
+int foo ()
+{
+ int i;
+ short b[N];
+ short c[N];
+ for (i = 0; i < N/2; i++)
+ {
+ b[i] = i*3;
+ c[i] = i;
+
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+
+ /* Strided access pattern. */
+ for (i = 0; i < N/2; i++)
+ {
+ a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
+ d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
+ }
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail { ! vect_strided2 } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
/* { dg-do compile } */
/* { dg-require-effective-target vect_int } */
-#include <stdlib.h>
-#define N 128
+#define N 16
short a[N];
short d[N];
-volatile int y = 0;
-
int foo ()
{
int i;
- short b[N];
- short c[N];
- for (i = 0; i < N/2; i++)
- {
- b[i] = i*3;
- c[i] = i;
-
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
+ short b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+ short c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
/* Strided access pattern. */
for (i = 0; i < N/2; i++)
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+struct extraction
+{
+ int a[N][N];
+ int b[N][N];
+};
+
+static int a[N][N];
+static int b[N][N];
+static int c[N][N];
+
+volatile int y;
+
+__attribute__ ((noinline))
+int main1 (int x) {
+ int i,j, off;
+ struct extraction *p;
+ p = (struct extraction *) malloc (sizeof (struct extraction));
+ for (i = 0; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ a[i][j] = (i*7 + j*17)%53;
+ b[i][j] = (i*11+ j*13)%41;
+ if (y)
+ abort (); /* to avoid vectorization. */
+ }
+ }
+ for (i = 0; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ c[i][j] = a[i][j];
+ if (y)
+ abort (); /* to avoid vectorization. */
+ }
+ }
+ for (i = 1; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ off = x + i + j + N+1;
+ if (x + i + j > N*N-1)
+ break;
+ if (off > N*N-1)
+ *(&c[0][0]+x+i+j) = *(&b[0][0] + off - N*N);
+ else
+ *(&c[0][0]+x+i+j) = *(&a[0][0] + off);
+ if (y)
+ abort (); /* to avoid vectorization. */
+ }
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ p->a[i][j] = a[i][j];
+ p->b[i][j] = b[i][j];
+ /* Because Y is volatile, the compiler cannot move this check out
+ of the loop. */
+ if (y)
+ abort (); /* to avoid vectorization. */
+ }
+ }
+
+ /* Vectorizable: distance > number of iterations. */
+ for (i = 1; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ *((int *)p + x + i + j) = *((int *)p + x + i + j + N+1);
+ }
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ if (p->a[i][j] != c[i][j])
+ abort ();
+ }
+ }
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 (N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 16
+#define N 4
struct extraction
{
int b[N][N];
};
-static int a[N][N];
-static int b[N][N];
-static int c[N][N];
+static int a[N][N] = {{1,2,3,11},{4,5,6,12},{7,8,9,13},{34,45,67,83}};
+static int b[N][N] = {{17,28,15,23},{0,2,3,24},{4,31,82,25},{29,31,432,256}};
+static int c[N][N] = {{1,2,3,11},{4,9,13,34},{45,67,83,13},{34,45,67,83}};
volatile int y;
__attribute__ ((noinline))
int main1 (int x) {
- int i,j, off;
+ int i,j;
struct extraction *p;
p = (struct extraction *) malloc (sizeof (struct extraction));
- for (i = 0; i < N; i++)
- {
- for (j = 0; j < N; j++)
- {
- a[i][j] = (i*7 + j*17)%53;
- b[i][j] = (i*11+ j*13)%41;
- if (y)
- abort (); /* to avoid vectorization. */
- }
- }
- for (i = 0; i < N; i++)
- {
- for (j = 0; j < N; j++)
- {
- c[i][j] = a[i][j];
- if (y)
- abort (); /* to avoid vectorization. */
- }
- }
- for (i = 1; i < N; i++)
- {
- for (j = 0; j < N; j++)
- {
- off = x + i + j + N+1;
- if (x + i + j > N*N-1)
- break;
- if (off > N*N-1)
- *(&c[0][0]+x+i+j) = *(&b[0][0] + off - N*N);
- else
- *(&c[0][0]+x+i+j) = *(&a[0][0] + off);
- if (y)
- abort (); /* to avoid vectorization. */
- }
- }
for (i = 0; i < N; i++)
{
/* Because Y is volatile, the compiler cannot move this check out
of the loop. */
if (y)
- abort (); /* to avoid vectorization. */
+ abort (); /* to avoid vectorization */
}
}
{
for (j = 0; j < N; j++)
{
- *((int *)p + x + i + j) = *((int *)p + x + i + j + N+1);
+ *((int *)p + x + i + j) = *((int *)p + x + i + j + 5);
}
}
for (j = 0; j < N; j++)
{
if (p->a[i][j] != c[i][j])
- abort ();
+ abort();
}
}
return 0;
}
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { target vect_no_align } } } */
/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 0 "vect" } } */
/* { dg-final { cleanup-tree-dump "vect" } } */
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+char cb[N];
+char cc[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+ int i;
+ int diff = 0;
+ int check_diff = 0;
+ for (i = 0; i < N; i++) {
+ cb[i] = i + 2;
+ cc[i] = i + 1;
+ check_diff += (cb[i] - cc[i]);
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+
+ /* Cross-iteration cycle. */
+ diff = 0;
+ for (i = 0; i < N; i++) {
+ diff += (cb[i] - cc[i]);
+ }
+
+ /* Check results. */
+ if (diff != check_diff)
+ abort ();
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
-char cb[N];
-char cc[N];
-
-volatile int y = 0;
+char cb[N] = {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17};
+char cc[N] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
__attribute__ ((noinline)) int
main1 (void)
{
int i;
int diff = 0;
- int check_diff = 0;
- for (i = 0; i < N; i++) {
- cb[i] = i + 2;
- cc[i] = i + 1;
- check_diff += (cb[i] - cc[i]);
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
/* Cross-iteration cycle. */
diff = 0;
}
/* Check results. */
- if (diff != check_diff)
- abort ();
+ if (diff != 16)
+ abort();
return 0;
}
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ int i;
+ int a[N];
+ int b[N];
+
+ for (i = 0; i <N; i++)
+ {
+ b[i] = i*3;
+ if (y)
+ abort ();
+ }
+
+ /* Not vectorizable yet (reverse access and forward access). */
+ for (i = N; i > 0; i--)
+ {
+ a[N-i] = b[i-1];
+ }
+
+ /* check results: */
+ for (i = 0; i <N; i++)
+ {
+ if (a[i] != b[N-1-i])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_perm && vect_hw_misalign } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
-
-volatile int y = 0;
+#define N 16
__attribute__ ((noinline))
int main1 ()
{
int i;
int a[N];
- int b[N];
-
- for (i = 0; i <N; i++)
- {
- b[i] = i*3;
- if (y)
- abort ();
- }
+ int b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
/* Not vectorizable yet (reverse access and forward access). */
for (i = N; i > 0; i--)
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+char cb[N];
+char ca[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ int i;
+
+ for (i = 0; i < N; i++)
+ {
+ cb[i] = i*3;
+ /* To avoid vectorization. */
+ if (y)
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ ca[i] = cb[i];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (ca[i] != cb[i])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
-char cb[N];
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
char ca[N];
-volatile int y = 0;
-
__attribute__ ((noinline))
int main1 ()
{
int i;
- for (i = 0; i < N; i++)
- {
- cb[i] = i*3;
- /* To avoid vectorization. */
- if (y)
- abort ();
- }
-
for (i = 0; i < N; i++)
{
ca[i] = cb[i];
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+struct t{
+ int k[N];
+ int l;
+};
+
+struct s{
+ char a; /* aligned */
+ char b[N-1]; /* unaligned (offset 1B) */
+ char c[N]; /* aligned (offset NB) */
+ struct t d; /* aligned (offset 2NB) */
+ struct t e; /* unaligned (offset 2N+4N+4 B) */
+};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ int i;
+ struct s tmp;
+
+ /* unaligned */
+ for (i = 0; i < N/2; i++)
+ {
+ tmp.b[i] = 5;
+ }
+
+ /* check results: */
+ for (i = 0; i <N/2; i++)
+ {
+ if (tmp.b[i] != 5)
+ abort ();
+ }
+
+ /* aligned */
+ for (i = 0; i < N/2; i++)
+ {
+ tmp.c[i] = 6;
+ }
+
+ /* check results: */
+ for (i = 0; i <N/2; i++)
+ {
+ if (tmp.c[i] != 6)
+ abort ();
+ }
+
+ /* aligned */
+ for (i = 0; i < N/2; i++)
+ {
+ tmp.d.k[i] = 7;
+ }
+
+ /* check results: */
+ for (i = 0; i <N/2; i++)
+ {
+ if (tmp.d.k[i] != 7)
+ abort ();
+ }
+
+ /* unaligned */
+ for (i = 0; i < N/2; i++)
+ {
+ tmp.e.k[i] = 8;
+ }
+
+ /* check results: */
+ for (i = 0; i <N/2; i++)
+ {
+ if (tmp.e.k[i] != 8)
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 256
+#define N 32
struct t{
int k[N];
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ struct {
+ char ca[N];
+ } s;
+ int i;
+
+ for (i = 0; i < N; i++)
+ {
+ s.ca[i] = 5;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (s.ca[i] != 5)
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
__attribute__ ((noinline))
int main1 ()
--- /dev/null
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+struct test {
+ char ca[N];
+};
+
+extern struct test s;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ int i;
+
+ for (i = 0; i < N; i++)
+ {
+ s.ca[i] = 5;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (s.ca[i] != 5)
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ return main1 ();
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { target vector_alignment_reachable } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target { {! vector_alignment_reachable} && {! vect_hw_misalign} } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
struct test {
char ca[N];
};
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+struct {
+ char ca[N];
+} s;
+char cb[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ int i;
+
+ for (i = 0; i < N; i++)
+ {
+ cb[i] = i*3;
+ /* To avoid vectorization. */
+ if (y)
+ abort ();
+ }
+ for (i = 0; i < N; i++)
+ {
+ s.ca[i] = cb[i];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (s.ca[i] != cb[i])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
struct {
char ca[N];
} s;
-char cb[N];
-
-volatile int y = 0;
-
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+
__attribute__ ((noinline))
int main1 ()
{
int i;
- for (i = 0; i < N; i++)
- {
- cb[i] = i*3;
- /* To avoid vectorization. */
- if (y)
- abort ();
- }
for (i = 0; i < N; i++)
{
s.ca[i] = cb[i];
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ union {
+ unsigned char a[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+ unsigned char b[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+ } s;
+ int i;
+
+ /* Initialization. */
+ for (i = 0; i < N; i++)
+ {
+ s.b[i] = i;
+ }
+
+ /* Dependence analysis fails cause s.a and s.b may overlap.
+ Use runtime aliasing test with versioning. */
+ for (i = 0; i < N; i++)
+ {
+ s.a[i] = s.b[i] + 1;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (s.a[i] != i + 1)
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { xfail { ia64-*-* sparc*-*-* } } } } */
+/* { dg-final { scan-tree-dump-times "can't determine dependence between" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
__attribute__ ((noinline))
int main1 ()
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ int i;
+ struct {
+ char ca[N];
+ char cb[N];
+ } s;
+
+
+ for (i = 0; i < N; i++)
+ {
+ s.cb[i] = 3*i;
+ __asm__ volatile ("");
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ s.ca[i] = s.cb[i];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (s.ca[i] != s.cb[i])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
__attribute__ ((noinline))
int main1 ()
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+float results1[N];
+float results2[N];
+float a[N] = {0};
+float e[N] = {0};
+float b[N];
+float c[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ int i;
+
+ for (i=0; i<N; i++)
+ {
+ b[i] = i*3;
+ c[i] = i;
+ results1[i] = 0;
+ results2[i] = 0;
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+ for (i=0; i<N/2; i++)
+ {
+ results1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+ results2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+
+ for (i = 0; i < N/2; i++)
+ {
+ a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+ e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+ }
+
+ /* check results: */
+ for (i=0; i<N; i++)
+ {
+ if (a[i] != results1[i] || e[i] != results2[i])
+ abort ();
+ }
+
+
+ for (i = 1; i <=N-4; i++)
+ {
+ a[i+3] = b[i-1];
+ }
+
+ /* check results: */
+ for (i = 1; i <=N-4; i++)
+ {
+ if (a[i+3] != b[i-1])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
-float results1[N];
-float results2[N];
+float results1[N] = {192.00,240.00,288.00,336.00,384.00,432.00,480.00,528.00,0.00};
+float results2[N] = {0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,54.00,120.00,198.00,288.00,390.00,504.00,630.00};
float a[N] = {0};
float e[N] = {0};
-float b[N];
-float c[N];
-
-volatile int y = 0;
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
__attribute__ ((noinline))
int main1 ()
{
int i;
- for (i=0; i<N; i++)
- {
- b[i] = i*3;
- c[i] = i;
- results1[i] = 0;
- results2[i] = 0;
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
- for (i=0; i<N/2; i++)
- {
- results1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
- results2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
-
for (i = 0; i < N/2; i++)
{
a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+int ic[N*2];
+int ib[N];
+
+#define ia (ic+N)
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ int i, j;
+
+ for (i = 0; i < N; i++)
+ {
+ ib[i] = i*3;
+ if (y)
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ ia[i] = ib[i];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (ia[i] != ib[i])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
int ic[N*2];
-int ib[N];
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
#define ia (ic+N)
-volatile int y = 0;
-
__attribute__ ((noinline))
int main1 ()
{
int i, j;
- for (i = 0; i < N; i++)
- {
- ib[i] = i*3;
- if (y)
- abort ();
- }
-
for (i = 0; i < N; i++)
{
ia[i] = ib[i];
for (i = 0; i < N; i++)
{
if (ia[i] != ib[i])
- abort ();
+ abort();
}
return 0;
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+/* Check handling of accesses for which the "initial condition" -
+ the expression that represents the first location accessed - is
+ more involved than just an ssa_name. */
+
+float a[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float b[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0};
+float c[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 7.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5};
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+main1 (float *__restrict__ pa, float * __restrict__ pb, float * __restrict__ pc)
+{
+ int i;
+ float *q = pb + 4;
+
+ for (i = 0; i < N; i++)
+ {
+ b[i] = i;
+ c[i] = 0.5 + i;
+ if (y)
+ abort ();
+ }
+ for (; i < N+4; i++)
+ {
+ b[i] = i;
+ if (y)
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ pa[i] = q[i] * pc[i];
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ if (pa[i] != q[i] * pc[i])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 (a, b, c);
+
+ return 0;
+}
+
+/* Xfail until handling restrict is refined. See pr29145. */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* Uncomment when this testcase gets vectorized again:
+ dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 3 "vect" { target vect_no_align } }
+ dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } }
+ dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail vect_no_align } }
+*/
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
/* Check handling of accesses for which the "initial condition" -
the expression that represents the first location accessed - is
float b[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0};
float c[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 7.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5};
-volatile int y = 0;
-
__attribute__ ((noinline)) int
main1 (float *__restrict__ pa, float * __restrict__ pb, float * __restrict__ pc)
{
int i;
float *q = pb + 4;
- for (i = 0; i < N; i++)
- {
- b[i] = i;
- c[i] = 0.5 + i;
- if (y)
- abort ();
- }
- for (; i < N+4; i++)
- {
- b[i] = i;
- if (y)
- abort ();
- }
-
for (i = 0; i < N; i++)
{
pa[i] = q[i] * pc[i];
for (i = 0; i < N; i++)
{
if (pa[i] != q[i] * pc[i])
- abort ();
+ abort();
}
return 0;
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 120
+#define OFF 8
+
+/* Check handling of accesses for which the "initial condition" -
+ the expression that represents the first location accessed - is
+ more involved than just an ssa_name. */
+
+int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17};
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 (int *ib)
+{
+ int i;
+ int ia[N];
+
+ for (i = OFF; i < N+OFF; i++)
+ {
+ ib[i] = ib[i%OFF]*(i/OFF);
+ if (y)
+ abort ();
+ }
+ for (i = 0; i < N; i++)
+ {
+ ia[i] = ib[i+OFF];
+ }
+
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (ia[i] != ib[i+OFF])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 (ib);
+ return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 120
+#define N 8
#define OFF 8
/* Check handling of accesses for which the "initial condition" -
the expression that represents the first location accessed - is
more involved than just an ssa_name. */
-int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17};
-
-volatile int y = 0;
+int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 14, 22, 26, 34};
__attribute__ ((noinline))
int main1 (int *ib)
int i;
int ia[N];
- for (i = OFF; i < N+OFF; i++)
- {
- ib[i] = ib[i%OFF]*(i/OFF);
- if (y)
- abort ();
- }
for (i = 0; i < N; i++)
{
ia[i] = ib[i+OFF];
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 124
+#define OFF 4
+
+/* Check handling of accesses for which the "initial condition" -
+ the expression that represents the first location accessed - is
+ more involved than just an ssa_name. */
+
+int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17};
+int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17};
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 (int *pib)
+{
+ int i;
+ int ia[N+OFF];
+ for (i = OFF; i < N+OFF; i++)
+ {
+ ib[i] = ib[i%8]*(i/8);
+ ic[i] = ic[i%8]*(i/8);
+ if (y)
+ abort ();
+ }
+
+ for (i = OFF; i < N; i++)
+ {
+ ia[i] = pib[i - OFF];
+ }
+
+
+ /* check results: */
+ for (i = OFF; i < N; i++)
+ {
+ if (ia[i] != pib[i - OFF])
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ ia[i] = pib[i - OFF];
+ }
+
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (ia[i] != pib[i - OFF])
+ abort ();
+ }
+
+ for (i = OFF; i < N; i++)
+ {
+ ia[i] = ic[i - OFF];
+ }
+
+
+ /* check results: */
+ for (i = OFF; i < N; i++)
+ {
+ if (ia[i] != ic[i - OFF])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 (&ib[OFF]);
+ return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 124
+#define N 24
#define OFF 4
/* Check handling of accesses for which the "initial condition" -
the expression that represents the first location accessed - is
more involved than just an ssa_name. */
-int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17};
-int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17};
-
-volatile int y = 0;
+int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
__attribute__ ((noinline))
int main1 (int *pib)
{
int i;
int ia[N+OFF];
- for (i = OFF; i < N+OFF; i++)
- {
- ib[i] = ib[i%8]*(i/8);
- ic[i] = ic[i%8]*(i/8);
- if (y)
- abort ();
- }
for (i = OFF; i < N; i++)
{
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+float fa[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float fb[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float fc[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+/* Check handling of accesses for which the "initial condition" -
+ the expression that represents the first location accessed - is
+ more involved than just an ssa_name. */
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+main1 (float * __restrict__ pa, float * __restrict__ pb, float *__restrict__ pc)
+{
+ int i;
+ float *q = pb + 4;
+ for (i = 0; i < N; i++)
+ {
+ fb[i] = i;
+ fc[i] = 0.5+i;
+ if (y)
+ abort ();
+ }
+ for (; i < N+4; i++)
+ {
+ fb[i] = i;
+ if (y)
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ pa[i] = q[i] * pc[i];
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ if (pa[i] != q[i] * pc[i])
+ abort ();
+ }
+
+ return 0;
+}
+
+
+int main (void)
+{
+ check_vect ();
+
+ main1 (fa, fb, fc);
+
+ return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the
+ all three accesses (peeling to align the store will not force the
+ two loads to be aligned). */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* Uncomment when this testcase gets vectorized again:
+ dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } }
+ dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail vect_no_align } }
+ dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" { target vect_no_align } }
+*/
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
float fa[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
-float fb[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
-float fc[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float fb[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0};
+float fc[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 7.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5};
/* Check handling of accesses for which the "initial condition" -
the expression that represents the first location accessed - is
more involved than just an ssa_name. */
-volatile int y = 0;
-
__attribute__ ((noinline)) int
main1 (float * __restrict__ pa, float * __restrict__ pb, float *__restrict__ pc)
{
int i;
float *q = pb + 4;
- for (i = 0; i < N; i++)
- {
- fb[i] = i;
- fc[i] = 0.5+i;
- if (y)
- abort ();
- }
- for (; i < N+4; i++)
- {
- fb[i] = i;
- if (y)
- abort ();
- }
for (i = 0; i < N; i++)
{
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline))
+int main1 (int *a)
+{
+ int i, j, k;
+ int b[N];
+
+ for (i = 0; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ k = i + N;
+ a[j] = k;
+ }
+ b[i] = k;
+ }
+
+
+ for (j = 0; j < N; j++)
+ if (a[j] != i + N - 1)
+ abort ();
+
+ for (j = 0; j < N; j++)
+ if (b[j] != j + N)
+ abort ();
+
+ return 0;
+}
+
+int main (void)
+{
+ int a[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+ check_vect ();
+
+ main1 (a);
+
+ return 0;
+}
+
+/* Fails for targets that don't vectorize PLUS (e.g alpha). */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
__attribute__ ((noinline))
int main1 (int *a)
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+struct tmp_struct
+{
+ int x;
+ int y[N];
+};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ int i, *q;
+ struct tmp_struct tmp, *p;
+
+ p = &tmp;
+ q = p->y;
+
+ for (i = 0; i < N; i++)
+ {
+ *q++ = 5;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (p->y[i] != 5)
+ {
+ abort ();
+ }
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
struct tmp_struct
{
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+char x[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+char cb[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+ struct {
+ char *p;
+ char *q;
+ } s;
+ int i;
+ for (i = 0; i < N; i++)
+ {
+ cb[i] = i*3;
+ if (y)
+ abort ();
+ }
+
+ /* Check that datarefs analysis can determine that the access via pointer
+ s.p is based off array x, which enables us to antialias this access from
+ the access to array cb. */
+ s.p = x;
+ for (i = 0; i < N; i++)
+ {
+ s.p[i] = cb[i];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (s.p[i] != cb[i])
+ abort ();
+ }
+
+ /* Check that datarefs analysis can determine that the access via pointer
+ s.p is based off array x, and that the access via pointer s.q is based off
+ array cb, which enables us to antialias these two accesses. */
+ s.q = cb;
+ for (i = 0; i < N; i++)
+ {
+ s.p[i] = s.q[i];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (s.p[i] != s.q[i])
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
char x[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
-char cb[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
-
-volatile int y = 0;
+char cb[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
__attribute__ ((noinline))
int main1 ()
char *q;
} s;
int i;
- for (i = 0; i < N; i++)
- {
- cb[i] = i*3;
- if (y)
- abort ();
- }
/* Check that datarefs analysis can determine that the access via pointer
s.p is based off array x, which enables us to antialias this access from
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DOT16( a, b) ( a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3] + \
+ a[4]*b[4] + a[5]*b[5] + a[6]*b[6] + a[7]*b[7] + \
+ a[8]*b[8] + a[9]*b[9] + a[10]*b[10] + a[11]*b[11] + \
+ a[12]*b[12] + a[13]*b[13] + a[14]*b[14] + a[15]*b[15])
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 (int ia[][N])
+{
+ int i, j;
+ int ib[N] = {0,3,6,9};
+ int ic[N][N];
+
+ for (i = 0; i < N; i++)
+ {
+ ic[0][i] = DOT16 (ia[i], ib);
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (ic[0][i] != DOT16 (ia[i], ib))
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ int ia[N][N];
+ int i,j;
+ for (i = 0; i < N; i++)
+ for (j = 0; j < N; j++)
+ {
+ ia[i][j] = i + j + 1;
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+
+ check_vect ();
+
+ return main1 (ia);
+}
+
+/* Needs interleaving support. */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided4 } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { xfail vect_strided4 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 16
-#define DOT16( a, b) ( a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3] + \
- a[4]*b[4] + a[5]*b[5] + a[6]*b[6] + a[7]*b[7] + \
- a[8]*b[8] + a[9]*b[9] + a[10]*b[10] + a[11]*b[11] + \
- a[12]*b[12] + a[13]*b[13] + a[14]*b[14] + a[15]*b[15])
-
-volatile int y = 0;
+#define N 4
+#define DOT4( a, b ) ( a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3] )
__attribute__ ((noinline))
int main1 (int ia[][N])
for (i = 0; i < N; i++)
{
- ic[0][i] = DOT16 (ia[i], ib);
+ ic[0][i] = DOT4 (ia[i], ib);
}
/* check results: */
for (i = 0; i < N; i++)
{
- if (ic[0][i] != DOT16 (ia[i], ib))
- abort ();
+ if (ic[0][i] != DOT4 (ia[i], ib))
+ abort();
}
return 0;
int main (void)
{
- int ia[N][N];
- int i,j;
- for (i = 0; i < N; i++)
- for (j = 0; j < N; j++)
- {
- ia[i][j] = i + j + 1;
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
+ int ia[N][N] = {{1,2,3,4},{2,3,5,7},{2,4,6,8},{22,43,55,77}};
check_vect ();
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+int iadd_results[N];
+float fadd_results[N];
+float fmul_results[N];
+float fresults1[N];
+float fresults2[N];
+
+/****************************************************/
+__attribute__ ((noinline))
+void icheck_results (int *a, int *results)
+{
+ int i;
+ for (i = 0; i < N; i++)
+ {
+ if (a[i] != results[i])
+ abort ();
+ }
+}
+
+__attribute__ ((noinline))
+void fcheck_results (float *a, float *results)
+{
+ int i;
+ for (i = 0; i < N; i++)
+ {
+ if (a[i] != results[i])
+ abort ();
+ }
+}
+
+__attribute__ ((noinline)) void
+fbar_mul (float *a)
+{
+ fcheck_results (a, fmul_results);
+}
+
+__attribute__ ((noinline)) void
+fbar_add (float *a)
+{
+ fcheck_results (a, fadd_results);
+}
+
+__attribute__ ((noinline)) void
+ibar_add (int *a)
+{
+ icheck_results (a, iadd_results);
+}
+
+__attribute__ ((noinline)) void
+fbar1 (float *a)
+{
+ fcheck_results (a, fresults1);
+}
+
+__attribute__ ((noinline)) void
+fbar2 (float *a)
+{
+ fcheck_results (a, fresults2);
+}
+
+float a[N];
+float e[N];
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
+int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ia[N];
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+char ca[N];
+short sa[N];
+
+volatile int y = 0;
+
+/* All of the loops below are currently vectorizable, except
+ initialization ones. */
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+ int i,j;
+ /* Initialization. */
+ for (i = 0; i < N; i++)
+ {
+ b[i] = i*3;
+ c[i] = i;
+ d[i] = i*2;
+ ic[i] = i*3;
+ ib[i] = i*3;
+ cb[i] = i*3;
+ fadd_results[i] = b[i] + c[i] + d[i];
+ iadd_results[i] = ib[i] + ic[i];
+ fmul_results[i] = b[i] * c[i];
+ fresults1[i] = 0;
+ fresults2[i] = 0;
+ if (y)
+ abort ();
+ }
+
+ /* Test 1: copy chars. */
+ for (i = 0; i < N; i++)
+ {
+ ca[i] = cb[i];
+ }
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (ca[i] != cb[i])
+ abort ();
+ }
+
+
+ /* Test 2: fp mult. */
+ for (i = 0; i < N; i++)
+ {
+ a[i] = b[i] * c[i];
+ }
+ fbar_mul (a);
+
+
+ /* Test 3: mixed types (int, fp), same nunits in vector. */
+ for (i = 0; i < N; i++)
+ {
+ a[i] = b[i] + c[i] + d[i];
+ e[i] = b[i] + c[i] + d[i];
+ ia[i] = ib[i] + ic[i];
+ }
+ ibar_add (ia);
+ fbar_add (a);
+ fbar_add (e);
+
+ /* Initialization. */
+ for (i = 0; i < N; i++)
+ {
+ fresults1[i] = a[i];
+ fresults2[i] = e[i];
+ if (y)
+ abort ();
+ }
+ for (i = 0; i < N/2; i++)
+ {
+ fresults1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+ fresults2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+ if (y)
+ abort ();
+ }
+ /* Test 4: access with offset. */
+ for (i = 0; i < N/2; i++)
+ {
+ a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+ e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+ }
+ fbar1 (a);
+ fbar2 (e);
+
+
+ /* Test 5: access with offset. */
+ for (i = 1; i <=N-4; i++)
+ {
+ a[i+3] = b[i-1];
+ }
+ /* check results: */
+ for (i = 1; i <=N-4; i++)
+ {
+ if (a[i+3] != b[i-1])
+ abort ();
+ }
+
+
+ /* Test 6 - loop induction with stride != 1. */
+ i = 0;
+ j = 0;
+ while (i < 5*N)
+ {
+ a[j] = c[j];
+ i += 5;
+ j++;
+ }
+ /* check results: */
+ for (i = 0; i <N; i++)
+ {
+ if (a[i] != c[i])
+ abort ();
+ }
+
+
+ /* Test 7 - reverse access. */
+ for (i = N; i > 0; i--)
+ {
+ a[N-i] = d[N-i];
+ }
+ /* check results: */
+ for (i = 0; i <N; i++)
+ {
+ if (a[i] != d[i])
+ abort ();
+ }
+
+
+ /* Tests 8,9,10 - constants. */
+ for (i = 0; i < N; i++)
+ {
+ a[i] = 5.0;
+ }
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (a[i] != 5.0)
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ sa[i] = 5;
+ }
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (sa[i] != 5)
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ ia[i] = ib[i] + 5;
+ }
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (ia[i] != ib[i] + 5)
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 10 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
-int iadd_results[N];
-float fadd_results[N];
-float fmul_results[N];
-float fresults1[N];
-float fresults2[N];
+int iadd_results[N] = {0,6,12,18,24,30,36,42,48,54,60,66,72,78,84,90};
+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};
+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};
+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};
+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};
/****************************************************/
__attribute__ ((noinline))
char ca[N];
short sa[N];
-volatile int y = 0;
-
-/* All of the loops below are currently vectorizable, except
- initialization ones. */
+/* All of the loops below are currently vectorizable. */
__attribute__ ((noinline)) int
main1 ()
{
int i,j;
- /* Initialization. */
- for (i = 0; i < N; i++)
- {
- b[i] = i*3;
- c[i] = i;
- d[i] = i*2;
- ic[i] = i*3;
- ib[i] = i*3;
- cb[i] = i*3;
- fadd_results[i] = b[i] + c[i] + d[i];
- iadd_results[i] = ib[i] + ic[i];
- fmul_results[i] = b[i] * c[i];
- fresults1[i] = 0;
- fresults2[i] = 0;
- if (y)
- abort ();
- }
/* Test 1: copy chars. */
for (i = 0; i < N; i++)
fbar_add (a);
fbar_add (e);
- /* Initialization. */
- for (i = 0; i < N; i++)
- {
- fresults1[i] = a[i];
- fresults2[i] = e[i];
- if (y)
- abort ();
- }
- for (i = 0; i < N/2; i++)
- {
- fresults1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
- fresults2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
- if (y)
- abort ();
- }
+
/* Test 4: access with offset. */
for (i = 0; i < N/2; i++)
{
--- /dev/null
+/* { dg-require-effective-target vect_int_mult } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define K 16
+
+int in[2*K][K] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+int out[K];
+int check_result[K];
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) void
+foo ()
+{
+ int sum;
+ int i, j, k;
+
+ for (k = 0; k < K; k++)
+ {
+ sum = 1;
+ for (j = 0; j < K; j++)
+ for (i = 0; i < K; i++)
+ {
+ sum *= in[i+k][j];
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+ check_result[k] = sum;
+ }
+
+ for (k = 0; k < K; k++)
+ {
+ sum = 1;
+ for (j = 0; j < K; j++)
+ for (i = 0; i < K; i++)
+ sum *= in[i+k][j];
+ out[k] = sum;
+ }
+}
+
+int main ()
+{
+ int i, j, k;
+
+ check_vect ();
+
+ for (i = 0; i < 2*K; i++)
+ for (j = 0; j < K; j++)
+ in[i][j] = (i+2)/3;
+
+ foo ();
+
+ for (k = 0; k < K; k++)
+ if (out[k] != check_result[k])
+ abort ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define K 16
+#define K 4
int in[2*K][K] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
int out[K];
-int check_result[K];
+int check_result[K] = {0,16,256,4096};
-volatile int y = 0;
-
-__attribute__ ((noinline)) void
+__attribute__ ((noinline)) void
foo ()
{
int sum;
for (k = 0; k < K; k++)
{
sum = 1;
- for (j = 0; j < K; j++)
- for (i = 0; i < K; i++)
- {
- sum *= in[i+k][j];
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
- check_result[k] = sum;
- }
-
- for (k = 0; k < K; k++)
- {
- sum = 1;
- for (j = 0; j < K; j++)
+ for (j = 0; j < K; j++)
for (i = 0; i < K; i++)
sum *= in[i+k][j];
out[k] = sum;
return 0;
}
-
+
/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
/* { dg-final { cleanup-tree-dump "vect" } } */
-
+
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline)) int main1 (short X)
+{
+ unsigned char a[N];
+ unsigned short b[N];
+ unsigned int c[N];
+ short myX = X;
+ int i;
+
+ /* vectorization of induction with type conversions. */
+ for (i = 0; i < N; i++)
+ {
+ a[i] = (unsigned char)X;
+ b[i] = X;
+ c[i] = (unsigned int)X;
+ X++;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (a[i] != (unsigned char)myX || b[i] != myX || c[i] != (unsigned int)myX++)
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 (3);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_pack_trunc && vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 26
__attribute__ ((noinline)) int main1 (short X)
{
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline)) int main1 (short X)
+{
+ signed char a[N];
+ short b[N];
+ int c[N];
+ short myX = X;
+ int i;
+
+ /* vectorization of induction with type conversions. */
+ for (i = 0; i < N; i++)
+ {
+ a[i] = (signed char)X;
+ b[i] = X;
+ c[i] = (int)X;
+ X++;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (a[i] != (signed char)myX || b[i] != myX || c[i] != (int)myX++)
+ abort ();
+ }
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 (3);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_pack_trunc && vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 26
__attribute__ ((noinline)) int main1 (short X)
{
--- /dev/null
+/* { dg-do compile } */
+
+#define N 256
+signed short image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+signed short block[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+signed short out[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+/* Can't do outer-loop vectorization because of non-consecutive access. */
+
+void
+foo (){
+ int i,j;
+ int diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < N; j+=8) {
+ diff += (image[i][j] - block[i][j]);
+ }
+ out[i]=diff;
+ }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 1 "vect" { xfail vect_multiple_sizes } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 2 "vect" { target vect_multiple_sizes } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
/* { dg-do compile } */
-#define N 256
+#define N 64
signed short image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
signed short block[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
signed short out[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
--- /dev/null
+/* { dg-do compile } */
+
+#define N 256
+signed short image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+signed short block[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+/* Can't do outer-loop vectorization because of non-consecutive access. */
+
+int
+foo (){
+ int i,j;
+ int diff = 0;
+
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j+=8) {
+ diff += (image[i][j] - block[i][j]);
+ }
+ }
+ return diff;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 1 "vect" { xfail vect_multiple_sizes } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 2 "vect" { target vect_multiple_sizes } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
/* { dg-do compile } */
-#define N 256
+#define N 64
signed short image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
signed short block[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
--- /dev/null
+/* { dg-do compile } */
+
+#define N 160
+signed short image[N][N];
+signed short block[N][N];
+signed short out[N];
+
+/* Outer-loop cannot get vectorized because of non-consecutive access. */
+
+void
+foo (){
+ int i,j;
+ int diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < N; j+=4) {
+ diff += (image[i][j] - block[i][j]);
+ }
+ out[i]=diff;
+ }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 1 "vect" { xfail vect_multiple_sizes } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 2 "vect" { target vect_multiple_sizes } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
/* { dg-do compile } */
-#define N 160
+#define N 40
signed short image[N][N];
signed short block[N][N];
signed short out[N];
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 160
+float image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float out[N];
+
+/* Outer-loop vectorization. */
+
+__attribute__ ((noinline)) void
+foo (){
+ int i,j;
+
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j++) {
+ image[j][i] = j+i;
+ }
+ }
+}
+
+int main (void)
+{
+ check_vect ();
+ int i, j;
+
+ foo ();
+
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j++) {
+ if (image[j][i] != j+i)
+ abort ();
+ }
+ }
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 160
+#define N 40
float image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
float out[N];
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 160
+float image[N][N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+__attribute__ ((noinline)) void
+foo (){
+ int i,j,k;
+
+ for (k=0; k<N; k++) {
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j++) {
+ image[k][j][i] = j+i+k;
+ }
+ }
+ }
+}
+
+int main (void)
+{
+ check_vect ();
+ int i, j, k;
+
+ foo ();
+
+ for (k=0; k<N; k++) {
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j++) {
+ if (image[k][j][i] != j+i+k)
+ abort ();
+ }
+ }
+ }
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 160
+#define N 40
float image[N][N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
__attribute__ ((noinline)) void
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 160
+float image[2*N][2*N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+__attribute__ ((noinline)) void
+foo (){
+ int i,j,k;
+
+ for (k=0; k<N; k++) {
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j+=2) {
+ image[k][j][i] = j+i+k;
+ }
+ }
+ }
+}
+
+int main (void)
+{
+ check_vect ();
+ int i, j, k;
+
+ foo ();
+
+ for (k=0; k<N; k++) {
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j+=2) {
+ if (image[k][j][i] != j+i+k)
+ abort ();
+ }
+ }
+ }
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 160
+#define N 40
float image[2*N][2*N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
__attribute__ ((noinline)) void
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 320
+float image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float out[N];
+
+/* Outer-loop vectoriation. */
+
+__attribute__ ((noinline)) void
+foo (){
+ int i,j;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < N; j++) {
+ diff += image[j][i];
+ }
+ out[i]=diff;
+ }
+}
+
+int main (void)
+{
+ check_vect ();
+ int i, j;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j++) {
+ image[i][j]=i+j;
+ }
+ }
+
+ foo ();
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < N; j++) {
+ diff += image[j][i];
+ }
+ if (out[i] != diff)
+ abort ();
+ }
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 320
+#define N 40
float image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
float out[N];
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 320
+float image[N][N+1] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float out[N];
+
+/* Outer-loop vectorization with misaliged accesses in the inner-loop. */
+
+__attribute__ ((noinline)) void
+foo (){
+ int i,j;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < N; j++) {
+ diff += image[j][i];
+ }
+ out[i]=diff;
+ }
+}
+
+int main (void)
+{
+ check_vect ();
+ int i, j;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+ for (j = 0; j < N; j++) {
+ image[i][j]=i+j;
+ }
+ }
+
+ foo ();
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < N; j++) {
+ diff += image[j][i];
+ }
+ if (out[i] != diff)
+ abort ();
+ }
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 2 "vect" { xfail vect_multiple_sizes } } } */
+/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 3 "vect" { target vect_multiple_sizes } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 320
+#define N 40
float image[N][N+1] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
float out[N];
--- /dev/null
+/* { dg-do compile } */
+
+#define N 512
+#define M 1024
+signed short in[N+M];
+signed short coeff[M];
+signed short out[N];
+
+/* Outer-loop vectorization. */
+
+void
+foo (){
+ int i,j;
+ int diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < M; j+=8) {
+ diff += in[j+i]*coeff[j];
+ }
+ out[i]=diff;
+ }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target { vect_widen_mult_hi_to_si && vect_pack_trunc } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
/* { dg-do compile } */
-#define N 512
-#define M 1024
+#define N 40
+#define M 128
signed short in[N+M];
signed short coeff[M];
signed short out[N];
--- /dev/null
+/* { dg-do compile } */
+
+#define N 320
+#define M 1024
+signed short in[N+M];
+signed short coeff[M];
+int out[N];
+
+/* Outer-loop vectorization. */
+
+void
+foo (){
+ int i,j;
+ int diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < M; j+=8) {
+ diff += in[j+i]*coeff[j];
+ }
+ out[i]=diff;
+ }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
/* { dg-do compile } */
-#define N 320
-#define M 1024
+#define N 40
+#define M 128
signed short in[N+M];
signed short coeff[M];
int out[N];
--- /dev/null
+/* { dg-do compile } */
+
+#define N 320
+#define M 1024
+unsigned short in[N+M];
+unsigned short coeff[M];
+unsigned int out[N];
+
+/* Outer-loop vectorization. */
+
+void
+foo (){
+ int i,j;
+ unsigned short diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < M; j+=8) {
+ diff += in[j+i]*coeff[j];
+ }
+ out[i]=diff;
+ }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target { vect_short_mult && { ! vect_no_align } } } } } */
+/* { dg-final { scan-tree-dump-times "zero step in outer loop." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
/* { dg-do compile } */
-#define N 320
-#define M 1024
+#define N 40
+#define M 128
unsigned short in[N+M];
unsigned short coeff[M];
unsigned int out[N];
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 320
+#define M 1024
+float in[N+M];
+float out[N];
+
+/* Outer-loop vectorization. */
+
+__attribute__ ((noinline)) void
+foo (){
+ int i,j;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < M; j+=4) {
+ diff += in[j+i];
+ }
+ out[i]=diff;
+ }
+}
+
+int main (void)
+{
+ check_vect ();
+ int i, j;
+ float diff;
+
+ for (i = 0; i < N; i++)
+ in[i] = i;
+
+ foo ();
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < M; j+=4) {
+ diff += in[j+i];
+ }
+ if (out[i] != diff)
+ abort ();
+ }
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 320
-#define M 1024
+#define N 40
+#define M 128
float in[N+M];
float out[N];
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 320
+#define M 1024
+unsigned short in[N+M];
+unsigned int out[N];
+
+/* Outer-loop vectorization. */
+/* Not vectorized due to multiple-types in the inner-loop. */
+
+__attribute__ ((noinline)) unsigned int
+foo (){
+ int i,j;
+ unsigned int diff;
+ unsigned int s=0;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < M; j+=8) {
+ diff += in[j+i];
+ }
+ s+=((unsigned short)diff>>3);
+ }
+ return s;
+}
+
+int main (void)
+{
+ int i, j;
+ unsigned int diff;
+ unsigned int s=0,sum=0;
+
+ check_vect ();
+
+ for (i = 0; i < N+M; i++) {
+ in[i] = i;
+ }
+
+ sum=foo ();
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < M; j+=8) {
+ diff += in[j+i];
+ }
+ s += ((unsigned short)diff>>3);
+ }
+
+ if (s != sum)
+ abort ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 320
-#define M 1024
+#define N 40
+#define M 128
unsigned short in[N+M];
unsigned int out[N];
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 80
+#define M 256
+float in[N+M];
+float coeff[M];
+float out[N];
+float fir_out[N];
+
+/* Should be vectorized. Fixed misaligment in the inner-loop. */
+__attribute__ ((noinline))
+void foo (){
+ int i,j,k;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+ out[i] = 0;
+ }
+
+ for (k = 0; k < 4; k++) {
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = k; j < M; j+=4) {
+ diff += in[j+i]*coeff[j];
+ }
+ out[i] += diff;
+ }
+ }
+
+}
+
+/* Vectorized. Changing misalignment in the inner-loop. */
+__attribute__ ((noinline))
+void fir (){
+ int i,j,k;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < M; j++) {
+ diff += in[j+i]*coeff[j];
+ }
+ fir_out[i] = diff;
+ }
+}
+
+
+int main (void)
+{
+ check_vect ();
+ int i, j;
+ float diff;
+
+ for (i = 0; i < M; i++)
+ coeff[i] = i;
+ for (i = 0; i < N+M; i++)
+ in[i] = i;
+
+ foo ();
+ fir ();
+
+ for (i = 0; i < N; i++) {
+ if (out[i] != fir_out[i])
+ abort ();
+ }
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
--- /dev/null
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 80
+#define M 128
+float in[N+M];
+float coeff[M];
+float out[N];
+float fir_out[N];
+
+/* Vectorized. Fixed misaligment in the inner-loop. */
+__attribute__ ((noinline))
+void foo (){
+ int i,j,k;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+ out[i] = 0;
+ }
+
+ for (k = 0; k < 4; k++) {
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ j = k;
+
+ do {
+ diff += in[j+i]*coeff[j];
+ j+=4;
+ } while (j < M);
+
+ out[i] += diff;
+ }
+ }
+
+}
+
+/* Vectorized. Changing misalignment in the inner-loop. */
+__attribute__ ((noinline))
+void fir (){
+ int i,j,k;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+ diff = 0;
+ for (j = 0; j < M; j++) {
+ diff += in[j+i]*coeff[j];
+ }
+ fir_out[i] = diff;
+ }
+}
+
+
+int main (void)
+{
+ check_vect ();
+ int i, j;
+ float diff;
+
+ for (i = 0; i < M; i++)
+ coeff[i] = i;
+ for (i = 0; i < N+M; i++)
+ in[i] = i;
+
+ foo ();
+ fir ();
+
+ for (i = 0; i < N; i++) {
+ if (out[i] != fir_out[i])
+ abort ();
+ }
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 80
-#define M 128
+#define N 40
+#define M 64
float in[N+M];
float coeff[M];
float out[N];
#include <stdarg.h>
#include "tree-vect.h"
-#define N 80
-#define M 256
+#define N 40
+#define M 128
float in[N+M];
float coeff[M];
float out[N];
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 512
+
+/* Modified rgb to rgb conversion from FFmpeg. */
+__attribute__ ((noinline)) void
+foo (unsigned char *src, unsigned char *dst)
+{
+ unsigned char *s = src;
+ unsigned short *d = (unsigned short *)dst;
+ int i;
+
+ for (i = 0; i < N/4; i++)
+ {
+ const int b = *s++;
+ const int g = *s++;
+ const int r = *s++;
+ const int a = *s++;
+ *d = ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5));
+ d++;
+ }
+
+ s = src;
+ d = (unsigned short *)dst;
+ for (i = 0; i < N/4; i++)
+ {
+ const int b = *s++;
+ const int g = *s++;
+ const int r = *s++;
+ const int a = *s++;
+ if (*d != ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5)))
+ abort ();
+ d++;
+ }
+}
+
+int main (void)
+{
+ int i;
+ unsigned char in[N], out[N];
+
+ check_vect ();
+
+ for (i = 0; i < N; i++)
+ {
+ in[i] = i;
+ out[i] = 255;
+ __asm__ volatile ("");
+ }
+
+ foo (in, out);
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_over_widening_pattern: detected" 4 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 512
+#define N 64
/* Modified rgb to rgb conversion from FFmpeg. */
__attribute__ ((noinline)) void
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 512
+
+/* Modified rgb to rgb conversion from FFmpeg. */
+__attribute__ ((noinline)) void
+foo (unsigned char *src, unsigned char *dst)
+{
+ unsigned char *s = src;
+ int *d = (int *)dst;
+ int i;
+
+ for (i = 0; i < N/4; i++)
+ {
+ const int b = *s++;
+ const int g = *s++;
+ const int r = *s++;
+ const int a = *s++;
+ *d = ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5));
+ d++;
+ }
+
+ s = src;
+ d = (int *)dst;
+ for (i = 0; i < N/4; i++)
+ {
+ const int b = *s++;
+ const int g = *s++;
+ const int r = *s++;
+ const int a = *s++;
+ if (*d != ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5)))
+ abort ();
+ d++;
+ }
+}
+
+int main (void)
+{
+ int i;
+ unsigned char in[N], out[N];
+
+ check_vect ();
+
+ for (i = 0; i < N; i++)
+ {
+ in[i] = i;
+ out[i] = 255;
+ __asm__ volatile ("");
+ }
+
+ foo (in, out);
+
+ return 0;
+}
+
+/* Final value stays in int, so no over-widening is detected at the moment. */
+/* { dg-final { scan-tree-dump-times "vect_recog_over_widening_pattern: detected" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 512
+#define N 64
/* Modified rgb to rgb conversion from FFmpeg. */
__attribute__ ((noinline)) void
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+/* Modified rgb to rgb conversion from FFmpeg. */
+__attribute__ ((noinline)) void
+foo (unsigned char *src, unsigned char *dst)
+{
+ unsigned char *s = src;
+ unsigned short *d = (unsigned short *)dst;
+ int i;
+
+ for (i = 0; i < N/4; i++)
+ {
+ const int b = *s++;
+ const int g = *s++;
+ const int r = *s++;
+ const int a = *s++;
+ *d = ((b>>3) | ((g&0xFFC)<<3) | ((r+0xF8)>>8) | (a<<9));
+ d++;
+ }
+
+ s = src;
+ d = (unsigned short *)dst;
+ for (i = 0; i < N/4; i++)
+ {
+ const int b = *s++;
+ const int g = *s++;
+ const int r = *s++;
+ const int a = *s++;
+ if (*d != ((b>>3) | ((g&0xFFC)<<3) | ((r+0xF8)>>8) | (a<<9)))
+ abort ();
+ d++;
+ }
+}
+
+int main (void)
+{
+ int i;
+ unsigned char in[N], out[N];
+
+ check_vect ();
+
+ for (i = 0; i < N; i++)
+ {
+ in[i] = i;
+ out[i] = 255;
+ __asm__ volatile ("");
+ }
+
+ foo (in, out);
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_over_widening_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 64
/* Modified rgb to rgb conversion from FFmpeg. */
__attribute__ ((noinline)) void
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 512
+
+/* Modified rgb to rgb conversion from FFmpeg. */
+__attribute__ ((noinline)) int
+foo (unsigned char *src, unsigned char *dst)
+{
+ unsigned char *s = src;
+ unsigned short *d = (unsigned short *)dst, res;
+ int i, result = 0;
+
+ for (i = 0; i < N/4; i++)
+ {
+ const int b = *s++;
+ const int g = *s++;
+ const int r = *s++;
+ const int a = *s++;
+ res = ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5));
+ *d = res;
+ result += res;
+ d++;
+ }
+
+ s = src;
+ d = (unsigned short *)dst;
+ for (i = 0; i < N/4; i++)
+ {
+ const int b = *s++;
+ const int g = *s++;
+ const int r = *s++;
+ const int a = *s++;
+ if (*d != ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5)))
+ abort ();
+ d++;
+ }
+
+ return result;
+}
+
+int main (void)
+{
+ int i;
+ unsigned char in[N], out[N];
+
+ check_vect ();
+
+ for (i = 0; i < N; i++)
+ {
+ in[i] = i;
+ out[i] = 255;
+ __asm__ volatile ("");
+ }
+
+ foo (in, out);
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_over_widening_pattern: detected" 4 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 512
+#define N 64
/* Modified rgb to rgb conversion from FFmpeg. */
__attribute__ ((noinline)) int
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+unsigned char ub[N];
+unsigned char uc[N];
+unsigned char diff;
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) void
+main1 (unsigned char x, unsigned char max_result, unsigned char min_result)
+{
+ int i;
+ unsigned char udiff = 2;
+ unsigned char umax = x;
+ unsigned char umin = x;
+
+ diff = 2;
+ for (i = 0; i < N; i++) {
+ ub[i] = i;
+ uc[i] = i;
+ if (i%16 == 0)
+ {
+ ub[i] = i+2;
+ diff += 2;
+ }
+ if (uc[i] > max_result)
+ max_result = uc[i];
+ if (uc[i] < min_result)
+ min_result = uc[i];
+
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+ for (i = 0; i < N; i++) {
+ udiff += (unsigned char) (ub[i] - uc[i]);
+ }
+
+ for (i = 0; i < N; i++) {
+ umax = umax < uc[i] ? uc[i] : umax;
+ }
+
+ for (i = 0; i < N; i++) {
+ umin = umin > uc[i] ? uc[i] : umin;
+ }
+
+ /* check results: */
+ if (udiff != diff)
+ abort ();
+ if (umax != max_result)
+ abort ();
+ if (umin != min_result)
+ abort ();
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 (100, 100, 1);
+ main1 (0, 15, 0);
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 256
+#define N 16
+#define DIFF 242
-unsigned char ub[N];
-unsigned char uc[N];
-unsigned char diff;
-
-volatile int y = 0;
+unsigned char ub[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned char uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
__attribute__ ((noinline)) void
main1 (unsigned char x, unsigned char max_result, unsigned char min_result)
unsigned char umax = x;
unsigned char umin = x;
- diff = 2;
- for (i = 0; i < N; i++) {
- ub[i] = i;
- uc[i] = i;
- if (i%16 == 0)
- {
- ub[i] = i+2;
- diff += 2;
- }
- if (uc[i] > max_result)
- max_result = uc[i];
- if (uc[i] < min_result)
- min_result = uc[i];
-
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
for (i = 0; i < N; i++) {
- udiff += (unsigned char) (ub[i] - uc[i]);
+ udiff += (unsigned char)(ub[i] - uc[i]);
}
for (i = 0; i < N; i++) {
}
/* check results: */
- if (udiff != diff)
+ if (udiff != DIFF)
abort ();
if (umax != max_result)
abort ();
}
int main (void)
-{
+{
check_vect ();
-
+
main1 (100, 100, 1);
main1 (0, 15, 0);
return 0;
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+volatile int y = 0;
+
+__attribute__ ((noinline))
+void main1 (signed char x, signed char max_result, signed char min_result)
+{
+ int i;
+ signed char b[N];
+ signed char c[N];
+ signed char check_diff = 2;
+ signed char diff = 2;
+ signed char max = x;
+ signed char min = x;
+
+ check_diff = 2;
+ for (i = 0; i < N; i++) {
+ b[i] = i;
+ c[i] = i;
+ if (i%16 == 0)
+ {
+ c[i] = i + 1;
+ check_diff += 1;
+ }
+ if (c[i] > max_result)
+ max_result = c[i];
+ if (c[i] < min_result)
+ min_result = c[i];
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+
+ for (i = 0; i < N; i++) {
+ diff += (signed char) (c[i] - b[i]);
+ }
+
+ for (i = 0; i < N; i++) {
+ max = max < c[i] ? c[i] : max;
+ }
+
+ for (i = 0; i < N; i++) {
+ min = min > c[i] ? c[i] : min;
+ }
+
+ /* check results: */
+ if (diff != check_diff)
+ abort ();
+ if (max != max_result)
+ abort ();
+ if (min != min_result)
+ abort ();
+}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 (100, 100, 1);
+ main1 (0, 15, 0);
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 256
-volatile int y = 0;
+#define N 16
+#define DIFF 121
__attribute__ ((noinline))
void main1 (signed char x, signed char max_result, signed char min_result)
{
int i;
- signed char b[N];
- signed char c[N];
- signed char check_diff = 2;
+ signed char b[N] = {1,2,3,6,8,10,12,14,16,18,20,22,24,26,28,30};
+ signed char c[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
signed char diff = 2;
signed char max = x;
signed char min = x;
- check_diff = 2;
for (i = 0; i < N; i++) {
- b[i] = i;
- c[i] = i;
- if (i%16 == 0)
- {
- c[i] = i + 1;
- check_diff += 1;
- }
- if (c[i] > max_result)
- max_result = c[i];
- if (c[i] < min_result)
- min_result = c[i];
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
-
- for (i = 0; i < N; i++) {
- diff += (signed char) (c[i] - b[i]);
+ diff += (signed char)(b[i] - c[i]);
}
for (i = 0; i < N; i++) {
}
/* check results: */
- if (diff != check_diff)
+ if (diff != DIFF)
abort ();
if (max != max_result)
abort ();
}
int main (void)
-{
+{
check_vect ();
-
+
main1 (100, 100, 1);
main1 (0, 15, 0);
return 0;
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+unsigned char udata_ch[N];
+#define SUM N*(N-1)
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+foo ()
+{
+ int i;
+ unsigned int intsum = 0;
+
+ for (i = 0; i < N; i++)
+ {
+ udata_ch[i] = i*2;
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+
+ /* widenning sum: sum chars into int. */
+ for (i = 0; i < N; i++)
+ {
+ intsum += udata_ch[i];
+ }
+
+ /* check results: */
+ if (intsum != SUM)
+ abort ();
+
+ return 0;
+}
+
+int
+main (void)
+{
+ check_vect ();
+ return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_sum_qi_to_si || vect_unpack } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { { ! vect_widen_sum_qi_to_si } && { ! vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
-unsigned char udata_ch[N];
-#define SUM N*(N-1)
-
-volatile int y = 0;
+#define N 16
+unsigned char udata_ch[N] =
+ { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
__attribute__ ((noinline)) int
foo ()
int i;
unsigned int intsum = 0;
- for (i = 0; i < N; i++)
- {
- udata_ch[i] = i*2;
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
-
/* widenning sum: sum chars into int. */
for (i = 0; i < N; i++)
{
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+unsigned char udata_ch[N];
+#define SUM N*(N-1)
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+foo ()
+{
+ int i;
+ unsigned short shortsum = 0;
+
+ for (i = 0; i < N; i++)
+ {
+ udata_ch[i] = i*2;
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+
+ /* widenning sum: sum chars into short. */
+ for (i = 0; i < N; i++)
+ {
+ shortsum += udata_ch[i];
+ }
+
+ /* check results: */
+ if (shortsum != SUM)
+ abort ();
+
+ return 0;
+}
+
+int
+main (void)
+{
+ check_vect ();
+ return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_sum_qi_to_hi } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_widen_sum_qi_to_hi } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
-unsigned char udata_ch[N];
-#define SUM N*(N-1)
-
-volatile int y = 0;
+#define N 16
+unsigned char udata_ch[N] =
+ { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
__attribute__ ((noinline)) int
foo ()
int i;
unsigned short shortsum = 0;
- for (i = 0; i < N; i++)
- {
- udata_ch[i] = i*2;
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
-
/* widenning sum: sum chars into short. */
for (i = 0; i < N; i++)
{
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+signed char data_ch[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+foo ()
+{
+ int i;
+ signed int intsum = 0;
+ signed int check_intsum = 0;
+
+ for (i = 0; i < N; i++)
+ {
+ data_ch[i] = i*2;
+ check_intsum += data_ch[i];
+ /* Avoid vectorization. */
+ if (y)
+ abort ();
+ }
+
+ /* widenning sum: sum chars into int. */
+ for (i = 0; i < N; i++)
+ {
+ intsum += data_ch[i];
+ }
+
+ /* check results: */
+ if (intsum != check_intsum)
+ abort ();
+
+ return 0;
+}
+
+int
+main (void)
+{
+ check_vect ();
+ return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_sum_qi_to_si && vect_unpack } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { { ! vect_widen_sum_qi_to_si } && { ! vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
-signed char data_ch[N];
-
-volatile int y = 0;
+#define N 16
+signed char data_ch[N] =
+ { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
__attribute__ ((noinline)) int
foo ()
{
int i;
signed int intsum = 0;
- signed int check_intsum = 0;
-
- for (i = 0; i < N; i++)
- {
- data_ch[i] = i*2;
- check_intsum += data_ch[i];
- /* Avoid vectorization. */
- if (y)
- abort ();
- }
/* widenning sum: sum chars into int. */
for (i = 0; i < N; i++)
}
/* check results: */
- if (intsum != check_intsum)
+ if (intsum != SUM)
abort ();
return 0;
--- /dev/null
+/* { dg-require-effective-target vect_shift } */
+/* { dg-require-effective-target vect_int } */
+/* Check the standard integer types for left and right shifts to see if the
+ compiler replaced a scalar instruction with a vector instruction whether the
+ correct value is generated. */
+
+#ifdef TRACE
+#endif
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#ifndef ALIGN
+#define ALIGN __attribute__((__aligned__(__BIGGEST_ALIGNMENT__)))
+#endif
+
+#ifndef NOINLINE
+#define NOINLINE __attribute__((__noinline__))
+#endif
+
+#ifdef TRACE
+#define TRACE_FUNC(PREFIX, NAME) printf (#PREFIX #NAME "\n")
+#define TRACE_DONE() printf ("done!\n")
+#define TRACE_ABORT(I,E,G) \
+do { \
+ printf ("Element %d, expected 0x%lx, got 0x%lx\n", \
+ I, (long)(E), (long)(G)); \
+ abort (); \
+} while (0)
+
+#else
+#define TRACE_FUNC(PREFIX, A)
+#define TRACE_DONE()
+#define TRACE_ABORT(I,E,G) abort ()
+#endif
+
+#define NAME(A,B) A ## B
+
+#define VECT_TESTS(PREFIX, TYPE, N) \
+ /* Restrict the optimizer from optimizing the setup loops. */ \
+volatile TYPE NAME (PREFIX, zero) = 0; \
+ \
+TYPE NAME (PREFIX, a)[N] ALIGN; \
+TYPE NAME (PREFIX, b)[N] ALIGN; \
+TYPE NAME (PREFIX, c)[N] ALIGN; \
+TYPE NAME (PREFIX, d)[N] ALIGN; \
+ \
+static void NOINLINE \
+NAME (PREFIX, lshift_2) (void) \
+{ \
+ int i; \
+ \
+ TRACE_FUNC (PREFIX, lshift_2); \
+ for (i = 0; i < N; i++) \
+ NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] << 2; \
+} \
+ \
+static void NOINLINE \
+NAME (PREFIX, lshift_var) (int shift) \
+{ \
+ int i; \
+ \
+ TRACE_FUNC (PREFIX, lshift_var); \
+ for (i = 0; i < N; i++) \
+ NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] << shift; \
+} \
+ \
+static void NOINLINE \
+NAME (PREFIX, lshift_vect) (void) \
+{ \
+ int i; \
+ \
+ TRACE_FUNC (PREFIX, lshift_vect); \
+ for (i = 0; i < N; i++) \
+ NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] << NAME (PREFIX, c)[i]; \
+} \
+ \
+static void NOINLINE \
+NAME (PREFIX, rshift_2) (void) \
+{ \
+ int i; \
+ \
+ TRACE_FUNC (PREFIX, rshift_2); \
+ for (i = 0; i < N; i++) \
+ NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] >> 2; \
+} \
+ \
+static void NOINLINE \
+NAME (PREFIX, rshift_var) (int shift) \
+{ \
+ int i; \
+ \
+ TRACE_FUNC (PREFIX, rshift_var); \
+ for (i = 0; i < N; i++) \
+ NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] >> shift; \
+} \
+ \
+static void NOINLINE \
+NAME (PREFIX, rshift_vect) (void) \
+{ \
+ int i; \
+ \
+ TRACE_FUNC (PREFIX, rshift_vect); \
+ for (i = 0; i < N; i++) \
+ NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] >> NAME (PREFIX, c)[i]; \
+} \
+ \
+static void NOINLINE \
+NAME (PREFIX, check) (void) \
+{ \
+ int i; \
+ \
+ TRACE_FUNC (PREFIX, check); \
+ for (i = 0; i < N; i++) \
+ if (NAME (PREFIX, a)[i] != NAME (PREFIX, d)[i]) \
+ TRACE_ABORT (i, NAME (PREFIX, d)[i], NAME (PREFIX, a)[i]); \
+} \
+ \
+static void NOINLINE \
+NAME (PREFIX, tests) (void) \
+{ \
+ int i; \
+ \
+ TRACE_FUNC (PREFIX, tests); \
+ for (i = 0; i < N; i++) \
+ { \
+ NAME (PREFIX, b)[i] = (i + NAME (PREFIX, zero)); \
+ NAME (PREFIX, c)[i] = 2; \
+ NAME (PREFIX, d)[i] = (i + NAME (PREFIX, zero)) << 2; \
+ } \
+ \
+ NAME (PREFIX, lshift_2) (); \
+ NAME (PREFIX, check) (); \
+ \
+ NAME (PREFIX, lshift_var) (2); \
+ NAME (PREFIX, check) (); \
+ \
+ NAME (PREFIX, lshift_vect) (); \
+ NAME (PREFIX, check) (); \
+ \
+ for (i = 0; i < N; i++) \
+ { \
+ NAME (PREFIX, b)[i] = ((i + NAME (PREFIX, zero)) << 4) \
+ | (((TYPE)0x80) << ((sizeof (TYPE) * 8) - 8)); \
+ NAME (PREFIX, c)[i] = 2; \
+ NAME (PREFIX, d)[i] = (TYPE)((NAME (PREFIX, b)[i] \
+ + NAME (PREFIX, zero)) >> 2); \
+ } \
+ \
+ NAME (PREFIX, rshift_2) (); \
+ NAME (PREFIX, check) (); \
+ \
+ NAME (PREFIX, rshift_var) (2); \
+ NAME (PREFIX, check) (); \
+ \
+ NAME (PREFIX, rshift_vect) (); \
+ NAME (PREFIX, check) (); \
+}
+
+VECT_TESTS (uc_, unsigned char, 128)
+VECT_TESTS (us_, unsigned short, 256)
+VECT_TESTS (ui_, unsigned int, 256)
+VECT_TESTS (ul_, unsigned long, 256)
+
+VECT_TESTS (sc_, signed char, 128)
+VECT_TESTS (ss_, short, 256)
+VECT_TESTS (si_, int, 256)
+VECT_TESTS (sl_, long, 256)
+
+int main ()
+{
+ int i;
+
+ check_vect ();
+
+ uc_tests ();
+ us_tests ();
+ ui_tests ();
+ ul_tests ();
+
+ sc_tests ();
+ ss_tests ();
+ si_tests ();
+ sl_tests ();
+
+ TRACE_DONE ();
+ return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
NAME (PREFIX, check) (); \
}
-VECT_TESTS (uc_, unsigned char, 128)
-VECT_TESTS (us_, unsigned short, 256)
-VECT_TESTS (ui_, unsigned int, 256)
-VECT_TESTS (ul_, unsigned long, 256)
-
-VECT_TESTS (sc_, signed char, 128)
-VECT_TESTS (ss_, short, 256)
-VECT_TESTS (si_, int, 256)
-VECT_TESTS (sl_, long, 256)
+VECT_TESTS(uc_, unsigned char, 16)
+VECT_TESTS(us_, unsigned short, 32)
+VECT_TESTS(ui_, unsigned int, 32)
+VECT_TESTS(ul_, unsigned long, 32)
+
+VECT_TESTS(sc_, signed char, 16)
+VECT_TESTS(ss_, short, 32)
+VECT_TESTS(si_, int, 32)
+VECT_TESTS(sl_, long, 32)
int main ()
{
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+ unsigned char a;
+ unsigned char b;
+ unsigned char c;
+ unsigned char d;
+ unsigned char e;
+ unsigned char f;
+ unsigned char g;
+ unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+ int i;
+ s arr[N];
+ s *ptr = arr;
+ s check_res[N];
+ s res[N];
+
+ for (i = 0; i < N; i++)
+ {
+ arr[i].a = i;
+ arr[i].b = i * 2;
+ arr[i].c = 17;
+ arr[i].d = i+34;
+ arr[i].e = i + 5;
+ arr[i].f = i * 2 + 2;
+ arr[i].g = i - 3;
+ arr[i].h = 56;
+
+ check_res[i].c = arr[i].a;
+ check_res[i].a = arr[i].f + arr[i].a;
+ check_res[i].d = arr[i].f - arr[i].a;
+ check_res[i].b = arr[i].f;
+ check_res[i].f = arr[i].a;
+ check_res[i].e = arr[i].f - arr[i].a;
+ check_res[i].h = arr[i].f;
+ check_res[i].g = arr[i].f - arr[i].a;
+
+ if (arr[i].a == 178)
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ res[i].c = ptr->a;
+ res[i].a = ptr->f + ptr->a;
+ res[i].d = ptr->f - ptr->a;
+ res[i].b = ptr->f;
+ res[i].f = ptr->a;
+ res[i].e = ptr->f - ptr->a;
+ res[i].h = ptr->f;
+ res[i].g = ptr->f - ptr->a;
+ ptr++;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (res[i].a != check_res[i].a
+ || res[i].b != check_res[i].b
+ || res[i].c != check_res[i].c
+ || res[i].d != check_res[i].d
+ || res[i].e != check_res[i].e
+ || res[i].f != check_res[i].f
+ || res[i].g != check_res[i].g
+ || res[i].h != check_res[i].h)
+ abort ();
+ }
+}
+
+
+int main (void)
+{
+ check_vect ();
+
+ main1 ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
typedef struct {
unsigned char a;
int i;
s arr[N];
s *ptr = arr;
- s check_res[N];
s res[N];
for (i = 0; i < N; i++)
arr[i].f = i * 2 + 2;
arr[i].g = i - 3;
arr[i].h = 56;
-
- check_res[i].c = arr[i].a;
- check_res[i].a = arr[i].f + arr[i].a;
- check_res[i].d = arr[i].f - arr[i].a;
- check_res[i].b = arr[i].f;
- check_res[i].f = arr[i].a;
- check_res[i].e = arr[i].f - arr[i].a;
- check_res[i].h = arr[i].f;
- check_res[i].g = arr[i].f - arr[i].a;
-
if (arr[i].a == 178)
abort();
}
res[i].d = ptr->f - ptr->a;
res[i].b = ptr->f;
res[i].f = ptr->a;
- res[i].e = ptr->f - ptr->a;
- res[i].h = ptr->f;
+ res[i].e = ptr->f - ptr->a;
+ res[i].h = ptr->f;
res[i].g = ptr->f - ptr->a;
- ptr++;
- }
-
+ ptr++;
+ }
+
/* check results: */
for (i = 0; i < N; i++)
- {
- if (res[i].a != check_res[i].a
- || res[i].b != check_res[i].b
- || res[i].c != check_res[i].c
- || res[i].d != check_res[i].d
- || res[i].e != check_res[i].e
- || res[i].f != check_res[i].f
- || res[i].g != check_res[i].g
- || res[i].h != check_res[i].h)
+ {
+ if (res[i].c != arr[i].a
+ || res[i].a != arr[i].f + arr[i].a
+ || res[i].d != arr[i].f - arr[i].a
+ || res[i].b != arr[i].f
+ || res[i].f != arr[i].a
+ || res[i].e != arr[i].f - arr[i].a
+ || res[i].h != arr[i].f
+ || res[i].g != arr[i].f - arr[i].a)
abort();
}
}
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
/* { dg-final { cleanup-tree-dump "vect" } } */
-
+
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+ unsigned char a;
+ unsigned char b;
+ unsigned char c;
+ unsigned char d;
+ unsigned char e;
+ unsigned char f;
+ unsigned char g;
+ unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+ int i;
+ s arr[N];
+ s *ptr = arr;
+ s check_res[N];
+ s res[N];
+ unsigned char u, t, s, x, y, z, w;
+
+ for (i = 0; i < N; i++)
+ {
+ arr[i].a = i;
+ arr[i].b = i * 2;
+ arr[i].c = 17;
+ arr[i].d = i+34;
+ arr[i].e = i * 3 + 5;
+ arr[i].f = i * 5;
+ arr[i].g = i - 3;
+ arr[i].h = 67;
+
+ u = arr[i].b - arr[i].a;
+ t = arr[i].d - arr[i].c;
+ check_res[i].c = u + t;
+ x = arr[i].b + arr[i].d;
+ check_res[i].a = arr[i].a + x;
+ check_res[i].d = u + t;
+ s = arr[i].h - arr[i].a;
+ check_res[i].b = s + t;
+ check_res[i].f = arr[i].f + arr[i].h;
+ check_res[i].e = arr[i].b + arr[i].e;
+ check_res[i].h = arr[i].d;
+ check_res[i].g = u + t;
+
+ if (arr[i].a == 178)
+ abort ();
+ }
+
+ for (i = 0; i < N; i++)
+ {
+ u = ptr->b - ptr->a;
+ t = ptr->d - ptr->c;
+ res[i].c = u + t;
+ x = ptr->b + ptr->d;
+ res[i].a = ptr->a + x;
+ res[i].d = u + t;
+ s = ptr->h - ptr->a;
+ res[i].b = s + t;
+ res[i].f = ptr->f + ptr->h;
+ res[i].e = ptr->b + ptr->e;
+ res[i].h = ptr->d;
+ res[i].g = u + t;
+ ptr++;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (res[i].a != check_res[i].a
+ || res[i].b != check_res[i].b
+ || res[i].c != check_res[i].c
+ || res[i].d != check_res[i].d
+ || res[i].e != check_res[i].e
+ || res[i].f != check_res[i].f
+ || res[i].g != check_res[i].g
+ || res[i].h != check_res[i].h)
+ abort ();
+ }
+}
+
+
+int main (void)
+{
+ check_vect ();
+
+ main1 ();
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
typedef struct {
unsigned char a;
int i;
s arr[N];
s *ptr = arr;
- s check_res[N];
s res[N];
unsigned char u, t, s, x, y, z, w;
arr[i].f = i * 5;
arr[i].g = i - 3;
arr[i].h = 67;
-
- u = arr[i].b - arr[i].a;
- t = arr[i].d - arr[i].c;
- check_res[i].c = u + t;
- x = arr[i].b + arr[i].d;
- check_res[i].a = arr[i].a + x;
- check_res[i].d = u + t;
- s = arr[i].h - arr[i].a;
- check_res[i].b = s + t;
- check_res[i].f = arr[i].f + arr[i].h;
- check_res[i].e = arr[i].b + arr[i].e;
- check_res[i].h = arr[i].d;
- check_res[i].g = u + t;
-
if (arr[i].a == 178)
abort();
}
/* check results: */
for (i = 0; i < N; i++)
{
- if (res[i].a != check_res[i].a
- || res[i].b != check_res[i].b
- || res[i].c != check_res[i].c
- || res[i].d != check_res[i].d
- || res[i].e != check_res[i].e
- || res[i].f != check_res[i].f
- || res[i].g != check_res[i].g
- || res[i].h != check_res[i].h)
+ if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+ || res[i].a != arr[i].a + arr[i].b + arr[i].d
+ || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+ || res[i].b != arr[i].h - arr[i].a + arr[i].d - arr[i].c
+ || res[i].f != arr[i].f + arr[i].h
+ || res[i].e != arr[i].b + arr[i].e
+ || res[i].h != arr[i].d
+ || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
abort();
}
}
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+ unsigned char a;
+ unsigned char b;
+ unsigned char c;
+ unsigned char d;
+ unsigned char e;
+ unsigned char f;
+ unsigned char g;
+ unsigned char h;
+} s;
+
+s check_res[N];
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+ int i;
+ s *ptr = arr;
+ s res[N];
+
+ for (i = 0; i < N; i++)
+ {
+ res[i].c = ptr->b;
+ res[i].a = ptr->f + ptr->b;
+ res[i].d = ptr->f - ptr->b;
+ res[i].b = ptr->f;
+ res[i].f = ptr->b;
+ res[i].e = ptr->f - ptr->b;
+ res[i].h = ptr->f;
+ res[i].g = ptr->f - ptr->b;
+ ptr++;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (res[i].a != check_res[i].a
+ || res[i].b != check_res[i].b
+ || res[i].c != check_res[i].c
+ || res[i].d != check_res[i].d
+ || res[i].e != check_res[i].e
+ || res[i].f != check_res[i].f
+ || res[i].g != check_res[i].g
+ || res[i].h != check_res[i].h)
+ abort ();
+ }
+}
+
+
+int main (void)
+{
+ int i;
+ s arr[N];
+
+ check_vect ();
+
+ for (i = 0; i < N; i++)
+ {
+ arr[i].a = i;
+ arr[i].b = i * 2;
+ arr[i].c = 17;
+ arr[i].d = i+34;
+ arr[i].e = i + 5;
+ arr[i].f = i * 2 + 2;
+ arr[i].g = i - 3;
+ arr[i].h = 56;
+
+ check_res[i].c = arr[i].b;
+ check_res[i].a = arr[i].f + arr[i].b;
+ check_res[i].d = arr[i].f - arr[i].b;
+ check_res[i].b = arr[i].f;
+ check_res[i].f = arr[i].b;
+ check_res[i].e = arr[i].f - arr[i].b;
+ check_res[i].h = arr[i].f;
+ check_res[i].g = arr[i].f - arr[i].b;
+ if (arr[i].a == 178)
+ abort ();
+ }
+
+ main1 (arr);
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
typedef struct {
unsigned char a;
unsigned char h;
} s;
-s check_res[N];
-
__attribute__ ((noinline)) int
main1 (s *arr)
{
res[i].d = ptr->f - ptr->b;
res[i].b = ptr->f;
res[i].f = ptr->b;
- res[i].e = ptr->f - ptr->b;
- res[i].h = ptr->f;
+ res[i].e = ptr->f - ptr->b;
+ res[i].h = ptr->f;
res[i].g = ptr->f - ptr->b;
- ptr++;
- }
-
+ ptr++;
+ }
+
/* check results: */
for (i = 0; i < N; i++)
- {
- if (res[i].a != check_res[i].a
- || res[i].b != check_res[i].b
- || res[i].c != check_res[i].c
- || res[i].d != check_res[i].d
- || res[i].e != check_res[i].e
- || res[i].f != check_res[i].f
- || res[i].g != check_res[i].g
- || res[i].h != check_res[i].h)
- abort ();
+ {
+ if (res[i].c != arr[i].b
+ || res[i].a != arr[i].f + arr[i].b
+ || res[i].d != arr[i].f - arr[i].b
+ || res[i].b != arr[i].f
+ || res[i].f != arr[i].b
+ || res[i].e != arr[i].f - arr[i].b
+ || res[i].h != arr[i].f
+ || res[i].g != arr[i].f - arr[i].b)
+ abort();
}
}
{
int i;
s arr[N];
-
+
check_vect ();
for (i = 0; i < N; i++)
- {
+ {
arr[i].a = i;
arr[i].b = i * 2;
arr[i].c = 17;
arr[i].f = i * 2 + 2;
arr[i].g = i - 3;
arr[i].h = 56;
-
- check_res[i].c = arr[i].b;
- check_res[i].a = arr[i].f + arr[i].b;
- check_res[i].d = arr[i].f - arr[i].b;
- check_res[i].b = arr[i].f;
- check_res[i].f = arr[i].b;
- check_res[i].e = arr[i].f - arr[i].b;
- check_res[i].h = arr[i].f;
- check_res[i].g = arr[i].f - arr[i].b;
if (arr[i].a == 178)
- abort ();
- }
+ abort();
+ }
main1 (arr);
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
/* { dg-final { cleanup-tree-dump "vect" } } */
-
+
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+ unsigned char a;
+ unsigned char b;
+ unsigned char c;
+ unsigned char d;
+ unsigned char e;
+ unsigned char f;
+ unsigned char g;
+ unsigned char h;
+} s;
+
+s check_res[N];
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+ int i;
+ s *ptr = arr;
+ s res[N];
+ unsigned char x;
+
+ for (i = 0; i < N; i++)
+ {
+ res[i].c = ptr->b + ptr->c;
+ x = ptr->c + ptr->f;
+ res[i].a = x + ptr->b;
+ res[i].d = ptr->b + ptr->c;
+ res[i].b = ptr->c;
+ res[i].f = ptr->f + ptr->e;
+ res[i].e = ptr->b + ptr->e;
+ res[i].h = ptr->c;
+ res[i].g = ptr->b + ptr->c;
+ ptr++;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (res[i].a != check_res[i].a
+ || res[i].b != check_res[i].b
+ || res[i].c != check_res[i].c
+ || res[i].d != check_res[i].d
+ || res[i].e != check_res[i].e
+ || res[i].f != check_res[i].f
+ || res[i].g != check_res[i].g
+ || res[i].h != check_res[i].h)
+ abort ();
+ }
+
+ ptr = arr;
+ /* Not vectorizable: gap in store. */
+ for (i = 0; i < N; i++)
+ {
+ res[i].a = ptr->b;
+ res[i].b = ptr->c;
+ ptr++;
+ }
+
+ /* Check results. */
+ for (i = 0; i < N; i++)
+ {
+ if (res[i].a != arr[i].b
+ || res[i].b != arr[i].c)
+ abort ();
+ }
+
+}
+
+
+int main (void)
+{
+ int i;
+ s arr[N];
+ unsigned char x;
+
+ check_vect ();
+
+ for (i = 0; i < N; i++)
+ {
+ arr[i].a = i;
+ arr[i].b = i * 2;
+ arr[i].c = 17;
+ arr[i].d = i+34;
+ arr[i].e = i * 3 + 5;
+ arr[i].f = i * 5;
+ arr[i].g = i - 3;
+ arr[i].h = 56;
+
+ check_res[i].c = arr[i].b + arr[i].c;
+ x = arr[i].c + arr[i].f;
+ check_res[i].a = x + arr[i].b;
+ check_res[i].d = arr[i].b + arr[i].c;
+ check_res[i].b = arr[i].c;
+ check_res[i].f = arr[i].f + arr[i].e;
+ check_res[i].e = arr[i].b + arr[i].e;
+ check_res[i].h = arr[i].c;
+ check_res[i].g = arr[i].b + arr[i].c;
+
+ if (arr[i].a == 178)
+ abort ();
+ }
+ main1 (arr);
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
typedef struct {
unsigned char a;
unsigned char h;
} s;
-s check_res[N];
-
__attribute__ ((noinline)) int
main1 (s *arr)
{
res[i].d = ptr->b + ptr->c;
res[i].b = ptr->c;
res[i].f = ptr->f + ptr->e;
- res[i].e = ptr->b + ptr->e;
- res[i].h = ptr->c;
+ res[i].e = ptr->b + ptr->e;
+ res[i].h = ptr->c;
res[i].g = ptr->b + ptr->c;
- ptr++;
- }
-
+ ptr++;
+ }
+
/* check results: */
for (i = 0; i < N; i++)
- {
- if (res[i].a != check_res[i].a
- || res[i].b != check_res[i].b
- || res[i].c != check_res[i].c
- || res[i].d != check_res[i].d
- || res[i].e != check_res[i].e
- || res[i].f != check_res[i].f
- || res[i].g != check_res[i].g
- || res[i].h != check_res[i].h)
+ {
+ if (res[i].c != arr[i].b + arr[i].c
+ || res[i].a != arr[i].c + arr[i].f + arr[i].b
+ || res[i].d != arr[i].b + arr[i].c
+ || res[i].b != arr[i].c
+ || res[i].f != arr[i].f + arr[i].e
+ || res[i].e != arr[i].b + arr[i].e
+ || res[i].h != arr[i].c
+ || res[i].g != arr[i].b + arr[i].c)
abort ();
}
ptr = arr;
/* Not vectorizable: gap in store. */
for (i = 0; i < N; i++)
- {
+ {
res[i].a = ptr->b;
res[i].b = ptr->c;
- ptr++;
+ ptr++;
}
-
+
/* Check results. */
for (i = 0; i < N; i++)
{
- if (res[i].a != arr[i].b
+ if (res[i].a != arr[i].b
|| res[i].b != arr[i].c)
abort ();
}
{
int i;
s arr[N];
- unsigned char x;
-
+
check_vect ();
for (i = 0; i < N; i++)
- {
+ {
arr[i].a = i;
arr[i].b = i * 2;
arr[i].c = 17;
arr[i].f = i * 5;
arr[i].g = i - 3;
arr[i].h = 56;
-
- check_res[i].c = arr[i].b + arr[i].c;
- x = arr[i].c + arr[i].f;
- check_res[i].a = x + arr[i].b;
- check_res[i].d = arr[i].b + arr[i].c;
- check_res[i].b = arr[i].c;
- check_res[i].f = arr[i].f + arr[i].e;
- check_res[i].e = arr[i].b + arr[i].e;
- check_res[i].h = arr[i].c;
- check_res[i].g = arr[i].b + arr[i].c;
-
if (arr[i].a == 178)
- abort ();
- }
+ abort();
+ }
+
main1 (arr);
return 0;
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
/* { dg-final { cleanup-tree-dump "vect" } } */
-
+
--- /dev/null
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+ unsigned char a;
+ unsigned char b;
+ unsigned char c;
+ unsigned char d;
+ unsigned char e;
+ unsigned char f;
+ unsigned char g;
+ unsigned char h;
+} s;
+
+s check_res[N];
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+ int i;
+ s *ptr = arr;
+ s res[N];
+ unsigned char u, t, s, x, y, z, w;
+
+ for (i = 0; i < N; i++)
+ {
+ u = ptr->b - ptr->a;
+ t = ptr->d - ptr->c;
+ res[i].c = u + t;
+ x = ptr->b + ptr->d;
+ res[i].a = ptr->a + x;
+ res[i].d = u + t;
+ s = ptr->h - ptr->a;
+ res[i].b = s + t;
+ res[i].f = ptr->f + ptr->h;
+ res[i].e = ptr->b + ptr->e;
+ res[i].h = ptr->d;
+ res[i].g = u + t;
+ ptr++;
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (res[i].a != check_res[i].a
+ || res[i].b != check_res[i].b
+ || res[i].c != check_res[i].c
+ || res[i].d != check_res[i].d
+ || res[i].e != check_res[i].e
+ || res[i].f != check_res[i].f
+ || res[i].g != check_res[i].g
+ || res[i].h != check_res[i].h)
+ abort ();
+ }
+}
+
+
+int main (void)
+{
+ int i;
+ s arr[N];
+ unsigned char u, t, s, x, y, z, w;
+
+ check_vect ();
+
+ for (i = 0; i < N; i++)
+ {
+ arr[i].a = i;
+ arr[i].b = i * 2;
+ arr[i].c = 17;
+ arr[i].d = i+34;
+ arr[i].e = i * 3 + 5;
+ arr[i].f = i * 5;
+ arr[i].g = i - 3;
+ arr[i].h = 67;
+
+ u = arr[i].b - arr[i].a;
+ t = arr[i].d - arr[i].c;
+ check_res[i].c = u + t;
+ x = arr[i].b + arr[i].d;
+ check_res[i].a = arr[i].a + x;
+ check_res[i].d = u + t;
+ s = arr[i].h - arr[i].a;
+ check_res[i].b = s + t;
+ check_res[i].f = arr[i].f + arr[i].h;
+ check_res[i].e = arr[i].b + arr[i].e;
+ check_res[i].h = arr[i].d;
+ check_res[i].g = u + t;
+
+ if (arr[i].a == 178)
+ abort ();
+ }
+
+ main1 (arr);
+
+ return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
#include <stdarg.h>
#include "tree-vect.h"
-#define N 128
+#define N 16
typedef struct {
unsigned char a;
unsigned char h;
} s;
-s check_res[N];
-
__attribute__ ((noinline)) int
main1 (s *arr)
{
/* check results: */
for (i = 0; i < N; i++)
{
- if (res[i].a != check_res[i].a
- || res[i].b != check_res[i].b
- || res[i].c != check_res[i].c
- || res[i].d != check_res[i].d
- || res[i].e != check_res[i].e
- || res[i].f != check_res[i].f
- || res[i].g != check_res[i].g
- || res[i].h != check_res[i].h)
+ if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+ || res[i].a != arr[i].a + arr[i].b + arr[i].d
+ || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+ || res[i].b != arr[i].h - arr[i].a + arr[i].d - arr[i].c
+ || res[i].f != arr[i].f + arr[i].h
+ || res[i].e != arr[i].b + arr[i].e
+ || res[i].h != arr[i].d
+ || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
abort();
}
}
{
int i;
s arr[N];
- unsigned char u, t, s, x, y, z, w;
check_vect ();
arr[i].f = i * 5;
arr[i].g = i - 3;
arr[i].h = 67;
-
- u = arr[i].b - arr[i].a;
- t = arr[i].d - arr[i].c;
- check_res[i].c = u + t;
- x = arr[i].b + arr[i].d;
- check_res[i].a = arr[i].a + x;
- check_res[i].d = u + t;
- s = arr[i].h - arr[i].a;
- check_res[i].b = s + t;
- check_res[i].f = arr[i].f + arr[i].h;
- check_res[i].e = arr[i].b + arr[i].e;
- check_res[i].h = arr[i].d;
- check_res[i].g = u + t;
-
if (arr[i].a == 178)
abort();
}
git://gcc.gnu.org / gcc.git / commitdiff