Clang Project

clang_source_code/test/OpenMP/distribute_parallel_for_reduction_messages.cpp
1// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s
2// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s
3// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s
4
5// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s
6// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s
7// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s
8
9extern int omp_default_mem_alloc;
10void foo() {
11}
12
13bool foobool(int argc) {
14  return argc;
15}
16
17void foobar(int &ref) {
18#pragma omp target
19#pragma omp teams
20#pragma omp distribute parallel for reduction(+:ref)
21  for (int i = 0; i < 10; ++i)
22    foo();
23}
24
25struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
26extern S1 a;
27class S2 {
28  mutable int a;
29  S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
30
31public:
32  S2() : a(0) {}
33  S2(S2 &s2) : a(s2.a) {}
34  static float S2s; // expected-note 2 {{static data member is predetermined as shared}}
35  static const float S2sc; // expected-note 2 {{'S2sc' declared here}}
36};
37const float S2::S2sc = 0;
38S2 b;                     // expected-note 3 {{'b' defined here}}
39const S2 ba[5];           // expected-note 2 {{'ba' defined here}}
40class S3 {
41  int a;
42
43public:
44  int b;
45  S3() : a(0) {}
46  S3(const S3 &s3) : a(s3.a) {}
47  S3 operator+(const S3 &arg1) { return arg1; }
48};
49int operator+(const S3 &arg1, const S3 &arg2) { return 5; }
50S3 c;               // expected-note 3 {{'c' defined here}}
51const S3 ca[5];     // expected-note 2 {{'ca' defined here}}
52extern const int f; // expected-note 4 {{'f' declared here}}
53class S4 {
54  int a;
55  S4(); // expected-note {{implicitly declared private here}}
56  S4(const S4 &s4);
57  S4 &operator+(const S4 &arg) { return (*this); }
58
59public:
60  S4(int v) : a(v) {}
61};
62S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; }
63class S5 {
64  int a;
65  S5() : a(0) {} // expected-note {{implicitly declared private here}}
66  S5(const S5 &s5) : a(s5.a) {}
67  S5 &operator+(const S5 &arg);
68
69public:
70  S5(int v) : a(v) {}
71};
72class S6 { // expected-note 3 {{candidate function (the implicit copy assignment operator) not viable: no known conversion from 'int' to 'const S6' for 1st argument}}
73#if __cplusplus >= 201103L // C++11 or later
74// expected-note@-2 3 {{candidate function (the implicit move assignment operator) not viable}}
75#endif
76  int a;
77
78public:
79  S6() : a(6) {}
80  operator int() { return 6; }
81} o;
82
83S3 h, k;
84#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
85
86template <class T>       // expected-note {{declared here}}
87T tmain(T argc) {
88  const T d = T();       // expected-note 4 {{'d' defined here}}
89  const T da[5] = {T()}; // expected-note 2 {{'da' defined here}}
90  T qa[5] = {T()};
91  T i;
92  T &j = i;                        // expected-note 4 {{'j' defined here}}
93  S3 &p = k;                       // expected-note 2 {{'p' defined here}}
94  const T &r = da[(int)i];         // expected-note 2 {{'r' defined here}}
95  T &q = qa[(int)i];               // expected-note 2 {{'q' defined here}}
96  T fl;
97#pragma omp target
98#pragma omp teams
99#pragma omp distribute parallel for reduction // expected-error {{expected '(' after 'reduction'}}
100  for (int i = 0; i < 10; ++i)
101    foo();
102#pragma omp target
103#pragma omp teams
104#pragma omp distribute parallel for reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp distribute parallel for' are ignored}}
105  for (int i = 0; i < 10; ++i)
106    foo();
107#pragma omp target
108#pragma omp teams
109#pragma omp distribute parallel for reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
110  for (int i = 0; i < 10; ++i)
111    foo();
112#pragma omp target
113#pragma omp teams
114#pragma omp distribute parallel for reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
115  for (int i = 0; i < 10; ++i)
116    foo();
117#pragma omp target
118#pragma omp teams
119#pragma omp distribute parallel for reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
120  for (int i = 0; i < 10; ++i)
121    foo();
122#pragma omp target
123#pragma omp teams
124#pragma omp distribute parallel for reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}}
125  for (int i = 0; i < 10; ++i)
126    foo();
127#pragma omp target
128#pragma omp teams
129#pragma omp distribute parallel for reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
130  for (int i = 0; i < 10; ++i)
131    foo();
132#pragma omp target
133#pragma omp teams
134#pragma omp distribute parallel for reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{invalid operands to binary expression ('float' and 'float')}}
135  for (int i = 0; i < 10; ++i)
136    foo();
137#pragma omp target
138#pragma omp teams
139#pragma omp distribute parallel for reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{invalid operands to binary expression ('float' and 'float')}}
140  for (int i = 0; i < 10; ++i)
141    foo();
142#pragma omp target
143#pragma omp teams
144#pragma omp distribute parallel for reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name, array element or array section}}
145  for (int i = 0; i < 10; ++i)
146    foo();
147#pragma omp target
148#pragma omp teams
149#pragma omp distribute parallel for reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'float'}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'int'}}
150  for (int i = 0; i < 10; ++i)
151    foo();
152#pragma omp target
153#pragma omp teams
154#pragma omp distribute parallel for reduction(&& : argc) allocate , allocate(, allocate(omp_default , allocate(omp_default_mem_alloc, allocate(omp_default_mem_alloc:, allocate(omp_default_mem_alloc: argc, allocate(omp_default_mem_alloc: argv), allocate(argv) // expected-error {{expected '(' after 'allocate'}} expected-error 2 {{expected expression}} expected-error 2 {{expected ')'}} expected-error {{use of undeclared identifier 'omp_default'}} expected-note 2 {{to match this '('}}
155  for (int i = 0; i < 10; ++i)
156    foo();
157#pragma omp target
158#pragma omp teams
159#pragma omp distribute parallel for reduction(^ : T) // expected-error {{'T' does not refer to a value}}
160  for (int i = 0; i < 10; ++i)
161    foo();
162#pragma omp target
163#pragma omp teams
164#pragma omp distribute parallel for reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} expected-error 2 {{'operator+' is a private member of 'S2'}} expected-warning 2 {{Non-trivial type 'S2' is mapped, only trivial types are guaranteed to be mapped correctly}} expected-warning 2 {{Non-trivial type 'S3' is mapped, only trivial types are guaranteed to be mapped correctly}}
165  for (int i = 0; i < 10; ++i)
166    foo();
167#pragma omp target
168#pragma omp teams
169#pragma omp distribute parallel for reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 4 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}}
170  for (int i = 0; i < 10; ++i)
171    foo();
172#pragma omp target
173#pragma omp teams
174#pragma omp distribute parallel for reduction(max : h.b) // expected-error {{expected variable name, array element or array section}}
175  for (int i = 0; i < 10; ++i)
176    foo();
177#pragma omp target
178#pragma omp teams
179#pragma omp distribute parallel for reduction(+ : ba) // expected-error {{const-qualified variable cannot be reduction}}
180  for (int i = 0; i < 10; ++i)
181    foo();
182#pragma omp target
183#pragma omp teams
184#pragma omp distribute parallel for reduction(* : ca) // expected-error {{const-qualified variable cannot be reduction}}
185  for (int i = 0; i < 10; ++i)
186    foo();
187#pragma omp target
188#pragma omp teams
189#pragma omp distribute parallel for reduction(- : da) // expected-error {{const-qualified variable cannot be reduction}} expected-error {{const-qualified variable cannot be reduction}}
190  for (int i = 0; i < 10; ++i)
191    foo();
192#pragma omp target
193#pragma omp teams
194#pragma omp distribute parallel for reduction(^ : fl) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
195  for (int i = 0; i < 10; ++i)
196    foo();
197#pragma omp target
198#pragma omp teams
199#pragma omp distribute parallel for reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
200  for (int i = 0; i < 10; ++i)
201    foo();
202#pragma omp target
203#pragma omp teams
204#pragma omp distribute parallel for reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}}
205  for (int i = 0; i < 10; ++i)
206    foo();
207#pragma omp target
208#pragma omp teams
209#pragma omp distribute parallel for reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} expected-warning 2 {{Non-trivial type 'S3' is mapped, only trivial types are guaranteed to be mapped correctly}}
210  for (int i = 0; i < 10; ++i)
211    foo();
212#pragma omp target
213#pragma omp teams
214#pragma omp distribute parallel for reduction(+ : o) // expected-error 2 {{no viable overloaded '='}}
215  for (int i = 0; i < 10; ++i)
216    foo();
217#pragma omp target
218#pragma omp teams
219#pragma omp distribute parallel for private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
220  for (int i = 0; i < 10; ++i)
221    foo();
222#pragma omp parallel private(k)
223#pragma omp target
224#pragma omp teams
225#pragma omp distribute parallel for reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
226  for (int i = 0; i < 10; ++i)
227    foo();
228#pragma omp target
229#pragma omp teams
230#pragma omp distribute parallel for reduction(+ : p), reduction(+ : p) // expected-error 2 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 2 {{previously referenced here}}
231  for (int i = 0; i < 10; ++i)
232    foo();
233#pragma omp target
234#pragma omp teams
235#pragma omp distribute parallel for reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}}
236  for (int i = 0; i < 10; ++i)
237    foo();
238#pragma omp parallel shared(i)
239#pragma omp parallel reduction(min : i)
240#pragma omp target
241#pragma omp teams
242#pragma omp distribute parallel for reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
243  for (int i = 0; i < 10; ++i)
244    foo();
245#pragma omp parallel private(fl)
246#pragma omp target
247#pragma omp teams
248#pragma omp distribute parallel for reduction(+ : fl)
249  for (int i = 0; i < 10; ++i)
250    foo();
251#pragma omp parallel reduction(* : fl)
252#pragma omp target
253#pragma omp teams
254#pragma omp distribute parallel for reduction(+ : fl)
255  for (int i = 0; i < 10; ++i)
256    foo();
257
258  return T();
259}
260
261namespace A {
262double x;
263#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
264}
265namespace B {
266using A::x;
267}
268
269int main(int argc, char **argv) {
270  const int d = 5;       // expected-note 2 {{'d' defined here}}
271  const int da[5] = {0}; // expected-note {{'da' defined here}}
272  int qa[5] = {0};
273  S4 e(4);
274  S5 g(5);
275  int i;
276  int &j = i;                      // expected-note 2 {{'j' defined here}}
277  S3 &p = k;                       // expected-note 2 {{'p' defined here}}
278  const int &r = da[i];            // expected-note {{'r' defined here}}
279  int &q = qa[i];                  // expected-note {{'q' defined here}}
280  float fl;
281#pragma omp target
282#pragma omp teams
283#pragma omp distribute parallel for reduction // expected-error {{expected '(' after 'reduction'}}
284  for (int i = 0; i < 10; ++i)
285    foo();
286#pragma omp target
287#pragma omp teams
288#pragma omp distribute parallel for reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp distribute parallel for' are ignored}}
289  for (int i = 0; i < 10; ++i)
290    foo();
291#pragma omp target
292#pragma omp teams
293#pragma omp distribute parallel for reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
294  for (int i = 0; i < 10; ++i)
295    foo();
296#pragma omp target
297#pragma omp teams
298#pragma omp distribute parallel for reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
299  for (int i = 0; i < 10; ++i)
300    foo();
301#pragma omp target
302#pragma omp teams
303#pragma omp distribute parallel for reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
304  for (int i = 0; i < 10; ++i)
305    foo();
306#pragma omp target
307#pragma omp teams
308#pragma omp distribute parallel for reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}}
309  for (int i = 0; i < 10; ++i)
310    foo();
311#pragma omp target
312#pragma omp teams
313#pragma omp distribute parallel for reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
314  for (int i = 0; i < 10; ++i)
315    foo();
316#pragma omp target
317#pragma omp teams
318#pragma omp distribute parallel for reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}}
319  for (int i = 0; i < 10; ++i)
320    foo();
321#pragma omp target
322#pragma omp teams
323#pragma omp distribute parallel for reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
324  for (int i = 0; i < 10; ++i)
325    foo();
326#pragma omp target
327#pragma omp teams
328#pragma omp distribute parallel for reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name, array element or array section}}
329  for (int i = 0; i < 10; ++i)
330    foo();
331#pragma omp target
332#pragma omp teams
333#pragma omp distribute parallel for reduction(~ : argc) // expected-error {{expected unqualified-id}}
334  for (int i = 0; i < 10; ++i)
335    foo();
336#pragma omp target
337#pragma omp teams
338#pragma omp distribute parallel for reduction(&& : argc)
339  for (int i = 0; i < 10; ++i)
340    foo();
341#pragma omp target
342#pragma omp teams
343#pragma omp distribute parallel for reduction(^ : S1) // expected-error {{'S1' does not refer to a value}}
344  for (int i = 0; i < 10; ++i)
345    foo();
346#pragma omp target
347#pragma omp teams
348#pragma omp distribute parallel for reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} expected-error {{'operator+' is a private member of 'S2'}} expected-error {{incomplete type 'S1' where a complete type is required}} expected-warning {{Non-trivial type 'S2' is mapped, only trivial types are guaranteed to be mapped correctly}} expected-warning {{Non-trivial type 'S3' is mapped, only trivial types are guaranteed to be mapped correctly}}
349  for (int i = 0; i < 10; ++i)
350    foo();
351#pragma omp target
352#pragma omp teams
353#pragma omp distribute parallel for reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} expected-error {{incomplete type 'S1' where a complete type is required}} expected-warning {{Non-trivial type 'S2' is mapped, only trivial types are guaranteed to be mapped correctly}} expected-warning {{Non-trivial type 'S3' is mapped, only trivial types are guaranteed to be mapped correctly}}
354  for (int i = 0; i < 10; ++i)
355    foo();
356#pragma omp target
357#pragma omp teams
358#pragma omp distribute parallel for reduction(max : h.b) // expected-error {{expected variable name, array element or array section}}
359  for (int i = 0; i < 10; ++i)
360    foo();
361#pragma omp target
362#pragma omp teams
363#pragma omp distribute parallel for reduction(+ : ba) // expected-error {{const-qualified variable cannot be reduction}} expected-warning {{Non-trivial type 'const S2 [5]' is mapped, only trivial types are guaranteed to be mapped correctl}}
364  for (int i = 0; i < 10; ++i)
365    foo();
366#pragma omp target
367#pragma omp teams
368#pragma omp distribute parallel for reduction(* : ca) // expected-error {{const-qualified variable cannot be reduction}} expected-warning {{Non-trivial type 'const S3 [5]' is mapped, only trivial types are guaranteed to be mapped correctly}}
369  for (int i = 0; i < 10; ++i)
370    foo();
371#pragma omp target
372#pragma omp teams
373#pragma omp distribute parallel for reduction(- : da) // expected-error {{const-qualified variable cannot be reduction}}
374  for (int i = 0; i < 10; ++i)
375    foo();
376#pragma omp target
377#pragma omp teams
378#pragma omp distribute parallel for reduction(^ : fl) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
379  for (int i = 0; i < 10; ++i)
380    foo();
381#pragma omp target
382#pragma omp teams
383#pragma omp distribute parallel for reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
384  for (int i = 0; i < 10; ++i)
385    foo();
386#pragma omp target
387#pragma omp teams
388#pragma omp distribute parallel for reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}}
389  for (int i = 0; i < 10; ++i)
390    foo();
391#pragma omp target
392#pragma omp teams
393#pragma omp distribute parallel for reduction(& : e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{invalid operands to binary expression ('S4' and 'S4')}} expected-error {{calling a private constructor of class 'S5'}} expected-error {{invalid operands to binary expression ('S5' and 'S5')}} expected-warning {{Non-trivial type 'S4' is mapped, only trivial types are guaranteed to be mapped correctly}} expected-warning {{Non-trivial type 'S5' is mapped, only trivial types are guaranteed to be mapped correctly}}
394  for (int i = 0; i < 10; ++i)
395    foo();
396#pragma omp target
397#pragma omp teams
398#pragma omp distribute parallel for reduction(+ : h, k, B::x) // expected-error 2 {{threadprivate or thread local variable cannot be reduction}} expected-warning {{Non-trivial type 'S3' is mapped, only trivial types are guaranteed to be mapped correctly}}
399  for (int i = 0; i < 10; ++i)
400    foo();
401#pragma omp target
402#pragma omp teams
403#pragma omp distribute parallel for reduction(+ : o) // expected-error {{no viable overloaded '='}} expected-warning {{Non-trivial type 'class S6' is mapped, only trivial types are guaranteed to be mapped correctly}}
404  for (int i = 0; i < 10; ++i)
405    foo();
406#pragma omp target
407#pragma omp teams
408#pragma omp distribute parallel for private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
409  for (int i = 0; i < 10; ++i)
410    foo();
411#pragma omp parallel private(k)
412#pragma omp target
413#pragma omp teams
414#pragma omp distribute parallel for reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} expected-warning {{Non-trivial type 'S3' is mapped, only trivial types are guaranteed to be mapped correctly}}
415  for (int i = 0; i < 10; ++i)
416    foo();
417#pragma omp target
418#pragma omp teams
419#pragma omp distribute parallel for reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} expected-warning {{Non-trivial type 'S3' is mapped, only trivial types are guaranteed to be mapped correctly}}
420  for (int i = 0; i < 10; ++i)
421    foo();
422#pragma omp target
423#pragma omp teams
424#pragma omp distribute parallel for reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}}
425  for (int i = 0; i < 10; ++i)
426    foo();
427#pragma omp parallel shared(i)
428#pragma omp parallel reduction(min : i)
429#pragma omp target
430#pragma omp teams
431#pragma omp distribute parallel for reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
432  for (int i = 0; i < 10; ++i)
433    foo();
434#pragma omp parallel private(fl)
435#pragma omp target
436#pragma omp teams
437#pragma omp distribute parallel for reduction(+ : fl)
438  for (int i = 0; i < 10; ++i)
439    foo();
440#pragma omp parallel reduction(* : fl)
441#pragma omp target
442#pragma omp teams
443#pragma omp distribute parallel for reduction(+ : fl)
444  for (int i = 0; i < 10; ++i)
445    foo();
446  static int m;
447#pragma omp target
448#pragma omp teams
449#pragma omp distribute parallel for reduction(+ : m) // OK
450  for (int i = 0; i < 10; ++i)
451    m++;
452
453  return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}}
454}
455
CodeThinker, Enjoy your reading code