1 // RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
2 // RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
3 // RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
4 // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -std=c++11 -fopenmp -fnoopenmp-use-tls -fexceptions -fcxx-exceptions -debug-info-kind=line-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
5 // RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -DARRAY -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck -check-prefix=ARRAY %s
6 // expected-no-diagnostics
7 // REQUIRES: x86-registered-target
8 #ifndef ARRAY
9 #ifndef HEADER
10 #define HEADER
11
12 class TestClass {
13 public:
14 int a;
TestClass()15 TestClass() : a(0) {}
TestClass(const TestClass & C)16 TestClass(const TestClass &C) : a(C.a) {}
operator =(const TestClass &)17 TestClass &operator=(const TestClass &) { return *this;}
~TestClass()18 ~TestClass(){};
19 };
20
21 // CHECK-DAG: [[TEST_CLASS_TY:%.+]] = type { i{{[0-9]+}} }
22 // CHECK-DAG: [[SST_TY:%.+]] = type { double }
23 // CHECK-DAG: [[SS_TY:%.+]] = type { i32, i8, i32* }
24 // CHECK-DAG: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
25 // CHECK: [[IMPLICIT_BARRIER_SINGLE_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 322, i32 0, i32 0, i8*
26
27 // CHECK: define void [[FOO:@.+]]()
28
29 TestClass tc;
30 TestClass tc2[2];
31 #pragma omp threadprivate(tc, tc2)
32
foo()33 void foo() {}
34
35 struct SS {
36 int a;
37 int b : 4;
38 int &c;
SSSS39 SS(int &d) : a(0), b(0), c(d) {
40 #pragma omp parallel firstprivate(a, b, c)
41 #pragma omp single copyprivate(a, this->b, (this)->c)
42 [&]() {
43 ++this->a, --b, (this)->c /= 1;
44 #pragma omp parallel firstprivate(a, b, c)
45 #pragma omp single copyprivate(a, this->b, (this)->c)
46 ++(this)->a, --b, this->c /= 1;
47 }();
48 }
49 };
50
51 template<typename T>
52 struct SST {
53 T a;
SSTSST54 SST() : a(T()) {
55 #pragma omp parallel firstprivate(a)
56 #pragma omp single copyprivate(this->a)
57 [&]() {
58 [&]() {
59 ++this->a;
60 #pragma omp parallel firstprivate(a)
61 #pragma omp single copyprivate((this)->a)
62 ++(this)->a;
63 }();
64 }();
65 }
66 };
67
68 // CHECK-LABEL: @main
69 // TERM_DEBUG-LABEL: @main
main()70 int main() {
71 // CHECK-DAG: [[A_ADDR:%.+]] = alloca i8
72 // CHECK-DAG: [[A2_ADDR:%.+]] = alloca [2 x i8]
73 // CHECK-DAG: [[C_ADDR:%.+]] = alloca [[TEST_CLASS_TY]]
74 char a;
75 char a2[2];
76 TestClass &c = tc;
77 SST<double> sst;
78 SS ss(c.a);
79
80 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:@.+]])
81 // CHECK-DAG: [[DID_IT:%.+]] = alloca i32,
82 // CHECK-DAG: [[COPY_LIST:%.+]] = alloca [5 x i8*],
83
84 // CHECK: [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
85 // CHECK-NEXT: [[IS_SINGLE:%.+]] = icmp ne i32 [[RES]], 0
86 // CHECK-NEXT: br i1 [[IS_SINGLE]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]]
87 // CHECK: [[THEN]]
88 // CHECK-NEXT: store i8 2, i8* [[A_ADDR]]
89 // CHECK-NEXT: call void @__kmpc_end_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
90 // CHECK-NEXT: br label {{%?}}[[EXIT]]
91 // CHECK: [[EXIT]]
92 // CHECK-NOT: call {{.+}} @__kmpc_cancel_barrier
93 #pragma omp single nowait
94 a = 2;
95 // CHECK: [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
96 // CHECK-NEXT: [[IS_SINGLE:%.+]] = icmp ne i32 [[RES]], 0
97 // CHECK-NEXT: br i1 [[IS_SINGLE]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]]
98 // CHECK: [[THEN]]
99 // CHECK-NEXT: store i8 2, i8* [[A_ADDR]]
100 // CHECK-NEXT: call void @__kmpc_end_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
101 // CHECK-NEXT: br label {{%?}}[[EXIT]]
102 // CHECK: [[EXIT]]
103 // CHECK: call{{.*}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_SINGLE_LOC]], i32 [[GTID]])
104 #pragma omp single
105 a = 2;
106 // CHECK: store i32 0, i32* [[DID_IT]]
107 // CHECK: [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
108 // CHECK-NEXT: [[IS_SINGLE:%.+]] = icmp ne i32 [[RES]], 0
109 // CHECK-NEXT: br i1 [[IS_SINGLE]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]]
110 // CHECK: [[THEN]]
111 // CHECK-NEXT: invoke void [[FOO]]()
112 // CHECK: to label {{%?}}[[CONT:.+]] unwind
113 // CHECK: [[CONT]]
114 // CHECK: call void @__kmpc_end_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
115 // CHECK: store i32 1, i32* [[DID_IT]]
116 // CHECK-NEXT: br label {{%?}}[[EXIT]]
117 // CHECK: [[EXIT]]
118 // CHECK: [[A_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
119 // CHECK: store i8* [[A_ADDR]], i8** [[A_PTR_REF]],
120 // CHECK: [[C_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 1
121 // CHECK: store i8* {{.+}}, i8** [[C_PTR_REF]],
122 // CHECK: [[TC_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 2
123 // CHECK: [[TC_THREADPRIVATE_ADDR_VOID_PTR:%.+]] = call{{.*}} i8* @__kmpc_threadprivate_cached
124 // CHECK: [[TC_THREADPRIVATE_ADDR:%.+]] = bitcast i8* [[TC_THREADPRIVATE_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
125 // CHECK: [[TC_PTR_REF_VOID_PTR:%.+]] = bitcast [[TEST_CLASS_TY]]* [[TC_THREADPRIVATE_ADDR]] to i8*
126 // CHECK: store i8* [[TC_PTR_REF_VOID_PTR]], i8** [[TC_PTR_REF]],
127 // CHECK: [[A2_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 3
128 // CHECK: [[BITCAST:%.+]] = bitcast [2 x i8]* [[A2_ADDR]] to i8*
129 // CHECK: store i8* [[BITCAST]], i8** [[A2_PTR_REF]],
130 // CHECK: [[TC2_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 4
131 // CHECK: [[TC2_THREADPRIVATE_ADDR_VOID_PTR:%.+]] = call{{.*}} i8* @__kmpc_threadprivate_cached
132 // CHECK: [[TC2_THREADPRIVATE_ADDR:%.+]] = bitcast i8* [[TC2_THREADPRIVATE_ADDR_VOID_PTR]] to [2 x [[TEST_CLASS_TY]]]*
133 // CHECK: [[TC2_PTR_REF_VOID_PTR:%.+]] = bitcast [2 x [[TEST_CLASS_TY]]]* [[TC2_THREADPRIVATE_ADDR]] to i8*
134 // CHECK: store i8* [[TC2_PTR_REF_VOID_PTR]], i8** [[TC2_PTR_REF]],
135 // CHECK: [[COPY_LIST_VOID_PTR:%.+]] = bitcast [5 x i8*]* [[COPY_LIST]] to i8*
136 // CHECK: [[DID_IT_VAL:%.+]] = load i32, i32* [[DID_IT]],
137 // CHECK: call void @__kmpc_copyprivate([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i64 40, i8* [[COPY_LIST_VOID_PTR]], void (i8*, i8*)* [[COPY_FUNC:@.+]], i32 [[DID_IT_VAL]])
138 // CHECK-NOT: call {{.+}} @__kmpc_cancel_barrier
139 #pragma omp single copyprivate(a, c, tc, a2, tc2)
140 foo();
141 // CHECK-NOT: call i32 @__kmpc_single
142 // CHECK-NOT: call void @__kmpc_end_single
143 return a;
144 }
145
146 // CHECK: void [[COPY_FUNC]](i8*, i8*)
147 // CHECK: store i8* %0, i8** [[DST_ADDR_REF:%.+]],
148 // CHECK: store i8* %1, i8** [[SRC_ADDR_REF:%.+]],
149 // CHECK: [[DST_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[DST_ADDR_REF]],
150 // CHECK: [[DST_ADDR:%.+]] = bitcast i8* [[DST_ADDR_VOID_PTR]] to [5 x i8*]*
151 // CHECK: [[SRC_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[SRC_ADDR_REF]],
152 // CHECK: [[SRC_ADDR:%.+]] = bitcast i8* [[SRC_ADDR_VOID_PTR]] to [5 x i8*]*
153 // CHECK: [[DST_A_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
154 // CHECK: [[DST_A_ADDR:%.+]] = load i8*, i8** [[DST_A_ADDR_REF]],
155 // CHECK: [[SRC_A_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
156 // CHECK: [[SRC_A_ADDR:%.+]] = load i8*, i8** [[SRC_A_ADDR_REF]],
157 // CHECK: [[SRC_A_VAL:%.+]] = load i8, i8* [[SRC_A_ADDR]],
158 // CHECK: store i8 [[SRC_A_VAL]], i8* [[DST_A_ADDR]],
159 // CHECK: [[DST_C_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 1
160 // CHECK: [[DST_C_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[DST_C_ADDR_REF]],
161 // CHECK: [[DST_C_ADDR:%.+]] = bitcast i8* [[DST_C_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
162 // CHECK: [[SRC_C_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 1
163 // CHECK: [[SRC_C_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[SRC_C_ADDR_REF]],
164 // CHECK: [[SRC_C_ADDR:%.+]] = bitcast i8* [[SRC_C_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
165 // CHECK: call{{.*}} [[TEST_CLASS_TY_ASSIGN:@.+]]([[TEST_CLASS_TY]]* [[DST_C_ADDR]], [[TEST_CLASS_TY]]* {{.*}}[[SRC_C_ADDR]])
166 // CHECK: [[DST_TC_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 2
167 // CHECK: [[DST_TC_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[DST_TC_ADDR_REF]],
168 // CHECK: [[DST_TC_ADDR:%.+]] = bitcast i8* [[DST_TC_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
169 // CHECK: [[SRC_TC_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 2
170 // CHECK: [[SRC_TC_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[SRC_TC_ADDR_REF]],
171 // CHECK: [[SRC_TC_ADDR:%.+]] = bitcast i8* [[SRC_TC_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
172 // CHECK: call{{.*}} [[TEST_CLASS_TY_ASSIGN]]([[TEST_CLASS_TY]]* [[DST_TC_ADDR]], [[TEST_CLASS_TY]]* {{.*}}[[SRC_TC_ADDR]])
173 // CHECK: [[DST_A2_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 3
174 // CHECK: [[DST_A2_ADDR:%.+]] = load i8*, i8** [[DST_A2_ADDR_REF]],
175 // CHECK: [[SRC_A2_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 3
176 // CHECK: [[SRC_A2_ADDR:%.+]] = load i8*, i8** [[SRC_A2_ADDR_REF]],
177 // CHECK: call void @llvm.memcpy.{{.+}}(i8* [[DST_A2_ADDR]], i8* [[SRC_A2_ADDR]], i{{[0-9]+}} 2, i{{[0-9]+}} 1, i1 false)
178 // CHECK: [[DST_TC2_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 4
179 // CHECK: [[DST_TC2_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[DST_TC2_ADDR_REF]],
180 // CHECK: [[DST_TC2_ADDR:%.+]] = bitcast i8* [[DST_TC2_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
181 // CHECK: [[SRC_TC2_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 4
182 // CHECK: [[SRC_TC2_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[SRC_TC2_ADDR_REF]],
183 // CHECK: [[SRC_TC2_ADDR:%.+]] = bitcast i8* [[SRC_TC2_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
184 // CHECK: br i1
185 // CHECK: call{{.*}} [[TEST_CLASS_TY_ASSIGN]]([[TEST_CLASS_TY]]* %{{.+}}, [[TEST_CLASS_TY]]* {{.*}})
186 // CHECK: br i1
187 // CHECK: ret void
188
189 // CHECK-LABEL: parallel_single
190 // TERM_DEBUG-LABEL: parallel_single
parallel_single()191 void parallel_single() {
192 #pragma omp parallel
193 #pragma omp single
194 // TERM_DEBUG-NOT: __kmpc_global_thread_num
195 // TERM_DEBUG: call i32 @__kmpc_single({{.+}}), !dbg [[DBG_LOC_START:![0-9]+]]
196 // TERM_DEBUG: invoke void {{.*}}foo{{.*}}()
197 // TERM_DEBUG: unwind label %[[TERM_LPAD:.+]],
198 // TERM_DEBUG-NOT: __kmpc_global_thread_num
199 // TERM_DEBUG: call void @__kmpc_end_single({{.+}}), !dbg [[DBG_LOC_END:![0-9]+]]
200 // TERM_DEBUG: [[TERM_LPAD]]
201 // TERM_DEBUG: call void @__clang_call_terminate
202 // TERM_DEBUG: unreachable
203 foo();
204 }
205 // TERM_DEBUG-DAG: [[DBG_LOC_START]] = !DILocation(line: [[@LINE-12]],
206 // TERM_DEBUG-DAG: [[DBG_LOC_END]] = !DILocation(line: [[@LINE-3]],
207 #endif
208 #else
209 // ARRAY-LABEL: array_func
210 struct St {
211 int a, b;
StSt212 St() : a(0), b(0) {}
operator =St213 St &operator=(const St &) { return *this; };
~StSt214 ~St() {}
215 };
216
array_func(int n,int a[n],St s[2])217 void array_func(int n, int a[n], St s[2]) {
218 // ARRAY: call void @__kmpc_copyprivate(%ident_t* @{{.+}}, i32 %{{.+}}, i64 16, i8* %{{.+}}, void (i8*, i8*)* [[CPY:@.+]], i32 %{{.+}})
219 #pragma omp single copyprivate(a, s)
220 ;
221 }
222 // ARRAY: define internal void [[CPY]]
223 // ARRAY: store i32* %{{.+}}, i32** %{{.+}},
224 // ARRAY: store %struct.St* %{{.+}}, %struct.St** %{{.+}},
225 #endif
226
227 // CHECK-LABEL:@_ZN2SSC2ERi(
228 // CHECK: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* @{{.+}}, i32 4, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, [[SS_TY]]*, i64, i64, i64)* [[SS_MICROTASK:@.+]] to void
229 // CHECK-NEXT: ret void
230
231 // CHECK: define internal void [[SS_MICROTASK]](i32* {{[^,]+}}, i32* {{[^,]+}}, [[SS_TY]]* {{.+}}, i64 {{.+}}, i64 {{.+}}, i64 {{.+}})
232 // Private a
233 // CHECK: alloca i64,
234 // Private b
235 // CHECK: alloca i64,
236 // Private c
237 // CHECK: alloca i64,
238 // CHECK: alloca i32*,
239 // CHECK: alloca i32*,
240 // CHECK: alloca i32*,
241 // CHECK: alloca i32*,
242 // CHECK: [[DID_IT:%.+]] = alloca i32,
243 // CHECK: bitcast i64* %{{.+}} to i32*
244 // CHECK: bitcast i64* %{{.+}} to i32*
245 // CHECK: bitcast i64* %{{.+}} to i32*
246 // CHECK: store i32 0, i32* [[DID_IT]],
247 // CHECK: [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
248 // CHECK-NEXT: icmp ne i32 [[RES]], 0
249 // CHECK-NEXT: br i1
250
251 // CHECK: getelementptr inbounds [[CAP_TY:%.+]], [[CAP_TY]]* [[CAP:%.+]], i32 0, i32 0
252 // CHECK: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 1
253 // CHECK-NEXT: load i32*, i32** %
254 // CHECK-NEXT: store i32* %
255 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 2
256 // CHECK-NEXT: store i32* %
257 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 3
258 // CHECK-NEXT: load i32*, i32** %
259 // CHECK-NEXT: store i32* %
260 // CHECK-LABEL: invoke void @_ZZN2SSC1ERiENKUlvE_clEv(
261 // CHECK-SAME: [[CAP_TY]]* [[CAP]])
262
263 // CHECK: call void @__kmpc_end_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
264 // CHECK: store i32 1, i32* [[DID_IT]],
265 // CHECK: br label
266
267 // CHECK: call void @__kmpc_end_single(%{{.+}}* @{{.+}}, i32 %{{.+}})
268 // CHECK: br label
269
270 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST:%.+]], i64 0, i64 0
271 // CHECK: load i32*, i32** %
272 // CHECK-NEXT: bitcast i32* %
273 // CHECK-NEXT: store i8* %
274 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST]], i64 0, i64 1
275 // CHECK-NEXT: bitcast i32* %
276 // CHECK-NEXT: store i8* %
277 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST]], i64 0, i64 2
278 // CHECK: load i32*, i32** %
279 // CHECK-NEXT: bitcast i32* %
280 // CHECK-NEXT: store i8* %
281 // CHECK-NEXT: bitcast [3 x i8*]* [[LIST]] to i8*
282 // CHECK-NEXT: load i32, i32* [[DID_IT]],
283 // CHECK-NEXT: call void @__kmpc_copyprivate([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}}, i64 24, i8* %{{.+}}, void (i8*, i8*)* [[COPY_FUNC:@[^,]+]], i32 %{{.+}})
284 // CHECK-NEXT: ret void
285
286 // CHECK-LABEL: @_ZZN2SSC1ERiENKUlvE_clEv(
287 // CHECK: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP:%.+]], i32 0, i32 1
288 // CHECK-NEXT: load i32*, i32** %
289 // CHECK-NEXT: load i32, i32* %
290 // CHECK-NEXT: add nsw i32 %{{.+}}, 1
291 // CHECK-NEXT: store i32 %
292 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 2
293 // CHECK-NEXT: load i32*, i32** %
294 // CHECK-NEXT: load i32, i32* %
295 // CHECK-NEXT: add nsw i32 %{{.+}}, -1
296 // CHECK-NEXT: store i32 %
297 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 3
298 // CHECK-NEXT: load i32*, i32** %
299 // CHECK-NEXT: load i32, i32* %
300 // CHECK-NEXT: sdiv i32 %{{.+}}, 1
301 // CHECK-NEXT: store i32 %
302 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 1
303 // CHECK-NEXT: load i32*, i32** %
304 // CHECK-NEXT: load i32, i32* %
305 // CHECK-NEXT: bitcast i64* %
306 // CHECK-NEXT: store i32 %{{.+}}, i32* %
307 // CHECK-NEXT: load i64, i64* %
308 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 2
309 // CHECK-NEXT: load i32*, i32** %
310 // CHECK-NEXT: load i32, i32* %
311 // CHECK-NEXT: bitcast i64* %
312 // CHECK-NEXT: store i32 %{{.+}}, i32* %
313 // CHECK-NEXT: load i64, i64* %
314 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 3
315 // CHECK-NEXT: load i32*, i32** %
316 // CHECK-NEXT: load i32, i32* %
317 // CHECK-NEXT: bitcast i64* %
318 // CHECK-NEXT: store i32 %{{.+}}, i32* %
319 // CHECK-NEXT: load i64, i64* %
320 // CHECK-NEXT: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* @{{.+}}, i32 4, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, [[SS_TY]]*, i64, i64, i64)* [[SS_MICROTASK1:@.+]] to void
321 // CHECK-NEXT: ret void
322
323 // CHECK: define internal void [[COPY_FUNC]](i8*, i8*)
324 // CHECK: ret void
325
326 // CHECK: define internal void [[SS_MICROTASK1]](i32* {{[^,]+}}, i32* {{[^,]+}}, [[SS_TY]]* {{.+}}, i64 {{.+}}, i64 {{.+}}, i64 {{.+}})
327 // Private a
328 // CHECK: alloca i64,
329 // Private b
330 // CHECK: alloca i64,
331 // Private c
332 // CHECK: alloca i64,
333 // CHECK: alloca i32*,
334 // CHECK: alloca i32*,
335 // CHECK: alloca i32*,
336 // CHECK: alloca i32*,
337 // CHECK: [[DID_IT:%.+]] = alloca i32,
338 // CHECK: bitcast i64* %{{.+}} to i32*
339 // CHECK: bitcast i64* %{{.+}} to i32*
340 // CHECK: bitcast i64* %{{.+}} to i32*
341 // CHECK: [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
342 // CHECK-NEXT: icmp ne i32 [[RES]], 0
343 // CHECK-NEXT: br i1
344
345 // CHECK-NOT: getelementptr inbounds
346 // CHECK: load i32*, i32** %
347 // CHECK-NEXT: load i32, i32* %
348 // CHECK-NEXT: add nsw i32 %{{.+}}, 1
349 // CHECK-NEXT: store i32 %
350 // CHECK-NOT: getelementptr inbounds
351 // CHECK: load i32, i32* %
352 // CHECK-NEXT: add nsw i32 %{{.+}}, -1
353 // CHECK-NEXT: store i32 %
354 // CHECK-NOT: getelementptr inbounds
355 // CHECK: load i32*, i32** %
356 // CHECK-NEXT: load i32, i32* %
357 // CHECK-NEXT: sdiv i32 %{{.+}}, 1
358 // CHECK-NEXT: store i32 %
359 // CHECK-NEXT: call void @__kmpc_end_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
360 // CHECK-NEXT: store i32 1, i32* [[DID_IT]],
361 // CHECK-NEXT: br label
362
363 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST:%.+]], i64 0, i64 0
364 // CHECK: load i32*, i32** %
365 // CHECK-NEXT: bitcast i32* %
366 // CHECK-NEXT: store i8* %
367 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST]], i64 0, i64 1
368 // CHECK-NEXT: bitcast i32* %
369 // CHECK-NEXT: store i8* %
370 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST]], i64 0, i64 2
371 // CHECK: load i32*, i32** %
372 // CHECK-NEXT: bitcast i32* %
373 // CHECK-NEXT: store i8* %
374 // CHECK-NEXT: bitcast [3 x i8*]* [[LIST]] to i8*
375 // CHECK-NEXT: load i32, i32* [[DID_IT]],
376 // CHECK-NEXT: call void @__kmpc_copyprivate([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}}, i64 24, i8* %{{.+}}, void (i8*, i8*)* [[COPY_FUNC:@[^,]+]], i32 %{{.+}})
377 // CHECK-NEXT: ret void
378
379 // CHECK: define internal void [[COPY_FUNC]](i8*, i8*)
380 // CHECK: ret void
381
382 // CHECK-LABEL: @_ZN3SSTIdEC2Ev
383 // CHECK: getelementptr inbounds [[SST_TY]], [[SST_TY]]* %{{.+}}, i32 0, i32 0
384 // CHECK-NEXT: store double 0.000000e+00, double* %
385 // CHECK-NEXT: getelementptr inbounds [[SST_TY]], [[SST_TY]]* %{{.+}}, i32 0, i32 0
386 // CHECK-NEXT: store double* %{{.+}}, double** %
387 // CHECK-NEXT: load double*, double** %
388 // CHECK-NEXT: load double, double* %
389 // CHECK-NEXT: bitcast i64* %{{.+}} to double*
390 // CHECK-NEXT: store double %{{.+}}, double* %
391 // CHECK-NEXT: load i64, i64* %
392 // CHECK-NEXT: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* @{{.+}}, i32 2, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, [[SST_TY]]*, i64)* [[SST_MICROTASK:@.+]] to void
393 // CHECK-NEXT: ret void
394
395 // CHECK: define internal void [[SST_MICROTASK]](i32* {{[^,]+}}, i32* {{[^,]+}}, [[SST_TY]]* {{.+}}, i64 {{.+}})
396 // CHECK: [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
397 // CHECK-NEXT: icmp ne i32 [[RES]], 0
398 // CHECK-NEXT: br i1
399
400 // CHECK: getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i32 0, i32 1
401 // CHECK-NEXT: load double*, double** %
402 // CHECK-NEXT: store double* %
403 // CHECK-LABEL: invoke void @_ZZN3SSTIdEC1EvENKUlvE_clEv(
404
405 // CHECK: call void @__kmpc_end_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
406 // CHECK-NEXT: store i32 1, i32* [[DID_IT]],
407 // CHECK-NEXT: br label
408
409 // CHECK: call void @__kmpc_end_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
410 // CHECK-NEXT: br label
411
412 // CHECK: getelementptr inbounds [1 x i8*], [1 x i8*]* [[LIST:%.+]], i64 0, i64 0
413 // CHECK: load double*, double** %
414 // CHECK-NEXT: bitcast double* %
415 // CHECK-NEXT: store i8* %
416 // CHECK-NEXT: bitcast [1 x i8*]* [[LIST]] to i8*
417 // CHECK-NEXT: load i32, i32* [[DID_IT]],
418 // CHECK-NEXT: call void @__kmpc_copyprivate([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}}, i64 8, i8* %{{.+}}, void (i8*, i8*)* [[COPY_FUNC:@[^,]+]], i32 %{{.+}})
419 // CHECK-NEXT: ret void
420
421 // CHECK-LABEL: @_ZZN3SSTIdEC1EvENKUlvE_clEv(
422 // CHECK: getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i32 0, i32 1
423 // CHECK-NEXT: getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i32 0, i32 1
424 // CHECK-NEXT: load double*, double** %
425 // CHECK-NEXT: store double* %
426 // CHECK-LABEL: call void @_ZZZN3SSTIdEC1EvENKUlvE_clEvENKUlvE_clEv(
427 // CHECK-NEXT: ret void
428
429 // CHECK: define internal void [[COPY_FUNC]](i8*, i8*)
430 // CHECK: ret void
431
432 // CHECK-LABEL: @_ZZZN3SSTIdEC1EvENKUlvE_clEvENKUlvE_clEv(
433