1 // RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s
2
3 // CHECK-LABEL: void xxx(int argc)
xxx(int argc)4 void xxx(int argc) {
5 // CHECK: [B1]
6 // CHECK-NEXT: 1: int x;
7 // CHECK-NEXT: 2: int cond;
8 // CHECK-NEXT: 3: int fp;
9 // CHECK-NEXT: 4: int rd;
10 // CHECK-NEXT: 5: int lin;
11 // CHECK-NEXT: 6: int step;
12 // CHECK-NEXT: 7: int map;
13 int x, cond, fp, rd, lin, step, map;
14 // CHECK-NEXT: [[#ATOM:]]: x
15 // CHECK-NEXT: [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
16 // CHECK-NEXT: [[#ATOM+2]]: argc
17 // CHECK-NEXT: [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]]
18 // CHECK-NEXT: [[#ATOM+4]]: #pragma omp atomic read
19 // CHECK-NEXT: [B1.[[#ATOM+3]]];
20 #pragma omp atomic read
21 argc = x;
22 // CHECK-NEXT: [[#CRIT:]]: x
23 // CHECK-NEXT: [[#CRIT+1]]: [B1.[[#CRIT]]] (ImplicitCastExpr, LValueToRValue, int)
24 // CHECK-NEXT: [[#CRIT+2]]: argc
25 // CHECK-NEXT: [[#CRIT+3]]: [B1.[[#CRIT+2]]] = [B1.[[#CRIT+1]]]
26 // CHECK-NEXT: [[#CRIT+4]]: #pragma omp critical
27 // CHECK-NEXT: [B1.[[#CRIT+3]]];
28 #pragma omp critical
29 argc = x;
30 // CHECK-NEXT: [[#MASTER:]]: x
31 // CHECK-NEXT: [[#MASTER+1]]: [B1.[[#MASTER]]] (ImplicitCastExpr, LValueToRValue, int)
32 // CHECK-NEXT: [[#MASTER+2]]: argc
33 // CHECK-NEXT: [[#MASTER+3]]: [B1.[[#MASTER+2]]] = [B1.[[#MASTER+1]]]
34 // CHECK-NEXT: [[#MASTER+4]]: #pragma omp master
35 // CHECK-NEXT: [B1.[[#MASTER+3]]];
36 #pragma omp master
37 argc = x;
38 // CHECK-NEXT: [[#PAR:]]: x
39 // CHECK-NEXT: [[#PAR+1]]: [B1.[[#PAR]]] (ImplicitCastExpr, LValueToRValue, int)
40 // CHECK-NEXT: [[#PAR+2]]: argc
41 // CHECK-NEXT: [[#PAR+3]]: [B1.[[#PAR+2]]] = [B1.[[#PAR+1]]]
42 // CHECK-NEXT: [[#PAR+4]]: cond
43 // CHECK-NEXT: [[#PAR+5]]: [B1.[[#PAR+4]]] (ImplicitCastExpr, LValueToRValue, int)
44 // CHECK-NEXT: [[#PAR+6]]: [B1.[[#PAR+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
45 // CHECK-NEXT: [[#PAR+7]]: fp
46 // CHECK-NEXT: [[#PAR+8]]: rd
47 // CHECK-NEXT: [[#PAR+9]]: #pragma omp parallel if(cond) firstprivate(fp) reduction(min: rd)
48 // CHECK-NEXT: [B1.[[#PAR+3]]];
49 #pragma omp parallel if(cond) firstprivate(fp) reduction(min:rd)
50 argc = x;
51 // CHECK-NEXT: [[#PSECT:]]: x
52 // CHECK-NEXT: [[#PSECT+1]]: [B1.[[#PSECT]]] (ImplicitCastExpr, LValueToRValue, int)
53 // CHECK-NEXT: [[#PSECT+2]]: argc
54 // CHECK-NEXT: [[#PSECT+3]]: [B1.[[#PSECT+2]]] = [B1.[[#PSECT+1]]]
55 // CHECK-NEXT: [[#PSECT+4]]: cond
56 // CHECK-NEXT: [[#PSECT+5]]: [B1.[[#PSECT+4]]] (ImplicitCastExpr, LValueToRValue, int)
57 // CHECK-NEXT: [[#PSECT+6]]: [B1.[[#PSECT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
58 // CHECK-NEXT: [[#PSECT+7]]: fp
59 // CHECK-NEXT: [[#PSECT+8]]: rd
60 // CHECK-NEXT: [[#PSECT+9]]: #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&: rd)
61 // CHECK-NEXT: {
62 // CHECK-NEXT: [B1.[[#PSECT+3]]];
63 // CHECK-NEXT: }
64 #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&:rd)
65 {
66 argc = x;
67 }
68 // CHECK-NEXT: [[#SINGLE:]]: x
69 // CHECK-NEXT: [[#SINGLE+1]]: [B1.[[#SINGLE]]] (ImplicitCastExpr, LValueToRValue, int)
70 // CHECK-NEXT: [[#SINGLE+2]]: argc
71 // CHECK-NEXT: [[#SINGLE+3]]: [B1.[[#SINGLE+2]]] = [B1.[[#SINGLE+1]]]
72 // CHECK-NEXT: [[#SINGLE+4]]: #pragma omp single
73 // CHECK-NEXT: [B1.[[#SINGLE+3]]];
74 #pragma omp single
75 argc = x;
76 // CHECK-NEXT: [[#TARGET:]]:
77 // CHECK-SAME: [B1.[[#TARGET+10]]]
78 // CHECK-NEXT: [[#TARGET+1]]: [B1.[[#TARGET+10]]] (ImplicitCastExpr, LValueToRValue, int)
79 // CHECK-NEXT: [[#TARGET+2]]: [B1.[[#TARGET+9]]]
80 // CHECK-NEXT: [[#TARGET+3]]: [B1.[[#TARGET+9]]] = [B1.[[#TARGET+1]]]
81 // CHECK-NEXT: [[#TARGET+4]]: cond
82 // CHECK-NEXT: [[#TARGET+5]]: [B1.[[#TARGET+4]]] (ImplicitCastExpr, LValueToRValue, int)
83 // CHECK-NEXT: [[#TARGET+6]]: [B1.[[#TARGET+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
84 // CHECK-NEXT: [[#TARGET+7]]: fp
85 // CHECK-NEXT: [[#TARGET+8]]: rd
86 // CHECK-NEXT: [[#TARGET+9]]: argc
87 // CHECK-NEXT: [[#TARGET+10]]: x
88 // CHECK-NEXT: [[#TARGET+11]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp) reduction(-: rd)
89 // CHECK-NEXT: [B1.[[#TARGET+3]]];
90 #pragma omp target depend(in \
91 : argc) if(cond) firstprivate(fp) reduction(-:rd)
92 argc = x;
93 // CHECK-NEXT: [[#TP:]]:
94 // CHECK-SAME: [B1.[[#TP+11]]]
95 // CHECK-NEXT: [[#TP+1]]: [B1.[[#TP+11]]] (ImplicitCastExpr, LValueToRValue, int)
96 // CHECK-NEXT: [[#TP+2]]: [B1.[[#TP+10]]]
97 // CHECK-NEXT: [[#TP+3]]: [B1.[[#TP+10]]] = [B1.[[#TP+1]]]
98 // CHECK-NEXT: [[#TP+4]]: cond
99 // CHECK-NEXT: [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int)
100 // CHECK-NEXT: [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
101 // CHECK-NEXT: [[#TP+7]]: fp
102 // CHECK-NEXT: [[#TP+8]]: rd
103 // CHECK-NEXT: [[#TP+9]]: map
104 // CHECK-NEXT: [[#TP+10]]: argc
105 // CHECK-NEXT: [[#TP+11]]: x
106 // CHECK-NEXT: [[#TP+12]]: #pragma omp target parallel if(cond) firstprivate(fp) reduction(+: rd) map(to: map)
107 // CHECK-NEXT: [B1.[[#TP+3]]];
108 #pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd) map(to:map)
109 argc = x;
110 // CHECK-NEXT: [[#TT:]]:
111 // CHECK-SAME: [B1.[[#TT+11]]]
112 // CHECK-NEXT: [[#TT+1]]: [B1.[[#TT+11]]] (ImplicitCastExpr, LValueToRValue, int)
113 // CHECK-NEXT: [[#TT+2]]: [B1.[[#TT+10]]]
114 // CHECK-NEXT: [[#TT+3]]: [B1.[[#TT+10]]] = [B1.[[#TT+1]]]
115 // CHECK-NEXT: [[#TT+4]]: cond
116 // CHECK-NEXT: [[#TT+5]]: [B1.[[#TT+4]]] (ImplicitCastExpr, LValueToRValue, int)
117 // CHECK-NEXT: [[#TT+6]]: [B1.[[#TT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
118 // CHECK-NEXT: [[#TT+7]]: fp
119 // CHECK-NEXT: [[#TT+8]]: rd
120 // CHECK-NEXT: [[#TT+9]]: map
121 // CHECK-NEXT: [[#TT+10]]: argc
122 // CHECK-NEXT: [[#TT+11]]: x
123 // CHECK-NEXT: [[#TT+12]]: #pragma omp target teams if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
124 // CHECK-NEXT: [B1.[[#TT+3]]];
125 #pragma omp target teams if(cond) firstprivate(fp) reduction(+:rd) map(tofrom:map)
126 argc = x;
127 // CHECK-NEXT: [[#TU:]]: cond
128 // CHECK-NEXT: [[#TU+1]]: [B1.[[#TU]]] (ImplicitCastExpr, LValueToRValue, int)
129 // CHECK-NEXT: [[#TU+2]]: [B1.[[#TU+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
130 // CHECK-NEXT: [[#TU+3]]: #pragma omp target update to(x) if(target update: cond)
131 #pragma omp target update to(x) if(target update:cond)
132 // CHECK-NEXT: [[#TASK:]]:
133 // CHECK-SAME: [B1.[[#TASK+9]]]
134 // CHECK-NEXT: [[#TASK+1]]: [B1.[[#TASK+9]]] (ImplicitCastExpr, LValueToRValue, int)
135 // CHECK-NEXT: [[#TASK+2]]: [B1.[[#TASK+8]]]
136 // CHECK-NEXT: [[#TASK+3]]: [B1.[[#TASK+8]]] = [B1.[[#TASK+1]]]
137 // CHECK-NEXT: [[#TASK+4]]: cond
138 // CHECK-NEXT: [[#TASK+5]]: [B1.[[#TASK+4]]] (ImplicitCastExpr, LValueToRValue, int)
139 // CHECK-NEXT: [[#TASK+6]]: [B1.[[#TASK+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
140 // CHECK-NEXT: [[#TASK+7]]: fp
141 // CHECK-NEXT: [[#TASK+8]]: argc
142 // CHECK-NEXT: [[#TASK+9]]: x
143 // CHECK-NEXT: [[#TASK+10]]: #pragma omp task if(cond) firstprivate(fp)
144 // CHECK-NEXT: [B1.[[#TASK+3]]];
145 #pragma omp task if(cond) firstprivate(fp)
146 argc = x;
147 // CHECK-NEXT: [[#TG:]]: x
148 // CHECK-NEXT: [[#TG+1]]: [B1.[[#TG]]] (ImplicitCastExpr, LValueToRValue, int)
149 // CHECK-NEXT: [[#TG+2]]: argc
150 // CHECK-NEXT: [[#TG+3]]: [B1.[[#TG+2]]] = [B1.[[#TG+1]]]
151 // CHECK-NEXT: [[#TG+4]]: #pragma omp taskgroup
152 // CHECK-NEXT: [B1.[[#TG+3]]];
153 #pragma omp taskgroup
154 argc = x;
155 // CHECK-NEXT: [[#TEAMS:]]: x
156 // CHECK-NEXT: [[#TEAMS+1]]: [B1.[[#TEAMS]]] (ImplicitCastExpr, LValueToRValue, int)
157 // CHECK-NEXT: [[#TEAMS+2]]: argc
158 // CHECK-NEXT: [[#TEAMS+3]]: [B1.[[#TEAMS+2]]] = [B1.[[#TEAMS+1]]]
159 // CHECK-NEXT: [[#TEAMS+4]]: [B1.[[#TEAMS+7]]]
160 // CHECK-NEXT: [[#TEAMS+5]]: [B1.[[#TEAMS+8]]]
161 // CHECK-NEXT: [[#TEAMS+6]]: #pragma omp teams firstprivate(fp) reduction(+: rd)
162 // CHECK-NEXT: [B1.[[#TEAMS+3]]];
163 // CHECK-NEXT: [[#TEAMS+7]]: fp
164 // CHECK-NEXT: [[#TEAMS+8]]: rd
165 // CHECK-NEXT: [[#TEAMS+9]]: argc
166 // CHECK-NEXT: [[#TEAMS+10]]: x
167 // CHECK-NEXT: [[#TEAMS+11]]: #pragma omp target
168 #pragma omp target
169 #pragma omp teams firstprivate(fp) reduction(+:rd)
170 argc = x;
171 // CHECK-NEXT: [B1.[[#TEAMS+6]]] Preds
172 }
173
174 // CHECK-LABEL: void dpf(int argc)
dpf(int argc)175 void dpf(int argc) {
176 int x, cond, fp, rd, lin, step, map;
177 // CHECK-DAG: [B3]
178 // CHECK-DAG: [[#DPFB:]]: x
179 // CHECK-DAG: [[#DPFB+1]]: [B3.[[#DPFB]]] (ImplicitCastExpr, LValueToRValue, int)
180 // CHECK-DAG: [[#DPFB+2]]: argc
181 // CHECK-DAG: [[#DPFB+3]]: [B3.[[#DPFB+2]]] = [B3.[[#DPFB+1]]]
182 // CHECK-DAG: [B1]
183 // CHECK-DAG: [[#DPF:]]: cond
184 // CHECK-DAG: [[#DPF+1]]: [B1.[[#DPF]]] (ImplicitCastExpr, LValueToRValue, int)
185 // CHECK-DAG: [[#DPF+2]]: [B1.[[#DPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
186 // CHECK-DAG: [[#DPF+3]]: fp
187 // CHECK-DAG: [[#DPF+4]]: rd
188 // CHECK-DAG: [[#DPF+5]]: #pragma omp distribute parallel for if(parallel: cond) firstprivate(fp) reduction(+: rd)
189 // CHECK-DAG: for (int i = 0;
190 // CHECK-DAG: [B3.[[#DPFB+3]]];
191 #pragma omp distribute parallel for if(parallel:cond) firstprivate(fp) reduction(+:rd)
192 for (int i = 0; i < 10; ++i)
193 argc = x;
194 }
195
196 // CHECK-LABEL: void dpfs(int argc)
dpfs(int argc)197 void dpfs(int argc) {
198 int x, cond, fp, rd, lin, step, map;
199 // CHECK-DAG: [B3]
200 // CHECK-DAG: [[#DPFSB:]]: x
201 // CHECK-DAG: [[#DPFSB+1]]: [B3.[[#DPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
202 // CHECK-DAG: [[#DPFSB+2]]: argc
203 // CHECK-DAG: [[#DPFSB+3]]: [B3.[[#DPFSB+2]]] = [B3.[[#DPFSB+1]]]
204 // CHECK-DAG: [B1]
205 // CHECK-DAG: [[#DPFS:]]: cond
206 // CHECK-DAG: [[#DPFS+1]]: [B1.[[#DPFS]]] (ImplicitCastExpr, LValueToRValue, int)
207 // CHECK-DAG: [[#DPFS+2]]: [B1.[[#DPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
208 // CHECK-DAG: [[#DPFS+3]]: fp
209 // CHECK-DAG: [[#DPFS+4]]: rd
210 // CHECK-DAG: [[#DPFS+5]]: #pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-: rd)
211 // CHECK-DAG: for (int i = 0;
212 // CHECK-DAG: [B3.[[#DPFSB+3]]];
213 #pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-:rd)
214 for (int i = 0; i < 10; ++i)
215 argc = x;
216 }
217
218 // CHECK-LABEL: void ds(int argc)
ds(int argc)219 void ds(int argc) {
220 int x, cond, fp, rd, lin, step, map;
221 // CHECK-DAG: [B3]
222 // CHECK-DAG: [[#DSB:]]: x
223 // CHECK-DAG: [[#DSB+1]]: [B3.[[#DSB]]] (ImplicitCastExpr, LValueToRValue, int)
224 // CHECK-DAG: [[#DSB+2]]: argc
225 // CHECK-DAG: [[#DSB+3]]: [B3.[[#DSB+2]]] = [B3.[[#DSB+1]]]
226 // CHECK-DAG: [B1]
227 // CHECK-DAG: [[#DS:]]: #pragma omp distribute simd
228 // CHECK-DAG: for (int i = 0;
229 // CHECK-DAG: [B3.[[#DSB+3]]];
230 #pragma omp distribute simd
231 for (int i = 0; i < 10; ++i)
232 argc = x;
233 }
234
235 // CHECK-LABEL: void for_fn(int argc)
for_fn(int argc)236 void for_fn(int argc) {
237 int x, cond, fp, rd, lin, step, map;
238 // CHECK-DAG: [B3]
239 // CHECK-DAG: [[#FORB:]]: x
240 // CHECK-DAG: [[#FORB+1]]: [B3.[[#FORB]]] (ImplicitCastExpr, LValueToRValue, int)
241 // CHECK-DAG: [[#FORB+2]]: argc
242 // CHECK-DAG: [[#FORB+3]]: [B3.[[#FORB+2]]] = [B3.[[#FORB+1]]]
243 // CHECK-DAG: [B1]
244 // CHECK-DAG: [[#FOR:]]: lin
245 // CHECK-DAG: [[#FOR+1]]: step
246 // CHECK-DAG: [[#FOR+2]]: [B1.[[#FOR+1]]] (ImplicitCastExpr, LValueToRValue, int)
247 // CHECK-DAG: [[#FOR+3]]: #pragma omp for linear(lin: step)
248 // CHECK-DAG: for (int i = 0;
249 // CHECK-DAG: [B3.[[#FORB+3]]];
250 #pragma omp for linear(lin : step)
251 for (int i = 0; i < 10; ++i)
252 argc = x;
253 }
254
255 // CHECK-LABEL: void fs(int argc)
fs(int argc)256 void fs(int argc) {
257 int x, cond, fp, rd, lin, step, map;
258 // CHECK-DAG: [B3]
259 // CHECK-DAG: [[#FSB:]]: x
260 // CHECK-DAG: [[#FSB+1]]: [B3.[[#FSB]]] (ImplicitCastExpr, LValueToRValue, int)
261 // CHECK-DAG: [[#FSB+2]]: argc
262 // CHECK-DAG: [[#FSB+3]]: [B3.[[#FSB+2]]] = [B3.[[#FSB+1]]]
263 // CHECK-DAG: [B1]
264 // CHECK-DAG: [[#FS:]]: lin
265 // CHECK-DAG: [[#FS+1]]: step
266 // CHECK-DAG: [[#FS+2]]: [B1.[[#FS+1]]] (ImplicitCastExpr, LValueToRValue, int)
267 // CHECK-DAG: [[#FS+3]]: #pragma omp for simd linear(lin: step)
268 // CHECK-DAG: for (int i = 0;
269 // CHECK-DAG: [B3.[[#FSB+3]]];
270 #pragma omp for simd linear(lin: step)
271 for (int i = 0; i < 10; ++i)
272 argc = x;
273 }
274
275 // CHECK-LABEL: void ord(int argc)
ord(int argc)276 void ord(int argc) {
277 int x, cond, fp, rd, lin, step, map;
278 // CHECK-DAG: [B3]
279 // CHECK-DAG: [[#ORDB:]]: x
280 // CHECK-DAG: [[#ORDB+1]]: [B3.[[#ORDB]]] (ImplicitCastExpr, LValueToRValue, int)
281 // CHECK-DAG: [[#ORDB+2]]: argc
282 // CHECK-DAG: [[#ORDB+3]]: [B3.[[#ORDB+2]]] = [B3.[[#ORDB+1]]]
283 // CHECK-DAG: [[#ORDB+4]]: #pragma omp ordered
284 // CHECK-DAG: [B3.[[#ORDB+3]]];
285 // CHECK-DAG: [B1]
286 // CHECK-DAG: [[#ORD:]]: #pragma omp for ordered
287 // CHECK-DAG: for (int i = 0
288 // CHECK-DAG:[B3.[[#ORDB+4]]] }
289 #pragma omp for ordered
290 for (int i = 0; i < 10; ++i) {
291 #pragma omp ordered
292 argc = x;
293 }
294 }
295
296 // CHECK-LABEL: void pf(int argc)
pf(int argc)297 void pf(int argc) {
298 int x, cond, fp, rd, lin, step, map;
299 // CHECK-DAG: [B3]
300 // CHECK-DAG: [[#PFB:]]: x
301 // CHECK-DAG: [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)
302 // CHECK-DAG: [[#PFB+2]]: argc
303 // CHECK-DAG: [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]
304 // CHECK-DAG: [B1]
305 // CHECK-DAG: [[#PF:]]: cond
306 // CHECK-DAG: [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)
307 // CHECK-DAG: [[#PF+2]]: [B1.[[#PF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
308 // CHECK-DAG: [[#PF+3]]: fp
309 // CHECK-DAG: [[#PF+4]]: rd
310 // CHECK-DAG: [[#PF+5]]: lin
311 // CHECK-DAG: [[#PF+6]]: step
312 // CHECK-DAG: [[#PF+7]]: [B1.[[#PF+6]]] (ImplicitCastExpr, LValueToRValue, int)
313 // CHECK-DAG: [[#PF+8]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd) linear(lin: step)
314 // CHECK-DAG: for (int i = 0;
315 // CHECK-DAG: [B3.[[#PFB+3]]];
316 #pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd) linear(lin: step)
317 for (int i = 0; i < 10; ++i)
318 argc = x;
319 }
320
321 // CHECK-LABEL: void pfs(int argc)
pfs(int argc)322 void pfs(int argc) {
323 int x, cond, fp, rd, lin, step, map;
324 // CHECK-DAG: [B3]
325 // CHECK-DAG: [[#PFSB:]]: x
326 // CHECK-DAG: [[#PFSB+1]]: [B3.[[#PFSB]]] (ImplicitCastExpr, LValueToRValue, int)
327 // CHECK-DAG: [[#PFSB+2]]: argc
328 // CHECK-DAG: [[#PFSB+3]]: [B3.[[#PFSB+2]]] = [B3.[[#PFSB+1]]]
329 // CHECK-DAG: [B1]
330 // CHECK-DAG: [[#PFS:]]: cond
331 // CHECK-DAG: [[#PFS+1]]: [B1.[[#PFS]]] (ImplicitCastExpr, LValueToRValue, int)
332 // CHECK-DAG: [[#PFS+2]]: [B1.[[#PFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
333 // CHECK-DAG: [[#PFS+3]]: fp
334 // CHECK-DAG: [[#PFS+4]]: rd
335 // CHECK-DAG: [[#PFS+5]]: lin
336 // CHECK-DAG: [[#PFS+6]]: step
337 // CHECK-DAG: [[#PFS+7]]: [B1.[[#PFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
338 // CHECK-DAG: [[#PFS+8]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd) linear(lin: step)
339 // CHECK-DAG: for (int i = 0;
340 // CHECK-DAG: [B3.[[#PFSB+3]]];
341 #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd) linear(lin: step)
342 for (int i = 0; i < 10; ++i)
343 argc = x;
344 }
345
346 // CHECK-LABEL: void simd(int argc)
simd(int argc)347 void simd(int argc) {
348 int x, cond, fp, rd, lin, step, map;
349 // CHECK-DAG: [B3]
350 // CHECK-DAG: [[#SIMDB:]]: x
351 // CHECK-DAG: [[#SIMDB+1]]: [B3.[[#SIMDB]]] (ImplicitCastExpr, LValueToRValue, int)
352 // CHECK-DAG: [[#SIMDB+2]]: argc
353 // CHECK-DAG: [[#SIMDB+3]]: [B3.[[#SIMDB+2]]] = [B3.[[#SIMDB+1]]]
354 // CHECK-DAG: [B1]
355 // CHECK-DAG: [[#SIMD:]]: lin
356 // CHECK-DAG: [[#SIMD+1]]: step
357 // CHECK-DAG: [[#SIMD+2]]: [B1.[[#SIMD+1]]] (ImplicitCastExpr, LValueToRValue, int)
358 // CHECK-DAG: [[#SIMD+3]]: #pragma omp simd linear(lin: step)
359 // CHECK-DAG: for (int i = 0;
360 // CHECK-DAG: [B3.[[#SIMDB+3]]];
361 #pragma omp simd linear(lin: step)
362 for (int i = 0; i < 10; ++i)
363 argc = x;
364 }
365
366 // CHECK-LABEL: void tpf(int argc)
tpf(int argc)367 void tpf(int argc) {
368 int x, cond, fp, rd, lin, step, map;
369 // CHECK-DAG: [B3]
370 // CHECK-DAG: [[#TPFB:]]: x
371 // CHECK-DAG: [[#TPFB+1]]: [B3.[[#TPFB]]] (ImplicitCastExpr, LValueToRValue, int)
372 // CHECK-DAG: [[#TPFB+2]]: argc
373 // CHECK-DAG: [[#TPFB+3]]: [B3.[[#TPFB+2]]] = [B3.[[#TPFB+1]]]
374 // CHECK-DAG: [B1]
375 // CHECK-DAG: [[#TPF:]]: cond
376 // CHECK-DAG: [[#TPF+1]]: [B1.[[#TPF]]] (ImplicitCastExpr, LValueToRValue, int)
377 // CHECK-DAG: [[#TPF+2]]: [B1.[[#TPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
378 // CHECK-DAG: [[#TPF+3]]: fp
379 // CHECK-DAG: [[#TPF+4]]: rd
380 // CHECK-DAG: [[#TPF+5]]: lin
381 // CHECK-DAG: [[#TPF+6]]: step
382 // CHECK-DAG: [[#TPF+7]]: [B1.[[#TPF+6]]] (ImplicitCastExpr, LValueToRValue, int)
383 // CHECK-DAG: [[#TPF+8]]: map
384 // CHECK-DAG: [[#TPF+9]]: [B3.[[#TPFB+2]]]
385 // CHECK-DAG: [[#TPF+10]]: [B3.[[#TPFB]]]
386 // CHECK-DAG: [[#TPF+11]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step) map(tofrom: map)
387 // CHECK-DAG: for (int i = 0;
388 // CHECK-DAG: [B3.[[#TPFB+3]]];
389 #pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step) map(map)
390 for (int i = 0; i < 10; ++i)
391 argc = x;
392 }
393
394 // CHECK-LABEL: void tpfs(int argc)
tpfs(int argc)395 void tpfs(int argc) {
396 int x, cond, fp, rd, lin, step, map;
397 // CHECK-DAG: [B3]
398 // CHECK-DAG: [[#TPFSB:]]: x
399 // CHECK-DAG: [[#TPFSB+1]]: [B3.[[#TPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
400 // CHECK-DAG: [[#TPFSB+2]]: argc
401 // CHECK-DAG: [[#TPFSB+3]]: [B3.[[#TPFSB+2]]] = [B3.[[#TPFSB+1]]]
402 // CHECK-DAG: [B1]
403 // CHECK-DAG: [[#TPFS:]]: cond
404 // CHECK-DAG: [[#TPFS+1]]: [B1.[[#TPFS]]] (ImplicitCastExpr, LValueToRValue, int)
405 // CHECK-DAG: [[#TPFS+2]]: [B1.[[#TPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
406 // CHECK-DAG: [[#TPFS+3]]: fp
407 // CHECK-DAG: [[#TPFS+4]]: rd
408 // CHECK-DAG: [[#TPFS+5]]: lin
409 // CHECK-DAG: [[#TPFS+6]]: step
410 // CHECK-DAG: [[#TPFS+7]]: [B1.[[#TPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
411 // CHECK-DAG: [[#TPFS+8]]: map
412 // CHECK-DAG: [[#TPFS+9]]: [B3.[[#TPFSB+2]]]
413 // CHECK-DAG: [[#TPFS+10]]: [B3.[[#TPFSB]]]
414 // CHECK-DAG: [[#TPFS+11]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step) map(tofrom: map)
415 // CHECK-DAG: for (int i = 0;
416 // CHECK-DAG: [B3.[[#TPFSB+3]]];
417 #pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step) map(tofrom:map)
418 for (int i = 0; i < 10; ++i)
419 argc = x;
420 }
421
422 // CHECK-LABEL: void ts(int argc)
ts(int argc)423 void ts(int argc) {
424 int x, cond, fp, rd, lin, step, map;
425 // CHECK-DAG: [B3]
426 // CHECK-DAG: [[#TSB:]]: x
427 // CHECK-DAG: [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)
428 // CHECK-DAG: [[#TSB+2]]: argc
429 // CHECK-DAG: [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]
430 // CHECK-DAG: [B1]
431 // CHECK-DAG: [[#TS:]]: cond
432 // CHECK-DAG: [[#TS+1]]: [B1.[[#TS]]] (ImplicitCastExpr, LValueToRValue, int)
433 // CHECK-DAG: [[#TS+2]]: [B1.[[#TS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
434 // CHECK-DAG: [[#TS+3]]: fp
435 // CHECK-DAG: [[#TS+4]]: rd
436 // CHECK-DAG: [[#TS+5]]: lin
437 // CHECK-DAG: [[#TS+6]]: step
438 // CHECK-DAG: [[#TS+7]]: [B1.[[#TS+6]]] (ImplicitCastExpr, LValueToRValue, int)
439 // CHECK-DAG: [[#TS+8]]: [B3.[[#TSB+2]]]
440 // CHECK-DAG: [[#TS+9]]: [B3.[[#TSB]]]
441 // CHECK-DAG: [[#TS+10]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step) map(alloc: map)
442 // CHECK-DAG: for (int i = 0;
443 // CHECK-DAG: [B3.[[#TSB+3]]];
444 #pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step) map(alloc:map)
445 for (int i = 0; i < 10; ++i)
446 argc = x;
447 }
448
449 // CHECK-LABEL: void ttd(int argc)
ttd(int argc)450 void ttd(int argc) {
451 int x, cond, fp, rd, lin, step, map;
452 // CHECK-DAG: [B3]
453 // CHECK-DAG: [[#TTDB:]]: x
454 // CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
455 // CHECK-DAG: [[#TTDB+2]]: argc
456 // CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
457 // CHECK-DAG: [B1]
458 // CHECK-DAG: [[#TTD:]]: cond
459 // CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
460 // CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
461 // CHECK-DAG: [[#TTD+3]]: fp
462 // CHECK-DAG: [[#TTD+4]]: rd
463 // CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
464 // CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
465 // CHECK-DAG: [[#TTD+7]]: #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
466 // CHECK-DAG: for (int i = 0;
467 // CHECK-DAG: [B3.[[#TTDB+3]]];
468 #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
469 for (int i = 0; i < 10; ++i)
470 argc = x;
471 }
472
473 // CHECK-LABEL: void ttdpf(int argc)
ttdpf(int argc)474 void ttdpf(int argc) {
475 int x, cond, fp, rd, lin, step, map;
476 // CHECK-DAG: [B3]
477 // CHECK-DAG: [[#TTDPFB:]]: x
478 // CHECK-DAG: [[#TTDPFB+1]]: [B3.[[#TTDPFB]]] (ImplicitCastExpr, LValueToRValue, int)
479 // CHECK-DAG: [[#TTDPFB+2]]: argc
480 // CHECK-DAG: [[#TTDPFB+3]]: [B3.[[#TTDPFB+2]]] = [B3.[[#TTDPFB+1]]]
481 // CHECK-DAG: [B1]
482 // CHECK-DAG: [[#TTDPF:]]: cond
483 // CHECK-DAG: [[#TTDPF+1]]: [B1.[[#TTDPF]]] (ImplicitCastExpr, LValueToRValue, int)
484 // CHECK-DAG: [[#TTDPF+2]]: [B1.[[#TTDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
485 // CHECK-DAG: [[#TTDPF+3]]: fp
486 // CHECK-DAG: [[#TTDPF+4]]: rd
487 // CHECK-DAG: [[#TTDPF+5]]: [B3.[[#TTDPFB+2]]]
488 // CHECK-DAG: [[#TTDPF+6]]: [B3.[[#TTDPFB]]]
489 // CHECK-DAG: [[#TTDPF+7]]: #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
490 // CHECK-DAG: for (int i = 0;
491 // CHECK-DAG: [B3.[[#TTDPFB+3]]];
492 #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
493 for (int i = 0; i < 10; ++i)
494 argc = x;
495 }
496
497 // CHECK-LABEL: void ttdpfs(int argc)
ttdpfs(int argc)498 void ttdpfs(int argc) {
499 int x, cond, fp, rd, lin, step, map;
500 // CHECK-DAG: [B3]
501 // CHECK-DAG: [[#TTDPFSB:]]: x
502 // CHECK-DAG: [[#TTDPFSB+1]]: [B3.[[#TTDPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
503 // CHECK-DAG: [[#TTDPFSB+2]]: argc
504 // CHECK-DAG: [[#TTDPFSB+3]]: [B3.[[#TTDPFSB+2]]] = [B3.[[#TTDPFSB+1]]]
505 // CHECK-DAG: [B1]
506 // CHECK-DAG: [[#TTDPFS:]]: cond
507 // CHECK-DAG: [[#TTDPFS+1]]: [B1.[[#TTDPFS]]] (ImplicitCastExpr, LValueToRValue, int)
508 // CHECK-DAG: [[#TTDPFS+2]]: [B1.[[#TTDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
509 // CHECK-DAG: [[#TTDPFS+3]]: fp
510 // CHECK-DAG: [[#TTDPFS+4]]: rd
511 // CHECK-DAG: [[#TTDPFS+5]]: [B3.[[#TTDPFSB+2]]]
512 // CHECK-DAG: [[#TTDPFS+6]]: [B3.[[#TTDPFSB]]]
513 // CHECK-DAG: [[#TTDPFS+7]]: #pragma omp target teams distribute parallel for simd if(parallel: cond) firstprivate(fp) reduction(+: rd) map(from: map)
514 // CHECK-DAG: for (int i = 0;
515 // CHECK-DAG: [B3.[[#TTDPFSB+3]]];
516 #pragma omp target teams distribute parallel for simd if(parallel:cond) firstprivate(fp) reduction(+:rd) map(from:map)
517 for (int i = 0; i < 10; ++i)
518 argc = x;
519 }
520
521 // CHECK-LABEL: void ttds(int argc)
ttds(int argc)522 void ttds(int argc) {
523 int x, cond, fp, rd, lin, step, map;
524 // CHECK-DAG: [B3]
525 // CHECK-DAG: [[#TTDSB:]]: x
526 // CHECK-DAG: [[#TTDSB+1]]: [B3.[[#TTDSB]]] (ImplicitCastExpr, LValueToRValue, int)
527 // CHECK-DAG: [[#TTDSB+2]]: argc
528 // CHECK-DAG: [[#TTDSB+3]]: [B3.[[#TTDSB+2]]] = [B3.[[#TTDSB+1]]]
529 // CHECK-DAG: [B1]
530 // CHECK-DAG: [[#TTDS:]]: cond
531 // CHECK-DAG: [[#TTDS+1]]: [B1.[[#TTDS]]] (ImplicitCastExpr, LValueToRValue, int)
532 // CHECK-DAG: [[#TTDS+2]]: [B1.[[#TTDS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
533 // CHECK-DAG: [[#TTDS+3]]: fp
534 // CHECK-DAG: [[#TTDS+4]]: rd
535 // CHECK-DAG: [[#TTDS+5]]: map
536 // CHECK-DAG: [[#TTDS+6]]: [B3.[[#TTDSB+2]]]
537 // CHECK-DAG: [[#TTDS+7]]: [B3.[[#TTDSB]]]
538 // CHECK-DAG: [[#TTDS+8]]: #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
539 // CHECK-DAG: for (int i = 0;
540 // CHECK-DAG: [B3.[[#TTDPFSB+3]]];
541 #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+:rd) map(map)
542 for (int i = 0; i < 10; ++i)
543 argc = x;
544 }
545
546 // CHECK-LABEL: void tl(int argc)
tl(int argc)547 void tl(int argc) {
548 int x, cond, fp, rd, lin, step, map;
549 // CHECK-DAG: [B3]
550 // CHECK-DAG: [[#TLB:]]: x
551 // CHECK-DAG: [[#TLB+1]]: [B3.[[#TLB]]] (ImplicitCastExpr, LValueToRValue, int)
552 // CHECK-DAG: [[#TLB+2]]: argc
553 // CHECK-DAG: [[#TLB+3]]: [B3.[[#TLB+2]]] = [B3.[[#TLB+1]]]
554 // CHECK-DAG: [B1]
555 // CHECK-DAG: [[#TL:]]: cond
556 // CHECK-DAG: [[#TL+1]]: [B1.[[#TL]]] (ImplicitCastExpr, LValueToRValue, int)
557 // CHECK-DAG: [[#TL+2]]: [B1.[[#TL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
558 // CHECK-DAG: [[#TL+3]]: fp
559 // CHECK-DAG: [[#TL+4]]: rd
560 // CHECK-DAG: [[#TL+5]]: [B3.[[#TLB+2]]]
561 // CHECK-DAG: [[#TL+6]]: [B3.[[#TLB]]]
562 // CHECK-DAG: [[#TL+7]]: #pragma omp taskloop if(cond) firstprivate(fp) reduction(+: rd)
563 // CHECK-DAG: for (int i = 0;
564 // CHECK-DAG: [B3.[[#TLB+3]]];
565 #pragma omp taskloop if(cond) firstprivate(fp) reduction(+:rd)
566 for (int i = 0; i < 10; ++i)
567 argc = x;
568 }
569
570 // CHECK-LABEL: void tls(int argc)
tls(int argc)571 void tls(int argc) {
572 int x, cond, fp, rd, lin, step, map;
573 // CHECK-DAG: [B3]
574 // CHECK-DAG: [[#TLSB:]]: x
575 // CHECK-DAG: [[#TLSB+1]]: [B3.[[#TLSB]]] (ImplicitCastExpr, LValueToRValue, int)
576 // CHECK-DAG: [[#TLSB+2]]: argc
577 // CHECK-DAG: [[#TLSB+3]]: [B3.[[#TLSB+2]]] = [B3.[[#TLSB+1]]]
578 // CHECK-DAG: [B1]
579 // CHECK-DAG: [[#TLS:]]: cond
580 // CHECK-DAG: [[#TLS+1]]: [B1.[[#TLS]]] (ImplicitCastExpr, LValueToRValue, int)
581 // CHECK-DAG: [[#TLS+2]]: [B1.[[#TLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
582 // CHECK-DAG: [[#TLS+3]]: fp
583 // CHECK-DAG: [[#TLS+4]]: rd
584 // CHECK-DAG: [[#TLS+5]]: lin
585 // CHECK-DAG: [[#TLS+6]]: step
586 // CHECK-DAG: [[#TLS+7]]: [B1.[[#TLS+6]]] (ImplicitCastExpr, LValueToRValue, int)
587 // CHECK-DAG: [[#TLS+8]]: [B3.[[#TLSB+2]]]
588 // CHECK-DAG: [[#TLS+9]]: [B3.[[#TLSB]]]
589 // CHECK-DAG: [[#TLS+10]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
590 // CHECK-DAG: for (int i = 0;
591 // CHECK-DAG: [B3.[[#TLSB+3]]];
592 #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
593 for (int i = 0; i < 10; ++i)
594 argc = x;
595 }
596
597 // CHECK-LABEL: void tdpf(int argc)
tdpf(int argc)598 void tdpf(int argc) {
599 int x, cond, fp, rd, lin, step, map;
600 // CHECK-DAG: [B1]
601 // CHECK-DAG: [[#TDPF:]]: cond
602 // CHECK-DAG: [[#TDPF+1]]: [B1.[[#TDPF]]] (ImplicitCastExpr, LValueToRValue, int)
603 // CHECK-DAG: [[#TDPF+2]]: [B1.[[#TDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
604 // CHECK-DAG: [[#TDPF+3]]: [B1.[[#TDPF+6]]]
605 // CHECK-DAG: [[#TDPF+4]]: [B1.[[#TDPF+7]]]
606 // CHECK-DAG: [[#TDPF+5]]: #pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd)
607 // CHECK-DAG: for (int i = 0;
608 // CHECK-DAG: [B3.[[#TDPFB:]]];
609 // CHECK-DAG: [[#TDPF+6]]: fp
610 // CHECK-DAG: [[#TDPF+7]]: rd
611 // CHECK-DAG: [[#TDPF+8]]: argc
612 // CHECK-DAG: [[#TDPF+9]]: x
613 // CHECK-DAG: [[#TDPF+10]]: cond
614 // CHECK-DAG: [[#TDPF+11]]: #pragma omp target
615 // CHECK-DAG: [B3]
616 // CHECK-DAG: [[#TDPFB-3]]: x
617 // CHECK-DAG: [[#TDPFB-2]]: [B3.[[#TDPFB-3]]] (ImplicitCastExpr, LValueToRValue, int)
618 // CHECK-DAG: [[#TDPFB-1]]: argc
619 // CHECK-DAG: [[#TDPFB]]: [B3.[[#TDPFB-1]]] = [B3.[[#TDPFB-2]]]
620 #pragma omp target
621 #pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd)
622 for (int i = 0; i < 10; ++i)
623 argc = x;
624 }
625
626 // CHECK-LABEL: void tdpfs(int argc)
tdpfs(int argc)627 void tdpfs(int argc) {
628 int x, cond, fp, rd, lin, step, map;
629 // CHECK-DAG: [B1]
630 // CHECK-DAG: [[#TDPFS:]]: cond
631 // CHECK-DAG: [[#TDPFS+1]]: [B1.[[#TDPFS]]] (ImplicitCastExpr, LValueToRValue, int)
632 // CHECK-DAG: [[#TDPFS+2]]: [B1.[[#TDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
633 // CHECK-DAG: [[#TDPFS+3]]: [B1.[[#TDPFS+6]]]
634 // CHECK-DAG: [[#TDPFS+4]]: [B1.[[#TDPFS+7]]]
635 // CHECK-DAG: [[#TDPFS+5]]: #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+: rd)
636 // CHECK-DAG: for (int i = 0;
637 // CHECK-DAG: [B3.[[#TDPFSB:]]];
638 // CHECK-DAG: [[#TDPFS+6]]: fp
639 // CHECK-DAG: [[#TDPFS+7]]: rd
640 // CHECK-DAG: [[#TDPFS+8]]: argc
641 // CHECK-DAG: [[#TDPFS+9]]: x
642 // CHECK-DAG: [[#TDPFS+10]]: cond
643 // CHECK-DAG: [[#TDPFS+11]]: #pragma omp target
644 // CHECK-DAG: [B3]
645 // CHECK-DAG: [[#TDPFSB-3]]: x
646 // CHECK-DAG: [[#TDPFSB-2]]: [B3.[[#TDPFSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
647 // CHECK-DAG: [[#TDPFSB-1]]: argc
648 // CHECK-DAG: [[#TDPFSB]]: [B3.[[#TDPFSB-1]]] = [B3.[[#TDPFSB-2]]]
649 #pragma omp target
650 #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+:rd)
651 for (int i = 0; i < 10; ++i)
652 argc = x;
653 }
654
655 // CHECK-LABEL: void tds(int argc)
tds(int argc)656 void tds(int argc) {
657 int x, cond, fp, rd, lin, step, map;
658 // CHECK-DAG: [B1]
659 // CHECK-DAG: [[#TDS:]]: #pragma omp teams distribute simd firstprivate(fp) reduction(+: rd)
660 // CHECK-DAG: [[#TDS-2]]: [B1.[[#TDS+1]]]
661 // CHECK-DAG: [[#TDS-1]]: [B1.[[#TDS+2]]]
662 // CHECK-DAG: for (int i = 0;
663 // CHECK-DAG: [B3.[[#TDSB:]]];
664 // CHECK-DAG: [[#TDS+1]]: fp
665 // CHECK-DAG: [[#TDS+2]]: rd
666 // CHECK-DAG: [[#TDS+3]]: argc
667 // CHECK-DAG: [[#TDS+4]]: x
668 // CHECK-DAG: [[#TDS+5]]: #pragma omp target
669 // CHECK-DAG: [B3]
670 // CHECK-DAG: [[#TDSB-3]]: x
671 // CHECK-DAG: [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
672 // CHECK-DAG: [[#TDSB-1]]: argc
673 // CHECK-DAG: [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]
674 #pragma omp target
675 #pragma omp teams distribute simd firstprivate(fp) reduction(+:rd)
676 for (int i = 0; i < 10; ++i)
677 argc = x;
678 }
679