1 /* { dg-do compile } */
2 /* { dg-additional-options "-std=c99" { target c } } */
3
4 typedef enum omp_allocator_handle_t
5 #if __cplusplus >= 201103L
6 : __UINTPTR_TYPE__
7 #endif
8 {
9 omp_null_allocator = 0,
10 omp_default_mem_alloc = 1,
11 omp_large_cap_mem_alloc = 2,
12 omp_const_mem_alloc = 3,
13 omp_high_bw_mem_alloc = 4,
14 omp_low_lat_mem_alloc = 5,
15 omp_cgroup_mem_alloc = 6,
16 omp_pteam_mem_alloc = 7,
17 omp_thread_mem_alloc = 8,
18 __omp_allocator_handle_t_max__ = __UINTPTR_MAX__
19 } omp_allocator_handle_t;
20
21 typedef enum omp_sync_hint_t {
22 omp_sync_hint_none = 0x0,
23 omp_lock_hint_none = omp_sync_hint_none,
24 omp_sync_hint_uncontended = 0x1,
25 omp_lock_hint_uncontended = omp_sync_hint_uncontended,
26 omp_sync_hint_contended = 0x2,
27 omp_lock_hint_contended = omp_sync_hint_contended,
28 omp_sync_hint_nonspeculative = 0x4,
29 omp_lock_hint_nonspeculative = omp_sync_hint_nonspeculative,
30 omp_sync_hint_speculative = 0x8,
31 omp_lock_hint_speculative = omp_sync_hint_speculative
32 } omp_sync_hint_t;
33
34 typedef struct __attribute__((__aligned__ (sizeof (void *)))) omp_depend_t {
35 char __omp_depend_t__[2 * sizeof (void *)];
36 } omp_depend_t;
37
38 int t;
39 #pragma omp threadprivate (t)
40
41 #pragma omp declare target
42 int f, l, ll, r, r2;
43
44 void
45 foo (int d, int m, int i1, int i2, int p, int *idp, int s,
46 int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm)
47 {
48 #pragma omp distribute parallel for, \
49 private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \
50 if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
51 lastprivate (l), schedule(static, 4), order(concurrent), allocate (omp_default_mem_alloc:f)
52 for (int i = 0; i < 64; i++)
53 ll++;
54 #pragma omp distribute parallel for simd, \
55 private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \
56 if (parallel: i2), if(simd: i1), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
57 lastprivate (l), schedule(static, 4), nontemporal(ntm), \
58 safelen(8), simdlen(4), aligned(q: 32), order(concurrent), allocate (omp_default_mem_alloc:f)
59 for (int i = 0; i < 64; i++)
60 ll++;
61 #pragma omp distribute simd, \
62 private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \
63 safelen(8), simdlen(4), aligned(q: 32), reduction(+:r), if(i1), nontemporal(ntm), \
64 order(concurrent), allocate (omp_default_mem_alloc:f)
65 for (int i = 0; i < 64; i++)
66 ll++;
67 }
68
69 void
70 qux (int p)
71 {
72 #pragma omp loop, bind(teams), order(concurrent), \
73 private (p), lastprivate (l), collapse(1), reduction(+:r)
74 for (l = 0; l < 64; ++l)
75 ll++;
76 }
77 #pragma omp end declare target
78
79 void
80 baz (int d, int m, int i1, int i2, int p, int *idp, int s,
81 int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm)
82 {
83 #pragma omp distribute parallel for, \
84 private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \
85 if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
86 lastprivate (l), schedule(static, 4), copyin(t), allocate (p)
87 for (int i = 0; i < 64; i++)
88 ll++;
89 #pragma omp distribute parallel for, \
90 private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \
91 if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
92 lastprivate (l), schedule(static, 4), order(concurrent), allocate (p)
93 for (int i = 0; i < 64; i++)
94 ll++;
95 #pragma omp distribute parallel for simd, \
96 private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \
97 if (parallel: i2), if(simd: i1), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
98 lastprivate (l), schedule(static, 4), nontemporal(ntm), \
99 safelen(8), simdlen(4), aligned(q: 32), copyin(t), allocate (f)
100 for (int i = 0; i < 64; i++)
101 ll++;
102 #pragma omp distribute parallel for simd, \
103 private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \
104 if (parallel: i2), if(simd: i1), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
105 lastprivate (l), schedule(static, 4), nontemporal(ntm), \
106 safelen(8), simdlen(4), aligned(q: 32), order(concurrent), allocate (f)
107 for (int i = 0; i < 64; i++)
108 ll++;
109 #pragma omp distribute simd, \
110 private (p), firstprivate (f), collapse(1), dist_schedule(static, 16), \
111 safelen(8), simdlen(4), aligned(q: 32), reduction(+:r), if(i1), nontemporal(ntm), \
112 order(concurrent), allocate (f)
113 for (int i = 0; i < 64; i++)
114 ll++;
115 #pragma omp loop, bind(parallel), order(concurrent), \
116 private (p), lastprivate (l), collapse(1), reduction(+:r)
117 for (l = 0; l < 64; ++l)
118 ll++;
119 }
120
121 void
122 bar (int d, int m, int i1, int i2, int i3, int p, int *idp, int hda, int s,
123 int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int *dd, int ntm,
124 int n1, int n2)
125 {
126 #pragma omp for simd, \
127 private (p), firstprivate (f), lastprivate (l), linear (ll:1), reduction(+:r), schedule(static, 4), collapse(1), nowait, \
128 safelen(8), simdlen(4), aligned(q: 32), nontemporal(ntm), if(i1), order(concurrent), allocate (f)
129 for (int i = 0; i < 64; i++)
130 ll++;
131 #pragma omp parallel for, \
132 private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \
133 lastprivate (l), linear (ll:1), ordered, schedule(static, 4), collapse(1), allocate (f)
134 for (int i = 0; i < 64; i++)
135 ll++;
136 #pragma omp parallel for, \
137 private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \
138 lastprivate (l), linear (ll:1), schedule(static, 4), collapse(1), order(concurrent), allocate (f)
139 for (int i = 0; i < 64; i++)
140 ll++;
141 #pragma omp parallel for simd, \
142 private (p), firstprivate (f), if (i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \
143 lastprivate (l), linear (ll:1), schedule(static, 4), collapse(1), \
144 safelen(8), simdlen(4), aligned(q: 32), nontemporal(ntm), order(concurrent), allocate (f)
145 for (int i = 0; i < 64; i++)
146 ll++;
147 #pragma omp parallel sections, \
148 private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \
149 lastprivate (l), allocate (f)
150 {
151 #pragma omp section
152 {}
153 #pragma omp section
154 {}
155 }
156 #pragma omp target parallel, \
157 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
158 if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
159 nowait, depend(inout: dd[0]), allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda)
160 ;
161 #pragma omp target parallel for, \
162 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
163 if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
164 lastprivate (l), linear (ll:1), ordered, schedule(static, 4), collapse(1), nowait, depend(inout: dd[0]), \
165 allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda)
166 for (int i = 0; i < 64; i++)
167 ll++;
168 #pragma omp target parallel for, \
169 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
170 if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
171 lastprivate (l), linear (ll:1), schedule(static, 4), collapse(1), nowait, depend(inout: dd[0]), order(concurrent), \
172 allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda)
173 for (int i = 0; i < 64; i++)
174 ll++;
175 #pragma omp target parallel for simd, \
176 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
177 if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
178 lastprivate (l), linear (ll:1), schedule(static, 4), collapse(1), \
179 safelen(8), simdlen(4), aligned(q: 32), nowait, depend(inout: dd[0]), nontemporal(ntm), if (simd: i3), order(concurrent), \
180 allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda)
181 for (int i = 0; i < 64; i++)
182 ll++;
183 #pragma omp target teams, \
184 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
185 shared(s), default(shared), reduction(+:r), num_teams(nte - 1:nte), thread_limit(tl), nowait depend(inout: dd[0]), \
186 allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda)
187 ;
188 #pragma omp target teams distribute, \
189 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
190 shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), order(concurrent), \
191 collapse(1), dist_schedule(static, 16), nowait, depend(inout: dd[0]), allocate (omp_default_mem_alloc:f), in_reduction(+:r2), \
192 has_device_addr(hda)
193 for (int i = 0; i < 64; i++)
194 ;
195 #pragma omp target teams distribute parallel for, \
196 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
197 shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \
198 collapse(1), dist_schedule(static, 16), \
199 if (parallel: i2), num_threads (nth), proc_bind(spread), \
200 lastprivate (l), schedule(static, 4), nowait, depend(inout: dd[0]), order(concurrent), \
201 allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda)
202 for (int i = 0; i < 64; i++)
203 ll++;
204 #pragma omp target teams distribute parallel for simd, \
205 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
206 shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \
207 collapse(1), dist_schedule(static, 16), \
208 if (parallel: i2), num_threads (nth), proc_bind(spread), \
209 lastprivate (l), schedule(static, 4), order(concurrent), \
210 safelen(8), simdlen(4), aligned(q: 32), nowait, depend(inout: dd[0]), nontemporal(ntm), if (simd: i3), \
211 allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda)
212 for (int i = 0; i < 64; i++)
213 ll++;
214 #pragma omp target teams distribute simd, \
215 device(d), map (tofrom: m), if (i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
216 shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \
217 collapse(1), dist_schedule(static, 16), order(concurrent), \
218 safelen(8), simdlen(4), aligned(q: 32), nowait depend(inout: dd[0]), nontemporal(ntm), \
219 allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda)
220 for (int i = 0; i < 64; i++)
221 ll++;
222 #pragma omp target simd, \
223 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
224 safelen(8), simdlen(4), lastprivate (l), linear(ll: 1), aligned(q: 32), reduction(+:r), \
225 nowait depend(inout: dd[0]), nontemporal(ntm), if(simd:i3), order(concurrent), \
226 allocate (omp_default_mem_alloc:f), in_reduction(+:r2), has_device_addr(hda)
227 for (int i = 0; i < 64; i++)
228 ll++;
229 #pragma omp taskgroup, task_reduction(+:r2), allocate (r2)
230 #pragma omp taskloop simd, \
231 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \
232 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \
233 order(concurrent), allocate (f)
234 for (int i = 0; i < 64; i++)
235 ll++;
236 #pragma omp taskgroup, task_reduction(+:r), allocate (r)
237 #pragma omp taskloop simd, \
238 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(i1), final(fi), mergeable, nogroup, priority (pp), \
239 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), in_reduction(+:r), nontemporal(ntm), \
240 order(concurrent), allocate (f)
241 for (int i = 0; i < 64; i++)
242 ll++;
243 #pragma omp taskwait
244 #pragma omp taskloop simd, \
245 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), if(taskloop: i1), final(fi), priority (pp), \
246 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(+:r), if (simd: i3), nontemporal(ntm), \
247 order(concurrent), allocate (f)
248 for (int i = 0; i < 64; i++)
249 ll++;
250 #pragma omp target, nowait, depend(inout: dd[0]), in_reduction(+:r2)
251 #pragma omp teams distribute, \
252 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \
253 collapse(1), dist_schedule(static, 16), allocate (omp_default_mem_alloc: f), order(concurrent)
254 for (int i = 0; i < 64; i++)
255 ;
256 #pragma omp target
257 #pragma omp teams distribute parallel for, \
258 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \
259 collapse(1), dist_schedule(static, 16), \
260 if (parallel: i2), num_threads (nth), proc_bind(spread), \
261 lastprivate (l), schedule(static, 4), order(concurrent), allocate (omp_default_mem_alloc: f)
262 for (int i = 0; i < 64; i++)
263 ll++;
264 #pragma omp target
265 #pragma omp teams distribute parallel for simd, \
266 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \
267 collapse(1), dist_schedule(static, 16), \
268 if (parallel: i2), num_threads (nth), proc_bind(spread), \
269 lastprivate (l), schedule(static, 4), order(concurrent), \
270 safelen(8), simdlen(4), aligned(q: 32), if (simd: i3), nontemporal(ntm), \
271 allocate (omp_default_mem_alloc: f)
272 for (int i = 0; i < 64; i++)
273 ll++;
274 #pragma omp target
275 #pragma omp teams distribute simd, \
276 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \
277 collapse(1), dist_schedule(static, 16), order(concurrent), \
278 safelen(8), simdlen(4), aligned(q: 32), if(i3), nontemporal(ntm), \
279 allocate (omp_default_mem_alloc: f)
280 for (int i = 0; i < 64; i++)
281 ll++;
282 #pragma omp teams distribute parallel for, \
283 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \
284 collapse(1), dist_schedule(static, 16), \
285 if (parallel: i2), num_threads (nth), proc_bind(spread), \
286 lastprivate (l), schedule(static, 4), copyin(t), allocate (f)
287 for (int i = 0; i < 64; i++)
288 ll++;
289 #pragma omp teams distribute parallel for, \
290 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \
291 collapse(1), dist_schedule(static, 16), order(concurrent), \
292 if (parallel: i2), num_threads (nth), proc_bind(spread), \
293 lastprivate (l), schedule(static, 4), allocate (f)
294 for (int i = 0; i < 64; i++)
295 ll++;
296 #pragma omp teams distribute parallel for simd, \
297 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \
298 collapse(1), dist_schedule(static, 16), \
299 if (parallel: i2), num_threads (nth), proc_bind(spread), \
300 lastprivate (l), schedule(static, 4), \
301 safelen(8), simdlen(4), aligned(q: 32), if (simd: i3), nontemporal(ntm), copyin(t), \
302 allocate (f)
303 for (int i = 0; i < 64; i++)
304 ll++;
305 #pragma omp teams distribute parallel for simd, \
306 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \
307 collapse(1), dist_schedule(static, 16), \
308 if (parallel: i2), num_threads (nth), proc_bind(spread), \
309 lastprivate (l), schedule(static, 4), order(concurrent), \
310 safelen(8), simdlen(4), aligned(q: 32), if (simd: i3), nontemporal(ntm), \
311 allocate (f)
312 for (int i = 0; i < 64; i++)
313 ll++;
314 #pragma omp teams distribute simd, \
315 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \
316 collapse(1), dist_schedule(static, 16), order(concurrent), \
317 safelen(8), simdlen(4), aligned(q: 32), if(i3), nontemporal(ntm), allocate(f)
318 for (int i = 0; i < 64; i++)
319 ll++;
320 #pragma omp parallel master, \
321 private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), reduction(+:r), \
322 num_threads (nth), proc_bind(spread), copyin(t), allocate (f)
323 ;
324 #pragma omp parallel masked, \
325 private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), reduction(+:r), \
326 num_threads (nth), proc_bind(spread), copyin(t), allocate (f), filter (d)
327 ;
328 #pragma omp taskgroup, task_reduction (+:r2), allocate (r2)
329 #pragma omp master taskloop, \
330 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), final(fi), mergeable, priority (pp), \
331 reduction(default, +:r), in_reduction(+:r2), allocate (f)
332 for (int i = 0; i < 64; i++)
333 ll++;
334 #pragma omp taskgroup, task_reduction (+:r2), allocate (r2)
335 #pragma omp masked taskloop, \
336 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), final(fi), mergeable, priority (pp), \
337 reduction(default, +:r), in_reduction(+:r2), allocate (f), filter (d)
338 for (int i = 0; i < 64; i++)
339 ll++;
340 #pragma omp taskgroup, task_reduction (+:r2), allocate (r2)
341 #pragma omp master taskloop simd, \
342 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \
343 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \
344 order(concurrent), allocate (f)
345 for (int i = 0; i < 64; i++)
346 ll++;
347 #pragma omp taskgroup, task_reduction (+:r2), allocate (r2)
348 #pragma omp masked taskloop simd, \
349 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \
350 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \
351 order(concurrent), allocate (f), filter (d)
352 for (int i = 0; i < 64; i++)
353 ll++;
354 #pragma omp parallel master taskloop, \
355 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), final(fi), mergeable, priority (pp), \
356 reduction(default, +:r), if (parallel: i2), num_threads (nth), proc_bind(spread), copyin(t), allocate (f)
357 for (int i = 0; i < 64; i++)
358 ll++;
359 #pragma omp parallel masked taskloop, \
360 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), final(fi), mergeable, priority (pp), \
361 reduction(default, +:r), if (parallel: i2), num_threads (nth), proc_bind(spread), copyin(t), allocate (f), filter (d)
362 for (int i = 0; i < 64; i++)
363 ll++;
364 #pragma omp parallel master taskloop simd, \
365 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \
366 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), nontemporal(ntm), if (parallel: i2), num_threads (nth), proc_bind(spread), copyin(t), \
367 order(concurrent), allocate (f)
368 for (int i = 0; i < 64; i++)
369 ll++;
370 #pragma omp parallel masked taskloop simd, \
371 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), grainsize (g), collapse(1), untied, if(taskloop: i1), if(simd: i2), final(fi), mergeable, priority (pp), \
372 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), nontemporal(ntm), if (parallel: i2), num_threads (nth), proc_bind(spread), copyin(t), \
373 order(concurrent), allocate (f), filter (d)
374 for (int i = 0; i < 64; i++)
375 ll++;
376 #pragma omp taskgroup, task_reduction (+:r2), allocate (r2)
377 #pragma omp master taskloop, \
378 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \
379 reduction(default, +:r), in_reduction(+:r2)
380 for (int i = 0; i < 64; i++)
381 ll++;
382 #pragma omp taskgroup, task_reduction (+:r2), allocate (r2)
383 #pragma omp mastked taskloop, \
384 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \
385 reduction(default, +:r), in_reduction(+:r2), filter (d)
386 for (int i = 0; i < 64; i++)
387 ll++;
388 #pragma omp taskgroup, task_reduction (+:r2), allocate (r2)
389 #pragma omp master taskloop simd, \
390 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \
391 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \
392 order(concurrent), allocate (f)
393 for (int i = 0; i < 64; i++)
394 ll++;
395 #pragma omp taskgroup, task_reduction (+:r2), allocate (r2)
396 #pragma omp masked taskloop simd, \
397 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \
398 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), in_reduction(+:r2), nontemporal(ntm), \
399 order(concurrent), allocate (f), filter (d)
400 for (int i = 0; i < 64; i++)
401 ll++;
402 #pragma omp parallel master taskloop, \
403 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \
404 reduction(default, +:r), num_threads (nth), proc_bind(spread), copyin(t), allocate (f)
405 for (int i = 0; i < 64; i++)
406 ll++;
407 #pragma omp parallel masked taskloop, \
408 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \
409 reduction(default, +:r), num_threads (nth), proc_bind(spread), copyin(t), allocate (f), filter (d)
410 for (int i = 0; i < 64; i++)
411 ll++;
412 #pragma omp parallel master taskloop simd, \
413 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \
414 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), nontemporal(ntm), num_threads (nth), proc_bind(spread), copyin(t), \
415 order(concurrent), allocate (f)
416 for (int i = 0; i < 64; i++)
417 ll++;
418 #pragma omp parallel masked taskloop simd, \
419 private (p), firstprivate (f), lastprivate (l), shared (s), default(shared), num_tasks (nta), collapse(1), untied, if(i1), final(fi), mergeable, priority (pp), \
420 safelen(8), simdlen(4), linear(ll: 1), aligned(q: 32), reduction(default, +:r), nontemporal(ntm), num_threads (nth), proc_bind(spread), copyin(t), \
421 order(concurrent), allocate (f), filter (d)
422 for (int i = 0; i < 64; i++)
423 ll++;
424 #pragma omp loop, bind(thread), order(concurrent), \
425 private (p), lastprivate (l), collapse(1), reduction(+:r)
426 for (l = 0; l < 64; ++l)
427 ll++;
428 #pragma omp parallel loop, \
429 private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \
430 lastprivate (l), collapse(1), bind(parallel), order(concurrent), allocate (f)
431 for (l = 0; l < 64; l++)
432 ll++;
433 #pragma omp parallel loop, \
434 private (p), firstprivate (f), if (parallel: i2), default(shared), shared(s), copyin(t), reduction(+:r), num_threads (nth), proc_bind(spread), \
435 lastprivate (l), collapse(1), allocate (f)
436 for (l = 0; l < 64; l++)
437 ll++;
438 #pragma omp teams loop, \
439 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), \
440 collapse(1), lastprivate (l), bind(teams), allocate (f)
441 for (l = 0; l < 64; ++l)
442 ;
443 #pragma omp teams loop, \
444 private(p), firstprivate (f), shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), \
445 collapse(1), lastprivate (l), order(concurrent), allocate (f)
446 for (l = 0; l < 64; ++l)
447 ;
448 #pragma omp target parallel loop, \
449 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
450 if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
451 nowait depend(inout: dd[0]), lastprivate (l), bind(parallel), order(concurrent), collapse(1), \
452 allocate (omp_default_mem_alloc: f), in_reduction(+:r2), has_device_addr(hda)
453 for (l = 0; l < 64; ++l)
454 ;
455 #pragma omp target parallel loop, \
456 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
457 if (parallel: i2), default(shared), shared(s), reduction(+:r), num_threads (nth), proc_bind(spread), \
458 nowait depend(inout: dd[0]), lastprivate (l), order(concurrent), collapse(1), \
459 allocate (omp_default_mem_alloc: f), in_reduction(+:r2), has_device_addr(hda)
460 for (l = 0; l < 64; ++l)
461 ;
462 #pragma omp target teams loop, \
463 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
464 shared(s), default(shared), reduction(+:r), num_teams(nte-1:nte), thread_limit(tl), nowait depend(inout: dd[0]), \
465 lastprivate (l), bind(teams), collapse(1), \
466 allocate (omp_default_mem_alloc: f), in_reduction(+:r2), has_device_addr(hda)
467 for (l = 0; l < 64; ++l)
468 ;
469 #pragma omp target teams loop, \
470 device(d), map (tofrom: m), if (target: i1), private (p), firstprivate (f), defaultmap(tofrom: scalar), is_device_ptr (idp), \
471 shared(s), default(shared), reduction(+:r), num_teams(nte), thread_limit(tl), nowait depend(inout: dd[0]), \
472 lastprivate (l), order(concurrent), collapse(1), \
473 allocate (omp_default_mem_alloc: f), in_reduction(+:r2), has_device_addr(hda)
474 for (l = 0; l < 64; ++l)
475 ;
476 #pragma omp critical
477 ;
478 #pragma omp critical (foobar),hint(omp_sync_hint_none)
479 ;
480 #pragma omp taskwait, depend (inout: dd[0])
481 ;
482 #pragma omp taskgroup, task_reduction(+:r2),allocate (r2)
483 ;
484 #pragma omp atomic, update,seq_cst,hint(omp_sync_hint_none)
485 p++;
486 #pragma omp atomic, read, hint(omp_sync_hint_none),relaxed
487 f = p;
488 #pragma omp atomic,write, release hint(omp_sync_hint_none)
489 p = f;
490 #pragma omp flush
491 ;
492 #pragma omp flush, acq_rel
493 ;
494 #pragma omp flush, acquire
495 ;
496 #pragma omp flush, release
497 ;
498 #pragma omp flush, seq_cst
499 ;
500 #pragma omp flush (p, f)
501 ;
502 #pragma omp simd, \
503 private (p),lastprivate (l),linear (ll:1),reduction(+:r),collapse(1),safelen(8),simdlen(4),aligned(q: 32), \
504 nontemporal(ntm),if(i1)
505 for (int i = 0; i < 64; i++)
506 #pragma omp ordered, simd
507 ll++;
508 #pragma omp for, \
509 private (p),firstprivate (f),lastprivate (l),linear (ll:1),reduction(+:r),schedule(static, 4),collapse(1),nowait, \
510 ordered, allocate (f)
511 for (int i = 0; i < 64; i++)
512 #pragma omp ordered, threads
513 ll++;
514 #pragma omp for, ordered (1)
515 for (l = 0; l < 64; l++)
516 {
517 #pragma omp ordered, depend (sink: l - 1)
518 ;
519 #pragma omp ordered, depend (source)
520 ;
521 }
522 extern omp_depend_t depobj;
523 #pragma omp depobj(depobj),depend(in : dd[0])
524 ;
525 #pragma omp parallel
526 {
527 if (p) {
528 #pragma omp cancel, parallel
529 ;
530 } else {
531 #pragma omp cancellation point, parallel
532 ;
533 }
534 }
535 #pragma omp scope, private (p), firstprivate (f), reduction(+:r), nowait, \
536 allocate(omp_default_mem_alloc: r)
537 ;
538 #pragma omp scope, private (p), firstprivate (f), reduction(task, +:r), \
539 allocate (omp_default_mem_alloc: f)
540 ;
541 extern int t2;
542 #pragma omp threadprivate (t2)
543 extern int t2;
544 #pragma omp declare reduction (dr: int: omp_out += omp_in),initializer (omp_priv = 0)
545 #pragma omp assume, no_openmp, no_openmp_routines, no_parallelism, \
546 absent (atomic, barrier, cancel, cancellation point), \
547 absent (critical, depobj), \
548 absent (distribute, flush, loop, masked, master, nothing, ordered), \
549 absent (parallel, scan, scope, section, sections, simd, single, task), \
550 absent (taskgroup, taskloop, taskwait, taskyield), \
551 absent (target, teams, for, error), holds (n1 < n2)
552 if (0)
553 ;
554 #pragma omp assume, contains (simd)
555 #pragma omp for simd
556 for (int i = 0; i < 64; i++)
557 ;
558 }
559
560 void corge1 ();
561
562 void
563 corge ()
564 {
565 #pragma omp declare variant (corge1),match (construct={parallel,for})
566 extern void corge2 ();
567 #pragma omp parallel
568 #pragma omp for
569 for (int i = 0; i < 5; i++)
570 corge2 ();
571 #pragma omp declare simd, simdlen(4),linear(l),aligned(p:4),uniform(p),inbranch
572 #pragma omp declare simd,simdlen(8),notinbranch
573 extern int corge3 (int l, int *p);
574 #pragma omp declare simd, simdlen(4),linear(l),aligned(p:4),uniform(p),inbranch
575 #pragma omp declare simd, simdlen(8),notinbranch
576 extern int corge4 (int l, int *p);
577 #pragma omp declare simd, simdlen(4),linear(l),aligned(p:4),uniform(p),inbranch
578 #pragma omp declare simd, simdlen(8),notinbranch
579 extern int corge5 (int l, int *p);
580 #pragma omp declare target
581 extern void corge6 ();
582 #pragma omp end declare target
583 }
584
585 int
586 garply (int a, int *c, int *d, int *e, int *f)
587 {
588 int i;
589 #pragma omp simd, reduction (inscan, +: a)
590 for (i = 0; i < 64; i++)
591 {
592 d[i] = a;
593 #pragma omp scan, exclusive (a)
594 a += c[i];
595 }
596 #pragma omp simd, reduction (inscan, +: a)
597 for (i = 0; i < 64; i++)
598 {
599 a += c[i];
600 #pragma omp scan inclusive (a)
601 d[i] = a;
602 }
603 return a;
604 }