1 /* { dg-require-effective-target vect_int } */
2 /* { dg-require-effective-target vect_float } */
3 /* { dg-add-options bind_pic_locally } */
4
5 #include <stdarg.h>
6 #include "tree-vect.h"
7
8 #define N 128
9
10 int iadd_results[N];
11 float fadd_results[N];
12 float fmul_results[N];
13 float fresults1[N];
14 float fresults2[N];
15
16 /****************************************************/
17 __attribute__ ((noinline))
18 void icheck_results (int *a, int *results)
19 {
20 int i;
21 for (i = 0; i < N; i++)
22 {
23 if (a[i] != results[i])
24 abort ();
25 }
26 }
27
28 __attribute__ ((noinline))
29 void fcheck_results (float *a, float *results)
30 {
31 int i;
32 for (i = 0; i < N; i++)
33 {
34 if (a[i] != results[i])
35 abort ();
36 }
37 }
38
39 __attribute__ ((noinline)) void
40 fbar_mul (float *a)
41 {
42 fcheck_results (a, fmul_results);
43 }
44
45 __attribute__ ((noinline)) void
46 fbar_add (float *a)
47 {
48 fcheck_results (a, fadd_results);
49 }
50
51 __attribute__ ((noinline)) void
52 ibar_add (int *a)
53 {
54 icheck_results (a, iadd_results);
55 }
56
57 __attribute__ ((noinline)) void
58 fbar1 (float *a)
59 {
60 fcheck_results (a, fresults1);
61 }
62
63 __attribute__ ((noinline)) void
64 fbar2 (float *a)
65 {
66 fcheck_results (a, fresults2);
67 }
68
69 float a[N];
70 float e[N];
71 float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
72 float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
73 float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
74 int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
75 int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
76 int ia[N];
77 char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
78 char ca[N];
79 short sa[N];
80
81 /* All of the loops below are currently vectorizable, except
82 initialization ones. */
83
84 __attribute__ ((noinline)) int
85 main1 ()
86 {
87 int i,j;
88 /* Initialization. */
89 for (i = 0; i < N; i++)
90 {
91 b[i] = i*3;
92 c[i] = i;
93 d[i] = i*2;
94 ic[i] = i*3;
95 ib[i] = i*3;
96 cb[i] = i*3;
97 fadd_results[i] = b[i] + c[i] + d[i];
98 iadd_results[i] = ib[i] + ic[i];
99 fmul_results[i] = b[i] * c[i];
100 fresults1[i] = 0;
101 fresults2[i] = 0;
102 asm volatile ("" ::: "memory");
103 }
104
105 /* Test 1: copy chars. */
106 for (i = 0; i < N; i++)
107 {
108 ca[i] = cb[i];
109 }
110 /* check results: */
111 for (i = 0; i < N; i++)
112 {
113 if (ca[i] != cb[i])
114 abort ();
115 }
116
117
118 /* Test 2: fp mult. */
119 for (i = 0; i < N; i++)
120 {
121 a[i] = b[i] * c[i];
122 }
123 fbar_mul (a);
124
125
126 /* Test 3: mixed types (int, fp), same nunits in vector. */
127 for (i = 0; i < N; i++)
128 {
129 a[i] = b[i] + c[i] + d[i];
130 e[i] = b[i] + c[i] + d[i];
131 ia[i] = ib[i] + ic[i];
132 }
133 ibar_add (ia);
134 fbar_add (a);
135 fbar_add (e);
136
137 /* Initialization. */
138 for (i = 0; i < N; i++)
139 {
140 fresults1[i] = a[i];
141 fresults2[i] = e[i];
142 asm volatile ("" ::: "memory");
143 }
144 for (i = 0; i < N/2; i++)
145 {
146 fresults1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
147 fresults2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
148 asm volatile ("" ::: "memory");
149 }
150 /* Test 4: access with offset. */
151 for (i = 0; i < N/2; i++)
152 {
153 a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
154 e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
155 }
156 fbar1 (a);
157 fbar2 (e);
158
159
160 /* Test 5: access with offset. */
161 for (i = 1; i <=N-4; i++)
162 {
163 a[i+3] = b[i-1];
164 }
165 /* check results: */
166 for (i = 1; i <=N-4; i++)
167 {
168 if (a[i+3] != b[i-1])
169 abort ();
170 }
171
172
173 /* Test 6 - loop induction with stride != 1. */
174 i = 0;
175 j = 0;
176 while (i < 5*N)
177 {
178 a[j] = c[j];
179 i += 5;
180 j++;
181 }
182 /* check results: */
183 for (i = 0; i <N; i++)
184 {
185 if (a[i] != c[i])
186 abort ();
187 }
188
189
190 /* Test 7 - reverse access. */
191 for (i = N; i > 0; i--)
192 {
193 a[N-i] = d[N-i];
194 }
195 /* check results: */
196 for (i = 0; i <N; i++)
197 {
198 if (a[i] != d[i])
199 abort ();
200 }
201
202
203 /* Tests 8,9,10 - constants. */
204 for (i = 0; i < N; i++)
205 {
206 a[i] = 5.0;
207 }
208 /* check results: */
209 for (i = 0; i < N; i++)
210 {
211 if (a[i] != 5.0)
212 abort ();
213 }
214
215 for (i = 0; i < N; i++)
216 {
217 sa[i] = 5;
218 }
219 /* check results: */
220 for (i = 0; i < N; i++)
221 {
222 if (sa[i] != 5)
223 abort ();
224 }
225
226 for (i = 0; i < N; i++)
227 {
228 ia[i] = ib[i] + 5;
229 }
230 /* check results: */
231 for (i = 0; i < N; i++)
232 {
233 if (ia[i] != ib[i] + 5)
234 abort ();
235 }
236
237 return 0;
238 }
239
240 int main (void)
241 {
242 check_vect ();
243
244 return main1 ();
245 }
246
247 /* { dg-final { scan-tree-dump-times "vectorized 10 loops" 1 "vect" } } */
248 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" { target { { vect_aligned_arrays } && {! vect_sizes_32B_16B} } } } } */
249 /* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { target { {! vect_aligned_arrays } && {vect_sizes_32B_16B} } } } } */
250 /* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */