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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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(release: 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(release:map)
469   for (int i = 0; i < 10; ++i)
470     argc = x;
471 }
472 
473 // CHECK-LABEL:  void 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(delete: 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(delete:map)
493   for (int i = 0; i < 10; ++i)
494     argc = x;
495 }
496 
497 // CHECK-LABEL:  void 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)
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)
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)
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)
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)
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)
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