1 // RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s
2
3 // RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp | FileCheck %s --check-prefix=OMP51
4
5 #if _OPENMP == 202011
6
7 // OMP51-LABEL: void target_has_device_addr(int argc)
target_has_device_addr(int argc)8 void target_has_device_addr(int argc) {
9 // OMP51: [B1]
10 // OMP51-NEXT: [[#TTD:]]: 5
11 // OMP51-NEXT: [[#TTD+1]]: int x = 5;
12 // OMP51-NEXT: [[#TTD+2]]: x
13 // OMP51-NEXT: [[#TTD+3]]: [B1.[[#TTD+2]]] (ImplicitCastExpr, LValueToRValue, int)
14 // OMP51-NEXT: [[#TTD+4]]: [B1.[[#TTD+6]]]
15 // OMP51-NEXT: [[#TTD+5]]: [B1.[[#TTD+6]]] = [B1.[[#TTD+3]]]
16 // OMP51-NEXT: [[#TTD+6]]: argc
17 // OMP51-NEXT: [[#TTD+7]]: #pragma omp target has_device_addr(x)
18 // OMP51-NEXT: [B1.[[#TTD+5]]]
19 int x = 5;
20 #pragma omp target has_device_addr(x)
21 argc = x;
22 }
23 // OMP51-LABEL: void target_s_has_device_addr(int argc)
target_s_has_device_addr(int argc)24 void target_s_has_device_addr(int argc) {
25 int x, cond, fp, rd, lin, step_sz, map;
26 // OMP51-DAG: [B3]
27 // OMP51-DAG: [[#TSB:]]: x
28 // OMP51-DAG: [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)
29 // OMP51-DAG: [[#TSB+2]]: argc
30 // OMP51-DAG: [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]
31 // OMP51-DAG: [B1]
32 // OMP51-DAG: [[#TS:]]: cond
33 // OMP51-DAG: [[#TS+1]]: [B1.[[#TS]]] (ImplicitCastExpr, LValueToRValue, int)
34 // OMP51-DAG: [[#TS+2]]: [B1.[[#TS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
35 // OMP51-DAG: [[#TS+3]]: fp
36 // OMP51-DAG: [[#TS+4]]: rd
37 // OMP51-DAG: [[#TS+5]]: lin
38 // OMP51-DAG: [[#TS+6]]: step_sz
39 // OMP51-DAG: [[#TS+7]]: [B1.[[#TS+6]]] (ImplicitCastExpr, LValueToRValue, int)
40 // OMP51-DAG: [[#TS+8]]: [B3.[[#TSB+2]]]
41 // OMP51-DAG: [[#TS+9]]: [B3.[[#TSB]]]
42 // OMP51-DAG: [[#TS+10]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step(step_sz)) has_device_addr(map)
43 // OMP51-DAG: for (int i = 0;
44 // OMP51-DAG: [B3.[[#TSB+3]]];
45 #pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step_sz) has_device_addr(map)
46 for (int i = 0; i < 10; ++i)
47 argc = x;
48 }
49 // OMP51-LABEL: void target_t_l_has_device_addr(int argc)
target_t_l_has_device_addr(int argc)50 void target_t_l_has_device_addr(int argc) {
51 int x, cond, fp, rd, map;
52 // OMP51-DAG: [B3]
53 // OMP51-DAG: [[#TTDB:]]: x
54 // OMP51-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
55 // OMP51-DAG: [[#TTDB+2]]: argc
56 // OMP51-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
57 // OMP51-DAG: [B1]
58 // OMP51-DAG: [[#TTD:]]: cond
59 // OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
60 // OMP51-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
61 // OMP51-DAG: [[#TTD+3]]: fp
62 // OMP51-DAG: [[#TTD+4]]: rd
63 // OMP51-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
64 // OMP51-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
65 // OMP51-DAG: [[#TTD+7]]: #pragma omp target teams loop if(cond) firstprivate(fp) reduction(+: rd) has_device_addr(map)
66 // OMP51-DAG: for (int i = 0;
67 // OMP51-DAG: [B3.[[#TTDB+3]]];
68 #pragma omp target teams loop if(cond) firstprivate(fp) reduction(+:rd) has_device_addr(map)
69 for (int i = 0; i <10; ++i)
70 argc = x;
71 }
72 // OMP51-LABEL: void target_p_l_has_device_addr(int argc)
target_p_l_has_device_addr(int argc)73 void target_p_l_has_device_addr(int argc) {
74 int x, cond, fp, rd, map;
75 #pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+:rd) has_device_addr(map)
76 // OMP51-DAG: [B3]
77 // OMP51-DAG: [[#TTDB:]]: x
78 // OMP51-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
79 // OMP51-DAG: [[#TTDB+2]]: argc
80 // OMP51-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
81 // OMP51-DAG: [B1]
82 // OMP51-DAG: [[#TTD:]]: cond
83 // OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
84 // OMP51-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
85 // OMP51-DAG: [[#TTD+3]]: fp
86 // OMP51-DAG: [[#TTD+4]]: rd
87 // OMP51-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
88 // OMP51-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
89 // OMP51-DAG: [[#TTD+7]]: #pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+: rd) has_device_addr(map)
90 // OMP51-DAG: for (int i = 0;
91 // OMP51-DAG: [B3.[[#TTDB+3]]];
92 for (int i = 0; i < 10; ++i)
93 argc = x;
94 }
95 struct SomeKernel {
96 int targetDev;
97 float devPtr;
98 SomeKernel();
99 ~SomeKernel();
100 // OMP51-LABEL: template<> void apply<32U>()
101 template<unsigned int nRHS>
applySomeKernel102 void apply() {
103 // OMP51-DAG: [B1]
104 // OMP51-DAG: [[#TTD:]]: 10
105 // OMP51-DAG: [[#TTD+1]]: [B1.[[#TTD:]]] (ImplicitCastExpr, IntegralToFloating, float)
106 // OMP51-DAG: [[#TTD+2]]: this
107 // OMP51-DAG: [[#TTD+3]]: [B1.[[#TTD+2]]]->devPtr
108 // OMP51-DAG: [[#TTD+4]]: [B1.[[#TTD+3]]] = [B1.[[#TTD+1]]]
109 // OMP51-DAG: [[#TTD+5]]: #pragma omp target has_device_addr(this->devPtr) device(this->targetDev)
110 // OMP51-DAG: {
111 // OMP51-DAG: [B1.[[#TTD+4]]];
112 #pragma omp target has_device_addr(devPtr) device(targetDev)
113 {
114 devPtr = 10;
115 }
116 }
117 };
use_template()118 void use_template() {
119 SomeKernel aKern;
120 aKern.apply<32>();
121 }
122 #else // _OPENMP
123
124 // CHECK-LABEL: void xxx(int argc)
xxx(int argc)125 void xxx(int argc) {
126 // CHECK: [B1]
127 // CHECK-NEXT: 1: int x;
128 // CHECK-NEXT: 2: int cond;
129 // CHECK-NEXT: 3: int fp;
130 // CHECK-NEXT: 4: int rd;
131 // CHECK-NEXT: 5: int lin;
132 // CHECK-NEXT: 6: int step_sz;
133 // CHECK-NEXT: 7: int map;
134 int x, cond, fp, rd, lin, step_sz, map;
135 // CHECK-NEXT: [[#ATOM:]]: x
136 // CHECK-NEXT: [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
137 // CHECK-NEXT: [[#ATOM+2]]: argc
138 // CHECK-NEXT: [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]]
139 // CHECK-NEXT: [[#ATOM+4]]: #pragma omp atomic read
140 // CHECK-NEXT: [B1.[[#ATOM+3]]];
141 #pragma omp atomic read
142 argc = x;
143 // CHECK-NEXT: [[#CRIT:]]: x
144 // CHECK-NEXT: [[#CRIT+1]]: [B1.[[#CRIT]]] (ImplicitCastExpr, LValueToRValue, int)
145 // CHECK-NEXT: [[#CRIT+2]]: argc
146 // CHECK-NEXT: [[#CRIT+3]]: [B1.[[#CRIT+2]]] = [B1.[[#CRIT+1]]]
147 // CHECK-NEXT: [[#CRIT+4]]: #pragma omp critical
148 // CHECK-NEXT: [B1.[[#CRIT+3]]];
149 #pragma omp critical
150 argc = x;
151 // CHECK-NEXT: [[#MASTER:]]: x
152 // CHECK-NEXT: [[#MASTER+1]]: [B1.[[#MASTER]]] (ImplicitCastExpr, LValueToRValue, int)
153 // CHECK-NEXT: [[#MASTER+2]]: argc
154 // CHECK-NEXT: [[#MASTER+3]]: [B1.[[#MASTER+2]]] = [B1.[[#MASTER+1]]]
155 // CHECK-NEXT: [[#MASTER+4]]: #pragma omp master
156 // CHECK-NEXT: [B1.[[#MASTER+3]]];
157 #pragma omp master
158 argc = x;
159 // CHECK-NEXT: [[#PAR:]]: x
160 // CHECK-NEXT: [[#PAR+1]]: [B1.[[#PAR]]] (ImplicitCastExpr, LValueToRValue, int)
161 // CHECK-NEXT: [[#PAR+2]]: argc
162 // CHECK-NEXT: [[#PAR+3]]: [B1.[[#PAR+2]]] = [B1.[[#PAR+1]]]
163 // CHECK-NEXT: [[#PAR+4]]: cond
164 // CHECK-NEXT: [[#PAR+5]]: [B1.[[#PAR+4]]] (ImplicitCastExpr, LValueToRValue, int)
165 // CHECK-NEXT: [[#PAR+6]]: [B1.[[#PAR+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
166 // CHECK-NEXT: [[#PAR+7]]: fp
167 // CHECK-NEXT: [[#PAR+8]]: rd
168 // CHECK-NEXT: [[#PAR+9]]: #pragma omp parallel if(cond) firstprivate(fp) reduction(min: rd)
169 // CHECK-NEXT: [B1.[[#PAR+3]]];
170 #pragma omp parallel if(cond) firstprivate(fp) reduction(min:rd)
171 argc = x;
172 // CHECK-NEXT: [[#PSECT:]]: x
173 // CHECK-NEXT: [[#PSECT+1]]: [B1.[[#PSECT]]] (ImplicitCastExpr, LValueToRValue, int)
174 // CHECK-NEXT: [[#PSECT+2]]: argc
175 // CHECK-NEXT: [[#PSECT+3]]: [B1.[[#PSECT+2]]] = [B1.[[#PSECT+1]]]
176 // CHECK-NEXT: [[#PSECT+4]]: cond
177 // CHECK-NEXT: [[#PSECT+5]]: [B1.[[#PSECT+4]]] (ImplicitCastExpr, LValueToRValue, int)
178 // CHECK-NEXT: [[#PSECT+6]]: [B1.[[#PSECT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
179 // CHECK-NEXT: [[#PSECT+7]]: fp
180 // CHECK-NEXT: [[#PSECT+8]]: rd
181 // CHECK-NEXT: [[#PSECT+9]]: #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&: rd)
182 // CHECK-NEXT: {
183 // CHECK-NEXT: [B1.[[#PSECT+3]]];
184 // CHECK-NEXT: }
185 #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&:rd)
186 {
187 argc = x;
188 }
189 // CHECK-NEXT: [[#SINGLE:]]: x
190 // CHECK-NEXT: [[#SINGLE+1]]: [B1.[[#SINGLE]]] (ImplicitCastExpr, LValueToRValue, int)
191 // CHECK-NEXT: [[#SINGLE+2]]: argc
192 // CHECK-NEXT: [[#SINGLE+3]]: [B1.[[#SINGLE+2]]] = [B1.[[#SINGLE+1]]]
193 // CHECK-NEXT: [[#SINGLE+4]]: #pragma omp single
194 // CHECK-NEXT: [B1.[[#SINGLE+3]]];
195 #pragma omp single
196 argc = x;
197 // CHECK-NEXT: [[#TARGET:]]:
198 // CHECK-SAME: [B1.[[#TARGET+9]]]
199 // CHECK-NEXT: [[#TARGET+1]]: [B1.[[#TARGET+9]]] (ImplicitCastExpr, LValueToRValue, int)
200 // CHECK-NEXT: [[#TARGET+2]]: [B1.[[#TARGET+8]]]
201 // CHECK-NEXT: [[#TARGET+3]]: [B1.[[#TARGET+8]]] = [B1.[[#TARGET+1]]]
202 // CHECK-NEXT: [[#TARGET+4]]: cond
203 // CHECK-NEXT: [[#TARGET+5]]: [B1.[[#TARGET+4]]] (ImplicitCastExpr, LValueToRValue, int)
204 // CHECK-NEXT: [[#TARGET+6]]: [B1.[[#TARGET+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
205 // CHECK-NEXT: [[#TARGET+7]]: fp
206 // CHECK-NEXT: [[#TARGET+8]]: argc
207 // CHECK-NEXT: [[#TARGET+9]]: x
208 // CHECK-NEXT: [[#TARGET+10]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp)
209 // CHECK-NEXT: [B1.[[#TARGET+3]]];
210 #pragma omp target depend(in \
211 : argc) if(cond) firstprivate(fp)
212 argc = x;
213 // CHECK-NEXT: [[#TP:]]:
214 // CHECK-SAME: [B1.[[#TP+11]]]
215 // CHECK-NEXT: [[#TP+1]]: [B1.[[#TP+11]]] (ImplicitCastExpr, LValueToRValue, int)
216 // CHECK-NEXT: [[#TP+2]]: [B1.[[#TP+10]]]
217 // CHECK-NEXT: [[#TP+3]]: [B1.[[#TP+10]]] = [B1.[[#TP+1]]]
218 // CHECK-NEXT: [[#TP+4]]: cond
219 // CHECK-NEXT: [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int)
220 // CHECK-NEXT: [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
221 // CHECK-NEXT: [[#TP+7]]: fp
222 // CHECK-NEXT: [[#TP+8]]: rd
223 // CHECK-NEXT: [[#TP+9]]: map
224 // CHECK-NEXT: [[#TP+10]]: argc
225 // CHECK-NEXT: [[#TP+11]]: x
226 // CHECK-NEXT: [[#TP+12]]: #pragma omp target parallel if(cond) firstprivate(fp) reduction(+: rd) map(to: map)
227 // CHECK-NEXT: [B1.[[#TP+3]]];
228 #pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd) map(to:map)
229 argc = x;
230 // CHECK-NEXT: [[#TT:]]:
231 // CHECK-SAME: [B1.[[#TT+11]]]
232 // CHECK-NEXT: [[#TT+1]]: [B1.[[#TT+11]]] (ImplicitCastExpr, LValueToRValue, int)
233 // CHECK-NEXT: [[#TT+2]]: [B1.[[#TT+10]]]
234 // CHECK-NEXT: [[#TT+3]]: [B1.[[#TT+10]]] = [B1.[[#TT+1]]]
235 // CHECK-NEXT: [[#TT+4]]: cond
236 // CHECK-NEXT: [[#TT+5]]: [B1.[[#TT+4]]] (ImplicitCastExpr, LValueToRValue, int)
237 // CHECK-NEXT: [[#TT+6]]: [B1.[[#TT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
238 // CHECK-NEXT: [[#TT+7]]: fp
239 // CHECK-NEXT: [[#TT+8]]: rd
240 // CHECK-NEXT: [[#TT+9]]: map
241 // CHECK-NEXT: [[#TT+10]]: argc
242 // CHECK-NEXT: [[#TT+11]]: x
243 // CHECK-NEXT: [[#TT+12]]: #pragma omp target teams if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
244 // CHECK-NEXT: [B1.[[#TT+3]]];
245 #pragma omp target teams if(cond) firstprivate(fp) reduction(+:rd) map(tofrom:map)
246 argc = x;
247 // CHECK-NEXT: [[#TU:]]: cond
248 // CHECK-NEXT: [[#TU+1]]: [B1.[[#TU]]] (ImplicitCastExpr, LValueToRValue, int)
249 // CHECK-NEXT: [[#TU+2]]: [B1.[[#TU+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
250 // CHECK-NEXT: [[#TU+3]]: #pragma omp target update to(x) if(target update: cond)
251 #pragma omp target update to(x) if(target update:cond)
252 // CHECK-NEXT: [[#TASK:]]:
253 // CHECK-SAME: [B1.[[#TASK+9]]]
254 // CHECK-NEXT: [[#TASK+1]]: [B1.[[#TASK+9]]] (ImplicitCastExpr, LValueToRValue, int)
255 // CHECK-NEXT: [[#TASK+2]]: [B1.[[#TASK+8]]]
256 // CHECK-NEXT: [[#TASK+3]]: [B1.[[#TASK+8]]] = [B1.[[#TASK+1]]]
257 // CHECK-NEXT: [[#TASK+4]]: cond
258 // CHECK-NEXT: [[#TASK+5]]: [B1.[[#TASK+4]]] (ImplicitCastExpr, LValueToRValue, int)
259 // CHECK-NEXT: [[#TASK+6]]: [B1.[[#TASK+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
260 // CHECK-NEXT: [[#TASK+7]]: fp
261 // CHECK-NEXT: [[#TASK+8]]: argc
262 // CHECK-NEXT: [[#TASK+9]]: x
263 // CHECK-NEXT: [[#TASK+10]]: #pragma omp task if(cond) firstprivate(fp)
264 // CHECK-NEXT: [B1.[[#TASK+3]]];
265 #pragma omp task if(cond) firstprivate(fp)
266 argc = x;
267 // CHECK-NEXT: [[#TG:]]: x
268 // CHECK-NEXT: [[#TG+1]]: [B1.[[#TG]]] (ImplicitCastExpr, LValueToRValue, int)
269 // CHECK-NEXT: [[#TG+2]]: argc
270 // CHECK-NEXT: [[#TG+3]]: [B1.[[#TG+2]]] = [B1.[[#TG+1]]]
271 // CHECK-NEXT: [[#TG+4]]: #pragma omp taskgroup
272 // CHECK-NEXT: [B1.[[#TG+3]]];
273 #pragma omp taskgroup
274 argc = x;
275 // CHECK-NEXT: [[#TEAMS:]]: x
276 // CHECK-NEXT: [[#TEAMS+1]]: [B1.[[#TEAMS]]] (ImplicitCastExpr, LValueToRValue, int)
277 // CHECK-NEXT: [[#TEAMS+2]]: argc
278 // CHECK-NEXT: [[#TEAMS+3]]: [B1.[[#TEAMS+2]]] = [B1.[[#TEAMS+1]]]
279 // CHECK-NEXT: [[#TEAMS+4]]: [B1.[[#TEAMS+7]]]
280 // CHECK-NEXT: [[#TEAMS+5]]: [B1.[[#TEAMS+8]]]
281 // CHECK-NEXT: [[#TEAMS+6]]: #pragma omp teams firstprivate(fp) reduction(+: rd)
282 // CHECK-NEXT: [B1.[[#TEAMS+3]]];
283 // CHECK-NEXT: [[#TEAMS+7]]: fp
284 // CHECK-NEXT: [[#TEAMS+8]]: rd
285 // CHECK-NEXT: [[#TEAMS+9]]: argc
286 // CHECK-NEXT: [[#TEAMS+10]]: x
287 // CHECK-NEXT: [[#TEAMS+11]]: #pragma omp target
288 #pragma omp target
289 #pragma omp teams firstprivate(fp) reduction(+:rd)
290 argc = x;
291 // CHECK-NEXT: [B1.[[#TEAMS+6]]] Preds
292 }
293
294 // CHECK-LABEL: void dpf(int argc)
dpf(int argc)295 void dpf(int argc) {
296 int x, cond, fp, rd, lin, step_sz, map;
297 // CHECK-DAG: [B3]
298 // CHECK-DAG: [[#DPFB:]]: x
299 // CHECK-DAG: [[#DPFB+1]]: [B3.[[#DPFB]]] (ImplicitCastExpr, LValueToRValue, int)
300 // CHECK-DAG: [[#DPFB+2]]: argc
301 // CHECK-DAG: [[#DPFB+3]]: [B3.[[#DPFB+2]]] = [B3.[[#DPFB+1]]]
302 // CHECK-DAG: [B1]
303 // CHECK-DAG: [[#DPF:]]: cond
304 // CHECK-DAG: [[#DPF+1]]: [B1.[[#DPF]]] (ImplicitCastExpr, LValueToRValue, int)
305 // CHECK-DAG: [[#DPF+2]]: [B1.[[#DPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
306 // CHECK-DAG: [[#DPF+3]]: fp
307 // CHECK-DAG: [[#DPF+4]]: rd
308 // CHECK-DAG: [[#DPF+5]]: #pragma omp distribute parallel for if(parallel: cond) firstprivate(fp) reduction(+: rd)
309 // CHECK-DAG: for (int i = 0;
310 // CHECK-DAG: [B3.[[#DPFB+3]]];
311 #pragma omp distribute parallel for if(parallel:cond) firstprivate(fp) reduction(+:rd)
312 for (int i = 0; i < 10; ++i)
313 argc = x;
314 }
315
316 // CHECK-LABEL: void dpfs(int argc)
dpfs(int argc)317 void dpfs(int argc) {
318 int x, cond, fp, rd, lin, step_sz, map;
319 // CHECK-DAG: [B3]
320 // CHECK-DAG: [[#DPFSB:]]: x
321 // CHECK-DAG: [[#DPFSB+1]]: [B3.[[#DPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
322 // CHECK-DAG: [[#DPFSB+2]]: argc
323 // CHECK-DAG: [[#DPFSB+3]]: [B3.[[#DPFSB+2]]] = [B3.[[#DPFSB+1]]]
324 // CHECK-DAG: [B1]
325 // CHECK-DAG: [[#DPFS:]]: cond
326 // CHECK-DAG: [[#DPFS+1]]: [B1.[[#DPFS]]] (ImplicitCastExpr, LValueToRValue, int)
327 // CHECK-DAG: [[#DPFS+2]]: [B1.[[#DPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
328 // CHECK-DAG: [[#DPFS+3]]: fp
329 // CHECK-DAG: [[#DPFS+4]]: rd
330 // CHECK-DAG: [[#DPFS+5]]: #pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-: rd)
331 // CHECK-DAG: for (int i = 0;
332 // CHECK-DAG: [B3.[[#DPFSB+3]]];
333 #pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-:rd)
334 for (int i = 0; i < 10; ++i)
335 argc = x;
336 }
337
338 // CHECK-LABEL: void ds(int argc)
ds(int argc)339 void ds(int argc) {
340 int x, cond, fp, rd, lin, step_sz, map;
341 // CHECK-DAG: [B3]
342 // CHECK-DAG: [[#DSB:]]: x
343 // CHECK-DAG: [[#DSB+1]]: [B3.[[#DSB]]] (ImplicitCastExpr, LValueToRValue, int)
344 // CHECK-DAG: [[#DSB+2]]: argc
345 // CHECK-DAG: [[#DSB+3]]: [B3.[[#DSB+2]]] = [B3.[[#DSB+1]]]
346 // CHECK-DAG: [B1]
347 // CHECK-DAG: [[#DS:]]: #pragma omp distribute simd
348 // CHECK-DAG: for (int i = 0;
349 // CHECK-DAG: [B3.[[#DSB+3]]];
350 #pragma omp distribute simd
351 for (int i = 0; i < 10; ++i)
352 argc = x;
353 }
354
355 // CHECK-LABEL: void for_fn(int argc)
for_fn(int argc)356 void for_fn(int argc) {
357 int x, cond, fp, rd, lin, step_sz, map;
358 // CHECK-DAG: [B3]
359 // CHECK-DAG: [[#FORB:]]: x
360 // CHECK-DAG: [[#FORB+1]]: [B3.[[#FORB]]] (ImplicitCastExpr, LValueToRValue, int)
361 // CHECK-DAG: [[#FORB+2]]: argc
362 // CHECK-DAG: [[#FORB+3]]: [B3.[[#FORB+2]]] = [B3.[[#FORB+1]]]
363 // CHECK-DAG: [B1]
364 // CHECK-DAG: [[#FOR:]]: lin
365 // CHECK-DAG: [[#FOR+1]]: step_sz
366 // CHECK-DAG: [[#FOR+2]]: [B1.[[#FOR+1]]] (ImplicitCastExpr, LValueToRValue, int)
367 // CHECK-DAG: [[#FOR+3]]: #pragma omp for linear(lin: step(step_sz))
368 // CHECK-DAG: for (int i = 0;
369 // CHECK-DAG: [B3.[[#FORB+3]]];
370 #pragma omp for linear(lin : step_sz)
371 for (int i = 0; i < 10; ++i)
372 argc = x;
373 }
374
375 // CHECK-LABEL: void fs(int argc)
fs(int argc)376 void fs(int argc) {
377 int x, cond, fp, rd, lin, step_sz, map;
378 // CHECK-DAG: [B3]
379 // CHECK-DAG: [[#FSB:]]: x
380 // CHECK-DAG: [[#FSB+1]]: [B3.[[#FSB]]] (ImplicitCastExpr, LValueToRValue, int)
381 // CHECK-DAG: [[#FSB+2]]: argc
382 // CHECK-DAG: [[#FSB+3]]: [B3.[[#FSB+2]]] = [B3.[[#FSB+1]]]
383 // CHECK-DAG: [B1]
384 // CHECK-DAG: [[#FS:]]: lin
385 // CHECK-DAG: [[#FS+1]]: step_sz
386 // CHECK-DAG: [[#FS+2]]: [B1.[[#FS+1]]] (ImplicitCastExpr, LValueToRValue, int)
387 // CHECK-DAG: [[#FS+3]]: #pragma omp for simd linear(lin: step(step_sz))
388 // CHECK-DAG: for (int i = 0;
389 // CHECK-DAG: [B3.[[#FSB+3]]];
390 #pragma omp for simd linear(lin: step_sz)
391 for (int i = 0; i < 10; ++i)
392 argc = x;
393 }
394
395 // CHECK-LABEL: void ord(int argc)
ord(int argc)396 void ord(int argc) {
397 int x, cond, fp, rd, lin, step_sz, map;
398 // CHECK-DAG: [B3]
399 // CHECK-DAG: [[#ORDB:]]: x
400 // CHECK-DAG: [[#ORDB+1]]: [B3.[[#ORDB]]] (ImplicitCastExpr, LValueToRValue, int)
401 // CHECK-DAG: [[#ORDB+2]]: argc
402 // CHECK-DAG: [[#ORDB+3]]: [B3.[[#ORDB+2]]] = [B3.[[#ORDB+1]]]
403 // CHECK-DAG: [[#ORDB+4]]: #pragma omp ordered
404 // CHECK-DAG: [B3.[[#ORDB+3]]];
405 // CHECK-DAG: [B1]
406 // CHECK-DAG: [[#ORD:]]: #pragma omp for ordered
407 // CHECK-DAG: for (int i = 0
408 // CHECK-DAG:[B3.[[#ORDB+4]]] }
409 #pragma omp for ordered
410 for (int i = 0; i < 10; ++i) {
411 #pragma omp ordered
412 argc = x;
413 }
414 }
415
416 // CHECK-LABEL: void pf(int argc)
pf(int argc)417 void pf(int argc) {
418 int x, cond, fp, rd, lin, step_sz, map;
419 // CHECK-DAG: [B3]
420 // CHECK-DAG: [[#PFB:]]: x
421 // CHECK-DAG: [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)
422 // CHECK-DAG: [[#PFB+2]]: argc
423 // CHECK-DAG: [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]
424 // CHECK-DAG: [B1]
425 // CHECK-DAG: [[#PF:]]: cond
426 // CHECK-DAG: [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)
427 // CHECK-DAG: [[#PF+2]]: [B1.[[#PF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
428 // CHECK-DAG: [[#PF+3]]: fp
429 // CHECK-DAG: [[#PF+4]]: rd
430 // CHECK-DAG: [[#PF+5]]: lin
431 // CHECK-DAG: [[#PF+6]]: step_sz
432 // CHECK-DAG: [[#PF+7]]: [B1.[[#PF+6]]] (ImplicitCastExpr, LValueToRValue, int)
433 // CHECK-DAG: [[#PF+8]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd) linear(lin: step(step_sz))
434 // CHECK-DAG: for (int i = 0;
435 // CHECK-DAG: [B3.[[#PFB+3]]];
436 #pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd) linear(lin: step_sz)
437 for (int i = 0; i < 10; ++i)
438 argc = x;
439 }
440
441 // CHECK-LABEL: void pfs(int argc)
pfs(int argc)442 void pfs(int argc) {
443 int x, cond, fp, rd, lin, step_sz, map;
444 // CHECK-DAG: [B3]
445 // CHECK-DAG: [[#PFSB:]]: x
446 // CHECK-DAG: [[#PFSB+1]]: [B3.[[#PFSB]]] (ImplicitCastExpr, LValueToRValue, int)
447 // CHECK-DAG: [[#PFSB+2]]: argc
448 // CHECK-DAG: [[#PFSB+3]]: [B3.[[#PFSB+2]]] = [B3.[[#PFSB+1]]]
449 // CHECK-DAG: [B1]
450 // CHECK-DAG: [[#PFS:]]: cond
451 // CHECK-DAG: [[#PFS+1]]: [B1.[[#PFS]]] (ImplicitCastExpr, LValueToRValue, int)
452 // CHECK-DAG: [[#PFS+2]]: [B1.[[#PFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
453 // CHECK-DAG: [[#PFS+3]]: fp
454 // CHECK-DAG: [[#PFS+4]]: rd
455 // CHECK-DAG: [[#PFS+5]]: lin
456 // CHECK-DAG: [[#PFS+6]]: step_sz
457 // CHECK-DAG: [[#PFS+7]]: [B1.[[#PFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
458 // CHECK-DAG: [[#PFS+8]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd) linear(lin: step(step_sz))
459 // CHECK-DAG: for (int i = 0;
460 // CHECK-DAG: [B3.[[#PFSB+3]]];
461 #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd) linear(lin: step_sz)
462 for (int i = 0; i < 10; ++i)
463 argc = x;
464 }
465
466 // CHECK-LABEL: void simd(int argc)
simd(int argc)467 void simd(int argc) {
468 int x, cond, fp, rd, lin, step_sz, map;
469 // CHECK-DAG: [B3]
470 // CHECK-DAG: [[#SIMDB:]]: x
471 // CHECK-DAG: [[#SIMDB+1]]: [B3.[[#SIMDB]]] (ImplicitCastExpr, LValueToRValue, int)
472 // CHECK-DAG: [[#SIMDB+2]]: argc
473 // CHECK-DAG: [[#SIMDB+3]]: [B3.[[#SIMDB+2]]] = [B3.[[#SIMDB+1]]]
474 // CHECK-DAG: [B1]
475 // CHECK-DAG: [[#SIMD:]]: lin
476 // CHECK-DAG: [[#SIMD+1]]: step_sz
477 // CHECK-DAG: [[#SIMD+2]]: [B1.[[#SIMD+1]]] (ImplicitCastExpr, LValueToRValue, int)
478 // CHECK-DAG: [[#SIMD+3]]: #pragma omp simd linear(lin: step(step_sz))
479 // CHECK-DAG: for (int i = 0;
480 // CHECK-DAG: [B3.[[#SIMDB+3]]];
481 #pragma omp simd linear(lin: step_sz)
482 for (int i = 0; i < 10; ++i)
483 argc = x;
484 }
485
486 // CHECK-LABEL: void tpf(int argc)
tpf(int argc)487 void tpf(int argc) {
488 int x, cond, fp, rd, lin, step_sz, map;
489 // CHECK-DAG: [B3]
490 // CHECK-DAG: [[#TPFB:]]: x
491 // CHECK-DAG: [[#TPFB+1]]: [B3.[[#TPFB]]] (ImplicitCastExpr, LValueToRValue, int)
492 // CHECK-DAG: [[#TPFB+2]]: argc
493 // CHECK-DAG: [[#TPFB+3]]: [B3.[[#TPFB+2]]] = [B3.[[#TPFB+1]]]
494 // CHECK-DAG: [B1]
495 // CHECK-DAG: [[#TPF:]]: cond
496 // CHECK-DAG: [[#TPF+1]]: [B1.[[#TPF]]] (ImplicitCastExpr, LValueToRValue, int)
497 // CHECK-DAG: [[#TPF+2]]: [B1.[[#TPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
498 // CHECK-DAG: [[#TPF+3]]: fp
499 // CHECK-DAG: [[#TPF+4]]: rd
500 // CHECK-DAG: [[#TPF+5]]: lin
501 // CHECK-DAG: [[#TPF+6]]: step_sz
502 // CHECK-DAG: [[#TPF+7]]: [B1.[[#TPF+6]]] (ImplicitCastExpr, LValueToRValue, int)
503 // CHECK-DAG: [[#TPF+8]]: map
504 // CHECK-DAG: [[#TPF+9]]: [B3.[[#TPFB+2]]]
505 // CHECK-DAG: [[#TPF+10]]: [B3.[[#TPFB]]]
506 // CHECK-DAG: [[#TPF+11]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step(step_sz)) map(tofrom: map)
507 // CHECK-DAG: for (int i = 0;
508 // CHECK-DAG: [B3.[[#TPFB+3]]];
509 #pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step_sz) map(map)
510 for (int i = 0; i < 10; ++i)
511 argc = x;
512 }
513
514 // CHECK-LABEL: void tpfs(int argc)
tpfs(int argc)515 void tpfs(int argc) {
516 int x, cond, fp, rd, lin, step_sz, map;
517 // CHECK-DAG: [B3]
518 // CHECK-DAG: [[#TPFSB:]]: x
519 // CHECK-DAG: [[#TPFSB+1]]: [B3.[[#TPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
520 // CHECK-DAG: [[#TPFSB+2]]: argc
521 // CHECK-DAG: [[#TPFSB+3]]: [B3.[[#TPFSB+2]]] = [B3.[[#TPFSB+1]]]
522 // CHECK-DAG: [B1]
523 // CHECK-DAG: [[#TPFS:]]: cond
524 // CHECK-DAG: [[#TPFS+1]]: [B1.[[#TPFS]]] (ImplicitCastExpr, LValueToRValue, int)
525 // CHECK-DAG: [[#TPFS+2]]: [B1.[[#TPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
526 // CHECK-DAG: [[#TPFS+3]]: fp
527 // CHECK-DAG: [[#TPFS+4]]: rd
528 // CHECK-DAG: [[#TPFS+5]]: lin
529 // CHECK-DAG: [[#TPFS+6]]: step_sz
530 // CHECK-DAG: [[#TPFS+7]]: [B1.[[#TPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
531 // CHECK-DAG: [[#TPFS+8]]: map
532 // CHECK-DAG: [[#TPFS+9]]: [B3.[[#TPFSB+2]]]
533 // CHECK-DAG: [[#TPFS+10]]: [B3.[[#TPFSB]]]
534 // CHECK-DAG: [[#TPFS+11]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step(step_sz)) map(tofrom: map)
535 // CHECK-DAG: for (int i = 0;
536 // CHECK-DAG: [B3.[[#TPFSB+3]]];
537 #pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step_sz) map(tofrom:map)
538 for (int i = 0; i < 10; ++i)
539 argc = x;
540 }
541
542 // CHECK-LABEL: void ts(int argc)
ts(int argc)543 void ts(int argc) {
544 int x, cond, fp, rd, lin, step_sz, map;
545 // CHECK-DAG: [B3]
546 // CHECK-DAG: [[#TSB:]]: x
547 // CHECK-DAG: [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)
548 // CHECK-DAG: [[#TSB+2]]: argc
549 // CHECK-DAG: [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]
550 // CHECK-DAG: [B1]
551 // CHECK-DAG: [[#TS:]]: cond
552 // CHECK-DAG: [[#TS+1]]: [B1.[[#TS]]] (ImplicitCastExpr, LValueToRValue, int)
553 // CHECK-DAG: [[#TS+2]]: [B1.[[#TS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
554 // CHECK-DAG: [[#TS+3]]: fp
555 // CHECK-DAG: [[#TS+4]]: rd
556 // CHECK-DAG: [[#TS+5]]: lin
557 // CHECK-DAG: [[#TS+6]]: step_sz
558 // CHECK-DAG: [[#TS+7]]: [B1.[[#TS+6]]] (ImplicitCastExpr, LValueToRValue, int)
559 // CHECK-DAG: [[#TS+8]]: [B3.[[#TSB+2]]]
560 // CHECK-DAG: [[#TS+9]]: [B3.[[#TSB]]]
561 // CHECK-DAG: [[#TS+10]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step(step_sz)) map(alloc: map)
562 // CHECK-DAG: for (int i = 0;
563 // CHECK-DAG: [B3.[[#TSB+3]]];
564 #pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step_sz) map(alloc:map)
565 for (int i = 0; i < 10; ++i)
566 argc = x;
567 }
568
569 // CHECK-LABEL: void ttd(int argc)
ttd(int argc)570 void ttd(int argc) {
571 int x, cond, fp, rd, lin, step_sz, map;
572 // CHECK-DAG: [B3]
573 // CHECK-DAG: [[#TTDB:]]: x
574 // CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
575 // CHECK-DAG: [[#TTDB+2]]: argc
576 // CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
577 // CHECK-DAG: [B1]
578 // CHECK-DAG: [[#TTD:]]: cond
579 // CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
580 // CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
581 // CHECK-DAG: [[#TTD+3]]: fp
582 // CHECK-DAG: [[#TTD+4]]: rd
583 // CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
584 // CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
585 // CHECK-DAG: [[#TTD+7]]: #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
586 // CHECK-DAG: for (int i = 0;
587 // CHECK-DAG: [B3.[[#TTDB+3]]];
588 #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
589 for (int i = 0; i < 10; ++i)
590 argc = x;
591 }
592
593 // CHECK-LABEL: void ttdpf(int argc)
ttdpf(int argc)594 void ttdpf(int argc) {
595 int x, cond, fp, rd, lin, step_sz, map;
596 // CHECK-DAG: [B3]
597 // CHECK-DAG: [[#TTDPFB:]]: x
598 // CHECK-DAG: [[#TTDPFB+1]]: [B3.[[#TTDPFB]]] (ImplicitCastExpr, LValueToRValue, int)
599 // CHECK-DAG: [[#TTDPFB+2]]: argc
600 // CHECK-DAG: [[#TTDPFB+3]]: [B3.[[#TTDPFB+2]]] = [B3.[[#TTDPFB+1]]]
601 // CHECK-DAG: [B1]
602 // CHECK-DAG: [[#TTDPF:]]: cond
603 // CHECK-DAG: [[#TTDPF+1]]: [B1.[[#TTDPF]]] (ImplicitCastExpr, LValueToRValue, int)
604 // CHECK-DAG: [[#TTDPF+2]]: [B1.[[#TTDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
605 // CHECK-DAG: [[#TTDPF+3]]: fp
606 // CHECK-DAG: [[#TTDPF+4]]: rd
607 // CHECK-DAG: [[#TTDPF+5]]: [B3.[[#TTDPFB+2]]]
608 // CHECK-DAG: [[#TTDPF+6]]: [B3.[[#TTDPFB]]]
609 // CHECK-DAG: [[#TTDPF+7]]: #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
610 // CHECK-DAG: for (int i = 0;
611 // CHECK-DAG: [B3.[[#TTDPFB+3]]];
612 #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
613 for (int i = 0; i < 10; ++i)
614 argc = x;
615 }
616
617 // CHECK-LABEL: void ttdpfs(int argc)
ttdpfs(int argc)618 void ttdpfs(int argc) {
619 int x, cond, fp, rd, lin, step_sz, map;
620 // CHECK-DAG: [B3]
621 // CHECK-DAG: [[#TTDPFSB:]]: x
622 // CHECK-DAG: [[#TTDPFSB+1]]: [B3.[[#TTDPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
623 // CHECK-DAG: [[#TTDPFSB+2]]: argc
624 // CHECK-DAG: [[#TTDPFSB+3]]: [B3.[[#TTDPFSB+2]]] = [B3.[[#TTDPFSB+1]]]
625 // CHECK-DAG: [B1]
626 // CHECK-DAG: [[#TTDPFS:]]: cond
627 // CHECK-DAG: [[#TTDPFS+1]]: [B1.[[#TTDPFS]]] (ImplicitCastExpr, LValueToRValue, int)
628 // CHECK-DAG: [[#TTDPFS+2]]: [B1.[[#TTDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
629 // CHECK-DAG: [[#TTDPFS+3]]: fp
630 // CHECK-DAG: [[#TTDPFS+4]]: rd
631 // CHECK-DAG: [[#TTDPFS+5]]: [B3.[[#TTDPFSB+2]]]
632 // CHECK-DAG: [[#TTDPFS+6]]: [B3.[[#TTDPFSB]]]
633 // CHECK-DAG: [[#TTDPFS+7]]: #pragma omp target teams distribute parallel for simd if(parallel: cond) firstprivate(fp) reduction(+: rd) map(from: map)
634 // CHECK-DAG: for (int i = 0;
635 // CHECK-DAG: [B3.[[#TTDPFSB+3]]];
636 #pragma omp target teams distribute parallel for simd if(parallel:cond) firstprivate(fp) reduction(+:rd) map(from:map)
637 for (int i = 0; i < 10; ++i)
638 argc = x;
639 }
640
641 // CHECK-LABEL: void ttds(int argc)
ttds(int argc)642 void ttds(int argc) {
643 int x, cond, fp, rd, lin, step_sz, map;
644 // CHECK-DAG: [B3]
645 // CHECK-DAG: [[#TTDSB:]]: x
646 // CHECK-DAG: [[#TTDSB+1]]: [B3.[[#TTDSB]]] (ImplicitCastExpr, LValueToRValue, int)
647 // CHECK-DAG: [[#TTDSB+2]]: argc
648 // CHECK-DAG: [[#TTDSB+3]]: [B3.[[#TTDSB+2]]] = [B3.[[#TTDSB+1]]]
649 // CHECK-DAG: [B1]
650 // CHECK-DAG: [[#TTDS:]]: cond
651 // CHECK-DAG: [[#TTDS+1]]: [B1.[[#TTDS]]] (ImplicitCastExpr, LValueToRValue, int)
652 // CHECK-DAG: [[#TTDS+2]]: [B1.[[#TTDS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
653 // CHECK-DAG: [[#TTDS+3]]: fp
654 // CHECK-DAG: [[#TTDS+4]]: rd
655 // CHECK-DAG: [[#TTDS+5]]: map
656 // CHECK-DAG: [[#TTDS+6]]: [B3.[[#TTDSB+2]]]
657 // CHECK-DAG: [[#TTDS+7]]: [B3.[[#TTDSB]]]
658 // CHECK-DAG: [[#TTDS+8]]: #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
659 // CHECK-DAG: for (int i = 0;
660 // CHECK-DAG: [B3.[[#TTDPFSB+3]]];
661 #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+:rd) map(map)
662 for (int i = 0; i < 10; ++i)
663 argc = x;
664 }
665
666 // CHECK-LABEL: void tl(int argc)
tl(int argc)667 void tl(int argc) {
668 int x, cond, fp, rd, lin, step_sz, map;
669 // CHECK-DAG: [B3]
670 // CHECK-DAG: [[#TLB:]]: x
671 // CHECK-DAG: [[#TLB+1]]: [B3.[[#TLB]]] (ImplicitCastExpr, LValueToRValue, int)
672 // CHECK-DAG: [[#TLB+2]]: argc
673 // CHECK-DAG: [[#TLB+3]]: [B3.[[#TLB+2]]] = [B3.[[#TLB+1]]]
674 // CHECK-DAG: [B1]
675 // CHECK-DAG: [[#TL:]]: cond
676 // CHECK-DAG: [[#TL+1]]: [B1.[[#TL]]] (ImplicitCastExpr, LValueToRValue, int)
677 // CHECK-DAG: [[#TL+2]]: [B1.[[#TL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
678 // CHECK-DAG: [[#TL+3]]: fp
679 // CHECK-DAG: [[#TL+4]]: rd
680 // CHECK-DAG: [[#TL+5]]: [B3.[[#TLB+2]]]
681 // CHECK-DAG: [[#TL+6]]: [B3.[[#TLB]]]
682 // CHECK-DAG: [[#TL+7]]: #pragma omp taskloop if(cond) firstprivate(fp) reduction(+: rd)
683 // CHECK-DAG: for (int i = 0;
684 // CHECK-DAG: [B3.[[#TLB+3]]];
685 #pragma omp taskloop if(cond) firstprivate(fp) reduction(+:rd)
686 for (int i = 0; i < 10; ++i)
687 argc = x;
688 }
689
690 // CHECK-LABEL: void maskedtaskloop(int argc)
maskedtaskloop(int argc)691 void maskedtaskloop(int argc) {
692 int x, cond, fp, rd, lin, step_sz, map;
693 // CHECK-DAG: [B3]
694 // CHECK-DAG: [[#MTLB:]]: x
695 // CHECK-DAG: [[#MTLB+1]]: [B3.[[#MTLB]]] (ImplicitCastExpr, LValueToRValue, int)
696 // CHECK-DAG: [[#MTLB+2]]: argc
697 // CHECK-DAG: [[#MTLB+3]]: [B3.[[#MTLB+2]]] = [B3.[[#MTLB+1]]]
698 // CHECK-DAG: [B1]
699 // CHECK-DAG: [[#MTL:]]: cond
700 // CHECK-DAG: [[#MTL+1]]: [B1.[[#MTL]]] (ImplicitCastExpr, LValueToRValue, int)
701 // CHECK-DAG: [[#MTL+2]]: [B1.[[#MTL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
702 // CHECK-DAG: [[#MTL+3]]: fp
703 // CHECK-DAG: [[#MTL+4]]: rd
704 // CHECK-DAG: [[#MTL+5]]: [B3.[[#MTLB+2]]]
705 // CHECK-DAG: [[#MTL+6]]: [B3.[[#MTLB]]]
706 // CHECK-DAG: [[#MTL+7]]: #pragma omp masked taskloop if(cond) firstprivate(fp) reduction(+: rd)
707 // CHECK-DAG: for (int i = 0;
708 // CHECK-DAG: [B3.[[#MTLB+3]]];
709 #pragma omp masked taskloop if(cond) firstprivate(fp) reduction(+:rd)
710 for (int i = 0; i < 10; ++i)
711 argc = x;
712 }
713
714 // CHECK-LABEL: void parallelmaskedtaskloop(int argc)
parallelmaskedtaskloop(int argc)715 void parallelmaskedtaskloop(int argc) {
716 int x, cond, fp, rd, lin, step_sz, map;
717 // CHECK-DAG: [B3]
718 // CHECK-DAG: [[#PMTLB:]]: x
719 // CHECK-DAG: [[#PMTLB+1]]: [B3.[[#PMTLB]]] (ImplicitCastExpr, LValueToRValue, int)
720 // CHECK-DAG: [[#PMTLB+2]]: argc
721 // CHECK-DAG: [[#PMTLB+3]]: [B3.[[#PMTLB+2]]] = [B3.[[#PMTLB+1]]]
722 // CHECK-DAG: [B1]
723 // CHECK-DAG: [[#PMTL:]]: cond
724 // CHECK-DAG: [[#PMTL+1]]: [B1.[[#PMTL]]] (ImplicitCastExpr, LValueToRValue, int)
725 // CHECK-DAG: [[#PMTL+2]]: [B1.[[#PMTL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
726 // CHECK-DAG: [[#PMTL+3]]: fp
727 // CHECK-DAG: [[#PMTL+4]]: rd
728 // CHECK-DAG: [[#PMTL+5]]: [B3.[[#PMTLB+2]]]
729 // CHECK-DAG: [[#PMTL+6]]: [B3.[[#PMTLB]]]
730 // CHECK-DAG: [[#PMTL+7]]: #pragma omp parallel masked taskloop if(cond) firstprivate(fp) reduction(+: rd)
731 // CHECK-DAG: for (int i = 0;
732 // CHECK-DAG: [B3.[[#PMTLB+3]]];
733 #pragma omp parallel masked taskloop if(cond) firstprivate(fp) reduction(+:rd)
734 for (int i = 0; i < 10; ++i)
735 argc = x;
736 }
737
738 // CHECK-LABEL: void parallelmaskedtasksimdloop(int argc)
parallelmaskedtasksimdloop(int argc)739 void parallelmaskedtasksimdloop(int argc) {
740 int x, cond, fp, rd, lin, step_sz, map;
741 // CHECK-DAG: [B3]
742 // CHECK-DAG: [[#PMTLSB:]]: x
743 // CHECK-DAG: [[#PMTLSB+1]]: [B3.[[#PMTLSB]]] (ImplicitCastExpr, LValueToRValue, int)
744 // CHECK-DAG: [[#PMTLSB+2]]: argc
745 // CHECK-DAG: [[#PMTLSB+3]]: [B3.[[#PMTLSB+2]]] = [B3.[[#PMTLSB+1]]]
746 // CHECK-DAG: [B1]
747 // CHECK-DAG: [[#PMTLS:]]: cond
748 // CHECK-DAG: [[#PMTLS+1]]: [B1.[[#PMTLS]]] (ImplicitCastExpr, LValueToRValue, int)
749 // CHECK-DAG: [[#PMTLS+2]]: [B1.[[#PMTLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
750 // CHECK-DAG: [[#PMTLS+3]]: fp
751 // CHECK-DAG: [[#PMTLS+4]]: rd
752 // CHECK-DAG: [[#PMTLS+5]]: [B3.[[#PMTLSB+2]]]
753 // CHECK-DAG: [[#PMTLS+6]]: [B3.[[#PMTLSB]]]
754 // CHECK-DAG: [[#PMTLS+7]]: #pragma omp parallel masked taskloop simd if(cond) firstprivate(fp) reduction(+: rd)
755 // CHECK-DAG: for (int i = 0;
756 // CHECK-DAG: [B3.[[#PMTLSB+3]]];
757 #pragma omp parallel masked taskloop simd if(cond) firstprivate(fp) reduction(+:rd)
758 for (int i = 0; i < 10; ++i)
759 argc = x;
760 }
761
762 // CHECK-LABEL: void tls(int argc)
tls(int argc)763 void tls(int argc) {
764 int x, cond, fp, rd, lin, step_sz, map;
765 // CHECK-DAG: [B3]
766 // CHECK-DAG: [[#TLSB:]]: x
767 // CHECK-DAG: [[#TLSB+1]]: [B3.[[#TLSB]]] (ImplicitCastExpr, LValueToRValue, int)
768 // CHECK-DAG: [[#TLSB+2]]: argc
769 // CHECK-DAG: [[#TLSB+3]]: [B3.[[#TLSB+2]]] = [B3.[[#TLSB+1]]]
770 // CHECK-DAG: [B1]
771 // CHECK-DAG: [[#TLS:]]: cond
772 // CHECK-DAG: [[#TLS+1]]: [B1.[[#TLS]]] (ImplicitCastExpr, LValueToRValue, int)
773 // CHECK-DAG: [[#TLS+2]]: [B1.[[#TLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
774 // CHECK-DAG: [[#TLS+3]]: fp
775 // CHECK-DAG: [[#TLS+4]]: rd
776 // CHECK-DAG: [[#TLS+5]]: lin
777 // CHECK-DAG: [[#TLS+6]]: step_sz
778 // CHECK-DAG: [[#TLS+7]]: [B1.[[#TLS+6]]] (ImplicitCastExpr, LValueToRValue, int)
779 // CHECK-DAG: [[#TLS+8]]: [B3.[[#TLSB+2]]]
780 // CHECK-DAG: [[#TLS+9]]: [B3.[[#TLSB]]]
781 // CHECK-DAG: [[#TLS+10]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step(step_sz))
782 // CHECK-DAG: for (int i = 0;
783 // CHECK-DAG: [B3.[[#TLSB+3]]];
784 #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step_sz)
785 for (int i = 0; i < 10; ++i)
786 argc = x;
787 }
788
789 // CHECK-LABEL: void maskedtaskloopsimd(int argc)
maskedtaskloopsimd(int argc)790 void maskedtaskloopsimd(int argc) {
791 int x, cond, fp, rd, lin, step_sz, map;
792 // CHECK-DAG: [B3]
793 // CHECK-DAG: [[#MTLSB:]]: x
794 // CHECK-DAG: [[#MTLSB+1]]: [B3.[[#MTLSB]]] (ImplicitCastExpr, LValueToRValue, int)
795 // CHECK-DAG: [[#MTLSB+2]]: argc
796 // CHECK-DAG: [[#MTLSB+3]]: [B3.[[#MTLSB+2]]] = [B3.[[#MTLSB+1]]]
797 // CHECK-DAG: [B1]
798 // CHECK-DAG: [[#MTLS:]]: cond
799 // CHECK-DAG: [[#MTLS+1]]: [B1.[[#MTLS]]] (ImplicitCastExpr, LValueToRValue, int)
800 // CHECK-DAG: [[#MTLS+2]]: [B1.[[#MTLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
801 // CHECK-DAG: [[#MTLS+3]]: fp
802 // CHECK-DAG: [[#MTLS+4]]: rd
803 // CHECK-DAG: [[#MTLS+5]]: lin
804 // CHECK-DAG: [[#MTLS+6]]: step_sz
805 // CHECK-DAG: [[#MTLS+7]]: [B1.[[#MTLS+6]]] (ImplicitCastExpr, LValueToRValue, int)
806 // CHECK-DAG: [[#MTLS+8]]: [B3.[[#MTLSB+2]]]
807 // CHECK-DAG: [[#MTLS+9]]: [B3.[[#MTLSB]]]
808 // CHECK-DAG: [[#MTLS+10]]: #pragma omp masked taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step(step_sz))
809 // CHECK-DAG: for (int i = 0;
810 // CHECK-DAG: [B3.[[#MTLSB+3]]];
811 #pragma omp masked taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step_sz)
812 for (int i = 0; i < 10; ++i)
813 argc = x;
814 }
815
816 // CHECK-LABEL: void tdpf(int argc)
tdpf(int argc)817 void tdpf(int argc) {
818 int x, cond, fp, rd, lin, step_sz, map;
819 // CHECK-DAG: [B1]
820 // CHECK-DAG: [[#TDPF:]]: [B1.{{.+}}]
821 // CHECK-DAG: [[#TDPF+1]]: [B1.[[#TDPF+6]]] (ImplicitCastExpr, LValueToRValue, int)
822 // CHECK-DAG: [[#TDPF+2]]: [B1.[[#TDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
823 // CHECK-DAG: [[#TDPF+3]]: [B1.[[#TDPF+7]]]
824 // CHECK-DAG: [[#TDPF+4]]: [B1.[[#TDPF+8]]]
825 // CHECK-DAG: [[#TDPF+5]]: #pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd)
826 // CHECK-DAG: for (int i = 0;
827 // CHECK-DAG: [B3.[[#TDPFB:]]];
828 // CHECK-DAG: [[#TDPF+6]]: cond
829 // CHECK-DAG: [[#TDPF+7]]: fp
830 // CHECK-DAG: [[#TDPF+8]]: rd
831 // CHECK-DAG: [[#TDPF+9]]: argc
832 // CHECK-DAG: [[#TDPF+10]]: x
833 // CHECK-DAG: [[#TDPF+11]]: #pragma omp target
834 // CHECK-DAG: [B3]
835 // CHECK-DAG: [[#TDPFB-3]]: x
836 // CHECK-DAG: [[#TDPFB-2]]: [B3.[[#TDPFB-3]]] (ImplicitCastExpr, LValueToRValue, int)
837 // CHECK-DAG: [[#TDPFB-1]]: argc
838 // CHECK-DAG: [[#TDPFB]]: [B3.[[#TDPFB-1]]] = [B3.[[#TDPFB-2]]]
839 #pragma omp target
840 #pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd)
841 for (int i = 0; i < 10; ++i)
842 argc = x;
843 }
844
845 // CHECK-LABEL: void tdpfs(int argc)
tdpfs(int argc)846 void tdpfs(int argc) {
847 int x, cond, fp, rd, lin, step_sz, map;
848 // CHECK-DAG: [B1]
849 // CHECK-DAG: [[#TDPFS:]]: [B1.{{.+}}]
850 // CHECK-DAG: [[#TDPFS+1]]: [B1.[[#TDPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
851 // CHECK-DAG: [[#TDPFS+2]]: [B1.[[#TDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
852 // CHECK-DAG: [[#TDPFS+3]]: [B1.[[#TDPFS+7]]]
853 // CHECK-DAG: [[#TDPFS+4]]: [B1.[[#TDPFS+8]]]
854 // CHECK-DAG: [[#TDPFS+5]]: #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+: rd)
855 // CHECK-DAG: for (int i = 0;
856 // CHECK-DAG: [B3.[[#TDPFSB:]]];
857 // CHECK-DAG: [[#TDPFS+6]]: cond
858 // CHECK-DAG: [[#TDPFS+7]]: fp
859 // CHECK-DAG: [[#TDPFS+8]]: rd
860 // CHECK-DAG: [[#TDPFS+9]]: argc
861 // CHECK-DAG: [[#TDPFS+10]]: x
862 // CHECK-DAG: [[#TDPFS+11]]: #pragma omp target
863 // CHECK-DAG: [B3]
864 // CHECK-DAG: [[#TDPFSB-3]]: x
865 // CHECK-DAG: [[#TDPFSB-2]]: [B3.[[#TDPFSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
866 // CHECK-DAG: [[#TDPFSB-1]]: argc
867 // CHECK-DAG: [[#TDPFSB]]: [B3.[[#TDPFSB-1]]] = [B3.[[#TDPFSB-2]]]
868 #pragma omp target
869 #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+:rd)
870 for (int i = 0; i < 10; ++i)
871 argc = x;
872 }
873
874 // CHECK-LABEL: void tds(int argc)
tds(int argc)875 void tds(int argc) {
876 int x, cond, fp, rd, lin, step_sz, map;
877 // CHECK-DAG: [B1]
878 // CHECK-DAG: [[#TDS:]]: #pragma omp teams distribute simd firstprivate(fp) reduction(+: rd)
879 // CHECK-DAG: [[#TDS-2]]: [B1.[[#TDS+1]]]
880 // CHECK-DAG: [[#TDS-1]]: [B1.[[#TDS+2]]]
881 // CHECK-DAG: for (int i = 0;
882 // CHECK-DAG: [B3.[[#TDSB:]]];
883 // CHECK-DAG: [[#TDS+1]]: fp
884 // CHECK-DAG: [[#TDS+2]]: rd
885 // CHECK-DAG: [[#TDS+3]]: argc
886 // CHECK-DAG: [[#TDS+4]]: x
887 // CHECK-DAG: [[#TDS+5]]: #pragma omp target
888 // CHECK-DAG: [B3]
889 // CHECK-DAG: [[#TDSB-3]]: x
890 // CHECK-DAG: [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
891 // CHECK-DAG: [[#TDSB-1]]: argc
892 // CHECK-DAG: [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]
893 #pragma omp target
894 #pragma omp teams distribute simd firstprivate(fp) reduction(+:rd)
895 for (int i = 0; i < 10; ++i)
896 argc = x;
897 }
898
899 // CHECK-LABEL: void teamsloop(int argc)
teamsloop(int argc)900 void teamsloop(int argc) {
901 int x, cond, fp, rd, lin, step_sz, map;
902 // CHECK-DAG: [B1]
903 // CHECK-DAG: [[#TDS:]]: #pragma omp teams loop firstprivate(fp) reduction(+: rd)
904 // CHECK-DAG: [[#TDS-2]]: [B1.[[#TDS+1]]]
905 // CHECK-DAG: [[#TDS-1]]: [B1.[[#TDS+2]]]
906 // CHECK-DAG: for (int i = 0;
907 // CHECK-DAG: [B3.[[#TDSB:]]];
908 // CHECK-DAG: [[#TDS+1]]: fp
909 // CHECK-DAG: [[#TDS+2]]: rd
910 // CHECK-DAG: [[#TDS+3]]: argc
911 // CHECK-DAG: [[#TDS+4]]: x
912 // CHECK-DAG: [[#TDS+5]]: #pragma omp target
913 // CHECK-DAG: [B3]
914 // CHECK-DAG: [[#TDSB-3]]: x
915 // CHECK-DAG: [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
916 // CHECK-DAG: [[#TDSB-1]]: argc
917 // CHECK-DAG: [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]
918 #pragma omp target
919 #pragma omp teams loop firstprivate(fp) reduction(+:rd)
920 for (int i = 0; i < 10; ++i)
921 argc = x;
922 }
923
924 // CHECK-LABEL: void targetteamsloop(int argc)
targetteamsloop(int argc)925 void targetteamsloop(int argc) {
926 int x, cond, fp, rd, map;
927 // CHECK-DAG: [B3]
928 // CHECK-DAG: [[#TTDB:]]: x
929 // CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
930 // CHECK-DAG: [[#TTDB+2]]: argc
931 // CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
932 // CHECK-DAG: [B1]
933 // CHECK-DAG: [[#TTD:]]: cond
934 // CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
935 // CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
936 // CHECK-DAG: [[#TTD+3]]: fp
937 // CHECK-DAG: [[#TTD+4]]: rd
938 // CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
939 // CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
940 // CHECK-DAG: [[#TTD+7]]: #pragma omp target teams loop if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
941 // CHECK-DAG: for (int i = 0;
942 // CHECK-DAG: [B3.[[#TTDB+3]]];
943 #pragma omp target teams loop if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
944 for (int i = 0; i < 10; ++i)
945 argc = x;
946 }
947
948 // CHECK-LABEL: void parallelloop(int argc)
parallelloop(int argc)949 void parallelloop(int argc) {
950 int x, cond, fp, rd;
951 // CHECK-DAG: [B3]
952 // CHECK-DAG: [[#PFB:]]: x
953 // CHECK-DAG: [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)
954 // CHECK-DAG: [[#PFB+2]]: argc
955 // CHECK-DAG: [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]
956 // CHECK-DAG: [B1]
957 // CHECK-DAG: [[#PF:]]: cond
958 // CHECK-DAG: [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)
959 // CHECK-DAG: [[#PF+2]]: [B1.[[#PF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
960 // CHECK-DAG: [[#PF+3]]: fp
961 // CHECK-DAG: [[#PF+4]]: rd
962 // CHECK-DAG: [[#PF+5]]: #pragma omp parallel loop if(cond) firstprivate(fp) reduction(&: rd)
963 // CHECK-DAG: for (int i = 0;
964 // CHECK-DAG: [B3.[[#PFB+3]]];
965 #pragma omp parallel loop if(cond) firstprivate(fp) reduction(&:rd)
966 for (int i = 0; i < 10; ++i)
967 argc = x;
968 }
969
970 // CHECK-LABEL: void targetparallelloop(int argc)
targetparallelloop(int argc)971 void targetparallelloop(int argc) {
972 int x, cond, fp, rd, map;
973 // CHECK-DAG: [B3]
974 // CHECK-DAG: [[#TTDB:]]: x
975 // CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
976 // CHECK-DAG: [[#TTDB+2]]: argc
977 // CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
978 // CHECK-DAG: [B1]
979 // CHECK-DAG: [[#TTD:]]: cond
980 // CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
981 // CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
982 // CHECK-DAG: [[#TTD+3]]: fp
983 // CHECK-DAG: [[#TTD+4]]: rd
984 // CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
985 // CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
986 // CHECK-DAG: [[#TTD+7]]: #pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
987 // CHECK-DAG: for (int i = 0;
988 // CHECK-DAG: [B3.[[#TTDB+3]]];
989 #pragma omp target parallel loop if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
990 for (int i = 0; i < 10; ++i)
991 argc = x;
992 }
993
994 // CHECK-LABEL: void parallelmasked(int argc)
parallelmasked(int argc)995 void parallelmasked(int argc) {
996 int x = 0;
997 // CHECK: [B1]
998 // CHECK-NEXT: 1: 0
999 // CHECK-NEXT: 2: int x = 0;
1000 // CHECK-NEXT: [[#MASKED:]]: x
1001 // CHECK-NEXT: [[#MASKED+1]]: [B1.[[#MASKED]]] (ImplicitCastExpr, LValueToRValue, int)
1002 // CHECK-NEXT: [[#MASKED+2]]: argc
1003 // CHECK-NEXT: [[#MASKED+3]]: [B1.[[#MASKED+2]]] = [B1.[[#MASKED+1]]]
1004 // CHECK-NEXT: [[#MASKED+4]]: #pragma omp parallel masked
1005 #pragma omp parallel masked
1006 argc = x;
1007 }
1008 #endif // _OPENMP
1009