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