1 // RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
2 // RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
3 // RUN: %clang_cc1 -fopenmp=libiomp5 -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=libiomp5 -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
5 //
6 // expected-no-diagnostics
7 #ifndef HEADER
8 #define HEADER
9 
10 // CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
11 // CHECK-DAG: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8*
12 // CHECK-DAG: [[I:@.+]] = global i8 1,
13 // CHECK-DAG: [[J:@.+]] = global i8 2,
14 // CHECK-DAG: [[K:@.+]] = global i8 3,
15 
16 // CHECK-LABEL: define {{.*void}} @{{.*}}without_schedule_clause{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
17 void without_schedule_clause(float *a, float *b, float *c, float *d) {
18 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
19   #pragma omp for nowait
20 // CHECK: call void @__kmpc_for_static_init_4([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 34, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1)
21 // UB = min(UB, GlobalUB)
22 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
23 // CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 4571423
24 // CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
25 // CHECK: [[UBRESULT:%.+]] = phi i32 [ 4571423, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
26 // CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
27 // CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
28 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
29 // Loop header
30 // CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
31 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
32 // CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]]
33 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
34   for (int i = 33; i < 32000000; i += 7) {
35 // CHECK: [[LOOP1_BODY]]
36 // Start of body: calculate i from IV:
37 // CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]
38 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 7
39 // CHECK-NEXT: [[CALC_I_2:%.+]] = add nsw i32 33, [[CALC_I_1]]
40 // CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]
41 // ... loop body ...
42 // End of body: store into a[i]:
43 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
44     a[i] = b[i] * c[i] * d[i];
45 // CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
46 // CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1
47 // CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
48 // CHECK-NEXT: br label %{{.+}}
49   }
50 // CHECK: [[LOOP1_END]]
51 // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
52 // CHECK-NOT: __kmpc_cancel_barrier
53 // CHECK: ret void
54 }
55 
56 // CHECK-LABEL: define {{.*void}} @{{.*}}static_not_chunked{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
57 void static_not_chunked(float *a, float *b, float *c, float *d) {
58 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
59   #pragma omp for schedule(static)
60 // CHECK: call void @__kmpc_for_static_init_4([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 34, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 1)
61 // UB = min(UB, GlobalUB)
62 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
63 // CHECK-NEXT: [[UBCMP:%.+]] = icmp sgt i32 [[UB]], 4571423
64 // CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
65 // CHECK: [[UBRESULT:%.+]] = phi i32 [ 4571423, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
66 // CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
67 // CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
68 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
69 // Loop header
70 // CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
71 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
72 // CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]]
73 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
74   for (int i = 32000000; i > 33; i += -7) {
75 // CHECK: [[LOOP1_BODY]]
76 // Start of body: calculate i from IV:
77 // CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]
78 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul nsw i32 [[IV1_1]], 7
79 // CHECK-NEXT: [[CALC_I_2:%.+]] = sub nsw i32 32000000, [[CALC_I_1]]
80 // CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]
81 // ... loop body ...
82 // End of body: store into a[i]:
83 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
84     a[i] = b[i] * c[i] * d[i];
85 // CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
86 // CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1
87 // CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
88 // CHECK-NEXT: br label %{{.+}}
89   }
90 // CHECK: [[LOOP1_END]]
91 // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
92 // CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
93 // CHECK: ret void
94 }
95 
96 // CHECK-LABEL: define {{.*void}} @{{.*}}static_chunked{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
97 void static_chunked(float *a, float *b, float *c, float *d) {
98 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
99   #pragma omp for schedule(static, 5)
100 // CHECK: call void @__kmpc_for_static_init_4u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 33, i32* [[IS_LAST:%[^,]+]], i32* [[OMP_LB:%[^,]+]], i32* [[OMP_UB:%[^,]+]], i32* [[OMP_ST:%[^,]+]], i32 1, i32 5)
101 // UB = min(UB, GlobalUB)
102 // CHECK: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
103 // CHECK-NEXT: [[UBCMP:%.+]] = icmp ugt i32 [[UB]], 16908288
104 // CHECK-NEXT: br i1 [[UBCMP]], label [[UB_TRUE:%[^,]+]], label [[UB_FALSE:%[^,]+]]
105 // CHECK: [[UBRESULT:%.+]] = phi i32 [ 16908288, [[UB_TRUE]] ], [ [[UBVAL:%[^,]+]], [[UB_FALSE]] ]
106 // CHECK-NEXT: store i32 [[UBRESULT]], i32* [[OMP_UB]]
107 // CHECK-NEXT: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
108 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
109 
110 // Outer loop header
111 // CHECK: [[O_IV:%.+]] = load i32, i32* [[OMP_IV]]
112 // CHECK-NEXT: [[O_UB:%.+]] = load i32, i32* [[OMP_UB]]
113 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ule i32 [[O_IV]], [[O_UB]]
114 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
115 
116 // Loop header
117 // CHECK: [[O_LOOP1_BODY]]
118 // CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
119 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
120 // CHECK-NEXT: [[CMP:%.+]] = icmp ule i32 [[IV]], [[UB]]
121 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
122   for (unsigned i = 131071; i <= 2147483647; i += 127) {
123 // CHECK: [[LOOP1_BODY]]
124 // Start of body: calculate i from IV:
125 // CHECK: [[IV1_1:%.+]] = load i32, i32* [[OMP_IV]]
126 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul i32 [[IV1_1]], 127
127 // CHECK-NEXT: [[CALC_I_2:%.+]] = add i32 131071, [[CALC_I_1]]
128 // CHECK-NEXT: store i32 [[CALC_I_2]], i32* [[LC_I:.+]]
129 // ... loop body ...
130 // End of body: store into a[i]:
131 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
132     a[i] = b[i] * c[i] * d[i];
133 // CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
134 // CHECK-NEXT: [[ADD1_2:%.+]] = add i32 [[IV1_2]], 1
135 // CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
136 // CHECK-NEXT: br label %{{.+}}
137   }
138 // CHECK: [[LOOP1_END]]
139 // Update the counters, adding stride
140 // CHECK:  [[LB:%.+]] = load i32, i32* [[OMP_LB]]
141 // CHECK-NEXT: [[ST:%.+]] = load i32, i32* [[OMP_ST]]
142 // CHECK-NEXT: [[ADD_LB:%.+]] = add i32 [[LB]], [[ST]]
143 // CHECK-NEXT: store i32 [[ADD_LB]], i32* [[OMP_LB]]
144 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
145 // CHECK-NEXT: [[ST:%.+]] = load i32, i32* [[OMP_ST]]
146 // CHECK-NEXT: [[ADD_UB:%.+]] = add i32 [[UB]], [[ST]]
147 // CHECK-NEXT: store i32 [[ADD_UB]], i32* [[OMP_UB]]
148 
149 // CHECK: [[O_LOOP1_END]]
150 // CHECK: call void @__kmpc_for_static_fini([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
151 // CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
152 // CHECK: ret void
153 }
154 
155 // CHECK-LABEL: define {{.*void}} @{{.*}}dynamic1{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
156 void dynamic1(float *a, float *b, float *c, float *d) {
157 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
158   #pragma omp for schedule(dynamic)
159 // CHECK: call void @__kmpc_dispatch_init_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 35, i64 0, i64 16908287, i64 1, i64 1)
160 //
161 // 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:%[^,]+]])
162 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
163 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
164 
165 // Loop header
166 // CHECK: [[O_LOOP1_BODY]]
167 // CHECK: [[LB:%.+]] = load i64, i64* [[OMP_LB]]
168 // CHECK-NEXT: store i64 [[LB]], i64* [[OMP_IV:[^,]+]]
169 // CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]
170 
171 // CHECK-NEXT: [[UB:%.+]] = load i64, i64* [[OMP_UB]]
172 // CHECK-NEXT: [[CMP:%.+]] = icmp ule i64 [[IV]], [[UB]]
173 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
174   for (unsigned long long i = 131071; i < 2147483647; i += 127) {
175 // CHECK: [[LOOP1_BODY]]
176 // Start of body: calculate i from IV:
177 // CHECK: [[IV1_1:%.+]] = load i64, i64* [[OMP_IV]]
178 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul i64 [[IV1_1]], 127
179 // CHECK-NEXT: [[CALC_I_2:%.+]] = add i64 131071, [[CALC_I_1]]
180 // CHECK-NEXT: store i64 [[CALC_I_2]], i64* [[LC_I:.+]]
181 // ... loop body ...
182 // End of body: store into a[i]:
183 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
184     a[i] = b[i] * c[i] * d[i];
185 // CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}
186 // CHECK-NEXT: [[ADD1_2:%.+]] = add i64 [[IV1_2]], 1
187 // CHECK-NEXT: store i64 [[ADD1_2]], i64* [[OMP_IV]]
188 // CHECK-NEXT: br label %{{.+}}
189   }
190 // CHECK: [[LOOP1_END]]
191 // CHECK: [[O_LOOP1_END]]
192 // CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
193 // CHECK: ret void
194 }
195 
196 // CHECK-LABEL: define {{.*void}} @{{.*}}guided7{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
197 void guided7(float *a, float *b, float *c, float *d) {
198 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
199   #pragma omp for schedule(guided, 7)
200 // CHECK: call void @__kmpc_dispatch_init_8u([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 36, i64 0, i64 16908287, i64 1, i64 7)
201 //
202 // 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:%[^,]+]])
203 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
204 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
205 
206 // Loop header
207 // CHECK: [[O_LOOP1_BODY]]
208 // CHECK: [[LB:%.+]] = load i64, i64* [[OMP_LB]]
209 // CHECK-NEXT: store i64 [[LB]], i64* [[OMP_IV:[^,]+]]
210 // CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]
211 
212 // CHECK-NEXT: [[UB:%.+]] = load i64, i64* [[OMP_UB]]
213 // CHECK-NEXT: [[CMP:%.+]] = icmp ule i64 [[IV]], [[UB]]
214 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
215   for (unsigned long long i = 131071; i < 2147483647; i += 127) {
216 // CHECK: [[LOOP1_BODY]]
217 // Start of body: calculate i from IV:
218 // CHECK: [[IV1_1:%.+]] = load i64, i64* [[OMP_IV]]
219 // CHECK-NEXT: [[CALC_I_1:%.+]] = mul i64 [[IV1_1]], 127
220 // CHECK-NEXT: [[CALC_I_2:%.+]] = add i64 131071, [[CALC_I_1]]
221 // CHECK-NEXT: store i64 [[CALC_I_2]], i64* [[LC_I:.+]]
222 // ... loop body ...
223 // End of body: store into a[i]:
224 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
225     a[i] = b[i] * c[i] * d[i];
226 // CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}
227 // CHECK-NEXT: [[ADD1_2:%.+]] = add i64 [[IV1_2]], 1
228 // CHECK-NEXT: store i64 [[ADD1_2]], i64* [[OMP_IV]]
229 // CHECK-NEXT: br label %{{.+}}
230   }
231 // CHECK: [[LOOP1_END]]
232 // CHECK: [[O_LOOP1_END]]
233 // CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
234 // CHECK: ret void
235 }
236 
237 // CHECK-LABEL: define {{.*void}} @{{.*}}test_auto{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
238 void test_auto(float *a, float *b, float *c, float *d) {
239   unsigned int x = 0;
240   unsigned int y = 0;
241 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
242   #pragma omp for schedule(auto) collapse(2)
243 // 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)
244 //
245 // 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:%[^,]+]])
246 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
247 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
248 
249 // Loop header
250 // CHECK: [[O_LOOP1_BODY]]
251 // CHECK: [[LB:%.+]] = load i64, i64* [[OMP_LB]]
252 // CHECK-NEXT: store i64 [[LB]], i64* [[OMP_IV:[^,]+]]
253 // CHECK: [[IV:%.+]] = load i64, i64* [[OMP_IV]]
254 
255 // CHECK-NEXT: [[UB:%.+]] = load i64, i64* [[OMP_UB]]
256 // CHECK-NEXT: [[CMP:%.+]] = icmp sle i64 [[IV]], [[UB]]
257 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
258 // FIXME: When the iteration count of some nested loop is not a known constant,
259 // we should pre-calculate it, like we do for the total number of iterations!
260   for (char i = static_cast<char>(y); i <= '9'; ++i)
261     for (x = 11; x > 0; --x) {
262 // CHECK: [[LOOP1_BODY]]
263 // Start of body: indices are calculated from IV:
264 // CHECK: store i8 {{%[^,]+}}, i8* {{%[^,]+}}
265 // CHECK: store i32 {{%[^,]+}}, i32* {{%[^,]+}}
266 // ... loop body ...
267 // End of body: store into a[i]:
268 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
269     a[i] = b[i] * c[i] * d[i];
270 // CHECK: [[IV1_2:%.+]] = load i64, i64* [[OMP_IV]]{{.*}}
271 // CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i64 [[IV1_2]], 1
272 // CHECK-NEXT: store i64 [[ADD1_2]], i64* [[OMP_IV]]
273 // CHECK-NEXT: br label %{{.+}}
274   }
275 // CHECK: [[LOOP1_END]]
276 // CHECK: [[O_LOOP1_END]]
277 // CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
278 // CHECK: ret void
279 }
280 
281 // CHECK-LABEL: define {{.*void}} @{{.*}}runtime{{.*}}(float* {{.+}}, float* {{.+}}, float* {{.+}}, float* {{.+}})
282 void runtime(float *a, float *b, float *c, float *d) {
283   int x = 0;
284 // CHECK: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:[@%].+]])
285   #pragma omp for collapse(2) schedule(runtime)
286 // CHECK: call void @__kmpc_dispatch_init_4([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i32 37, i32 0, i32 199, i32 1, i32 1)
287 //
288 // 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:%[^,]+]])
289 // CHECK-NEXT: [[O_CMP:%.+]] = icmp ne i32 [[HASWORK]], 0
290 // CHECK-NEXT: br i1 [[O_CMP]], label %[[O_LOOP1_BODY:[^,]+]], label %[[O_LOOP1_END:[^,]+]]
291 
292 // Loop header
293 // CHECK: [[O_LOOP1_BODY]]
294 // CHECK: [[LB:%.+]] = load i32, i32* [[OMP_LB]]
295 // CHECK-NEXT: store i32 [[LB]], i32* [[OMP_IV:[^,]+]]
296 // CHECK: [[IV:%.+]] = load i32, i32* [[OMP_IV]]
297 
298 // CHECK-NEXT: [[UB:%.+]] = load i32, i32* [[OMP_UB]]
299 // CHECK-NEXT: [[CMP:%.+]] = icmp sle i32 [[IV]], [[UB]]
300 // CHECK-NEXT: br i1 [[CMP]], label %[[LOOP1_BODY:[^,]+]], label %[[LOOP1_END:[^,]+]]
301   for (unsigned char i = '0' ; i <= '9'; ++i)
302     for (x = -10; x < 10; ++x) {
303 // CHECK: [[LOOP1_BODY]]
304 // Start of body: indices are calculated from IV:
305 // CHECK: store i8 {{%[^,]+}}, i8* {{%[^,]+}}
306 // CHECK: store i32 {{%[^,]+}}, i32* {{%[^,]+}}
307 // ... loop body ...
308 // End of body: store into a[i]:
309 // CHECK: store float [[RESULT:%.+]], float* {{%.+}}
310     a[i] = b[i] * c[i] * d[i];
311 // CHECK: [[IV1_2:%.+]] = load i32, i32* [[OMP_IV]]{{.*}}
312 // CHECK-NEXT: [[ADD1_2:%.+]] = add nsw i32 [[IV1_2]], 1
313 // CHECK-NEXT: store i32 [[ADD1_2]], i32* [[OMP_IV]]
314 // CHECK-NEXT: br label %{{.+}}
315   }
316 // CHECK: [[LOOP1_END]]
317 // CHECK: [[O_LOOP1_END]]
318 // CHECK: call {{.+}} @__kmpc_cancel_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_LOC]], i32 [[GTID]])
319 // CHECK: ret void
320 }
321 
322 // CHECK-LABEL: test_precond
323 void test_precond() {
324   // CHECK: [[A_ADDR:%.+]] = alloca i8,
325   // CHECK: [[I_ADDR:%.+]] = alloca i8,
326   char a = 0;
327   // CHECK: store i32 0, i32* [[IV_ADDR:%.+]],
328   // CHECK: [[A:%.+]] = load i8, i8* [[A_ADDR]],
329   // CHECK: [[CONV:%.+]] = sext i8 [[A]] to i32
330   // CHECK: [[IV:%.+]] = load i32, i32* [[IV_ADDR]],
331   // CHECK: [[MUL:%.+]] = mul nsw i32 [[IV]], 1
332   // CHECK: [[ADD:%.+]] = add nsw i32 [[CONV]], [[MUL]]
333   // CHECK: [[CONV:%.+]] = trunc i32 [[ADD]] to i8
334   // CHECK: store i8 [[CONV]], i8* [[I_ADDR]],
335   // CHECK: [[A:%.+]] = load i8, i8* [[A_ADDR]],
336   // CHECK: [[CONV:%.+]] = sext i8 [[A]] to i32
337   // CHECK: [[CMP:%.+]] = icmp slt i32 [[CONV]], 10
338   // CHECK: br i1 [[CMP]], label %[[PRECOND_THEN:[^,]+]], label %[[PRECOND_END:[^,]+]]
339   // CHECK: [[PRECOND_THEN]]
340   // CHECK: call void @__kmpc_for_static_init_4
341 #pragma omp for
342   for(char i = a; i < 10; ++i);
343   // CHECK: call void @__kmpc_for_static_fini
344   // CHECK: [[PRECOND_END]]
345 }
346 
347 // TERM_DEBUG-LABEL: foo
348 int foo() {return 0;};
349 
350 // TERM_DEBUG-LABEL: parallel_for
351 void parallel_for(float *a) {
352 #pragma omp parallel
353 #pragma omp for schedule(static, 5)
354   // TERM_DEBUG-NOT: __kmpc_global_thread_num
355   // TERM_DEBUG:     call void @__kmpc_for_static_init_4u({{.+}}), !dbg [[DBG_LOC_START:![0-9]+]]
356   // TERM_DEBUG:     invoke i32 {{.*}}foo{{.*}}()
357   // TERM_DEBUG:     unwind label %[[TERM_LPAD:.+]],
358   // TERM_DEBUG-NOT: __kmpc_global_thread_num
359   // TERM_DEBUG:     call void @__kmpc_for_static_fini({{.+}}), !dbg [[DBG_LOC_END:![0-9]+]]
360   // TERM_DEBUG:     call {{.+}} @__kmpc_cancel_barrier({{.+}}), !dbg [[DBG_LOC_CANCEL:![0-9]+]]
361   // TERM_DEBUG:     [[TERM_LPAD]]
362   // TERM_DEBUG:     call void @__clang_call_terminate
363   // TERM_DEBUG:     unreachable
364   for (unsigned i = 131071; i <= 2147483647; i += 127)
365     a[i] += foo();
366 }
367 // Check source line corresponds to "#pragma omp for schedule(static, 5)" above:
368 // TERM_DEBUG-DAG: [[DBG_LOC_START]] = !DILocation(line: [[@LINE-15]],
369 // TERM_DEBUG-DAG: [[DBG_LOC_END]] = !DILocation(line: [[@LINE-16]],
370 // TERM_DEBUG-DAG: [[DBG_LOC_CANCEL]] = !DILocation(line: [[@LINE-17]],
371 
372 char i = 1, j = 2, k = 3;
373 // CHECK-LABEL: for_with_global_lcv
374 void for_with_global_lcv() {
375 // CHECK: [[I_ADDR:%.+]] = alloca i8,
376 // CHECK: [[J_ADDR:%.+]] = alloca i8,
377 
378 // CHECK: call void @__kmpc_for_static_init_4(
379 // CHECK-NOT: [[I]]
380 // CHECK: store i8 %{{.+}}, i8* [[I_ADDR]]
381 // CHECK-NOT: [[I]]
382 // CHECK: [[I_VAL:%.+]] = load i8, i8* [[I_ADDR]],
383 // CHECK-NOT: [[I]]
384 // CHECK: store i8 [[I_VAL]], i8* [[K]]
385 // CHECK-NOT: [[I]]
386 // CHECK: call void @__kmpc_for_static_fini(
387 #pragma omp for
388   for (i = 0; i < 2; ++i) {
389     k = i;
390   }
391 // CHECK: call void @__kmpc_for_static_init_4(
392 // CHECK-NOT: [[J]]
393 // CHECK: store i8 %{{.+}}, i8* [[J_ADDR]]
394 // CHECK-NOT: [[J]]
395 // CHECK: [[J_VAL:%.+]] = load i8, i8* [[J_ADDR]],
396 // CHECK-NOT: [[J]]
397 // CHECK: store i8 [[J_VAL]], i8* [[K]]
398 // CHECK-NOT: [[J]]
399 // CHECK: call void @__kmpc_for_static_fini(
400 #pragma omp for collapse(2)
401   for (int i = 0; i < 2; ++i)
402   for (j = 0; j < 2; ++j) {
403     k = i;
404     k = j;
405   }
406 }
407 
408 #endif // HEADER
409 
410