1 // RUN: %clang_cc1 -std=c++11 -verify %s
2
3 // Note that this puts the expected lines before the directives to work around
4 // limitations in the -verify mode.
5
6 template <int V, int I>
test_nontype_template_param(int * List,int Length)7 void test_nontype_template_param(int *List, int Length) {
8 #pragma clang loop vectorize_width(V) interleave_count(I)
9 for (int i = 0; i < Length; i++) {
10 List[i] = i;
11 }
12
13 #pragma clang loop vectorize_width(V + 4) interleave_count(I + 4)
14 for (int i = 0; i < Length; i++) {
15 List[i] = i;
16 }
17 }
18
19 template <int V>
test_nontype_template_vectorize(int * List,int Length)20 void test_nontype_template_vectorize(int *List, int Length) {
21 /* expected-error {{invalid value '-1'; must be positive}} */ #pragma clang loop vectorize_width(V)
22 for (int i = 0; i < Length; i++) {
23 List[i] = i;
24 }
25
26 /* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop vectorize_width(V / 2)
27 for (int i = 0; i < Length; i++) {
28 List[i] += i;
29 }
30 }
31
32 template <int I>
test_nontype_template_interleave(int * List,int Length)33 void test_nontype_template_interleave(int *List, int Length) {
34 /* expected-error {{invalid value '-1'; must be positive}} */ #pragma clang loop interleave_count(I)
35 for (int i = 0; i < Length; i++) {
36 List[i] = i;
37 }
38
39 /* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop interleave_count(2 % I)
40 for (int i = 0; i < Length; i++) {
41 List[i] = i;
42 }
43 }
44
45 template <char V>
test_nontype_template_char(int * List,int Length)46 void test_nontype_template_char(int *List, int Length) {
47 /* expected-error {{invalid argument of type 'char'; expected an integer type}} */ #pragma clang loop vectorize_width(V)
48 for (int i = 0; i < Length; i++) {
49 List[i] = i;
50 }
51 }
52
53 template <bool V>
test_nontype_template_bool(int * List,int Length)54 void test_nontype_template_bool(int *List, int Length) {
55 /* expected-error {{invalid argument of type 'bool'; expected an integer type}} */ #pragma clang loop vectorize_width(V)
56 for (int i = 0; i < Length; i++) {
57 List[i] = i;
58 }
59 }
60
61 template <int V, int I>
test_nontype_template_badarg(int * List,int Length)62 void test_nontype_template_badarg(int *List, int Length) {
63 /* expected-error {{use of undeclared identifier 'Vec'}} */ #pragma clang loop vectorize_width(Vec) interleave_count(I) /*
64 expected-note {{vectorize_width loop hint malformed; use vectorize_width(X, fixed) or vectorize_width(X, scalable) where X is an integer, or vectorize_width('fixed' or 'scalable')}} */
65 /* expected-error {{use of undeclared identifier 'Int'}} */ #pragma clang loop vectorize_width(V) interleave_count(Int)
66 for (int i = 0; i < Length; i++) {
67 List[i] = i;
68 }
69 }
70
71 template <typename T>
test_type_template_vectorize(int * List,int Length)72 void test_type_template_vectorize(int *List, int Length) {
73 const T Value = -1;
74 /* expected-error {{invalid value '-1'; must be positive}} */ #pragma clang loop vectorize_width(Value)
75 for (int i = 0; i < Length; i++) {
76 List[i] = i;
77 }
78
79 /* expected-error {{invalid value '-1'; must be positive}} */ #pragma clang loop vectorize_width(Value, fixed)
80 for (int i = 0; i < Length; i++) {
81 List[i] = i;
82 }
83 }
84
test(int * List,int Length)85 void test(int *List, int Length) { // expected-note {{declared here}}
86 int i = 0;
87
88 #pragma clang loop vectorize(enable)
89 #pragma clang loop interleave(enable)
90 #pragma clang loop vectorize_predicate(enable)
91 #pragma clang loop unroll(full)
92 while (i + 1 < Length) {
93 List[i] = i;
94 }
95
96 #pragma clang loop vectorize_width(4)
97 #pragma clang loop interleave_count(8)
98 #pragma clang loop unroll_count(16)
99 while (i < Length) {
100 List[i] = i;
101 }
102
103 #pragma clang loop vectorize(disable)
104 #pragma clang loop interleave(disable)
105 #pragma clang loop vectorize_predicate(disable)
106 #pragma clang loop unroll(disable)
107 while (i - 1 < Length) {
108 List[i] = i;
109 }
110
111 #pragma clang loop vectorize_width(4) interleave_count(8) unroll_count(16)
112 while (i - 2 < Length) {
113 List[i] = i;
114 }
115
116 #pragma clang loop interleave_count(16)
117 while (i - 3 < Length) {
118 List[i] = i;
119 }
120
121 int VList[Length]; // expected-warning {{variable length arrays in C++ are a Clang extension}} \
122 expected-note {{function parameter 'Length' with unknown value cannot be used in a constant expression}}
123 #pragma clang loop vectorize(disable) interleave(disable) unroll(disable) vectorize_predicate(disable)
124 for (int j : VList) {
125 VList[j] = List[j];
126 }
127
128 #pragma clang loop distribute(enable)
129 for (int j : VList) {
130 VList[j] = List[j];
131 }
132
133 #pragma clang loop distribute(disable)
134 for (int j : VList) {
135 VList[j] = List[j];
136 }
137
138 test_nontype_template_param<4, 8>(List, Length);
139
140 /* expected-error {{expected '('}} */ #pragma clang loop vectorize
141 /* expected-error {{expected '('}} */ #pragma clang loop interleave
142 /* expected-error {{expected '('}} */ #pragma clang loop vectorize_predicate
143 /* expected-error {{expected '('}} */ #pragma clang loop unroll
144 /* expected-error {{expected '('}} */ #pragma clang loop distribute
145
146 /* expected-error {{expected ')'}} */ #pragma clang loop vectorize(enable
147 /* expected-error {{expected ')'}} */ #pragma clang loop interleave(enable
148 /* expected-error {{expected ')'}} */ #pragma clang loop vectorize_predicate(enable
149 /* expected-error {{expected ')'}} */ #pragma clang loop unroll(full
150 /* expected-error {{expected ')'}} */ #pragma clang loop distribute(enable
151
152 /* expected-error {{expected ')'}} */ #pragma clang loop vectorize_width(4
153 /* expected-error {{expected ')'}} */ #pragma clang loop interleave_count(4
154 /* expected-error {{expected ')'}} */ #pragma clang loop unroll_count(4
155
156 /* expected-error {{missing argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop vectorize()
157 /* expected-error {{missing argument; expected an integer value}} */ #pragma clang loop interleave_count()
158 /* expected-error {{missing argument; expected 'enable', 'full' or 'disable'}} */ #pragma clang loop unroll()
159 /* expected-error {{missing argument; expected 'enable' or 'disable'}} */ #pragma clang loop distribute()
160
161 /* expected-error {{missing option; expected vectorize, vectorize_width, interleave, interleave_count, unroll, unroll_count, pipeline, pipeline_initiation_interval, vectorize_predicate, or distribute}} */ #pragma clang loop
162 /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop badkeyword
163 /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop badkeyword(enable)
164 /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop vectorize(enable) badkeyword(4)
165 /* expected-warning {{extra tokens at end of '#pragma clang loop'}} */ #pragma clang loop vectorize(enable) ,
166 while (i-4 < Length) {
167 List[i] = i;
168 }
169
170 /* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop vectorize_width(0)
171 /* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop interleave_count(0)
172 /* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop unroll_count(0)
173
174 /* expected-error {{expression is not an integral constant expression}} expected-note {{division by zero}} */ #pragma clang loop vectorize_width(10 / 0)
175 /* expected-error {{invalid value '0'; must be positive}} */ #pragma clang loop interleave_count(10 / 5 - 2)
176 while (i-5 < Length) {
177 List[i] = i;
178 }
179
180 test_nontype_template_vectorize<4>(List, Length);
181 /* expected-note {{in instantiation of function template specialization}} */ test_nontype_template_vectorize<-1>(List, Length);
182 test_nontype_template_interleave<8>(List, Length);
183 /* expected-note {{in instantiation of function template specialization}} */ test_nontype_template_interleave<-1>(List, Length);
184
185 /* expected-note {{in instantiation of function template specialization}} */ test_nontype_template_char<'A'>(List, Length); // Loop hint arg cannot be a char.
186 /* expected-note {{in instantiation of function template specialization}} */ test_nontype_template_bool<true>(List, Length); // Or a bool.
187 /* expected-note {{in instantiation of function template specialization}} */ test_type_template_vectorize<int>(List, Length); // Or a template type.
188
189 /* expected-error {{value '3000000000' is too large}} */ #pragma clang loop vectorize_width(3000000000)
190 /* expected-error {{value '3000000000' is too large}} */ #pragma clang loop interleave_count(3000000000)
191 /* expected-error {{value '3000000000' is too large}} */ #pragma clang loop unroll_count(3000000000)
192 while (i-6 < Length) {
193 List[i] = i;
194 }
195
196 /* expected-warning {{extra tokens at end of '#pragma clang loop'}} */ #pragma clang loop vectorize_width(1 +) 1
197 /* expected-warning {{extra tokens at end of '#pragma clang loop'}} */ #pragma clang loop vectorize_width(1) +1
198 const int VV = 4;
199 /* expected-error {{expected expression}} */ #pragma clang loop vectorize_width(VV +/ 2) /*
200 expected-note {{vectorize_width loop hint malformed; use vectorize_width(X, fixed) or vectorize_width(X, scalable) where X is an integer, or vectorize_width('fixed' or 'scalable')}} */
201 /* expected-error {{use of undeclared identifier 'undefined'}} */ #pragma clang loop vectorize_width(VV+undefined) /*
202 expected-note {{vectorize_width loop hint malformed; use vectorize_width(X, fixed) or vectorize_width(X, scalable) where X is an integer, or vectorize_width('fixed' or 'scalable')}} */
203 /* expected-error {{expected ')'}} */ #pragma clang loop vectorize_width(1+(^*/2 * ()
204 /* expected-warning {{extra tokens at end of '#pragma clang loop' - ignored}} */ #pragma clang loop vectorize_width(1+(-0[0]))))))
205
206 /* expected-error {{use of undeclared identifier 'badvalue'}} */ #pragma clang loop vectorize_width(badvalue) /*
207 expected-note {{vectorize_width loop hint malformed; use vectorize_width(X, fixed) or vectorize_width(X, scalable) where X is an integer, or vectorize_width('fixed' or 'scalable')}} */
208 /* expected-error {{use of undeclared identifier 'badvalue'}} */ #pragma clang loop interleave_count(badvalue)
209 /* expected-error {{use of undeclared identifier 'badvalue'}} */ #pragma clang loop unroll_count(badvalue)
210 while (i-6 < Length) {
211 List[i] = i;
212 }
213
214 /* expected-error {{invalid argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop vectorize(badidentifier)
215 /* expected-error {{invalid argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop interleave(badidentifier)
216 /* expected-error {{invalid argument; expected 'enable', 'full' or 'disable'}} */ #pragma clang loop unroll(badidentifier)
217 /* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop distribute(badidentifier)
218 while (i-7 < Length) {
219 List[i] = i;
220 }
221
222 // PR20069 - Loop pragma arguments that are not identifiers or numeric
223 // constants crash FE.
224 /* expected-error {{expected ')'}} */ #pragma clang loop vectorize(()
225 /* expected-error {{invalid argument; expected 'enable', 'assume_safety' or 'disable'}} */ #pragma clang loop interleave(*)
226 /* expected-error {{invalid argument; expected 'enable', 'full' or 'disable'}} */ #pragma clang loop unroll(=)
227 /* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ #pragma clang loop distribute(+)
228 /* expected-error {{type name requires a specifier or qualifier}} expected-error {{expected expression}} */ #pragma clang loop vectorize_width(^) /* expected-note {{vectorize_width loop hint malformed; use vectorize_width(X, fixed) or vectorize_width(X, scalable) where X is an integer, or vectorize_width('fixed' or 'scalable')}} */
229 /* expected-error {{expected expression}} expected-error {{expected expression}} */ #pragma clang loop interleave_count(/)
230 /* expected-error {{expected expression}} expected-error {{expected expression}} */ #pragma clang loop unroll_count(==)
231 while (i-8 < Length) {
232 List[i] = i;
233 }
234
235 #pragma clang loop vectorize(enable)
236 /* expected-error {{expected a for, while, or do-while loop to follow '#pragma clang loop'}} */ int j = Length;
237 List[0] = List[1];
238
239 while (j-1 < Length) {
240 List[j] = j;
241 }
242
243 // FIXME: A bug in ParsedAttributes causes the order of the attributes to be
244 // processed in reverse. Consequently, the errors occur on the first of pragma
245 // of the next three tests rather than the last, and the order of the kinds
246 // is also reversed.
247
248 #pragma clang loop vectorize_width(4)
249 /* expected-error {{incompatible directives 'vectorize(disable)' and 'vectorize_width(4)'}} */ #pragma clang loop vectorize(disable)
250 #pragma clang loop interleave_count(4)
251 /* expected-error {{incompatible directives 'interleave(disable)' and 'interleave_count(4)'}} */ #pragma clang loop interleave(disable)
252 #pragma clang loop unroll_count(4)
253 /* expected-error {{incompatible directives 'unroll(disable)' and 'unroll_count(4)'}} */ #pragma clang loop unroll(disable)
254 while (i-8 < Length) {
255 List[i] = i;
256 }
257
258 #pragma clang loop vectorize(enable)
259 /* expected-error {{duplicate directives 'vectorize(enable)' and 'vectorize(disable)'}} */ #pragma clang loop vectorize(disable)
260 #pragma clang loop interleave(enable)
261 /* expected-error {{duplicate directives 'interleave(enable)' and 'interleave(disable)'}} */ #pragma clang loop interleave(disable)
262 #pragma clang loop vectorize_predicate(enable)
263 /* expected-error@+1 {{duplicate directives 'vectorize_predicate(enable)' and 'vectorize_predicate(disable)'}} */
264 #pragma clang loop vectorize_predicate(disable)
265 #pragma clang loop unroll(full)
266 /* expected-error {{duplicate directives 'unroll(full)' and 'unroll(disable)'}} */ #pragma clang loop unroll(disable)
267 #pragma clang loop distribute(enable)
268 /* expected-error {{duplicate directives 'distribute(enable)' and 'distribute(disable)'}} */ #pragma clang loop distribute(disable)
269 while (i-9 < Length) {
270 List[i] = i;
271 }
272
273 #pragma clang loop vectorize(disable)
274 /* expected-error {{incompatible directives 'vectorize(disable)' and 'vectorize_width(4)'}} */ #pragma clang loop vectorize_width(4)
275 #pragma clang loop interleave(disable)
276 /* expected-error {{incompatible directives 'interleave(disable)' and 'interleave_count(4)'}} */ #pragma clang loop interleave_count(4)
277 #pragma clang loop unroll(disable)
278 /* expected-error {{incompatible directives 'unroll(disable)' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4)
279 while (i-10 < Length) {
280 List[i] = i;
281 }
282
283 #pragma clang loop vectorize_width(8)
284 /* expected-error {{duplicate directives 'vectorize_width(8)' and 'vectorize_width(4)'}} */ #pragma clang loop vectorize_width(4)
285 #pragma clang loop interleave_count(8)
286 /* expected-error {{duplicate directives 'interleave_count(8)' and 'interleave_count(4)'}} */ #pragma clang loop interleave_count(4)
287 #pragma clang loop unroll_count(8)
288 /* expected-error {{duplicate directives 'unroll_count(8)' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4)
289 while (i-11 < Length) {
290 List[i] = i;
291 }
292
293 #pragma clang loop unroll(full)
294 /* expected-error {{incompatible directives 'unroll(full)' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4)
295 while (i-11 < Length) {
296 List[i] = i;
297 }
298
299 #pragma clang loop interleave(enable)
300 /* expected-error {{expected statement}} */ }
301
foo(void)302 void foo(void) {
303 #pragma clang loop vectorize_predicate(enable)
304 /* expected-error {{expected statement}} */ }
305
foo(int * List,int Length)306 void foo(int *List, int Length) {
307 int i;
308 #pragma clang loop vectorize(enable, extra)
309 /* expected-warning {{extra tokens at end of '#pragma clang loop vectorize' - ignored}}*/ while (i-6 < Length) {
310 List[i] = i;
311 }
312
313 #pragma clang loop interleave(enable, extra)
314 /* expected-warning {{extra tokens at end of '#pragma clang loop interleave' - ignored}}*/ while (i-6 < Length) {
315 List[i] = i;
316 }
317
318 #pragma clang loop unroll(enable, extra)
319 /* expected-warning {{extra tokens at end of '#pragma clang loop unroll' - ignored}}*/ while (i-6 < Length) {
320 List[i] = i;
321 }
322
323 #pragma clang loop vectorize_predicate(enable, extra)
324 /* expected-warning {{extra tokens at end of '#pragma clang loop vectorize_predicate' - ignored}}*/ while (i-6 < Length) {
325 List[i] = i;
326 }
327
328 #pragma clang loop pipeline(disable, extra)
329 /* expected-warning {{extra tokens at end of '#pragma clang loop pipeline' - ignored}}*/ while (i-6 < Length) {
330 List[i] = i;
331 }
332
333 /* expected-warning {{extra tokens at end of '#pragma clang loop vectorize_width' - ignored}}*/ #pragma clang loop vectorize_width(2, scalable, extra)
334 /* expected-warning {{extra tokens at end of '#pragma clang loop interleave_count' - ignored}}*/ #pragma clang loop interleave_count(2, extra)
335 /* expected-warning {{extra tokens at end of '#pragma clang loop unroll_count' - ignored}}*/ #pragma clang loop unroll_count(2, extra)
336 /* expected-warning {{extra tokens at end of '#pragma clang loop pipeline_initiation_interval' - ignored}}*/ #pragma clang loop pipeline_initiation_interval(2, extra)
337 while (i-6 < Length) {
338 List[i] = i;
339 }
340 }
341