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:  [[#DPF:]]: x
31 // CHECK-NEXT:  [[#DPF+1]]: [B1.[[#DPF]]] (ImplicitCastExpr, LValueToRValue, int)
32 // CHECK-NEXT:  [[#DPF+2]]: argc
33 // CHECK-NEXT:  [[#DPF+3]]: [B1.[[#DPF+2]]] = [B1.[[#DPF+1]]]
34 // CHECK-NEXT:  [[#DPF+4]]: cond
35 // CHECK-NEXT:  [[#DPF+5]]: [B1.[[#DPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
36 // CHECK-NEXT:  [[#DPF+6]]: [B1.[[#DPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
37 // CHECK-NEXT:  [[#DPF+7]]: fp
38 // CHECK-NEXT:  [[#DPF+8]]: rd
39 // CHECK-NEXT:  [[#DPF+9]]: #pragma omp distribute parallel for if(parallel: cond) firstprivate(fp) reduction(+: rd)
40 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
41 // CHECK-NEXT:        [B1.[[#DPF+3]]];
42 #pragma omp distribute parallel for if(parallel:cond) firstprivate(fp) reduction(+:rd)
43   for (int i = 0; i < 10; ++i)
44     argc = x;
45 // CHECK-NEXT:  [[#DPFS:]]: x
46 // CHECK-NEXT:  [[#DPFS+1]]: [B1.[[#DPFS]]] (ImplicitCastExpr, LValueToRValue, int)
47 // CHECK-NEXT:  [[#DPFS+2]]: argc
48 // CHECK-NEXT:  [[#DPFS+3]]: [B1.[[#DPFS+2]]] = [B1.[[#DPFS+1]]]
49 // CHECK-NEXT:  [[#DPFS+4]]: cond
50 // CHECK-NEXT:  [[#DPFS+5]]: [B1.[[#DPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
51 // CHECK-NEXT:  [[#DPFS+6]]: [B1.[[#DPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
52 // CHECK-NEXT:  [[#DPFS+7]]: fp
53 // CHECK-NEXT:  [[#DPFS+8]]: rd
54 // CHECK-NEXT:  [[#DPFS+9]]: #pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-: rd)
55 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
56 // CHECK-NEXT:        [B1.[[#DPFS+3]]];
57 #pragma omp distribute parallel for simd if(cond)  firstprivate(fp) reduction(-:rd)
58   for (int i = 0; i < 10; ++i)
59     argc = x;
60 // CHECK-NEXT:  [[#DS:]]: x
61 // CHECK-NEXT:  [[#DS+1]]: [B1.[[#DS]]] (ImplicitCastExpr, LValueToRValue, int)
62 // CHECK-NEXT:  [[#DS+2]]: argc
63 // CHECK-NEXT:  [[#DS+3]]: [B1.[[#DS+2]]] = [B1.[[#DS+1]]]
64 // CHECK-NEXT:  [[#DS+4]]: #pragma omp distribute simd
65 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
66 // CHECK-NEXT:        [B1.[[#DS+3]]];
67 #pragma omp distribute simd
68   for (int i = 0; i < 10; ++i)
69     argc = x;
70 // CHECK-NEXT:  [[#FOR:]]: x
71 // CHECK-NEXT:  [[#FOR+1]]: [B1.[[#FOR]]] (ImplicitCastExpr, LValueToRValue, int)
72 // CHECK-NEXT:  [[#FOR+2]]: argc
73 // CHECK-NEXT:  [[#FOR+3]]: [B1.[[#FOR+2]]] = [B1.[[#FOR+1]]]
74 // CHECK-NEXT:  [[#FOR+4]]: lin
75 // CHECK-NEXT:  [[#FOR+5]]: step
76 // CHECK-NEXT:  [[#FOR+6]]: [B1.[[#FOR+5]]] (ImplicitCastExpr, LValueToRValue, int)
77 // CHECK-NEXT:  [[#FOR+7]]: #pragma omp for linear(lin: step)
78 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
79 // CHECK-NEXT:        [B1.[[#FOR+3]]];
80 #pragma omp for linear(lin : step)
81   for (int i = 0; i < 10; ++i)
82     argc = x;
83 // CHECK-NEXT:  [[#FS:]]: x
84 // CHECK-NEXT:  [[#FS+1]]: [B1.[[#FS]]] (ImplicitCastExpr, LValueToRValue, int)
85 // CHECK-NEXT:  [[#FS+2]]: argc
86 // CHECK-NEXT:  [[#FS+3]]: [B1.[[#FS+2]]] = [B1.[[#FS+1]]]
87 // CHECK-NEXT:  [[#FS+4]]: lin
88 // CHECK-NEXT:  [[#FS+5]]: step
89 // CHECK-NEXT:  [[#FS+6]]: [B1.[[#FS+5]]] (ImplicitCastExpr, LValueToRValue, int)
90 // CHECK-NEXT:  [[#FS+7]]: #pragma omp for simd linear(lin: step)
91 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
92 // CHECK-NEXT:        [B1.[[#FS+3]]];
93 #pragma omp for simd linear(lin: step)
94   for (int i = 0; i < 10; ++i)
95     argc = x;
96 // CHECK-NEXT:  [[#MASTER:]]: x
97 // CHECK-NEXT:  [[#MASTER+1]]: [B1.[[#MASTER]]] (ImplicitCastExpr, LValueToRValue, int)
98 // CHECK-NEXT:  [[#MASTER+2]]: argc
99 // CHECK-NEXT:  [[#MASTER+3]]: [B1.[[#MASTER+2]]] = [B1.[[#MASTER+1]]]
100 // CHECK-NEXT:  [[#MASTER+4]]: #pragma omp master
101 // CHECK-NEXT:    [B1.[[#MASTER+3]]];
102 #pragma omp master
103   argc = x;
104 // CHECK-NEXT:  [[#ORD:]]: x
105 // CHECK-NEXT:  [[#ORD+1]]: [B1.[[#ORD]]] (ImplicitCastExpr, LValueToRValue, int)
106 // CHECK-NEXT:  [[#ORD+2]]: argc
107 // CHECK-NEXT:  [[#ORD+3]]: [B1.[[#ORD+2]]] = [B1.[[#ORD+1]]]
108 // CHECK-NEXT:  [[#ORD+4]]: #pragma omp ordered
109 // CHECK-NEXT:    [B1.[[#ORD+3]]];
110 // CHECK-NEXT:  [[#ORD+5]]: #pragma omp for ordered
111 // CHECK-NEXT:    for (int i = 0; i < 10; ++i) {
112 // CHECK-NEXT:[B1.[[#ORD+4]]]    }
113 #pragma omp for ordered
114   for (int i = 0; i < 10; ++i) {
115 #pragma omp ordered
116     argc = x;
117   }
118 // CHECK-NEXT:  [[#PF:]]: x
119 // CHECK-NEXT:  [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)
120 // CHECK-NEXT:  [[#PF+2]]: argc
121 // CHECK-NEXT:  [[#PF+3]]: [B1.[[#PF+2]]] = [B1.[[#PF+1]]]
122 // CHECK-NEXT:  [[#PF+4]]: cond
123 // CHECK-NEXT:  [[#PF+5]]: [B1.[[#PF+4]]] (ImplicitCastExpr, LValueToRValue, int)
124 // CHECK-NEXT:  [[#PF+6]]: [B1.[[#PF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
125 // CHECK-NEXT:  [[#PF+7]]: fp
126 // CHECK-NEXT:  [[#PF+8]]: rd
127 // CHECK-NEXT:  [[#PF+9]]: lin
128 // CHECK-NEXT:  [[#PF+10]]: step
129 // CHECK-NEXT:  [[#PF+11]]: [B1.[[#PF+10]]] (ImplicitCastExpr, LValueToRValue, int)
130 // CHECK-NEXT:  [[#PF+12]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd) linear(lin: step)
131 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
132 // CHECK-NEXT:        [B1.[[#PF+3]]];
133 #pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd) linear(lin: step)
134   for (int i = 0; i < 10; ++i)
135     argc = x;
136 // CHECK-NEXT:  [[#PFS:]]: x
137 // CHECK-NEXT:  [[#PFS+1]]: [B1.[[#PFS]]] (ImplicitCastExpr, LValueToRValue, int)
138 // CHECK-NEXT:  [[#PFS+2]]: argc
139 // CHECK-NEXT:  [[#PFS+3]]: [B1.[[#PFS+2]]] = [B1.[[#PFS+1]]]
140 // CHECK-NEXT:  [[#PFS+4]]: cond
141 // CHECK-NEXT:  [[#PFS+5]]: [B1.[[#PFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
142 // CHECK-NEXT:  [[#PFS+6]]: [B1.[[#PFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
143 // CHECK-NEXT:  [[#PFS+7]]: fp
144 // CHECK-NEXT:  [[#PFS+8]]: rd
145 // CHECK-NEXT:  [[#PFS+9]]: lin
146 // CHECK-NEXT:  [[#PFS+10]]: step
147 // CHECK-NEXT:  [[#PFS+11]]: [B1.[[#PFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
148 // CHECK-NEXT:  [[#PFS+12]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd) linear(lin: step)
149 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
150 // CHECK-NEXT:        [B1.[[#PFS+3]]];
151 #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd) linear(lin: step)
152   for (int i = 0; i < 10; ++i)
153     argc = x;
154 // CHECK-NEXT:  [[#PAR:]]: x
155 // CHECK-NEXT:  [[#PAR+1]]: [B1.[[#PAR]]] (ImplicitCastExpr, LValueToRValue, int)
156 // CHECK-NEXT:  [[#PAR+2]]: argc
157 // CHECK-NEXT:  [[#PAR+3]]: [B1.[[#PAR+2]]] = [B1.[[#PAR+1]]]
158 // CHECK-NEXT:  [[#PAR+4]]: cond
159 // CHECK-NEXT:  [[#PAR+5]]: [B1.[[#PAR+4]]] (ImplicitCastExpr, LValueToRValue, int)
160 // CHECK-NEXT:  [[#PAR+6]]: [B1.[[#PAR+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
161 // CHECK-NEXT:  [[#PAR+7]]: fp
162 // CHECK-NEXT:  [[#PAR+8]]: rd
163 // CHECK-NEXT:  [[#PAR+9]]: #pragma omp parallel if(cond) firstprivate(fp) reduction(min: rd)
164 // CHECK-NEXT:    [B1.[[#PAR+3]]];
165 #pragma omp parallel if(cond) firstprivate(fp) reduction(min:rd)
166   argc = x;
167 // CHECK-NEXT:  [[#PSECT:]]: x
168 // CHECK-NEXT:  [[#PSECT+1]]: [B1.[[#PSECT]]] (ImplicitCastExpr, LValueToRValue, int)
169 // CHECK-NEXT:  [[#PSECT+2]]: argc
170 // CHECK-NEXT:  [[#PSECT+3]]: [B1.[[#PSECT+2]]] = [B1.[[#PSECT+1]]]
171 // CHECK-NEXT:  [[#PSECT+4]]: cond
172 // CHECK-NEXT:  [[#PSECT+5]]: [B1.[[#PSECT+4]]] (ImplicitCastExpr, LValueToRValue, int)
173 // CHECK-NEXT:  [[#PSECT+6]]: [B1.[[#PSECT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
174 // CHECK-NEXT:  [[#PSECT+7]]: fp
175 // CHECK-NEXT:  [[#PSECT+8]]: rd
176 // CHECK-NEXT:  [[#PSECT+9]]: #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&: rd)
177 // CHECK-NEXT:    {
178 // CHECK-NEXT:        [B1.[[#PSECT+3]]];
179 // CHECK-NEXT:    }
180 #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&:rd)
181   {
182     argc = x;
183   }
184 // CHECK-NEXT:  [[#SIMD:]]: x
185 // CHECK-NEXT:  [[#SIMD+1]]: [B1.[[#SIMD]]] (ImplicitCastExpr, LValueToRValue, int)
186 // CHECK-NEXT:  [[#SIMD+2]]: argc
187 // CHECK-NEXT:  [[#SIMD+3]]: [B1.[[#SIMD+2]]] = [B1.[[#SIMD+1]]]
188 // CHECK-NEXT:  [[#SIMD+4]]: lin
189 // CHECK-NEXT:  [[#SIMD+5]]: step
190 // CHECK-NEXT:  [[#SIMD+6]]: [B1.[[#SIMD+5]]] (ImplicitCastExpr, LValueToRValue, int)
191 // CHECK-NEXT:  [[#SIMD+7]]: #pragma omp simd linear(lin: step)
192 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
193 // CHECK-NEXT:        [B1.[[#SIMD+3]]];
194 #pragma omp simd linear(lin: step)
195   for (int i = 0; i < 10; ++i)
196     argc = x;
197 // CHECK-NEXT:  [[#SINGLE:]]: x
198 // CHECK-NEXT:  [[#SINGLE+1]]: [B1.[[#SINGLE]]] (ImplicitCastExpr, LValueToRValue, int)
199 // CHECK-NEXT:  [[#SINGLE+2]]: argc
200 // CHECK-NEXT:  [[#SINGLE+3]]: [B1.[[#SINGLE+2]]] = [B1.[[#SINGLE+1]]]
201 // CHECK-NEXT:  [[#SINGLE+4]]: #pragma omp single
202 // CHECK-NEXT:    [B1.[[#SINGLE+3]]];
203 #pragma omp single
204   argc = x;
205 // CHECK-NEXT:  [[#TARGET:]]:
206 // CHECK-SAME:  [B1.[[#TARGET+10]]]
207 // CHECK-NEXT:  [[#TARGET+1]]: [B1.[[#TARGET+10]]] (ImplicitCastExpr, LValueToRValue, int)
208 // CHECK-NEXT:  [[#TARGET+2]]: [B1.[[#TARGET+9]]]
209 // CHECK-NEXT:  [[#TARGET+3]]: [B1.[[#TARGET+9]]] = [B1.[[#TARGET+1]]]
210 // CHECK-NEXT:  [[#TARGET+4]]: cond
211 // CHECK-NEXT:  [[#TARGET+5]]: [B1.[[#TARGET+4]]] (ImplicitCastExpr, LValueToRValue, int)
212 // CHECK-NEXT:  [[#TARGET+6]]: [B1.[[#TARGET+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
213 // CHECK-NEXT:  [[#TARGET+7]]: fp
214 // CHECK-NEXT:  [[#TARGET+8]]: rd
215 // CHECK-NEXT:  [[#TARGET+9]]: argc
216 // CHECK-NEXT:  [[#TARGET+10]]: x
217 // CHECK-NEXT:  [[#TARGET+11]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp) reduction(-: rd)
218 // CHECK-NEXT:    [B1.[[#TARGET+3]]];
219 #pragma omp target depend(in \
220                           : argc) if(cond) firstprivate(fp) reduction(-:rd)
221   argc = x;
222 // CHECK-NEXT:  [[#TPF:]]:
223 // CHECK-SAME:  [B1.[[#TPF+14]]]
224 // CHECK-NEXT:  [[#TPF+1]]: [B1.[[#TPF+14]]] (ImplicitCastExpr, LValueToRValue, int)
225 // CHECK-NEXT:  [[#TPF+2]]: [B1.[[#TPF+13]]]
226 // CHECK-NEXT:  [[#TPF+3]]: [B1.[[#TPF+13]]] = [B1.[[#TPF+1]]]
227 // CHECK-NEXT:  [[#TPF+4]]: cond
228 // CHECK-NEXT:  [[#TPF+5]]: [B1.[[#TPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
229 // CHECK-NEXT:  [[#TPF+6]]: [B1.[[#TPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
230 // CHECK-NEXT:  [[#TPF+7]]: fp
231 // CHECK-NEXT:  [[#TPF+8]]: rd
232 // CHECK-NEXT:  [[#TPF+9]]: lin
233 // CHECK-NEXT:  [[#TPF+10]]: step
234 // CHECK-NEXT:  [[#TPF+11]]: [B1.[[#TPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
235 // CHECK-NEXT:  [[#TPF+12]]: map
236 // CHECK-NEXT:  [[#TPF+13]]: argc
237 // CHECK-NEXT:  [[#TPF+14]]: x
238 // CHECK-NEXT:  [[#TPF+15]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step) map(tofrom: map)
239 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
240 // CHECK-NEXT:        [B1.[[#TPF+3]]];
241 #pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step) map(map)
242   for (int i = 0; i < 10; ++i)
243     argc = x;
244 // CHECK-NEXT:  [[#TPFS:]]:
245 // CHECK-SAME:  [B1.[[#TPFS+14]]]
246 // CHECK-NEXT:  [[#TPFS+1]]: [B1.[[#TPFS+14]]] (ImplicitCastExpr, LValueToRValue, int)
247 // CHECK-NEXT:  [[#TPFS+2]]: [B1.[[#TPFS+13]]]
248 // CHECK-NEXT:  [[#TPFS+3]]: [B1.[[#TPFS+13]]] = [B1.[[#TPFS+1]]]
249 // CHECK-NEXT:  [[#TPFS+4]]: cond
250 // CHECK-NEXT:  [[#TPFS+5]]: [B1.[[#TPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
251 // CHECK-NEXT:  [[#TPFS+6]]: [B1.[[#TPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
252 // CHECK-NEXT:  [[#TPFS+7]]: fp
253 // CHECK-NEXT:  [[#TPFS+8]]: rd
254 // CHECK-NEXT:  [[#TPFS+9]]: lin
255 // CHECK-NEXT:  [[#TPFS+10]]: step
256 // CHECK-NEXT:  [[#TPFS+11]]: [B1.[[#TPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
257 // CHECK-NEXT:  [[#TPFS+12]]: map
258 // CHECK-NEXT:  [[#TPFS+13]]: argc
259 // CHECK-NEXT:  [[#TPFS+14]]: x
260 // CHECK-NEXT:  [[#TPFS+15]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step) map(tofrom: map)
261 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
262 // CHECK-NEXT:        [B1.[[#TPFS+3]]];
263 #pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step) map(tofrom:map)
264   for (int i = 0; i < 10; ++i)
265     argc = x;
266 // CHECK-NEXT:  [[#TP:]]:
267 // CHECK-SAME:  [B1.[[#TP+11]]]
268 // CHECK-NEXT:  [[#TP+1]]: [B1.[[#TP+11]]] (ImplicitCastExpr, LValueToRValue, int)
269 // CHECK-NEXT:  [[#TP+2]]: [B1.[[#TP+10]]]
270 // CHECK-NEXT:  [[#TP+3]]: [B1.[[#TP+10]]] = [B1.[[#TP+1]]]
271 // CHECK-NEXT:  [[#TP+4]]: cond
272 // CHECK-NEXT:  [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int)
273 // CHECK-NEXT:  [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
274 // CHECK-NEXT:  [[#TP+7]]: fp
275 // CHECK-NEXT:  [[#TP+8]]: rd
276 // CHECK-NEXT:  [[#TP+9]]: map
277 // CHECK-NEXT:  [[#TP+10]]: argc
278 // CHECK-NEXT:  [[#TP+11]]: x
279 // CHECK-NEXT:  [[#TP+12]]: #pragma omp target parallel if(cond) firstprivate(fp) reduction(+: rd) map(to: map)
280 // CHECK-NEXT:    [B1.[[#TP+3]]];
281 #pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd) map(to:map)
282   argc = x;
283 // CHECK-NEXT:  [[#TSIMD:]]:
284 // CHECK-SAME:  [B1.[[#TSIMD+13]]]
285 // CHECK-NEXT:  [[#TSIMD+1]]: [B1.[[#TSIMD+13]]] (ImplicitCastExpr, LValueToRValue, int)
286 // CHECK-NEXT:  [[#TSIMD+2]]: [B1.[[#TSIMD+12]]]
287 // CHECK-NEXT:  [[#TSIMD+3]]: [B1.[[#TSIMD+12]]] = [B1.[[#TSIMD+1]]]
288 // CHECK-NEXT:  [[#TSIMD+4]]: cond
289 // CHECK-NEXT:  [[#TSIMD+5]]: [B1.[[#TSIMD+4]]] (ImplicitCastExpr, LValueToRValue, int)
290 // CHECK-NEXT:  [[#TSIMD+6]]: [B1.[[#TSIMD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
291 // CHECK-NEXT:  [[#TSIMD+7]]: fp
292 // CHECK-NEXT:  [[#TSIMD+8]]: rd
293 // CHECK-NEXT:  [[#TSIMD+9]]: lin
294 // CHECK-NEXT:  [[#TSIMD+10]]: step
295 // CHECK-NEXT:  [[#TSIMD+11]]: [B1.[[#TSIMD+10]]] (ImplicitCastExpr, LValueToRValue, int)
296 // CHECK-NEXT:  [[#TSIMD+12]]: argc
297 // CHECK-NEXT:  [[#TSIMD+13]]: x
298 // CHECK-NEXT:  [[#TSIMD+14]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step) map(alloc: map)
299 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
300 // CHECK-NEXT:        [B1.[[#TSIMD+3]]];
301 #pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step) map(alloc:map)
302   for (int i = 0; i < 10; ++i)
303     argc = x;
304 // CHECK-NEXT:  [[#TTD:]]:
305 // CHECK-SAME:  [B1.[[#TTD+10]]]
306 // CHECK-NEXT:  [[#TTD+1]]: [B1.[[#TTD+10]]] (ImplicitCastExpr, LValueToRValue, int)
307 // CHECK-NEXT:  [[#TTD+2]]: [B1.[[#TTD+9]]]
308 // CHECK-NEXT:  [[#TTD+3]]: [B1.[[#TTD+9]]] = [B1.[[#TTD+1]]]
309 // CHECK-NEXT:  [[#TTD+4]]: cond
310 // CHECK-NEXT:  [[#TTD+5]]: [B1.[[#TTD+4]]] (ImplicitCastExpr, LValueToRValue, int)
311 // CHECK-NEXT:  [[#TTD+6]]: [B1.[[#TTD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
312 // CHECK-NEXT:  [[#TTD+7]]: fp
313 // CHECK-NEXT:  [[#TTD+8]]: rd
314 // CHECK-NEXT:  [[#TTD+9]]: argc
315 // CHECK-NEXT:  [[#TTD+10]]: x
316 // CHECK-NEXT:  [[#TTD+11]]: #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+: rd) map(release: map)
317 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
318 // CHECK-NEXT:        [B1.[[#TTD+3]]];
319 #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+:rd) map(release:map)
320   for (int i = 0; i < 10; ++i)
321     argc = x;
322 // CHECK-NEXT:  [[#TTDPF:]]:
323 // CHECK-SAME:  [B1.[[#TTDPF+10]]]
324 // CHECK-NEXT:  [[#TTDPF+1]]: [B1.[[#TTDPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
325 // CHECK-NEXT:  [[#TTDPF+2]]: [B1.[[#TTDPF+9]]]
326 // CHECK-NEXT:  [[#TTDPF+3]]: [B1.[[#TTDPF+9]]] = [B1.[[#TTDPF+1]]]
327 // CHECK-NEXT:  [[#TTDPF+4]]: cond
328 // CHECK-NEXT:  [[#TTDPF+5]]: [B1.[[#TTDPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
329 // CHECK-NEXT:  [[#TTDPF+6]]: [B1.[[#TTDPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
330 // CHECK-NEXT:  [[#TTDPF+7]]: fp
331 // CHECK-NEXT:  [[#TTDPF+8]]: rd
332 // CHECK-NEXT:  [[#TTDPF+9]]: argc
333 // CHECK-NEXT:  [[#TTDPF+10]]: x
334 // CHECK-NEXT:  [[#TTDPF+11]]: #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd) map(delete: map)
335 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
336 // CHECK-NEXT:        [B1.[[#TTDPF+3]]];
337 #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd) map(delete:map)
338   for (int i = 0; i < 10; ++i)
339     argc = x;
340 // CHECK-NEXT:  [[#TTDPFS:]]:
341 // CHECK-SAME:  [B1.[[#TTDPFS+10]]]
342 // CHECK-NEXT:  [[#TTDPFS+1]]: [B1.[[#TTDPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
343 // CHECK-NEXT:  [[#TTDPFS+2]]: [B1.[[#TTDPFS+9]]]
344 // CHECK-NEXT:  [[#TTDPFS+3]]: [B1.[[#TTDPFS+9]]] = [B1.[[#TTDPFS+1]]]
345 // CHECK-NEXT:  [[#TTDPFS+4]]: cond
346 // CHECK-NEXT:  [[#TTDPFS+5]]: [B1.[[#TTDPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
347 // CHECK-NEXT:  [[#TTDPFS+6]]: [B1.[[#TTDPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
348 // CHECK-NEXT:  [[#TTDPFS+7]]: fp
349 // CHECK-NEXT:  [[#TTDPFS+8]]: rd
350 // CHECK-NEXT:  [[#TTDPFS+9]]: argc
351 // CHECK-NEXT:  [[#TTDPFS+10]]: x
352 // CHECK-NEXT:  [[#TTDPFS+11]]: #pragma omp target teams distribute parallel for simd if(parallel: cond) firstprivate(fp) reduction(+: rd) map(from: map)
353 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
354 // CHECK-NEXT:        [B1.[[#TTDPFS+3]]];
355 #pragma omp target teams distribute parallel for simd if(parallel:cond) firstprivate(fp) reduction(+:rd) map(from:map)
356   for (int i = 0; i < 10; ++i)
357     argc = x;
358 // CHECK-NEXT:  [[#TTDS:]]:
359 // CHECK-SAME:  [B1.[[#TTDS+11]]]
360 // CHECK-NEXT:  [[#TTDS+1]]: [B1.[[#TTDS+11]]] (ImplicitCastExpr, LValueToRValue, int)
361 // CHECK-NEXT:  [[#TTDS+2]]: [B1.[[#TTDS+10]]]
362 // CHECK-NEXT:  [[#TTDS+3]]: [B1.[[#TTDS+10]]] = [B1.[[#TTDS+1]]]
363 // CHECK-NEXT:  [[#TTDS+4]]: cond
364 // CHECK-NEXT:  [[#TTDS+5]]: [B1.[[#TTDS+4]]] (ImplicitCastExpr, LValueToRValue, int)
365 // CHECK-NEXT:  [[#TTDS+6]]: [B1.[[#TTDS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
366 // CHECK-NEXT:  [[#TTDS+7]]: fp
367 // CHECK-NEXT:  [[#TTDS+8]]: rd
368 // CHECK-NEXT:  [[#TTDS+9]]: map
369 // CHECK-NEXT:  [[#TTDS+10]]: argc
370 // CHECK-NEXT:  [[#TTDS+11]]: x
371 // CHECK-NEXT:  [[#TTDS+12]]: #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
372 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
373 // CHECK-NEXT:        [B1.[[#TTDS+3]]];
374 #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+:rd) map(map)
375   for (int i = 0; i < 10; ++i)
376     argc = x;
377 // CHECK-NEXT:  [[#TT:]]:
378 // CHECK-SAME:  [B1.[[#TT+11]]]
379 // CHECK-NEXT:  [[#TT+1]]: [B1.[[#TT+11]]] (ImplicitCastExpr, LValueToRValue, int)
380 // CHECK-NEXT:  [[#TT+2]]: [B1.[[#TT+10]]]
381 // CHECK-NEXT:  [[#TT+3]]: [B1.[[#TT+10]]] = [B1.[[#TT+1]]]
382 // CHECK-NEXT:  [[#TT+4]]: cond
383 // CHECK-NEXT:  [[#TT+5]]: [B1.[[#TT+4]]] (ImplicitCastExpr, LValueToRValue, int)
384 // CHECK-NEXT:  [[#TT+6]]: [B1.[[#TT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
385 // CHECK-NEXT:  [[#TT+7]]: fp
386 // CHECK-NEXT:  [[#TT+8]]: rd
387 // CHECK-NEXT:  [[#TT+9]]: map
388 // CHECK-NEXT:  [[#TT+10]]: argc
389 // CHECK-NEXT:  [[#TT+11]]: x
390 // CHECK-NEXT:  [[#TT+12]]: #pragma omp target teams if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
391 // CHECK-NEXT:    [B1.[[#TT+3]]];
392 #pragma omp target teams if(cond) firstprivate(fp) reduction(+:rd) map(tofrom:map)
393   argc = x;
394 // CHECK-NEXT: [[#TU:]]: cond
395 // CHECK-NEXT: [[#TU+1]]: [B1.[[#TU]]] (ImplicitCastExpr, LValueToRValue, int)
396 // CHECK-NEXT: [[#TU+2]]: [B1.[[#TU+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
397 // CHECK-NEXT: [[#TU+3]]: #pragma omp target update to(x) if(target update: cond)
398 #pragma omp target update to(x) if(target update:cond)
399 // CHECK-NEXT:  [[#TASK:]]:
400 // CHECK-SAME:  [B1.[[#TASK+9]]]
401 // CHECK-NEXT:  [[#TASK+1]]: [B1.[[#TASK+9]]] (ImplicitCastExpr, LValueToRValue, int)
402 // CHECK-NEXT:  [[#TASK+2]]: [B1.[[#TASK+8]]]
403 // CHECK-NEXT:  [[#TASK+3]]: [B1.[[#TASK+8]]] = [B1.[[#TASK+1]]]
404 // CHECK-NEXT:  [[#TASK+4]]: cond
405 // CHECK-NEXT:  [[#TASK+5]]: [B1.[[#TASK+4]]] (ImplicitCastExpr, LValueToRValue, int)
406 // CHECK-NEXT:  [[#TASK+6]]: [B1.[[#TASK+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
407 // CHECK-NEXT:  [[#TASK+7]]: fp
408 // CHECK-NEXT:  [[#TASK+8]]: argc
409 // CHECK-NEXT:  [[#TASK+9]]: x
410 // CHECK-NEXT:  [[#TASK+10]]: #pragma omp task if(cond) firstprivate(fp)
411 // CHECK-NEXT:    [B1.[[#TASK+3]]];
412 #pragma omp task if(cond) firstprivate(fp)
413   argc = x;
414 // CHECK-NEXT:  [[#TG:]]: x
415 // CHECK-NEXT:  [[#TG+1]]: [B1.[[#TG]]] (ImplicitCastExpr, LValueToRValue, int)
416 // CHECK-NEXT:  [[#TG+2]]: argc
417 // CHECK-NEXT:  [[#TG+3]]: [B1.[[#TG+2]]] = [B1.[[#TG+1]]]
418 // CHECK-NEXT:  [[#TG+4]]: #pragma omp taskgroup
419 // CHECK-NEXT:    [B1.[[#TG+3]]];
420 #pragma omp taskgroup
421   argc = x;
422 // CHECK-NEXT:  [[#TL:]]:
423 // CHECK-SAME:  [B1.[[#TL+10]]]
424 // CHECK-NEXT:  [[#TL+1]]: [B1.[[#TL+10]]] (ImplicitCastExpr, LValueToRValue, int)
425 // CHECK-NEXT:  [[#TL+2]]: [B1.[[#TL+9]]]
426 // CHECK-NEXT:  [[#TL+3]]: [B1.[[#TL+9]]] = [B1.[[#TL+1]]]
427 // CHECK-NEXT:  [[#TL+4]]: cond
428 // CHECK-NEXT:  [[#TL+5]]: [B1.[[#TL+4]]] (ImplicitCastExpr, LValueToRValue, int)
429 // CHECK-NEXT:  [[#TL+6]]: [B1.[[#TL+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
430 // CHECK-NEXT:  [[#TL+7]]: fp
431 // CHECK-NEXT:  [[#TL+8]]: rd
432 // CHECK-NEXT:  [[#TL+9]]: argc
433 // CHECK-NEXT:  [[#TL+10]]: x
434 // CHECK-NEXT:  [[#TL+11]]: #pragma omp taskloop if(cond) firstprivate(fp) reduction(+: rd)
435 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
436 // CHECK-NEXT:        [B1.[[#TL+3]]];
437 #pragma omp taskloop if(cond) firstprivate(fp) reduction(+:rd)
438   for (int i = 0; i < 10; ++i)
439     argc = x;
440 // CHECK-NEXT:  [[#TLS:]]:
441 // CHECK-SAME:  [B1.[[#TLS+13]]]
442 // CHECK-NEXT:  [[#TLS+1]]: [B1.[[#TLS+13]]] (ImplicitCastExpr, LValueToRValue, int)
443 // CHECK-NEXT:  [[#TLS+2]]: [B1.[[#TLS+12]]]
444 // CHECK-NEXT:  [[#TLS+3]]: [B1.[[#TLS+12]]] = [B1.[[#TLS+1]]]
445 // CHECK-NEXT:  [[#TLS+4]]: cond
446 // CHECK-NEXT:  [[#TLS+5]]: [B1.[[#TLS+4]]] (ImplicitCastExpr, LValueToRValue, int)
447 // CHECK-NEXT:  [[#TLS+6]]: [B1.[[#TLS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
448 // CHECK-NEXT:  [[#TLS+7]]: fp
449 // CHECK-NEXT:  [[#TLS+8]]: rd
450 // CHECK-NEXT:  [[#TLS+9]]: lin
451 // CHECK-NEXT:  [[#TLS+10]]: step
452 // CHECK-NEXT:  [[#TLS+11]]: [B1.[[#TLS+10]]] (ImplicitCastExpr, LValueToRValue, int)
453 // CHECK-NEXT:  [[#TLS+12]]: argc
454 // CHECK-NEXT:  [[#TLS+13]]: x
455 // CHECK-NEXT:  [[#TLS+14]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
456 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
457 // CHECK-NEXT:        [B1.[[#TLS+3]]];
458 #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
459   for (int i = 0; i < 10; ++i)
460     argc = x;
461 // CHECK-NEXT:  [[#TDPF:]]: x
462 // CHECK-NEXT:  [[#TDPF+1]]: [B1.[[#TDPF]]] (ImplicitCastExpr, LValueToRValue, int)
463 // CHECK-NEXT:  [[#TDPF+2]]: argc
464 // CHECK-NEXT:  [[#TDPF+3]]: [B1.[[#TDPF+2]]] = [B1.[[#TDPF+1]]]
465 // CHECK-NEXT:  [[#TDPF+4]]: cond
466 // CHECK-NEXT:  [[#TDPF+5]]: [B1.[[#TDPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
467 // CHECK-NEXT:  [[#TDPF+6]]: [B1.[[#TDPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
468 // CHECK-NEXT:  [[#TDPF+7]]: [B1.[[#TDPF+10]]]
469 // CHECK-NEXT:  [[#TDPF+8]]: [B1.[[#TDPF+11]]]
470 // CHECK-NEXT:  [[#TDPF+9]]: #pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd)
471 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
472 // CHECK-NEXT:        [B1.[[#TDPF+3]]];
473 // CHECK-NEXT:  [[#TDPF+10]]: fp
474 // CHECK-NEXT:  [[#TDPF+11]]: rd
475 // CHECK-NEXT:  [[#TDPF+12]]: argc
476 // CHECK-NEXT:  [[#TDPF+13]]: x
477 // CHECK-NEXT:  [[#TDPF+14]]: cond
478 // CHECK-NEXT:  [[#TDPF+15]]: #pragma omp target
479 #pragma omp target
480 #pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd)
481   for (int i = 0; i < 10; ++i)
482     argc = x;
483 // CHECK-NEXT:  [B1.[[#TDPF+9]]] [[#TDPFS:]]: x
484 // CHECK-NEXT:  [[#TDPFS+1]]: [B1.[[#TDPFS]]] (ImplicitCastExpr, LValueToRValue, int)
485 // CHECK-NEXT:  [[#TDPFS+2]]: argc
486 // CHECK-NEXT:  [[#TDPFS+3]]: [B1.[[#TDPFS+2]]] = [B1.[[#TDPFS+1]]]
487 // CHECK-NEXT:  [[#TDPFS+4]]: cond
488 // CHECK-NEXT:  [[#TDPFS+5]]: [B1.[[#TDPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
489 // CHECK-NEXT:  [[#TDPFS+6]]: [B1.[[#TDPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
490 // CHECK-NEXT:  [[#TDPFS+7]]: [B1.[[#TDPFS+10]]]
491 // CHECK-NEXT:  [[#TDPFS+8]]: [B1.[[#TDPFS+11]]]
492 // CHECK-NEXT:  [[#TDPFS+9]]: #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+: rd)
493 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
494 // CHECK-NEXT:        [B1.[[#TDPFS+3]]];
495 // CHECK-NEXT:  [[#TDPFS+10]]: fp
496 // CHECK-NEXT:  [[#TDPFS+11]]: rd
497 // CHECK-NEXT:  [[#TDPFS+12]]: argc
498 // CHECK-NEXT:  [[#TDPFS+13]]: x
499 // CHECK-NEXT:  [[#TDPFS+14]]: cond
500 // CHECK-NEXT:  [[#TDPFS+15]]: #pragma omp target
501 #pragma omp target
502 #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+:rd)
503   for (int i = 0; i < 10; ++i)
504     argc = x;
505 // CHECK-NEXT:  [B1.[[#TDPFS+9]]] [[#TDS:]]: x
506 // CHECK-NEXT:  [[#TDS+1]]: [B1.[[#TDS]]] (ImplicitCastExpr, LValueToRValue, int)
507 // CHECK-NEXT:  [[#TDS+2]]: argc
508 // CHECK-NEXT:  [[#TDS+3]]: [B1.[[#TDS+2]]] = [B1.[[#TDS+1]]]
509 // CHECK-NEXT:  [[#TDS+4]]: [B1.[[#TDS+7]]]
510 // CHECK-NEXT:  [[#TDS+5]]: [B1.[[#TDS+8]]]
511 // CHECK-NEXT:  [[#TDS+6]]: #pragma omp teams distribute simd firstprivate(fp) reduction(+: rd)
512 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
513 // CHECK-NEXT:        [B1.[[#TDS+3]]];
514 // CHECK-NEXT:  [[#TDS+7]]: fp
515 // CHECK-NEXT:  [[#TDS+8]]: rd
516 // CHECK-NEXT:  [[#TDS+9]]: argc
517 // CHECK-NEXT:  [[#TDS+10]]: x
518 // CHECK-NEXT:  [[#TDS+11]]: #pragma omp target
519 #pragma omp target
520 #pragma omp teams distribute simd firstprivate(fp) reduction(+:rd)
521   for (int i = 0; i < 10; ++i)
522     argc = x;
523 // CHECK-NEXT:  [B1.[[#TDS+6]]] [[#TEAMS:]]: x
524 // CHECK-NEXT:  [[#TEAMS+1]]: [B1.[[#TEAMS]]] (ImplicitCastExpr, LValueToRValue, int)
525 // CHECK-NEXT:  [[#TEAMS+2]]: argc
526 // CHECK-NEXT:  [[#TEAMS+3]]: [B1.[[#TEAMS+2]]] = [B1.[[#TEAMS+1]]]
527 // CHECK-NEXT:  [[#TEAMS+4]]: [B1.[[#TEAMS+7]]]
528 // CHECK-NEXT:  [[#TEAMS+5]]: [B1.[[#TEAMS+8]]]
529 // CHECK-NEXT:  [[#TEAMS+6]]: #pragma omp teams firstprivate(fp) reduction(+: rd)
530 // CHECK-NEXT:    [B1.[[#TEAMS+3]]];
531 // CHECK-NEXT:  [[#TEAMS+7]]: fp
532 // CHECK-NEXT:  [[#TEAMS+8]]: rd
533 // CHECK-NEXT:  [[#TEAMS+9]]: argc
534 // CHECK-NEXT:  [[#TEAMS+10]]: x
535 // CHECK-NEXT:  [[#TEAMS+11]]: #pragma omp target
536 #pragma omp target
537 #pragma omp teams firstprivate(fp) reduction(+:rd)
538   argc = x;
539 // CHECK-NEXT:  [B1.[[#TEAMS+6]]]   Preds
540 }
541 
542