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