Clang Project

clang_source_code/test/OpenMP/for_codegen.cpp
1// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s --check-prefix=CHECK --check-prefix=LIFETIME
2// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
3// RUN: %clang_cc1 -fopenmp -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 -fopenmp -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 -main-file-name for_codegen.cpp %s -o - -emit-llvm -fprofile-instrument=clang -fprofile-instrument-path=for_codegen-test.profraw | FileCheck %s --check-prefix=PROF-INSTR-PATH
6
7// RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck --check-prefix SIMD-ONLY0 %s
8// RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
9// RUN: %clang_cc1 -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s
10// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp-simd -fexceptions -fcxx-exceptions -debug-info-kind=line-tables-only -x c++ -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s
11// RUN: %clang_cc1 -main-file-name for_codegen.cpp %s -o - -emit-llvm -fprofile-instrument=clang -fprofile-instrument-path=for_codegen-test.profraw | FileCheck --check-prefix SIMD-ONLY0 %s
12// SIMD-ONLY0-NOT: {{__kmpc|__tgt}}
13//
14// expected-no-diagnostics
15#ifndef HEADER
16#define HEADER
17// PROF-INSTR-PATH: constant [25 x i8] c"for_codegen-test.profraw\00"
18
19// CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
20// CHECK-DAG: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr global %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8*
21// CHECK-DAG: [[LOOP_LOC:@.+]] = private unnamed_addr global %{{.+}} { i32 0, i32 514, i32 0, i32 0, i8*
22// CHECK-DAG: [[I:@.+]] = global i8 1,
23// CHECK-DAG: [[J:@.+]] = global i8 2,
24// CHECK-DAG: [[K:@.+]] = global i8 3,
25
26// CHECK-LABEL: loop_with_counter_collapse
27void loop_with_counter_collapse() {
28  // LIFETIME: call void @llvm.lifetime.end
29  // LIFETIME: call void @llvm.lifetime.end
30  // CHECK: call void @__kmpc_for_static_init_8(%struct.ident_t* @
31  // CHECK: call void @__kmpc_for_static_fini(%struct.ident_t* @
32  // LIFETIME: call void @llvm.lifetime.end
33  // LIFETIME: call void @llvm.lifetime.end
34  // LIFETIME: call void @llvm.lifetime.end
35  // LIFETIME: call void @llvm.lifetime.end
36  // LIFETIME: call void @llvm.lifetime.end
37  // LIFETIME: call void @llvm.lifetime.end
38  // LIFETIME: call void @llvm.lifetime.end
39  // LIFETIME: call void @llvm.lifetime.end
40  // LIFETIME: call void @llvm.lifetime.end
41  #pragma omp for collapse(2)
42  for (int i = 0; i < 4; i++) {
43    for (int j = i; j < 4; j++) {
44    }
45  }
46}
47// CHECK-LABEL: define {{.*void}} @{{.*}}without_schedule_clause{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
48void without_schedule_clause(float *a, float *b, float *c, float *d) {
49// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
50  #pragma omp for nowait
51// CHECK: call void @__kmpc_for_static_init_4([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]], i32 34, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1)
52// UB = min(UB, GlobalUB)
53// CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
54// CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 4571423
55// CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
56// CHECK: [[UBRESULT:%.+]] = phi i32 [ 4571423, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
57// CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
58// CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
59// CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
60// Loop header
61// CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
62// CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
63// CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]]
64// CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
65  for (int i = 33; i < 32000000; i += 7) {
66// CHECK: [[LOOP1_BODY]]
67// Start of body: calculate i from IV:
68// CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]
69// CHECK-NEXT: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 7
70// CHECK-NEXT: [[CALC_I_2:%.+]] = add nsw i32 33, [[CALC_I_1]]
71// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]
72// ... loop body ...
73// End of body: store into a[i]:
74// CHECK: store float [[RESULT:%.+]], float* {{%.+}}
75// CHECK-NOT: !llvm.access.group
76    a[i] = b[i] * c[i] * d[i];
77// CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
78// CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1
79// CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
80// CHECK-NEXT: br label %{{.+}}
81  }
82// CHECK: [[LOOP1_END]]
83// CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]])
84// CHECK-NOT: __kmpc_barrier
85// CHECK: ret void
86}
87
88// CHECK-LABEL: define {{.*void}} @{{.*}}static_not_chunked{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
89void static_not_chunked(float *a, float *b, float *c, float *d) {
90// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
91  #pragma omp for schedule(static)
92// CHECK: call void @__kmpc_for_static_init_4([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]], i32 34, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1)
93// UB = min(UB, GlobalUB)
94// CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
95// CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 4571423
96// CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
97// CHECK: [[UBRESULT:%.+]] = phi i32 [ 4571423, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
98// CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
99// CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
100// CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
101// Loop header
102// CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
103// CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
104// CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]]
105// CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
106  for (int i = 32000000; i > 33; i += -7) {
107// CHECK: [[LOOP1_BODY]]
108// Start of body: calculate i from IV:
109// CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]
110// CHECK-NEXT: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 7
111// CHECK-NEXT: [[CALC_I_2:%.+]] = sub nsw i32 32000000, [[CALC_I_1]]
112// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]
113// ... loop body ...
114// End of body: store into a[i]:
115// CHECK: store float [[RESULT:%.+]], float* {{%.+}}
116// CHECK-NOT: !llvm.access.group
117    a[i] = b[i] * c[i] * d[i];
118// CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
119// CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1
120// CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
121// CHECK-NEXT: br label %{{.+}}
122  }
123// CHECK: [[LOOP1_END]]
124// CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]])
125// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
126// CHECK: ret void
127}
128
129// CHECK-LABEL: define {{.*void}} @{{.*}}static_chunked{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
130void static_chunked(float *a, float *b, float *c, float *d) {
131// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
132  #pragma omp for schedule(monotonic: static, 5)
133// CHECK: call void @__kmpc_for_static_init_4u([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]], i32 536870945, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 5)
134// UB = min(UB, GlobalUB)
135// CHECK: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
136// CHECK-NEXT: [[UBCMP:%.+]] = icmp ugt i32 [[UB]], 16908288
137// CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
138// CHECK: [[UBRESULT:%.+]] = phi i32 [ 16908288, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
139// CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
140// CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
141// CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
142
143// Outer loop header
144// CHECK: [[O_IV:%.+]] = load i32, i32* [[OMP_IV]]
145// CHECK-NEXT: [[O_UB:%.+]] = load i32, i32* [[OMP_UB]]
146// CHECK-NEXT: [[O_CMP:%.+]] = icmp ule i32 [[O_IV]], [[O_UB]]
147// CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
148
149// Loop header
150// CHECK: [[O_LOOP1_BODY]]
151// CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
152// CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
153// CHECK-NEXT: [[CMP:%.+]] = icmp ule i32 [[IV]], [[UB]]
154// CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
155  for (unsigned i = 131071; i <= 2147483647; i += 127) {
156// CHECK: [[LOOP1_BODY]]
157// Start of body: calculate i from IV:
158// CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]
159// CHECK-NEXT: [[CALC_I_1:%.+]] = mul i32 [[IV1_1]], 127
160// CHECK-NEXT: [[CALC_I_2:%.+]] = add i32 131071, [[CALC_I_1]]
161// CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]
162// ... loop body ...
163// End of body: store into a[i]:
164// CHECK: store float [[RESULT:%.+]], float* {{%.+}}
165// CHECK-NOT: !llvm.access.group
166    a[i] = b[i] * c[i] * d[i];
167// CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
168// CHECK-NEXT: [[ADD1_2:%.+]] = add i32 [[IV1_2]], 1
169// CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
170// CHECK-NEXT: br label %{{.+}}
171  }
172// CHECK: [[LOOP1_END]]
173// Update the counters, adding stride
174// CHECK:  [[LB:%.+]] = load i32, i32* [[OMP_LB]]
175// CHECK-NEXT: [[ST:%.+]] = load i32, i32* [[OMP_ST]]
176// CHECK-NEXT: [[ADD_LB:%.+]] = add i32 [[LB]], [[ST]]
177// CHECK-NEXT: store i32 [[ADD_LB]], i32* [[OMP_LB]]
178// CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
179// CHECK-NEXT: [[ST:%.+]] = load i32, i32* [[OMP_ST]]
180// CHECK-NEXT: [[ADD_UB:%.+]] = add i32 [[UB]], [[ST]]
181// CHECK-NEXT: store i32 [[ADD_UB]], i32* [[OMP_UB]]
182
183// CHECK: [[O_LOOP1_END]]
184// CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[LOOP_LOC]], i32 [[GTID]])
185// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
186// CHECK: ret void
187}
188
189// CHECK-LABEL: define {{.*void}} @{{.*}}dynamic1{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
190void dynamic1(float *a, float *b, float *c, float *d) {
191// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
192  #pragma omp for schedule(nonmonotonic: dynamic)
193// CHECK: call void @__kmpc_dispatch_init_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 1073741859, i64 0, i64 16908287, i64 1, i64 1)
194//
195// CHECK: [[HASWORK:%.+]] = call i32 @__kmpc_dispatch_next_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32* [[OMP_ISLAST:%[^,]+]], i64* [[OMP_LB:%[^,]+]], i64* [[OMP_UB:%[^,]+]], i64* [[OMP_ST:%[^,]+]])
196// CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
197// CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
198
199// Loop header
200// CHECK: [[O_LOOP1_BODY]]
201// CHECK: [[LB:%.+]] = load i64, i64* [[OMP_LB]]
202// CHECK-NEXT: store i64 [[LB]], i64* [[OMP_IV:[^,]+]]
203// CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]
204
205// CHECK-NEXT: [[UB:%.+]] = load i64, i64* [[OMP_UB]]
206// CHECK-NEXT: [[BOUND:%.+]] = add i64 [[UB]], 1
207// CHECK-NEXT: [[CMP:%.+]] = icmp ult i64 [[IV]], [[BOUND]]
208// CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
209  for (unsigned long long i = 131071; i < 2147483647; i += 127) {
210// CHECK: [[LOOP1_BODY]]
211// Start of body: calculate i from IV:
212// CHECK: [[IV1_1:%.+]] = load i64, i64* [[OMP_IV]]
213// CHECK-NEXT: [[CALC_I_1:%.+]] = mul i64 [[IV1_1]], 127
214// CHECK-NEXT: [[CALC_I_2:%.+]] = add i64 131071, [[CALC_I_1]]
215// CHECK-NEXT: store i64 [[CALC_I_2]], i64* [[LC_I:.+]]
216// ... loop body ...
217// End of body: store into a[i]:
218// CHECK: store float [[RESULT:%.+]], float* {{%.+}}!llvm.access.group
219    a[i] = b[i] * c[i] * d[i];
220// CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}
221// CHECK-NEXT: [[ADD1_2:%.+]] = add i64 [[IV1_2]], 1
222// CHECK-NEXT: store i64 [[ADD1_2]], i64* [[OMP_IV]]
223// CHECK-NEXT: br label %{{.+}}
224  }
225// CHECK: [[LOOP1_END]]
226// CHECK: [[O_LOOP1_END]]
227// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
228// CHECK: ret void
229}
230
231// CHECK-LABEL: define {{.*void}} @{{.*}}guided7{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
232void guided7(float *a, float *b, float *c, float *d) {
233// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
234  #pragma omp for schedule(guided, 7)
235// CHECK: call void @__kmpc_dispatch_init_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 36, i64 0, i64 16908287, i64 1, i64 7)
236//
237// CHECK: [[HASWORK:%.+]] = call i32 @__kmpc_dispatch_next_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32* [[OMP_ISLAST:%[^,]+]], i64* [[OMP_LB:%[^,]+]], i64* [[OMP_UB:%[^,]+]], i64* [[OMP_ST:%[^,]+]])
238// CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
239// CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
240
241// Loop header
242// CHECK: [[O_LOOP1_BODY]]
243// CHECK: [[LB:%.+]] = load i64, i64* [[OMP_LB]]
244// CHECK-NEXT: store i64 [[LB]], i64* [[OMP_IV:[^,]+]]
245// CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]
246
247// CHECK-NEXT: [[UB:%.+]] = load i64, i64* [[OMP_UB]]
248// CHECK-NEXT: [[BOUND:%.+]] = add i64 [[UB]], 1
249// CHECK-NEXT: [[CMP:%.+]] = icmp ult i64 [[IV]], [[BOUND]]
250// CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
251  for (unsigned long long i = 131071; i < 2147483647; i += 127) {
252// CHECK: [[LOOP1_BODY]]
253// Start of body: calculate i from IV:
254// CHECK: [[IV1_1:%.+]] = load i64, i64* [[OMP_IV]]
255// CHECK-NEXT: [[CALC_I_1:%.+]] = mul i64 [[IV1_1]], 127
256// CHECK-NEXT: [[CALC_I_2:%.+]] = add i64 131071, [[CALC_I_1]]
257// CHECK-NEXT: store i64 [[CALC_I_2]], i64* [[LC_I:.+]]
258// ... loop body ...
259// End of body: store into a[i]:
260// CHECK: store float [[RESULT:%.+]], float* {{%.+}}!llvm.access.group
261    a[i] = b[i] * c[i] * d[i];
262// CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}
263// CHECK-NEXT: [[ADD1_2:%.+]] = add i64 [[IV1_2]], 1
264// CHECK-NEXT: store i64 [[ADD1_2]], i64* [[OMP_IV]]
265// CHECK-NEXT: br label %{{.+}}
266  }
267// CHECK: [[LOOP1_END]]
268// CHECK: [[O_LOOP1_END]]
269// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
270// CHECK: ret void
271}
272
273// CHECK-LABEL: define {{.*void}} @{{.*}}test_auto{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
274void test_auto(float *a, float *b, float *c, float *d) {
275  unsigned int x = 0;
276  unsigned int y = 0;
277// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
278  #pragma omp for schedule(auto) collapse(2)
279// CHECK: call void @__kmpc_dispatch_init_8([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 38, i64 0, i64 [[LAST_ITER:%[^,]+]], i64 1, i64 1)
280//
281// CHECK: [[HASWORK:%.+]] = call i32 @__kmpc_dispatch_next_8([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32* [[OMP_ISLAST:%[^,]+]], i64* [[OMP_LB:%[^,]+]], i64* [[OMP_UB:%[^,]+]], i64* [[OMP_ST:%[^,]+]])
282// CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
283// CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
284
285// Loop header
286// CHECK: [[O_LOOP1_BODY]]
287// CHECK: [[LB:%.+]] = load i64, i64* [[OMP_LB]]
288// CHECK-NEXT: store i64 [[LB]], i64* [[OMP_IV:[^,]+]]
289// CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]
290
291// CHECK-NEXT: [[UB:%.+]] = load i64, i64* [[OMP_UB]]
292// CHECK-NEXT: [[CMP:%.+]] = icmp sle i64 [[IV]], [[UB]]
293// CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
294// FIXME: When the iteration count of some nested loop is not a known constant,
295// we should pre-calculate it, like we do for the total number of iterations!
296  for (char i = static_cast<char>(y); i <= '9'; ++i)
297    for (x = 11; x > 0; --x) {
298// CHECK: [[LOOP1_BODY]]
299// Start of body: indices are calculated from IV:
300// CHECK: store i8 {{%[^,]+}}, i8* {{%[^,]+}}
301// CHECK: store i32 {{%[^,]+}}, i32* {{%[^,]+}}
302// ... loop body ...
303// End of body: store into a[i]:
304// CHECK: store float [[RESULT:%.+]], float* {{%.+}}
305// CHECK-NOT: !llvm.access.group
306    a[i] = b[i] * c[i] * d[i];
307// CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}
308// CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i64 [[IV1_2]], 1
309// CHECK-NEXT: store i64 [[ADD1_2]], i64* [[OMP_IV]]
310// CHECK-NEXT: br label %{{.+}}
311  }
312// CHECK: [[LOOP1_END]]
313// CHECK: [[O_LOOP1_END]]
314// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
315// CHECK: ret void
316}
317
318// CHECK-LABEL: define {{.*void}} @{{.*}}runtime{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
319void runtime(float *a, float *b, float *c, float *d) {
320  int x = 0;
321// CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
322  #pragma omp for collapse(2) schedule(runtime)
323// CHECK: call void @__kmpc_dispatch_init_4([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 37, i32 0, i32 199, i32 1, i32 1)
324//
325// CHECK: [[HASWORK:%.+]] = call i32 @__kmpc_dispatch_next_4([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32* [[OMP_ISLAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]])
326// CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
327// CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
328
329// Loop header
330// CHECK: [[O_LOOP1_BODY]]
331// CHECK: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
332// CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
333// CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
334
335// CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
336// CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]]
337// CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
338  for (unsigned char i = '0' ; i <= '9'; ++i)
339    for (x = -10; x < 10; ++x) {
340// CHECK: [[LOOP1_BODY]]
341// Start of body: indices are calculated from IV:
342// CHECK: store i8 {{%[^,]+}}, i8* {{%[^,]+}}
343// CHECK: store i32 {{%[^,]+}}, i32* {{%[^,]+}}
344// ... loop body ...
345// End of body: store into a[i]:
346// CHECK: store float [[RESULT:%.+]], float* {{%.+}}
347// CHECK-NOT: !llvm.access.group
348    a[i] = b[i] * c[i] * d[i];
349// CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
350// CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1
351// CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
352// CHECK-NEXT: br label %{{.+}}
353  }
354// CHECK: [[LOOP1_END]]
355// CHECK: [[O_LOOP1_END]]
356// CHECK: call {{.+}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
357// CHECK: ret void
358}
359
360// CHECK-LABEL: test_precond
361void test_precond() {
362  // CHECK: [[A_ADDR:%.+]] = alloca i8,
363  // CHECK: [[I_ADDR:%.+]] = alloca i8,
364  // CHECK: [[CAP:%.+]] = alloca i8,
365  char a = 0;
366  // CHECK: store i8 0,
367  // CHECK: store i32
368  // CHECK: store i8
369  // CHECK: [[A:%.+]] = load i8, i8* [[CAP]],
370  // CHECK: [[CONV:%.+]] = sext i8 [[A]] to i32
371  // CHECK: [[CMP:%.+]] = icmp slt i32 [[CONV]], 10
372  // CHECK: br i1 [[CMP]], label %[[PRECOND_THEN:[^,]+]], label %[[PRECOND_END:[^,]+]]
373  // CHECK: [[PRECOND_THEN]]
374  // CHECK: call void @__kmpc_for_static_init_4
375#pragma omp for
376  for(char i = a; i < 10; ++i);
377  // CHECK: call void @__kmpc_for_static_fini
378  // CHECK: [[PRECOND_END]]
379}
380
381// TERM_DEBUG-LABEL: foo
382int foo() {return 0;};
383
384// TERM_DEBUG-LABEL: parallel_for
385void parallel_for(float *a) {
386#pragma omp parallel
387#pragma omp for schedule(static, 5)
388  // TERM_DEBUG-NOT: __kmpc_global_thread_num
389  // TERM_DEBUG:     call void @__kmpc_for_static_init_4u({{.+}}), !dbg [[DBG_LOC:![0-9]+]]
390  // TERM_DEBUG:     invoke i32 {{.*}}foo{{.*}}()
391  // TERM_DEBUG:     unwind label %[[TERM_LPAD:.+]],
392  // TERM_DEBUG-NOT: __kmpc_global_thread_num
393  // TERM_DEBUG:     call void @__kmpc_for_static_fini({{.+}}), !dbg [[DBG_LOC]]
394  // TERM_DEBUG:     call {{.+}} @__kmpc_barrier({{.+}}), !dbg [[DBG_LOC]]
395  // TERM_DEBUG:     [[TERM_LPAD]]
396  // TERM_DEBUG:     call void @__clang_call_terminate
397  // TERM_DEBUG:     unreachable
398  for (unsigned i = 131071; i <= 2147483647; i += 127)
399    a[i] += foo();
400}
401// Check source line corresponds to "#pragma omp for schedule(static, 5)" above:
402// TERM_DEBUG: [[DBG_LOC]] = !DILocation(line: [[@LINE-15]],
403
404char i = 1, j = 2, k = 3;
405// CHECK-LABEL: for_with_global_lcv
406void for_with_global_lcv() {
407// CHECK: alloca i8,
408// CHECK: [[I_ADDR:%.+]] = alloca i8,
409// CHECK: alloca i8,
410// CHECK: [[J_ADDR:%.+]] = alloca i8,
411
412// CHECK: call void @__kmpc_for_static_init_4(
413// CHECK-NOT: [[I]]
414// CHECK: store i8 %{{.+}}, i8* [[I_ADDR]]
415// CHECK-NOT: [[I]]
416// CHECK: [[I_VAL:%.+]] = load i8, i8* [[I_ADDR]],
417// CHECK-NOT: [[I]]
418// CHECK: store i8 [[I_VAL]], i8* [[K]]
419// CHECK-NOT: [[I]]
420// CHECK: call void @__kmpc_for_static_fini(
421// CHECK: call void @__kmpc_barrier(
422#pragma omp for
423  for (i = 0; i < 2; ++i) {
424    k = i;
425  }
426// CHECK: call void @__kmpc_for_static_init_4(
427// CHECK-NOT: [[J]]
428// CHECK: store i8 %{{.+}}, i8* [[J_ADDR]]
429// CHECK-NOT: [[J]]
430// CHECK: [[J_VAL:%.+]] = load i8, i8* [[J_ADDR]],
431// CHECK-NOT: [[J]]
432// CHECK: store i8 [[J_VAL]], i8* [[K]]
433// CHECK-NOT: [[J]]
434// CHECK: call void @__kmpc_for_static_fini(
435#pragma omp for collapse(2)
436  for (int i = 0; i < 2; ++i)
437  for (j = 0; j < 2; ++j) {
438    k = i;
439    k = j;
440  }
441  char &cnt = i;
442#pragma omp for
443  for (cnt = 0; cnt < 2; ++cnt)
444    k = cnt;
445}
446
447// CHECK-LABEL: for_with_references
448void for_with_references() {
449// CHECK: [[I:%.+]] = alloca i8,
450// CHECK: [[CNT:%.+]] = alloca i8*,
451// CHECK: [[CNT_PRIV:%.+]] = alloca i8,
452// CHECK: call void @__kmpc_for_static_init_4(
453// CHECK-NOT: load i8, i8* [[CNT]],
454// CHECK: call void @__kmpc_for_static_fini(
455  char i = 0;
456  char &cnt = i;
457#pragma omp for
458  for (cnt = 0; cnt < 2; ++cnt)
459    k = cnt;
460}
461
462struct Bool {
463  Bool(bool b) : b(b) {}
464  operator bool() const { return b; }
465  const bool b;
466};
467
468template <typename T>
469struct It {
470  It() : p(0) {}
471  It(const It &, int = 0) ;
472  template <typename U>
473  It(U &, int = 0) ;
474  It &operator=(const It &);
475  It &operator=(It &);
476  ~It() {}
477
478  It(T *p) : p(p) {}
479
480  operator T *&() { return p; }
481  operator T *() const { return p; }
482  T *operator->() const { return p; }
483
484  It &operator++() { ++p; return *this; }
485  It &operator--() { --p; return *this; }
486  It &operator+=(unsigned n) { p += n; return *this; }
487  It &operator-=(unsigned n) { p -= n; return *this; }
488
489  T *p;
490};
491
492template <typename T>
493It<T> operator+(It<T> a, typename It<T>::difference_type n) { return a.p + n; }
494
495template <typename T>
496It<T> operator+(typename It<T>::difference_type n, It<T> a) { return a.p + n; }
497
498template <typename T>
499It<T> operator-(It<T> a, typename It<T>::difference_type n) { return a.p - n; }
500
501typedef Bool BoolType;
502
503template <typename T>
504BoolType operator<(It<T> a, It<T> b) { return a.p < b.p; }
505
506void loop_with_It(It<char> begin, It<char> end) {
507#pragma omp for
508  for (It<char> it = begin; it < end; ++it) {
509    *it = 0;
510  }
511}
512
513// CHECK-LABEL: loop_with_It
514// CHECK: call i32 @__kmpc_global_thread_num(
515// CHECK: call void @__kmpc_for_static_init_8(
516// CHECK: call void @__kmpc_for_static_fini(
517
518void loop_with_It_plus(It<char> begin, It<char> end) {
519#pragma omp for
520  for (It<char> it = begin; it < end; it+=1u) {
521    *it = 0;
522  }
523}
524
525// CHECK-LABEL: loop_with_It_plus
526// CHECK: call i32 @__kmpc_global_thread_num(
527// CHECK: call void @__kmpc_for_static_init_8(
528// CHECK: call void @__kmpc_for_static_fini(
529
530void loop_with_stmt_expr() {
531#pragma omp for
532  for (int i = __extension__({float b = 0;b; }); i < __extension__({double c = 1;c; }); i += __extension__({char d = 1; d; }))
533    ;
534}
535// CHECK-LABEL: loop_with_stmt_expr
536// CHECK: call i32 @__kmpc_global_thread_num(
537// CHECK: call void @__kmpc_for_static_init_4(
538// CHECK: call void @__kmpc_for_static_fini(
539
540
541// CHECK-LABEL: fint
542// CHECK: call {{.*}}i32 {{.*}}ftemplate
543// CHECK: ret i32
544
545// CHECK: load i16, i16*
546// CHECK: store i16 %
547// CHECK: call void {{.+}}@__kmpc_fork_call(
548// CHECK: call void @__kmpc_for_static_init_4(
549template <typename T>
550T ftemplate() {
551  short aa = 0;
552
553#pragma omp parallel for schedule(static, aa)
554  for (int i = 0; i < 100; i++) {
555  }
556  return T();
557}
558
559int fint(void) { return ftemplate<int>(); }
560
561#endif // HEADER
562
CodeThinker, Enjoy your reading code