|
111
|
1 /* { dg-require-effective-target vect_int } */
|
|
|
2
|
|
|
3 #include <stdarg.h>
|
|
|
4 #include "tree-vect.h"
|
|
|
5
|
|
|
6 #define N 128
|
|
|
7
|
|
|
8 int
|
|
|
9 main1 ()
|
|
|
10 {
|
|
|
11 unsigned short i;
|
|
|
12 unsigned short out[N*8], out2[N*8], b0, b1, b2, b3, b4, a0, a1, a2, a3, b5;
|
|
|
13 unsigned short in[N*8];
|
|
|
14
|
|
|
15 for (i = 0; i < N*8; i++)
|
|
|
16 {
|
|
|
17 in[i] = i;
|
|
|
18 }
|
|
|
19
|
|
|
20 /* Different operations in both cases - vectorization with interleaving. */
|
|
|
21 for (i = 0; i < N; i++)
|
|
|
22 {
|
|
|
23 a0 = in[i*4];
|
|
|
24 a1 = in[i*4 + 1];
|
|
|
25 a2 = in[i*4 + 2];
|
|
|
26 a3 = in[i*4 + 3];
|
|
|
27
|
|
|
28 b0 = a0 * 8;
|
|
|
29 b1 = a1 + 7;
|
|
|
30 b2 = a2 + 6;
|
|
|
31 b3 = a3 * 5;
|
|
|
32
|
|
|
33 b4 = a2 + 4;
|
|
|
34 b5 = a3 + 3;
|
|
|
35
|
|
|
36 out[i*4] = b0;
|
|
|
37 out[i*4 + 1] = b1;
|
|
|
38 out[i*4 + 2] = b2;
|
|
|
39 out[i*4 + 3] = b3;
|
|
|
40
|
|
|
41 out2[i*4] = b0;
|
|
|
42 out2[i*4 + 1] = b1;
|
|
|
43 out2[i*4 + 2] = b4;
|
|
|
44 out2[i*4 + 3] = b5;
|
|
|
45 }
|
|
|
46
|
|
|
47 /* check results: */
|
|
|
48 for (i = 0; i < N; i++)
|
|
|
49 {
|
|
|
50 a0 = in[i*4];
|
|
|
51 a1 = in[i*4 + 1];
|
|
|
52 a2 = in[i*4 + 2];
|
|
|
53 a3 = in[i*4 + 3];
|
|
|
54
|
|
|
55 b0 = a0 * 8;
|
|
|
56 b1 = a1 + 7;
|
|
|
57 b2 = a2 + 6;
|
|
|
58 b3 = a3 * 5;
|
|
|
59
|
|
|
60 b4 = a2 + 4;
|
|
|
61 b5 = a3 + 3;
|
|
|
62
|
|
|
63 if (out[i*4] != b0
|
|
|
64 || out[i*4 + 1] != b1
|
|
|
65 || out[i*4 + 2] != b2
|
|
|
66 || out[i*4 + 3] != b3)
|
|
|
67 abort ();
|
|
|
68
|
|
|
69 if (out2[i*4] != b0
|
|
|
70 || out2[i*4 + 1] != b1
|
|
|
71 || out2[i*4 + 2] != b4
|
|
|
72 || out2[i*4 + 3] != b5)
|
|
|
73 abort ();
|
|
|
74 }
|
|
|
75
|
|
|
76 /* Different operations in the first case - vectorization with interleaving. */
|
|
|
77 for (i = 0; i < N; i++)
|
|
|
78 {
|
|
|
79 a0 = in[i*4];
|
|
|
80 a1 = in[i*4 + 1];
|
|
|
81 a2 = in[i*4 + 2];
|
|
|
82 a3 = in[i*4 + 3];
|
|
|
83
|
|
|
84 b0 = a0 + 8;
|
|
|
85 b1 = a1 + 7;
|
|
|
86 b2 = a2 + 6;
|
|
|
87 b3 = a3 * 5;
|
|
|
88
|
|
|
89 b4 = a2 + 4;
|
|
|
90 b5 = a3 + 3;
|
|
|
91
|
|
|
92 out[i*4] = b0;
|
|
|
93 out[i*4 + 1] = b1;
|
|
|
94 out[i*4 + 2] = b2;
|
|
|
95 out[i*4 + 3] = b3;
|
|
|
96
|
|
|
97 out2[i*4] = b0;
|
|
|
98 out2[i*4 + 1] = b1;
|
|
|
99 out2[i*4 + 2] = b4;
|
|
|
100 out2[i*4 + 3] = b5;
|
|
|
101 }
|
|
|
102
|
|
|
103 /* check results: */
|
|
|
104 for (i = 0; i < N; i++)
|
|
|
105 {
|
|
|
106 a0 = in[i*4];
|
|
|
107 a1 = in[i*4 + 1];
|
|
|
108 a2 = in[i*4 + 2];
|
|
|
109 a3 = in[i*4 + 3];
|
|
|
110
|
|
|
111 b0 = a0 + 8;
|
|
|
112 b1 = a1 + 7;
|
|
|
113 b2 = a2 + 6;
|
|
|
114 b3 = a3 * 5;
|
|
|
115
|
|
|
116 b4 = a2 + 4;
|
|
|
117 b5 = a3 + 3;
|
|
|
118
|
|
|
119 if (out[i*4] != b0
|
|
|
120 || out[i*4 + 1] != b1
|
|
|
121 || out[i*4 + 2] != b2
|
|
|
122 || out[i*4 + 3] != b3)
|
|
|
123 abort ();
|
|
|
124
|
|
|
125 if (out2[i*4] != b0
|
|
|
126 || out2[i*4 + 1] != b1
|
|
|
127 || out2[i*4 + 2] != b4
|
|
|
128 || out2[i*4 + 3] != b5)
|
|
|
129 abort ();
|
|
|
130 }
|
|
|
131
|
|
|
132
|
|
|
133 /* Different operations in the second case - vectorization with interleaving. */
|
|
|
134 for (i = 0; i < N; i++)
|
|
|
135 {
|
|
|
136 a0 = in[i*4];
|
|
|
137 a1 = in[i*4 + 1];
|
|
|
138 a2 = in[i*4 + 2];
|
|
|
139 a3 = in[i*4 + 3];
|
|
|
140
|
|
|
141 b0 = a0 + 8;
|
|
|
142 b1 = a1 + 7;
|
|
|
143 b2 = a2 + 6;
|
|
|
144 b3 = a3 + 5;
|
|
|
145
|
|
|
146 b4 = a2 * 4;
|
|
|
147 b5 = a3 + 3;
|
|
|
148
|
|
|
149 out[i*4] = b0;
|
|
|
150 out[i*4 + 1] = b1;
|
|
|
151 out[i*4 + 2] = b2;
|
|
|
152 out[i*4 + 3] = b3;
|
|
|
153
|
|
|
154 out2[i*4] = b0;
|
|
|
155 out2[i*4 + 1] = b1;
|
|
|
156 out2[i*4 + 2] = b4;
|
|
|
157 out2[i*4 + 3] = b5;
|
|
|
158 }
|
|
|
159
|
|
|
160 /* check results: */
|
|
|
161 for (i = 0; i < N; i++)
|
|
|
162 {
|
|
|
163 a0 = in[i*4];
|
|
|
164 a1 = in[i*4 + 1];
|
|
|
165 a2 = in[i*4 + 2];
|
|
|
166 a3 = in[i*4 + 3];
|
|
|
167
|
|
|
168 b0 = a0 + 8;
|
|
|
169 b1 = a1 + 7;
|
|
|
170 b2 = a2 + 6;
|
|
|
171 b3 = a3 + 5;
|
|
|
172
|
|
|
173 b4 = a2 * 4;
|
|
|
174 b5 = a3 + 3;
|
|
|
175
|
|
|
176 if (out[i*4] != b0
|
|
|
177 || out[i*4 + 1] != b1
|
|
|
178 || out[i*4 + 2] != b2
|
|
|
179 || out[i*4 + 3] != b3)
|
|
|
180 abort ();
|
|
|
181
|
|
|
182 if (out2[i*4] != b0
|
|
|
183 || out2[i*4 + 1] != b1
|
|
|
184 || out2[i*4 + 2] != b4
|
|
|
185 || out2[i*4 + 3] != b5)
|
|
|
186 abort ();
|
|
|
187 }
|
|
|
188
|
|
|
189
|
|
|
190 return 0;
|
|
|
191 }
|
|
|
192
|
|
|
193 int main (void)
|
|
|
194 {
|
|
|
195 check_vect ();
|
|
|
196
|
|
|
197 main1 ();
|
|
|
198
|
|
|
199 return 0;
|
|
|
200 }
|
|
|
201
|
|
|
202 /* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" { target { vect_strided4 || vect_extract_even_odd } } } } */
|
|
|
203 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { ! { vect_strided4 || vect_extract_even_odd } } } } } */
|
|
131
|
204 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target vect_strided4 } } } */
|
|
111
|
205 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" { target { ! { vect_strided4 } } } } } */
|
|
|
206
|
