1 // RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s
2 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s
3 // RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
4
5 // RUN: %clang_cc1 -verify -fopenmp-simd -ast-print %s | FileCheck %s
6 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -emit-pch -o %t %s
7 // RUN: %clang_cc1 -fopenmp-simd -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
8
9 // RUN: %clang_cc1 -DOMP51 -verify -fopenmp -fopenmp-version=51 -ast-print %s | FileCheck -check-prefixes=CHECK,OMP51 %s
10 // RUN: %clang_cc1 -DOMP51 -fopenmp -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
11 // RUN: %clang_cc1 -DOMP51 -fopenmp -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck -check-prefixes=CHECK,OMP51 %s
12
13 // RUN: %clang_cc1 -DOMP51 -verify -fopenmp-simd -fopenmp-version=51 -ast-print %s | FileCheck -check-prefixes=CHECK,OMP51 %s
14 // RUN: %clang_cc1 -DOMP51 -fopenmp-simd -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
15 // RUN: %clang_cc1 -DOMP51 -fopenmp-simd -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck -check-prefixes=CHECK,OMP51 %s
16 // expected-no-diagnostics
17
18 #ifndef HEADER
19 #define HEADER
20
foo()21 void foo() {}
22
23 struct S1 {
S1S124 S1(): a(0) {}
S1S125 S1(int v) : a(v) {}
26 int a;
27 typedef int type;
28 S1& operator +(const S1&);
29 S1& operator *(const S1&);
30 S1& operator &&(const S1&);
31 S1& operator ^(const S1&);
32 };
33
34 template <typename T>
35 class S7 : public T {
36 protected:
37 T a;
38 T b[100];
S7()39 S7() : a(0) {}
40
41 public:
S7(typename T::type v)42 S7(typename T::type v) : a(v) {
43 #pragma omp parallel private(a) private(this->a) private(T::a)
44 for (int k = 0; k < a.a; ++k)
45 ++this->a.a;
46 #pragma omp parallel firstprivate(a) firstprivate(this->a) firstprivate(T::a)
47 for (int k = 0; k < a.a; ++k)
48 ++this->a.a;
49 #pragma omp parallel shared(a) shared(this->a) shared(T::a)
50 for (int k = 0; k < a.a; ++k)
51 ++this->a.a;
52 #pragma omp parallel reduction(+ : a) reduction(*: b[:])
53 for (int k = 0; k < a.a; ++k)
54 ++this->a.a;
55 }
operator =(S7 & s)56 S7 &operator=(S7 &s) {
57 #pragma omp parallel private(a) private(this->a)
58 for (int k = 0; k < s.a.a; ++k)
59 ++s.a.a;
60 #pragma omp parallel firstprivate(a) firstprivate(this->a)
61 for (int k = 0; k < s.a.a; ++k)
62 ++s.a.a;
63 #pragma omp parallel shared(a) shared(this->a)
64 for (int k = 0; k < s.a.a; ++k)
65 ++s.a.a;
66 #pragma omp parallel reduction(&& : this->a) reduction(^: b[s.a.a])
67 for (int k = 0; k < s.a.a; ++k)
68 ++s.a.a;
69 return *this;
70 }
71 };
72
73 // CHECK: #pragma omp parallel private(this->a) private(this->a) private(T::a)
74 // CHECK: #pragma omp parallel firstprivate(this->a) firstprivate(this->a) firstprivate(T::a)
75 // CHECK: #pragma omp parallel shared(this->a) shared(this->a) shared(T::a)
76 // CHECK: #pragma omp parallel reduction(+: this->a) reduction(*: this->b[:])
77 // CHECK: #pragma omp parallel private(this->a) private(this->a)
78 // CHECK: #pragma omp parallel firstprivate(this->a) firstprivate(this->a)
79 // CHECK: #pragma omp parallel shared(this->a) shared(this->a)
80 // CHECK: #pragma omp parallel reduction(&&: this->a) reduction(^: this->b[s.a.a])
81 // CHECK: #pragma omp parallel private(this->a) private(this->a) private(this->S1::a)
82 // CHECK: #pragma omp parallel firstprivate(this->a) firstprivate(this->a) firstprivate(this->S1::a)
83 // CHECK: #pragma omp parallel shared(this->a) shared(this->a) shared(this->S1::a)
84 // CHECK: #pragma omp parallel reduction(+: this->a) reduction(*: this->b[:])
85
86 class S8 : public S7<S1> {
S8()87 S8() {}
88
89 public:
S8(int v)90 S8(int v) : S7<S1>(v){
91 #pragma omp parallel private(a) private(this->a) private(S7 < S1 > ::a)
92 for (int k = 0; k < a.a; ++k)
93 ++this->a.a;
94 #pragma omp parallel firstprivate(a) firstprivate(this->a) firstprivate(S7 < S1 > ::a)
95 for (int k = 0; k < a.a; ++k)
96 ++this->a.a;
97 #pragma omp parallel shared(a) shared(this->a) shared(S7 < S1 > ::a)
98 for (int k = 0; k < a.a; ++k)
99 ++this->a.a;
100 #pragma omp parallel reduction(default, ^ : S7 < S1 > ::a) reduction(+ : S7 < S1 > ::b[ : S7 < S1 > ::a.a])
101 for (int k = 0; k < a.a; ++k)
102 ++this->a.a;
103 }
operator =(S8 & s)104 S8 &operator=(S8 &s) {
105 #pragma omp parallel private(a) private(this->a)
106 for (int k = 0; k < s.a.a; ++k)
107 ++s.a.a;
108 #pragma omp parallel firstprivate(a) firstprivate(this->a)
109 for (int k = 0; k < s.a.a; ++k)
110 ++s.a.a;
111 #pragma omp parallel shared(a) shared(this->a)
112 for (int k = 0; k < s.a.a; ++k)
113 ++s.a.a;
114 #pragma omp parallel reduction(* : this->a) reduction(&&:this->b[a.a:])
115 for (int k = 0; k < s.a.a; ++k)
116 ++s.a.a;
117 return *this;
118 }
119 };
120
121 // CHECK: #pragma omp parallel private(this->a) private(this->a) private(this->S7<S1>::a)
122 // CHECK: #pragma omp parallel firstprivate(this->a) firstprivate(this->a) firstprivate(this->S7<S1>::a)
123 // CHECK: #pragma omp parallel shared(this->a) shared(this->a) shared(this->S7<S1>::a)
124 // CHECK: #pragma omp parallel reduction(default, ^: this->S7<S1>::a) reduction(+: this->S7<S1>::b[:this->S7<S1>::a.a])
125 // CHECK: #pragma omp parallel private(this->a) private(this->a)
126 // CHECK: #pragma omp parallel firstprivate(this->a) firstprivate(this->a)
127 // CHECK: #pragma omp parallel shared(this->a) shared(this->a)
128 // CHECK: #pragma omp parallel reduction(*: this->a) reduction(&&: this->b[this->a.a:])
129
130 template <class T>
131 struct S {
operator TS132 operator T() {return T();}
133 static T TS;
134 #pragma omp threadprivate(TS)
135 };
136
137 // CHECK: template <class T> struct S {
138 // CHECK: static T TS;
139 // CHECK-NEXT: #pragma omp threadprivate(S::TS)
140 // CHECK: };
141 // CHECK: template<> struct S<int> {
142 // CHECK: static int TS;
143 // CHECK-NEXT: #pragma omp threadprivate(S<int>::TS)
144 // CHECK-NEXT: }
145 // CHECK: template<> struct S<long> {
146 // CHECK: static long TS;
147 // CHECK-NEXT: #pragma omp threadprivate(S<long>::TS)
148 // CHECK-NEXT: }
149
150 int thrp;
151 #pragma omp threadprivate(thrp)
152
153 template <typename T, int C>
154 T tmain(T argc, T *argv) {
155 T b = argc, c, d, e, f, g;
156 static T a;
157 S<T> s;
158 T arr[C][10], arr1[C];
159 #pragma omp parallel
160 a=2;
161 #pragma omp parallel default(none), private(argc,b) firstprivate(argv) shared (d) if (parallel:argc > 0) num_threads(C) copyin(S<T>::TS, thrp) proc_bind(master) reduction(+:c, arr1[argc]) reduction(max:e, arr[:C][0:10])
162 foo();
163 #ifdef OMP51
164 #pragma omp parallel default(none), private(argc,b) firstprivate(argv) shared (d) if (parallel:argc > 0) num_threads(C) copyin(S<T>::TS, thrp) proc_bind(primary) reduction(+:c, arr1[argc]) reduction(max:e, arr[:C][0:10])
165 foo();
166 #endif
167 #pragma omp parallel if (C) num_threads(s) proc_bind(close) reduction(^:e, f, arr[0:C][:argc]) reduction(default, && : g) reduction(task,+:argc)
168 foo();
169 return 0;
170 }
171
172 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
173 // CHECK-NEXT: T b = argc, c, d, e, f, g;
174 // CHECK-NEXT: static T a;
175 // CHECK-NEXT: S<T> s;
176 // CHECK-NEXT: T arr[C][10], arr1[C];
177 // CHECK-NEXT: #pragma omp parallel{{$}}
178 // CHECK-NEXT: a = 2;
179 // CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) copyin(S<T>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:C][0:10])
180 // CHECK-NEXT: foo()
181 // OMP51-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) copyin(S<T>::TS,thrp) proc_bind(primary) reduction(+: c,arr1[argc]) reduction(max: e,arr[:C][0:10])
182 // OMP51-NEXT: foo()
183 // CHECK-NEXT: #pragma omp parallel if(C) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:C][:argc]) reduction(default, &&: g) reduction(task, +: argc)
184 // CHECK-NEXT: foo()
185 // CHECK: template<> int tmain<int, 5>(int argc, int *argv) {
186 // CHECK-NEXT: int b = argc, c, d, e, f, g;
187 // CHECK-NEXT: static int a;
188 // CHECK-NEXT: S<int> s;
189 // CHECK-NEXT: int arr[5][10], arr1[5];
190 // CHECK-NEXT: #pragma omp parallel
191 // CHECK-NEXT: a = 2;
192 // CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(5) copyin(S<int>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:5][0:10])
193 // CHECK-NEXT: foo()
194 // OMP51-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(5) copyin(S<int>::TS,thrp) proc_bind(primary) reduction(+: c,arr1[argc]) reduction(max: e,arr[:5][0:10])
195 // OMP51-NEXT: foo()
196 // CHECK-NEXT: #pragma omp parallel if(5) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:5][:argc]) reduction(default, &&: g) reduction(task, +: argc)
197 // CHECK-NEXT: foo()
198 // CHECK: template<> long tmain<long, 1>(long argc, long *argv) {
199 // CHECK-NEXT: long b = argc, c, d, e, f, g;
200 // CHECK-NEXT: static long a;
201 // CHECK-NEXT: S<long> s;
202 // CHECK-NEXT: long arr[1][10], arr1[1];
203 // CHECK-NEXT: #pragma omp parallel
204 // CHECK-NEXT: a = 2;
205 // CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(1) copyin(S<long>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:1][0:10])
206 // CHECK-NEXT: foo()
207 // OMP51-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(1) copyin(S<long>::TS,thrp) proc_bind(primary) reduction(+: c,arr1[argc]) reduction(max: e,arr[:1][0:10])
208 // OMP51-NEXT: foo()
209 // CHECK-NEXT: #pragma omp parallel if(1) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:1][:argc]) reduction(default, &&: g) reduction(task, +: argc)
210 // CHECK-NEXT: foo()
211
212 enum Enum { };
213
main(int argc,char ** argv)214 int main (int argc, char **argv) {
215 long x;
216 int b = argc, c, d, e, f, g;
217 static int a;
218 #pragma omp threadprivate(a)
219 int arr[10][argc], arr1[2];
220 Enum ee;
221 // CHECK: Enum ee;
222 #pragma omp parallel
223 // CHECK-NEXT: #pragma omp parallel
224 a=2;
225 // CHECK-NEXT: a = 2;
226 #pragma omp parallel default(none), private(argc,b) firstprivate(argv) if (parallel: argc > 0) num_threads(ee) copyin(a) proc_bind(spread) reduction(| : c, d, arr1[argc]) reduction(* : e, arr[:10][0:argc]) allocate(e)
227 // CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) if(parallel: argc > 0) num_threads(ee) copyin(a) proc_bind(spread) reduction(|: c,d,arr1[argc]) reduction(*: e,arr[:10][0:argc]) allocate(e)
228 foo();
229 // CHECK-NEXT: foo();
230 // CHECK-NEXT: #pragma omp parallel allocate(e) if(b) num_threads(c) proc_bind(close) reduction(^: e,f) reduction(&&: g,arr[0:argc][:10])
231 // CHECK-NEXT: foo()
232 #pragma omp parallel allocate(e) if (b) num_threads(c) proc_bind(close) reduction(^:e, f) reduction(&& : g, arr[0:argc][:10])
233 foo();
234 return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x);
235 }
236
237 template <class T>
238 struct Foo {
239 int foo;
240 };
241
foo(const Foo<int> & arg)242 void foo(const Foo<int> &arg) {
243 // CHECK: #pragma omp parallel
244 #pragma omp parallel
245 {
246 // CHECK: #pragma omp for schedule(static)
247 #pragma omp for schedule(static)
248 for (int idx = 0; idx < 1234; ++idx) {
249 //arg.foo = idx;
250 idx = arg.foo;
251 }
252 }
253 }
254
255 template<typename T>
256 T S<T>::TS = 0;
257
258 #endif
259