Clang Project

clang_source_code/test/OpenMP/target_teams_distribute_parallel_for_reduction_codegen.cpp
1// RUN: %clang_cc1 -DCHECK -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
2// RUN: %clang_cc1 -DCHECK -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
3// RUN: %clang_cc1 -DCHECK -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
4// RUN: %clang_cc1 -DCHECK -verify -fopenmp -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-32
5// RUN: %clang_cc1 -DCHECK -fopenmp -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -o %t %s
6// RUN: %clang_cc1 -DCHECK -fopenmp -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-32
7
8// RUN: %clang_cc1 -DLAMBDA -verify -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix LAMBDA --check-prefix LAMBDA-64
9// RUN: %clang_cc1 -DLAMBDA -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
10// RUN: %clang_cc1 -DLAMBDA -fopenmp -x c++  -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix LAMBDA --check-prefix LAMBDA-64
11
12// RUN: %clang_cc1 -DCHECK -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix SIMD-ONLY 
13// RUN: %clang_cc1 -DCHECK -fopenmp-simd -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
14// RUN: %clang_cc1 -DCHECK -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix SIMD-ONLY 
15// RUN: %clang_cc1 -DCHECK -verify -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix SIMD-ONLY
16// RUN: %clang_cc1 -DCHECK -fopenmp-simd -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -o %t %s
17// RUN: %clang_cc1 -DCHECK -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix SIMD-ONLY
18
19// RUN: %clang_cc1 -DLAMBDA -verify -fopenmp-simd -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix SIMD-ONLY
20// RUN: %clang_cc1 -DLAMBDA -fopenmp-simd -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
21// RUN: %clang_cc1 -DLAMBDA -fopenmp-simd -x c++  -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix SIMD-ONLY 
22// SIMD-ONLY-NOT: {{__kmpc|__tgt}}
23
24// expected-no-diagnostics
25#ifndef HEADER
26#define HEADER
27
28template <typename T>
29T tmain() {
30  T t_var = T();
31  T vec[] = {1, 2};
32#pragma omp target teams distribute parallel for reduction(+: t_var)
33  for (int i = 0; i < 2; ++i) {
34    t_var += (T) i;
35  }
36  return T();
37}
38
39int main() {
40  static int sivar;
41#ifdef LAMBDA
42  // LAMBDA: [[RED_VAR:@.+]] = common global [8 x {{.+}}] zeroinitializer
43
44  // LAMBDA-LABEL: @main
45  // LAMBDA: call void [[OUTER_LAMBDA:@.+]](
46  [&]() {
47    // LAMBDA: define{{.*}} internal{{.*}} void [[OUTER_LAMBDA]](
48    // LAMBDA: call i32 @__tgt_target_teams(i64 -1, i8* @{{[^,]+}}, i32 1, i8** %{{[^,]+}}, i8** %{{[^,]+}}, i{{64|32}}* {{.+}}@{{[^,]+}}, i32 0, i32 0), i64* {{.+}}@{{[^,]+}}, i32 0, i32 0), i32 0, i32 0)
49    // LAMBDA: call void @[[LOFFL1:.+]](
50    // LAMBDA:  ret
51#pragma omp target teams distribute parallel for reduction(+: sivar)
52  for (int i = 0; i < 2; ++i) {
53    // LAMBDA: define{{.*}} internal{{.*}} void @[[LOFFL1]](i{{64|32}}*{{.*}} [[SIVAR_ARG:%.+]])
54    // LAMBDA: [[SIVAR_ADDR:%.+]] = alloca i{{.+}},
55    // LAMBDA: store{{.+}} [[SIVAR_ARG]], {{.+}} [[SIVAR_ADDR]],
56    // LAMBDA: [[SIVAR_PAR:%.+]] = load{{.+}}, {{.+}} [[SIVAR_ADDR]],
57    // LAMBDA: call void {{.+}} @__kmpc_fork_teams({{.+}}, i32 1, {{.+}} @[[LOUTL1:.+]] to {{.+}}, {{.+}} [[SIVAR_PAR]])
58    // LAMBDA: ret void
59
60    // LAMBDA: define internal void @[[LOUTL1]]({{.+}}, {{.+}}, {{.+}} [[SIVAR_ARG:%.+]])
61    // Skip global and bound tid vars
62    // LAMBDA: {{.+}} = alloca i32*,
63    // LAMBDA: {{.+}} = alloca i32*,
64    // LAMBDA: [[SIVAR_ADDR:%.+]] = alloca i{{.+}},
65    // LAMBDA: [[SIVAR_PRIV:%.+]] = alloca i{{.+}},
66    // LAMBDA: [[RED_LIST:%.+]] = alloca [1 x {{.+}}],
67    // LAMBDA: store{{.+}} [[SIVAR_ARG]], {{.+}} [[SIVAR_ADDR]],
68    // LAMBDA: [[SIVAR_REF:%.+]] = load{{.+}}, {{.+}} [[SIVAR_ADDR]]
69    // LAMBDA: store{{.+}} 0, {{.+}} [[SIVAR_PRIV]],
70
71    // LAMBDA: call void @__kmpc_for_static_init_4(
72    // LAMBDA: call void {{.*}} @__kmpc_fork_call({{.+}}, {{.+}}, {{.+}} @[[LPAR_OUTL:.+]] to
73    // LAMBDA: call void @__kmpc_for_static_fini(
74    // LAMBDA: [[RED_LIST_GEP:%.+]] = getelementptr{{.+}} [[RED_LIST]],
75    // LAMBDA: [[SIVAR_PRIV_CAST:%.+]] = bitcast{{.+}} [[SIVAR_PRIV]] to
76    // LAMBDA: store{{.+}} [[SIVAR_PRIV_CAST]], {{.+}} [[RED_LIST_GEP]],
77    // LAMBDA: [[RED_LIST_BCAST:%.+]] = bitcast{{.+}} [[RED_LIST]] to
78    // LAMBDA: [[K_RED_RET:%.+]] = call{{.+}} @__kmpc_reduce_nowait({{.+}}, {{.+}}, {{.+}}, {{.+}}, {{.+}} [[RED_LIST_BCAST]], {{.+}} [[RED_FUN:@.+]], {{.+}} [[RED_VAR]])
79    // LAMBDA: switch{{.+}} [[K_RED_RET]], label{{.+}} [
80    // LAMBDA: {{.+}}, label %[[CASE1:.+]]
81    // LAMBDA: {{.+}}, label %[[CASE2:.+]]
82    // LAMBDA: ]
83    // LAMBDA: [[CASE1]]:
84    // LAMBDA-DAG: [[SIVAR_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_REF]],
85    // LAMBDA-DAG: [[SIVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_PRIV]],
86    // LAMBDA-DAG: [[SIVAR_INC:%.+]] = add{{.+}} [[SIVAR_VAL]], [[SIVAR_PRIV_VAL]]
87    // LAMBDA: store{{.+}} [[SIVAR_INC]], {{.+}} [[SIVAR_REF]],
88    // LAMBDA: call void @__kmpc_end_reduce_nowait({{.+}}, {{.+}}, {{.+}} [[RED_VAR]])
89    // LAMBDA: br
90    // LAMBDA: [[CASE2]]:
91    // LAMBDA-DAG: [[SIVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_PRIV]],
92    // LAMBDA-DAG: [[ATOMIC_RES:%.+]] = atomicrmw add{{.+}} [[SIVAR_REF]], {{.+}} [[SIVAR_PRIV_VAL]]
93    // LAMBDA: br
94
95    // LAMBDA: define internal void @[[LPAR_OUTL]]({{.+}}, {{.+}}, {{.+}}, {{.+}}, {{.+}} [[SIVAR_ARG:%.+]])
96
97    // Skip global and bound tid vars, and prev lb and ub vars
98    // LAMBDA: {{.+}} = alloca i32*,
99    // LAMBDA: {{.+}} = alloca i32*,
100    // LAMBDA: alloca i{{[0-9]+}},
101    // LAMBDA: alloca i{{[0-9]+}},
102    // LAMBDA: [[SIVAR_ADDR:%.+]] = alloca i{{.+}},
103    // skip loop vars
104    // LAMBDA: alloca i32,
105    // LAMBDA: alloca i32,
106    // LAMBDA: alloca i32,
107    // LAMBDA: alloca i32,
108    // LAMBDA: alloca i32,
109    // LAMBDA: alloca i32,
110    // LAMBDA: [[SIVAR_PRIV:%.+]] = alloca i{{.+}},
111    // LAMBDA: [[RED_LIST:%.+]] = alloca [1 x {{.+}}],
112    // LAMBDA: store{{.+}} [[SIVAR_ARG]], {{.+}} [[SIVAR_ADDR]],
113    // LAMBDA: [[SIVAR_REF:%.+]] = load {{.+}} [[SIVAR_ADDR]]
114    // LAMBDA: store{{.+}} 0, {{.+}} [[SIVAR_PRIV]],
115
116    // LAMBDA: call void @__kmpc_for_static_init_4(
117     // LAMBDA: store{{.+}}, {{.+}} [[SIVAR_PRIV]],
118    // LAMBDA: call void [[INNER_LAMBDA:@.+]](
119    // LAMBDA: call void @__kmpc_for_static_fini(
120    // LAMBDA: [[RED_LIST_GEP:%.+]] = getelementptr{{.+}} [[RED_LIST]],
121    // LAMBDA: [[SIVAR_PRIV_CAST:%.+]] = bitcast{{.+}} [[SIVAR_PRIV]] to
122    // LAMBDA: store{{.+}} [[SIVAR_PRIV_CAST]], {{.+}} [[RED_LIST_GEP]],
123    // LAMBDA: [[RED_LIST_BCAST:%.+]] = bitcast{{.+}} [[RED_LIST]] to
124    // LAMBDA: [[K_RED_RET:%.+]] = call{{.+}} @__kmpc_reduce_nowait({{.+}}, {{.+}}, {{.+}}, {{.+}}, {{.+}} [[RED_LIST_BCAST]], {{.+}} [[RED_FUN:@.+]], {{.+}} [[RED_VAR]])
125    // LAMBDA: switch{{.+}} [[K_RED_RET]], label{{.+}} [
126    // LAMBDA: {{.+}}, label %[[CASE1:.+]]
127    // LAMBDA: {{.+}}, label %[[CASE2:.+]]
128    // LAMBDA: ]
129    // LAMBDA: [[CASE1]]:
130    // LAMBDA-64-DAG: [[SIVAR_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_REF]],
131    // LAMBDA-32-DAG: [[SIVAR_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_ADDR]],
132    // LAMBDA-DAG: [[SIVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_PRIV]],
133    // LAMBDA-DAG: [[SIVAR_INC:%.+]] = add{{.+}} [[SIVAR_VAL]], [[SIVAR_PRIV_VAL]]
134    // LAMBDA: store{{.+}} [[SIVAR_INC]], {{.+}} [[SIVAR_REF]],
135    // LAMBDA: call void @__kmpc_end_reduce_nowait({{.+}}, {{.+}}, {{.+}} [[RED_VAR]])
136    // LAMBDA: br
137    // LAMBDA: [[CASE2]]:
138    // LAMBDA-DAG: [[SIVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_PRIV]],
139    // LAMBDA-DAG: [[ATOMIC_RES:%.+]] = atomicrmw add{{.+}} [[SIVAR_REF]], {{.+}} [[SIVAR_PRIV_VAL]]
140    // LAMBDA: br
141
142    sivar += i;
143
144    [&]() {
145      // LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]])
146      // LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]],
147
148      sivar += 4;
149      // LAMBDA: [[ARG_PTR:%.+]] = load %{{.+}}*, %{{.+}}** [[ARG_PTR_REF]]
150
151      // LAMBDA: [[SIVAR_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
152      // LAMBDA: [[SIVAR_REF:%.+]] = load i{{[0-9]+}}*, i{{[0-9]+}}** [[SIVAR_PTR_REF]]
153      // LAMBDA: [[SIVAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[SIVAR_REF]]
154      // LAMBDA: [[SIVAR_INC:%.+]] = add{{.+}} [[SIVAR_VAL]], 4
155      // LAMBDA: store i{{[0-9]+}} [[SIVAR_INC]], i{{[0-9]+}}* [[SIVAR_REF]]
156    }();
157  }
158  }();
159  return 0;
160#else
161#pragma omp target teams distribute parallel for reduction(+: sivar)
162  for (int i = 0; i < 2; ++i) {
163    sivar += i;
164  }
165  return tmain<int>();
166#endif
167}
168
169// CHECK: [[RED_VAR:@.+]] = common global [8 x {{.+}}] zeroinitializer
170
171// CHECK: define {{.*}}i{{[0-9]+}} @main()
172// CHECK: call i32 @__tgt_target_teams(i64 -1, i8* @{{[^,]+}}, i32 1, i8** %{{[^,]+}}, i8** %{{[^,]+}}, i{{64|32}}* {{.+}}@{{[^,]+}}, i32 0, i32 0), i64* {{.+}}@{{[^,]+}}, i32 0, i32 0), i32 0, i32 0)
173// CHECK: call void @[[OFFL1:.+]](i{{64|32}}* @{{.+}})
174// CHECK: {{%.+}} = call{{.*}} i32 @[[TMAIN_INT:.+]]()
175// CHECK:  ret
176
177// CHECK: define{{.*}} void @[[OFFL1]](i{{64|32}}*{{.*}} [[SIVAR_ARG:%.+]])
178// CHECK: [[SIVAR_ADDR:%.+]] = alloca i{{.+}},
179// CHECK: store{{.+}} [[SIVAR_ARG]], {{.+}} [[SIVAR_ADDR]],
180// CHECK: [[SIVAR_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_ADDR]]
181// CHECK: call void {{.+}} @__kmpc_fork_teams({{.+}}, i32 1, {{.+}} @[[OUTL1:.+]] to {{.+}}, {{.+}} [[SIVAR_VAL]])
182// CHECK: ret void
183
184// CHECK: define internal void @[[OUTL1]]({{.+}}, {{.+}}, {{.+}} [[SIVAR_ARG:%.+]])
185// Skip global and bound tid vars
186// CHECK: {{.+}} = alloca i32*,
187// CHECK: {{.+}} = alloca i32*,
188// CHECK: [[SIVAR_ADDR:%.+]] = alloca i{{.+}},
189// CHECK: [[SIVAR_PRIV:%.+]] = alloca i{{.+}},
190// CHECK: [[RED_LIST:%.+]] = alloca [1 x {{.+}}],
191// CHECK: store{{.+}} [[SIVAR_ARG]], {{.+}} [[SIVAR_ADDR]],
192// CHECK: [[SIVAR_REF:%.+]] = load{{.+}} [[SIVAR_ADDR]],
193// CHECK: store{{.+}} 0, {{.+}} [[SIVAR_PRIV]],
194
195// CHECK: call void @__kmpc_for_static_init_4(
196// CHECK: call void {{.*}} @__kmpc_fork_call({{.+}}, {{.+}}, {{.+}} @[[PAR_OUTL:.+]] to
197// CHECK: call void @__kmpc_for_static_fini(
198// CHECK: [[RED_LIST_GEP:%.+]] = getelementptr{{.+}} [[RED_LIST]],
199// CHECK: [[SIVAR_PRIV_CAST:%.+]] = bitcast{{.+}} [[SIVAR_PRIV]] to
200// CHECK: store{{.+}} [[SIVAR_PRIV_CAST]], {{.+}} [[RED_LIST_GEP]],
201// CHECK: [[RED_LIST_BCAST:%.+]] = bitcast{{.+}} [[RED_LIST]] to
202// CHECK: [[K_RED_RET:%.+]] = call{{.+}} @__kmpc_reduce_nowait({{.+}}, {{.+}}, {{.+}}, {{.+}}, {{.+}} [[RED_LIST_BCAST]], {{.+}} [[RED_FUN:@.+]], {{.+}} [[RED_VAR]])
203// CHECK: switch{{.+}} [[K_RED_RET]], label{{.+}} [
204// CHECK: {{.+}}, label %[[CASE1:.+]]
205// CHECK: {{.+}}, label %[[CASE2:.+]]
206// CHECK: ]
207// CHECK: [[CASE1]]:
208// CHECK-DAG: [[SIVAR_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_REF]],
209// CHECK-DAG: [[SIVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_PRIV]],
210// CHECK-DAG: [[SIVAR_INC:%.+]] = add{{.+}} [[SIVAR_VAL]], [[SIVAR_PRIV_VAL]]
211// CHECK: store{{.+}} [[SIVAR_INC]], {{.+}} [[SIVAR_REF]],
212// CHECK: call void @__kmpc_end_reduce_nowait({{.+}}, {{.+}}, {{.+}} [[RED_VAR]])
213// CHECK: br
214// CHECK: [[CASE2]]:
215// CHECK-DAG: [[SIVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_PRIV]],
216// CHECK-DAG: [[ATOMIC_RES:%.+]] = atomicrmw add{{.+}} [[SIVAR_REF]], {{.+}} [[SIVAR_PRIV_VAL]]
217// CHECK: br
218
219// CHECK: define internal void @[[PAR_OUTL]]({{.+}}, {{.+}}, {{.+}}, {{.+}}, {{.+}} [[SIVAR_ARG:%.+]])
220// Skip global and bound tid vars, and prev lb and ub
221// CHECK: {{.+}} = alloca i32*,
222// CHECK: {{.+}} = alloca i32*,
223// CHECK: alloca i{{[0-9]+}},
224// CHECK: alloca i{{[0-9]+}},
225// CHECK: [[SIVAR_ADDR:%.+]] = alloca i{{.+}},
226// skip loop vars
227// CHECK: alloca i32,
228// CHECK: alloca i32,
229// CHECK: alloca i32,
230// CHECK: alloca i32,
231// CHECK: alloca i32,
232// CHECK: alloca i32,
233// CHECK: [[SIVAR_PRIV:%.+]] = alloca i{{.+}},
234// CHECK: [[RED_LIST:%.+]] = alloca [1 x {{.+}}],
235// CHECK: store{{.+}} [[SIVAR_ARG]], {{.+}} [[SIVAR_ADDR]],
236// CHECK-64: [[SIVAR_REF:%.+]] = load {{.+}} [[SIVAR_ADDR]],
237// CHECK: store{{.+}} 0, {{.+}} [[SIVAR_PRIV]],
238
239// CHECK: call void @__kmpc_for_static_init_4(
240// CHECK: store{{.+}}, {{.+}} [[SIVAR_PRIV]],
241// CHECK: call void @__kmpc_for_static_fini(
242// CHECK: [[RED_LIST_GEP:%.+]] = getelementptr{{.+}} [[RED_LIST]],
243// CHECK: [[SIVAR_PRIV_CAST:%.+]] = bitcast{{.+}} [[SIVAR_PRIV]] to
244// CHECK: store{{.+}} [[SIVAR_PRIV_CAST]], {{.+}} [[RED_LIST_GEP]],
245// CHECK: [[RED_LIST_BCAST:%.+]] = bitcast{{.+}} [[RED_LIST]] to
246// CHECK: [[K_RED_RET:%.+]] = call{{.+}} @__kmpc_reduce_nowait({{.+}}, {{.+}}, {{.+}}, {{.+}}, {{.+}} [[RED_LIST_BCAST]], {{.+}} [[RED_FUN:@.+]], {{.+}} [[RED_VAR]])
247// CHECK: switch{{.+}} [[K_RED_RET]], label{{.+}} [
248// CHECK: {{.+}}, label %[[CASE1:.+]]
249// CHECK: {{.+}}, label %[[CASE2:.+]]
250// CHECK: ]
251// CHECK: [[CASE1]]:
252// CHECK-DAG: [[SIVAR_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_REF]],
253// CHECK-DAG: [[SIVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_PRIV]],
254// CHECK-DAG: [[SIVAR_INC:%.+]] = add{{.+}} [[SIVAR_VAL]], [[SIVAR_PRIV_VAL]]
255// CHECK: store{{.+}} [[SIVAR_INC]], {{.+}} [[SIVAR_REF]],
256// CHECK: call void @__kmpc_end_reduce_nowait({{.+}}, {{.+}}, {{.+}} [[RED_VAR]])
257// CHECK: br
258// CHECK: [[CASE2]]:
259// CHECK-DAG: [[SIVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[SIVAR_PRIV]],
260// CHECK-DAG: [[ATOMIC_RES:%.+]] = atomicrmw add{{.+}} [[SIVAR_REF]], {{.+}} [[SIVAR_PRIV_VAL]]
261// CHECK: br
262
263// CHECK: define{{.*}} i{{[0-9]+}} @[[TMAIN_INT]]()
264// CHECK: call i32 @__tgt_target_teams(i64 -1, i8* @{{[^,]+}}, i32 1,
265// CHECK: call void @[[TOFFL1:.+]]({{.+}})
266// CHECK:  ret
267
268// CHECK: define{{.*}} void @[[TOFFL1]](i{{64|32}}*{{.*}} [[TVAR_ARG:%.+]])
269// CHECK: [[TVAR_ADDR:%.+]] = alloca i{{.+}},
270// CHECK: store{{.+}} [[TVAR_ARG]], {{.+}} [[TVAR_ADDR]],
271// CHECK: [[TVAR_VAL:%.+]] = load{{.+}}, {{.+}} [[TVAR_ADDR]]
272// CHECK: call void {{.+}} @__kmpc_fork_teams({{.+}}, i32 1, {{.+}} @[[TOUTL1:.+]] to {{.+}}, {{.+}} [[TVAR_VAL]])
273// CHECK: ret void
274
275// CHECK: define internal void @[[TOUTL1]]({{.+}}, {{.+}}, {{.+}} [[TVAR_ARG:%.+]])
276// Skip global and bound tid vars
277// CHECK: {{.+}} = alloca i32*,
278// CHECK: {{.+}} = alloca i32*,
279// CHECK: [[TVAR_ADDR:%.+]] = alloca i{{.+}},
280// CHECK: [[TVAR_PRIV:%.+]] = alloca i{{.+}},
281// CHECK: [[RED_LIST:%.+]] = alloca [1 x {{.+}}],
282// CHECK: store{{.+}} [[TVAR_ARG]], {{.+}} [[TVAR_ADDR]],
283// CHECK: [[TVAR_REF:%.+]] = load {{.+}} [[TVAR_ADDR]],
284// CHECK: store{{.+}} 0, {{.+}} [[TVAR_PRIV]],
285
286// CHECK: call void @__kmpc_for_static_init_4(
287// CHECK: call void {{.*}} @__kmpc_fork_call({{.+}}, {{.+}}, {{.+}} @[[TPAR_OUTL:.+]] to
288// CHECK: call void @__kmpc_for_static_fini(
289// CHECK: [[RED_LIST_GEP:%.+]] = getelementptr{{.+}} [[RED_LIST]],
290// CHECK: [[TVAR_PRIV_CAST:%.+]] = bitcast{{.+}} [[TVAR_PRIV]] to
291// CHECK: store{{.+}} [[TVAR_PRIV_CAST]], {{.+}} [[RED_LIST_GEP]],
292// CHECK: [[RED_LIST_BCAST:%.+]] = bitcast{{.+}} [[RED_LIST]] to
293// CHECK: [[K_RED_RET:%.+]] = call{{.+}} @__kmpc_reduce_nowait({{.+}}, {{.+}}, {{.+}}, {{.+}}, {{.+}} [[RED_LIST_BCAST]], {{.+}} [[RED_FUN:@.+]], {{.+}} [[RED_VAR]])
294// CHECK: switch{{.+}} [[K_RED_RET]], label{{.+}} [
295// CHECK: {{.+}}, label %[[CASE1:.+]]
296// CHECK: {{.+}}, label %[[CASE2:.+]]
297// CHECK: ]
298// CHECK: [[CASE1]]:
299// CHECK-DAG: [[TVAR_VAL:%.+]] = load{{.+}}, {{.+}} [[TVAR_REF]],
300// CHECK-DAG: [[TVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[TVAR_PRIV]],
301// CHECK-DAG: [[TVAR_INC:%.+]] = add{{.+}} [[TVAR_VAL]], [[TVAR_PRIV_VAL]]
302// CHECK: store{{.+}} [[TVAR_INC]], {{.+}} [[TVAR_REF]],
303// CHECK: call void @__kmpc_end_reduce_nowait({{.+}}, {{.+}}, {{.+}} [[RED_VAR]])
304// CHECK: br
305// CHECK: [[CASE2]]:
306// CHECK-DAG: [[TVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[TVAR_PRIV]],
307// CHECK-DAG: [[ATOMIC_RES:%.+]] = atomicrmw add{{.+}} [[TVAR_REF]], {{.+}} [[TVAR_PRIV_VAL]]
308// CHECK: br
309
310// CHECK: define internal void @[[TPAR_OUTL]]({{.+}}, {{.+}}, {{.+}}, {{.+}}, {{.+}} [[TVAR_ARG:%.+]])
311// Skip global and bound tid vars, and prev lb and ub vars
312// CHECK: {{.+}} = alloca i32*,
313// CHECK: {{.+}} = alloca i32*,
314// CHECK: alloca i{{[0-9]+}},
315// CHECK: alloca i{{[0-9]+}},
316// CHECK: [[TVAR_ADDR:%.+]] = alloca i{{.+}},
317// skip loop vars
318// CHECK: alloca i32,
319// CHECK: alloca i32,
320// CHECK: alloca i32,
321// CHECK: alloca i32,
322// CHECK: alloca i32,
323// CHECK: alloca i32,
324// CHECK: [[TVAR_PRIV:%.+]] = alloca i{{.+}},
325// CHECK: [[RED_LIST:%.+]] = alloca [1 x {{.+}}],
326// CHECK: store{{.+}} [[TVAR_ARG]], {{.+}} [[TVAR_ADDR]],
327// CHECK: [[TVAR_REF:%.+]] = load {{.+}} [[TVAR_ADDR]],
328// CHECK: store{{.+}} 0, {{.+}} [[TVAR_PRIV]],
329
330// CHECK: call void @__kmpc_for_static_init_4(
331// CHECK: store{{.+}}, {{.+}} [[TVAR_PRIV]],
332// CHECK: call void @__kmpc_for_static_fini(
333// CHECK: [[RED_LIST_GEP:%.+]] = getelementptr{{.+}} [[RED_LIST]],
334// CHECK: [[TVAR_PRIV_CAST:%.+]] = bitcast{{.+}} [[TVAR_PRIV]] to
335// CHECK: store{{.+}} [[TVAR_PRIV_CAST]], {{.+}} [[RED_LIST_GEP]],
336// CHECK: [[RED_LIST_BCAST:%.+]] = bitcast{{.+}} [[RED_LIST]] to
337// CHECK: [[K_RED_RET:%.+]] = call{{.+}} @__kmpc_reduce_nowait({{.+}}, {{.+}}, {{.+}}, {{.+}}, {{.+}} [[RED_LIST_BCAST]], {{.+}} [[RED_FUN:@.+]], {{.+}} [[RED_VAR]])
338// CHECK: switch{{.+}} [[K_RED_RET]], label{{.+}} [
339// CHECK: {{.+}}, label %[[CASE1:.+]]
340// CHECK: {{.+}}, label %[[CASE2:.+]]
341// CHECK: ]
342// CHECK: [[CASE1]]:
343// CHECK-DAG: [[TVAR_VAL:%.+]] = load{{.+}}, {{.+}} [[TVAR_REF]],
344// CHECK-DAG: [[TVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[TVAR_PRIV]],
345// CHECK-DAG: [[TVAR_INC:%.+]] = add{{.+}} [[TVAR_VAL]], [[TVAR_PRIV_VAL]]
346// CHECK: store{{.+}} [[TVAR_INC]], {{.+}} [[TVAR_REF]],
347// CHECK: call void @__kmpc_end_reduce_nowait({{.+}}, {{.+}}, {{.+}} [[RED_VAR]])
348// CHECK: br
349// CHECK: [[CASE2]]:
350// CHECK-DAG: [[TVAR_PRIV_VAL:%.+]] = load{{.+}}, {{.+}} [[TVAR_PRIV]],
351// CHECK-DAG: [[ATOMIC_RES:%.+]] = atomicrmw add{{.+}} [[TVAR_REF]], {{.+}} [[TVAR_PRIV_VAL]]
352// CHECK: br
353#endif
354
CodeThinker, Enjoy your reading code