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