1 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck %s
2 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-apple-darwin10 -emit-pch -o %t %s
3 // RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-apple-darwin10 -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
4 // RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++11 -DLAMBDA -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck -check-prefix=LAMBDA %s
5 // RUN: %clang_cc1 -verify -fopenmp -x c++ -fblocks -DBLOCKS -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck -check-prefix=BLOCKS %s
6 // expected-no-diagnostics
7 // REQUIRES: x86-registered-target
8 #ifndef HEADER
9 #define HEADER
10
11 struct SS {
12 int a;
13 int b : 4;
14 int &c;
SSSS15 SS(int &d) : a(0), b(0), c(d) {
16 #pragma omp parallel
17 #pragma omp for lastprivate(a, b, c)
18 for (int i = 0; i < 2; ++i)
19 #ifdef LAMBDA
20 [&]() {
21 ++this->a, --b, (this)->c /= 1;
22 #pragma omp parallel
23 #pragma omp for lastprivate(a, b, c)
24 for (int i = 0; i < 2; ++i)
25 ++(this)->a, --b, this->c /= 1;
26 }();
27 #elif defined(BLOCKS)
28 ^{
29 ++a;
30 --this->b;
31 (this)->c /= 1;
32 #pragma omp parallel
33 #pragma omp for lastprivate(a, b, c)
34 for (int i = 0; i < 2; ++i)
35 ++(this)->a, --b, this->c /= 1;
36 }();
37 #else
38 ++this->a, --b, c /= 1;
39 #endif
40 #pragma omp for
41 for (a = 0; a < 2; ++a)
42 #ifdef LAMBDA
43 [&]() {
44 ++this->a, --b, (this)->c /= 1;
45 #pragma omp parallel
46 #pragma omp for lastprivate(b)
47 for (b = 0; b < 2; ++b)
48 ++(this)->a, --b, this->c /= 1;
49 }();
50 #elif defined(BLOCKS)
51 ^{
52 ++a;
53 --this->b;
54 (this)->c /= 1;
55 #pragma omp parallel
56 #pragma omp for
57 for (c = 0; c < 2; ++c)
58 ++(this)->a, --b, this->c /= 1;
59 }();
60 #else
61 ++this->a, --b, c /= 1;
62 #endif
63 }
64 };
65
66 template <typename T>
67 struct SST {
68 T a;
SSTSST69 SST() : a(T()) {
70 #pragma omp parallel
71 #pragma omp for lastprivate(a)
72 for (int i = 0; i < 2; ++i)
73 #ifdef LAMBDA
74 [&]() {
75 [&]() {
76 ++this->a;
77 #pragma omp parallel
78 #pragma omp for lastprivate(a)
79 for (int i = 0; i < 2; ++i)
80 ++(this)->a;
81 }();
82 }();
83 #elif defined(BLOCKS)
84 ^{
85 ^{
86 ++a;
87 #pragma omp parallel
88 #pragma omp for lastprivate(a)
89 for (int i = 0; i < 2; ++i)
90 ++(this)->a;
91 }();
92 }();
93 #else
94 ++(this)->a;
95 #endif
96 #pragma omp for
97 for (a = 0; a < 2; ++a)
98 #ifdef LAMBDA
99 [&]() {
100 ++this->a;
101 #pragma omp parallel
102 #pragma omp for
103 for (a = 0; a < 2; ++(this)->a)
104 ++(this)->a;
105 }();
106 #elif defined(BLOCKS)
107 ^{
108 ++a;
109 #pragma omp parallel
110 #pragma omp for
111 for (this->a = 0; a < 2; ++a)
112 ++(this)->a;
113 }();
114 #else
115 ++(this)->a;
116 #endif
117 }
118 };
119
120 template <class T>
121 struct S {
122 T f;
SS123 S(T a) : f(a) {}
SS124 S() : f() {}
125 S<T> &operator=(const S<T> &);
operator TS126 operator T() { return T(); }
~SS127 ~S() {}
128 };
129
130 volatile int g __attribute__((aligned(128)))= 1212;
131 volatile int &g1 = g;
132 float f;
133 char cnt;
134
135 // CHECK: [[SS_TY:%.+]] = type { i{{[0-9]+}}, i8
136 // LAMBDA: [[SS_TY:%.+]] = type { i{{[0-9]+}}, i8
137 // BLOCKS: [[SS_TY:%.+]] = type { i{{[0-9]+}}, i8
138 // CHECK: [[S_FLOAT_TY:%.+]] = type { float }
139 // CHECK: [[S_INT_TY:%.+]] = type { i32 }
140 // CHECK-DAG: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8*
141 // CHECK-DAG: [[X:@.+]] = global double 0.0
142 // CHECK-DAG: [[F:@.+]] = global float 0.0
143 // CHECK-DAG: [[CNT:@.+]] = global i8 0
144 template <typename T>
tmain()145 T tmain() {
146 S<T> test;
147 SST<T> sst;
148 T t_var __attribute__((aligned(128))) = T();
149 T vec[] __attribute__((aligned(128))) = {1, 2};
150 S<T> s_arr[] __attribute__((aligned(128))) = {1, 2};
151 S<T> &var __attribute__((aligned(128))) = test;
152 #pragma omp parallel
153 #pragma omp for lastprivate(t_var, vec, s_arr, var)
154 for (int i = 0; i < 2; ++i) {
155 vec[i] = t_var;
156 s_arr[i] = var;
157 }
158 return T();
159 }
160
161 namespace A {
162 double x;
163 }
164 namespace B {
165 using A::x;
166 }
167
main()168 int main() {
169 static int sivar;
170 SS ss(sivar);
171 #ifdef LAMBDA
172 // LAMBDA: [[G:@.+]] = global i{{[0-9]+}} 1212,
173 // LAMBDA: [[SIVAR:@.+]] = internal global i{{[0-9]+}} 0,
174 // LAMBDA-LABEL: @main
175 // LAMBDA: alloca [[SS_TY]],
176 // LAMBDA: alloca [[CAP_TY:%.+]],
177 // LAMBDA: call void [[OUTER_LAMBDA:@.+]]([[CAP_TY]]*
178 [&]() {
179 // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
180 // LAMBDA: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i32* %{{.+}})
181 #pragma omp parallel
182 #pragma omp for lastprivate(g, g1, sivar)
183 for (int i = 0; i < 2; ++i) {
184 // LAMBDA: define {{.+}} @{{.+}}([[SS_TY]]*
185 // LAMBDA: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0
186 // LAMBDA: store i{{[0-9]+}} 0, i{{[0-9]+}}* %
187 // LAMBDA: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 1
188 // LAMBDA: store i8
189 // LAMBDA: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 2
190 // LAMBDA: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[SS_TY]]*)* [[SS_MICROTASK:@.+]] to void
191 // LAMBDA: call void @__kmpc_for_static_init_4(
192 // LAMBDA-NOT: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0
193 // LAMBDA: call void {{.+}} [[SS_LAMBDA:@[^ ]+]]
194 // LAMBDA: call void @__kmpc_for_static_fini(%
195 // LAMBDA: ret
196
197 // LAMBDA: define internal void [[SS_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}})
198 // LAMBDA: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 0
199 // LAMBDA-NOT: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1
200 // LAMBDA: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 2
201 // LAMBDA: call void @__kmpc_for_static_init_4(
202 // LAMBDA-NOT: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]*
203 // LAMBDA: call{{.*}} void
204 // LAMBDA: call void @__kmpc_for_static_fini(
205 // LAMBDA: br i1
206 // LAMBDA: [[B_REF:%.+]] = getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1
207 // LAMBDA: store i8 %{{.+}}, i8* [[B_REF]],
208 // LAMBDA: br label
209 // LAMBDA: ret void
210
211 // LAMBDA: define internal void @{{.+}}(i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}}, i32* {{.+}}, i32* {{.+}}, i32* {{.+}})
212 // LAMBDA: alloca i{{[0-9]+}},
213 // LAMBDA: alloca i{{[0-9]+}},
214 // LAMBDA: alloca i{{[0-9]+}},
215 // LAMBDA: alloca i{{[0-9]+}},
216 // LAMBDA: alloca i{{[0-9]+}},
217 // LAMBDA: [[A_PRIV:%.+]] = alloca i{{[0-9]+}},
218 // LAMBDA: [[B_PRIV:%.+]] = alloca i{{[0-9]+}},
219 // LAMBDA: [[C_PRIV:%.+]] = alloca i{{[0-9]+}},
220 // LAMBDA: store i{{[0-9]+}}* [[A_PRIV]], i{{[0-9]+}}** [[REFA:%.+]],
221 // LAMBDA: store i{{[0-9]+}}* [[C_PRIV]], i{{[0-9]+}}** [[REFC:%.+]],
222 // LAMBDA: call void @__kmpc_for_static_init_4(
223 // LAMBDA: [[A_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFA]],
224 // LAMBDA-NEXT: [[A_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[A_PRIV]],
225 // LAMBDA-NEXT: [[INC:%.+]] = add nsw i{{[0-9]+}} [[A_VAL]], 1
226 // LAMBDA-NEXT: store i{{[0-9]+}} [[INC]], i{{[0-9]+}}* [[A_PRIV]],
227 // LAMBDA-NEXT: [[B_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[B_PRIV]],
228 // LAMBDA-NEXT: [[DEC:%.+]] = add nsw i{{[0-9]+}} [[B_VAL]], -1
229 // LAMBDA-NEXT: store i{{[0-9]+}} [[DEC]], i{{[0-9]+}}* [[B_PRIV]],
230 // LAMBDA-NEXT: [[C_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFC]],
231 // LAMBDA-NEXT: [[C_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[C_PRIV]],
232 // LAMBDA-NEXT: [[DIV:%.+]] = sdiv i{{[0-9]+}} [[C_VAL]], 1
233 // LAMBDA-NEXT: store i{{[0-9]+}} [[DIV]], i{{[0-9]+}}* [[C_PRIV]],
234 // LAMBDA: call void @__kmpc_for_static_fini(
235 // LAMBDA: br i1
236 // LAMBDA: br label
237 // LAMBDA: ret void
238
239 // LAMBDA: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* noalias %{{.+}}, i32* noalias %{{.+}}, i32* dereferenceable(4) [[SIVAR:%.+]])
240 // LAMBDA: alloca i{{[0-9]+}},
241 // LAMBDA: alloca i{{[0-9]+}},
242 // LAMBDA: alloca i{{[0-9]+}},
243 // LAMBDA: alloca i{{[0-9]+}},
244 // LAMBDA: alloca i{{[0-9]+}},
245 // LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, align 128
246 // LAMBDA: [[G1_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}},
247 // LAMBDA: [[SIVAR_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}},
248 // LAMBDA: [[SIVAR_PRIVATE_ADDR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %{{.+}},
249
250 // LAMBDA: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %{{.+}}
251 // LAMBDA: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
252
253 // LAMBDA: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
254 // LAMBDA: store i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]],
255 // LAMBDA: store i{{[0-9]+}} 2, i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]],
256 // LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
257 // LAMBDA: store i{{[0-9]+}}* [[G_PRIVATE_ADDR]], i{{[0-9]+}}** [[G_PRIVATE_ADDR_REF]]
258 // LAMBDA: [[SIVAR_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 1
259 // LAMBDA: store i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]], i{{[0-9]+}}** [[SIVAR_PRIVATE_ADDR_REF]]
260 // LAMBDA: call void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]])
261 // LAMBDA: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]])
262 g = 1;
263 g1 = 1;
264 sivar = 2;
265 // Check for final copying of private values back to original vars.
266 // LAMBDA: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
267 // LAMBDA: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
268 // LAMBDA: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
269 // LAMBDA: [[LAST_THEN]]
270 // Actual copying.
271
272 // original g=private_g;
273 // LAMBDA: [[G_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[G_PRIVATE_ADDR]],
274 // LAMBDA: store volatile i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G]],
275
276 // original sivar=private_sivar;
277 // LAMBDA: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]],
278 // LAMBDA: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* %{{.+}},
279 // LAMBDA: br label %[[LAST_DONE]]
280 // LAMBDA: [[LAST_DONE]]
281 // LAMBDA: call void @__kmpc_barrier(%{{.+}}* @{{.+}}, i{{[0-9]+}} [[GTID]])
282 [&]() {
283 // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]])
284 // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]],
285 g = 2;
286 g1 = 2;
287 sivar = 4;
288 // LAMBDA: [[ARG_PTR:%.+]] = load %{{.+}}*, %{{.+}}** [[ARG_PTR_REF]]
289 // LAMBDA: [[G_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
290 // LAMBDA: [[G_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[G_PTR_REF]]
291 // LAMBDA: store i{{[0-9]+}} 2, i{{[0-9]+}}* [[G_REF]]
292 // LAMBDA: [[SIVAR_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 1
293 // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
294 // LAMBDA: store i{{[0-9]+}} 4, i{{[0-9]+}}* [[SIVAR_REF]]
295 }();
296 }
297 }();
298 return 0;
299 #elif defined(BLOCKS)
300 // BLOCKS: [[G:@.+]] = global i{{[0-9]+}} 1212,
301 // BLOCKS-LABEL: @main
302 // BLOCKS: call
303 // BLOCKS: call void {{%.+}}(i8
304 ^{
305 // BLOCKS: define{{.*}} internal{{.*}} void {{.+}}(i8*
306 // BLOCKS: call void {{.+}} @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}})
307 #pragma omp parallel
308 #pragma omp for lastprivate(g, g1, sivar)
309 for (int i = 0; i < 2; ++i) {
310 // BLOCKS: define{{.*}} internal{{.*}} void [[OMP_REGION]](i32* noalias %{{.+}}, i32* noalias %{{.+}}, i32* dereferenceable(4) [[SIVAR:%.+]])
311 // BLOCKS: alloca i{{[0-9]+}},
312 // BLOCKS: alloca i{{[0-9]+}},
313 // BLOCKS: alloca i{{[0-9]+}},
314 // BLOCKS: alloca i{{[0-9]+}},
315 // BLOCKS: alloca i{{[0-9]+}},
316 // BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, align 128
317 // BLOCKS: [[G1_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}}, align 4
318 // BLOCKS: [[SIVAR_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}},
319 // BLOCKS: store i{{[0-9]+}}* [[SIVAR]], i{{[0-9]+}}** [[SIVAR_ADDR:%.+]],
320 // BLOCKS: {{.+}} = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_ADDR]]
321 // BLOCKS: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %{{.+}}
322 // BLOCKS: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
323 // BLOCKS: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
324 // BLOCKS: store i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]],
325 // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
326 // BLOCKS: i{{[0-9]+}}* [[G_PRIVATE_ADDR]]
327 // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
328 // BLOCKS: call void {{%.+}}(i8
329 // BLOCKS: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]])
330 g = 1;
331 g1 = 1;
332 sivar = 2;
333 // Check for final copying of private values back to original vars.
334 // BLOCKS: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
335 // BLOCKS: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
336 // BLOCKS: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
337 // BLOCKS: [[LAST_THEN]]
338 // Actual copying.
339
340 // original g=private_g;
341 // BLOCKS: [[G_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[G_PRIVATE_ADDR]],
342 // BLOCKS: store volatile i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G]],
343 // BLOCKS: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[SIVAR_PRIVATE_ADDR]],
344 // BLOCKS: store i{{[0-9]+}} [[SIVAR_VAL]], i{{[0-9]+}}* %{{.+}},
345 // BLOCKS: br label %[[LAST_DONE]]
346 // BLOCKS: [[LAST_DONE]]
347 // BLOCKS: call void @__kmpc_barrier(%{{.+}}* @{{.+}}, i{{[0-9]+}} [[GTID]])
348 g = 1;
349 g1 = 1;
350 ^{
351 // BLOCKS: define {{.+}} void {{@.+}}(i8*
352 g = 2;
353 g1 = 1;
354 sivar = 4;
355 // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
356 // BLOCKS: store i{{[0-9]+}} 2, i{{[0-9]+}}*
357 // BLOCKS-NOT: [[G]]{{[[^:word:]]}}
358 // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
359 // BLOCKS: store i{{[0-9]+}} 4, i{{[0-9]+}}*
360 // BLOCKS-NOT: [[SIVAR]]{{[[^:word:]]}}
361 // BLOCKS: ret
362 }();
363 }
364 }();
365 return 0;
366 // BLOCKS: define {{.+}} @{{.+}}([[SS_TY]]*
367 // BLOCKS: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0
368 // BLOCKS: store i{{[0-9]+}} 0, i{{[0-9]+}}* %
369 // BLOCKS: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 1
370 // BLOCKS: store i8
371 // BLOCKS: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 2
372 // BLOCKS: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[SS_TY]]*)* [[SS_MICROTASK:@.+]] to void
373 // BLOCKS: call void @__kmpc_for_static_init_4(
374 // BLOCKS-NOT: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0
375 // BLOCKS: call void
376 // BLOCKS: call void @__kmpc_for_static_fini(%
377 // BLOCKS: ret
378
379 // BLOCKS: define internal void [[SS_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}})
380 // BLOCKS: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 0
381 // BLOCKS-NOT: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1
382 // BLOCKS: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 2
383 // BLOCKS: call void @__kmpc_for_static_init_4(
384 // BLOCKS-NOT: getelementptr {{.*}}[[SS_TY]], [[SS_TY]]*
385 // BLOCKS: call{{.*}} void
386 // BLOCKS: call void @__kmpc_for_static_fini(
387 // BLOCKS: br i1
388 // BLOCKS: [[B_REF:%.+]] = getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1
389 // BLOCKS: store i8 %{{.+}}, i8* [[B_REF]],
390 // BLOCKS: br label
391 // BLOCKS: ret void
392
393 // BLOCKS: define internal void @{{.+}}(i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}}, i32* {{.+}}, i32* {{.+}}, i32* {{.+}})
394 // BLOCKS: alloca i{{[0-9]+}},
395 // BLOCKS: alloca i{{[0-9]+}},
396 // BLOCKS: alloca i{{[0-9]+}},
397 // BLOCKS: alloca i{{[0-9]+}},
398 // BLOCKS: alloca i{{[0-9]+}},
399 // BLOCKS: [[A_PRIV:%.+]] = alloca i{{[0-9]+}},
400 // BLOCKS: [[B_PRIV:%.+]] = alloca i{{[0-9]+}},
401 // BLOCKS: [[C_PRIV:%.+]] = alloca i{{[0-9]+}},
402 // BLOCKS: store i{{[0-9]+}}* [[A_PRIV]], i{{[0-9]+}}** [[REFA:%.+]],
403 // BLOCKS: store i{{[0-9]+}}* [[C_PRIV]], i{{[0-9]+}}** [[REFC:%.+]],
404 // BLOCKS: call void @__kmpc_for_static_init_4(
405 // BLOCKS: [[A_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFA]],
406 // BLOCKS-NEXT: [[A_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[A_PRIV]],
407 // BLOCKS-NEXT: [[INC:%.+]] = add nsw i{{[0-9]+}} [[A_VAL]], 1
408 // BLOCKS-NEXT: store i{{[0-9]+}} [[INC]], i{{[0-9]+}}* [[A_PRIV]],
409 // BLOCKS-NEXT: [[B_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[B_PRIV]],
410 // BLOCKS-NEXT: [[DEC:%.+]] = add nsw i{{[0-9]+}} [[B_VAL]], -1
411 // BLOCKS-NEXT: store i{{[0-9]+}} [[DEC]], i{{[0-9]+}}* [[B_PRIV]],
412 // BLOCKS-NEXT: [[C_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFC]],
413 // BLOCKS-NEXT: [[C_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[C_PRIV]],
414 // BLOCKS-NEXT: [[DIV:%.+]] = sdiv i{{[0-9]+}} [[C_VAL]], 1
415 // BLOCKS-NEXT: store i{{[0-9]+}} [[DIV]], i{{[0-9]+}}* [[C_PRIV]],
416 // BLOCKS: call void @__kmpc_for_static_fini(
417 // BLOCKS: br i1
418 // BLOCKS: br label
419 // BLOCKS: ret void
420 #else
421 S<float> test;
422 int t_var = 0;
423 int vec[] = {1, 2};
424 S<float> s_arr[] = {1, 2};
425 S<float> var(3);
426 #pragma omp parallel
427 #pragma omp for lastprivate(t_var, vec, s_arr, var, sivar)
428 for (int i = 0; i < 2; ++i) {
429 vec[i] = t_var;
430 s_arr[i] = var;
431 sivar += i;
432 }
433 #pragma omp parallel
434 #pragma omp for lastprivate(A::x, B::x) firstprivate(f) lastprivate(f)
435 for (int i = 0; i < 2; ++i) {
436 A::x++;
437 }
438 #pragma omp parallel
439 #pragma omp for firstprivate(f) lastprivate(f)
440 for (int i = 0; i < 2; ++i) {
441 A::x++;
442 }
443 #pragma omp parallel
444 #pragma omp for lastprivate(cnt)
445 for (cnt = 0; cnt < 2; ++cnt) {
446 A::x++;
447 }
448 return tmain<int>();
449 #endif
450 }
451
452 // CHECK: define i{{[0-9]+}} @main()
453 // CHECK: [[TEST:%.+]] = alloca [[S_FLOAT_TY]],
454 // CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR:@.+]]([[S_FLOAT_TY]]* [[TEST]])
455 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 5, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, i32*, [2 x i32]*, [2 x [[S_FLOAT_TY]]]*, [[S_FLOAT_TY]]*, i32*)* [[MAIN_MICROTASK:@.+]] to void
456 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 0, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*)* [[MAIN_MICROTASK1:@.+]] to void
457 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 0, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*)* [[MAIN_MICROTASK2:@.+]] to void
458 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 0, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*)* [[MAIN_MICROTASK3:@.+]] to void
459 // CHECK: = call {{.+}} [[TMAIN_INT:@.+]]()
460 // CHECK: call void [[S_FLOAT_TY_DESTR:@.+]]([[S_FLOAT_TY]]*
461 // CHECK: ret
462
463 // CHECK: define internal void [[MAIN_MICROTASK]](i32* noalias [[GTID_ADDR:%.+]], i32* noalias %{{.+}}, i32* dereferenceable(4) %{{.+}}, [2 x i32]* dereferenceable(8) %{{.+}}, [2 x [[S_FLOAT_TY]]]* dereferenceable(8) %{{.+}}, [[S_FLOAT_TY]]* dereferenceable(4) %{{.+}})
464 // CHECK: alloca i{{[0-9]+}},
465 // CHECK: alloca i{{[0-9]+}},
466 // CHECK: alloca i{{[0-9]+}},
467 // CHECK: alloca i{{[0-9]+}},
468 // CHECK: alloca i{{[0-9]+}},
469 // CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}},
470 // CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}],
471 // CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_FLOAT_TY]]],
472 // CHECK: [[VAR_PRIV:%.+]] = alloca [[S_FLOAT_TY]],
473 // CHECK: [[SIVAR_PRIV:%.+]] = alloca i{{[0-9]+}},
474 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]]
475
476 // CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %
477 // CHECK: [[VEC_REF:%.+]] = load [2 x i32]*, [2 x i32]** %
478 // CHECK: [[S_ARR_REF:%.+]] = load [2 x [[S_FLOAT_TY]]]*, [2 x [[S_FLOAT_TY]]]** %
479 // CHECK: [[VAR_REF:%.+]] = load [[S_FLOAT_TY]]*, [[S_FLOAT_TY]]** %
480
481 // Check for default initialization.
482 // CHECK-NOT: [[T_VAR_PRIV]]
483 // CHECK-NOT: [[VEC_PRIV]]
484 // CHECK: [[S_ARR_PRIV_ITEM:%.+]] = phi [[S_FLOAT_TY]]*
485 // CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR]]([[S_FLOAT_TY]]* [[S_ARR_PRIV_ITEM]])
486 // CHECK: call {{.*}} [[S_FLOAT_TY_DEF_CONSTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]])
487 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 %{{.+}}, i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
488 // <Skip loop body>
489 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 %{{.+}})
490
491 // Check for final copying of private values back to original vars.
492 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
493 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
494 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
495 // CHECK: [[LAST_THEN]]
496 // Actual copying.
497
498 // original t_var=private_t_var;
499 // CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PRIV]],
500 // CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_REF]],
501
502 // original vec[]=private_vec[];
503 // CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8*
504 // CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8*
505 // CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]],
506
507 // original s_arr[]=private_s_arr[];
508 // CHECK: [[S_ARR_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[S_ARR_REF]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
509 // CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = bitcast [2 x [[S_FLOAT_TY]]]* [[S_ARR_PRIV]] to [[S_FLOAT_TY]]*
510 // CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2
511 // CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], [[S_ARR_END]]
512 // CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]
513 // CHECK: [[S_ARR_BODY]]
514 // CHECK: call {{.*}} [[S_FLOAT_TY_COPY_ASSIGN:@.+]]([[S_FLOAT_TY]]* {{.+}}, [[S_FLOAT_TY]]* {{.+}})
515 // CHECK: br i1 {{.+}}, label %[[S_ARR_BODY_DONE]], label %[[S_ARR_BODY]]
516 // CHECK: [[S_ARR_BODY_DONE]]
517
518 // original var=private_var;
519 // CHECK: call {{.*}} [[S_FLOAT_TY_COPY_ASSIGN:@.+]]([[S_FLOAT_TY]]* [[VAR_REF]], [[S_FLOAT_TY]]* {{.*}} [[VAR_PRIV]])
520 // CHECK: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[SIVAR_PRIV]],
521 // CHECK: br label %[[LAST_DONE]]
522 // CHECK: [[LAST_DONE]]
523 // CHECK-DAG: call void [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]])
524 // CHECK-DAG: call void [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]*
525 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]]
526 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
527 // CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
528 // CHECK: ret void
529
530 //
531 // CHECK: define internal void [[MAIN_MICROTASK1]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}})
532 // CHECK: [[F_PRIV:%.+]] = alloca float,
533 // CHECK-NOT: alloca float
534 // CHECK: [[X_PRIV:%.+]] = alloca double,
535 // CHECK-NOT: alloca float
536 // CHECK-NOT: alloca double
537
538 // Check for default initialization.
539 // CHECK-NOT: [[X_PRIV]]
540 // CHECK: [[F_VAL:%.+]] = load float, float* [[F]],
541 // CHECK: store float [[F_VAL]], float* [[F_PRIV]],
542 // CHECK-NOT: [[X_PRIV]]
543
544 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]]
545 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
546 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
547 // <Skip loop body>
548 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]])
549
550 // Check for final copying of private values back to original vars.
551 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
552 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
553 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
554 // CHECK: [[LAST_THEN]]
555 // Actual copying.
556
557 // original x=private_x;
558 // CHECK: [[X_VAL:%.+]] = load double, double* [[X_PRIV]],
559 // CHECK: store double [[X_VAL]], double* [[X]],
560
561 // original f=private_f;
562 // CHECK: [[F_VAL:%.+]] = load float, float* [[F_PRIV]],
563 // CHECK: store float [[F_VAL]], float* [[F]],
564
565 // CHECK-NEXT: br label %[[LAST_DONE]]
566 // CHECK: [[LAST_DONE]]
567
568 // CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
569 // CHECK: ret void
570
571 // CHECK: define internal void [[MAIN_MICROTASK2]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}})
572 // CHECK: [[F_PRIV:%.+]] = alloca float,
573 // CHECK-NOT: alloca float
574
575 // Check for default initialization.
576 // CHECK: [[F_VAL:%.+]] = load float, float* [[F]],
577 // CHECK: store float [[F_VAL]], float* [[F_PRIV]],
578
579 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]]
580 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
581 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
582 // <Skip loop body>
583 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]])
584
585 // Check for final copying of private values back to original vars.
586 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
587 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
588 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
589 // CHECK: [[LAST_THEN]]
590 // Actual copying.
591
592 // original f=private_f;
593 // CHECK: [[F_VAL:%.+]] = load float, float* [[F_PRIV]],
594 // CHECK: store float [[F_VAL]], float* [[F]],
595
596 // CHECK-NEXT: br label %[[LAST_DONE]]
597 // CHECK: [[LAST_DONE]]
598
599 // CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
600 // CHECK: ret void
601
602 // CHECK: define internal void [[MAIN_MICROTASK3]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}})
603 // CHECK: [[CNT_PRIV:%.+]] = alloca i8,
604
605 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]]
606 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
607 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 [[GTID]], i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1)
608 // UB = min(UB, GlobalUB)
609 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
610 // CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 1
611 // CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
612 // CHECK: [[UBRESULT:%.+]] = phi i32 [ 1, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
613 // CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
614 // CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
615 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
616 // <Skip loop body>
617 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 [[GTID]])
618
619 // Check for final copying of private values back to original vars.
620 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
621 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
622 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
623 // CHECK: [[LAST_THEN]]
624
625 // Calculate private cnt value.
626 // CHECK: store i8 2, i8* [[CNT_PRIV]]
627 // original cnt=private_cnt;
628 // CHECK: [[CNT_VAL:%.+]] = load i8, i8* [[CNT_PRIV]],
629 // CHECK: store i8 [[CNT_VAL]], i8* [[CNT]],
630
631 // CHECK-NEXT: br label %[[LAST_DONE]]
632 // CHECK: [[LAST_DONE]]
633
634 // CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
635 // CHECK: ret void
636
637 // CHECK: define {{.*}} i{{[0-9]+}} [[TMAIN_INT]]()
638 // CHECK: [[TEST:%.+]] = alloca [[S_INT_TY]],
639 // CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR:@.+]]([[S_INT_TY]]* [[TEST]])
640 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 4, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, i32*, [2 x i32]*, [2 x [[S_INT_TY]]]*, [[S_INT_TY]]*)* [[TMAIN_MICROTASK:@.+]] to void
641 // CHECK: call void [[S_INT_TY_DESTR:@.+]]([[S_INT_TY]]*
642 // CHECK: ret
643
644 // CHECK: define {{.+}} @{{.+}}([[SS_TY]]*
645 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0
646 // CHECK: store i{{[0-9]+}} 0, i{{[0-9]+}}* %
647 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 1
648 // CHECK: store i8
649 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 2
650 // CHECK: call void (%{{.+}}*, i{{[0-9]+}}, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)*, ...) @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}*, i{{[0-9]+}}*, ...)* bitcast (void (i{{[0-9]+}}*, i{{[0-9]+}}*, [[SS_TY]]*)* [[SS_MICROTASK:@.+]] to void
651 // CHECK: call void @__kmpc_for_static_init_4(
652 // CHECK-NOT: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 0
653 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 1
654 // CHECK: getelementptr inbounds [[SS_TY]], [[SS_TY]]* %{{.+}}, i32 0, i32 2
655 // CHECK: call void @__kmpc_for_static_fini(%
656 // CHECK: ret
657
658 // CHECK: define internal void [[SS_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, [[SS_TY]]* %{{.+}})
659 // CHECK: alloca i{{[0-9]+}},
660 // CHECK: alloca i{{[0-9]+}},
661 // CHECK: alloca i{{[0-9]+}},
662 // CHECK: alloca i{{[0-9]+}},
663 // CHECK: alloca i{{[0-9]+}},
664 // CHECK: alloca i{{[0-9]+}},
665 // CHECK: [[A_PRIV:%.+]] = alloca i{{[0-9]+}},
666 // CHECK: [[B_PRIV:%.+]] = alloca i{{[0-9]+}},
667 // CHECK: [[C_PRIV:%.+]] = alloca i{{[0-9]+}},
668 // CHECK: store i{{[0-9]+}}* [[A_PRIV]], i{{[0-9]+}}** [[REFA:%.+]],
669 // CHECK: store i{{[0-9]+}}* [[C_PRIV]], i{{[0-9]+}}** [[REFC:%.+]],
670 // CHECK: call void @__kmpc_for_static_init_4(
671 // CHECK: [[A_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFA]],
672 // CHECK-NEXT: [[A_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[A_PRIV]],
673 // CHECK-NEXT: [[INC:%.+]] = add nsw i{{[0-9]+}} [[A_VAL]], 1
674 // CHECK-NEXT: store i{{[0-9]+}} [[INC]], i{{[0-9]+}}* [[A_PRIV]],
675 // CHECK-NEXT: [[B_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[B_PRIV]],
676 // CHECK-NEXT: [[DEC:%.+]] = add nsw i{{[0-9]+}} [[B_VAL]], -1
677 // CHECK-NEXT: store i{{[0-9]+}} [[DEC]], i{{[0-9]+}}* [[B_PRIV]],
678 // CHECK-NEXT: [[C_PRIV:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[REFC]],
679 // CHECK-NEXT: [[C_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[C_PRIV]],
680 // CHECK-NEXT: [[DIV:%.+]] = sdiv i{{[0-9]+}} [[C_VAL]], 1
681 // CHECK-NEXT: store i{{[0-9]+}} [[DIV]], i{{[0-9]+}}* [[C_PRIV]],
682 // CHECK: call void @__kmpc_for_static_fini(
683 // CHECK: br i1
684 // CHECK: [[B_REF:%.+]] = getelementptr {{.*}}[[SS_TY]], [[SS_TY]]* %{{.*}}, i32 0, i32 1
685 // CHECK: store i8 %{{.+}}, i8* [[B_REF]],
686 // CHECK: br label
687 // CHECK: ret void
688
689 // CHECK: define internal void [[TMAIN_MICROTASK]](i{{[0-9]+}}* noalias [[GTID_ADDR:%.+]], i{{[0-9]+}}* noalias %{{.+}}, i32* dereferenceable(4) %{{.+}}, [2 x i32]* dereferenceable(8) %{{.+}}, [2 x [[S_INT_TY]]]* dereferenceable(8) %{{.+}}, [[S_INT_TY]]* dereferenceable(4) %{{.+}})
690 // CHECK: alloca i{{[0-9]+}},
691 // CHECK: alloca i{{[0-9]+}},
692 // CHECK: alloca i{{[0-9]+}},
693 // CHECK: alloca i{{[0-9]+}},
694 // CHECK: alloca i{{[0-9]+}},
695 // CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}}, align 128
696 // CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}], align 128
697 // CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_INT_TY]]], align 128
698 // CHECK: [[VAR_PRIV:%.+]] = alloca [[S_INT_TY]], align 128
699 // CHECK: [[VAR_PRIV_REF:%.+]] = alloca [[S_INT_TY]]*,
700 // CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]]
701
702 // CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** %
703 // CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}]*, [2 x i{{[0-9]+}}]** %
704 // CHECK: [[S_ARR_REF:%.+]] = load [2 x [[S_INT_TY]]]*, [2 x [[S_INT_TY]]]** %
705
706 // Check for default initialization.
707 // CHECK-NOT: [[T_VAR_PRIV]]
708 // CHECK-NOT: [[VEC_PRIV]]
709 // CHECK: [[S_ARR_PRIV_ITEM:%.+]] = phi [[S_INT_TY]]*
710 // CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR]]([[S_INT_TY]]* [[S_ARR_PRIV_ITEM]])
711 // CHECK: [[VAR_REF:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** %
712 // CHECK: call {{.*}} [[S_INT_TY_DEF_CONSTR]]([[S_INT_TY]]* [[VAR_PRIV]])
713 // CHECK: store [[S_INT_TY]]* [[VAR_PRIV]], [[S_INT_TY]]** [[VAR_PRIV_REF]]
714 // CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 %{{.+}}, i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
715 // <Skip loop body>
716 // CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 %{{.+}})
717
718 // Check for final copying of private values back to original vars.
719 // CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
720 // CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
721 // CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
722 // CHECK: [[LAST_THEN]]
723 // Actual copying.
724
725 // original t_var=private_t_var;
726 // CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PRIV]],
727 // CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_REF]],
728
729 // original vec[]=private_vec[];
730 // CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8*
731 // CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8*
732 // CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]],
733
734 // original s_arr[]=private_s_arr[];
735 // CHECK: [[S_ARR_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_INT_TY]]], [2 x [[S_INT_TY]]]* [[S_ARR_REF]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
736 // CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = bitcast [2 x [[S_INT_TY]]]* [[S_ARR_PRIV]] to [[S_INT_TY]]*
737 // CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_INT_TY]], [[S_INT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2
738 // CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_INT_TY]]* [[S_ARR_BEGIN]], [[S_ARR_END]]
739 // CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]
740 // CHECK: [[S_ARR_BODY]]
741 // CHECK: call {{.*}} [[S_INT_TY_COPY_ASSIGN:@.+]]([[S_INT_TY]]* {{.+}}, [[S_INT_TY]]* {{.+}})
742 // CHECK: br i1 {{.+}}, label %[[S_ARR_BODY_DONE]], label %[[S_ARR_BODY]]
743 // CHECK: [[S_ARR_BODY_DONE]]
744
745 // original var=private_var;
746 // CHECK: [[VAR_PRIV1:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** [[VAR_PRIV_REF]],
747 // CHECK: call {{.*}} [[S_INT_TY_COPY_ASSIGN:@.+]]([[S_INT_TY]]* [[VAR_REF]], [[S_INT_TY]]* {{.*}} [[VAR_PRIV1]])
748 // CHECK: br label %[[LAST_DONE]]
749 // CHECK: [[LAST_DONE]]
750 // CHECK-DAG: call void [[S_INT_TY_DESTR]]([[S_INT_TY]]* [[VAR_PRIV]])
751 // CHECK-DAG: call void [[S_INT_TY_DESTR]]([[S_INT_TY]]*
752 // CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[GTID_ADDR_REF]]
753 // CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
754 // CHECK: call void @__kmpc_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
755 // CHECK: ret void
756 #endif
757
758