Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
14 pmbaty 1
#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
2
#undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
3
 
4
namespace llvm {
5
namespace omp {
6
 
7
  // Sets for allocate
8
 
9
  static OmpClauseSet allowedClauses_OMPD_allocate {
10
  };
11
 
12
  static OmpClauseSet allowedOnceClauses_OMPD_allocate {
13
    llvm::omp::Clause::OMPC_allocator,
14
    llvm::omp::Clause::OMPC_align,
15
  };
16
 
17
  static OmpClauseSet allowedExclusiveClauses_OMPD_allocate {
18
  };
19
 
20
  static OmpClauseSet requiredClauses_OMPD_allocate {
21
  };
22
 
23
  // Sets for assumes
24
 
25
  static OmpClauseSet allowedClauses_OMPD_assumes {
26
  };
27
 
28
  static OmpClauseSet allowedOnceClauses_OMPD_assumes {
29
  };
30
 
31
  static OmpClauseSet allowedExclusiveClauses_OMPD_assumes {
32
  };
33
 
34
  static OmpClauseSet requiredClauses_OMPD_assumes {
35
  };
36
 
37
  // Sets for atomic
38
 
39
  static OmpClauseSet allowedClauses_OMPD_atomic {
40
    llvm::omp::Clause::OMPC_read,
41
    llvm::omp::Clause::OMPC_write,
42
    llvm::omp::Clause::OMPC_update,
43
    llvm::omp::Clause::OMPC_capture,
44
    llvm::omp::Clause::OMPC_compare,
45
  };
46
 
47
  static OmpClauseSet allowedOnceClauses_OMPD_atomic {
48
    llvm::omp::Clause::OMPC_seq_cst,
49
    llvm::omp::Clause::OMPC_acq_rel,
50
    llvm::omp::Clause::OMPC_acquire,
51
    llvm::omp::Clause::OMPC_release,
52
    llvm::omp::Clause::OMPC_relaxed,
53
    llvm::omp::Clause::OMPC_hint,
54
  };
55
 
56
  static OmpClauseSet allowedExclusiveClauses_OMPD_atomic {
57
  };
58
 
59
  static OmpClauseSet requiredClauses_OMPD_atomic {
60
  };
61
 
62
  // Sets for barrier
63
 
64
  static OmpClauseSet allowedClauses_OMPD_barrier {
65
  };
66
 
67
  static OmpClauseSet allowedOnceClauses_OMPD_barrier {
68
  };
69
 
70
  static OmpClauseSet allowedExclusiveClauses_OMPD_barrier {
71
  };
72
 
73
  static OmpClauseSet requiredClauses_OMPD_barrier {
74
  };
75
 
76
  // Sets for begin assumes
77
 
78
  static OmpClauseSet allowedClauses_OMPD_begin_assumes {
79
  };
80
 
81
  static OmpClauseSet allowedOnceClauses_OMPD_begin_assumes {
82
  };
83
 
84
  static OmpClauseSet allowedExclusiveClauses_OMPD_begin_assumes {
85
  };
86
 
87
  static OmpClauseSet requiredClauses_OMPD_begin_assumes {
88
  };
89
 
90
  // Sets for begin declare target
91
 
92
  static OmpClauseSet allowedClauses_OMPD_begin_declare_target {
93
    llvm::omp::Clause::OMPC_to,
94
    llvm::omp::Clause::OMPC_link,
95
    llvm::omp::Clause::OMPC_device_type,
96
    llvm::omp::Clause::OMPC_indirect,
97
  };
98
 
99
  static OmpClauseSet allowedOnceClauses_OMPD_begin_declare_target {
100
  };
101
 
102
  static OmpClauseSet allowedExclusiveClauses_OMPD_begin_declare_target {
103
  };
104
 
105
  static OmpClauseSet requiredClauses_OMPD_begin_declare_target {
106
  };
107
 
108
  // Sets for begin declare variant
109
 
110
  static OmpClauseSet allowedClauses_OMPD_begin_declare_variant {
111
  };
112
 
113
  static OmpClauseSet allowedOnceClauses_OMPD_begin_declare_variant {
114
  };
115
 
116
  static OmpClauseSet allowedExclusiveClauses_OMPD_begin_declare_variant {
117
  };
118
 
119
  static OmpClauseSet requiredClauses_OMPD_begin_declare_variant {
120
  };
121
 
122
  // Sets for cancel
123
 
124
  static OmpClauseSet allowedClauses_OMPD_cancel {
125
    llvm::omp::Clause::OMPC_if,
126
  };
127
 
128
  static OmpClauseSet allowedOnceClauses_OMPD_cancel {
129
  };
130
 
131
  static OmpClauseSet allowedExclusiveClauses_OMPD_cancel {
132
  };
133
 
134
  static OmpClauseSet requiredClauses_OMPD_cancel {
135
  };
136
 
137
  // Sets for cancellation point
138
 
139
  static OmpClauseSet allowedClauses_OMPD_cancellation_point {
140
  };
141
 
142
  static OmpClauseSet allowedOnceClauses_OMPD_cancellation_point {
143
  };
144
 
145
  static OmpClauseSet allowedExclusiveClauses_OMPD_cancellation_point {
146
  };
147
 
148
  static OmpClauseSet requiredClauses_OMPD_cancellation_point {
149
  };
150
 
151
  // Sets for critical
152
 
153
  static OmpClauseSet allowedClauses_OMPD_critical {
154
    llvm::omp::Clause::OMPC_hint,
155
  };
156
 
157
  static OmpClauseSet allowedOnceClauses_OMPD_critical {
158
  };
159
 
160
  static OmpClauseSet allowedExclusiveClauses_OMPD_critical {
161
  };
162
 
163
  static OmpClauseSet requiredClauses_OMPD_critical {
164
  };
165
 
166
  // Sets for declare mapper
167
 
168
  static OmpClauseSet allowedClauses_OMPD_declare_mapper {
169
    llvm::omp::Clause::OMPC_map,
170
  };
171
 
172
  static OmpClauseSet allowedOnceClauses_OMPD_declare_mapper {
173
  };
174
 
175
  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_mapper {
176
  };
177
 
178
  static OmpClauseSet requiredClauses_OMPD_declare_mapper {
179
  };
180
 
181
  // Sets for declare reduction
182
 
183
  static OmpClauseSet allowedClauses_OMPD_declare_reduction {
184
  };
185
 
186
  static OmpClauseSet allowedOnceClauses_OMPD_declare_reduction {
187
  };
188
 
189
  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_reduction {
190
  };
191
 
192
  static OmpClauseSet requiredClauses_OMPD_declare_reduction {
193
  };
194
 
195
  // Sets for declare simd
196
 
197
  static OmpClauseSet allowedClauses_OMPD_declare_simd {
198
    llvm::omp::Clause::OMPC_linear,
199
    llvm::omp::Clause::OMPC_aligned,
200
    llvm::omp::Clause::OMPC_uniform,
201
  };
202
 
203
  static OmpClauseSet allowedOnceClauses_OMPD_declare_simd {
204
    llvm::omp::Clause::OMPC_simdlen,
205
  };
206
 
207
  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_simd {
208
    llvm::omp::Clause::OMPC_inbranch,
209
    llvm::omp::Clause::OMPC_notinbranch,
210
  };
211
 
212
  static OmpClauseSet requiredClauses_OMPD_declare_simd {
213
  };
214
 
215
  // Sets for declare target
216
 
217
  static OmpClauseSet allowedClauses_OMPD_declare_target {
218
    llvm::omp::Clause::OMPC_to,
219
    llvm::omp::Clause::OMPC_link,
220
    llvm::omp::Clause::OMPC_indirect,
221
  };
222
 
223
  static OmpClauseSet allowedOnceClauses_OMPD_declare_target {
224
  };
225
 
226
  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_target {
227
  };
228
 
229
  static OmpClauseSet requiredClauses_OMPD_declare_target {
230
  };
231
 
232
  // Sets for declare variant
233
 
234
  static OmpClauseSet allowedClauses_OMPD_declare_variant {
235
    llvm::omp::Clause::OMPC_match,
236
  };
237
 
238
  static OmpClauseSet allowedOnceClauses_OMPD_declare_variant {
239
  };
240
 
241
  static OmpClauseSet allowedExclusiveClauses_OMPD_declare_variant {
242
    llvm::omp::Clause::OMPC_adjust_args,
243
    llvm::omp::Clause::OMPC_append_args,
244
  };
245
 
246
  static OmpClauseSet requiredClauses_OMPD_declare_variant {
247
  };
248
 
249
  // Sets for depobj
250
 
251
  static OmpClauseSet allowedClauses_OMPD_depobj {
252
    llvm::omp::Clause::OMPC_depend,
253
    llvm::omp::Clause::OMPC_destroy,
254
    llvm::omp::Clause::OMPC_update,
255
    llvm::omp::Clause::OMPC_depobj,
256
  };
257
 
258
  static OmpClauseSet allowedOnceClauses_OMPD_depobj {
259
  };
260
 
261
  static OmpClauseSet allowedExclusiveClauses_OMPD_depobj {
262
  };
263
 
264
  static OmpClauseSet requiredClauses_OMPD_depobj {
265
  };
266
 
267
  // Sets for distribute
268
 
269
  static OmpClauseSet allowedClauses_OMPD_distribute {
270
    llvm::omp::Clause::OMPC_private,
271
    llvm::omp::Clause::OMPC_firstprivate,
272
    llvm::omp::Clause::OMPC_lastprivate,
273
    llvm::omp::Clause::OMPC_allocate,
274
  };
275
 
276
  static OmpClauseSet allowedOnceClauses_OMPD_distribute {
277
    llvm::omp::Clause::OMPC_collapse,
278
    llvm::omp::Clause::OMPC_dist_schedule,
279
  };
280
 
281
  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute {
282
  };
283
 
284
  static OmpClauseSet requiredClauses_OMPD_distribute {
285
  };
286
 
287
  // Sets for distribute parallel do
288
 
289
  static OmpClauseSet allowedClauses_OMPD_distribute_parallel_do {
290
    llvm::omp::Clause::OMPC_private,
291
    llvm::omp::Clause::OMPC_firstprivate,
292
    llvm::omp::Clause::OMPC_lastprivate,
293
    llvm::omp::Clause::OMPC_allocate,
294
    llvm::omp::Clause::OMPC_order,
295
    llvm::omp::Clause::OMPC_default,
296
    llvm::omp::Clause::OMPC_shared,
297
    llvm::omp::Clause::OMPC_reduction,
298
    llvm::omp::Clause::OMPC_copyin,
299
    llvm::omp::Clause::OMPC_linear,
300
  };
301
 
302
  static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_do {
303
    llvm::omp::Clause::OMPC_collapse,
304
    llvm::omp::Clause::OMPC_dist_schedule,
305
    llvm::omp::Clause::OMPC_if,
306
    llvm::omp::Clause::OMPC_num_threads,
307
    llvm::omp::Clause::OMPC_proc_bind,
308
    llvm::omp::Clause::OMPC_schedule,
309
    llvm::omp::Clause::OMPC_ordered,
310
  };
311
 
312
  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_do {
313
  };
314
 
315
  static OmpClauseSet requiredClauses_OMPD_distribute_parallel_do {
316
  };
317
 
318
  // Sets for distribute parallel do simd
319
 
320
  static OmpClauseSet allowedClauses_OMPD_distribute_parallel_do_simd {
321
    llvm::omp::Clause::OMPC_firstprivate,
322
    llvm::omp::Clause::OMPC_lastprivate,
323
    llvm::omp::Clause::OMPC_collapse,
324
    llvm::omp::Clause::OMPC_dist_schedule,
325
    llvm::omp::Clause::OMPC_if,
326
    llvm::omp::Clause::OMPC_num_threads,
327
    llvm::omp::Clause::OMPC_default,
328
    llvm::omp::Clause::OMPC_proc_bind,
329
    llvm::omp::Clause::OMPC_private,
330
    llvm::omp::Clause::OMPC_shared,
331
    llvm::omp::Clause::OMPC_reduction,
332
    llvm::omp::Clause::OMPC_copyin,
333
    llvm::omp::Clause::OMPC_schedule,
334
    llvm::omp::Clause::OMPC_linear,
335
    llvm::omp::Clause::OMPC_aligned,
336
    llvm::omp::Clause::OMPC_safelen,
337
    llvm::omp::Clause::OMPC_simdlen,
338
    llvm::omp::Clause::OMPC_allocate,
339
    llvm::omp::Clause::OMPC_nontemporal,
340
    llvm::omp::Clause::OMPC_order,
341
  };
342
 
343
  static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_do_simd {
344
  };
345
 
346
  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_do_simd {
347
  };
348
 
349
  static OmpClauseSet requiredClauses_OMPD_distribute_parallel_do_simd {
350
  };
351
 
352
  // Sets for distribute parallel for
353
 
354
  static OmpClauseSet allowedClauses_OMPD_distribute_parallel_for {
355
    llvm::omp::Clause::OMPC_firstprivate,
356
    llvm::omp::Clause::OMPC_lastprivate,
357
    llvm::omp::Clause::OMPC_collapse,
358
    llvm::omp::Clause::OMPC_dist_schedule,
359
    llvm::omp::Clause::OMPC_if,
360
    llvm::omp::Clause::OMPC_num_threads,
361
    llvm::omp::Clause::OMPC_default,
362
    llvm::omp::Clause::OMPC_proc_bind,
363
    llvm::omp::Clause::OMPC_private,
364
    llvm::omp::Clause::OMPC_shared,
365
    llvm::omp::Clause::OMPC_reduction,
366
    llvm::omp::Clause::OMPC_copyin,
367
    llvm::omp::Clause::OMPC_schedule,
368
    llvm::omp::Clause::OMPC_allocate,
369
    llvm::omp::Clause::OMPC_order,
370
  };
371
 
372
  static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_for {
373
  };
374
 
375
  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_for {
376
  };
377
 
378
  static OmpClauseSet requiredClauses_OMPD_distribute_parallel_for {
379
  };
380
 
381
  // Sets for distribute parallel for simd
382
 
383
  static OmpClauseSet allowedClauses_OMPD_distribute_parallel_for_simd {
384
    llvm::omp::Clause::OMPC_firstprivate,
385
    llvm::omp::Clause::OMPC_lastprivate,
386
    llvm::omp::Clause::OMPC_collapse,
387
    llvm::omp::Clause::OMPC_dist_schedule,
388
    llvm::omp::Clause::OMPC_if,
389
    llvm::omp::Clause::OMPC_num_threads,
390
    llvm::omp::Clause::OMPC_default,
391
    llvm::omp::Clause::OMPC_proc_bind,
392
    llvm::omp::Clause::OMPC_private,
393
    llvm::omp::Clause::OMPC_shared,
394
    llvm::omp::Clause::OMPC_reduction,
395
    llvm::omp::Clause::OMPC_copyin,
396
    llvm::omp::Clause::OMPC_schedule,
397
    llvm::omp::Clause::OMPC_linear,
398
    llvm::omp::Clause::OMPC_aligned,
399
    llvm::omp::Clause::OMPC_safelen,
400
    llvm::omp::Clause::OMPC_simdlen,
401
    llvm::omp::Clause::OMPC_allocate,
402
    llvm::omp::Clause::OMPC_nontemporal,
403
    llvm::omp::Clause::OMPC_order,
404
  };
405
 
406
  static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_for_simd {
407
  };
408
 
409
  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_for_simd {
410
  };
411
 
412
  static OmpClauseSet requiredClauses_OMPD_distribute_parallel_for_simd {
413
  };
414
 
415
  // Sets for distribute simd
416
 
417
  static OmpClauseSet allowedClauses_OMPD_distribute_simd {
418
    llvm::omp::Clause::OMPC_aligned,
419
    llvm::omp::Clause::OMPC_allocate,
420
    llvm::omp::Clause::OMPC_copyin,
421
    llvm::omp::Clause::OMPC_default,
422
    llvm::omp::Clause::OMPC_linear,
423
    llvm::omp::Clause::OMPC_firstprivate,
424
    llvm::omp::Clause::OMPC_lastprivate,
425
    llvm::omp::Clause::OMPC_nontemporal,
426
    llvm::omp::Clause::OMPC_order,
427
    llvm::omp::Clause::OMPC_private,
428
    llvm::omp::Clause::OMPC_reduction,
429
  };
430
 
431
  static OmpClauseSet allowedOnceClauses_OMPD_distribute_simd {
432
    llvm::omp::Clause::OMPC_collapse,
433
    llvm::omp::Clause::OMPC_dist_schedule,
434
    llvm::omp::Clause::OMPC_if,
435
    llvm::omp::Clause::OMPC_num_threads,
436
    llvm::omp::Clause::OMPC_ordered,
437
    llvm::omp::Clause::OMPC_proc_bind,
438
    llvm::omp::Clause::OMPC_schedule,
439
    llvm::omp::Clause::OMPC_safelen,
440
    llvm::omp::Clause::OMPC_simdlen,
441
  };
442
 
443
  static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_simd {
444
  };
445
 
446
  static OmpClauseSet requiredClauses_OMPD_distribute_simd {
447
  };
448
 
449
  // Sets for do
450
 
451
  static OmpClauseSet allowedClauses_OMPD_do {
452
    llvm::omp::Clause::OMPC_private,
453
    llvm::omp::Clause::OMPC_firstprivate,
454
    llvm::omp::Clause::OMPC_lastprivate,
455
    llvm::omp::Clause::OMPC_linear,
456
    llvm::omp::Clause::OMPC_reduction,
457
  };
458
 
459
  static OmpClauseSet allowedOnceClauses_OMPD_do {
460
    llvm::omp::Clause::OMPC_schedule,
461
    llvm::omp::Clause::OMPC_collapse,
462
    llvm::omp::Clause::OMPC_ordered,
463
    llvm::omp::Clause::OMPC_nowait,
464
  };
465
 
466
  static OmpClauseSet allowedExclusiveClauses_OMPD_do {
467
  };
468
 
469
  static OmpClauseSet requiredClauses_OMPD_do {
470
  };
471
 
472
  // Sets for do simd
473
 
474
  static OmpClauseSet allowedClauses_OMPD_do_simd {
475
    llvm::omp::Clause::OMPC_aligned,
476
    llvm::omp::Clause::OMPC_private,
477
    llvm::omp::Clause::OMPC_firstprivate,
478
    llvm::omp::Clause::OMPC_lastprivate,
479
    llvm::omp::Clause::OMPC_linear,
480
    llvm::omp::Clause::OMPC_reduction,
481
  };
482
 
483
  static OmpClauseSet allowedOnceClauses_OMPD_do_simd {
484
    llvm::omp::Clause::OMPC_schedule,
485
    llvm::omp::Clause::OMPC_collapse,
486
    llvm::omp::Clause::OMPC_ordered,
487
    llvm::omp::Clause::OMPC_safelen,
488
    llvm::omp::Clause::OMPC_simdlen,
489
    llvm::omp::Clause::OMPC_nowait,
490
  };
491
 
492
  static OmpClauseSet allowedExclusiveClauses_OMPD_do_simd {
493
  };
494
 
495
  static OmpClauseSet requiredClauses_OMPD_do_simd {
496
  };
497
 
498
  // Sets for end assumes
499
 
500
  static OmpClauseSet allowedClauses_OMPD_end_assumes {
501
  };
502
 
503
  static OmpClauseSet allowedOnceClauses_OMPD_end_assumes {
504
  };
505
 
506
  static OmpClauseSet allowedExclusiveClauses_OMPD_end_assumes {
507
  };
508
 
509
  static OmpClauseSet requiredClauses_OMPD_end_assumes {
510
  };
511
 
512
  // Sets for end declare target
513
 
514
  static OmpClauseSet allowedClauses_OMPD_end_declare_target {
515
  };
516
 
517
  static OmpClauseSet allowedOnceClauses_OMPD_end_declare_target {
518
  };
519
 
520
  static OmpClauseSet allowedExclusiveClauses_OMPD_end_declare_target {
521
  };
522
 
523
  static OmpClauseSet requiredClauses_OMPD_end_declare_target {
524
  };
525
 
526
  // Sets for end declare variant
527
 
528
  static OmpClauseSet allowedClauses_OMPD_end_declare_variant {
529
  };
530
 
531
  static OmpClauseSet allowedOnceClauses_OMPD_end_declare_variant {
532
  };
533
 
534
  static OmpClauseSet allowedExclusiveClauses_OMPD_end_declare_variant {
535
  };
536
 
537
  static OmpClauseSet requiredClauses_OMPD_end_declare_variant {
538
  };
539
 
540
  // Sets for end do
541
 
542
  static OmpClauseSet allowedClauses_OMPD_end_do {
543
  };
544
 
545
  static OmpClauseSet allowedOnceClauses_OMPD_end_do {
546
  };
547
 
548
  static OmpClauseSet allowedExclusiveClauses_OMPD_end_do {
549
  };
550
 
551
  static OmpClauseSet requiredClauses_OMPD_end_do {
552
  };
553
 
554
  // Sets for end do simd
555
 
556
  static OmpClauseSet allowedClauses_OMPD_end_do_simd {
557
  };
558
 
559
  static OmpClauseSet allowedOnceClauses_OMPD_end_do_simd {
560
  };
561
 
562
  static OmpClauseSet allowedExclusiveClauses_OMPD_end_do_simd {
563
  };
564
 
565
  static OmpClauseSet requiredClauses_OMPD_end_do_simd {
566
  };
567
 
568
  // Sets for end sections
569
 
570
  static OmpClauseSet allowedClauses_OMPD_end_sections {
571
  };
572
 
573
  static OmpClauseSet allowedOnceClauses_OMPD_end_sections {
574
    llvm::omp::Clause::OMPC_nowait,
575
  };
576
 
577
  static OmpClauseSet allowedExclusiveClauses_OMPD_end_sections {
578
  };
579
 
580
  static OmpClauseSet requiredClauses_OMPD_end_sections {
581
  };
582
 
583
  // Sets for end single
584
 
585
  static OmpClauseSet allowedClauses_OMPD_end_single {
586
    llvm::omp::Clause::OMPC_copyprivate,
587
  };
588
 
589
  static OmpClauseSet allowedOnceClauses_OMPD_end_single {
590
    llvm::omp::Clause::OMPC_nowait,
591
  };
592
 
593
  static OmpClauseSet allowedExclusiveClauses_OMPD_end_single {
594
  };
595
 
596
  static OmpClauseSet requiredClauses_OMPD_end_single {
597
  };
598
 
599
  // Sets for end workshare
600
 
601
  static OmpClauseSet allowedClauses_OMPD_end_workshare {
602
    llvm::omp::Clause::OMPC_nowait,
603
  };
604
 
605
  static OmpClauseSet allowedOnceClauses_OMPD_end_workshare {
606
  };
607
 
608
  static OmpClauseSet allowedExclusiveClauses_OMPD_end_workshare {
609
  };
610
 
611
  static OmpClauseSet requiredClauses_OMPD_end_workshare {
612
  };
613
 
614
  // Sets for error
615
 
616
  static OmpClauseSet allowedClauses_OMPD_error {
617
    llvm::omp::Clause::OMPC_at,
618
    llvm::omp::Clause::OMPC_severity,
619
    llvm::omp::Clause::OMPC_message,
620
  };
621
 
622
  static OmpClauseSet allowedOnceClauses_OMPD_error {
623
  };
624
 
625
  static OmpClauseSet allowedExclusiveClauses_OMPD_error {
626
  };
627
 
628
  static OmpClauseSet requiredClauses_OMPD_error {
629
  };
630
 
631
  // Sets for flush
632
 
633
  static OmpClauseSet allowedClauses_OMPD_flush {
634
  };
635
 
636
  static OmpClauseSet allowedOnceClauses_OMPD_flush {
637
    llvm::omp::Clause::OMPC_acq_rel,
638
    llvm::omp::Clause::OMPC_acquire,
639
    llvm::omp::Clause::OMPC_release,
640
    llvm::omp::Clause::OMPC_flush,
641
  };
642
 
643
  static OmpClauseSet allowedExclusiveClauses_OMPD_flush {
644
  };
645
 
646
  static OmpClauseSet requiredClauses_OMPD_flush {
647
  };
648
 
649
  // Sets for for
650
 
651
  static OmpClauseSet allowedClauses_OMPD_for {
652
    llvm::omp::Clause::OMPC_private,
653
    llvm::omp::Clause::OMPC_lastprivate,
654
    llvm::omp::Clause::OMPC_firstprivate,
655
    llvm::omp::Clause::OMPC_reduction,
656
    llvm::omp::Clause::OMPC_collapse,
657
    llvm::omp::Clause::OMPC_schedule,
658
    llvm::omp::Clause::OMPC_ordered,
659
    llvm::omp::Clause::OMPC_nowait,
660
    llvm::omp::Clause::OMPC_linear,
661
    llvm::omp::Clause::OMPC_allocate,
662
    llvm::omp::Clause::OMPC_order,
663
  };
664
 
665
  static OmpClauseSet allowedOnceClauses_OMPD_for {
666
  };
667
 
668
  static OmpClauseSet allowedExclusiveClauses_OMPD_for {
669
  };
670
 
671
  static OmpClauseSet requiredClauses_OMPD_for {
672
  };
673
 
674
  // Sets for for simd
675
 
676
  static OmpClauseSet allowedClauses_OMPD_for_simd {
677
    llvm::omp::Clause::OMPC_private,
678
    llvm::omp::Clause::OMPC_firstprivate,
679
    llvm::omp::Clause::OMPC_lastprivate,
680
    llvm::omp::Clause::OMPC_reduction,
681
    llvm::omp::Clause::OMPC_schedule,
682
    llvm::omp::Clause::OMPC_collapse,
683
    llvm::omp::Clause::OMPC_nowait,
684
    llvm::omp::Clause::OMPC_safelen,
685
    llvm::omp::Clause::OMPC_simdlen,
686
    llvm::omp::Clause::OMPC_linear,
687
    llvm::omp::Clause::OMPC_aligned,
688
    llvm::omp::Clause::OMPC_ordered,
689
    llvm::omp::Clause::OMPC_allocate,
690
    llvm::omp::Clause::OMPC_if,
691
    llvm::omp::Clause::OMPC_nontemporal,
692
    llvm::omp::Clause::OMPC_order,
693
  };
694
 
695
  static OmpClauseSet allowedOnceClauses_OMPD_for_simd {
696
  };
697
 
698
  static OmpClauseSet allowedExclusiveClauses_OMPD_for_simd {
699
  };
700
 
701
  static OmpClauseSet requiredClauses_OMPD_for_simd {
702
  };
703
 
704
  // Sets for masked taskloop
705
 
706
  static OmpClauseSet allowedClauses_OMPD_masked_taskloop {
707
    llvm::omp::Clause::OMPC_if,
708
    llvm::omp::Clause::OMPC_shared,
709
    llvm::omp::Clause::OMPC_private,
710
    llvm::omp::Clause::OMPC_firstprivate,
711
    llvm::omp::Clause::OMPC_lastprivate,
712
    llvm::omp::Clause::OMPC_default,
713
    llvm::omp::Clause::OMPC_collapse,
714
    llvm::omp::Clause::OMPC_final,
715
    llvm::omp::Clause::OMPC_untied,
716
    llvm::omp::Clause::OMPC_mergeable,
717
    llvm::omp::Clause::OMPC_priority,
718
    llvm::omp::Clause::OMPC_grainsize,
719
    llvm::omp::Clause::OMPC_nogroup,
720
    llvm::omp::Clause::OMPC_num_tasks,
721
    llvm::omp::Clause::OMPC_reduction,
722
    llvm::omp::Clause::OMPC_in_reduction,
723
    llvm::omp::Clause::OMPC_allocate,
724
    llvm::omp::Clause::OMPC_filter,
725
  };
726
 
727
  static OmpClauseSet allowedOnceClauses_OMPD_masked_taskloop {
728
  };
729
 
730
  static OmpClauseSet allowedExclusiveClauses_OMPD_masked_taskloop {
731
  };
732
 
733
  static OmpClauseSet requiredClauses_OMPD_masked_taskloop {
734
  };
735
 
736
  // Sets for masked taskloop simd
737
 
738
  static OmpClauseSet allowedClauses_OMPD_masked_taskloop_simd {
739
    llvm::omp::Clause::OMPC_if,
740
    llvm::omp::Clause::OMPC_shared,
741
    llvm::omp::Clause::OMPC_private,
742
    llvm::omp::Clause::OMPC_firstprivate,
743
    llvm::omp::Clause::OMPC_lastprivate,
744
    llvm::omp::Clause::OMPC_default,
745
    llvm::omp::Clause::OMPC_collapse,
746
    llvm::omp::Clause::OMPC_final,
747
    llvm::omp::Clause::OMPC_untied,
748
    llvm::omp::Clause::OMPC_mergeable,
749
    llvm::omp::Clause::OMPC_priority,
750
    llvm::omp::Clause::OMPC_linear,
751
    llvm::omp::Clause::OMPC_aligned,
752
    llvm::omp::Clause::OMPC_safelen,
753
    llvm::omp::Clause::OMPC_simdlen,
754
    llvm::omp::Clause::OMPC_grainsize,
755
    llvm::omp::Clause::OMPC_nogroup,
756
    llvm::omp::Clause::OMPC_num_tasks,
757
    llvm::omp::Clause::OMPC_reduction,
758
    llvm::omp::Clause::OMPC_in_reduction,
759
    llvm::omp::Clause::OMPC_allocate,
760
    llvm::omp::Clause::OMPC_nontemporal,
761
    llvm::omp::Clause::OMPC_order,
762
    llvm::omp::Clause::OMPC_filter,
763
  };
764
 
765
  static OmpClauseSet allowedOnceClauses_OMPD_masked_taskloop_simd {
766
  };
767
 
768
  static OmpClauseSet allowedExclusiveClauses_OMPD_masked_taskloop_simd {
769
  };
770
 
771
  static OmpClauseSet requiredClauses_OMPD_masked_taskloop_simd {
772
  };
773
 
774
  // Sets for master
775
 
776
  static OmpClauseSet allowedClauses_OMPD_master {
777
  };
778
 
779
  static OmpClauseSet allowedOnceClauses_OMPD_master {
780
  };
781
 
782
  static OmpClauseSet allowedExclusiveClauses_OMPD_master {
783
  };
784
 
785
  static OmpClauseSet requiredClauses_OMPD_master {
786
  };
787
 
788
  // Sets for master taskloop
789
 
790
  static OmpClauseSet allowedClauses_OMPD_master_taskloop {
791
    llvm::omp::Clause::OMPC_if,
792
    llvm::omp::Clause::OMPC_shared,
793
    llvm::omp::Clause::OMPC_private,
794
    llvm::omp::Clause::OMPC_firstprivate,
795
    llvm::omp::Clause::OMPC_lastprivate,
796
    llvm::omp::Clause::OMPC_default,
797
    llvm::omp::Clause::OMPC_collapse,
798
    llvm::omp::Clause::OMPC_final,
799
    llvm::omp::Clause::OMPC_untied,
800
    llvm::omp::Clause::OMPC_mergeable,
801
    llvm::omp::Clause::OMPC_priority,
802
    llvm::omp::Clause::OMPC_grainsize,
803
    llvm::omp::Clause::OMPC_nogroup,
804
    llvm::omp::Clause::OMPC_num_tasks,
805
    llvm::omp::Clause::OMPC_reduction,
806
    llvm::omp::Clause::OMPC_in_reduction,
807
    llvm::omp::Clause::OMPC_allocate,
808
  };
809
 
810
  static OmpClauseSet allowedOnceClauses_OMPD_master_taskloop {
811
  };
812
 
813
  static OmpClauseSet allowedExclusiveClauses_OMPD_master_taskloop {
814
  };
815
 
816
  static OmpClauseSet requiredClauses_OMPD_master_taskloop {
817
  };
818
 
819
  // Sets for master taskloop simd
820
 
821
  static OmpClauseSet allowedClauses_OMPD_master_taskloop_simd {
822
    llvm::omp::Clause::OMPC_if,
823
    llvm::omp::Clause::OMPC_shared,
824
    llvm::omp::Clause::OMPC_private,
825
    llvm::omp::Clause::OMPC_firstprivate,
826
    llvm::omp::Clause::OMPC_lastprivate,
827
    llvm::omp::Clause::OMPC_default,
828
    llvm::omp::Clause::OMPC_collapse,
829
    llvm::omp::Clause::OMPC_final,
830
    llvm::omp::Clause::OMPC_untied,
831
    llvm::omp::Clause::OMPC_mergeable,
832
    llvm::omp::Clause::OMPC_priority,
833
    llvm::omp::Clause::OMPC_linear,
834
    llvm::omp::Clause::OMPC_aligned,
835
    llvm::omp::Clause::OMPC_safelen,
836
    llvm::omp::Clause::OMPC_simdlen,
837
    llvm::omp::Clause::OMPC_grainsize,
838
    llvm::omp::Clause::OMPC_nogroup,
839
    llvm::omp::Clause::OMPC_num_tasks,
840
    llvm::omp::Clause::OMPC_reduction,
841
    llvm::omp::Clause::OMPC_in_reduction,
842
    llvm::omp::Clause::OMPC_allocate,
843
    llvm::omp::Clause::OMPC_nontemporal,
844
    llvm::omp::Clause::OMPC_order,
845
  };
846
 
847
  static OmpClauseSet allowedOnceClauses_OMPD_master_taskloop_simd {
848
  };
849
 
850
  static OmpClauseSet allowedExclusiveClauses_OMPD_master_taskloop_simd {
851
  };
852
 
853
  static OmpClauseSet requiredClauses_OMPD_master_taskloop_simd {
854
  };
855
 
856
  // Sets for metadirective
857
 
858
  static OmpClauseSet allowedClauses_OMPD_metadirective {
859
    llvm::omp::Clause::OMPC_when,
860
  };
861
 
862
  static OmpClauseSet allowedOnceClauses_OMPD_metadirective {
863
    llvm::omp::Clause::OMPC_default,
864
  };
865
 
866
  static OmpClauseSet allowedExclusiveClauses_OMPD_metadirective {
867
  };
868
 
869
  static OmpClauseSet requiredClauses_OMPD_metadirective {
870
  };
871
 
872
  // Sets for nothing
873
 
874
  static OmpClauseSet allowedClauses_OMPD_nothing {
875
  };
876
 
877
  static OmpClauseSet allowedOnceClauses_OMPD_nothing {
878
  };
879
 
880
  static OmpClauseSet allowedExclusiveClauses_OMPD_nothing {
881
  };
882
 
883
  static OmpClauseSet requiredClauses_OMPD_nothing {
884
  };
885
 
886
  // Sets for ordered
887
 
888
  static OmpClauseSet allowedClauses_OMPD_ordered {
889
    llvm::omp::Clause::OMPC_depend,
890
  };
891
 
892
  static OmpClauseSet allowedOnceClauses_OMPD_ordered {
893
    llvm::omp::Clause::OMPC_threads,
894
    llvm::omp::Clause::OMPC_simd,
895
  };
896
 
897
  static OmpClauseSet allowedExclusiveClauses_OMPD_ordered {
898
  };
899
 
900
  static OmpClauseSet requiredClauses_OMPD_ordered {
901
  };
902
 
903
  // Sets for parallel
904
 
905
  static OmpClauseSet allowedClauses_OMPD_parallel {
906
    llvm::omp::Clause::OMPC_private,
907
    llvm::omp::Clause::OMPC_firstprivate,
908
    llvm::omp::Clause::OMPC_shared,
909
    llvm::omp::Clause::OMPC_reduction,
910
    llvm::omp::Clause::OMPC_copyin,
911
    llvm::omp::Clause::OMPC_allocate,
912
  };
913
 
914
  static OmpClauseSet allowedOnceClauses_OMPD_parallel {
915
    llvm::omp::Clause::OMPC_default,
916
    llvm::omp::Clause::OMPC_if,
917
    llvm::omp::Clause::OMPC_num_threads,
918
    llvm::omp::Clause::OMPC_proc_bind,
919
  };
920
 
921
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel {
922
  };
923
 
924
  static OmpClauseSet requiredClauses_OMPD_parallel {
925
  };
926
 
927
  // Sets for parallel do
928
 
929
  static OmpClauseSet allowedClauses_OMPD_parallel_do {
930
    llvm::omp::Clause::OMPC_default,
931
    llvm::omp::Clause::OMPC_private,
932
    llvm::omp::Clause::OMPC_firstprivate,
933
    llvm::omp::Clause::OMPC_shared,
934
    llvm::omp::Clause::OMPC_reduction,
935
    llvm::omp::Clause::OMPC_copyin,
936
    llvm::omp::Clause::OMPC_lastprivate,
937
    llvm::omp::Clause::OMPC_linear,
938
  };
939
 
940
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_do {
941
    llvm::omp::Clause::OMPC_if,
942
    llvm::omp::Clause::OMPC_num_threads,
943
    llvm::omp::Clause::OMPC_proc_bind,
944
    llvm::omp::Clause::OMPC_schedule,
945
    llvm::omp::Clause::OMPC_ordered,
946
    llvm::omp::Clause::OMPC_collapse,
947
  };
948
 
949
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_do {
950
  };
951
 
952
  static OmpClauseSet requiredClauses_OMPD_parallel_do {
953
  };
954
 
955
  // Sets for parallel do simd
956
 
957
  static OmpClauseSet allowedClauses_OMPD_parallel_do_simd {
958
    llvm::omp::Clause::OMPC_default,
959
    llvm::omp::Clause::OMPC_private,
960
    llvm::omp::Clause::OMPC_firstprivate,
961
    llvm::omp::Clause::OMPC_shared,
962
    llvm::omp::Clause::OMPC_reduction,
963
    llvm::omp::Clause::OMPC_copyin,
964
    llvm::omp::Clause::OMPC_lastprivate,
965
    llvm::omp::Clause::OMPC_linear,
966
    llvm::omp::Clause::OMPC_aligned,
967
    llvm::omp::Clause::OMPC_allocate,
968
    llvm::omp::Clause::OMPC_nontemporal,
969
    llvm::omp::Clause::OMPC_order,
970
  };
971
 
972
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_do_simd {
973
    llvm::omp::Clause::OMPC_if,
974
    llvm::omp::Clause::OMPC_num_threads,
975
    llvm::omp::Clause::OMPC_proc_bind,
976
    llvm::omp::Clause::OMPC_schedule,
977
    llvm::omp::Clause::OMPC_ordered,
978
    llvm::omp::Clause::OMPC_collapse,
979
    llvm::omp::Clause::OMPC_safelen,
980
    llvm::omp::Clause::OMPC_simdlen,
981
  };
982
 
983
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_do_simd {
984
  };
985
 
986
  static OmpClauseSet requiredClauses_OMPD_parallel_do_simd {
987
  };
988
 
989
  // Sets for parallel for
990
 
991
  static OmpClauseSet allowedClauses_OMPD_parallel_for {
992
    llvm::omp::Clause::OMPC_if,
993
    llvm::omp::Clause::OMPC_num_threads,
994
    llvm::omp::Clause::OMPC_default,
995
    llvm::omp::Clause::OMPC_proc_bind,
996
    llvm::omp::Clause::OMPC_private,
997
    llvm::omp::Clause::OMPC_firstprivate,
998
    llvm::omp::Clause::OMPC_shared,
999
    llvm::omp::Clause::OMPC_reduction,
1000
    llvm::omp::Clause::OMPC_copyin,
1001
    llvm::omp::Clause::OMPC_lastprivate,
1002
    llvm::omp::Clause::OMPC_collapse,
1003
    llvm::omp::Clause::OMPC_schedule,
1004
    llvm::omp::Clause::OMPC_ordered,
1005
    llvm::omp::Clause::OMPC_linear,
1006
    llvm::omp::Clause::OMPC_allocate,
1007
    llvm::omp::Clause::OMPC_order,
1008
  };
1009
 
1010
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_for {
1011
  };
1012
 
1013
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_for {
1014
  };
1015
 
1016
  static OmpClauseSet requiredClauses_OMPD_parallel_for {
1017
  };
1018
 
1019
  // Sets for parallel for simd
1020
 
1021
  static OmpClauseSet allowedClauses_OMPD_parallel_for_simd {
1022
    llvm::omp::Clause::OMPC_if,
1023
    llvm::omp::Clause::OMPC_num_threads,
1024
    llvm::omp::Clause::OMPC_default,
1025
    llvm::omp::Clause::OMPC_proc_bind,
1026
    llvm::omp::Clause::OMPC_private,
1027
    llvm::omp::Clause::OMPC_firstprivate,
1028
    llvm::omp::Clause::OMPC_shared,
1029
    llvm::omp::Clause::OMPC_reduction,
1030
    llvm::omp::Clause::OMPC_copyin,
1031
    llvm::omp::Clause::OMPC_lastprivate,
1032
    llvm::omp::Clause::OMPC_collapse,
1033
    llvm::omp::Clause::OMPC_schedule,
1034
    llvm::omp::Clause::OMPC_safelen,
1035
    llvm::omp::Clause::OMPC_simdlen,
1036
    llvm::omp::Clause::OMPC_linear,
1037
    llvm::omp::Clause::OMPC_aligned,
1038
    llvm::omp::Clause::OMPC_ordered,
1039
    llvm::omp::Clause::OMPC_allocate,
1040
    llvm::omp::Clause::OMPC_nontemporal,
1041
    llvm::omp::Clause::OMPC_order,
1042
  };
1043
 
1044
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_for_simd {
1045
  };
1046
 
1047
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_for_simd {
1048
  };
1049
 
1050
  static OmpClauseSet requiredClauses_OMPD_parallel_for_simd {
1051
  };
1052
 
1053
  // Sets for parallel masked
1054
 
1055
  static OmpClauseSet allowedClauses_OMPD_parallel_masked {
1056
    llvm::omp::Clause::OMPC_if,
1057
    llvm::omp::Clause::OMPC_num_threads,
1058
    llvm::omp::Clause::OMPC_default,
1059
    llvm::omp::Clause::OMPC_private,
1060
    llvm::omp::Clause::OMPC_firstprivate,
1061
    llvm::omp::Clause::OMPC_shared,
1062
    llvm::omp::Clause::OMPC_copyin,
1063
    llvm::omp::Clause::OMPC_reduction,
1064
    llvm::omp::Clause::OMPC_proc_bind,
1065
    llvm::omp::Clause::OMPC_allocate,
1066
    llvm::omp::Clause::OMPC_filter,
1067
  };
1068
 
1069
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_masked {
1070
  };
1071
 
1072
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_masked {
1073
  };
1074
 
1075
  static OmpClauseSet requiredClauses_OMPD_parallel_masked {
1076
  };
1077
 
1078
  // Sets for parallel masked taskloop
1079
 
1080
  static OmpClauseSet allowedClauses_OMPD_parallel_masked_taskloop {
1081
    llvm::omp::Clause::OMPC_if,
1082
    llvm::omp::Clause::OMPC_shared,
1083
    llvm::omp::Clause::OMPC_private,
1084
    llvm::omp::Clause::OMPC_firstprivate,
1085
    llvm::omp::Clause::OMPC_lastprivate,
1086
    llvm::omp::Clause::OMPC_default,
1087
    llvm::omp::Clause::OMPC_collapse,
1088
    llvm::omp::Clause::OMPC_final,
1089
    llvm::omp::Clause::OMPC_untied,
1090
    llvm::omp::Clause::OMPC_mergeable,
1091
    llvm::omp::Clause::OMPC_priority,
1092
    llvm::omp::Clause::OMPC_grainsize,
1093
    llvm::omp::Clause::OMPC_nogroup,
1094
    llvm::omp::Clause::OMPC_num_tasks,
1095
    llvm::omp::Clause::OMPC_reduction,
1096
    llvm::omp::Clause::OMPC_allocate,
1097
    llvm::omp::Clause::OMPC_num_threads,
1098
    llvm::omp::Clause::OMPC_proc_bind,
1099
    llvm::omp::Clause::OMPC_copyin,
1100
    llvm::omp::Clause::OMPC_filter,
1101
  };
1102
 
1103
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_masked_taskloop {
1104
  };
1105
 
1106
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_masked_taskloop {
1107
  };
1108
 
1109
  static OmpClauseSet requiredClauses_OMPD_parallel_masked_taskloop {
1110
  };
1111
 
1112
  // Sets for parallel masked taskloop simd
1113
 
1114
  static OmpClauseSet allowedClauses_OMPD_parallel_masked_taskloop_simd {
1115
    llvm::omp::Clause::OMPC_if,
1116
    llvm::omp::Clause::OMPC_shared,
1117
    llvm::omp::Clause::OMPC_private,
1118
    llvm::omp::Clause::OMPC_firstprivate,
1119
    llvm::omp::Clause::OMPC_lastprivate,
1120
    llvm::omp::Clause::OMPC_default,
1121
    llvm::omp::Clause::OMPC_collapse,
1122
    llvm::omp::Clause::OMPC_final,
1123
    llvm::omp::Clause::OMPC_untied,
1124
    llvm::omp::Clause::OMPC_mergeable,
1125
    llvm::omp::Clause::OMPC_priority,
1126
    llvm::omp::Clause::OMPC_grainsize,
1127
    llvm::omp::Clause::OMPC_nogroup,
1128
    llvm::omp::Clause::OMPC_num_tasks,
1129
    llvm::omp::Clause::OMPC_reduction,
1130
    llvm::omp::Clause::OMPC_allocate,
1131
    llvm::omp::Clause::OMPC_num_threads,
1132
    llvm::omp::Clause::OMPC_proc_bind,
1133
    llvm::omp::Clause::OMPC_copyin,
1134
    llvm::omp::Clause::OMPC_linear,
1135
    llvm::omp::Clause::OMPC_aligned,
1136
    llvm::omp::Clause::OMPC_safelen,
1137
    llvm::omp::Clause::OMPC_simdlen,
1138
    llvm::omp::Clause::OMPC_nontemporal,
1139
    llvm::omp::Clause::OMPC_order,
1140
    llvm::omp::Clause::OMPC_filter,
1141
  };
1142
 
1143
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_masked_taskloop_simd {
1144
  };
1145
 
1146
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_masked_taskloop_simd {
1147
  };
1148
 
1149
  static OmpClauseSet requiredClauses_OMPD_parallel_masked_taskloop_simd {
1150
  };
1151
 
1152
  // Sets for parallel master
1153
 
1154
  static OmpClauseSet allowedClauses_OMPD_parallel_master {
1155
    llvm::omp::Clause::OMPC_if,
1156
    llvm::omp::Clause::OMPC_num_threads,
1157
    llvm::omp::Clause::OMPC_default,
1158
    llvm::omp::Clause::OMPC_private,
1159
    llvm::omp::Clause::OMPC_firstprivate,
1160
    llvm::omp::Clause::OMPC_shared,
1161
    llvm::omp::Clause::OMPC_copyin,
1162
    llvm::omp::Clause::OMPC_reduction,
1163
    llvm::omp::Clause::OMPC_proc_bind,
1164
    llvm::omp::Clause::OMPC_allocate,
1165
  };
1166
 
1167
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_master {
1168
  };
1169
 
1170
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master {
1171
  };
1172
 
1173
  static OmpClauseSet requiredClauses_OMPD_parallel_master {
1174
  };
1175
 
1176
  // Sets for parallel master taskloop
1177
 
1178
  static OmpClauseSet allowedClauses_OMPD_parallel_master_taskloop {
1179
    llvm::omp::Clause::OMPC_if,
1180
    llvm::omp::Clause::OMPC_shared,
1181
    llvm::omp::Clause::OMPC_private,
1182
    llvm::omp::Clause::OMPC_firstprivate,
1183
    llvm::omp::Clause::OMPC_lastprivate,
1184
    llvm::omp::Clause::OMPC_default,
1185
    llvm::omp::Clause::OMPC_collapse,
1186
    llvm::omp::Clause::OMPC_final,
1187
    llvm::omp::Clause::OMPC_untied,
1188
    llvm::omp::Clause::OMPC_mergeable,
1189
    llvm::omp::Clause::OMPC_priority,
1190
    llvm::omp::Clause::OMPC_grainsize,
1191
    llvm::omp::Clause::OMPC_nogroup,
1192
    llvm::omp::Clause::OMPC_num_tasks,
1193
    llvm::omp::Clause::OMPC_reduction,
1194
    llvm::omp::Clause::OMPC_allocate,
1195
    llvm::omp::Clause::OMPC_num_threads,
1196
    llvm::omp::Clause::OMPC_proc_bind,
1197
    llvm::omp::Clause::OMPC_copyin,
1198
  };
1199
 
1200
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_master_taskloop {
1201
  };
1202
 
1203
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master_taskloop {
1204
  };
1205
 
1206
  static OmpClauseSet requiredClauses_OMPD_parallel_master_taskloop {
1207
  };
1208
 
1209
  // Sets for parallel master taskloop simd
1210
 
1211
  static OmpClauseSet allowedClauses_OMPD_parallel_master_taskloop_simd {
1212
    llvm::omp::Clause::OMPC_if,
1213
    llvm::omp::Clause::OMPC_shared,
1214
    llvm::omp::Clause::OMPC_private,
1215
    llvm::omp::Clause::OMPC_firstprivate,
1216
    llvm::omp::Clause::OMPC_lastprivate,
1217
    llvm::omp::Clause::OMPC_default,
1218
    llvm::omp::Clause::OMPC_collapse,
1219
    llvm::omp::Clause::OMPC_final,
1220
    llvm::omp::Clause::OMPC_untied,
1221
    llvm::omp::Clause::OMPC_mergeable,
1222
    llvm::omp::Clause::OMPC_priority,
1223
    llvm::omp::Clause::OMPC_grainsize,
1224
    llvm::omp::Clause::OMPC_nogroup,
1225
    llvm::omp::Clause::OMPC_num_tasks,
1226
    llvm::omp::Clause::OMPC_reduction,
1227
    llvm::omp::Clause::OMPC_allocate,
1228
    llvm::omp::Clause::OMPC_num_threads,
1229
    llvm::omp::Clause::OMPC_proc_bind,
1230
    llvm::omp::Clause::OMPC_copyin,
1231
    llvm::omp::Clause::OMPC_linear,
1232
    llvm::omp::Clause::OMPC_aligned,
1233
    llvm::omp::Clause::OMPC_safelen,
1234
    llvm::omp::Clause::OMPC_simdlen,
1235
    llvm::omp::Clause::OMPC_nontemporal,
1236
    llvm::omp::Clause::OMPC_order,
1237
  };
1238
 
1239
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_master_taskloop_simd {
1240
  };
1241
 
1242
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master_taskloop_simd {
1243
  };
1244
 
1245
  static OmpClauseSet requiredClauses_OMPD_parallel_master_taskloop_simd {
1246
  };
1247
 
1248
  // Sets for parallel sections
1249
 
1250
  static OmpClauseSet allowedClauses_OMPD_parallel_sections {
1251
    llvm::omp::Clause::OMPC_if,
1252
    llvm::omp::Clause::OMPC_default,
1253
    llvm::omp::Clause::OMPC_proc_bind,
1254
    llvm::omp::Clause::OMPC_private,
1255
    llvm::omp::Clause::OMPC_firstprivate,
1256
    llvm::omp::Clause::OMPC_shared,
1257
    llvm::omp::Clause::OMPC_reduction,
1258
    llvm::omp::Clause::OMPC_copyin,
1259
    llvm::omp::Clause::OMPC_lastprivate,
1260
    llvm::omp::Clause::OMPC_allocate,
1261
  };
1262
 
1263
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_sections {
1264
    llvm::omp::Clause::OMPC_num_threads,
1265
  };
1266
 
1267
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_sections {
1268
  };
1269
 
1270
  static OmpClauseSet requiredClauses_OMPD_parallel_sections {
1271
  };
1272
 
1273
  // Sets for parallel workshare
1274
 
1275
  static OmpClauseSet allowedClauses_OMPD_parallel_workshare {
1276
    llvm::omp::Clause::OMPC_allocate,
1277
    llvm::omp::Clause::OMPC_copyin,
1278
    llvm::omp::Clause::OMPC_default,
1279
    llvm::omp::Clause::OMPC_firstprivate,
1280
    llvm::omp::Clause::OMPC_private,
1281
    llvm::omp::Clause::OMPC_reduction,
1282
    llvm::omp::Clause::OMPC_shared,
1283
  };
1284
 
1285
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_workshare {
1286
    llvm::omp::Clause::OMPC_if,
1287
    llvm::omp::Clause::OMPC_num_threads,
1288
    llvm::omp::Clause::OMPC_proc_bind,
1289
  };
1290
 
1291
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_workshare {
1292
  };
1293
 
1294
  static OmpClauseSet requiredClauses_OMPD_parallel_workshare {
1295
  };
1296
 
1297
  // Sets for requires
1298
 
1299
  static OmpClauseSet allowedClauses_OMPD_requires {
1300
  };
1301
 
1302
  static OmpClauseSet allowedOnceClauses_OMPD_requires {
1303
    llvm::omp::Clause::OMPC_unified_address,
1304
    llvm::omp::Clause::OMPC_unified_shared_memory,
1305
    llvm::omp::Clause::OMPC_reverse_offload,
1306
    llvm::omp::Clause::OMPC_dynamic_allocators,
1307
    llvm::omp::Clause::OMPC_atomic_default_mem_order,
1308
  };
1309
 
1310
  static OmpClauseSet allowedExclusiveClauses_OMPD_requires {
1311
  };
1312
 
1313
  static OmpClauseSet requiredClauses_OMPD_requires {
1314
  };
1315
 
1316
  // Sets for scan
1317
 
1318
  static OmpClauseSet allowedClauses_OMPD_scan {
1319
    llvm::omp::Clause::OMPC_inclusive,
1320
    llvm::omp::Clause::OMPC_exclusive,
1321
  };
1322
 
1323
  static OmpClauseSet allowedOnceClauses_OMPD_scan {
1324
  };
1325
 
1326
  static OmpClauseSet allowedExclusiveClauses_OMPD_scan {
1327
  };
1328
 
1329
  static OmpClauseSet requiredClauses_OMPD_scan {
1330
  };
1331
 
1332
  // Sets for section
1333
 
1334
  static OmpClauseSet allowedClauses_OMPD_section {
1335
  };
1336
 
1337
  static OmpClauseSet allowedOnceClauses_OMPD_section {
1338
  };
1339
 
1340
  static OmpClauseSet allowedExclusiveClauses_OMPD_section {
1341
  };
1342
 
1343
  static OmpClauseSet requiredClauses_OMPD_section {
1344
  };
1345
 
1346
  // Sets for sections
1347
 
1348
  static OmpClauseSet allowedClauses_OMPD_sections {
1349
    llvm::omp::Clause::OMPC_private,
1350
    llvm::omp::Clause::OMPC_lastprivate,
1351
    llvm::omp::Clause::OMPC_firstprivate,
1352
    llvm::omp::Clause::OMPC_reduction,
1353
    llvm::omp::Clause::OMPC_nowait,
1354
    llvm::omp::Clause::OMPC_allocate,
1355
  };
1356
 
1357
  static OmpClauseSet allowedOnceClauses_OMPD_sections {
1358
  };
1359
 
1360
  static OmpClauseSet allowedExclusiveClauses_OMPD_sections {
1361
  };
1362
 
1363
  static OmpClauseSet requiredClauses_OMPD_sections {
1364
  };
1365
 
1366
  // Sets for simd
1367
 
1368
  static OmpClauseSet allowedClauses_OMPD_simd {
1369
    llvm::omp::Clause::OMPC_private,
1370
    llvm::omp::Clause::OMPC_lastprivate,
1371
    llvm::omp::Clause::OMPC_linear,
1372
    llvm::omp::Clause::OMPC_aligned,
1373
    llvm::omp::Clause::OMPC_reduction,
1374
    llvm::omp::Clause::OMPC_allocate,
1375
    llvm::omp::Clause::OMPC_nontemporal,
1376
    llvm::omp::Clause::OMPC_order,
1377
  };
1378
 
1379
  static OmpClauseSet allowedOnceClauses_OMPD_simd {
1380
    llvm::omp::Clause::OMPC_collapse,
1381
    llvm::omp::Clause::OMPC_safelen,
1382
    llvm::omp::Clause::OMPC_simdlen,
1383
    llvm::omp::Clause::OMPC_if,
1384
  };
1385
 
1386
  static OmpClauseSet allowedExclusiveClauses_OMPD_simd {
1387
  };
1388
 
1389
  static OmpClauseSet requiredClauses_OMPD_simd {
1390
  };
1391
 
1392
  // Sets for single
1393
 
1394
  static OmpClauseSet allowedClauses_OMPD_single {
1395
    llvm::omp::Clause::OMPC_private,
1396
    llvm::omp::Clause::OMPC_firstprivate,
1397
    llvm::omp::Clause::OMPC_copyprivate,
1398
    llvm::omp::Clause::OMPC_nowait,
1399
    llvm::omp::Clause::OMPC_allocate,
1400
  };
1401
 
1402
  static OmpClauseSet allowedOnceClauses_OMPD_single {
1403
  };
1404
 
1405
  static OmpClauseSet allowedExclusiveClauses_OMPD_single {
1406
  };
1407
 
1408
  static OmpClauseSet requiredClauses_OMPD_single {
1409
  };
1410
 
1411
  // Sets for target
1412
 
1413
  static OmpClauseSet allowedClauses_OMPD_target {
1414
    llvm::omp::Clause::OMPC_if,
1415
    llvm::omp::Clause::OMPC_map,
1416
    llvm::omp::Clause::OMPC_private,
1417
    llvm::omp::Clause::OMPC_depend,
1418
    llvm::omp::Clause::OMPC_firstprivate,
1419
    llvm::omp::Clause::OMPC_is_device_ptr,
1420
    llvm::omp::Clause::OMPC_has_device_addr,
1421
    llvm::omp::Clause::OMPC_reduction,
1422
    llvm::omp::Clause::OMPC_in_reduction,
1423
    llvm::omp::Clause::OMPC_allocate,
1424
    llvm::omp::Clause::OMPC_uses_allocators,
1425
  };
1426
 
1427
  static OmpClauseSet allowedOnceClauses_OMPD_target {
1428
    llvm::omp::Clause::OMPC_device,
1429
    llvm::omp::Clause::OMPC_thread_limit,
1430
    llvm::omp::Clause::OMPC_defaultmap,
1431
    llvm::omp::Clause::OMPC_nowait,
1432
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1433
  };
1434
 
1435
  static OmpClauseSet allowedExclusiveClauses_OMPD_target {
1436
  };
1437
 
1438
  static OmpClauseSet requiredClauses_OMPD_target {
1439
  };
1440
 
1441
  // Sets for target data
1442
 
1443
  static OmpClauseSet allowedClauses_OMPD_target_data {
1444
    llvm::omp::Clause::OMPC_use_device_ptr,
1445
    llvm::omp::Clause::OMPC_use_device_addr,
1446
  };
1447
 
1448
  static OmpClauseSet allowedOnceClauses_OMPD_target_data {
1449
    llvm::omp::Clause::OMPC_device,
1450
    llvm::omp::Clause::OMPC_if,
1451
  };
1452
 
1453
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_data {
1454
  };
1455
 
1456
  static OmpClauseSet requiredClauses_OMPD_target_data {
1457
    llvm::omp::Clause::OMPC_map,
1458
  };
1459
 
1460
  // Sets for target enter data
1461
 
1462
  static OmpClauseSet allowedClauses_OMPD_target_enter_data {
1463
    llvm::omp::Clause::OMPC_depend,
1464
  };
1465
 
1466
  static OmpClauseSet allowedOnceClauses_OMPD_target_enter_data {
1467
    llvm::omp::Clause::OMPC_if,
1468
    llvm::omp::Clause::OMPC_device,
1469
    llvm::omp::Clause::OMPC_nowait,
1470
  };
1471
 
1472
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_enter_data {
1473
  };
1474
 
1475
  static OmpClauseSet requiredClauses_OMPD_target_enter_data {
1476
    llvm::omp::Clause::OMPC_map,
1477
  };
1478
 
1479
  // Sets for target exit data
1480
 
1481
  static OmpClauseSet allowedClauses_OMPD_target_exit_data {
1482
    llvm::omp::Clause::OMPC_depend,
1483
  };
1484
 
1485
  static OmpClauseSet allowedOnceClauses_OMPD_target_exit_data {
1486
    llvm::omp::Clause::OMPC_device,
1487
    llvm::omp::Clause::OMPC_if,
1488
    llvm::omp::Clause::OMPC_nowait,
1489
  };
1490
 
1491
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_exit_data {
1492
  };
1493
 
1494
  static OmpClauseSet requiredClauses_OMPD_target_exit_data {
1495
    llvm::omp::Clause::OMPC_map,
1496
  };
1497
 
1498
  // Sets for target parallel
1499
 
1500
  static OmpClauseSet allowedClauses_OMPD_target_parallel {
1501
    llvm::omp::Clause::OMPC_map,
1502
    llvm::omp::Clause::OMPC_nowait,
1503
    llvm::omp::Clause::OMPC_depend,
1504
    llvm::omp::Clause::OMPC_private,
1505
    llvm::omp::Clause::OMPC_firstprivate,
1506
    llvm::omp::Clause::OMPC_default,
1507
    llvm::omp::Clause::OMPC_shared,
1508
    llvm::omp::Clause::OMPC_reduction,
1509
    llvm::omp::Clause::OMPC_is_device_ptr,
1510
    llvm::omp::Clause::OMPC_has_device_addr,
1511
    llvm::omp::Clause::OMPC_allocate,
1512
    llvm::omp::Clause::OMPC_uses_allocators,
1513
  };
1514
 
1515
  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel {
1516
    llvm::omp::Clause::OMPC_defaultmap,
1517
    llvm::omp::Clause::OMPC_device,
1518
    llvm::omp::Clause::OMPC_if,
1519
    llvm::omp::Clause::OMPC_num_threads,
1520
    llvm::omp::Clause::OMPC_proc_bind,
1521
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1522
  };
1523
 
1524
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel {
1525
  };
1526
 
1527
  static OmpClauseSet requiredClauses_OMPD_target_parallel {
1528
  };
1529
 
1530
  // Sets for target parallel do
1531
 
1532
  static OmpClauseSet allowedClauses_OMPD_target_parallel_do {
1533
    llvm::omp::Clause::OMPC_map,
1534
    llvm::omp::Clause::OMPC_private,
1535
    llvm::omp::Clause::OMPC_firstprivate,
1536
    llvm::omp::Clause::OMPC_lastprivate,
1537
    llvm::omp::Clause::OMPC_depend,
1538
    llvm::omp::Clause::OMPC_shared,
1539
    llvm::omp::Clause::OMPC_reduction,
1540
    llvm::omp::Clause::OMPC_linear,
1541
    llvm::omp::Clause::OMPC_is_device_ptr,
1542
    llvm::omp::Clause::OMPC_has_device_addr,
1543
    llvm::omp::Clause::OMPC_allocator,
1544
    llvm::omp::Clause::OMPC_order,
1545
    llvm::omp::Clause::OMPC_uses_allocators,
1546
    llvm::omp::Clause::OMPC_default,
1547
    llvm::omp::Clause::OMPC_copyin,
1548
  };
1549
 
1550
  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_do {
1551
    llvm::omp::Clause::OMPC_if,
1552
    llvm::omp::Clause::OMPC_num_threads,
1553
    llvm::omp::Clause::OMPC_proc_bind,
1554
    llvm::omp::Clause::OMPC_device,
1555
    llvm::omp::Clause::OMPC_defaultmap,
1556
    llvm::omp::Clause::OMPC_schedule,
1557
    llvm::omp::Clause::OMPC_collapse,
1558
    llvm::omp::Clause::OMPC_ordered,
1559
    llvm::omp::Clause::OMPC_nowait,
1560
  };
1561
 
1562
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_do {
1563
  };
1564
 
1565
  static OmpClauseSet requiredClauses_OMPD_target_parallel_do {
1566
  };
1567
 
1568
  // Sets for target parallel do simd
1569
 
1570
  static OmpClauseSet allowedClauses_OMPD_target_parallel_do_simd {
1571
    llvm::omp::Clause::OMPC_if,
1572
    llvm::omp::Clause::OMPC_device,
1573
    llvm::omp::Clause::OMPC_map,
1574
    llvm::omp::Clause::OMPC_private,
1575
    llvm::omp::Clause::OMPC_firstprivate,
1576
    llvm::omp::Clause::OMPC_lastprivate,
1577
    llvm::omp::Clause::OMPC_nowait,
1578
    llvm::omp::Clause::OMPC_depend,
1579
    llvm::omp::Clause::OMPC_defaultmap,
1580
    llvm::omp::Clause::OMPC_num_threads,
1581
    llvm::omp::Clause::OMPC_default,
1582
    llvm::omp::Clause::OMPC_proc_bind,
1583
    llvm::omp::Clause::OMPC_shared,
1584
    llvm::omp::Clause::OMPC_reduction,
1585
    llvm::omp::Clause::OMPC_collapse,
1586
    llvm::omp::Clause::OMPC_schedule,
1587
    llvm::omp::Clause::OMPC_ordered,
1588
    llvm::omp::Clause::OMPC_linear,
1589
    llvm::omp::Clause::OMPC_safelen,
1590
    llvm::omp::Clause::OMPC_simdlen,
1591
    llvm::omp::Clause::OMPC_aligned,
1592
    llvm::omp::Clause::OMPC_is_device_ptr,
1593
    llvm::omp::Clause::OMPC_has_device_addr,
1594
    llvm::omp::Clause::OMPC_allocate,
1595
    llvm::omp::Clause::OMPC_nontemporal,
1596
    llvm::omp::Clause::OMPC_order,
1597
    llvm::omp::Clause::OMPC_uses_allocators,
1598
  };
1599
 
1600
  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_do_simd {
1601
  };
1602
 
1603
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_do_simd {
1604
  };
1605
 
1606
  static OmpClauseSet requiredClauses_OMPD_target_parallel_do_simd {
1607
  };
1608
 
1609
  // Sets for target parallel for
1610
 
1611
  static OmpClauseSet allowedClauses_OMPD_target_parallel_for {
1612
    llvm::omp::Clause::OMPC_if,
1613
    llvm::omp::Clause::OMPC_device,
1614
    llvm::omp::Clause::OMPC_map,
1615
    llvm::omp::Clause::OMPC_private,
1616
    llvm::omp::Clause::OMPC_firstprivate,
1617
    llvm::omp::Clause::OMPC_lastprivate,
1618
    llvm::omp::Clause::OMPC_nowait,
1619
    llvm::omp::Clause::OMPC_depend,
1620
    llvm::omp::Clause::OMPC_defaultmap,
1621
    llvm::omp::Clause::OMPC_num_threads,
1622
    llvm::omp::Clause::OMPC_default,
1623
    llvm::omp::Clause::OMPC_proc_bind,
1624
    llvm::omp::Clause::OMPC_shared,
1625
    llvm::omp::Clause::OMPC_reduction,
1626
    llvm::omp::Clause::OMPC_collapse,
1627
    llvm::omp::Clause::OMPC_schedule,
1628
    llvm::omp::Clause::OMPC_ordered,
1629
    llvm::omp::Clause::OMPC_linear,
1630
    llvm::omp::Clause::OMPC_is_device_ptr,
1631
    llvm::omp::Clause::OMPC_has_device_addr,
1632
    llvm::omp::Clause::OMPC_allocate,
1633
    llvm::omp::Clause::OMPC_order,
1634
    llvm::omp::Clause::OMPC_uses_allocators,
1635
  };
1636
 
1637
  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_for {
1638
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1639
  };
1640
 
1641
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_for {
1642
  };
1643
 
1644
  static OmpClauseSet requiredClauses_OMPD_target_parallel_for {
1645
  };
1646
 
1647
  // Sets for target parallel for simd
1648
 
1649
  static OmpClauseSet allowedClauses_OMPD_target_parallel_for_simd {
1650
    llvm::omp::Clause::OMPC_if,
1651
    llvm::omp::Clause::OMPC_device,
1652
    llvm::omp::Clause::OMPC_map,
1653
    llvm::omp::Clause::OMPC_private,
1654
    llvm::omp::Clause::OMPC_firstprivate,
1655
    llvm::omp::Clause::OMPC_lastprivate,
1656
    llvm::omp::Clause::OMPC_nowait,
1657
    llvm::omp::Clause::OMPC_depend,
1658
    llvm::omp::Clause::OMPC_defaultmap,
1659
    llvm::omp::Clause::OMPC_num_threads,
1660
    llvm::omp::Clause::OMPC_default,
1661
    llvm::omp::Clause::OMPC_proc_bind,
1662
    llvm::omp::Clause::OMPC_shared,
1663
    llvm::omp::Clause::OMPC_reduction,
1664
    llvm::omp::Clause::OMPC_collapse,
1665
    llvm::omp::Clause::OMPC_schedule,
1666
    llvm::omp::Clause::OMPC_ordered,
1667
    llvm::omp::Clause::OMPC_linear,
1668
    llvm::omp::Clause::OMPC_safelen,
1669
    llvm::omp::Clause::OMPC_simdlen,
1670
    llvm::omp::Clause::OMPC_aligned,
1671
    llvm::omp::Clause::OMPC_is_device_ptr,
1672
    llvm::omp::Clause::OMPC_has_device_addr,
1673
    llvm::omp::Clause::OMPC_allocate,
1674
    llvm::omp::Clause::OMPC_nontemporal,
1675
    llvm::omp::Clause::OMPC_order,
1676
    llvm::omp::Clause::OMPC_uses_allocators,
1677
  };
1678
 
1679
  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_for_simd {
1680
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1681
  };
1682
 
1683
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_for_simd {
1684
  };
1685
 
1686
  static OmpClauseSet requiredClauses_OMPD_target_parallel_for_simd {
1687
  };
1688
 
1689
  // Sets for target simd
1690
 
1691
  static OmpClauseSet allowedClauses_OMPD_target_simd {
1692
    llvm::omp::Clause::OMPC_aligned,
1693
    llvm::omp::Clause::OMPC_allocate,
1694
    llvm::omp::Clause::OMPC_depend,
1695
    llvm::omp::Clause::OMPC_firstprivate,
1696
    llvm::omp::Clause::OMPC_is_device_ptr,
1697
    llvm::omp::Clause::OMPC_has_device_addr,
1698
    llvm::omp::Clause::OMPC_lastprivate,
1699
    llvm::omp::Clause::OMPC_linear,
1700
    llvm::omp::Clause::OMPC_map,
1701
    llvm::omp::Clause::OMPC_nontemporal,
1702
    llvm::omp::Clause::OMPC_nowait,
1703
    llvm::omp::Clause::OMPC_order,
1704
    llvm::omp::Clause::OMPC_private,
1705
    llvm::omp::Clause::OMPC_reduction,
1706
    llvm::omp::Clause::OMPC_shared,
1707
    llvm::omp::Clause::OMPC_uses_allocators,
1708
  };
1709
 
1710
  static OmpClauseSet allowedOnceClauses_OMPD_target_simd {
1711
    llvm::omp::Clause::OMPC_collapse,
1712
    llvm::omp::Clause::OMPC_safelen,
1713
    llvm::omp::Clause::OMPC_simdlen,
1714
    llvm::omp::Clause::OMPC_if,
1715
    llvm::omp::Clause::OMPC_num_threads,
1716
    llvm::omp::Clause::OMPC_proc_bind,
1717
    llvm::omp::Clause::OMPC_device,
1718
    llvm::omp::Clause::OMPC_defaultmap,
1719
    llvm::omp::Clause::OMPC_schedule,
1720
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1721
  };
1722
 
1723
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_simd {
1724
  };
1725
 
1726
  static OmpClauseSet requiredClauses_OMPD_target_simd {
1727
  };
1728
 
1729
  // Sets for target teams
1730
 
1731
  static OmpClauseSet allowedClauses_OMPD_target_teams {
1732
    llvm::omp::Clause::OMPC_if,
1733
    llvm::omp::Clause::OMPC_map,
1734
    llvm::omp::Clause::OMPC_private,
1735
    llvm::omp::Clause::OMPC_depend,
1736
    llvm::omp::Clause::OMPC_firstprivate,
1737
    llvm::omp::Clause::OMPC_is_device_ptr,
1738
    llvm::omp::Clause::OMPC_has_device_addr,
1739
    llvm::omp::Clause::OMPC_reduction,
1740
    llvm::omp::Clause::OMPC_allocate,
1741
    llvm::omp::Clause::OMPC_uses_allocators,
1742
    llvm::omp::Clause::OMPC_shared,
1743
  };
1744
 
1745
  static OmpClauseSet allowedOnceClauses_OMPD_target_teams {
1746
    llvm::omp::Clause::OMPC_device,
1747
    llvm::omp::Clause::OMPC_nowait,
1748
    llvm::omp::Clause::OMPC_defaultmap,
1749
    llvm::omp::Clause::OMPC_default,
1750
    llvm::omp::Clause::OMPC_num_teams,
1751
    llvm::omp::Clause::OMPC_thread_limit,
1752
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1753
  };
1754
 
1755
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams {
1756
  };
1757
 
1758
  static OmpClauseSet requiredClauses_OMPD_target_teams {
1759
  };
1760
 
1761
  // Sets for target teams distribute
1762
 
1763
  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute {
1764
    llvm::omp::Clause::OMPC_if,
1765
    llvm::omp::Clause::OMPC_map,
1766
    llvm::omp::Clause::OMPC_private,
1767
    llvm::omp::Clause::OMPC_depend,
1768
    llvm::omp::Clause::OMPC_firstprivate,
1769
    llvm::omp::Clause::OMPC_is_device_ptr,
1770
    llvm::omp::Clause::OMPC_has_device_addr,
1771
    llvm::omp::Clause::OMPC_reduction,
1772
    llvm::omp::Clause::OMPC_allocate,
1773
    llvm::omp::Clause::OMPC_uses_allocators,
1774
    llvm::omp::Clause::OMPC_shared,
1775
    llvm::omp::Clause::OMPC_lastprivate,
1776
  };
1777
 
1778
  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute {
1779
    llvm::omp::Clause::OMPC_device,
1780
    llvm::omp::Clause::OMPC_nowait,
1781
    llvm::omp::Clause::OMPC_defaultmap,
1782
    llvm::omp::Clause::OMPC_default,
1783
    llvm::omp::Clause::OMPC_num_teams,
1784
    llvm::omp::Clause::OMPC_thread_limit,
1785
    llvm::omp::Clause::OMPC_collapse,
1786
    llvm::omp::Clause::OMPC_dist_schedule,
1787
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1788
  };
1789
 
1790
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute {
1791
  };
1792
 
1793
  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute {
1794
  };
1795
 
1796
  // Sets for target teams distribute parallel do
1797
 
1798
  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_do {
1799
    llvm::omp::Clause::OMPC_if,
1800
    llvm::omp::Clause::OMPC_map,
1801
    llvm::omp::Clause::OMPC_private,
1802
    llvm::omp::Clause::OMPC_depend,
1803
    llvm::omp::Clause::OMPC_firstprivate,
1804
    llvm::omp::Clause::OMPC_is_device_ptr,
1805
    llvm::omp::Clause::OMPC_has_device_addr,
1806
    llvm::omp::Clause::OMPC_reduction,
1807
    llvm::omp::Clause::OMPC_allocate,
1808
    llvm::omp::Clause::OMPC_uses_allocators,
1809
    llvm::omp::Clause::OMPC_shared,
1810
    llvm::omp::Clause::OMPC_lastprivate,
1811
    llvm::omp::Clause::OMPC_copyin,
1812
    llvm::omp::Clause::OMPC_linear,
1813
    llvm::omp::Clause::OMPC_ordered,
1814
    llvm::omp::Clause::OMPC_order,
1815
  };
1816
 
1817
  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_do {
1818
    llvm::omp::Clause::OMPC_device,
1819
    llvm::omp::Clause::OMPC_defaultmap,
1820
    llvm::omp::Clause::OMPC_nowait,
1821
    llvm::omp::Clause::OMPC_default,
1822
    llvm::omp::Clause::OMPC_num_teams,
1823
    llvm::omp::Clause::OMPC_thread_limit,
1824
    llvm::omp::Clause::OMPC_collapse,
1825
    llvm::omp::Clause::OMPC_dist_schedule,
1826
    llvm::omp::Clause::OMPC_num_threads,
1827
    llvm::omp::Clause::OMPC_proc_bind,
1828
    llvm::omp::Clause::OMPC_schedule,
1829
  };
1830
 
1831
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do {
1832
  };
1833
 
1834
  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_do {
1835
  };
1836
 
1837
  // Sets for target teams distribute parallel do simd
1838
 
1839
  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_do_simd {
1840
    llvm::omp::Clause::OMPC_map,
1841
    llvm::omp::Clause::OMPC_private,
1842
    llvm::omp::Clause::OMPC_depend,
1843
    llvm::omp::Clause::OMPC_firstprivate,
1844
    llvm::omp::Clause::OMPC_is_device_ptr,
1845
    llvm::omp::Clause::OMPC_has_device_addr,
1846
    llvm::omp::Clause::OMPC_reduction,
1847
    llvm::omp::Clause::OMPC_allocate,
1848
    llvm::omp::Clause::OMPC_uses_allocators,
1849
    llvm::omp::Clause::OMPC_shared,
1850
    llvm::omp::Clause::OMPC_lastprivate,
1851
    llvm::omp::Clause::OMPC_copyin,
1852
    llvm::omp::Clause::OMPC_linear,
1853
    llvm::omp::Clause::OMPC_ordered,
1854
    llvm::omp::Clause::OMPC_order,
1855
    llvm::omp::Clause::OMPC_aligned,
1856
    llvm::omp::Clause::OMPC_nontemporal,
1857
  };
1858
 
1859
  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_do_simd {
1860
    llvm::omp::Clause::OMPC_if,
1861
    llvm::omp::Clause::OMPC_device,
1862
    llvm::omp::Clause::OMPC_nowait,
1863
    llvm::omp::Clause::OMPC_defaultmap,
1864
    llvm::omp::Clause::OMPC_default,
1865
    llvm::omp::Clause::OMPC_num_teams,
1866
    llvm::omp::Clause::OMPC_thread_limit,
1867
    llvm::omp::Clause::OMPC_collapse,
1868
    llvm::omp::Clause::OMPC_dist_schedule,
1869
    llvm::omp::Clause::OMPC_num_threads,
1870
    llvm::omp::Clause::OMPC_proc_bind,
1871
    llvm::omp::Clause::OMPC_schedule,
1872
    llvm::omp::Clause::OMPC_safelen,
1873
    llvm::omp::Clause::OMPC_simdlen,
1874
  };
1875
 
1876
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do_simd {
1877
  };
1878
 
1879
  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_do_simd {
1880
  };
1881
 
1882
  // Sets for target teams distribute parallel for
1883
 
1884
  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_for {
1885
    llvm::omp::Clause::OMPC_if,
1886
    llvm::omp::Clause::OMPC_device,
1887
    llvm::omp::Clause::OMPC_map,
1888
    llvm::omp::Clause::OMPC_private,
1889
    llvm::omp::Clause::OMPC_nowait,
1890
    llvm::omp::Clause::OMPC_depend,
1891
    llvm::omp::Clause::OMPC_defaultmap,
1892
    llvm::omp::Clause::OMPC_firstprivate,
1893
    llvm::omp::Clause::OMPC_is_device_ptr,
1894
    llvm::omp::Clause::OMPC_has_device_addr,
1895
    llvm::omp::Clause::OMPC_default,
1896
    llvm::omp::Clause::OMPC_shared,
1897
    llvm::omp::Clause::OMPC_reduction,
1898
    llvm::omp::Clause::OMPC_num_teams,
1899
    llvm::omp::Clause::OMPC_thread_limit,
1900
    llvm::omp::Clause::OMPC_lastprivate,
1901
    llvm::omp::Clause::OMPC_collapse,
1902
    llvm::omp::Clause::OMPC_dist_schedule,
1903
    llvm::omp::Clause::OMPC_num_threads,
1904
    llvm::omp::Clause::OMPC_proc_bind,
1905
    llvm::omp::Clause::OMPC_schedule,
1906
    llvm::omp::Clause::OMPC_allocate,
1907
    llvm::omp::Clause::OMPC_order,
1908
    llvm::omp::Clause::OMPC_uses_allocators,
1909
  };
1910
 
1911
  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_for {
1912
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1913
  };
1914
 
1915
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for {
1916
  };
1917
 
1918
  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_for {
1919
  };
1920
 
1921
  // Sets for target teams distribute parallel for simd
1922
 
1923
  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_for_simd {
1924
    llvm::omp::Clause::OMPC_if,
1925
    llvm::omp::Clause::OMPC_device,
1926
    llvm::omp::Clause::OMPC_map,
1927
    llvm::omp::Clause::OMPC_private,
1928
    llvm::omp::Clause::OMPC_nowait,
1929
    llvm::omp::Clause::OMPC_depend,
1930
    llvm::omp::Clause::OMPC_defaultmap,
1931
    llvm::omp::Clause::OMPC_firstprivate,
1932
    llvm::omp::Clause::OMPC_is_device_ptr,
1933
    llvm::omp::Clause::OMPC_has_device_addr,
1934
    llvm::omp::Clause::OMPC_default,
1935
    llvm::omp::Clause::OMPC_shared,
1936
    llvm::omp::Clause::OMPC_reduction,
1937
    llvm::omp::Clause::OMPC_num_teams,
1938
    llvm::omp::Clause::OMPC_thread_limit,
1939
    llvm::omp::Clause::OMPC_lastprivate,
1940
    llvm::omp::Clause::OMPC_collapse,
1941
    llvm::omp::Clause::OMPC_dist_schedule,
1942
    llvm::omp::Clause::OMPC_num_threads,
1943
    llvm::omp::Clause::OMPC_proc_bind,
1944
    llvm::omp::Clause::OMPC_schedule,
1945
    llvm::omp::Clause::OMPC_linear,
1946
    llvm::omp::Clause::OMPC_aligned,
1947
    llvm::omp::Clause::OMPC_safelen,
1948
    llvm::omp::Clause::OMPC_simdlen,
1949
    llvm::omp::Clause::OMPC_allocate,
1950
    llvm::omp::Clause::OMPC_nontemporal,
1951
    llvm::omp::Clause::OMPC_order,
1952
    llvm::omp::Clause::OMPC_uses_allocators,
1953
  };
1954
 
1955
  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_for_simd {
1956
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1957
  };
1958
 
1959
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for_simd {
1960
  };
1961
 
1962
  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_for_simd {
1963
  };
1964
 
1965
  // Sets for target teams distribute simd
1966
 
1967
  static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_simd {
1968
    llvm::omp::Clause::OMPC_aligned,
1969
    llvm::omp::Clause::OMPC_allocate,
1970
    llvm::omp::Clause::OMPC_depend,
1971
    llvm::omp::Clause::OMPC_firstprivate,
1972
    llvm::omp::Clause::OMPC_if,
1973
    llvm::omp::Clause::OMPC_is_device_ptr,
1974
    llvm::omp::Clause::OMPC_has_device_addr,
1975
    llvm::omp::Clause::OMPC_lastprivate,
1976
    llvm::omp::Clause::OMPC_linear,
1977
    llvm::omp::Clause::OMPC_map,
1978
    llvm::omp::Clause::OMPC_nontemporal,
1979
    llvm::omp::Clause::OMPC_order,
1980
    llvm::omp::Clause::OMPC_private,
1981
    llvm::omp::Clause::OMPC_reduction,
1982
    llvm::omp::Clause::OMPC_shared,
1983
    llvm::omp::Clause::OMPC_uses_allocators,
1984
  };
1985
 
1986
  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_simd {
1987
    llvm::omp::Clause::OMPC_device,
1988
    llvm::omp::Clause::OMPC_defaultmap,
1989
    llvm::omp::Clause::OMPC_nowait,
1990
    llvm::omp::Clause::OMPC_num_teams,
1991
    llvm::omp::Clause::OMPC_thread_limit,
1992
    llvm::omp::Clause::OMPC_collapse,
1993
    llvm::omp::Clause::OMPC_dist_schedule,
1994
    llvm::omp::Clause::OMPC_safelen,
1995
    llvm::omp::Clause::OMPC_simdlen,
1996
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
1997
  };
1998
 
1999
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_simd {
2000
  };
2001
 
2002
  static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_simd {
2003
  };
2004
 
2005
  // Sets for target update
2006
 
2007
  static OmpClauseSet allowedClauses_OMPD_target_update {
2008
    llvm::omp::Clause::OMPC_to,
2009
    llvm::omp::Clause::OMPC_from,
2010
    llvm::omp::Clause::OMPC_depend,
2011
  };
2012
 
2013
  static OmpClauseSet allowedOnceClauses_OMPD_target_update {
2014
    llvm::omp::Clause::OMPC_device,
2015
    llvm::omp::Clause::OMPC_if,
2016
    llvm::omp::Clause::OMPC_nowait,
2017
  };
2018
 
2019
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_update {
2020
  };
2021
 
2022
  static OmpClauseSet requiredClauses_OMPD_target_update {
2023
  };
2024
 
2025
  // Sets for task
2026
 
2027
  static OmpClauseSet allowedClauses_OMPD_task {
2028
    llvm::omp::Clause::OMPC_private,
2029
    llvm::omp::Clause::OMPC_firstprivate,
2030
    llvm::omp::Clause::OMPC_shared,
2031
    llvm::omp::Clause::OMPC_untied,
2032
    llvm::omp::Clause::OMPC_mergeable,
2033
    llvm::omp::Clause::OMPC_depend,
2034
    llvm::omp::Clause::OMPC_in_reduction,
2035
    llvm::omp::Clause::OMPC_allocate,
2036
    llvm::omp::Clause::OMPC_detach,
2037
    llvm::omp::Clause::OMPC_affinity,
2038
  };
2039
 
2040
  static OmpClauseSet allowedOnceClauses_OMPD_task {
2041
    llvm::omp::Clause::OMPC_default,
2042
    llvm::omp::Clause::OMPC_if,
2043
    llvm::omp::Clause::OMPC_final,
2044
    llvm::omp::Clause::OMPC_priority,
2045
  };
2046
 
2047
  static OmpClauseSet allowedExclusiveClauses_OMPD_task {
2048
  };
2049
 
2050
  static OmpClauseSet requiredClauses_OMPD_task {
2051
  };
2052
 
2053
  // Sets for taskgroup
2054
 
2055
  static OmpClauseSet allowedClauses_OMPD_taskgroup {
2056
    llvm::omp::Clause::OMPC_task_reduction,
2057
    llvm::omp::Clause::OMPC_allocate,
2058
  };
2059
 
2060
  static OmpClauseSet allowedOnceClauses_OMPD_taskgroup {
2061
  };
2062
 
2063
  static OmpClauseSet allowedExclusiveClauses_OMPD_taskgroup {
2064
  };
2065
 
2066
  static OmpClauseSet requiredClauses_OMPD_taskgroup {
2067
  };
2068
 
2069
  // Sets for taskloop
2070
 
2071
  static OmpClauseSet allowedClauses_OMPD_taskloop {
2072
    llvm::omp::Clause::OMPC_shared,
2073
    llvm::omp::Clause::OMPC_private,
2074
    llvm::omp::Clause::OMPC_firstprivate,
2075
    llvm::omp::Clause::OMPC_lastprivate,
2076
    llvm::omp::Clause::OMPC_untied,
2077
    llvm::omp::Clause::OMPC_mergeable,
2078
    llvm::omp::Clause::OMPC_nogroup,
2079
    llvm::omp::Clause::OMPC_reduction,
2080
    llvm::omp::Clause::OMPC_in_reduction,
2081
    llvm::omp::Clause::OMPC_allocate,
2082
  };
2083
 
2084
  static OmpClauseSet allowedOnceClauses_OMPD_taskloop {
2085
    llvm::omp::Clause::OMPC_default,
2086
    llvm::omp::Clause::OMPC_if,
2087
    llvm::omp::Clause::OMPC_collapse,
2088
    llvm::omp::Clause::OMPC_final,
2089
    llvm::omp::Clause::OMPC_priority,
2090
  };
2091
 
2092
  static OmpClauseSet allowedExclusiveClauses_OMPD_taskloop {
2093
    llvm::omp::Clause::OMPC_grainsize,
2094
    llvm::omp::Clause::OMPC_num_tasks,
2095
  };
2096
 
2097
  static OmpClauseSet requiredClauses_OMPD_taskloop {
2098
  };
2099
 
2100
  // Sets for taskloop simd
2101
 
2102
  static OmpClauseSet allowedClauses_OMPD_taskloop_simd {
2103
    llvm::omp::Clause::OMPC_aligned,
2104
    llvm::omp::Clause::OMPC_allocate,
2105
    llvm::omp::Clause::OMPC_default,
2106
    llvm::omp::Clause::OMPC_firstprivate,
2107
    llvm::omp::Clause::OMPC_in_reduction,
2108
    llvm::omp::Clause::OMPC_lastprivate,
2109
    llvm::omp::Clause::OMPC_linear,
2110
    llvm::omp::Clause::OMPC_mergeable,
2111
    llvm::omp::Clause::OMPC_nogroup,
2112
    llvm::omp::Clause::OMPC_nontemporal,
2113
    llvm::omp::Clause::OMPC_order,
2114
    llvm::omp::Clause::OMPC_private,
2115
    llvm::omp::Clause::OMPC_reduction,
2116
    llvm::omp::Clause::OMPC_shared,
2117
    llvm::omp::Clause::OMPC_untied,
2118
  };
2119
 
2120
  static OmpClauseSet allowedOnceClauses_OMPD_taskloop_simd {
2121
    llvm::omp::Clause::OMPC_if,
2122
    llvm::omp::Clause::OMPC_collapse,
2123
    llvm::omp::Clause::OMPC_safelen,
2124
    llvm::omp::Clause::OMPC_simdlen,
2125
    llvm::omp::Clause::OMPC_final,
2126
    llvm::omp::Clause::OMPC_priority,
2127
  };
2128
 
2129
  static OmpClauseSet allowedExclusiveClauses_OMPD_taskloop_simd {
2130
    llvm::omp::Clause::OMPC_grainsize,
2131
    llvm::omp::Clause::OMPC_num_tasks,
2132
  };
2133
 
2134
  static OmpClauseSet requiredClauses_OMPD_taskloop_simd {
2135
  };
2136
 
2137
  // Sets for taskwait
2138
 
2139
  static OmpClauseSet allowedClauses_OMPD_taskwait {
2140
    llvm::omp::Clause::OMPC_depend,
2141
    llvm::omp::Clause::OMPC_nowait,
2142
  };
2143
 
2144
  static OmpClauseSet allowedOnceClauses_OMPD_taskwait {
2145
  };
2146
 
2147
  static OmpClauseSet allowedExclusiveClauses_OMPD_taskwait {
2148
  };
2149
 
2150
  static OmpClauseSet requiredClauses_OMPD_taskwait {
2151
  };
2152
 
2153
  // Sets for taskyield
2154
 
2155
  static OmpClauseSet allowedClauses_OMPD_taskyield {
2156
  };
2157
 
2158
  static OmpClauseSet allowedOnceClauses_OMPD_taskyield {
2159
  };
2160
 
2161
  static OmpClauseSet allowedExclusiveClauses_OMPD_taskyield {
2162
  };
2163
 
2164
  static OmpClauseSet requiredClauses_OMPD_taskyield {
2165
  };
2166
 
2167
  // Sets for teams
2168
 
2169
  static OmpClauseSet allowedClauses_OMPD_teams {
2170
    llvm::omp::Clause::OMPC_private,
2171
    llvm::omp::Clause::OMPC_firstprivate,
2172
    llvm::omp::Clause::OMPC_shared,
2173
    llvm::omp::Clause::OMPC_reduction,
2174
    llvm::omp::Clause::OMPC_allocate,
2175
  };
2176
 
2177
  static OmpClauseSet allowedOnceClauses_OMPD_teams {
2178
    llvm::omp::Clause::OMPC_default,
2179
    llvm::omp::Clause::OMPC_num_teams,
2180
    llvm::omp::Clause::OMPC_thread_limit,
2181
  };
2182
 
2183
  static OmpClauseSet allowedExclusiveClauses_OMPD_teams {
2184
  };
2185
 
2186
  static OmpClauseSet requiredClauses_OMPD_teams {
2187
  };
2188
 
2189
  // Sets for teams distribute
2190
 
2191
  static OmpClauseSet allowedClauses_OMPD_teams_distribute {
2192
    llvm::omp::Clause::OMPC_default,
2193
    llvm::omp::Clause::OMPC_private,
2194
    llvm::omp::Clause::OMPC_firstprivate,
2195
    llvm::omp::Clause::OMPC_shared,
2196
    llvm::omp::Clause::OMPC_reduction,
2197
    llvm::omp::Clause::OMPC_num_teams,
2198
    llvm::omp::Clause::OMPC_thread_limit,
2199
    llvm::omp::Clause::OMPC_lastprivate,
2200
    llvm::omp::Clause::OMPC_collapse,
2201
    llvm::omp::Clause::OMPC_dist_schedule,
2202
    llvm::omp::Clause::OMPC_allocate,
2203
  };
2204
 
2205
  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute {
2206
  };
2207
 
2208
  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute {
2209
  };
2210
 
2211
  static OmpClauseSet requiredClauses_OMPD_teams_distribute {
2212
  };
2213
 
2214
  // Sets for teams distribute parallel do
2215
 
2216
  static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_do {
2217
    llvm::omp::Clause::OMPC_private,
2218
    llvm::omp::Clause::OMPC_firstprivate,
2219
    llvm::omp::Clause::OMPC_lastprivate,
2220
    llvm::omp::Clause::OMPC_shared,
2221
    llvm::omp::Clause::OMPC_reduction,
2222
    llvm::omp::Clause::OMPC_allocate,
2223
    llvm::omp::Clause::OMPC_copyin,
2224
    llvm::omp::Clause::OMPC_linear,
2225
  };
2226
 
2227
  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_do {
2228
    llvm::omp::Clause::OMPC_num_teams,
2229
    llvm::omp::Clause::OMPC_thread_limit,
2230
    llvm::omp::Clause::OMPC_default,
2231
    llvm::omp::Clause::OMPC_collapse,
2232
    llvm::omp::Clause::OMPC_dist_schedule,
2233
    llvm::omp::Clause::OMPC_ordered,
2234
    llvm::omp::Clause::OMPC_order,
2235
    llvm::omp::Clause::OMPC_if,
2236
    llvm::omp::Clause::OMPC_num_threads,
2237
    llvm::omp::Clause::OMPC_proc_bind,
2238
    llvm::omp::Clause::OMPC_schedule,
2239
  };
2240
 
2241
  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_do {
2242
  };
2243
 
2244
  static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_do {
2245
  };
2246
 
2247
  // Sets for teams distribute parallel do simd
2248
 
2249
  static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_do_simd {
2250
    llvm::omp::Clause::OMPC_private,
2251
    llvm::omp::Clause::OMPC_firstprivate,
2252
    llvm::omp::Clause::OMPC_lastprivate,
2253
    llvm::omp::Clause::OMPC_allocate,
2254
    llvm::omp::Clause::OMPC_shared,
2255
    llvm::omp::Clause::OMPC_reduction,
2256
    llvm::omp::Clause::OMPC_linear,
2257
    llvm::omp::Clause::OMPC_order,
2258
    llvm::omp::Clause::OMPC_aligned,
2259
    llvm::omp::Clause::OMPC_nontemporal,
2260
  };
2261
 
2262
  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_do_simd {
2263
    llvm::omp::Clause::OMPC_default,
2264
    llvm::omp::Clause::OMPC_num_teams,
2265
    llvm::omp::Clause::OMPC_thread_limit,
2266
    llvm::omp::Clause::OMPC_collapse,
2267
    llvm::omp::Clause::OMPC_dist_schedule,
2268
    llvm::omp::Clause::OMPC_num_threads,
2269
    llvm::omp::Clause::OMPC_proc_bind,
2270
    llvm::omp::Clause::OMPC_schedule,
2271
    llvm::omp::Clause::OMPC_safelen,
2272
    llvm::omp::Clause::OMPC_simdlen,
2273
    llvm::omp::Clause::OMPC_if,
2274
  };
2275
 
2276
  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_do_simd {
2277
  };
2278
 
2279
  static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_do_simd {
2280
  };
2281
 
2282
  // Sets for teams distribute parallel for
2283
 
2284
  static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_for {
2285
    llvm::omp::Clause::OMPC_firstprivate,
2286
    llvm::omp::Clause::OMPC_lastprivate,
2287
    llvm::omp::Clause::OMPC_collapse,
2288
    llvm::omp::Clause::OMPC_dist_schedule,
2289
    llvm::omp::Clause::OMPC_if,
2290
    llvm::omp::Clause::OMPC_num_threads,
2291
    llvm::omp::Clause::OMPC_default,
2292
    llvm::omp::Clause::OMPC_proc_bind,
2293
    llvm::omp::Clause::OMPC_private,
2294
    llvm::omp::Clause::OMPC_shared,
2295
    llvm::omp::Clause::OMPC_reduction,
2296
    llvm::omp::Clause::OMPC_schedule,
2297
    llvm::omp::Clause::OMPC_num_teams,
2298
    llvm::omp::Clause::OMPC_thread_limit,
2299
    llvm::omp::Clause::OMPC_copyin,
2300
    llvm::omp::Clause::OMPC_allocate,
2301
    llvm::omp::Clause::OMPC_order,
2302
  };
2303
 
2304
  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_for {
2305
  };
2306
 
2307
  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_for {
2308
  };
2309
 
2310
  static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_for {
2311
  };
2312
 
2313
  // Sets for teams distribute parallel for simd
2314
 
2315
  static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_for_simd {
2316
    llvm::omp::Clause::OMPC_firstprivate,
2317
    llvm::omp::Clause::OMPC_lastprivate,
2318
    llvm::omp::Clause::OMPC_collapse,
2319
    llvm::omp::Clause::OMPC_dist_schedule,
2320
    llvm::omp::Clause::OMPC_if,
2321
    llvm::omp::Clause::OMPC_num_threads,
2322
    llvm::omp::Clause::OMPC_default,
2323
    llvm::omp::Clause::OMPC_proc_bind,
2324
    llvm::omp::Clause::OMPC_private,
2325
    llvm::omp::Clause::OMPC_shared,
2326
    llvm::omp::Clause::OMPC_reduction,
2327
    llvm::omp::Clause::OMPC_schedule,
2328
    llvm::omp::Clause::OMPC_linear,
2329
    llvm::omp::Clause::OMPC_aligned,
2330
    llvm::omp::Clause::OMPC_safelen,
2331
    llvm::omp::Clause::OMPC_simdlen,
2332
    llvm::omp::Clause::OMPC_num_teams,
2333
    llvm::omp::Clause::OMPC_thread_limit,
2334
    llvm::omp::Clause::OMPC_allocate,
2335
    llvm::omp::Clause::OMPC_nontemporal,
2336
    llvm::omp::Clause::OMPC_order,
2337
  };
2338
 
2339
  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_for_simd {
2340
  };
2341
 
2342
  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_for_simd {
2343
  };
2344
 
2345
  static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_for_simd {
2346
  };
2347
 
2348
  // Sets for teams distribute simd
2349
 
2350
  static OmpClauseSet allowedClauses_OMPD_teams_distribute_simd {
2351
    llvm::omp::Clause::OMPC_aligned,
2352
    llvm::omp::Clause::OMPC_allocate,
2353
    llvm::omp::Clause::OMPC_firstprivate,
2354
    llvm::omp::Clause::OMPC_lastprivate,
2355
    llvm::omp::Clause::OMPC_linear,
2356
    llvm::omp::Clause::OMPC_nontemporal,
2357
    llvm::omp::Clause::OMPC_order,
2358
    llvm::omp::Clause::OMPC_private,
2359
    llvm::omp::Clause::OMPC_reduction,
2360
    llvm::omp::Clause::OMPC_shared,
2361
  };
2362
 
2363
  static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_simd {
2364
    llvm::omp::Clause::OMPC_collapse,
2365
    llvm::omp::Clause::OMPC_default,
2366
    llvm::omp::Clause::OMPC_dist_schedule,
2367
    llvm::omp::Clause::OMPC_if,
2368
    llvm::omp::Clause::OMPC_num_teams,
2369
    llvm::omp::Clause::OMPC_safelen,
2370
    llvm::omp::Clause::OMPC_simdlen,
2371
    llvm::omp::Clause::OMPC_thread_limit,
2372
  };
2373
 
2374
  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_simd {
2375
  };
2376
 
2377
  static OmpClauseSet requiredClauses_OMPD_teams_distribute_simd {
2378
  };
2379
 
2380
  // Sets for threadprivate
2381
 
2382
  static OmpClauseSet allowedClauses_OMPD_threadprivate {
2383
  };
2384
 
2385
  static OmpClauseSet allowedOnceClauses_OMPD_threadprivate {
2386
  };
2387
 
2388
  static OmpClauseSet allowedExclusiveClauses_OMPD_threadprivate {
2389
  };
2390
 
2391
  static OmpClauseSet requiredClauses_OMPD_threadprivate {
2392
  };
2393
 
2394
  // Sets for tile
2395
 
2396
  static OmpClauseSet allowedClauses_OMPD_tile {
2397
  };
2398
 
2399
  static OmpClauseSet allowedOnceClauses_OMPD_tile {
2400
    llvm::omp::Clause::OMPC_sizes,
2401
  };
2402
 
2403
  static OmpClauseSet allowedExclusiveClauses_OMPD_tile {
2404
  };
2405
 
2406
  static OmpClauseSet requiredClauses_OMPD_tile {
2407
  };
2408
 
2409
  // Sets for unknown
2410
 
2411
  static OmpClauseSet allowedClauses_OMPD_unknown {
2412
  };
2413
 
2414
  static OmpClauseSet allowedOnceClauses_OMPD_unknown {
2415
  };
2416
 
2417
  static OmpClauseSet allowedExclusiveClauses_OMPD_unknown {
2418
  };
2419
 
2420
  static OmpClauseSet requiredClauses_OMPD_unknown {
2421
  };
2422
 
2423
  // Sets for unroll
2424
 
2425
  static OmpClauseSet allowedClauses_OMPD_unroll {
2426
  };
2427
 
2428
  static OmpClauseSet allowedOnceClauses_OMPD_unroll {
2429
    llvm::omp::Clause::OMPC_full,
2430
    llvm::omp::Clause::OMPC_partial,
2431
  };
2432
 
2433
  static OmpClauseSet allowedExclusiveClauses_OMPD_unroll {
2434
  };
2435
 
2436
  static OmpClauseSet requiredClauses_OMPD_unroll {
2437
  };
2438
 
2439
  // Sets for workshare
2440
 
2441
  static OmpClauseSet allowedClauses_OMPD_workshare {
2442
  };
2443
 
2444
  static OmpClauseSet allowedOnceClauses_OMPD_workshare {
2445
  };
2446
 
2447
  static OmpClauseSet allowedExclusiveClauses_OMPD_workshare {
2448
  };
2449
 
2450
  static OmpClauseSet requiredClauses_OMPD_workshare {
2451
  };
2452
 
2453
  // Sets for dispatch
2454
 
2455
  static OmpClauseSet allowedClauses_OMPD_dispatch {
2456
    llvm::omp::Clause::OMPC_device,
2457
    llvm::omp::Clause::OMPC_is_device_ptr,
2458
    llvm::omp::Clause::OMPC_has_device_addr,
2459
    llvm::omp::Clause::OMPC_nowait,
2460
    llvm::omp::Clause::OMPC_depend,
2461
    llvm::omp::Clause::OMPC_novariants,
2462
    llvm::omp::Clause::OMPC_nocontext,
2463
  };
2464
 
2465
  static OmpClauseSet allowedOnceClauses_OMPD_dispatch {
2466
  };
2467
 
2468
  static OmpClauseSet allowedExclusiveClauses_OMPD_dispatch {
2469
  };
2470
 
2471
  static OmpClauseSet requiredClauses_OMPD_dispatch {
2472
  };
2473
 
2474
  // Sets for interop
2475
 
2476
  static OmpClauseSet allowedClauses_OMPD_interop {
2477
    llvm::omp::Clause::OMPC_device,
2478
    llvm::omp::Clause::OMPC_depend,
2479
    llvm::omp::Clause::OMPC_destroy,
2480
    llvm::omp::Clause::OMPC_init,
2481
    llvm::omp::Clause::OMPC_nowait,
2482
    llvm::omp::Clause::OMPC_use,
2483
  };
2484
 
2485
  static OmpClauseSet allowedOnceClauses_OMPD_interop {
2486
  };
2487
 
2488
  static OmpClauseSet allowedExclusiveClauses_OMPD_interop {
2489
  };
2490
 
2491
  static OmpClauseSet requiredClauses_OMPD_interop {
2492
  };
2493
 
2494
  // Sets for loop
2495
 
2496
  static OmpClauseSet allowedClauses_OMPD_loop {
2497
    llvm::omp::Clause::OMPC_lastprivate,
2498
    llvm::omp::Clause::OMPC_private,
2499
    llvm::omp::Clause::OMPC_reduction,
2500
  };
2501
 
2502
  static OmpClauseSet allowedOnceClauses_OMPD_loop {
2503
    llvm::omp::Clause::OMPC_bind,
2504
    llvm::omp::Clause::OMPC_collapse,
2505
    llvm::omp::Clause::OMPC_order,
2506
  };
2507
 
2508
  static OmpClauseSet allowedExclusiveClauses_OMPD_loop {
2509
  };
2510
 
2511
  static OmpClauseSet requiredClauses_OMPD_loop {
2512
  };
2513
 
2514
  // Sets for masked
2515
 
2516
  static OmpClauseSet allowedClauses_OMPD_masked {
2517
  };
2518
 
2519
  static OmpClauseSet allowedOnceClauses_OMPD_masked {
2520
    llvm::omp::Clause::OMPC_filter,
2521
  };
2522
 
2523
  static OmpClauseSet allowedExclusiveClauses_OMPD_masked {
2524
  };
2525
 
2526
  static OmpClauseSet requiredClauses_OMPD_masked {
2527
  };
2528
 
2529
  // Sets for parallel loop
2530
 
2531
  static OmpClauseSet allowedClauses_OMPD_parallel_loop {
2532
    llvm::omp::Clause::OMPC_allocate,
2533
    llvm::omp::Clause::OMPC_copyin,
2534
    llvm::omp::Clause::OMPC_firstprivate,
2535
    llvm::omp::Clause::OMPC_lastprivate,
2536
    llvm::omp::Clause::OMPC_private,
2537
    llvm::omp::Clause::OMPC_reduction,
2538
    llvm::omp::Clause::OMPC_shared,
2539
  };
2540
 
2541
  static OmpClauseSet allowedOnceClauses_OMPD_parallel_loop {
2542
    llvm::omp::Clause::OMPC_bind,
2543
    llvm::omp::Clause::OMPC_collapse,
2544
    llvm::omp::Clause::OMPC_default,
2545
    llvm::omp::Clause::OMPC_if,
2546
    llvm::omp::Clause::OMPC_num_threads,
2547
    llvm::omp::Clause::OMPC_order,
2548
    llvm::omp::Clause::OMPC_proc_bind,
2549
  };
2550
 
2551
  static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_loop {
2552
  };
2553
 
2554
  static OmpClauseSet requiredClauses_OMPD_parallel_loop {
2555
  };
2556
 
2557
  // Sets for target parallel loop
2558
 
2559
  static OmpClauseSet allowedClauses_OMPD_target_parallel_loop {
2560
    llvm::omp::Clause::OMPC_allocate,
2561
    llvm::omp::Clause::OMPC_copyin,
2562
    llvm::omp::Clause::OMPC_depend,
2563
    llvm::omp::Clause::OMPC_device,
2564
    llvm::omp::Clause::OMPC_firstprivate,
2565
    llvm::omp::Clause::OMPC_is_device_ptr,
2566
    llvm::omp::Clause::OMPC_has_device_addr,
2567
    llvm::omp::Clause::OMPC_lastprivate,
2568
    llvm::omp::Clause::OMPC_map,
2569
    llvm::omp::Clause::OMPC_private,
2570
    llvm::omp::Clause::OMPC_reduction,
2571
    llvm::omp::Clause::OMPC_shared,
2572
    llvm::omp::Clause::OMPC_uses_allocators,
2573
  };
2574
 
2575
  static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_loop {
2576
    llvm::omp::Clause::OMPC_bind,
2577
    llvm::omp::Clause::OMPC_collapse,
2578
    llvm::omp::Clause::OMPC_default,
2579
    llvm::omp::Clause::OMPC_defaultmap,
2580
    llvm::omp::Clause::OMPC_if,
2581
    llvm::omp::Clause::OMPC_nowait,
2582
    llvm::omp::Clause::OMPC_num_threads,
2583
    llvm::omp::Clause::OMPC_order,
2584
    llvm::omp::Clause::OMPC_proc_bind,
2585
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
2586
  };
2587
 
2588
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_loop {
2589
  };
2590
 
2591
  static OmpClauseSet requiredClauses_OMPD_target_parallel_loop {
2592
  };
2593
 
2594
  // Sets for target teams loop
2595
 
2596
  static OmpClauseSet allowedClauses_OMPD_target_teams_loop {
2597
    llvm::omp::Clause::OMPC_allocate,
2598
    llvm::omp::Clause::OMPC_depend,
2599
    llvm::omp::Clause::OMPC_defaultmap,
2600
    llvm::omp::Clause::OMPC_device,
2601
    llvm::omp::Clause::OMPC_firstprivate,
2602
    llvm::omp::Clause::OMPC_is_device_ptr,
2603
    llvm::omp::Clause::OMPC_has_device_addr,
2604
    llvm::omp::Clause::OMPC_lastprivate,
2605
    llvm::omp::Clause::OMPC_map,
2606
    llvm::omp::Clause::OMPC_private,
2607
    llvm::omp::Clause::OMPC_reduction,
2608
    llvm::omp::Clause::OMPC_shared,
2609
    llvm::omp::Clause::OMPC_uses_allocators,
2610
  };
2611
 
2612
  static OmpClauseSet allowedOnceClauses_OMPD_target_teams_loop {
2613
    llvm::omp::Clause::OMPC_bind,
2614
    llvm::omp::Clause::OMPC_collapse,
2615
    llvm::omp::Clause::OMPC_default,
2616
    llvm::omp::Clause::OMPC_if,
2617
    llvm::omp::Clause::OMPC_nowait,
2618
    llvm::omp::Clause::OMPC_num_teams,
2619
    llvm::omp::Clause::OMPC_order,
2620
    llvm::omp::Clause::OMPC_thread_limit,
2621
    llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem,
2622
  };
2623
 
2624
  static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_loop {
2625
  };
2626
 
2627
  static OmpClauseSet requiredClauses_OMPD_target_teams_loop {
2628
  };
2629
 
2630
  // Sets for teams loop
2631
 
2632
  static OmpClauseSet allowedClauses_OMPD_teams_loop {
2633
    llvm::omp::Clause::OMPC_allocate,
2634
    llvm::omp::Clause::OMPC_firstprivate,
2635
    llvm::omp::Clause::OMPC_lastprivate,
2636
    llvm::omp::Clause::OMPC_private,
2637
    llvm::omp::Clause::OMPC_reduction,
2638
    llvm::omp::Clause::OMPC_shared,
2639
  };
2640
 
2641
  static OmpClauseSet allowedOnceClauses_OMPD_teams_loop {
2642
    llvm::omp::Clause::OMPC_bind,
2643
    llvm::omp::Clause::OMPC_collapse,
2644
    llvm::omp::Clause::OMPC_default,
2645
    llvm::omp::Clause::OMPC_num_teams,
2646
    llvm::omp::Clause::OMPC_order,
2647
    llvm::omp::Clause::OMPC_thread_limit,
2648
  };
2649
 
2650
  static OmpClauseSet allowedExclusiveClauses_OMPD_teams_loop {
2651
  };
2652
 
2653
  static OmpClauseSet requiredClauses_OMPD_teams_loop {
2654
  };
2655
} // namespace omp
2656
} // namespace llvm
2657
 
2658
#endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS
2659
 
2660
#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
2661
#undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
2662
 
2663
{
2664
  {llvm::omp::Directive::OMPD_allocate,
2665
    {
2666
      llvm::omp::allowedClauses_OMPD_allocate,
2667
      llvm::omp::allowedOnceClauses_OMPD_allocate,
2668
      llvm::omp::allowedExclusiveClauses_OMPD_allocate,
2669
      llvm::omp::requiredClauses_OMPD_allocate,
2670
    }
2671
  },
2672
  {llvm::omp::Directive::OMPD_assumes,
2673
    {
2674
      llvm::omp::allowedClauses_OMPD_assumes,
2675
      llvm::omp::allowedOnceClauses_OMPD_assumes,
2676
      llvm::omp::allowedExclusiveClauses_OMPD_assumes,
2677
      llvm::omp::requiredClauses_OMPD_assumes,
2678
    }
2679
  },
2680
  {llvm::omp::Directive::OMPD_atomic,
2681
    {
2682
      llvm::omp::allowedClauses_OMPD_atomic,
2683
      llvm::omp::allowedOnceClauses_OMPD_atomic,
2684
      llvm::omp::allowedExclusiveClauses_OMPD_atomic,
2685
      llvm::omp::requiredClauses_OMPD_atomic,
2686
    }
2687
  },
2688
  {llvm::omp::Directive::OMPD_barrier,
2689
    {
2690
      llvm::omp::allowedClauses_OMPD_barrier,
2691
      llvm::omp::allowedOnceClauses_OMPD_barrier,
2692
      llvm::omp::allowedExclusiveClauses_OMPD_barrier,
2693
      llvm::omp::requiredClauses_OMPD_barrier,
2694
    }
2695
  },
2696
  {llvm::omp::Directive::OMPD_begin_assumes,
2697
    {
2698
      llvm::omp::allowedClauses_OMPD_begin_assumes,
2699
      llvm::omp::allowedOnceClauses_OMPD_begin_assumes,
2700
      llvm::omp::allowedExclusiveClauses_OMPD_begin_assumes,
2701
      llvm::omp::requiredClauses_OMPD_begin_assumes,
2702
    }
2703
  },
2704
  {llvm::omp::Directive::OMPD_begin_declare_target,
2705
    {
2706
      llvm::omp::allowedClauses_OMPD_begin_declare_target,
2707
      llvm::omp::allowedOnceClauses_OMPD_begin_declare_target,
2708
      llvm::omp::allowedExclusiveClauses_OMPD_begin_declare_target,
2709
      llvm::omp::requiredClauses_OMPD_begin_declare_target,
2710
    }
2711
  },
2712
  {llvm::omp::Directive::OMPD_begin_declare_variant,
2713
    {
2714
      llvm::omp::allowedClauses_OMPD_begin_declare_variant,
2715
      llvm::omp::allowedOnceClauses_OMPD_begin_declare_variant,
2716
      llvm::omp::allowedExclusiveClauses_OMPD_begin_declare_variant,
2717
      llvm::omp::requiredClauses_OMPD_begin_declare_variant,
2718
    }
2719
  },
2720
  {llvm::omp::Directive::OMPD_cancel,
2721
    {
2722
      llvm::omp::allowedClauses_OMPD_cancel,
2723
      llvm::omp::allowedOnceClauses_OMPD_cancel,
2724
      llvm::omp::allowedExclusiveClauses_OMPD_cancel,
2725
      llvm::omp::requiredClauses_OMPD_cancel,
2726
    }
2727
  },
2728
  {llvm::omp::Directive::OMPD_cancellation_point,
2729
    {
2730
      llvm::omp::allowedClauses_OMPD_cancellation_point,
2731
      llvm::omp::allowedOnceClauses_OMPD_cancellation_point,
2732
      llvm::omp::allowedExclusiveClauses_OMPD_cancellation_point,
2733
      llvm::omp::requiredClauses_OMPD_cancellation_point,
2734
    }
2735
  },
2736
  {llvm::omp::Directive::OMPD_critical,
2737
    {
2738
      llvm::omp::allowedClauses_OMPD_critical,
2739
      llvm::omp::allowedOnceClauses_OMPD_critical,
2740
      llvm::omp::allowedExclusiveClauses_OMPD_critical,
2741
      llvm::omp::requiredClauses_OMPD_critical,
2742
    }
2743
  },
2744
  {llvm::omp::Directive::OMPD_declare_mapper,
2745
    {
2746
      llvm::omp::allowedClauses_OMPD_declare_mapper,
2747
      llvm::omp::allowedOnceClauses_OMPD_declare_mapper,
2748
      llvm::omp::allowedExclusiveClauses_OMPD_declare_mapper,
2749
      llvm::omp::requiredClauses_OMPD_declare_mapper,
2750
    }
2751
  },
2752
  {llvm::omp::Directive::OMPD_declare_reduction,
2753
    {
2754
      llvm::omp::allowedClauses_OMPD_declare_reduction,
2755
      llvm::omp::allowedOnceClauses_OMPD_declare_reduction,
2756
      llvm::omp::allowedExclusiveClauses_OMPD_declare_reduction,
2757
      llvm::omp::requiredClauses_OMPD_declare_reduction,
2758
    }
2759
  },
2760
  {llvm::omp::Directive::OMPD_declare_simd,
2761
    {
2762
      llvm::omp::allowedClauses_OMPD_declare_simd,
2763
      llvm::omp::allowedOnceClauses_OMPD_declare_simd,
2764
      llvm::omp::allowedExclusiveClauses_OMPD_declare_simd,
2765
      llvm::omp::requiredClauses_OMPD_declare_simd,
2766
    }
2767
  },
2768
  {llvm::omp::Directive::OMPD_declare_target,
2769
    {
2770
      llvm::omp::allowedClauses_OMPD_declare_target,
2771
      llvm::omp::allowedOnceClauses_OMPD_declare_target,
2772
      llvm::omp::allowedExclusiveClauses_OMPD_declare_target,
2773
      llvm::omp::requiredClauses_OMPD_declare_target,
2774
    }
2775
  },
2776
  {llvm::omp::Directive::OMPD_declare_variant,
2777
    {
2778
      llvm::omp::allowedClauses_OMPD_declare_variant,
2779
      llvm::omp::allowedOnceClauses_OMPD_declare_variant,
2780
      llvm::omp::allowedExclusiveClauses_OMPD_declare_variant,
2781
      llvm::omp::requiredClauses_OMPD_declare_variant,
2782
    }
2783
  },
2784
  {llvm::omp::Directive::OMPD_depobj,
2785
    {
2786
      llvm::omp::allowedClauses_OMPD_depobj,
2787
      llvm::omp::allowedOnceClauses_OMPD_depobj,
2788
      llvm::omp::allowedExclusiveClauses_OMPD_depobj,
2789
      llvm::omp::requiredClauses_OMPD_depobj,
2790
    }
2791
  },
2792
  {llvm::omp::Directive::OMPD_distribute,
2793
    {
2794
      llvm::omp::allowedClauses_OMPD_distribute,
2795
      llvm::omp::allowedOnceClauses_OMPD_distribute,
2796
      llvm::omp::allowedExclusiveClauses_OMPD_distribute,
2797
      llvm::omp::requiredClauses_OMPD_distribute,
2798
    }
2799
  },
2800
  {llvm::omp::Directive::OMPD_distribute_parallel_do,
2801
    {
2802
      llvm::omp::allowedClauses_OMPD_distribute_parallel_do,
2803
      llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_do,
2804
      llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_do,
2805
      llvm::omp::requiredClauses_OMPD_distribute_parallel_do,
2806
    }
2807
  },
2808
  {llvm::omp::Directive::OMPD_distribute_parallel_do_simd,
2809
    {
2810
      llvm::omp::allowedClauses_OMPD_distribute_parallel_do_simd,
2811
      llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_do_simd,
2812
      llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_do_simd,
2813
      llvm::omp::requiredClauses_OMPD_distribute_parallel_do_simd,
2814
    }
2815
  },
2816
  {llvm::omp::Directive::OMPD_distribute_parallel_for,
2817
    {
2818
      llvm::omp::allowedClauses_OMPD_distribute_parallel_for,
2819
      llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_for,
2820
      llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_for,
2821
      llvm::omp::requiredClauses_OMPD_distribute_parallel_for,
2822
    }
2823
  },
2824
  {llvm::omp::Directive::OMPD_distribute_parallel_for_simd,
2825
    {
2826
      llvm::omp::allowedClauses_OMPD_distribute_parallel_for_simd,
2827
      llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_for_simd,
2828
      llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_for_simd,
2829
      llvm::omp::requiredClauses_OMPD_distribute_parallel_for_simd,
2830
    }
2831
  },
2832
  {llvm::omp::Directive::OMPD_distribute_simd,
2833
    {
2834
      llvm::omp::allowedClauses_OMPD_distribute_simd,
2835
      llvm::omp::allowedOnceClauses_OMPD_distribute_simd,
2836
      llvm::omp::allowedExclusiveClauses_OMPD_distribute_simd,
2837
      llvm::omp::requiredClauses_OMPD_distribute_simd,
2838
    }
2839
  },
2840
  {llvm::omp::Directive::OMPD_do,
2841
    {
2842
      llvm::omp::allowedClauses_OMPD_do,
2843
      llvm::omp::allowedOnceClauses_OMPD_do,
2844
      llvm::omp::allowedExclusiveClauses_OMPD_do,
2845
      llvm::omp::requiredClauses_OMPD_do,
2846
    }
2847
  },
2848
  {llvm::omp::Directive::OMPD_do_simd,
2849
    {
2850
      llvm::omp::allowedClauses_OMPD_do_simd,
2851
      llvm::omp::allowedOnceClauses_OMPD_do_simd,
2852
      llvm::omp::allowedExclusiveClauses_OMPD_do_simd,
2853
      llvm::omp::requiredClauses_OMPD_do_simd,
2854
    }
2855
  },
2856
  {llvm::omp::Directive::OMPD_end_assumes,
2857
    {
2858
      llvm::omp::allowedClauses_OMPD_end_assumes,
2859
      llvm::omp::allowedOnceClauses_OMPD_end_assumes,
2860
      llvm::omp::allowedExclusiveClauses_OMPD_end_assumes,
2861
      llvm::omp::requiredClauses_OMPD_end_assumes,
2862
    }
2863
  },
2864
  {llvm::omp::Directive::OMPD_end_declare_target,
2865
    {
2866
      llvm::omp::allowedClauses_OMPD_end_declare_target,
2867
      llvm::omp::allowedOnceClauses_OMPD_end_declare_target,
2868
      llvm::omp::allowedExclusiveClauses_OMPD_end_declare_target,
2869
      llvm::omp::requiredClauses_OMPD_end_declare_target,
2870
    }
2871
  },
2872
  {llvm::omp::Directive::OMPD_end_declare_variant,
2873
    {
2874
      llvm::omp::allowedClauses_OMPD_end_declare_variant,
2875
      llvm::omp::allowedOnceClauses_OMPD_end_declare_variant,
2876
      llvm::omp::allowedExclusiveClauses_OMPD_end_declare_variant,
2877
      llvm::omp::requiredClauses_OMPD_end_declare_variant,
2878
    }
2879
  },
2880
  {llvm::omp::Directive::OMPD_end_do,
2881
    {
2882
      llvm::omp::allowedClauses_OMPD_end_do,
2883
      llvm::omp::allowedOnceClauses_OMPD_end_do,
2884
      llvm::omp::allowedExclusiveClauses_OMPD_end_do,
2885
      llvm::omp::requiredClauses_OMPD_end_do,
2886
    }
2887
  },
2888
  {llvm::omp::Directive::OMPD_end_do_simd,
2889
    {
2890
      llvm::omp::allowedClauses_OMPD_end_do_simd,
2891
      llvm::omp::allowedOnceClauses_OMPD_end_do_simd,
2892
      llvm::omp::allowedExclusiveClauses_OMPD_end_do_simd,
2893
      llvm::omp::requiredClauses_OMPD_end_do_simd,
2894
    }
2895
  },
2896
  {llvm::omp::Directive::OMPD_end_sections,
2897
    {
2898
      llvm::omp::allowedClauses_OMPD_end_sections,
2899
      llvm::omp::allowedOnceClauses_OMPD_end_sections,
2900
      llvm::omp::allowedExclusiveClauses_OMPD_end_sections,
2901
      llvm::omp::requiredClauses_OMPD_end_sections,
2902
    }
2903
  },
2904
  {llvm::omp::Directive::OMPD_end_single,
2905
    {
2906
      llvm::omp::allowedClauses_OMPD_end_single,
2907
      llvm::omp::allowedOnceClauses_OMPD_end_single,
2908
      llvm::omp::allowedExclusiveClauses_OMPD_end_single,
2909
      llvm::omp::requiredClauses_OMPD_end_single,
2910
    }
2911
  },
2912
  {llvm::omp::Directive::OMPD_end_workshare,
2913
    {
2914
      llvm::omp::allowedClauses_OMPD_end_workshare,
2915
      llvm::omp::allowedOnceClauses_OMPD_end_workshare,
2916
      llvm::omp::allowedExclusiveClauses_OMPD_end_workshare,
2917
      llvm::omp::requiredClauses_OMPD_end_workshare,
2918
    }
2919
  },
2920
  {llvm::omp::Directive::OMPD_error,
2921
    {
2922
      llvm::omp::allowedClauses_OMPD_error,
2923
      llvm::omp::allowedOnceClauses_OMPD_error,
2924
      llvm::omp::allowedExclusiveClauses_OMPD_error,
2925
      llvm::omp::requiredClauses_OMPD_error,
2926
    }
2927
  },
2928
  {llvm::omp::Directive::OMPD_flush,
2929
    {
2930
      llvm::omp::allowedClauses_OMPD_flush,
2931
      llvm::omp::allowedOnceClauses_OMPD_flush,
2932
      llvm::omp::allowedExclusiveClauses_OMPD_flush,
2933
      llvm::omp::requiredClauses_OMPD_flush,
2934
    }
2935
  },
2936
  {llvm::omp::Directive::OMPD_for,
2937
    {
2938
      llvm::omp::allowedClauses_OMPD_for,
2939
      llvm::omp::allowedOnceClauses_OMPD_for,
2940
      llvm::omp::allowedExclusiveClauses_OMPD_for,
2941
      llvm::omp::requiredClauses_OMPD_for,
2942
    }
2943
  },
2944
  {llvm::omp::Directive::OMPD_for_simd,
2945
    {
2946
      llvm::omp::allowedClauses_OMPD_for_simd,
2947
      llvm::omp::allowedOnceClauses_OMPD_for_simd,
2948
      llvm::omp::allowedExclusiveClauses_OMPD_for_simd,
2949
      llvm::omp::requiredClauses_OMPD_for_simd,
2950
    }
2951
  },
2952
  {llvm::omp::Directive::OMPD_masked_taskloop,
2953
    {
2954
      llvm::omp::allowedClauses_OMPD_masked_taskloop,
2955
      llvm::omp::allowedOnceClauses_OMPD_masked_taskloop,
2956
      llvm::omp::allowedExclusiveClauses_OMPD_masked_taskloop,
2957
      llvm::omp::requiredClauses_OMPD_masked_taskloop,
2958
    }
2959
  },
2960
  {llvm::omp::Directive::OMPD_masked_taskloop_simd,
2961
    {
2962
      llvm::omp::allowedClauses_OMPD_masked_taskloop_simd,
2963
      llvm::omp::allowedOnceClauses_OMPD_masked_taskloop_simd,
2964
      llvm::omp::allowedExclusiveClauses_OMPD_masked_taskloop_simd,
2965
      llvm::omp::requiredClauses_OMPD_masked_taskloop_simd,
2966
    }
2967
  },
2968
  {llvm::omp::Directive::OMPD_master,
2969
    {
2970
      llvm::omp::allowedClauses_OMPD_master,
2971
      llvm::omp::allowedOnceClauses_OMPD_master,
2972
      llvm::omp::allowedExclusiveClauses_OMPD_master,
2973
      llvm::omp::requiredClauses_OMPD_master,
2974
    }
2975
  },
2976
  {llvm::omp::Directive::OMPD_master_taskloop,
2977
    {
2978
      llvm::omp::allowedClauses_OMPD_master_taskloop,
2979
      llvm::omp::allowedOnceClauses_OMPD_master_taskloop,
2980
      llvm::omp::allowedExclusiveClauses_OMPD_master_taskloop,
2981
      llvm::omp::requiredClauses_OMPD_master_taskloop,
2982
    }
2983
  },
2984
  {llvm::omp::Directive::OMPD_master_taskloop_simd,
2985
    {
2986
      llvm::omp::allowedClauses_OMPD_master_taskloop_simd,
2987
      llvm::omp::allowedOnceClauses_OMPD_master_taskloop_simd,
2988
      llvm::omp::allowedExclusiveClauses_OMPD_master_taskloop_simd,
2989
      llvm::omp::requiredClauses_OMPD_master_taskloop_simd,
2990
    }
2991
  },
2992
  {llvm::omp::Directive::OMPD_metadirective,
2993
    {
2994
      llvm::omp::allowedClauses_OMPD_metadirective,
2995
      llvm::omp::allowedOnceClauses_OMPD_metadirective,
2996
      llvm::omp::allowedExclusiveClauses_OMPD_metadirective,
2997
      llvm::omp::requiredClauses_OMPD_metadirective,
2998
    }
2999
  },
3000
  {llvm::omp::Directive::OMPD_nothing,
3001
    {
3002
      llvm::omp::allowedClauses_OMPD_nothing,
3003
      llvm::omp::allowedOnceClauses_OMPD_nothing,
3004
      llvm::omp::allowedExclusiveClauses_OMPD_nothing,
3005
      llvm::omp::requiredClauses_OMPD_nothing,
3006
    }
3007
  },
3008
  {llvm::omp::Directive::OMPD_ordered,
3009
    {
3010
      llvm::omp::allowedClauses_OMPD_ordered,
3011
      llvm::omp::allowedOnceClauses_OMPD_ordered,
3012
      llvm::omp::allowedExclusiveClauses_OMPD_ordered,
3013
      llvm::omp::requiredClauses_OMPD_ordered,
3014
    }
3015
  },
3016
  {llvm::omp::Directive::OMPD_parallel,
3017
    {
3018
      llvm::omp::allowedClauses_OMPD_parallel,
3019
      llvm::omp::allowedOnceClauses_OMPD_parallel,
3020
      llvm::omp::allowedExclusiveClauses_OMPD_parallel,
3021
      llvm::omp::requiredClauses_OMPD_parallel,
3022
    }
3023
  },
3024
  {llvm::omp::Directive::OMPD_parallel_do,
3025
    {
3026
      llvm::omp::allowedClauses_OMPD_parallel_do,
3027
      llvm::omp::allowedOnceClauses_OMPD_parallel_do,
3028
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_do,
3029
      llvm::omp::requiredClauses_OMPD_parallel_do,
3030
    }
3031
  },
3032
  {llvm::omp::Directive::OMPD_parallel_do_simd,
3033
    {
3034
      llvm::omp::allowedClauses_OMPD_parallel_do_simd,
3035
      llvm::omp::allowedOnceClauses_OMPD_parallel_do_simd,
3036
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_do_simd,
3037
      llvm::omp::requiredClauses_OMPD_parallel_do_simd,
3038
    }
3039
  },
3040
  {llvm::omp::Directive::OMPD_parallel_for,
3041
    {
3042
      llvm::omp::allowedClauses_OMPD_parallel_for,
3043
      llvm::omp::allowedOnceClauses_OMPD_parallel_for,
3044
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_for,
3045
      llvm::omp::requiredClauses_OMPD_parallel_for,
3046
    }
3047
  },
3048
  {llvm::omp::Directive::OMPD_parallel_for_simd,
3049
    {
3050
      llvm::omp::allowedClauses_OMPD_parallel_for_simd,
3051
      llvm::omp::allowedOnceClauses_OMPD_parallel_for_simd,
3052
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_for_simd,
3053
      llvm::omp::requiredClauses_OMPD_parallel_for_simd,
3054
    }
3055
  },
3056
  {llvm::omp::Directive::OMPD_parallel_masked,
3057
    {
3058
      llvm::omp::allowedClauses_OMPD_parallel_masked,
3059
      llvm::omp::allowedOnceClauses_OMPD_parallel_masked,
3060
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_masked,
3061
      llvm::omp::requiredClauses_OMPD_parallel_masked,
3062
    }
3063
  },
3064
  {llvm::omp::Directive::OMPD_parallel_masked_taskloop,
3065
    {
3066
      llvm::omp::allowedClauses_OMPD_parallel_masked_taskloop,
3067
      llvm::omp::allowedOnceClauses_OMPD_parallel_masked_taskloop,
3068
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_masked_taskloop,
3069
      llvm::omp::requiredClauses_OMPD_parallel_masked_taskloop,
3070
    }
3071
  },
3072
  {llvm::omp::Directive::OMPD_parallel_masked_taskloop_simd,
3073
    {
3074
      llvm::omp::allowedClauses_OMPD_parallel_masked_taskloop_simd,
3075
      llvm::omp::allowedOnceClauses_OMPD_parallel_masked_taskloop_simd,
3076
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_masked_taskloop_simd,
3077
      llvm::omp::requiredClauses_OMPD_parallel_masked_taskloop_simd,
3078
    }
3079
  },
3080
  {llvm::omp::Directive::OMPD_parallel_master,
3081
    {
3082
      llvm::omp::allowedClauses_OMPD_parallel_master,
3083
      llvm::omp::allowedOnceClauses_OMPD_parallel_master,
3084
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_master,
3085
      llvm::omp::requiredClauses_OMPD_parallel_master,
3086
    }
3087
  },
3088
  {llvm::omp::Directive::OMPD_parallel_master_taskloop,
3089
    {
3090
      llvm::omp::allowedClauses_OMPD_parallel_master_taskloop,
3091
      llvm::omp::allowedOnceClauses_OMPD_parallel_master_taskloop,
3092
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_master_taskloop,
3093
      llvm::omp::requiredClauses_OMPD_parallel_master_taskloop,
3094
    }
3095
  },
3096
  {llvm::omp::Directive::OMPD_parallel_master_taskloop_simd,
3097
    {
3098
      llvm::omp::allowedClauses_OMPD_parallel_master_taskloop_simd,
3099
      llvm::omp::allowedOnceClauses_OMPD_parallel_master_taskloop_simd,
3100
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_master_taskloop_simd,
3101
      llvm::omp::requiredClauses_OMPD_parallel_master_taskloop_simd,
3102
    }
3103
  },
3104
  {llvm::omp::Directive::OMPD_parallel_sections,
3105
    {
3106
      llvm::omp::allowedClauses_OMPD_parallel_sections,
3107
      llvm::omp::allowedOnceClauses_OMPD_parallel_sections,
3108
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_sections,
3109
      llvm::omp::requiredClauses_OMPD_parallel_sections,
3110
    }
3111
  },
3112
  {llvm::omp::Directive::OMPD_parallel_workshare,
3113
    {
3114
      llvm::omp::allowedClauses_OMPD_parallel_workshare,
3115
      llvm::omp::allowedOnceClauses_OMPD_parallel_workshare,
3116
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_workshare,
3117
      llvm::omp::requiredClauses_OMPD_parallel_workshare,
3118
    }
3119
  },
3120
  {llvm::omp::Directive::OMPD_requires,
3121
    {
3122
      llvm::omp::allowedClauses_OMPD_requires,
3123
      llvm::omp::allowedOnceClauses_OMPD_requires,
3124
      llvm::omp::allowedExclusiveClauses_OMPD_requires,
3125
      llvm::omp::requiredClauses_OMPD_requires,
3126
    }
3127
  },
3128
  {llvm::omp::Directive::OMPD_scan,
3129
    {
3130
      llvm::omp::allowedClauses_OMPD_scan,
3131
      llvm::omp::allowedOnceClauses_OMPD_scan,
3132
      llvm::omp::allowedExclusiveClauses_OMPD_scan,
3133
      llvm::omp::requiredClauses_OMPD_scan,
3134
    }
3135
  },
3136
  {llvm::omp::Directive::OMPD_section,
3137
    {
3138
      llvm::omp::allowedClauses_OMPD_section,
3139
      llvm::omp::allowedOnceClauses_OMPD_section,
3140
      llvm::omp::allowedExclusiveClauses_OMPD_section,
3141
      llvm::omp::requiredClauses_OMPD_section,
3142
    }
3143
  },
3144
  {llvm::omp::Directive::OMPD_sections,
3145
    {
3146
      llvm::omp::allowedClauses_OMPD_sections,
3147
      llvm::omp::allowedOnceClauses_OMPD_sections,
3148
      llvm::omp::allowedExclusiveClauses_OMPD_sections,
3149
      llvm::omp::requiredClauses_OMPD_sections,
3150
    }
3151
  },
3152
  {llvm::omp::Directive::OMPD_simd,
3153
    {
3154
      llvm::omp::allowedClauses_OMPD_simd,
3155
      llvm::omp::allowedOnceClauses_OMPD_simd,
3156
      llvm::omp::allowedExclusiveClauses_OMPD_simd,
3157
      llvm::omp::requiredClauses_OMPD_simd,
3158
    }
3159
  },
3160
  {llvm::omp::Directive::OMPD_single,
3161
    {
3162
      llvm::omp::allowedClauses_OMPD_single,
3163
      llvm::omp::allowedOnceClauses_OMPD_single,
3164
      llvm::omp::allowedExclusiveClauses_OMPD_single,
3165
      llvm::omp::requiredClauses_OMPD_single,
3166
    }
3167
  },
3168
  {llvm::omp::Directive::OMPD_target,
3169
    {
3170
      llvm::omp::allowedClauses_OMPD_target,
3171
      llvm::omp::allowedOnceClauses_OMPD_target,
3172
      llvm::omp::allowedExclusiveClauses_OMPD_target,
3173
      llvm::omp::requiredClauses_OMPD_target,
3174
    }
3175
  },
3176
  {llvm::omp::Directive::OMPD_target_data,
3177
    {
3178
      llvm::omp::allowedClauses_OMPD_target_data,
3179
      llvm::omp::allowedOnceClauses_OMPD_target_data,
3180
      llvm::omp::allowedExclusiveClauses_OMPD_target_data,
3181
      llvm::omp::requiredClauses_OMPD_target_data,
3182
    }
3183
  },
3184
  {llvm::omp::Directive::OMPD_target_enter_data,
3185
    {
3186
      llvm::omp::allowedClauses_OMPD_target_enter_data,
3187
      llvm::omp::allowedOnceClauses_OMPD_target_enter_data,
3188
      llvm::omp::allowedExclusiveClauses_OMPD_target_enter_data,
3189
      llvm::omp::requiredClauses_OMPD_target_enter_data,
3190
    }
3191
  },
3192
  {llvm::omp::Directive::OMPD_target_exit_data,
3193
    {
3194
      llvm::omp::allowedClauses_OMPD_target_exit_data,
3195
      llvm::omp::allowedOnceClauses_OMPD_target_exit_data,
3196
      llvm::omp::allowedExclusiveClauses_OMPD_target_exit_data,
3197
      llvm::omp::requiredClauses_OMPD_target_exit_data,
3198
    }
3199
  },
3200
  {llvm::omp::Directive::OMPD_target_parallel,
3201
    {
3202
      llvm::omp::allowedClauses_OMPD_target_parallel,
3203
      llvm::omp::allowedOnceClauses_OMPD_target_parallel,
3204
      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel,
3205
      llvm::omp::requiredClauses_OMPD_target_parallel,
3206
    }
3207
  },
3208
  {llvm::omp::Directive::OMPD_target_parallel_do,
3209
    {
3210
      llvm::omp::allowedClauses_OMPD_target_parallel_do,
3211
      llvm::omp::allowedOnceClauses_OMPD_target_parallel_do,
3212
      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_do,
3213
      llvm::omp::requiredClauses_OMPD_target_parallel_do,
3214
    }
3215
  },
3216
  {llvm::omp::Directive::OMPD_target_parallel_do_simd,
3217
    {
3218
      llvm::omp::allowedClauses_OMPD_target_parallel_do_simd,
3219
      llvm::omp::allowedOnceClauses_OMPD_target_parallel_do_simd,
3220
      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_do_simd,
3221
      llvm::omp::requiredClauses_OMPD_target_parallel_do_simd,
3222
    }
3223
  },
3224
  {llvm::omp::Directive::OMPD_target_parallel_for,
3225
    {
3226
      llvm::omp::allowedClauses_OMPD_target_parallel_for,
3227
      llvm::omp::allowedOnceClauses_OMPD_target_parallel_for,
3228
      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_for,
3229
      llvm::omp::requiredClauses_OMPD_target_parallel_for,
3230
    }
3231
  },
3232
  {llvm::omp::Directive::OMPD_target_parallel_for_simd,
3233
    {
3234
      llvm::omp::allowedClauses_OMPD_target_parallel_for_simd,
3235
      llvm::omp::allowedOnceClauses_OMPD_target_parallel_for_simd,
3236
      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_for_simd,
3237
      llvm::omp::requiredClauses_OMPD_target_parallel_for_simd,
3238
    }
3239
  },
3240
  {llvm::omp::Directive::OMPD_target_simd,
3241
    {
3242
      llvm::omp::allowedClauses_OMPD_target_simd,
3243
      llvm::omp::allowedOnceClauses_OMPD_target_simd,
3244
      llvm::omp::allowedExclusiveClauses_OMPD_target_simd,
3245
      llvm::omp::requiredClauses_OMPD_target_simd,
3246
    }
3247
  },
3248
  {llvm::omp::Directive::OMPD_target_teams,
3249
    {
3250
      llvm::omp::allowedClauses_OMPD_target_teams,
3251
      llvm::omp::allowedOnceClauses_OMPD_target_teams,
3252
      llvm::omp::allowedExclusiveClauses_OMPD_target_teams,
3253
      llvm::omp::requiredClauses_OMPD_target_teams,
3254
    }
3255
  },
3256
  {llvm::omp::Directive::OMPD_target_teams_distribute,
3257
    {
3258
      llvm::omp::allowedClauses_OMPD_target_teams_distribute,
3259
      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute,
3260
      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute,
3261
      llvm::omp::requiredClauses_OMPD_target_teams_distribute,
3262
    }
3263
  },
3264
  {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do,
3265
    {
3266
      llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_do,
3267
      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_do,
3268
      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do,
3269
      llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_do,
3270
    }
3271
  },
3272
  {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd,
3273
    {
3274
      llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_do_simd,
3275
      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_do_simd,
3276
      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do_simd,
3277
      llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_do_simd,
3278
    }
3279
  },
3280
  {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for,
3281
    {
3282
      llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_for,
3283
      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_for,
3284
      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for,
3285
      llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_for,
3286
    }
3287
  },
3288
  {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for_simd,
3289
    {
3290
      llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_for_simd,
3291
      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_for_simd,
3292
      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for_simd,
3293
      llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_for_simd,
3294
    }
3295
  },
3296
  {llvm::omp::Directive::OMPD_target_teams_distribute_simd,
3297
    {
3298
      llvm::omp::allowedClauses_OMPD_target_teams_distribute_simd,
3299
      llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_simd,
3300
      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_simd,
3301
      llvm::omp::requiredClauses_OMPD_target_teams_distribute_simd,
3302
    }
3303
  },
3304
  {llvm::omp::Directive::OMPD_target_update,
3305
    {
3306
      llvm::omp::allowedClauses_OMPD_target_update,
3307
      llvm::omp::allowedOnceClauses_OMPD_target_update,
3308
      llvm::omp::allowedExclusiveClauses_OMPD_target_update,
3309
      llvm::omp::requiredClauses_OMPD_target_update,
3310
    }
3311
  },
3312
  {llvm::omp::Directive::OMPD_task,
3313
    {
3314
      llvm::omp::allowedClauses_OMPD_task,
3315
      llvm::omp::allowedOnceClauses_OMPD_task,
3316
      llvm::omp::allowedExclusiveClauses_OMPD_task,
3317
      llvm::omp::requiredClauses_OMPD_task,
3318
    }
3319
  },
3320
  {llvm::omp::Directive::OMPD_taskgroup,
3321
    {
3322
      llvm::omp::allowedClauses_OMPD_taskgroup,
3323
      llvm::omp::allowedOnceClauses_OMPD_taskgroup,
3324
      llvm::omp::allowedExclusiveClauses_OMPD_taskgroup,
3325
      llvm::omp::requiredClauses_OMPD_taskgroup,
3326
    }
3327
  },
3328
  {llvm::omp::Directive::OMPD_taskloop,
3329
    {
3330
      llvm::omp::allowedClauses_OMPD_taskloop,
3331
      llvm::omp::allowedOnceClauses_OMPD_taskloop,
3332
      llvm::omp::allowedExclusiveClauses_OMPD_taskloop,
3333
      llvm::omp::requiredClauses_OMPD_taskloop,
3334
    }
3335
  },
3336
  {llvm::omp::Directive::OMPD_taskloop_simd,
3337
    {
3338
      llvm::omp::allowedClauses_OMPD_taskloop_simd,
3339
      llvm::omp::allowedOnceClauses_OMPD_taskloop_simd,
3340
      llvm::omp::allowedExclusiveClauses_OMPD_taskloop_simd,
3341
      llvm::omp::requiredClauses_OMPD_taskloop_simd,
3342
    }
3343
  },
3344
  {llvm::omp::Directive::OMPD_taskwait,
3345
    {
3346
      llvm::omp::allowedClauses_OMPD_taskwait,
3347
      llvm::omp::allowedOnceClauses_OMPD_taskwait,
3348
      llvm::omp::allowedExclusiveClauses_OMPD_taskwait,
3349
      llvm::omp::requiredClauses_OMPD_taskwait,
3350
    }
3351
  },
3352
  {llvm::omp::Directive::OMPD_taskyield,
3353
    {
3354
      llvm::omp::allowedClauses_OMPD_taskyield,
3355
      llvm::omp::allowedOnceClauses_OMPD_taskyield,
3356
      llvm::omp::allowedExclusiveClauses_OMPD_taskyield,
3357
      llvm::omp::requiredClauses_OMPD_taskyield,
3358
    }
3359
  },
3360
  {llvm::omp::Directive::OMPD_teams,
3361
    {
3362
      llvm::omp::allowedClauses_OMPD_teams,
3363
      llvm::omp::allowedOnceClauses_OMPD_teams,
3364
      llvm::omp::allowedExclusiveClauses_OMPD_teams,
3365
      llvm::omp::requiredClauses_OMPD_teams,
3366
    }
3367
  },
3368
  {llvm::omp::Directive::OMPD_teams_distribute,
3369
    {
3370
      llvm::omp::allowedClauses_OMPD_teams_distribute,
3371
      llvm::omp::allowedOnceClauses_OMPD_teams_distribute,
3372
      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute,
3373
      llvm::omp::requiredClauses_OMPD_teams_distribute,
3374
    }
3375
  },
3376
  {llvm::omp::Directive::OMPD_teams_distribute_parallel_do,
3377
    {
3378
      llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_do,
3379
      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_do,
3380
      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_do,
3381
      llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_do,
3382
    }
3383
  },
3384
  {llvm::omp::Directive::OMPD_teams_distribute_parallel_do_simd,
3385
    {
3386
      llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_do_simd,
3387
      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_do_simd,
3388
      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_do_simd,
3389
      llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_do_simd,
3390
    }
3391
  },
3392
  {llvm::omp::Directive::OMPD_teams_distribute_parallel_for,
3393
    {
3394
      llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_for,
3395
      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_for,
3396
      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_for,
3397
      llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_for,
3398
    }
3399
  },
3400
  {llvm::omp::Directive::OMPD_teams_distribute_parallel_for_simd,
3401
    {
3402
      llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_for_simd,
3403
      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_for_simd,
3404
      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_for_simd,
3405
      llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_for_simd,
3406
    }
3407
  },
3408
  {llvm::omp::Directive::OMPD_teams_distribute_simd,
3409
    {
3410
      llvm::omp::allowedClauses_OMPD_teams_distribute_simd,
3411
      llvm::omp::allowedOnceClauses_OMPD_teams_distribute_simd,
3412
      llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_simd,
3413
      llvm::omp::requiredClauses_OMPD_teams_distribute_simd,
3414
    }
3415
  },
3416
  {llvm::omp::Directive::OMPD_threadprivate,
3417
    {
3418
      llvm::omp::allowedClauses_OMPD_threadprivate,
3419
      llvm::omp::allowedOnceClauses_OMPD_threadprivate,
3420
      llvm::omp::allowedExclusiveClauses_OMPD_threadprivate,
3421
      llvm::omp::requiredClauses_OMPD_threadprivate,
3422
    }
3423
  },
3424
  {llvm::omp::Directive::OMPD_tile,
3425
    {
3426
      llvm::omp::allowedClauses_OMPD_tile,
3427
      llvm::omp::allowedOnceClauses_OMPD_tile,
3428
      llvm::omp::allowedExclusiveClauses_OMPD_tile,
3429
      llvm::omp::requiredClauses_OMPD_tile,
3430
    }
3431
  },
3432
  {llvm::omp::Directive::OMPD_unknown,
3433
    {
3434
      llvm::omp::allowedClauses_OMPD_unknown,
3435
      llvm::omp::allowedOnceClauses_OMPD_unknown,
3436
      llvm::omp::allowedExclusiveClauses_OMPD_unknown,
3437
      llvm::omp::requiredClauses_OMPD_unknown,
3438
    }
3439
  },
3440
  {llvm::omp::Directive::OMPD_unroll,
3441
    {
3442
      llvm::omp::allowedClauses_OMPD_unroll,
3443
      llvm::omp::allowedOnceClauses_OMPD_unroll,
3444
      llvm::omp::allowedExclusiveClauses_OMPD_unroll,
3445
      llvm::omp::requiredClauses_OMPD_unroll,
3446
    }
3447
  },
3448
  {llvm::omp::Directive::OMPD_workshare,
3449
    {
3450
      llvm::omp::allowedClauses_OMPD_workshare,
3451
      llvm::omp::allowedOnceClauses_OMPD_workshare,
3452
      llvm::omp::allowedExclusiveClauses_OMPD_workshare,
3453
      llvm::omp::requiredClauses_OMPD_workshare,
3454
    }
3455
  },
3456
  {llvm::omp::Directive::OMPD_dispatch,
3457
    {
3458
      llvm::omp::allowedClauses_OMPD_dispatch,
3459
      llvm::omp::allowedOnceClauses_OMPD_dispatch,
3460
      llvm::omp::allowedExclusiveClauses_OMPD_dispatch,
3461
      llvm::omp::requiredClauses_OMPD_dispatch,
3462
    }
3463
  },
3464
  {llvm::omp::Directive::OMPD_interop,
3465
    {
3466
      llvm::omp::allowedClauses_OMPD_interop,
3467
      llvm::omp::allowedOnceClauses_OMPD_interop,
3468
      llvm::omp::allowedExclusiveClauses_OMPD_interop,
3469
      llvm::omp::requiredClauses_OMPD_interop,
3470
    }
3471
  },
3472
  {llvm::omp::Directive::OMPD_loop,
3473
    {
3474
      llvm::omp::allowedClauses_OMPD_loop,
3475
      llvm::omp::allowedOnceClauses_OMPD_loop,
3476
      llvm::omp::allowedExclusiveClauses_OMPD_loop,
3477
      llvm::omp::requiredClauses_OMPD_loop,
3478
    }
3479
  },
3480
  {llvm::omp::Directive::OMPD_masked,
3481
    {
3482
      llvm::omp::allowedClauses_OMPD_masked,
3483
      llvm::omp::allowedOnceClauses_OMPD_masked,
3484
      llvm::omp::allowedExclusiveClauses_OMPD_masked,
3485
      llvm::omp::requiredClauses_OMPD_masked,
3486
    }
3487
  },
3488
  {llvm::omp::Directive::OMPD_parallel_loop,
3489
    {
3490
      llvm::omp::allowedClauses_OMPD_parallel_loop,
3491
      llvm::omp::allowedOnceClauses_OMPD_parallel_loop,
3492
      llvm::omp::allowedExclusiveClauses_OMPD_parallel_loop,
3493
      llvm::omp::requiredClauses_OMPD_parallel_loop,
3494
    }
3495
  },
3496
  {llvm::omp::Directive::OMPD_target_parallel_loop,
3497
    {
3498
      llvm::omp::allowedClauses_OMPD_target_parallel_loop,
3499
      llvm::omp::allowedOnceClauses_OMPD_target_parallel_loop,
3500
      llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_loop,
3501
      llvm::omp::requiredClauses_OMPD_target_parallel_loop,
3502
    }
3503
  },
3504
  {llvm::omp::Directive::OMPD_target_teams_loop,
3505
    {
3506
      llvm::omp::allowedClauses_OMPD_target_teams_loop,
3507
      llvm::omp::allowedOnceClauses_OMPD_target_teams_loop,
3508
      llvm::omp::allowedExclusiveClauses_OMPD_target_teams_loop,
3509
      llvm::omp::requiredClauses_OMPD_target_teams_loop,
3510
    }
3511
  },
3512
  {llvm::omp::Directive::OMPD_teams_loop,
3513
    {
3514
      llvm::omp::allowedClauses_OMPD_teams_loop,
3515
      llvm::omp::allowedOnceClauses_OMPD_teams_loop,
3516
      llvm::omp::allowedExclusiveClauses_OMPD_teams_loop,
3517
      llvm::omp::requiredClauses_OMPD_teams_loop,
3518
    }
3519
  },
3520
}
3521
 
3522
#endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
3523
 
3524
#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES
3525
#undef GEN_FLANG_CLAUSE_PARSER_CLASSES
3526
 
3527
EMPTY_CLASS(AcqRel);
3528
EMPTY_CLASS(Acquire);
3529
EMPTY_CLASS(AdjustArgs);
3530
EMPTY_CLASS(Affinity);
3531
EMPTY_CLASS(Align);
3532
WRAPPER_CLASS(Aligned, OmpAlignedClause);
3533
WRAPPER_CLASS(Allocate, OmpAllocateClause);
3534
WRAPPER_CLASS(Allocator, ScalarIntExpr);
3535
EMPTY_CLASS(AppendArgs);
3536
EMPTY_CLASS(At);
3537
WRAPPER_CLASS(AtomicDefaultMemOrder, OmpAtomicDefaultMemOrderClause);
3538
EMPTY_CLASS(Bind);
3539
EMPTY_CLASS(CancellationConstructType);
3540
EMPTY_CLASS(Capture);
3541
WRAPPER_CLASS(Collapse, ScalarIntConstantExpr);
3542
EMPTY_CLASS(Compare);
3543
WRAPPER_CLASS(Copyprivate, OmpObjectList);
3544
WRAPPER_CLASS(Copyin, OmpObjectList);
3545
WRAPPER_CLASS(Default, OmpDefaultClause);
3546
WRAPPER_CLASS(Defaultmap, OmpDefaultmapClause);
3547
WRAPPER_CLASS(Depend, OmpDependClause);
3548
EMPTY_CLASS(Depobj);
3549
EMPTY_CLASS(Destroy);
3550
EMPTY_CLASS(Detach);
3551
WRAPPER_CLASS(Device, OmpDeviceClause);
3552
EMPTY_CLASS(DeviceType);
3553
WRAPPER_CLASS(DistSchedule, std::optional<ScalarIntExpr>);
3554
EMPTY_CLASS(DynamicAllocators);
3555
EMPTY_CLASS(Exclusive);
3556
WRAPPER_CLASS(Filter, ScalarIntExpr);
3557
WRAPPER_CLASS(Final, ScalarLogicalExpr);
3558
WRAPPER_CLASS(Firstprivate, OmpObjectList);
3559
EMPTY_CLASS(Flush);
3560
WRAPPER_CLASS(From, OmpObjectList);
3561
EMPTY_CLASS(Full);
3562
WRAPPER_CLASS(Grainsize, ScalarIntExpr);
3563
WRAPPER_CLASS(HasDeviceAddr, std::list<Name>);
3564
WRAPPER_CLASS(Hint, ConstantExpr);
3565
WRAPPER_CLASS(If, OmpIfClause);
3566
WRAPPER_CLASS(InReduction, OmpInReductionClause);
3567
EMPTY_CLASS(Inbranch);
3568
EMPTY_CLASS(Inclusive);
3569
EMPTY_CLASS(Indirect);
3570
EMPTY_CLASS(Init);
3571
WRAPPER_CLASS(IsDevicePtr, std::list<Name>);
3572
WRAPPER_CLASS(Lastprivate, OmpObjectList);
3573
WRAPPER_CLASS(Linear, OmpLinearClause);
3574
WRAPPER_CLASS(Link, OmpObjectList);
3575
WRAPPER_CLASS(Map, OmpMapClause);
3576
EMPTY_CLASS(Match);
3577
EMPTY_CLASS(MemoryOrder);
3578
EMPTY_CLASS(Mergeable);
3579
EMPTY_CLASS(Message);
3580
EMPTY_CLASS(Nogroup);
3581
EMPTY_CLASS(Nowait);
3582
WRAPPER_CLASS(Nocontext, ScalarLogicalExpr);
3583
WRAPPER_CLASS(Nontemporal, std::list<Name>);
3584
EMPTY_CLASS(Notinbranch);
3585
WRAPPER_CLASS(Novariants, ScalarLogicalExpr);
3586
WRAPPER_CLASS(NumTasks, ScalarIntExpr);
3587
WRAPPER_CLASS(NumTeams, ScalarIntExpr);
3588
WRAPPER_CLASS(NumThreads, ScalarIntExpr);
3589
WRAPPER_CLASS(OmpxDynCgroupMem, ScalarIntExpr);
3590
EMPTY_CLASS(Order);
3591
WRAPPER_CLASS(Ordered, std::optional<ScalarIntConstantExpr>);
3592
WRAPPER_CLASS(Partial, std::optional<ScalarIntConstantExpr>);
3593
WRAPPER_CLASS(Priority, ScalarIntExpr);
3594
WRAPPER_CLASS(Private, OmpObjectList);
3595
WRAPPER_CLASS(ProcBind, OmpProcBindClause);
3596
EMPTY_CLASS(Read);
3597
WRAPPER_CLASS(Reduction, OmpReductionClause);
3598
EMPTY_CLASS(Relaxed);
3599
EMPTY_CLASS(Release);
3600
EMPTY_CLASS(ReverseOffload);
3601
WRAPPER_CLASS(Safelen, ScalarIntConstantExpr);
3602
WRAPPER_CLASS(Schedule, OmpScheduleClause);
3603
EMPTY_CLASS(SeqCst);
3604
EMPTY_CLASS(Severity);
3605
WRAPPER_CLASS(Shared, OmpObjectList);
3606
EMPTY_CLASS(Simd);
3607
WRAPPER_CLASS(Simdlen, ScalarIntConstantExpr);
3608
WRAPPER_CLASS(Sizes, std::list<ScalarIntExpr>);
3609
WRAPPER_CLASS(TaskReduction, OmpReductionClause);
3610
WRAPPER_CLASS(ThreadLimit, ScalarIntExpr);
3611
EMPTY_CLASS(Threadprivate);
3612
EMPTY_CLASS(Threads);
3613
WRAPPER_CLASS(To, OmpObjectList);
3614
EMPTY_CLASS(UnifiedAddress);
3615
EMPTY_CLASS(UnifiedSharedMemory);
3616
WRAPPER_CLASS(Uniform, std::list<Name>);
3617
EMPTY_CLASS(Unknown);
3618
EMPTY_CLASS(Untied);
3619
EMPTY_CLASS(Update);
3620
EMPTY_CLASS(Use);
3621
EMPTY_CLASS(UseDeviceAddr);
3622
WRAPPER_CLASS(UseDevicePtr, std::list<Name>);
3623
EMPTY_CLASS(UsesAllocators);
3624
EMPTY_CLASS(When);
3625
EMPTY_CLASS(Write);
3626
 
3627
#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
3628
 
3629
#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
3630
#undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
3631
 
3632
AcqRel
3633
, Acquire
3634
, AdjustArgs
3635
, Affinity
3636
, Align
3637
, Aligned
3638
, Allocate
3639
, Allocator
3640
, AppendArgs
3641
, At
3642
, AtomicDefaultMemOrder
3643
, Bind
3644
, CancellationConstructType
3645
, Capture
3646
, Collapse
3647
, Compare
3648
, Copyprivate
3649
, Copyin
3650
, Default
3651
, Defaultmap
3652
, Depend
3653
, Depobj
3654
, Destroy
3655
, Detach
3656
, Device
3657
, DeviceType
3658
, DistSchedule
3659
, DynamicAllocators
3660
, Exclusive
3661
, Filter
3662
, Final
3663
, Firstprivate
3664
, Flush
3665
, From
3666
, Full
3667
, Grainsize
3668
, HasDeviceAddr
3669
, Hint
3670
, If
3671
, InReduction
3672
, Inbranch
3673
, Inclusive
3674
, Indirect
3675
, Init
3676
, IsDevicePtr
3677
, Lastprivate
3678
, Linear
3679
, Link
3680
, Map
3681
, Match
3682
, MemoryOrder
3683
, Mergeable
3684
, Message
3685
, Nogroup
3686
, Nowait
3687
, Nocontext
3688
, Nontemporal
3689
, Notinbranch
3690
, Novariants
3691
, NumTasks
3692
, NumTeams
3693
, NumThreads
3694
, OmpxDynCgroupMem
3695
, Order
3696
, Ordered
3697
, Partial
3698
, Priority
3699
, Private
3700
, ProcBind
3701
, Read
3702
, Reduction
3703
, Relaxed
3704
, Release
3705
, ReverseOffload
3706
, Safelen
3707
, Schedule
3708
, SeqCst
3709
, Severity
3710
, Shared
3711
, Simd
3712
, Simdlen
3713
, Sizes
3714
, TaskReduction
3715
, ThreadLimit
3716
, Threadprivate
3717
, Threads
3718
, To
3719
, UnifiedAddress
3720
, UnifiedSharedMemory
3721
, Uniform
3722
, Unknown
3723
, Untied
3724
, Update
3725
, Use
3726
, UseDeviceAddr
3727
, UseDevicePtr
3728
, UsesAllocators
3729
, When
3730
, Write
3731
 
3732
#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
3733
 
3734
#ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
3735
#undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
3736
 
3737
NODE(OmpClause, AcqRel)
3738
NODE(OmpClause, Acquire)
3739
NODE(OmpClause, AdjustArgs)
3740
NODE(OmpClause, Affinity)
3741
NODE(OmpClause, Align)
3742
NODE(OmpClause, Aligned)
3743
NODE(OmpClause, Allocate)
3744
NODE(OmpClause, Allocator)
3745
NODE(OmpClause, AppendArgs)
3746
NODE(OmpClause, At)
3747
NODE(OmpClause, AtomicDefaultMemOrder)
3748
NODE(OmpClause, Bind)
3749
NODE(OmpClause, CancellationConstructType)
3750
NODE(OmpClause, Capture)
3751
NODE(OmpClause, Collapse)
3752
NODE(OmpClause, Compare)
3753
NODE(OmpClause, Copyprivate)
3754
NODE(OmpClause, Copyin)
3755
NODE(OmpClause, Default)
3756
NODE(OmpClause, Defaultmap)
3757
NODE(OmpClause, Depend)
3758
NODE(OmpClause, Depobj)
3759
NODE(OmpClause, Destroy)
3760
NODE(OmpClause, Detach)
3761
NODE(OmpClause, Device)
3762
NODE(OmpClause, DeviceType)
3763
NODE(OmpClause, DistSchedule)
3764
NODE(OmpClause, DynamicAllocators)
3765
NODE(OmpClause, Exclusive)
3766
NODE(OmpClause, Filter)
3767
NODE(OmpClause, Final)
3768
NODE(OmpClause, Firstprivate)
3769
NODE(OmpClause, Flush)
3770
NODE(OmpClause, From)
3771
NODE(OmpClause, Full)
3772
NODE(OmpClause, Grainsize)
3773
NODE(OmpClause, HasDeviceAddr)
3774
NODE(OmpClause, Hint)
3775
NODE(OmpClause, If)
3776
NODE(OmpClause, InReduction)
3777
NODE(OmpClause, Inbranch)
3778
NODE(OmpClause, Inclusive)
3779
NODE(OmpClause, Indirect)
3780
NODE(OmpClause, Init)
3781
NODE(OmpClause, IsDevicePtr)
3782
NODE(OmpClause, Lastprivate)
3783
NODE(OmpClause, Linear)
3784
NODE(OmpClause, Link)
3785
NODE(OmpClause, Map)
3786
NODE(OmpClause, Match)
3787
NODE(OmpClause, MemoryOrder)
3788
NODE(OmpClause, Mergeable)
3789
NODE(OmpClause, Message)
3790
NODE(OmpClause, Nogroup)
3791
NODE(OmpClause, Nowait)
3792
NODE(OmpClause, Nocontext)
3793
NODE(OmpClause, Nontemporal)
3794
NODE(OmpClause, Notinbranch)
3795
NODE(OmpClause, Novariants)
3796
NODE(OmpClause, NumTasks)
3797
NODE(OmpClause, NumTeams)
3798
NODE(OmpClause, NumThreads)
3799
NODE(OmpClause, OmpxDynCgroupMem)
3800
NODE(OmpClause, Order)
3801
NODE(OmpClause, Ordered)
3802
NODE(OmpClause, Partial)
3803
NODE(OmpClause, Priority)
3804
NODE(OmpClause, Private)
3805
NODE(OmpClause, ProcBind)
3806
NODE(OmpClause, Read)
3807
NODE(OmpClause, Reduction)
3808
NODE(OmpClause, Relaxed)
3809
NODE(OmpClause, Release)
3810
NODE(OmpClause, ReverseOffload)
3811
NODE(OmpClause, Safelen)
3812
NODE(OmpClause, Schedule)
3813
NODE(OmpClause, SeqCst)
3814
NODE(OmpClause, Severity)
3815
NODE(OmpClause, Shared)
3816
NODE(OmpClause, Simd)
3817
NODE(OmpClause, Simdlen)
3818
NODE(OmpClause, Sizes)
3819
NODE(OmpClause, TaskReduction)
3820
NODE(OmpClause, ThreadLimit)
3821
NODE(OmpClause, Threadprivate)
3822
NODE(OmpClause, Threads)
3823
NODE(OmpClause, To)
3824
NODE(OmpClause, UnifiedAddress)
3825
NODE(OmpClause, UnifiedSharedMemory)
3826
NODE(OmpClause, Uniform)
3827
NODE(OmpClause, Unknown)
3828
NODE(OmpClause, Untied)
3829
NODE(OmpClause, Update)
3830
NODE(OmpClause, Use)
3831
NODE(OmpClause, UseDeviceAddr)
3832
NODE(OmpClause, UseDevicePtr)
3833
NODE(OmpClause, UsesAllocators)
3834
NODE(OmpClause, When)
3835
NODE(OmpClause, Write)
3836
 
3837
#endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
3838
 
3839
#ifdef GEN_FLANG_CLAUSE_UNPARSE
3840
#undef GEN_FLANG_CLAUSE_UNPARSE
3841
 
3842
void Before(const OmpClause::AcqRel &) { Word("ACQ_REL"); }
3843
void Before(const OmpClause::Acquire &) { Word("ACQUIRE"); }
3844
void Before(const OmpClause::AdjustArgs &) { Word("ADJUST_ARGS"); }
3845
void Before(const OmpClause::Affinity &) { Word("AFFINITY"); }
3846
void Before(const OmpClause::Align &) { Word("ALIGN"); }
3847
void Unparse(const OmpClause::Aligned &x) {
3848
  Word("ALIGNED");
3849
  Put("(");
3850
  Walk(x.v);
3851
  Put(")");
3852
}
3853
void Unparse(const OmpClause::Allocate &x) {
3854
  Word("ALLOCATE");
3855
  Put("(");
3856
  Walk(x.v);
3857
  Put(")");
3858
}
3859
void Unparse(const OmpClause::Allocator &x) {
3860
  Word("ALLOCATOR");
3861
  Put("(");
3862
  Walk(x.v);
3863
  Put(")");
3864
}
3865
void Before(const OmpClause::AppendArgs &) { Word("APPEND_ARGS"); }
3866
void Before(const OmpClause::At &) { Word("AT"); }
3867
void Unparse(const OmpClause::AtomicDefaultMemOrder &x) {
3868
  Word("ATOMIC_DEFAULT_MEM_ORDER");
3869
  Put("(");
3870
  Walk(x.v);
3871
  Put(")");
3872
}
3873
void Before(const OmpClause::Bind &) { Word("BIND"); }
3874
void Before(const OmpClause::CancellationConstructType &) { Word("CANCELLATION_CONSTRUCT_TYPE"); }
3875
void Before(const OmpClause::Capture &) { Word("CAPTURE"); }
3876
void Unparse(const OmpClause::Collapse &x) {
3877
  Word("COLLAPSE");
3878
  Put("(");
3879
  Walk(x.v);
3880
  Put(")");
3881
}
3882
void Before(const OmpClause::Compare &) { Word("COMPARE"); }
3883
void Unparse(const OmpClause::Copyprivate &x) {
3884
  Word("COPYPRIVATE");
3885
  Put("(");
3886
  Walk(x.v);
3887
  Put(")");
3888
}
3889
void Unparse(const OmpClause::Copyin &x) {
3890
  Word("COPYIN");
3891
  Put("(");
3892
  Walk(x.v);
3893
  Put(")");
3894
}
3895
void Unparse(const OmpClause::Default &x) {
3896
  Word("DEFAULT");
3897
  Put("(");
3898
  Walk(x.v);
3899
  Put(")");
3900
}
3901
void Unparse(const OmpClause::Defaultmap &x) {
3902
  Word("DEFAULTMAP");
3903
  Put("(");
3904
  Walk(x.v);
3905
  Put(")");
3906
}
3907
void Unparse(const OmpClause::Depend &x) {
3908
  Word("DEPEND");
3909
  Put("(");
3910
  Walk(x.v);
3911
  Put(")");
3912
}
3913
void Before(const OmpClause::Depobj &) { Word("DEPOBJ"); }
3914
void Before(const OmpClause::Destroy &) { Word("DESTROY"); }
3915
void Before(const OmpClause::Detach &) { Word("DETACH"); }
3916
void Unparse(const OmpClause::Device &x) {
3917
  Word("DEVICE");
3918
  Put("(");
3919
  Walk(x.v);
3920
  Put(")");
3921
}
3922
void Before(const OmpClause::DeviceType &) { Word("DEVICE_TYPE"); }
3923
void Unparse(const OmpClause::DistSchedule &x) {
3924
  Word("DIST_SCHEDULE");
3925
  Walk("(", x.v, ")");
3926
}
3927
void Before(const OmpClause::DynamicAllocators &) { Word("DYNAMIC_ALLOCATORS"); }
3928
void Before(const OmpClause::Exclusive &) { Word("EXCLUSIVE"); }
3929
void Unparse(const OmpClause::Filter &x) {
3930
  Word("FILTER");
3931
  Put("(");
3932
  Walk(x.v);
3933
  Put(")");
3934
}
3935
void Unparse(const OmpClause::Final &x) {
3936
  Word("FINAL");
3937
  Put("(");
3938
  Walk(x.v);
3939
  Put(")");
3940
}
3941
void Unparse(const OmpClause::Firstprivate &x) {
3942
  Word("FIRSTPRIVATE");
3943
  Put("(");
3944
  Walk(x.v);
3945
  Put(")");
3946
}
3947
void Before(const OmpClause::Flush &) { Word("FLUSH"); }
3948
void Unparse(const OmpClause::From &x) {
3949
  Word("FROM");
3950
  Put("(");
3951
  Walk(x.v);
3952
  Put(")");
3953
}
3954
void Before(const OmpClause::Full &) { Word("FULL"); }
3955
void Unparse(const OmpClause::Grainsize &x) {
3956
  Word("GRAINSIZE");
3957
  Put("(");
3958
  Walk(x.v);
3959
  Put(")");
3960
}
3961
void Unparse(const OmpClause::HasDeviceAddr &x) {
3962
  Word("HAS_DEVICE_ADDR");
3963
  Put("(");
3964
  Walk(x.v, ",");
3965
  Put(")");
3966
}
3967
void Unparse(const OmpClause::Hint &x) {
3968
  Word("HINT");
3969
  Put("(");
3970
  Walk(x.v);
3971
  Put(")");
3972
}
3973
void Unparse(const OmpClause::If &x) {
3974
  Word("IF");
3975
  Put("(");
3976
  Walk(x.v);
3977
  Put(")");
3978
}
3979
void Unparse(const OmpClause::InReduction &x) {
3980
  Word("IN_REDUCTION");
3981
  Put("(");
3982
  Walk(x.v);
3983
  Put(")");
3984
}
3985
void Before(const OmpClause::Inbranch &) { Word("INBRANCH"); }
3986
void Before(const OmpClause::Inclusive &) { Word("INCLUSIVE"); }
3987
void Before(const OmpClause::Indirect &) { Word("INDIRECT"); }
3988
void Before(const OmpClause::Init &) { Word("INIT"); }
3989
void Unparse(const OmpClause::IsDevicePtr &x) {
3990
  Word("IS_DEVICE_PTR");
3991
  Put("(");
3992
  Walk(x.v, ",");
3993
  Put(")");
3994
}
3995
void Unparse(const OmpClause::Lastprivate &x) {
3996
  Word("LASTPRIVATE");
3997
  Put("(");
3998
  Walk(x.v);
3999
  Put(")");
4000
}
4001
void Unparse(const OmpClause::Linear &x) {
4002
  Word("LINEAR");
4003
  Put("(");
4004
  Walk(x.v);
4005
  Put(")");
4006
}
4007
void Unparse(const OmpClause::Link &x) {
4008
  Word("LINK");
4009
  Put("(");
4010
  Walk(x.v);
4011
  Put(")");
4012
}
4013
void Unparse(const OmpClause::Map &x) {
4014
  Word("MAP");
4015
  Put("(");
4016
  Walk(x.v);
4017
  Put(")");
4018
}
4019
void Before(const OmpClause::Match &) { Word("MATCH"); }
4020
void Before(const OmpClause::MemoryOrder &) { Word("MEMORY_ORDER"); }
4021
void Before(const OmpClause::Mergeable &) { Word("MERGEABLE"); }
4022
void Before(const OmpClause::Message &) { Word("MESSAGE"); }
4023
void Before(const OmpClause::Nogroup &) { Word("NOGROUP"); }
4024
void Before(const OmpClause::Nowait &) { Word("NOWAIT"); }
4025
void Unparse(const OmpClause::Nocontext &x) {
4026
  Word("NOCONTEXT");
4027
  Put("(");
4028
  Walk(x.v);
4029
  Put(")");
4030
}
4031
void Unparse(const OmpClause::Nontemporal &x) {
4032
  Word("NONTEMPORAL");
4033
  Put("(");
4034
  Walk(x.v, ",");
4035
  Put(")");
4036
}
4037
void Before(const OmpClause::Notinbranch &) { Word("NOTINBRANCH"); }
4038
void Unparse(const OmpClause::Novariants &x) {
4039
  Word("NOVARIANTS");
4040
  Put("(");
4041
  Walk(x.v);
4042
  Put(")");
4043
}
4044
void Unparse(const OmpClause::NumTasks &x) {
4045
  Word("NUM_TASKS");
4046
  Put("(");
4047
  Walk(x.v);
4048
  Put(")");
4049
}
4050
void Unparse(const OmpClause::NumTeams &x) {
4051
  Word("NUM_TEAMS");
4052
  Put("(");
4053
  Walk(x.v);
4054
  Put(")");
4055
}
4056
void Unparse(const OmpClause::NumThreads &x) {
4057
  Word("NUM_THREADS");
4058
  Put("(");
4059
  Walk(x.v);
4060
  Put(")");
4061
}
4062
void Unparse(const OmpClause::OmpxDynCgroupMem &x) {
4063
  Word("OMPX_DYN_CGROUP_MEM");
4064
  Put("(");
4065
  Walk(x.v);
4066
  Put(")");
4067
}
4068
void Before(const OmpClause::Order &) { Word("ORDER"); }
4069
void Unparse(const OmpClause::Ordered &x) {
4070
  Word("ORDERED");
4071
  Walk("(", x.v, ")");
4072
}
4073
void Unparse(const OmpClause::Partial &x) {
4074
  Word("PARTIAL");
4075
  Walk("(", x.v, ")");
4076
}
4077
void Unparse(const OmpClause::Priority &x) {
4078
  Word("PRIORITY");
4079
  Put("(");
4080
  Walk(x.v);
4081
  Put(")");
4082
}
4083
void Unparse(const OmpClause::Private &x) {
4084
  Word("PRIVATE");
4085
  Put("(");
4086
  Walk(x.v);
4087
  Put(")");
4088
}
4089
void Unparse(const OmpClause::ProcBind &x) {
4090
  Word("PROC_BIND");
4091
  Put("(");
4092
  Walk(x.v);
4093
  Put(")");
4094
}
4095
void Before(const OmpClause::Read &) { Word("READ"); }
4096
void Unparse(const OmpClause::Reduction &x) {
4097
  Word("REDUCTION");
4098
  Put("(");
4099
  Walk(x.v);
4100
  Put(")");
4101
}
4102
void Before(const OmpClause::Relaxed &) { Word("RELAXED"); }
4103
void Before(const OmpClause::Release &) { Word("RELEASE"); }
4104
void Before(const OmpClause::ReverseOffload &) { Word("REVERSE_OFFLOAD"); }
4105
void Unparse(const OmpClause::Safelen &x) {
4106
  Word("SAFELEN");
4107
  Put("(");
4108
  Walk(x.v);
4109
  Put(")");
4110
}
4111
void Unparse(const OmpClause::Schedule &x) {
4112
  Word("SCHEDULE");
4113
  Put("(");
4114
  Walk(x.v);
4115
  Put(")");
4116
}
4117
void Before(const OmpClause::SeqCst &) { Word("SEQ_CST"); }
4118
void Before(const OmpClause::Severity &) { Word("SEVERITY"); }
4119
void Unparse(const OmpClause::Shared &x) {
4120
  Word("SHARED");
4121
  Put("(");
4122
  Walk(x.v);
4123
  Put(")");
4124
}
4125
void Before(const OmpClause::Simd &) { Word("SIMD"); }
4126
void Unparse(const OmpClause::Simdlen &x) {
4127
  Word("SIMDLEN");
4128
  Put("(");
4129
  Walk(x.v);
4130
  Put(")");
4131
}
4132
void Unparse(const OmpClause::Sizes &x) {
4133
  Word("SIZES");
4134
  Put("(");
4135
  Walk(x.v, ",");
4136
  Put(")");
4137
}
4138
void Unparse(const OmpClause::TaskReduction &x) {
4139
  Word("TASK_REDUCTION");
4140
  Put("(");
4141
  Walk(x.v);
4142
  Put(")");
4143
}
4144
void Unparse(const OmpClause::ThreadLimit &x) {
4145
  Word("THREAD_LIMIT");
4146
  Put("(");
4147
  Walk(x.v);
4148
  Put(")");
4149
}
4150
void Before(const OmpClause::Threadprivate &) { Word("THREADPRIVATE"); }
4151
void Before(const OmpClause::Threads &) { Word("THREADS"); }
4152
void Unparse(const OmpClause::To &x) {
4153
  Word("TO");
4154
  Put("(");
4155
  Walk(x.v);
4156
  Put(")");
4157
}
4158
void Before(const OmpClause::UnifiedAddress &) { Word("UNIFIED_ADDRESS"); }
4159
void Before(const OmpClause::UnifiedSharedMemory &) { Word("UNIFIED_SHARED_MEMORY"); }
4160
void Unparse(const OmpClause::Uniform &x) {
4161
  Word("UNIFORM");
4162
  Put("(");
4163
  Walk(x.v, ",");
4164
  Put(")");
4165
}
4166
void Before(const OmpClause::Unknown &) { Word("UNKNOWN"); }
4167
void Before(const OmpClause::Untied &) { Word("UNTIED"); }
4168
void Before(const OmpClause::Update &) { Word("UPDATE"); }
4169
void Before(const OmpClause::Use &) { Word("USE"); }
4170
void Before(const OmpClause::UseDeviceAddr &) { Word("USE_DEVICE_ADDR"); }
4171
void Unparse(const OmpClause::UseDevicePtr &x) {
4172
  Word("USE_DEVICE_PTR");
4173
  Put("(");
4174
  Walk(x.v, ",");
4175
  Put(")");
4176
}
4177
void Before(const OmpClause::UsesAllocators &) { Word("USES_ALLOCATORS"); }
4178
void Before(const OmpClause::When &) { Word("WHEN"); }
4179
void Before(const OmpClause::Write &) { Word("WRITE"); }
4180
 
4181
#endif // GEN_FLANG_CLAUSE_UNPARSE
4182
 
4183
#ifdef GEN_FLANG_CLAUSE_CHECK_ENTER
4184
#undef GEN_FLANG_CLAUSE_CHECK_ENTER
4185
 
4186
void Enter(const parser::OmpClause::AcqRel &);
4187
void Enter(const parser::OmpClause::Acquire &);
4188
void Enter(const parser::OmpClause::AdjustArgs &);
4189
void Enter(const parser::OmpClause::Affinity &);
4190
void Enter(const parser::OmpClause::Align &);
4191
void Enter(const parser::OmpClause::Aligned &);
4192
void Enter(const parser::OmpClause::Allocate &);
4193
void Enter(const parser::OmpClause::Allocator &);
4194
void Enter(const parser::OmpClause::AppendArgs &);
4195
void Enter(const parser::OmpClause::At &);
4196
void Enter(const parser::OmpClause::AtomicDefaultMemOrder &);
4197
void Enter(const parser::OmpClause::Bind &);
4198
void Enter(const parser::OmpClause::CancellationConstructType &);
4199
void Enter(const parser::OmpClause::Capture &);
4200
void Enter(const parser::OmpClause::Collapse &);
4201
void Enter(const parser::OmpClause::Compare &);
4202
void Enter(const parser::OmpClause::Copyprivate &);
4203
void Enter(const parser::OmpClause::Copyin &);
4204
void Enter(const parser::OmpClause::Default &);
4205
void Enter(const parser::OmpClause::Defaultmap &);
4206
void Enter(const parser::OmpClause::Depend &);
4207
void Enter(const parser::OmpClause::Depobj &);
4208
void Enter(const parser::OmpClause::Destroy &);
4209
void Enter(const parser::OmpClause::Detach &);
4210
void Enter(const parser::OmpClause::Device &);
4211
void Enter(const parser::OmpClause::DeviceType &);
4212
void Enter(const parser::OmpClause::DistSchedule &);
4213
void Enter(const parser::OmpClause::DynamicAllocators &);
4214
void Enter(const parser::OmpClause::Exclusive &);
4215
void Enter(const parser::OmpClause::Filter &);
4216
void Enter(const parser::OmpClause::Final &);
4217
void Enter(const parser::OmpClause::Firstprivate &);
4218
void Enter(const parser::OmpClause::Flush &);
4219
void Enter(const parser::OmpClause::From &);
4220
void Enter(const parser::OmpClause::Full &);
4221
void Enter(const parser::OmpClause::Grainsize &);
4222
void Enter(const parser::OmpClause::HasDeviceAddr &);
4223
void Enter(const parser::OmpClause::Hint &);
4224
void Enter(const parser::OmpClause::If &);
4225
void Enter(const parser::OmpClause::InReduction &);
4226
void Enter(const parser::OmpClause::Inbranch &);
4227
void Enter(const parser::OmpClause::Inclusive &);
4228
void Enter(const parser::OmpClause::Indirect &);
4229
void Enter(const parser::OmpClause::Init &);
4230
void Enter(const parser::OmpClause::IsDevicePtr &);
4231
void Enter(const parser::OmpClause::Lastprivate &);
4232
void Enter(const parser::OmpClause::Linear &);
4233
void Enter(const parser::OmpClause::Link &);
4234
void Enter(const parser::OmpClause::Map &);
4235
void Enter(const parser::OmpClause::Match &);
4236
void Enter(const parser::OmpClause::MemoryOrder &);
4237
void Enter(const parser::OmpClause::Mergeable &);
4238
void Enter(const parser::OmpClause::Message &);
4239
void Enter(const parser::OmpClause::Nogroup &);
4240
void Enter(const parser::OmpClause::Nowait &);
4241
void Enter(const parser::OmpClause::Nocontext &);
4242
void Enter(const parser::OmpClause::Nontemporal &);
4243
void Enter(const parser::OmpClause::Notinbranch &);
4244
void Enter(const parser::OmpClause::Novariants &);
4245
void Enter(const parser::OmpClause::NumTasks &);
4246
void Enter(const parser::OmpClause::NumTeams &);
4247
void Enter(const parser::OmpClause::NumThreads &);
4248
void Enter(const parser::OmpClause::OmpxDynCgroupMem &);
4249
void Enter(const parser::OmpClause::Order &);
4250
void Enter(const parser::OmpClause::Ordered &);
4251
void Enter(const parser::OmpClause::Partial &);
4252
void Enter(const parser::OmpClause::Priority &);
4253
void Enter(const parser::OmpClause::Private &);
4254
void Enter(const parser::OmpClause::ProcBind &);
4255
void Enter(const parser::OmpClause::Read &);
4256
void Enter(const parser::OmpClause::Reduction &);
4257
void Enter(const parser::OmpClause::Relaxed &);
4258
void Enter(const parser::OmpClause::Release &);
4259
void Enter(const parser::OmpClause::ReverseOffload &);
4260
void Enter(const parser::OmpClause::Safelen &);
4261
void Enter(const parser::OmpClause::Schedule &);
4262
void Enter(const parser::OmpClause::SeqCst &);
4263
void Enter(const parser::OmpClause::Severity &);
4264
void Enter(const parser::OmpClause::Shared &);
4265
void Enter(const parser::OmpClause::Simd &);
4266
void Enter(const parser::OmpClause::Simdlen &);
4267
void Enter(const parser::OmpClause::Sizes &);
4268
void Enter(const parser::OmpClause::TaskReduction &);
4269
void Enter(const parser::OmpClause::ThreadLimit &);
4270
void Enter(const parser::OmpClause::Threadprivate &);
4271
void Enter(const parser::OmpClause::Threads &);
4272
void Enter(const parser::OmpClause::To &);
4273
void Enter(const parser::OmpClause::UnifiedAddress &);
4274
void Enter(const parser::OmpClause::UnifiedSharedMemory &);
4275
void Enter(const parser::OmpClause::Uniform &);
4276
void Enter(const parser::OmpClause::Unknown &);
4277
void Enter(const parser::OmpClause::Untied &);
4278
void Enter(const parser::OmpClause::Update &);
4279
void Enter(const parser::OmpClause::Use &);
4280
void Enter(const parser::OmpClause::UseDeviceAddr &);
4281
void Enter(const parser::OmpClause::UseDevicePtr &);
4282
void Enter(const parser::OmpClause::UsesAllocators &);
4283
void Enter(const parser::OmpClause::When &);
4284
void Enter(const parser::OmpClause::Write &);
4285
 
4286
#endif // GEN_FLANG_CLAUSE_CHECK_ENTER
4287
 
4288
#ifdef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
4289
#undef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
4290
 
4291
if constexpr (std::is_same_v<A, parser::OmpClause::AcqRel>)
4292
  return llvm::omp::Clause::OMPC_acq_rel;
4293
if constexpr (std::is_same_v<A, parser::OmpClause::Acquire>)
4294
  return llvm::omp::Clause::OMPC_acquire;
4295
if constexpr (std::is_same_v<A, parser::OmpClause::AdjustArgs>)
4296
  return llvm::omp::Clause::OMPC_adjust_args;
4297
if constexpr (std::is_same_v<A, parser::OmpClause::Affinity>)
4298
  return llvm::omp::Clause::OMPC_affinity;
4299
if constexpr (std::is_same_v<A, parser::OmpClause::Align>)
4300
  return llvm::omp::Clause::OMPC_align;
4301
if constexpr (std::is_same_v<A, parser::OmpClause::Aligned>)
4302
  return llvm::omp::Clause::OMPC_aligned;
4303
if constexpr (std::is_same_v<A, parser::OmpClause::Allocate>)
4304
  return llvm::omp::Clause::OMPC_allocate;
4305
if constexpr (std::is_same_v<A, parser::OmpClause::Allocator>)
4306
  return llvm::omp::Clause::OMPC_allocator;
4307
if constexpr (std::is_same_v<A, parser::OmpClause::AppendArgs>)
4308
  return llvm::omp::Clause::OMPC_append_args;
4309
if constexpr (std::is_same_v<A, parser::OmpClause::At>)
4310
  return llvm::omp::Clause::OMPC_at;
4311
if constexpr (std::is_same_v<A, parser::OmpClause::AtomicDefaultMemOrder>)
4312
  return llvm::omp::Clause::OMPC_atomic_default_mem_order;
4313
if constexpr (std::is_same_v<A, parser::OmpClause::Bind>)
4314
  return llvm::omp::Clause::OMPC_bind;
4315
if constexpr (std::is_same_v<A, parser::OmpClause::CancellationConstructType>)
4316
  return llvm::omp::Clause::OMPC_cancellation_construct_type;
4317
if constexpr (std::is_same_v<A, parser::OmpClause::Capture>)
4318
  return llvm::omp::Clause::OMPC_capture;
4319
if constexpr (std::is_same_v<A, parser::OmpClause::Collapse>)
4320
  return llvm::omp::Clause::OMPC_collapse;
4321
if constexpr (std::is_same_v<A, parser::OmpClause::Compare>)
4322
  return llvm::omp::Clause::OMPC_compare;
4323
if constexpr (std::is_same_v<A, parser::OmpClause::Copyprivate>)
4324
  return llvm::omp::Clause::OMPC_copyprivate;
4325
if constexpr (std::is_same_v<A, parser::OmpClause::Copyin>)
4326
  return llvm::omp::Clause::OMPC_copyin;
4327
if constexpr (std::is_same_v<A, parser::OmpClause::Default>)
4328
  return llvm::omp::Clause::OMPC_default;
4329
if constexpr (std::is_same_v<A, parser::OmpClause::Defaultmap>)
4330
  return llvm::omp::Clause::OMPC_defaultmap;
4331
if constexpr (std::is_same_v<A, parser::OmpClause::Depend>)
4332
  return llvm::omp::Clause::OMPC_depend;
4333
if constexpr (std::is_same_v<A, parser::OmpClause::Depobj>)
4334
  return llvm::omp::Clause::OMPC_depobj;
4335
if constexpr (std::is_same_v<A, parser::OmpClause::Destroy>)
4336
  return llvm::omp::Clause::OMPC_destroy;
4337
if constexpr (std::is_same_v<A, parser::OmpClause::Detach>)
4338
  return llvm::omp::Clause::OMPC_detach;
4339
if constexpr (std::is_same_v<A, parser::OmpClause::Device>)
4340
  return llvm::omp::Clause::OMPC_device;
4341
if constexpr (std::is_same_v<A, parser::OmpClause::DeviceType>)
4342
  return llvm::omp::Clause::OMPC_device_type;
4343
if constexpr (std::is_same_v<A, parser::OmpClause::DistSchedule>)
4344
  return llvm::omp::Clause::OMPC_dist_schedule;
4345
if constexpr (std::is_same_v<A, parser::OmpClause::DynamicAllocators>)
4346
  return llvm::omp::Clause::OMPC_dynamic_allocators;
4347
if constexpr (std::is_same_v<A, parser::OmpClause::Exclusive>)
4348
  return llvm::omp::Clause::OMPC_exclusive;
4349
if constexpr (std::is_same_v<A, parser::OmpClause::Filter>)
4350
  return llvm::omp::Clause::OMPC_filter;
4351
if constexpr (std::is_same_v<A, parser::OmpClause::Final>)
4352
  return llvm::omp::Clause::OMPC_final;
4353
if constexpr (std::is_same_v<A, parser::OmpClause::Firstprivate>)
4354
  return llvm::omp::Clause::OMPC_firstprivate;
4355
if constexpr (std::is_same_v<A, parser::OmpClause::Flush>)
4356
  return llvm::omp::Clause::OMPC_flush;
4357
if constexpr (std::is_same_v<A, parser::OmpClause::From>)
4358
  return llvm::omp::Clause::OMPC_from;
4359
if constexpr (std::is_same_v<A, parser::OmpClause::Full>)
4360
  return llvm::omp::Clause::OMPC_full;
4361
if constexpr (std::is_same_v<A, parser::OmpClause::Grainsize>)
4362
  return llvm::omp::Clause::OMPC_grainsize;
4363
if constexpr (std::is_same_v<A, parser::OmpClause::HasDeviceAddr>)
4364
  return llvm::omp::Clause::OMPC_has_device_addr;
4365
if constexpr (std::is_same_v<A, parser::OmpClause::Hint>)
4366
  return llvm::omp::Clause::OMPC_hint;
4367
if constexpr (std::is_same_v<A, parser::OmpClause::If>)
4368
  return llvm::omp::Clause::OMPC_if;
4369
if constexpr (std::is_same_v<A, parser::OmpClause::InReduction>)
4370
  return llvm::omp::Clause::OMPC_in_reduction;
4371
if constexpr (std::is_same_v<A, parser::OmpClause::Inbranch>)
4372
  return llvm::omp::Clause::OMPC_inbranch;
4373
if constexpr (std::is_same_v<A, parser::OmpClause::Inclusive>)
4374
  return llvm::omp::Clause::OMPC_inclusive;
4375
if constexpr (std::is_same_v<A, parser::OmpClause::Indirect>)
4376
  return llvm::omp::Clause::OMPC_indirect;
4377
if constexpr (std::is_same_v<A, parser::OmpClause::Init>)
4378
  return llvm::omp::Clause::OMPC_init;
4379
if constexpr (std::is_same_v<A, parser::OmpClause::IsDevicePtr>)
4380
  return llvm::omp::Clause::OMPC_is_device_ptr;
4381
if constexpr (std::is_same_v<A, parser::OmpClause::Lastprivate>)
4382
  return llvm::omp::Clause::OMPC_lastprivate;
4383
if constexpr (std::is_same_v<A, parser::OmpClause::Linear>)
4384
  return llvm::omp::Clause::OMPC_linear;
4385
if constexpr (std::is_same_v<A, parser::OmpClause::Link>)
4386
  return llvm::omp::Clause::OMPC_link;
4387
if constexpr (std::is_same_v<A, parser::OmpClause::Map>)
4388
  return llvm::omp::Clause::OMPC_map;
4389
if constexpr (std::is_same_v<A, parser::OmpClause::Match>)
4390
  return llvm::omp::Clause::OMPC_match;
4391
if constexpr (std::is_same_v<A, parser::OmpClause::MemoryOrder>)
4392
  return llvm::omp::Clause::OMPC_memory_order;
4393
if constexpr (std::is_same_v<A, parser::OmpClause::Mergeable>)
4394
  return llvm::omp::Clause::OMPC_mergeable;
4395
if constexpr (std::is_same_v<A, parser::OmpClause::Message>)
4396
  return llvm::omp::Clause::OMPC_message;
4397
if constexpr (std::is_same_v<A, parser::OmpClause::Nogroup>)
4398
  return llvm::omp::Clause::OMPC_nogroup;
4399
if constexpr (std::is_same_v<A, parser::OmpClause::Nowait>)
4400
  return llvm::omp::Clause::OMPC_nowait;
4401
if constexpr (std::is_same_v<A, parser::OmpClause::Nocontext>)
4402
  return llvm::omp::Clause::OMPC_nocontext;
4403
if constexpr (std::is_same_v<A, parser::OmpClause::Nontemporal>)
4404
  return llvm::omp::Clause::OMPC_nontemporal;
4405
if constexpr (std::is_same_v<A, parser::OmpClause::Notinbranch>)
4406
  return llvm::omp::Clause::OMPC_notinbranch;
4407
if constexpr (std::is_same_v<A, parser::OmpClause::Novariants>)
4408
  return llvm::omp::Clause::OMPC_novariants;
4409
if constexpr (std::is_same_v<A, parser::OmpClause::NumTasks>)
4410
  return llvm::omp::Clause::OMPC_num_tasks;
4411
if constexpr (std::is_same_v<A, parser::OmpClause::NumTeams>)
4412
  return llvm::omp::Clause::OMPC_num_teams;
4413
if constexpr (std::is_same_v<A, parser::OmpClause::NumThreads>)
4414
  return llvm::omp::Clause::OMPC_num_threads;
4415
if constexpr (std::is_same_v<A, parser::OmpClause::OmpxDynCgroupMem>)
4416
  return llvm::omp::Clause::OMPC_ompx_dyn_cgroup_mem;
4417
if constexpr (std::is_same_v<A, parser::OmpClause::Order>)
4418
  return llvm::omp::Clause::OMPC_order;
4419
if constexpr (std::is_same_v<A, parser::OmpClause::Ordered>)
4420
  return llvm::omp::Clause::OMPC_ordered;
4421
if constexpr (std::is_same_v<A, parser::OmpClause::Partial>)
4422
  return llvm::omp::Clause::OMPC_partial;
4423
if constexpr (std::is_same_v<A, parser::OmpClause::Priority>)
4424
  return llvm::omp::Clause::OMPC_priority;
4425
if constexpr (std::is_same_v<A, parser::OmpClause::Private>)
4426
  return llvm::omp::Clause::OMPC_private;
4427
if constexpr (std::is_same_v<A, parser::OmpClause::ProcBind>)
4428
  return llvm::omp::Clause::OMPC_proc_bind;
4429
if constexpr (std::is_same_v<A, parser::OmpClause::Read>)
4430
  return llvm::omp::Clause::OMPC_read;
4431
if constexpr (std::is_same_v<A, parser::OmpClause::Reduction>)
4432
  return llvm::omp::Clause::OMPC_reduction;
4433
if constexpr (std::is_same_v<A, parser::OmpClause::Relaxed>)
4434
  return llvm::omp::Clause::OMPC_relaxed;
4435
if constexpr (std::is_same_v<A, parser::OmpClause::Release>)
4436
  return llvm::omp::Clause::OMPC_release;
4437
if constexpr (std::is_same_v<A, parser::OmpClause::ReverseOffload>)
4438
  return llvm::omp::Clause::OMPC_reverse_offload;
4439
if constexpr (std::is_same_v<A, parser::OmpClause::Safelen>)
4440
  return llvm::omp::Clause::OMPC_safelen;
4441
if constexpr (std::is_same_v<A, parser::OmpClause::Schedule>)
4442
  return llvm::omp::Clause::OMPC_schedule;
4443
if constexpr (std::is_same_v<A, parser::OmpClause::SeqCst>)
4444
  return llvm::omp::Clause::OMPC_seq_cst;
4445
if constexpr (std::is_same_v<A, parser::OmpClause::Severity>)
4446
  return llvm::omp::Clause::OMPC_severity;
4447
if constexpr (std::is_same_v<A, parser::OmpClause::Shared>)
4448
  return llvm::omp::Clause::OMPC_shared;
4449
if constexpr (std::is_same_v<A, parser::OmpClause::Simd>)
4450
  return llvm::omp::Clause::OMPC_simd;
4451
if constexpr (std::is_same_v<A, parser::OmpClause::Simdlen>)
4452
  return llvm::omp::Clause::OMPC_simdlen;
4453
if constexpr (std::is_same_v<A, parser::OmpClause::Sizes>)
4454
  return llvm::omp::Clause::OMPC_sizes;
4455
if constexpr (std::is_same_v<A, parser::OmpClause::TaskReduction>)
4456
  return llvm::omp::Clause::OMPC_task_reduction;
4457
if constexpr (std::is_same_v<A, parser::OmpClause::ThreadLimit>)
4458
  return llvm::omp::Clause::OMPC_thread_limit;
4459
if constexpr (std::is_same_v<A, parser::OmpClause::Threadprivate>)
4460
  return llvm::omp::Clause::OMPC_threadprivate;
4461
if constexpr (std::is_same_v<A, parser::OmpClause::Threads>)
4462
  return llvm::omp::Clause::OMPC_threads;
4463
if constexpr (std::is_same_v<A, parser::OmpClause::To>)
4464
  return llvm::omp::Clause::OMPC_to;
4465
if constexpr (std::is_same_v<A, parser::OmpClause::UnifiedAddress>)
4466
  return llvm::omp::Clause::OMPC_unified_address;
4467
if constexpr (std::is_same_v<A, parser::OmpClause::UnifiedSharedMemory>)
4468
  return llvm::omp::Clause::OMPC_unified_shared_memory;
4469
if constexpr (std::is_same_v<A, parser::OmpClause::Uniform>)
4470
  return llvm::omp::Clause::OMPC_uniform;
4471
if constexpr (std::is_same_v<A, parser::OmpClause::Unknown>)
4472
  return llvm::omp::Clause::OMPC_unknown;
4473
if constexpr (std::is_same_v<A, parser::OmpClause::Untied>)
4474
  return llvm::omp::Clause::OMPC_untied;
4475
if constexpr (std::is_same_v<A, parser::OmpClause::Update>)
4476
  return llvm::omp::Clause::OMPC_update;
4477
if constexpr (std::is_same_v<A, parser::OmpClause::Use>)
4478
  return llvm::omp::Clause::OMPC_use;
4479
if constexpr (std::is_same_v<A, parser::OmpClause::UseDeviceAddr>)
4480
  return llvm::omp::Clause::OMPC_use_device_addr;
4481
if constexpr (std::is_same_v<A, parser::OmpClause::UseDevicePtr>)
4482
  return llvm::omp::Clause::OMPC_use_device_ptr;
4483
if constexpr (std::is_same_v<A, parser::OmpClause::UsesAllocators>)
4484
  return llvm::omp::Clause::OMPC_uses_allocators;
4485
if constexpr (std::is_same_v<A, parser::OmpClause::When>)
4486
  return llvm::omp::Clause::OMPC_when;
4487
if constexpr (std::is_same_v<A, parser::OmpClause::Write>)
4488
  return llvm::omp::Clause::OMPC_write;
4489
llvm_unreachable("Invalid OpenMP Parser clause");
4490
 
4491
#endif // GEN_FLANG_CLAUSE_PARSER_KIND_MAP
4492
 
4493
#ifdef GEN_FLANG_CLAUSES_PARSER
4494
#undef GEN_FLANG_CLAUSES_PARSER
4495
 
4496
TYPE_PARSER(
4497
  "write" >> construct<OmpClause>(construct<OmpClause::Write>()) ||
4498
  "when" >> construct<OmpClause>(construct<OmpClause::When>()) ||
4499
  "uses_allocators" >> construct<OmpClause>(construct<OmpClause::UsesAllocators>()) ||
4500
  "use_device_ptr" >> construct<OmpClause>(construct<OmpClause::UseDevicePtr>(parenthesized(name))) ||
4501
  "use_device_addr" >> construct<OmpClause>(construct<OmpClause::UseDeviceAddr>()) ||
4502
  "use" >> construct<OmpClause>(construct<OmpClause::Use>()) ||
4503
  "update" >> construct<OmpClause>(construct<OmpClause::Update>()) ||
4504
  "untied" >> construct<OmpClause>(construct<OmpClause::Untied>()) ||
4505
  "unknown" >> construct<OmpClause>(construct<OmpClause::Unknown>()) ||
4506
  "uniform" >> construct<OmpClause>(construct<OmpClause::Uniform>(parenthesized(name))) ||
4507
  "unified_shared_memory" >> construct<OmpClause>(construct<OmpClause::UnifiedSharedMemory>()) ||
4508
  "unified_address" >> construct<OmpClause>(construct<OmpClause::UnifiedAddress>()) ||
4509
  "to" >> construct<OmpClause>(construct<OmpClause::To>(parenthesized(Parser<OmpObjectList>{}))) ||
4510
  "threads" >> construct<OmpClause>(construct<OmpClause::Threads>()) ||
4511
  "threadprivate" >> construct<OmpClause>(construct<OmpClause::Threadprivate>()) ||
4512
  "thread_limit" >> construct<OmpClause>(construct<OmpClause::ThreadLimit>(parenthesized(scalarIntExpr))) ||
4513
  "task_reduction" >> construct<OmpClause>(construct<OmpClause::TaskReduction>(parenthesized(Parser<OmpReductionClause>{}))) ||
4514
  "sizes" >> construct<OmpClause>(construct<OmpClause::Sizes>(parenthesized(scalarIntExpr))) ||
4515
  "simdlen" >> construct<OmpClause>(construct<OmpClause::Simdlen>(parenthesized(scalarIntConstantExpr))) ||
4516
  "simd" >> construct<OmpClause>(construct<OmpClause::Simd>()) ||
4517
  "shared" >> construct<OmpClause>(construct<OmpClause::Shared>(parenthesized(Parser<OmpObjectList>{}))) ||
4518
  "severity" >> construct<OmpClause>(construct<OmpClause::Severity>()) ||
4519
  "seq_cst" >> construct<OmpClause>(construct<OmpClause::SeqCst>()) ||
4520
  "schedule" >> construct<OmpClause>(construct<OmpClause::Schedule>(parenthesized(Parser<OmpScheduleClause>{}))) ||
4521
  "safelen" >> construct<OmpClause>(construct<OmpClause::Safelen>(parenthesized(scalarIntConstantExpr))) ||
4522
  "reverse_offload" >> construct<OmpClause>(construct<OmpClause::ReverseOffload>()) ||
4523
  "release" >> construct<OmpClause>(construct<OmpClause::Release>()) ||
4524
  "relaxed" >> construct<OmpClause>(construct<OmpClause::Relaxed>()) ||
4525
  "reduction" >> construct<OmpClause>(construct<OmpClause::Reduction>(parenthesized(Parser<OmpReductionClause>{}))) ||
4526
  "read" >> construct<OmpClause>(construct<OmpClause::Read>()) ||
4527
  "proc_bind" >> construct<OmpClause>(construct<OmpClause::ProcBind>(parenthesized(Parser<OmpProcBindClause>{}))) ||
4528
  "private" >> construct<OmpClause>(construct<OmpClause::Private>(parenthesized(Parser<OmpObjectList>{}))) ||
4529
  "priority" >> construct<OmpClause>(construct<OmpClause::Priority>(parenthesized(scalarIntExpr))) ||
4530
  "partial" >> construct<OmpClause>(construct<OmpClause::Partial>(maybe(parenthesized(scalarIntConstantExpr)))) ||
4531
  "ordered" >> construct<OmpClause>(construct<OmpClause::Ordered>(maybe(parenthesized(scalarIntConstantExpr)))) ||
4532
  "order" >> construct<OmpClause>(construct<OmpClause::Order>()) ||
4533
  "ompx_dyn_cgroup_mem" >> construct<OmpClause>(construct<OmpClause::OmpxDynCgroupMem>(parenthesized(scalarIntExpr))) ||
4534
  "num_threads" >> construct<OmpClause>(construct<OmpClause::NumThreads>(parenthesized(scalarIntExpr))) ||
4535
  "num_teams" >> construct<OmpClause>(construct<OmpClause::NumTeams>(parenthesized(scalarIntExpr))) ||
4536
  "num_tasks" >> construct<OmpClause>(construct<OmpClause::NumTasks>(parenthesized(scalarIntExpr))) ||
4537
  "nowait" >> construct<OmpClause>(construct<OmpClause::Nowait>()) ||
4538
  "novariants" >> construct<OmpClause>(construct<OmpClause::Novariants>(parenthesized(scalarLogicalExpr))) ||
4539
  "notinbranch" >> construct<OmpClause>(construct<OmpClause::Notinbranch>()) ||
4540
  "nontemporal" >> construct<OmpClause>(construct<OmpClause::Nontemporal>(parenthesized(name))) ||
4541
  "nogroup" >> construct<OmpClause>(construct<OmpClause::Nogroup>()) ||
4542
  "nocontext" >> construct<OmpClause>(construct<OmpClause::Nocontext>(parenthesized(scalarLogicalExpr))) ||
4543
  "message" >> construct<OmpClause>(construct<OmpClause::Message>()) ||
4544
  "mergeable" >> construct<OmpClause>(construct<OmpClause::Mergeable>()) ||
4545
  "memory_order" >> construct<OmpClause>(construct<OmpClause::MemoryOrder>()) ||
4546
  "match" >> construct<OmpClause>(construct<OmpClause::Match>()) ||
4547
  "map" >> construct<OmpClause>(construct<OmpClause::Map>(parenthesized(Parser<OmpMapClause>{}))) ||
4548
  "link" >> construct<OmpClause>(construct<OmpClause::Link>(parenthesized(Parser<OmpObjectList>{}))) ||
4549
  "linear" >> construct<OmpClause>(construct<OmpClause::Linear>(parenthesized(Parser<OmpLinearClause>{}))) ||
4550
  "lastprivate" >> construct<OmpClause>(construct<OmpClause::Lastprivate>(parenthesized(Parser<OmpObjectList>{}))) ||
4551
  "is_device_ptr" >> construct<OmpClause>(construct<OmpClause::IsDevicePtr>(parenthesized(name))) ||
4552
  "init" >> construct<OmpClause>(construct<OmpClause::Init>()) ||
4553
  "indirect" >> construct<OmpClause>(construct<OmpClause::Indirect>()) ||
4554
  "inclusive" >> construct<OmpClause>(construct<OmpClause::Inclusive>()) ||
4555
  "inbranch" >> construct<OmpClause>(construct<OmpClause::Inbranch>()) ||
4556
  "in_reduction" >> construct<OmpClause>(construct<OmpClause::InReduction>(parenthesized(Parser<OmpInReductionClause>{}))) ||
4557
  "if" >> construct<OmpClause>(construct<OmpClause::If>(parenthesized(Parser<OmpIfClause>{}))) ||
4558
  "hint" >> construct<OmpClause>(construct<OmpClause::Hint>(parenthesized(Parser<ConstantExpr>{}))) ||
4559
  "has_device_addr" >> construct<OmpClause>(construct<OmpClause::HasDeviceAddr>(parenthesized(name))) ||
4560
  "grainsize" >> construct<OmpClause>(construct<OmpClause::Grainsize>(parenthesized(scalarIntExpr))) ||
4561
  "full" >> construct<OmpClause>(construct<OmpClause::Full>()) ||
4562
  "from" >> construct<OmpClause>(construct<OmpClause::From>(parenthesized(Parser<OmpObjectList>{}))) ||
4563
  "flush" >> construct<OmpClause>(construct<OmpClause::Flush>()) ||
4564
  "firstprivate" >> construct<OmpClause>(construct<OmpClause::Firstprivate>(parenthesized(Parser<OmpObjectList>{}))) ||
4565
  "final" >> construct<OmpClause>(construct<OmpClause::Final>(parenthesized(scalarLogicalExpr))) ||
4566
  "filter" >> construct<OmpClause>(construct<OmpClause::Filter>(parenthesized(scalarIntExpr))) ||
4567
  "exclusive" >> construct<OmpClause>(construct<OmpClause::Exclusive>()) ||
4568
  "dynamic_allocators" >> construct<OmpClause>(construct<OmpClause::DynamicAllocators>()) ||
4569
  "dist_schedule" >> construct<OmpClause>(construct<OmpClause::DistSchedule>(maybe(parenthesized(scalarIntExpr)))) ||
4570
  "device_type" >> construct<OmpClause>(construct<OmpClause::DeviceType>()) ||
4571
  "device" >> construct<OmpClause>(construct<OmpClause::Device>(parenthesized(Parser<OmpDeviceClause>{}))) ||
4572
  "detach" >> construct<OmpClause>(construct<OmpClause::Detach>()) ||
4573
  "destroy" >> construct<OmpClause>(construct<OmpClause::Destroy>()) ||
4574
  "depobj" >> construct<OmpClause>(construct<OmpClause::Depobj>()) ||
4575
  "depend" >> construct<OmpClause>(construct<OmpClause::Depend>(parenthesized(Parser<OmpDependClause>{}))) ||
4576
  "defaultmap" >> construct<OmpClause>(construct<OmpClause::Defaultmap>(parenthesized(Parser<OmpDefaultmapClause>{}))) ||
4577
  "default" >> construct<OmpClause>(construct<OmpClause::Default>(parenthesized(Parser<OmpDefaultClause>{}))) ||
4578
  "copyprivate" >> construct<OmpClause>(construct<OmpClause::Copyprivate>(parenthesized(Parser<OmpObjectList>{}))) ||
4579
  "copyin" >> construct<OmpClause>(construct<OmpClause::Copyin>(parenthesized(Parser<OmpObjectList>{}))) ||
4580
  "compare" >> construct<OmpClause>(construct<OmpClause::Compare>()) ||
4581
  "collapse" >> construct<OmpClause>(construct<OmpClause::Collapse>(parenthesized(scalarIntConstantExpr))) ||
4582
  "capture" >> construct<OmpClause>(construct<OmpClause::Capture>()) ||
4583
  "cancellation_construct_type" >> construct<OmpClause>(construct<OmpClause::CancellationConstructType>()) ||
4584
  "bind" >> construct<OmpClause>(construct<OmpClause::Bind>()) ||
4585
  "atomic_default_mem_order" >> construct<OmpClause>(construct<OmpClause::AtomicDefaultMemOrder>(parenthesized(Parser<OmpAtomicDefaultMemOrderClause>{}))) ||
4586
  "at" >> construct<OmpClause>(construct<OmpClause::At>()) ||
4587
  "append_args" >> construct<OmpClause>(construct<OmpClause::AppendArgs>()) ||
4588
  "allocator" >> construct<OmpClause>(construct<OmpClause::Allocator>(parenthesized(scalarIntExpr))) ||
4589
  "allocate" >> construct<OmpClause>(construct<OmpClause::Allocate>(parenthesized(Parser<OmpAllocateClause>{}))) ||
4590
  "aligned" >> construct<OmpClause>(construct<OmpClause::Aligned>(parenthesized(Parser<OmpAlignedClause>{}))) ||
4591
  "align" >> construct<OmpClause>(construct<OmpClause::Align>()) ||
4592
  "affinity" >> construct<OmpClause>(construct<OmpClause::Affinity>()) ||
4593
  "adjust_args" >> construct<OmpClause>(construct<OmpClause::AdjustArgs>()) ||
4594
  "acquire" >> construct<OmpClause>(construct<OmpClause::Acquire>()) ||
4595
  "acq_rel" >> construct<OmpClause>(construct<OmpClause::AcqRel>())
4596
)
4597
 
4598
#endif // GEN_FLANG_CLAUSES_PARSER
4599
 
4600
#ifdef GEN_CLANG_CLAUSE_CLASS
4601
#undef GEN_CLANG_CLAUSE_CLASS
4602
 
4603
#ifndef CLAUSE
4604
#define CLAUSE(Enum, Str, Implicit)
4605
#endif
4606
#ifndef CLAUSE_CLASS
4607
#define CLAUSE_CLASS(Enum, Str, Class)
4608
#endif
4609
#ifndef CLAUSE_NO_CLASS
4610
#define CLAUSE_NO_CLASS(Enum, Str)
4611
#endif
4612
 
4613
#define __CLAUSE(Name, Class)                      \
4614
  CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \
4615
  CLAUSE_CLASS(OMPC_##Name, #Name, Class)
4616
#define __CLAUSE_NO_CLASS(Name)                    \
4617
  CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \
4618
  CLAUSE_NO_CLASS(OMPC_##Name, #Name)
4619
#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class)  \
4620
  CLAUSE(OMPC_##Name, Str, /* Implicit */ true)    \
4621
  CLAUSE_CLASS(OMPC_##Name, Str, Class)
4622
#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \
4623
  CLAUSE(OMPC_##Name, Str, /* Implicit */ true)    \
4624
  CLAUSE_NO_CLASS(OMPC_##Name, Str)
4625
 
4626
__CLAUSE(acq_rel, OMPAcqRelClause)
4627
__CLAUSE(acquire, OMPAcquireClause)
4628
__CLAUSE_NO_CLASS(adjust_args)
4629
__CLAUSE(affinity, OMPAffinityClause)
4630
__CLAUSE(align, OMPAlignClause)
4631
__CLAUSE(aligned, OMPAlignedClause)
4632
__CLAUSE(allocate, OMPAllocateClause)
4633
__CLAUSE(allocator, OMPAllocatorClause)
4634
__CLAUSE_NO_CLASS(append_args)
4635
__CLAUSE(at, OMPAtClause)
4636
__CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause)
4637
__CLAUSE(bind, OMPBindClause)
4638
__CLAUSE_NO_CLASS(cancellation_construct_type)
4639
__CLAUSE(capture, OMPCaptureClause)
4640
__CLAUSE(collapse, OMPCollapseClause)
4641
__CLAUSE(compare, OMPCompareClause)
4642
__CLAUSE(copyprivate, OMPCopyprivateClause)
4643
__CLAUSE(copyin, OMPCopyinClause)
4644
__CLAUSE(default, OMPDefaultClause)
4645
__CLAUSE(defaultmap, OMPDefaultmapClause)
4646
__CLAUSE(depend, OMPDependClause)
4647
__IMPLICIT_CLAUSE_CLASS(depobj, "depobj", OMPDepobjClause)
4648
__CLAUSE(destroy, OMPDestroyClause)
4649
__CLAUSE(detach, OMPDetachClause)
4650
__CLAUSE(device, OMPDeviceClause)
4651
__CLAUSE_NO_CLASS(device_type)
4652
__CLAUSE(dist_schedule, OMPDistScheduleClause)
4653
__CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause)
4654
__CLAUSE(exclusive, OMPExclusiveClause)
4655
__CLAUSE(filter, OMPFilterClause)
4656
__CLAUSE(final, OMPFinalClause)
4657
__CLAUSE(firstprivate, OMPFirstprivateClause)
4658
__IMPLICIT_CLAUSE_CLASS(flush, "flush", OMPFlushClause)
4659
__CLAUSE(from, OMPFromClause)
4660
__CLAUSE(full, OMPFullClause)
4661
__CLAUSE(grainsize, OMPGrainsizeClause)
4662
__CLAUSE(has_device_addr, OMPHasDeviceAddrClause)
4663
__CLAUSE(hint, OMPHintClause)
4664
__CLAUSE(if, OMPIfClause)
4665
__CLAUSE(in_reduction, OMPInReductionClause)
4666
__CLAUSE_NO_CLASS(inbranch)
4667
__CLAUSE(inclusive, OMPInclusiveClause)
4668
__CLAUSE_NO_CLASS(indirect)
4669
__CLAUSE(init, OMPInitClause)
4670
__CLAUSE(is_device_ptr, OMPIsDevicePtrClause)
4671
__CLAUSE(lastprivate, OMPLastprivateClause)
4672
__CLAUSE(linear, OMPLinearClause)
4673
__CLAUSE_NO_CLASS(link)
4674
__CLAUSE(map, OMPMapClause)
4675
__CLAUSE_NO_CLASS(match)
4676
__CLAUSE_NO_CLASS(memory_order)
4677
__CLAUSE(mergeable, OMPMergeableClause)
4678
__CLAUSE(message, OMPMessageClause)
4679
__CLAUSE(nogroup, OMPNogroupClause)
4680
__CLAUSE(nowait, OMPNowaitClause)
4681
__CLAUSE(nocontext, OMPNocontextClause)
4682
__CLAUSE(nontemporal, OMPNontemporalClause)
4683
__CLAUSE_NO_CLASS(notinbranch)
4684
__CLAUSE(novariants, OMPNovariantsClause)
4685
__CLAUSE(num_tasks, OMPNumTasksClause)
4686
__CLAUSE(num_teams, OMPNumTeamsClause)
4687
__CLAUSE(num_threads, OMPNumThreadsClause)
4688
__CLAUSE(ompx_dyn_cgroup_mem, OMPXDynCGroupMemClause)
4689
__CLAUSE(order, OMPOrderClause)
4690
__CLAUSE(ordered, OMPOrderedClause)
4691
__CLAUSE(partial, OMPPartialClause)
4692
__CLAUSE(priority, OMPPriorityClause)
4693
__CLAUSE(private, OMPPrivateClause)
4694
__CLAUSE(proc_bind, OMPProcBindClause)
4695
__CLAUSE(read, OMPReadClause)
4696
__CLAUSE(reduction, OMPReductionClause)
4697
__CLAUSE(relaxed, OMPRelaxedClause)
4698
__CLAUSE(release, OMPReleaseClause)
4699
__CLAUSE(reverse_offload, OMPReverseOffloadClause)
4700
__CLAUSE(safelen, OMPSafelenClause)
4701
__CLAUSE(schedule, OMPScheduleClause)
4702
__CLAUSE(seq_cst, OMPSeqCstClause)
4703
__CLAUSE(severity, OMPSeverityClause)
4704
__CLAUSE(shared, OMPSharedClause)
4705
__CLAUSE(simd, OMPSIMDClause)
4706
__CLAUSE(simdlen, OMPSimdlenClause)
4707
__CLAUSE(sizes, OMPSizesClause)
4708
__CLAUSE(task_reduction, OMPTaskReductionClause)
4709
__CLAUSE(thread_limit, OMPThreadLimitClause)
4710
__IMPLICIT_CLAUSE_NO_CLASS(threadprivate, "threadprivate")
4711
__CLAUSE(threads, OMPThreadsClause)
4712
__CLAUSE(to, OMPToClause)
4713
__CLAUSE(unified_address, OMPUnifiedAddressClause)
4714
__CLAUSE(unified_shared_memory, OMPUnifiedSharedMemoryClause)
4715
__CLAUSE_NO_CLASS(uniform)
4716
__IMPLICIT_CLAUSE_NO_CLASS(unknown, "unknown")
4717
__CLAUSE(untied, OMPUntiedClause)
4718
__CLAUSE(update, OMPUpdateClause)
4719
__CLAUSE(use, OMPUseClause)
4720
__CLAUSE(use_device_addr, OMPUseDeviceAddrClause)
4721
__CLAUSE(use_device_ptr, OMPUseDevicePtrClause)
4722
__CLAUSE(uses_allocators, OMPUsesAllocatorsClause)
4723
__CLAUSE_NO_CLASS(when)
4724
__CLAUSE(write, OMPWriteClause)
4725
 
4726
#undef __IMPLICIT_CLAUSE_NO_CLASS
4727
#undef __IMPLICIT_CLAUSE_CLASS
4728
#undef __CLAUSE
4729
#undef CLAUSE_NO_CLASS
4730
#undef CLAUSE_CLASS
4731
#undef CLAUSE
4732
 
4733
#endif // GEN_CLANG_CLAUSE_CLASS
4734
 
4735
#ifdef GEN_DIRECTIVES_IMPL
4736
#undef GEN_DIRECTIVES_IMPL
4737
 
4738
Directive llvm::omp::getOpenMPDirectiveKind(llvm::StringRef Str) {
4739
  return llvm::StringSwitch<Directive>(Str)
4740
    .Case("allocate",OMPD_allocate)
4741
    .Case("assumes",OMPD_assumes)
4742
    .Case("atomic",OMPD_atomic)
4743
    .Case("barrier",OMPD_barrier)
4744
    .Case("begin assumes",OMPD_begin_assumes)
4745
    .Case("begin declare target",OMPD_begin_declare_target)
4746
    .Case("begin declare variant",OMPD_begin_declare_variant)
4747
    .Case("cancel",OMPD_cancel)
4748
    .Case("cancellation point",OMPD_cancellation_point)
4749
    .Case("critical",OMPD_critical)
4750
    .Case("declare mapper",OMPD_declare_mapper)
4751
    .Case("declare reduction",OMPD_declare_reduction)
4752
    .Case("declare simd",OMPD_declare_simd)
4753
    .Case("declare target",OMPD_declare_target)
4754
    .Case("declare variant",OMPD_declare_variant)
4755
    .Case("depobj",OMPD_depobj)
4756
    .Case("distribute",OMPD_distribute)
4757
    .Case("distribute parallel do",OMPD_distribute_parallel_do)
4758
    .Case("distribute parallel do simd",OMPD_distribute_parallel_do_simd)
4759
    .Case("distribute parallel for",OMPD_distribute_parallel_for)
4760
    .Case("distribute parallel for simd",OMPD_distribute_parallel_for_simd)
4761
    .Case("distribute simd",OMPD_distribute_simd)
4762
    .Case("do",OMPD_do)
4763
    .Case("do simd",OMPD_do_simd)
4764
    .Case("end assumes",OMPD_end_assumes)
4765
    .Case("end declare target",OMPD_end_declare_target)
4766
    .Case("end declare variant",OMPD_end_declare_variant)
4767
    .Case("end do",OMPD_end_do)
4768
    .Case("end do simd",OMPD_end_do_simd)
4769
    .Case("end sections",OMPD_end_sections)
4770
    .Case("end single",OMPD_end_single)
4771
    .Case("end workshare",OMPD_end_workshare)
4772
    .Case("error",OMPD_error)
4773
    .Case("flush",OMPD_flush)
4774
    .Case("for",OMPD_for)
4775
    .Case("for simd",OMPD_for_simd)
4776
    .Case("masked taskloop",OMPD_masked_taskloop)
4777
    .Case("masked taskloop simd",OMPD_masked_taskloop_simd)
4778
    .Case("master",OMPD_master)
4779
    .Case("master taskloop",OMPD_master_taskloop)
4780
    .Case("master taskloop simd",OMPD_master_taskloop_simd)
4781
    .Case("metadirective",OMPD_metadirective)
4782
    .Case("nothing",OMPD_nothing)
4783
    .Case("ordered",OMPD_ordered)
4784
    .Case("parallel",OMPD_parallel)
4785
    .Case("parallel do",OMPD_parallel_do)
4786
    .Case("parallel do simd",OMPD_parallel_do_simd)
4787
    .Case("parallel for",OMPD_parallel_for)
4788
    .Case("parallel for simd",OMPD_parallel_for_simd)
4789
    .Case("parallel masked",OMPD_parallel_masked)
4790
    .Case("parallel masked taskloop",OMPD_parallel_masked_taskloop)
4791
    .Case("parallel masked taskloop simd",OMPD_parallel_masked_taskloop_simd)
4792
    .Case("parallel master",OMPD_parallel_master)
4793
    .Case("parallel master taskloop",OMPD_parallel_master_taskloop)
4794
    .Case("parallel master taskloop simd",OMPD_parallel_master_taskloop_simd)
4795
    .Case("parallel sections",OMPD_parallel_sections)
4796
    .Case("parallel workshare",OMPD_parallel_workshare)
4797
    .Case("requires",OMPD_requires)
4798
    .Case("scan",OMPD_scan)
4799
    .Case("section",OMPD_section)
4800
    .Case("sections",OMPD_sections)
4801
    .Case("simd",OMPD_simd)
4802
    .Case("single",OMPD_single)
4803
    .Case("target",OMPD_target)
4804
    .Case("target data",OMPD_target_data)
4805
    .Case("target enter data",OMPD_target_enter_data)
4806
    .Case("target exit data",OMPD_target_exit_data)
4807
    .Case("target parallel",OMPD_target_parallel)
4808
    .Case("target parallel do",OMPD_target_parallel_do)
4809
    .Case("target parallel do simd",OMPD_target_parallel_do_simd)
4810
    .Case("target parallel for",OMPD_target_parallel_for)
4811
    .Case("target parallel for simd",OMPD_target_parallel_for_simd)
4812
    .Case("target simd",OMPD_target_simd)
4813
    .Case("target teams",OMPD_target_teams)
4814
    .Case("target teams distribute",OMPD_target_teams_distribute)
4815
    .Case("target teams distribute parallel do",OMPD_target_teams_distribute_parallel_do)
4816
    .Case("target teams distribute parallel do simd",OMPD_target_teams_distribute_parallel_do_simd)
4817
    .Case("target teams distribute parallel for",OMPD_target_teams_distribute_parallel_for)
4818
    .Case("target teams distribute parallel for simd",OMPD_target_teams_distribute_parallel_for_simd)
4819
    .Case("target teams distribute simd",OMPD_target_teams_distribute_simd)
4820
    .Case("target update",OMPD_target_update)
4821
    .Case("task",OMPD_task)
4822
    .Case("taskgroup",OMPD_taskgroup)
4823
    .Case("taskloop",OMPD_taskloop)
4824
    .Case("taskloop simd",OMPD_taskloop_simd)
4825
    .Case("taskwait",OMPD_taskwait)
4826
    .Case("taskyield",OMPD_taskyield)
4827
    .Case("teams",OMPD_teams)
4828
    .Case("teams distribute",OMPD_teams_distribute)
4829
    .Case("teams distribute parallel do",OMPD_teams_distribute_parallel_do)
4830
    .Case("teams distribute parallel do simd",OMPD_teams_distribute_parallel_do_simd)
4831
    .Case("teams distribute parallel for",OMPD_teams_distribute_parallel_for)
4832
    .Case("teams distribute parallel for simd",OMPD_teams_distribute_parallel_for_simd)
4833
    .Case("teams distribute simd",OMPD_teams_distribute_simd)
4834
    .Case("threadprivate",OMPD_threadprivate)
4835
    .Case("tile",OMPD_tile)
4836
    .Case("unknown",OMPD_unknown)
4837
    .Case("unroll",OMPD_unroll)
4838
    .Case("workshare",OMPD_workshare)
4839
    .Case("dispatch",OMPD_dispatch)
4840
    .Case("interop",OMPD_interop)
4841
    .Case("loop",OMPD_loop)
4842
    .Case("masked",OMPD_masked)
4843
    .Case("parallel loop",OMPD_parallel_loop)
4844
    .Case("target parallel loop",OMPD_target_parallel_loop)
4845
    .Case("target teams loop",OMPD_target_teams_loop)
4846
    .Case("teams loop",OMPD_teams_loop)
4847
    .Default(OMPD_unknown);
4848
}
4849
 
4850
llvm::StringRef llvm::omp::getOpenMPDirectiveName(Directive Kind) {
4851
  switch (Kind) {
4852
    case OMPD_allocate:
4853
      return "allocate";
4854
    case OMPD_assumes:
4855
      return "assumes";
4856
    case OMPD_atomic:
4857
      return "atomic";
4858
    case OMPD_barrier:
4859
      return "barrier";
4860
    case OMPD_begin_assumes:
4861
      return "begin assumes";
4862
    case OMPD_begin_declare_target:
4863
      return "begin declare target";
4864
    case OMPD_begin_declare_variant:
4865
      return "begin declare variant";
4866
    case OMPD_cancel:
4867
      return "cancel";
4868
    case OMPD_cancellation_point:
4869
      return "cancellation point";
4870
    case OMPD_critical:
4871
      return "critical";
4872
    case OMPD_declare_mapper:
4873
      return "declare mapper";
4874
    case OMPD_declare_reduction:
4875
      return "declare reduction";
4876
    case OMPD_declare_simd:
4877
      return "declare simd";
4878
    case OMPD_declare_target:
4879
      return "declare target";
4880
    case OMPD_declare_variant:
4881
      return "declare variant";
4882
    case OMPD_depobj:
4883
      return "depobj";
4884
    case OMPD_distribute:
4885
      return "distribute";
4886
    case OMPD_distribute_parallel_do:
4887
      return "distribute parallel do";
4888
    case OMPD_distribute_parallel_do_simd:
4889
      return "distribute parallel do simd";
4890
    case OMPD_distribute_parallel_for:
4891
      return "distribute parallel for";
4892
    case OMPD_distribute_parallel_for_simd:
4893
      return "distribute parallel for simd";
4894
    case OMPD_distribute_simd:
4895
      return "distribute simd";
4896
    case OMPD_do:
4897
      return "do";
4898
    case OMPD_do_simd:
4899
      return "do simd";
4900
    case OMPD_end_assumes:
4901
      return "end assumes";
4902
    case OMPD_end_declare_target:
4903
      return "end declare target";
4904
    case OMPD_end_declare_variant:
4905
      return "end declare variant";
4906
    case OMPD_end_do:
4907
      return "end do";
4908
    case OMPD_end_do_simd:
4909
      return "end do simd";
4910
    case OMPD_end_sections:
4911
      return "end sections";
4912
    case OMPD_end_single:
4913
      return "end single";
4914
    case OMPD_end_workshare:
4915
      return "end workshare";
4916
    case OMPD_error:
4917
      return "error";
4918
    case OMPD_flush:
4919
      return "flush";
4920
    case OMPD_for:
4921
      return "for";
4922
    case OMPD_for_simd:
4923
      return "for simd";
4924
    case OMPD_masked_taskloop:
4925
      return "masked taskloop";
4926
    case OMPD_masked_taskloop_simd:
4927
      return "masked taskloop simd";
4928
    case OMPD_master:
4929
      return "master";
4930
    case OMPD_master_taskloop:
4931
      return "master taskloop";
4932
    case OMPD_master_taskloop_simd:
4933
      return "master taskloop simd";
4934
    case OMPD_metadirective:
4935
      return "metadirective";
4936
    case OMPD_nothing:
4937
      return "nothing";
4938
    case OMPD_ordered:
4939
      return "ordered";
4940
    case OMPD_parallel:
4941
      return "parallel";
4942
    case OMPD_parallel_do:
4943
      return "parallel do";
4944
    case OMPD_parallel_do_simd:
4945
      return "parallel do simd";
4946
    case OMPD_parallel_for:
4947
      return "parallel for";
4948
    case OMPD_parallel_for_simd:
4949
      return "parallel for simd";
4950
    case OMPD_parallel_masked:
4951
      return "parallel masked";
4952
    case OMPD_parallel_masked_taskloop:
4953
      return "parallel masked taskloop";
4954
    case OMPD_parallel_masked_taskloop_simd:
4955
      return "parallel masked taskloop simd";
4956
    case OMPD_parallel_master:
4957
      return "parallel master";
4958
    case OMPD_parallel_master_taskloop:
4959
      return "parallel master taskloop";
4960
    case OMPD_parallel_master_taskloop_simd:
4961
      return "parallel master taskloop simd";
4962
    case OMPD_parallel_sections:
4963
      return "parallel sections";
4964
    case OMPD_parallel_workshare:
4965
      return "parallel workshare";
4966
    case OMPD_requires:
4967
      return "requires";
4968
    case OMPD_scan:
4969
      return "scan";
4970
    case OMPD_section:
4971
      return "section";
4972
    case OMPD_sections:
4973
      return "sections";
4974
    case OMPD_simd:
4975
      return "simd";
4976
    case OMPD_single:
4977
      return "single";
4978
    case OMPD_target:
4979
      return "target";
4980
    case OMPD_target_data:
4981
      return "target data";
4982
    case OMPD_target_enter_data:
4983
      return "target enter data";
4984
    case OMPD_target_exit_data:
4985
      return "target exit data";
4986
    case OMPD_target_parallel:
4987
      return "target parallel";
4988
    case OMPD_target_parallel_do:
4989
      return "target parallel do";
4990
    case OMPD_target_parallel_do_simd:
4991
      return "target parallel do simd";
4992
    case OMPD_target_parallel_for:
4993
      return "target parallel for";
4994
    case OMPD_target_parallel_for_simd:
4995
      return "target parallel for simd";
4996
    case OMPD_target_simd:
4997
      return "target simd";
4998
    case OMPD_target_teams:
4999
      return "target teams";
5000
    case OMPD_target_teams_distribute:
5001
      return "target teams distribute";
5002
    case OMPD_target_teams_distribute_parallel_do:
5003
      return "target teams distribute parallel do";
5004
    case OMPD_target_teams_distribute_parallel_do_simd:
5005
      return "target teams distribute parallel do simd";
5006
    case OMPD_target_teams_distribute_parallel_for:
5007
      return "target teams distribute parallel for";
5008
    case OMPD_target_teams_distribute_parallel_for_simd:
5009
      return "target teams distribute parallel for simd";
5010
    case OMPD_target_teams_distribute_simd:
5011
      return "target teams distribute simd";
5012
    case OMPD_target_update:
5013
      return "target update";
5014
    case OMPD_task:
5015
      return "task";
5016
    case OMPD_taskgroup:
5017
      return "taskgroup";
5018
    case OMPD_taskloop:
5019
      return "taskloop";
5020
    case OMPD_taskloop_simd:
5021
      return "taskloop simd";
5022
    case OMPD_taskwait:
5023
      return "taskwait";
5024
    case OMPD_taskyield:
5025
      return "taskyield";
5026
    case OMPD_teams:
5027
      return "teams";
5028
    case OMPD_teams_distribute:
5029
      return "teams distribute";
5030
    case OMPD_teams_distribute_parallel_do:
5031
      return "teams distribute parallel do";
5032
    case OMPD_teams_distribute_parallel_do_simd:
5033
      return "teams distribute parallel do simd";
5034
    case OMPD_teams_distribute_parallel_for:
5035
      return "teams distribute parallel for";
5036
    case OMPD_teams_distribute_parallel_for_simd:
5037
      return "teams distribute parallel for simd";
5038
    case OMPD_teams_distribute_simd:
5039
      return "teams distribute simd";
5040
    case OMPD_threadprivate:
5041
      return "threadprivate";
5042
    case OMPD_tile:
5043
      return "tile";
5044
    case OMPD_unknown:
5045
      return "unknown";
5046
    case OMPD_unroll:
5047
      return "unroll";
5048
    case OMPD_workshare:
5049
      return "workshare";
5050
    case OMPD_dispatch:
5051
      return "dispatch";
5052
    case OMPD_interop:
5053
      return "interop";
5054
    case OMPD_loop:
5055
      return "loop";
5056
    case OMPD_masked:
5057
      return "masked";
5058
    case OMPD_parallel_loop:
5059
      return "parallel loop";
5060
    case OMPD_target_parallel_loop:
5061
      return "target parallel loop";
5062
    case OMPD_target_teams_loop:
5063
      return "target teams loop";
5064
    case OMPD_teams_loop:
5065
      return "teams loop";
5066
  }
5067
  llvm_unreachable("Invalid OpenMP Directive kind");
5068
}
5069
 
5070
Clause llvm::omp::getOpenMPClauseKind(llvm::StringRef Str) {
5071
  return llvm::StringSwitch<Clause>(Str)
5072
    .Case("acq_rel",OMPC_acq_rel)
5073
    .Case("acquire",OMPC_acquire)
5074
    .Case("adjust_args",OMPC_adjust_args)
5075
    .Case("affinity",OMPC_affinity)
5076
    .Case("align",OMPC_align)
5077
    .Case("aligned",OMPC_aligned)
5078
    .Case("allocate",OMPC_allocate)
5079
    .Case("allocator",OMPC_allocator)
5080
    .Case("append_args",OMPC_append_args)
5081
    .Case("at",OMPC_at)
5082
    .Case("atomic_default_mem_order",OMPC_atomic_default_mem_order)
5083
    .Case("bind",OMPC_bind)
5084
    .Case("cancellation_construct_type",OMPC_cancellation_construct_type)
5085
    .Case("capture",OMPC_capture)
5086
    .Case("collapse",OMPC_collapse)
5087
    .Case("compare",OMPC_compare)
5088
    .Case("copyprivate",OMPC_copyprivate)
5089
    .Case("copyin",OMPC_copyin)
5090
    .Case("default",OMPC_default)
5091
    .Case("defaultmap",OMPC_defaultmap)
5092
    .Case("depend",OMPC_depend)
5093
    .Case("depobj",OMPC_unknown)
5094
    .Case("destroy",OMPC_destroy)
5095
    .Case("detach",OMPC_detach)
5096
    .Case("device",OMPC_device)
5097
    .Case("device_type",OMPC_device_type)
5098
    .Case("dist_schedule",OMPC_dist_schedule)
5099
    .Case("dynamic_allocators",OMPC_dynamic_allocators)
5100
    .Case("exclusive",OMPC_exclusive)
5101
    .Case("filter",OMPC_filter)
5102
    .Case("final",OMPC_final)
5103
    .Case("firstprivate",OMPC_firstprivate)
5104
    .Case("flush",OMPC_unknown)
5105
    .Case("from",OMPC_from)
5106
    .Case("full",OMPC_full)
5107
    .Case("grainsize",OMPC_grainsize)
5108
    .Case("has_device_addr",OMPC_has_device_addr)
5109
    .Case("hint",OMPC_hint)
5110
    .Case("if",OMPC_if)
5111
    .Case("in_reduction",OMPC_in_reduction)
5112
    .Case("inbranch",OMPC_inbranch)
5113
    .Case("inclusive",OMPC_inclusive)
5114
    .Case("indirect",OMPC_indirect)
5115
    .Case("init",OMPC_init)
5116
    .Case("is_device_ptr",OMPC_is_device_ptr)
5117
    .Case("lastprivate",OMPC_lastprivate)
5118
    .Case("linear",OMPC_linear)
5119
    .Case("link",OMPC_link)
5120
    .Case("map",OMPC_map)
5121
    .Case("match",OMPC_match)
5122
    .Case("memory_order",OMPC_memory_order)
5123
    .Case("mergeable",OMPC_mergeable)
5124
    .Case("message",OMPC_message)
5125
    .Case("nogroup",OMPC_nogroup)
5126
    .Case("nowait",OMPC_nowait)
5127
    .Case("nocontext",OMPC_nocontext)
5128
    .Case("nontemporal",OMPC_nontemporal)
5129
    .Case("notinbranch",OMPC_notinbranch)
5130
    .Case("novariants",OMPC_novariants)
5131
    .Case("num_tasks",OMPC_num_tasks)
5132
    .Case("num_teams",OMPC_num_teams)
5133
    .Case("num_threads",OMPC_num_threads)
5134
    .Case("ompx_dyn_cgroup_mem",OMPC_ompx_dyn_cgroup_mem)
5135
    .Case("order",OMPC_order)
5136
    .Case("ordered",OMPC_ordered)
5137
    .Case("partial",OMPC_partial)
5138
    .Case("priority",OMPC_priority)
5139
    .Case("private",OMPC_private)
5140
    .Case("proc_bind",OMPC_proc_bind)
5141
    .Case("read",OMPC_read)
5142
    .Case("reduction",OMPC_reduction)
5143
    .Case("relaxed",OMPC_relaxed)
5144
    .Case("release",OMPC_release)
5145
    .Case("reverse_offload",OMPC_reverse_offload)
5146
    .Case("safelen",OMPC_safelen)
5147
    .Case("schedule",OMPC_schedule)
5148
    .Case("seq_cst",OMPC_seq_cst)
5149
    .Case("severity",OMPC_severity)
5150
    .Case("shared",OMPC_shared)
5151
    .Case("simd",OMPC_simd)
5152
    .Case("simdlen",OMPC_simdlen)
5153
    .Case("sizes",OMPC_sizes)
5154
    .Case("task_reduction",OMPC_task_reduction)
5155
    .Case("thread_limit",OMPC_thread_limit)
5156
    .Case("threadprivate",OMPC_unknown)
5157
    .Case("threads",OMPC_threads)
5158
    .Case("to",OMPC_to)
5159
    .Case("unified_address",OMPC_unified_address)
5160
    .Case("unified_shared_memory",OMPC_unified_shared_memory)
5161
    .Case("uniform",OMPC_uniform)
5162
    .Case("unknown",OMPC_unknown)
5163
    .Case("untied",OMPC_untied)
5164
    .Case("update",OMPC_update)
5165
    .Case("use",OMPC_use)
5166
    .Case("use_device_addr",OMPC_use_device_addr)
5167
    .Case("use_device_ptr",OMPC_use_device_ptr)
5168
    .Case("uses_allocators",OMPC_uses_allocators)
5169
    .Case("when",OMPC_when)
5170
    .Case("write",OMPC_write)
5171
    .Default(OMPC_unknown);
5172
}
5173
 
5174
llvm::StringRef llvm::omp::getOpenMPClauseName(Clause Kind) {
5175
  switch (Kind) {
5176
    case OMPC_acq_rel:
5177
      return "acq_rel";
5178
    case OMPC_acquire:
5179
      return "acquire";
5180
    case OMPC_adjust_args:
5181
      return "adjust_args";
5182
    case OMPC_affinity:
5183
      return "affinity";
5184
    case OMPC_align:
5185
      return "align";
5186
    case OMPC_aligned:
5187
      return "aligned";
5188
    case OMPC_allocate:
5189
      return "allocate";
5190
    case OMPC_allocator:
5191
      return "allocator";
5192
    case OMPC_append_args:
5193
      return "append_args";
5194
    case OMPC_at:
5195
      return "at";
5196
    case OMPC_atomic_default_mem_order:
5197
      return "atomic_default_mem_order";
5198
    case OMPC_bind:
5199
      return "bind";
5200
    case OMPC_cancellation_construct_type:
5201
      return "cancellation_construct_type";
5202
    case OMPC_capture:
5203
      return "capture";
5204
    case OMPC_collapse:
5205
      return "collapse";
5206
    case OMPC_compare:
5207
      return "compare";
5208
    case OMPC_copyprivate:
5209
      return "copyprivate";
5210
    case OMPC_copyin:
5211
      return "copyin";
5212
    case OMPC_default:
5213
      return "default";
5214
    case OMPC_defaultmap:
5215
      return "defaultmap";
5216
    case OMPC_depend:
5217
      return "depend";
5218
    case OMPC_depobj:
5219
      return "depobj";
5220
    case OMPC_destroy:
5221
      return "destroy";
5222
    case OMPC_detach:
5223
      return "detach";
5224
    case OMPC_device:
5225
      return "device";
5226
    case OMPC_device_type:
5227
      return "device_type";
5228
    case OMPC_dist_schedule:
5229
      return "dist_schedule";
5230
    case OMPC_dynamic_allocators:
5231
      return "dynamic_allocators";
5232
    case OMPC_exclusive:
5233
      return "exclusive";
5234
    case OMPC_filter:
5235
      return "filter";
5236
    case OMPC_final:
5237
      return "final";
5238
    case OMPC_firstprivate:
5239
      return "firstprivate";
5240
    case OMPC_flush:
5241
      return "flush";
5242
    case OMPC_from:
5243
      return "from";
5244
    case OMPC_full:
5245
      return "full";
5246
    case OMPC_grainsize:
5247
      return "grainsize";
5248
    case OMPC_has_device_addr:
5249
      return "has_device_addr";
5250
    case OMPC_hint:
5251
      return "hint";
5252
    case OMPC_if:
5253
      return "if";
5254
    case OMPC_in_reduction:
5255
      return "in_reduction";
5256
    case OMPC_inbranch:
5257
      return "inbranch";
5258
    case OMPC_inclusive:
5259
      return "inclusive";
5260
    case OMPC_indirect:
5261
      return "indirect";
5262
    case OMPC_init:
5263
      return "init";
5264
    case OMPC_is_device_ptr:
5265
      return "is_device_ptr";
5266
    case OMPC_lastprivate:
5267
      return "lastprivate";
5268
    case OMPC_linear:
5269
      return "linear";
5270
    case OMPC_link:
5271
      return "link";
5272
    case OMPC_map:
5273
      return "map";
5274
    case OMPC_match:
5275
      return "match";
5276
    case OMPC_memory_order:
5277
      return "memory_order";
5278
    case OMPC_mergeable:
5279
      return "mergeable";
5280
    case OMPC_message:
5281
      return "message";
5282
    case OMPC_nogroup:
5283
      return "nogroup";
5284
    case OMPC_nowait:
5285
      return "nowait";
5286
    case OMPC_nocontext:
5287
      return "nocontext";
5288
    case OMPC_nontemporal:
5289
      return "nontemporal";
5290
    case OMPC_notinbranch:
5291
      return "notinbranch";
5292
    case OMPC_novariants:
5293
      return "novariants";
5294
    case OMPC_num_tasks:
5295
      return "num_tasks";
5296
    case OMPC_num_teams:
5297
      return "num_teams";
5298
    case OMPC_num_threads:
5299
      return "num_threads";
5300
    case OMPC_ompx_dyn_cgroup_mem:
5301
      return "ompx_dyn_cgroup_mem";
5302
    case OMPC_order:
5303
      return "order";
5304
    case OMPC_ordered:
5305
      return "ordered";
5306
    case OMPC_partial:
5307
      return "partial";
5308
    case OMPC_priority:
5309
      return "priority";
5310
    case OMPC_private:
5311
      return "private";
5312
    case OMPC_proc_bind:
5313
      return "proc_bind";
5314
    case OMPC_read:
5315
      return "read";
5316
    case OMPC_reduction:
5317
      return "reduction";
5318
    case OMPC_relaxed:
5319
      return "relaxed";
5320
    case OMPC_release:
5321
      return "release";
5322
    case OMPC_reverse_offload:
5323
      return "reverse_offload";
5324
    case OMPC_safelen:
5325
      return "safelen";
5326
    case OMPC_schedule:
5327
      return "schedule";
5328
    case OMPC_seq_cst:
5329
      return "seq_cst";
5330
    case OMPC_severity:
5331
      return "severity";
5332
    case OMPC_shared:
5333
      return "shared";
5334
    case OMPC_simd:
5335
      return "simd";
5336
    case OMPC_simdlen:
5337
      return "simdlen";
5338
    case OMPC_sizes:
5339
      return "sizes";
5340
    case OMPC_task_reduction:
5341
      return "task_reduction";
5342
    case OMPC_thread_limit:
5343
      return "thread_limit";
5344
    case OMPC_threadprivate:
5345
      return "threadprivate or thread local";
5346
    case OMPC_threads:
5347
      return "threads";
5348
    case OMPC_to:
5349
      return "to";
5350
    case OMPC_unified_address:
5351
      return "unified_address";
5352
    case OMPC_unified_shared_memory:
5353
      return "unified_shared_memory";
5354
    case OMPC_uniform:
5355
      return "uniform";
5356
    case OMPC_unknown:
5357
      return "unknown";
5358
    case OMPC_untied:
5359
      return "untied";
5360
    case OMPC_update:
5361
      return "update";
5362
    case OMPC_use:
5363
      return "use";
5364
    case OMPC_use_device_addr:
5365
      return "use_device_addr";
5366
    case OMPC_use_device_ptr:
5367
      return "use_device_ptr";
5368
    case OMPC_uses_allocators:
5369
      return "uses_allocators";
5370
    case OMPC_when:
5371
      return "when";
5372
    case OMPC_write:
5373
      return "write";
5374
  }
5375
  llvm_unreachable("Invalid OpenMP Clause kind");
5376
}
5377
 
5378
CancellationConstructType llvm::omp::getCancellationConstructType(llvm::StringRef Str) {
5379
  return llvm::StringSwitch<CancellationConstructType>(Str)
5380
    .Case("parallel",OMP_CANCELLATION_CONSTRUCT_Parallel)
5381
    .Case("loop",OMP_CANCELLATION_CONSTRUCT_Loop)
5382
    .Case("sections",OMP_CANCELLATION_CONSTRUCT_Sections)
5383
    .Case("taskgroup",OMP_CANCELLATION_CONSTRUCT_Taskgroup)
5384
    .Case("none",OMP_CANCELLATION_CONSTRUCT_None)
5385
    .Default(OMP_CANCELLATION_CONSTRUCT_None);
5386
}
5387
 
5388
llvm::StringRef llvm::omp::getOpenMPCancellationConstructTypeName(llvm::omp::CancellationConstructType x) {
5389
  switch (x) {
5390
    case OMP_CANCELLATION_CONSTRUCT_Parallel:
5391
      return "parallel";
5392
    case OMP_CANCELLATION_CONSTRUCT_Loop:
5393
      return "loop";
5394
    case OMP_CANCELLATION_CONSTRUCT_Sections:
5395
      return "sections";
5396
    case OMP_CANCELLATION_CONSTRUCT_Taskgroup:
5397
      return "taskgroup";
5398
    case OMP_CANCELLATION_CONSTRUCT_None:
5399
      return "none";
5400
  }
5401
  llvm_unreachable("Invalid OpenMP CancellationConstructType kind");
5402
}
5403
 
5404
GrainsizeType llvm::omp::getGrainsizeType(llvm::StringRef Str) {
5405
  return llvm::StringSwitch<GrainsizeType>(Str)
5406
    .Case("strict",OMP_GRAINSIZE_Strict)
5407
    .Case("unkonwn",OMP_GRAINSIZE_Unknown)
5408
    .Default(OMP_GRAINSIZE_Unknown);
5409
}
5410
 
5411
llvm::StringRef llvm::omp::getOpenMPGrainsizeTypeName(llvm::omp::GrainsizeType x) {
5412
  switch (x) {
5413
    case OMP_GRAINSIZE_Strict:
5414
      return "strict";
5415
    case OMP_GRAINSIZE_Unknown:
5416
      return "unkonwn";
5417
  }
5418
  llvm_unreachable("Invalid OpenMP GrainsizeType kind");
5419
}
5420
 
5421
MemoryOrderKind llvm::omp::getMemoryOrderKind(llvm::StringRef Str) {
5422
  return llvm::StringSwitch<MemoryOrderKind>(Str)
5423
    .Case("seq_cst",OMP_MEMORY_ORDER_SeqCst)
5424
    .Case("acq_rel",OMP_MEMORY_ORDER_AcqRel)
5425
    .Case("acquire",OMP_MEMORY_ORDER_Acquire)
5426
    .Case("release",OMP_MEMORY_ORDER_Release)
5427
    .Case("relaxed",OMP_MEMORY_ORDER_Relaxed)
5428
    .Case("default",OMP_MEMORY_ORDER_Default)
5429
    .Default(OMP_MEMORY_ORDER_Default);
5430
}
5431
 
5432
llvm::StringRef llvm::omp::getOpenMPMemoryOrderKindName(llvm::omp::MemoryOrderKind x) {
5433
  switch (x) {
5434
    case OMP_MEMORY_ORDER_SeqCst:
5435
      return "seq_cst";
5436
    case OMP_MEMORY_ORDER_AcqRel:
5437
      return "acq_rel";
5438
    case OMP_MEMORY_ORDER_Acquire:
5439
      return "acquire";
5440
    case OMP_MEMORY_ORDER_Release:
5441
      return "release";
5442
    case OMP_MEMORY_ORDER_Relaxed:
5443
      return "relaxed";
5444
    case OMP_MEMORY_ORDER_Default:
5445
      return "default";
5446
  }
5447
  llvm_unreachable("Invalid OpenMP MemoryOrderKind kind");
5448
}
5449
 
5450
NumTasksType llvm::omp::getNumTasksType(llvm::StringRef Str) {
5451
  return llvm::StringSwitch<NumTasksType>(Str)
5452
    .Case("strict",OMP_NUMTASKS_Strict)
5453
    .Case("unkonwn",OMP_NUMTASKS_Unknown)
5454
    .Default(OMP_NUMTASKS_Unknown);
5455
}
5456
 
5457
llvm::StringRef llvm::omp::getOpenMPNumTasksTypeName(llvm::omp::NumTasksType x) {
5458
  switch (x) {
5459
    case OMP_NUMTASKS_Strict:
5460
      return "strict";
5461
    case OMP_NUMTASKS_Unknown:
5462
      return "unkonwn";
5463
  }
5464
  llvm_unreachable("Invalid OpenMP NumTasksType kind");
5465
}
5466
 
5467
OrderKind llvm::omp::getOrderKind(llvm::StringRef Str) {
5468
  return llvm::StringSwitch<OrderKind>(Str)
5469
    .Case("unknown",OMP_ORDER_unknown)
5470
    .Case("concurrent",OMP_ORDER_concurrent)
5471
    .Default(OMP_ORDER_unknown);
5472
}
5473
 
5474
llvm::StringRef llvm::omp::getOpenMPOrderKindName(llvm::omp::OrderKind x) {
5475
  switch (x) {
5476
    case OMP_ORDER_unknown:
5477
      return "unknown";
5478
    case OMP_ORDER_concurrent:
5479
      return "concurrent";
5480
  }
5481
  llvm_unreachable("Invalid OpenMP OrderKind kind");
5482
}
5483
 
5484
ProcBindKind llvm::omp::getProcBindKind(llvm::StringRef Str) {
5485
  return llvm::StringSwitch<ProcBindKind>(Str)
5486
    .Case("primary",OMP_PROC_BIND_primary)
5487
    .Case("master",OMP_PROC_BIND_master)
5488
    .Case("close",OMP_PROC_BIND_close)
5489
    .Case("spread",OMP_PROC_BIND_spread)
5490
    .Case("default",OMP_PROC_BIND_default)
5491
    .Case("unknown",OMP_PROC_BIND_unknown)
5492
    .Default(OMP_PROC_BIND_unknown);
5493
}
5494
 
5495
llvm::StringRef llvm::omp::getOpenMPProcBindKindName(llvm::omp::ProcBindKind x) {
5496
  switch (x) {
5497
    case OMP_PROC_BIND_primary:
5498
      return "primary";
5499
    case OMP_PROC_BIND_master:
5500
      return "master";
5501
    case OMP_PROC_BIND_close:
5502
      return "close";
5503
    case OMP_PROC_BIND_spread:
5504
      return "spread";
5505
    case OMP_PROC_BIND_default:
5506
      return "default";
5507
    case OMP_PROC_BIND_unknown:
5508
      return "unknown";
5509
  }
5510
  llvm_unreachable("Invalid OpenMP ProcBindKind kind");
5511
}
5512
 
5513
ScheduleKind llvm::omp::getScheduleKind(llvm::StringRef Str) {
5514
  return llvm::StringSwitch<ScheduleKind>(Str)
5515
    .Case("static",OMP_SCHEDULE_Static)
5516
    .Case("dynamic",OMP_SCHEDULE_Dynamic)
5517
    .Case("guided",OMP_SCHEDULE_Guided)
5518
    .Case("auto",OMP_SCHEDULE_Auto)
5519
    .Case("runtime",OMP_SCHEDULE_Runtime)
5520
    .Case("default",OMP_SCHEDULE_Default)
5521
    .Default(OMP_SCHEDULE_Default);
5522
}
5523
 
5524
llvm::StringRef llvm::omp::getOpenMPScheduleKindName(llvm::omp::ScheduleKind x) {
5525
  switch (x) {
5526
    case OMP_SCHEDULE_Static:
5527
      return "static";
5528
    case OMP_SCHEDULE_Dynamic:
5529
      return "dynamic";
5530
    case OMP_SCHEDULE_Guided:
5531
      return "guided";
5532
    case OMP_SCHEDULE_Auto:
5533
      return "auto";
5534
    case OMP_SCHEDULE_Runtime:
5535
      return "runtime";
5536
    case OMP_SCHEDULE_Default:
5537
      return "default";
5538
  }
5539
  llvm_unreachable("Invalid OpenMP ScheduleKind kind");
5540
}
5541
 
5542
bool llvm::omp::isAllowedClauseForDirective(Directive D, Clause C, unsigned Version) {
5543
  assert(unsigned(D) <= llvm::omp::Directive_enumSize);
5544
  assert(unsigned(C) <= llvm::omp::Clause_enumSize);
5545
  switch (D) {
5546
    case OMPD_allocate:
5547
      switch (C) {
5548
        case OMPC_allocator:
5549
          return 1 <= Version && 2147483647 >= Version;
5550
        case OMPC_align:
5551
          return 51 <= Version && 2147483647 >= Version;
5552
        default:
5553
          return false;
5554
      }
5555
      break;
5556
    case OMPD_assumes:
5557
      return false;
5558
      break;
5559
    case OMPD_atomic:
5560
      switch (C) {
5561
        case OMPC_read:
5562
          return 1 <= Version && 2147483647 >= Version;
5563
        case OMPC_write:
5564
          return 1 <= Version && 2147483647 >= Version;
5565
        case OMPC_update:
5566
          return 1 <= Version && 2147483647 >= Version;
5567
        case OMPC_capture:
5568
          return 1 <= Version && 2147483647 >= Version;
5569
        case OMPC_compare:
5570
          return 51 <= Version && 2147483647 >= Version;
5571
        case OMPC_seq_cst:
5572
          return 1 <= Version && 2147483647 >= Version;
5573
        case OMPC_acq_rel:
5574
          return 50 <= Version && 2147483647 >= Version;
5575
        case OMPC_acquire:
5576
          return 50 <= Version && 2147483647 >= Version;
5577
        case OMPC_release:
5578
          return 50 <= Version && 2147483647 >= Version;
5579
        case OMPC_relaxed:
5580
          return 50 <= Version && 2147483647 >= Version;
5581
        case OMPC_hint:
5582
          return 50 <= Version && 2147483647 >= Version;
5583
        default:
5584
          return false;
5585
      }
5586
      break;
5587
    case OMPD_barrier:
5588
      return false;
5589
      break;
5590
    case OMPD_begin_assumes:
5591
      return false;
5592
      break;
5593
    case OMPD_begin_declare_target:
5594
      switch (C) {
5595
        case OMPC_to:
5596
          return 1 <= Version && 2147483647 >= Version;
5597
        case OMPC_link:
5598
          return 1 <= Version && 2147483647 >= Version;
5599
        case OMPC_device_type:
5600
          return 1 <= Version && 2147483647 >= Version;
5601
        case OMPC_indirect:
5602
          return 1 <= Version && 2147483647 >= Version;
5603
        default:
5604
          return false;
5605
      }
5606
      break;
5607
    case OMPD_begin_declare_variant:
5608
      return false;
5609
      break;
5610
    case OMPD_cancel:
5611
      switch (C) {
5612
        case OMPC_if:
5613
          return 1 <= Version && 2147483647 >= Version;
5614
        default:
5615
          return false;
5616
      }
5617
      break;
5618
    case OMPD_cancellation_point:
5619
      return false;
5620
      break;
5621
    case OMPD_critical:
5622
      switch (C) {
5623
        case OMPC_hint:
5624
          return 1 <= Version && 2147483647 >= Version;
5625
        default:
5626
          return false;
5627
      }
5628
      break;
5629
    case OMPD_declare_mapper:
5630
      switch (C) {
5631
        case OMPC_map:
5632
          return 1 <= Version && 2147483647 >= Version;
5633
        default:
5634
          return false;
5635
      }
5636
      break;
5637
    case OMPD_declare_reduction:
5638
      return false;
5639
      break;
5640
    case OMPD_declare_simd:
5641
      switch (C) {
5642
        case OMPC_linear:
5643
          return 1 <= Version && 2147483647 >= Version;
5644
        case OMPC_aligned:
5645
          return 1 <= Version && 2147483647 >= Version;
5646
        case OMPC_uniform:
5647
          return 1 <= Version && 2147483647 >= Version;
5648
        case OMPC_simdlen:
5649
          return 1 <= Version && 2147483647 >= Version;
5650
        case OMPC_inbranch:
5651
          return 1 <= Version && 2147483647 >= Version;
5652
        case OMPC_notinbranch:
5653
          return 1 <= Version && 2147483647 >= Version;
5654
        default:
5655
          return false;
5656
      }
5657
      break;
5658
    case OMPD_declare_target:
5659
      switch (C) {
5660
        case OMPC_to:
5661
          return 1 <= Version && 2147483647 >= Version;
5662
        case OMPC_link:
5663
          return 1 <= Version && 2147483647 >= Version;
5664
        case OMPC_indirect:
5665
          return 1 <= Version && 2147483647 >= Version;
5666
        default:
5667
          return false;
5668
      }
5669
      break;
5670
    case OMPD_declare_variant:
5671
      switch (C) {
5672
        case OMPC_match:
5673
          return 1 <= Version && 2147483647 >= Version;
5674
        case OMPC_adjust_args:
5675
          return 51 <= Version && 2147483647 >= Version;
5676
        case OMPC_append_args:
5677
          return 51 <= Version && 2147483647 >= Version;
5678
        default:
5679
          return false;
5680
      }
5681
      break;
5682
    case OMPD_depobj:
5683
      switch (C) {
5684
        case OMPC_depend:
5685
          return 50 <= Version && 2147483647 >= Version;
5686
        case OMPC_destroy:
5687
          return 50 <= Version && 2147483647 >= Version;
5688
        case OMPC_update:
5689
          return 50 <= Version && 2147483647 >= Version;
5690
        case OMPC_depobj:
5691
          return 50 <= Version && 2147483647 >= Version;
5692
        default:
5693
          return false;
5694
      }
5695
      break;
5696
    case OMPD_distribute:
5697
      switch (C) {
5698
        case OMPC_private:
5699
          return 1 <= Version && 2147483647 >= Version;
5700
        case OMPC_firstprivate:
5701
          return 1 <= Version && 2147483647 >= Version;
5702
        case OMPC_lastprivate:
5703
          return 1 <= Version && 2147483647 >= Version;
5704
        case OMPC_allocate:
5705
          return 1 <= Version && 2147483647 >= Version;
5706
        case OMPC_collapse:
5707
          return 1 <= Version && 2147483647 >= Version;
5708
        case OMPC_dist_schedule:
5709
          return 1 <= Version && 2147483647 >= Version;
5710
        default:
5711
          return false;
5712
      }
5713
      break;
5714
    case OMPD_distribute_parallel_do:
5715
      switch (C) {
5716
        case OMPC_private:
5717
          return 1 <= Version && 2147483647 >= Version;
5718
        case OMPC_firstprivate:
5719
          return 1 <= Version && 2147483647 >= Version;
5720
        case OMPC_lastprivate:
5721
          return 1 <= Version && 2147483647 >= Version;
5722
        case OMPC_allocate:
5723
          return 1 <= Version && 2147483647 >= Version;
5724
        case OMPC_order:
5725
          return 1 <= Version && 2147483647 >= Version;
5726
        case OMPC_default:
5727
          return 1 <= Version && 2147483647 >= Version;
5728
        case OMPC_shared:
5729
          return 1 <= Version && 2147483647 >= Version;
5730
        case OMPC_reduction:
5731
          return 1 <= Version && 2147483647 >= Version;
5732
        case OMPC_copyin:
5733
          return 1 <= Version && 2147483647 >= Version;
5734
        case OMPC_linear:
5735
          return 1 <= Version && 2147483647 >= Version;
5736
        case OMPC_collapse:
5737
          return 1 <= Version && 2147483647 >= Version;
5738
        case OMPC_dist_schedule:
5739
          return 1 <= Version && 2147483647 >= Version;
5740
        case OMPC_if:
5741
          return 1 <= Version && 2147483647 >= Version;
5742
        case OMPC_num_threads:
5743
          return 1 <= Version && 2147483647 >= Version;
5744
        case OMPC_proc_bind:
5745
          return 1 <= Version && 2147483647 >= Version;
5746
        case OMPC_schedule:
5747
          return 1 <= Version && 2147483647 >= Version;
5748
        case OMPC_ordered:
5749
          return 1 <= Version && 2147483647 >= Version;
5750
        default:
5751
          return false;
5752
      }
5753
      break;
5754
    case OMPD_distribute_parallel_do_simd:
5755
      switch (C) {
5756
        case OMPC_firstprivate:
5757
          return 1 <= Version && 2147483647 >= Version;
5758
        case OMPC_lastprivate:
5759
          return 1 <= Version && 2147483647 >= Version;
5760
        case OMPC_collapse:
5761
          return 1 <= Version && 2147483647 >= Version;
5762
        case OMPC_dist_schedule:
5763
          return 1 <= Version && 2147483647 >= Version;
5764
        case OMPC_if:
5765
          return 1 <= Version && 2147483647 >= Version;
5766
        case OMPC_num_threads:
5767
          return 1 <= Version && 2147483647 >= Version;
5768
        case OMPC_default:
5769
          return 1 <= Version && 2147483647 >= Version;
5770
        case OMPC_proc_bind:
5771
          return 1 <= Version && 2147483647 >= Version;
5772
        case OMPC_private:
5773
          return 1 <= Version && 2147483647 >= Version;
5774
        case OMPC_shared:
5775
          return 1 <= Version && 2147483647 >= Version;
5776
        case OMPC_reduction:
5777
          return 1 <= Version && 2147483647 >= Version;
5778
        case OMPC_copyin:
5779
          return 1 <= Version && 2147483647 >= Version;
5780
        case OMPC_schedule:
5781
          return 1 <= Version && 2147483647 >= Version;
5782
        case OMPC_linear:
5783
          return 1 <= Version && 2147483647 >= Version;
5784
        case OMPC_aligned:
5785
          return 1 <= Version && 2147483647 >= Version;
5786
        case OMPC_safelen:
5787
          return 1 <= Version && 2147483647 >= Version;
5788
        case OMPC_simdlen:
5789
          return 1 <= Version && 2147483647 >= Version;
5790
        case OMPC_allocate:
5791
          return 1 <= Version && 2147483647 >= Version;
5792
        case OMPC_nontemporal:
5793
          return 1 <= Version && 2147483647 >= Version;
5794
        case OMPC_order:
5795
          return 1 <= Version && 2147483647 >= Version;
5796
        default:
5797
          return false;
5798
      }
5799
      break;
5800
    case OMPD_distribute_parallel_for:
5801
      switch (C) {
5802
        case OMPC_firstprivate:
5803
          return 1 <= Version && 2147483647 >= Version;
5804
        case OMPC_lastprivate:
5805
          return 1 <= Version && 2147483647 >= Version;
5806
        case OMPC_collapse:
5807
          return 1 <= Version && 2147483647 >= Version;
5808
        case OMPC_dist_schedule:
5809
          return 1 <= Version && 2147483647 >= Version;
5810
        case OMPC_if:
5811
          return 1 <= Version && 2147483647 >= Version;
5812
        case OMPC_num_threads:
5813
          return 1 <= Version && 2147483647 >= Version;
5814
        case OMPC_default:
5815
          return 1 <= Version && 2147483647 >= Version;
5816
        case OMPC_proc_bind:
5817
          return 1 <= Version && 2147483647 >= Version;
5818
        case OMPC_private:
5819
          return 1 <= Version && 2147483647 >= Version;
5820
        case OMPC_shared:
5821
          return 1 <= Version && 2147483647 >= Version;
5822
        case OMPC_reduction:
5823
          return 1 <= Version && 2147483647 >= Version;
5824
        case OMPC_copyin:
5825
          return 1 <= Version && 2147483647 >= Version;
5826
        case OMPC_schedule:
5827
          return 1 <= Version && 2147483647 >= Version;
5828
        case OMPC_allocate:
5829
          return 1 <= Version && 2147483647 >= Version;
5830
        case OMPC_order:
5831
          return 50 <= Version && 2147483647 >= Version;
5832
        default:
5833
          return false;
5834
      }
5835
      break;
5836
    case OMPD_distribute_parallel_for_simd:
5837
      switch (C) {
5838
        case OMPC_firstprivate:
5839
          return 1 <= Version && 2147483647 >= Version;
5840
        case OMPC_lastprivate:
5841
          return 1 <= Version && 2147483647 >= Version;
5842
        case OMPC_collapse:
5843
          return 1 <= Version && 2147483647 >= Version;
5844
        case OMPC_dist_schedule:
5845
          return 1 <= Version && 2147483647 >= Version;
5846
        case OMPC_if:
5847
          return 1 <= Version && 2147483647 >= Version;
5848
        case OMPC_num_threads:
5849
          return 1 <= Version && 2147483647 >= Version;
5850
        case OMPC_default:
5851
          return 1 <= Version && 2147483647 >= Version;
5852
        case OMPC_proc_bind:
5853
          return 1 <= Version && 2147483647 >= Version;
5854
        case OMPC_private:
5855
          return 1 <= Version && 2147483647 >= Version;
5856
        case OMPC_shared:
5857
          return 1 <= Version && 2147483647 >= Version;
5858
        case OMPC_reduction:
5859
          return 1 <= Version && 2147483647 >= Version;
5860
        case OMPC_copyin:
5861
          return 1 <= Version && 2147483647 >= Version;
5862
        case OMPC_schedule:
5863
          return 1 <= Version && 2147483647 >= Version;
5864
        case OMPC_linear:
5865
          return 1 <= Version && 2147483647 >= Version;
5866
        case OMPC_aligned:
5867
          return 1 <= Version && 2147483647 >= Version;
5868
        case OMPC_safelen:
5869
          return 1 <= Version && 2147483647 >= Version;
5870
        case OMPC_simdlen:
5871
          return 1 <= Version && 2147483647 >= Version;
5872
        case OMPC_allocate:
5873
          return 1 <= Version && 2147483647 >= Version;
5874
        case OMPC_nontemporal:
5875
          return 50 <= Version && 2147483647 >= Version;
5876
        case OMPC_order:
5877
          return 50 <= Version && 2147483647 >= Version;
5878
        default:
5879
          return false;
5880
      }
5881
      break;
5882
    case OMPD_distribute_simd:
5883
      switch (C) {
5884
        case OMPC_aligned:
5885
          return 1 <= Version && 2147483647 >= Version;
5886
        case OMPC_allocate:
5887
          return 1 <= Version && 2147483647 >= Version;
5888
        case OMPC_copyin:
5889
          return 1 <= Version && 2147483647 >= Version;
5890
        case OMPC_default:
5891
          return 1 <= Version && 2147483647 >= Version;
5892
        case OMPC_linear:
5893
          return 1 <= Version && 2147483647 >= Version;
5894
        case OMPC_firstprivate:
5895
          return 1 <= Version && 2147483647 >= Version;
5896
        case OMPC_lastprivate:
5897
          return 1 <= Version && 2147483647 >= Version;
5898
        case OMPC_nontemporal:
5899
          return 50 <= Version && 2147483647 >= Version;
5900
        case OMPC_order:
5901
          return 50 <= Version && 2147483647 >= Version;
5902
        case OMPC_private:
5903
          return 1 <= Version && 2147483647 >= Version;
5904
        case OMPC_reduction:
5905
          return 1 <= Version && 2147483647 >= Version;
5906
        case OMPC_collapse:
5907
          return 1 <= Version && 2147483647 >= Version;
5908
        case OMPC_dist_schedule:
5909
          return 1 <= Version && 2147483647 >= Version;
5910
        case OMPC_if:
5911
          return 50 <= Version && 2147483647 >= Version;
5912
        case OMPC_num_threads:
5913
          return 1 <= Version && 2147483647 >= Version;
5914
        case OMPC_ordered:
5915
          return 1 <= Version && 2147483647 >= Version;
5916
        case OMPC_proc_bind:
5917
          return 1 <= Version && 2147483647 >= Version;
5918
        case OMPC_schedule:
5919
          return 1 <= Version && 2147483647 >= Version;
5920
        case OMPC_safelen:
5921
          return 1 <= Version && 2147483647 >= Version;
5922
        case OMPC_simdlen:
5923
          return 1 <= Version && 2147483647 >= Version;
5924
        default:
5925
          return false;
5926
      }
5927
      break;
5928
    case OMPD_do:
5929
      switch (C) {
5930
        case OMPC_private:
5931
          return 1 <= Version && 2147483647 >= Version;
5932
        case OMPC_firstprivate:
5933
          return 1 <= Version && 2147483647 >= Version;
5934
        case OMPC_lastprivate:
5935
          return 1 <= Version && 2147483647 >= Version;
5936
        case OMPC_linear:
5937
          return 1 <= Version && 2147483647 >= Version;
5938
        case OMPC_reduction:
5939
          return 1 <= Version && 2147483647 >= Version;
5940
        case OMPC_schedule:
5941
          return 1 <= Version && 2147483647 >= Version;
5942
        case OMPC_collapse:
5943
          return 1 <= Version && 2147483647 >= Version;
5944
        case OMPC_ordered:
5945
          return 1 <= Version && 2147483647 >= Version;
5946
        case OMPC_nowait:
5947
          return 1 <= Version && 2147483647 >= Version;
5948
        default:
5949
          return false;
5950
      }
5951
      break;
5952
    case OMPD_do_simd:
5953
      switch (C) {
5954
        case OMPC_aligned:
5955
          return 1 <= Version && 2147483647 >= Version;
5956
        case OMPC_private:
5957
          return 1 <= Version && 2147483647 >= Version;
5958
        case OMPC_firstprivate:
5959
          return 1 <= Version && 2147483647 >= Version;
5960
        case OMPC_lastprivate:
5961
          return 1 <= Version && 2147483647 >= Version;
5962
        case OMPC_linear:
5963
          return 1 <= Version && 2147483647 >= Version;
5964
        case OMPC_reduction:
5965
          return 1 <= Version && 2147483647 >= Version;
5966
        case OMPC_schedule:
5967
          return 1 <= Version && 2147483647 >= Version;
5968
        case OMPC_collapse:
5969
          return 1 <= Version && 2147483647 >= Version;
5970
        case OMPC_ordered:
5971
          return 1 <= Version && 2147483647 >= Version;
5972
        case OMPC_safelen:
5973
          return 1 <= Version && 2147483647 >= Version;
5974
        case OMPC_simdlen:
5975
          return 1 <= Version && 2147483647 >= Version;
5976
        case OMPC_nowait:
5977
          return 1 <= Version && 2147483647 >= Version;
5978
        default:
5979
          return false;
5980
      }
5981
      break;
5982
    case OMPD_end_assumes:
5983
      return false;
5984
      break;
5985
    case OMPD_end_declare_target:
5986
      return false;
5987
      break;
5988
    case OMPD_end_declare_variant:
5989
      return false;
5990
      break;
5991
    case OMPD_end_do:
5992
      return false;
5993
      break;
5994
    case OMPD_end_do_simd:
5995
      return false;
5996
      break;
5997
    case OMPD_end_sections:
5998
      switch (C) {
5999
        case OMPC_nowait:
6000
          return 1 <= Version && 2147483647 >= Version;
6001
        default:
6002
          return false;
6003
      }
6004
      break;
6005
    case OMPD_end_single:
6006
      switch (C) {
6007
        case OMPC_copyprivate:
6008
          return 1 <= Version && 2147483647 >= Version;
6009
        case OMPC_nowait:
6010
          return 1 <= Version && 2147483647 >= Version;
6011
        default:
6012
          return false;
6013
      }
6014
      break;
6015
    case OMPD_end_workshare:
6016
      switch (C) {
6017
        case OMPC_nowait:
6018
          return 1 <= Version && 2147483647 >= Version;
6019
        default:
6020
          return false;
6021
      }
6022
      break;
6023
    case OMPD_error:
6024
      switch (C) {
6025
        case OMPC_at:
6026
          return 51 <= Version && 2147483647 >= Version;
6027
        case OMPC_severity:
6028
          return 51 <= Version && 2147483647 >= Version;
6029
        case OMPC_message:
6030
          return 51 <= Version && 2147483647 >= Version;
6031
        default:
6032
          return false;
6033
      }
6034
      break;
6035
    case OMPD_flush:
6036
      switch (C) {
6037
        case OMPC_acq_rel:
6038
          return 50 <= Version && 2147483647 >= Version;
6039
        case OMPC_acquire:
6040
          return 50 <= Version && 2147483647 >= Version;
6041
        case OMPC_release:
6042
          return 50 <= Version && 2147483647 >= Version;
6043
        case OMPC_flush:
6044
          return 1 <= Version && 2147483647 >= Version;
6045
        default:
6046
          return false;
6047
      }
6048
      break;
6049
    case OMPD_for:
6050
      switch (C) {
6051
        case OMPC_private:
6052
          return 1 <= Version && 2147483647 >= Version;
6053
        case OMPC_lastprivate:
6054
          return 1 <= Version && 2147483647 >= Version;
6055
        case OMPC_firstprivate:
6056
          return 1 <= Version && 2147483647 >= Version;
6057
        case OMPC_reduction:
6058
          return 1 <= Version && 2147483647 >= Version;
6059
        case OMPC_collapse:
6060
          return 1 <= Version && 2147483647 >= Version;
6061
        case OMPC_schedule:
6062
          return 1 <= Version && 2147483647 >= Version;
6063
        case OMPC_ordered:
6064
          return 1 <= Version && 2147483647 >= Version;
6065
        case OMPC_nowait:
6066
          return 1 <= Version && 2147483647 >= Version;
6067
        case OMPC_linear:
6068
          return 1 <= Version && 2147483647 >= Version;
6069
        case OMPC_allocate:
6070
          return 1 <= Version && 2147483647 >= Version;
6071
        case OMPC_order:
6072
          return 50 <= Version && 2147483647 >= Version;
6073
        default:
6074
          return false;
6075
      }
6076
      break;
6077
    case OMPD_for_simd:
6078
      switch (C) {
6079
        case OMPC_private:
6080
          return 1 <= Version && 2147483647 >= Version;
6081
        case OMPC_firstprivate:
6082
          return 1 <= Version && 2147483647 >= Version;
6083
        case OMPC_lastprivate:
6084
          return 1 <= Version && 2147483647 >= Version;
6085
        case OMPC_reduction:
6086
          return 1 <= Version && 2147483647 >= Version;
6087
        case OMPC_schedule:
6088
          return 1 <= Version && 2147483647 >= Version;
6089
        case OMPC_collapse:
6090
          return 1 <= Version && 2147483647 >= Version;
6091
        case OMPC_nowait:
6092
          return 1 <= Version && 2147483647 >= Version;
6093
        case OMPC_safelen:
6094
          return 1 <= Version && 2147483647 >= Version;
6095
        case OMPC_simdlen:
6096
          return 1 <= Version && 2147483647 >= Version;
6097
        case OMPC_linear:
6098
          return 1 <= Version && 2147483647 >= Version;
6099
        case OMPC_aligned:
6100
          return 1 <= Version && 2147483647 >= Version;
6101
        case OMPC_ordered:
6102
          return 1 <= Version && 2147483647 >= Version;
6103
        case OMPC_allocate:
6104
          return 1 <= Version && 2147483647 >= Version;
6105
        case OMPC_if:
6106
          return 50 <= Version && 2147483647 >= Version;
6107
        case OMPC_nontemporal:
6108
          return 50 <= Version && 2147483647 >= Version;
6109
        case OMPC_order:
6110
          return 50 <= Version && 2147483647 >= Version;
6111
        default:
6112
          return false;
6113
      }
6114
      break;
6115
    case OMPD_masked_taskloop:
6116
      switch (C) {
6117
        case OMPC_if:
6118
          return 1 <= Version && 2147483647 >= Version;
6119
        case OMPC_shared:
6120
          return 1 <= Version && 2147483647 >= Version;
6121
        case OMPC_private:
6122
          return 1 <= Version && 2147483647 >= Version;
6123
        case OMPC_firstprivate:
6124
          return 1 <= Version && 2147483647 >= Version;
6125
        case OMPC_lastprivate:
6126
          return 1 <= Version && 2147483647 >= Version;
6127
        case OMPC_default:
6128
          return 1 <= Version && 2147483647 >= Version;
6129
        case OMPC_collapse:
6130
          return 1 <= Version && 2147483647 >= Version;
6131
        case OMPC_final:
6132
          return 1 <= Version && 2147483647 >= Version;
6133
        case OMPC_untied:
6134
          return 1 <= Version && 2147483647 >= Version;
6135
        case OMPC_mergeable:
6136
          return 1 <= Version && 2147483647 >= Version;
6137
        case OMPC_priority:
6138
          return 1 <= Version && 2147483647 >= Version;
6139
        case OMPC_grainsize:
6140
          return 1 <= Version && 2147483647 >= Version;
6141
        case OMPC_nogroup:
6142
          return 1 <= Version && 2147483647 >= Version;
6143
        case OMPC_num_tasks:
6144
          return 1 <= Version && 2147483647 >= Version;
6145
        case OMPC_reduction:
6146
          return 1 <= Version && 2147483647 >= Version;
6147
        case OMPC_in_reduction:
6148
          return 1 <= Version && 2147483647 >= Version;
6149
        case OMPC_allocate:
6150
          return 1 <= Version && 2147483647 >= Version;
6151
        case OMPC_filter:
6152
          return 1 <= Version && 2147483647 >= Version;
6153
        default:
6154
          return false;
6155
      }
6156
      break;
6157
    case OMPD_masked_taskloop_simd:
6158
      switch (C) {
6159
        case OMPC_if:
6160
          return 1 <= Version && 2147483647 >= Version;
6161
        case OMPC_shared:
6162
          return 1 <= Version && 2147483647 >= Version;
6163
        case OMPC_private:
6164
          return 1 <= Version && 2147483647 >= Version;
6165
        case OMPC_firstprivate:
6166
          return 1 <= Version && 2147483647 >= Version;
6167
        case OMPC_lastprivate:
6168
          return 1 <= Version && 2147483647 >= Version;
6169
        case OMPC_default:
6170
          return 1 <= Version && 2147483647 >= Version;
6171
        case OMPC_collapse:
6172
          return 1 <= Version && 2147483647 >= Version;
6173
        case OMPC_final:
6174
          return 1 <= Version && 2147483647 >= Version;
6175
        case OMPC_untied:
6176
          return 1 <= Version && 2147483647 >= Version;
6177
        case OMPC_mergeable:
6178
          return 1 <= Version && 2147483647 >= Version;
6179
        case OMPC_priority:
6180
          return 1 <= Version && 2147483647 >= Version;
6181
        case OMPC_linear:
6182
          return 1 <= Version && 2147483647 >= Version;
6183
        case OMPC_aligned:
6184
          return 1 <= Version && 2147483647 >= Version;
6185
        case OMPC_safelen:
6186
          return 1 <= Version && 2147483647 >= Version;
6187
        case OMPC_simdlen:
6188
          return 1 <= Version && 2147483647 >= Version;
6189
        case OMPC_grainsize:
6190
          return 1 <= Version && 2147483647 >= Version;
6191
        case OMPC_nogroup:
6192
          return 1 <= Version && 2147483647 >= Version;
6193
        case OMPC_num_tasks:
6194
          return 1 <= Version && 2147483647 >= Version;
6195
        case OMPC_reduction:
6196
          return 1 <= Version && 2147483647 >= Version;
6197
        case OMPC_in_reduction:
6198
          return 1 <= Version && 2147483647 >= Version;
6199
        case OMPC_allocate:
6200
          return 1 <= Version && 2147483647 >= Version;
6201
        case OMPC_nontemporal:
6202
          return 50 <= Version && 2147483647 >= Version;
6203
        case OMPC_order:
6204
          return 50 <= Version && 2147483647 >= Version;
6205
        case OMPC_filter:
6206
          return 1 <= Version && 2147483647 >= Version;
6207
        default:
6208
          return false;
6209
      }
6210
      break;
6211
    case OMPD_master:
6212
      return false;
6213
      break;
6214
    case OMPD_master_taskloop:
6215
      switch (C) {
6216
        case OMPC_if:
6217
          return 1 <= Version && 2147483647 >= Version;
6218
        case OMPC_shared:
6219
          return 1 <= Version && 2147483647 >= Version;
6220
        case OMPC_private:
6221
          return 1 <= Version && 2147483647 >= Version;
6222
        case OMPC_firstprivate:
6223
          return 1 <= Version && 2147483647 >= Version;
6224
        case OMPC_lastprivate:
6225
          return 1 <= Version && 2147483647 >= Version;
6226
        case OMPC_default:
6227
          return 1 <= Version && 2147483647 >= Version;
6228
        case OMPC_collapse:
6229
          return 1 <= Version && 2147483647 >= Version;
6230
        case OMPC_final:
6231
          return 1 <= Version && 2147483647 >= Version;
6232
        case OMPC_untied:
6233
          return 1 <= Version && 2147483647 >= Version;
6234
        case OMPC_mergeable:
6235
          return 1 <= Version && 2147483647 >= Version;
6236
        case OMPC_priority:
6237
          return 1 <= Version && 2147483647 >= Version;
6238
        case OMPC_grainsize:
6239
          return 1 <= Version && 2147483647 >= Version;
6240
        case OMPC_nogroup:
6241
          return 1 <= Version && 2147483647 >= Version;
6242
        case OMPC_num_tasks:
6243
          return 1 <= Version && 2147483647 >= Version;
6244
        case OMPC_reduction:
6245
          return 1 <= Version && 2147483647 >= Version;
6246
        case OMPC_in_reduction:
6247
          return 1 <= Version && 2147483647 >= Version;
6248
        case OMPC_allocate:
6249
          return 1 <= Version && 2147483647 >= Version;
6250
        default:
6251
          return false;
6252
      }
6253
      break;
6254
    case OMPD_master_taskloop_simd:
6255
      switch (C) {
6256
        case OMPC_if:
6257
          return 1 <= Version && 2147483647 >= Version;
6258
        case OMPC_shared:
6259
          return 1 <= Version && 2147483647 >= Version;
6260
        case OMPC_private:
6261
          return 1 <= Version && 2147483647 >= Version;
6262
        case OMPC_firstprivate:
6263
          return 1 <= Version && 2147483647 >= Version;
6264
        case OMPC_lastprivate:
6265
          return 1 <= Version && 2147483647 >= Version;
6266
        case OMPC_default:
6267
          return 1 <= Version && 2147483647 >= Version;
6268
        case OMPC_collapse:
6269
          return 1 <= Version && 2147483647 >= Version;
6270
        case OMPC_final:
6271
          return 1 <= Version && 2147483647 >= Version;
6272
        case OMPC_untied:
6273
          return 1 <= Version && 2147483647 >= Version;
6274
        case OMPC_mergeable:
6275
          return 1 <= Version && 2147483647 >= Version;
6276
        case OMPC_priority:
6277
          return 1 <= Version && 2147483647 >= Version;
6278
        case OMPC_linear:
6279
          return 1 <= Version && 2147483647 >= Version;
6280
        case OMPC_aligned:
6281
          return 1 <= Version && 2147483647 >= Version;
6282
        case OMPC_safelen:
6283
          return 1 <= Version && 2147483647 >= Version;
6284
        case OMPC_simdlen:
6285
          return 1 <= Version && 2147483647 >= Version;
6286
        case OMPC_grainsize:
6287
          return 1 <= Version && 2147483647 >= Version;
6288
        case OMPC_nogroup:
6289
          return 1 <= Version && 2147483647 >= Version;
6290
        case OMPC_num_tasks:
6291
          return 1 <= Version && 2147483647 >= Version;
6292
        case OMPC_reduction:
6293
          return 1 <= Version && 2147483647 >= Version;
6294
        case OMPC_in_reduction:
6295
          return 1 <= Version && 2147483647 >= Version;
6296
        case OMPC_allocate:
6297
          return 1 <= Version && 2147483647 >= Version;
6298
        case OMPC_nontemporal:
6299
          return 50 <= Version && 2147483647 >= Version;
6300
        case OMPC_order:
6301
          return 50 <= Version && 2147483647 >= Version;
6302
        default:
6303
          return false;
6304
      }
6305
      break;
6306
    case OMPD_metadirective:
6307
      switch (C) {
6308
        case OMPC_when:
6309
          return 1 <= Version && 2147483647 >= Version;
6310
        case OMPC_default:
6311
          return 1 <= Version && 2147483647 >= Version;
6312
        default:
6313
          return false;
6314
      }
6315
      break;
6316
    case OMPD_nothing:
6317
      return false;
6318
      break;
6319
    case OMPD_ordered:
6320
      switch (C) {
6321
        case OMPC_depend:
6322
          return 1 <= Version && 2147483647 >= Version;
6323
        case OMPC_threads:
6324
          return 1 <= Version && 2147483647 >= Version;
6325
        case OMPC_simd:
6326
          return 1 <= Version && 2147483647 >= Version;
6327
        default:
6328
          return false;
6329
      }
6330
      break;
6331
    case OMPD_parallel:
6332
      switch (C) {
6333
        case OMPC_private:
6334
          return 1 <= Version && 2147483647 >= Version;
6335
        case OMPC_firstprivate:
6336
          return 1 <= Version && 2147483647 >= Version;
6337
        case OMPC_shared:
6338
          return 1 <= Version && 2147483647 >= Version;
6339
        case OMPC_reduction:
6340
          return 1 <= Version && 2147483647 >= Version;
6341
        case OMPC_copyin:
6342
          return 1 <= Version && 2147483647 >= Version;
6343
        case OMPC_allocate:
6344
          return 1 <= Version && 2147483647 >= Version;
6345
        case OMPC_default:
6346
          return 1 <= Version && 2147483647 >= Version;
6347
        case OMPC_if:
6348
          return 1 <= Version && 2147483647 >= Version;
6349
        case OMPC_num_threads:
6350
          return 1 <= Version && 2147483647 >= Version;
6351
        case OMPC_proc_bind:
6352
          return 1 <= Version && 2147483647 >= Version;
6353
        default:
6354
          return false;
6355
      }
6356
      break;
6357
    case OMPD_parallel_do:
6358
      switch (C) {
6359
        case OMPC_default:
6360
          return 1 <= Version && 2147483647 >= Version;
6361
        case OMPC_private:
6362
          return 1 <= Version && 2147483647 >= Version;
6363
        case OMPC_firstprivate:
6364
          return 1 <= Version && 2147483647 >= Version;
6365
        case OMPC_shared:
6366
          return 1 <= Version && 2147483647 >= Version;
6367
        case OMPC_reduction:
6368
          return 1 <= Version && 2147483647 >= Version;
6369
        case OMPC_copyin:
6370
          return 1 <= Version && 2147483647 >= Version;
6371
        case OMPC_lastprivate:
6372
          return 1 <= Version && 2147483647 >= Version;
6373
        case OMPC_linear:
6374
          return 1 <= Version && 2147483647 >= Version;
6375
        case OMPC_if:
6376
          return 1 <= Version && 2147483647 >= Version;
6377
        case OMPC_num_threads:
6378
          return 1 <= Version && 2147483647 >= Version;
6379
        case OMPC_proc_bind:
6380
          return 1 <= Version && 2147483647 >= Version;
6381
        case OMPC_schedule:
6382
          return 1 <= Version && 2147483647 >= Version;
6383
        case OMPC_ordered:
6384
          return 1 <= Version && 2147483647 >= Version;
6385
        case OMPC_collapse:
6386
          return 1 <= Version && 2147483647 >= Version;
6387
        default:
6388
          return false;
6389
      }
6390
      break;
6391
    case OMPD_parallel_do_simd:
6392
      switch (C) {
6393
        case OMPC_default:
6394
          return 1 <= Version && 2147483647 >= Version;
6395
        case OMPC_private:
6396
          return 1 <= Version && 2147483647 >= Version;
6397
        case OMPC_firstprivate:
6398
          return 1 <= Version && 2147483647 >= Version;
6399
        case OMPC_shared:
6400
          return 1 <= Version && 2147483647 >= Version;
6401
        case OMPC_reduction:
6402
          return 1 <= Version && 2147483647 >= Version;
6403
        case OMPC_copyin:
6404
          return 1 <= Version && 2147483647 >= Version;
6405
        case OMPC_lastprivate:
6406
          return 1 <= Version && 2147483647 >= Version;
6407
        case OMPC_linear:
6408
          return 1 <= Version && 2147483647 >= Version;
6409
        case OMPC_aligned:
6410
          return 1 <= Version && 2147483647 >= Version;
6411
        case OMPC_allocate:
6412
          return 1 <= Version && 2147483647 >= Version;
6413
        case OMPC_nontemporal:
6414
          return 1 <= Version && 2147483647 >= Version;
6415
        case OMPC_order:
6416
          return 1 <= Version && 2147483647 >= Version;
6417
        case OMPC_if:
6418
          return 1 <= Version && 2147483647 >= Version;
6419
        case OMPC_num_threads:
6420
          return 1 <= Version && 2147483647 >= Version;
6421
        case OMPC_proc_bind:
6422
          return 1 <= Version && 2147483647 >= Version;
6423
        case OMPC_schedule:
6424
          return 1 <= Version && 2147483647 >= Version;
6425
        case OMPC_ordered:
6426
          return 1 <= Version && 2147483647 >= Version;
6427
        case OMPC_collapse:
6428
          return 1 <= Version && 2147483647 >= Version;
6429
        case OMPC_safelen:
6430
          return 1 <= Version && 2147483647 >= Version;
6431
        case OMPC_simdlen:
6432
          return 1 <= Version && 2147483647 >= Version;
6433
        default:
6434
          return false;
6435
      }
6436
      break;
6437
    case OMPD_parallel_for:
6438
      switch (C) {
6439
        case OMPC_if:
6440
          return 1 <= Version && 2147483647 >= Version;
6441
        case OMPC_num_threads:
6442
          return 1 <= Version && 2147483647 >= Version;
6443
        case OMPC_default:
6444
          return 1 <= Version && 2147483647 >= Version;
6445
        case OMPC_proc_bind:
6446
          return 1 <= Version && 2147483647 >= Version;
6447
        case OMPC_private:
6448
          return 1 <= Version && 2147483647 >= Version;
6449
        case OMPC_firstprivate:
6450
          return 1 <= Version && 2147483647 >= Version;
6451
        case OMPC_shared:
6452
          return 1 <= Version && 2147483647 >= Version;
6453
        case OMPC_reduction:
6454
          return 1 <= Version && 2147483647 >= Version;
6455
        case OMPC_copyin:
6456
          return 1 <= Version && 2147483647 >= Version;
6457
        case OMPC_lastprivate:
6458
          return 1 <= Version && 2147483647 >= Version;
6459
        case OMPC_collapse:
6460
          return 1 <= Version && 2147483647 >= Version;
6461
        case OMPC_schedule:
6462
          return 1 <= Version && 2147483647 >= Version;
6463
        case OMPC_ordered:
6464
          return 1 <= Version && 2147483647 >= Version;
6465
        case OMPC_linear:
6466
          return 1 <= Version && 2147483647 >= Version;
6467
        case OMPC_allocate:
6468
          return 1 <= Version && 2147483647 >= Version;
6469
        case OMPC_order:
6470
          return 50 <= Version && 2147483647 >= Version;
6471
        default:
6472
          return false;
6473
      }
6474
      break;
6475
    case OMPD_parallel_for_simd:
6476
      switch (C) {
6477
        case OMPC_if:
6478
          return 1 <= Version && 2147483647 >= Version;
6479
        case OMPC_num_threads:
6480
          return 1 <= Version && 2147483647 >= Version;
6481
        case OMPC_default:
6482
          return 1 <= Version && 2147483647 >= Version;
6483
        case OMPC_proc_bind:
6484
          return 1 <= Version && 2147483647 >= Version;
6485
        case OMPC_private:
6486
          return 1 <= Version && 2147483647 >= Version;
6487
        case OMPC_firstprivate:
6488
          return 1 <= Version && 2147483647 >= Version;
6489
        case OMPC_shared:
6490
          return 1 <= Version && 2147483647 >= Version;
6491
        case OMPC_reduction:
6492
          return 1 <= Version && 2147483647 >= Version;
6493
        case OMPC_copyin:
6494
          return 1 <= Version && 2147483647 >= Version;
6495
        case OMPC_lastprivate:
6496
          return 1 <= Version && 2147483647 >= Version;
6497
        case OMPC_collapse:
6498
          return 1 <= Version && 2147483647 >= Version;
6499
        case OMPC_schedule:
6500
          return 1 <= Version && 2147483647 >= Version;
6501
        case OMPC_safelen:
6502
          return 1 <= Version && 2147483647 >= Version;
6503
        case OMPC_simdlen:
6504
          return 1 <= Version && 2147483647 >= Version;
6505
        case OMPC_linear:
6506
          return 1 <= Version && 2147483647 >= Version;
6507
        case OMPC_aligned:
6508
          return 1 <= Version && 2147483647 >= Version;
6509
        case OMPC_ordered:
6510
          return 1 <= Version && 2147483647 >= Version;
6511
        case OMPC_allocate:
6512
          return 1 <= Version && 2147483647 >= Version;
6513
        case OMPC_nontemporal:
6514
          return 50 <= Version && 2147483647 >= Version;
6515
        case OMPC_order:
6516
          return 50 <= Version && 2147483647 >= Version;
6517
        default:
6518
          return false;
6519
      }
6520
      break;
6521
    case OMPD_parallel_masked:
6522
      switch (C) {
6523
        case OMPC_if:
6524
          return 1 <= Version && 2147483647 >= Version;
6525
        case OMPC_num_threads:
6526
          return 1 <= Version && 2147483647 >= Version;
6527
        case OMPC_default:
6528
          return 1 <= Version && 2147483647 >= Version;
6529
        case OMPC_private:
6530
          return 1 <= Version && 2147483647 >= Version;
6531
        case OMPC_firstprivate:
6532
          return 1 <= Version && 2147483647 >= Version;
6533
        case OMPC_shared:
6534
          return 1 <= Version && 2147483647 >= Version;
6535
        case OMPC_copyin:
6536
          return 1 <= Version && 2147483647 >= Version;
6537
        case OMPC_reduction:
6538
          return 1 <= Version && 2147483647 >= Version;
6539
        case OMPC_proc_bind:
6540
          return 1 <= Version && 2147483647 >= Version;
6541
        case OMPC_allocate:
6542
          return 1 <= Version && 2147483647 >= Version;
6543
        case OMPC_filter:
6544
          return 1 <= Version && 2147483647 >= Version;
6545
        default:
6546
          return false;
6547
      }
6548
      break;
6549
    case OMPD_parallel_masked_taskloop:
6550
      switch (C) {
6551
        case OMPC_if:
6552
          return 1 <= Version && 2147483647 >= Version;
6553
        case OMPC_shared:
6554
          return 1 <= Version && 2147483647 >= Version;
6555
        case OMPC_private:
6556
          return 1 <= Version && 2147483647 >= Version;
6557
        case OMPC_firstprivate:
6558
          return 1 <= Version && 2147483647 >= Version;
6559
        case OMPC_lastprivate:
6560
          return 1 <= Version && 2147483647 >= Version;
6561
        case OMPC_default:
6562
          return 1 <= Version && 2147483647 >= Version;
6563
        case OMPC_collapse:
6564
          return 1 <= Version && 2147483647 >= Version;
6565
        case OMPC_final:
6566
          return 1 <= Version && 2147483647 >= Version;
6567
        case OMPC_untied:
6568
          return 1 <= Version && 2147483647 >= Version;
6569
        case OMPC_mergeable:
6570
          return 1 <= Version && 2147483647 >= Version;
6571
        case OMPC_priority:
6572
          return 1 <= Version && 2147483647 >= Version;
6573
        case OMPC_grainsize:
6574
          return 1 <= Version && 2147483647 >= Version;
6575
        case OMPC_nogroup:
6576
          return 1 <= Version && 2147483647 >= Version;
6577
        case OMPC_num_tasks:
6578
          return 1 <= Version && 2147483647 >= Version;
6579
        case OMPC_reduction:
6580
          return 1 <= Version && 2147483647 >= Version;
6581
        case OMPC_allocate:
6582
          return 1 <= Version && 2147483647 >= Version;
6583
        case OMPC_num_threads:
6584
          return 1 <= Version && 2147483647 >= Version;
6585
        case OMPC_proc_bind:
6586
          return 1 <= Version && 2147483647 >= Version;
6587
        case OMPC_copyin:
6588
          return 1 <= Version && 2147483647 >= Version;
6589
        case OMPC_filter:
6590
          return 1 <= Version && 2147483647 >= Version;
6591
        default:
6592
          return false;
6593
      }
6594
      break;
6595
    case OMPD_parallel_masked_taskloop_simd:
6596
      switch (C) {
6597
        case OMPC_if:
6598
          return 1 <= Version && 2147483647 >= Version;
6599
        case OMPC_shared:
6600
          return 1 <= Version && 2147483647 >= Version;
6601
        case OMPC_private:
6602
          return 1 <= Version && 2147483647 >= Version;
6603
        case OMPC_firstprivate:
6604
          return 1 <= Version && 2147483647 >= Version;
6605
        case OMPC_lastprivate:
6606
          return 1 <= Version && 2147483647 >= Version;
6607
        case OMPC_default:
6608
          return 1 <= Version && 2147483647 >= Version;
6609
        case OMPC_collapse:
6610
          return 1 <= Version && 2147483647 >= Version;
6611
        case OMPC_final:
6612
          return 1 <= Version && 2147483647 >= Version;
6613
        case OMPC_untied:
6614
          return 1 <= Version && 2147483647 >= Version;
6615
        case OMPC_mergeable:
6616
          return 1 <= Version && 2147483647 >= Version;
6617
        case OMPC_priority:
6618
          return 1 <= Version && 2147483647 >= Version;
6619
        case OMPC_grainsize:
6620
          return 1 <= Version && 2147483647 >= Version;
6621
        case OMPC_nogroup:
6622
          return 1 <= Version && 2147483647 >= Version;
6623
        case OMPC_num_tasks:
6624
          return 1 <= Version && 2147483647 >= Version;
6625
        case OMPC_reduction:
6626
          return 1 <= Version && 2147483647 >= Version;
6627
        case OMPC_allocate:
6628
          return 1 <= Version && 2147483647 >= Version;
6629
        case OMPC_num_threads:
6630
          return 1 <= Version && 2147483647 >= Version;
6631
        case OMPC_proc_bind:
6632
          return 1 <= Version && 2147483647 >= Version;
6633
        case OMPC_copyin:
6634
          return 1 <= Version && 2147483647 >= Version;
6635
        case OMPC_linear:
6636
          return 1 <= Version && 2147483647 >= Version;
6637
        case OMPC_aligned:
6638
          return 1 <= Version && 2147483647 >= Version;
6639
        case OMPC_safelen:
6640
          return 1 <= Version && 2147483647 >= Version;
6641
        case OMPC_simdlen:
6642
          return 1 <= Version && 2147483647 >= Version;
6643
        case OMPC_nontemporal:
6644
          return 50 <= Version && 2147483647 >= Version;
6645
        case OMPC_order:
6646
          return 50 <= Version && 2147483647 >= Version;
6647
        case OMPC_filter:
6648
          return 1 <= Version && 2147483647 >= Version;
6649
        default:
6650
          return false;
6651
      }
6652
      break;
6653
    case OMPD_parallel_master:
6654
      switch (C) {
6655
        case OMPC_if:
6656
          return 1 <= Version && 2147483647 >= Version;
6657
        case OMPC_num_threads:
6658
          return 1 <= Version && 2147483647 >= Version;
6659
        case OMPC_default:
6660
          return 1 <= Version && 2147483647 >= Version;
6661
        case OMPC_private:
6662
          return 1 <= Version && 2147483647 >= Version;
6663
        case OMPC_firstprivate:
6664
          return 1 <= Version && 2147483647 >= Version;
6665
        case OMPC_shared:
6666
          return 1 <= Version && 2147483647 >= Version;
6667
        case OMPC_copyin:
6668
          return 1 <= Version && 2147483647 >= Version;
6669
        case OMPC_reduction:
6670
          return 1 <= Version && 2147483647 >= Version;
6671
        case OMPC_proc_bind:
6672
          return 1 <= Version && 2147483647 >= Version;
6673
        case OMPC_allocate:
6674
          return 1 <= Version && 2147483647 >= Version;
6675
        default:
6676
          return false;
6677
      }
6678
      break;
6679
    case OMPD_parallel_master_taskloop:
6680
      switch (C) {
6681
        case OMPC_if:
6682
          return 1 <= Version && 2147483647 >= Version;
6683
        case OMPC_shared:
6684
          return 1 <= Version && 2147483647 >= Version;
6685
        case OMPC_private:
6686
          return 1 <= Version && 2147483647 >= Version;
6687
        case OMPC_firstprivate:
6688
          return 1 <= Version && 2147483647 >= Version;
6689
        case OMPC_lastprivate:
6690
          return 1 <= Version && 2147483647 >= Version;
6691
        case OMPC_default:
6692
          return 1 <= Version && 2147483647 >= Version;
6693
        case OMPC_collapse:
6694
          return 1 <= Version && 2147483647 >= Version;
6695
        case OMPC_final:
6696
          return 1 <= Version && 2147483647 >= Version;
6697
        case OMPC_untied:
6698
          return 1 <= Version && 2147483647 >= Version;
6699
        case OMPC_mergeable:
6700
          return 1 <= Version && 2147483647 >= Version;
6701
        case OMPC_priority:
6702
          return 1 <= Version && 2147483647 >= Version;
6703
        case OMPC_grainsize:
6704
          return 1 <= Version && 2147483647 >= Version;
6705
        case OMPC_nogroup:
6706
          return 1 <= Version && 2147483647 >= Version;
6707
        case OMPC_num_tasks:
6708
          return 1 <= Version && 2147483647 >= Version;
6709
        case OMPC_reduction:
6710
          return 1 <= Version && 2147483647 >= Version;
6711
        case OMPC_allocate:
6712
          return 1 <= Version && 2147483647 >= Version;
6713
        case OMPC_num_threads:
6714
          return 1 <= Version && 2147483647 >= Version;
6715
        case OMPC_proc_bind:
6716
          return 1 <= Version && 2147483647 >= Version;
6717
        case OMPC_copyin:
6718
          return 1 <= Version && 2147483647 >= Version;
6719
        default:
6720
          return false;
6721
      }
6722
      break;
6723
    case OMPD_parallel_master_taskloop_simd:
6724
      switch (C) {
6725
        case OMPC_if:
6726
          return 1 <= Version && 2147483647 >= Version;
6727
        case OMPC_shared:
6728
          return 1 <= Version && 2147483647 >= Version;
6729
        case OMPC_private:
6730
          return 1 <= Version && 2147483647 >= Version;
6731
        case OMPC_firstprivate:
6732
          return 1 <= Version && 2147483647 >= Version;
6733
        case OMPC_lastprivate:
6734
          return 1 <= Version && 2147483647 >= Version;
6735
        case OMPC_default:
6736
          return 1 <= Version && 2147483647 >= Version;
6737
        case OMPC_collapse:
6738
          return 1 <= Version && 2147483647 >= Version;
6739
        case OMPC_final:
6740
          return 1 <= Version && 2147483647 >= Version;
6741
        case OMPC_untied:
6742
          return 1 <= Version && 2147483647 >= Version;
6743
        case OMPC_mergeable:
6744
          return 1 <= Version && 2147483647 >= Version;
6745
        case OMPC_priority:
6746
          return 1 <= Version && 2147483647 >= Version;
6747
        case OMPC_grainsize:
6748
          return 1 <= Version && 2147483647 >= Version;
6749
        case OMPC_nogroup:
6750
          return 1 <= Version && 2147483647 >= Version;
6751
        case OMPC_num_tasks:
6752
          return 1 <= Version && 2147483647 >= Version;
6753
        case OMPC_reduction:
6754
          return 1 <= Version && 2147483647 >= Version;
6755
        case OMPC_allocate:
6756
          return 1 <= Version && 2147483647 >= Version;
6757
        case OMPC_num_threads:
6758
          return 1 <= Version && 2147483647 >= Version;
6759
        case OMPC_proc_bind:
6760
          return 1 <= Version && 2147483647 >= Version;
6761
        case OMPC_copyin:
6762
          return 1 <= Version && 2147483647 >= Version;
6763
        case OMPC_linear:
6764
          return 1 <= Version && 2147483647 >= Version;
6765
        case OMPC_aligned:
6766
          return 1 <= Version && 2147483647 >= Version;
6767
        case OMPC_safelen:
6768
          return 1 <= Version && 2147483647 >= Version;
6769
        case OMPC_simdlen:
6770
          return 1 <= Version && 2147483647 >= Version;
6771
        case OMPC_nontemporal:
6772
          return 50 <= Version && 2147483647 >= Version;
6773
        case OMPC_order:
6774
          return 50 <= Version && 2147483647 >= Version;
6775
        default:
6776
          return false;
6777
      }
6778
      break;
6779
    case OMPD_parallel_sections:
6780
      switch (C) {
6781
        case OMPC_if:
6782
          return 1 <= Version && 2147483647 >= Version;
6783
        case OMPC_default:
6784
          return 1 <= Version && 2147483647 >= Version;
6785
        case OMPC_proc_bind:
6786
          return 1 <= Version && 2147483647 >= Version;
6787
        case OMPC_private:
6788
          return 1 <= Version && 2147483647 >= Version;
6789
        case OMPC_firstprivate:
6790
          return 1 <= Version && 2147483647 >= Version;
6791
        case OMPC_shared:
6792
          return 1 <= Version && 2147483647 >= Version;
6793
        case OMPC_reduction:
6794
          return 1 <= Version && 2147483647 >= Version;
6795
        case OMPC_copyin:
6796
          return 1 <= Version && 2147483647 >= Version;
6797
        case OMPC_lastprivate:
6798
          return 1 <= Version && 2147483647 >= Version;
6799
        case OMPC_allocate:
6800
          return 1 <= Version && 2147483647 >= Version;
6801
        case OMPC_num_threads:
6802
          return 1 <= Version && 2147483647 >= Version;
6803
        default:
6804
          return false;
6805
      }
6806
      break;
6807
    case OMPD_parallel_workshare:
6808
      switch (C) {
6809
        case OMPC_allocate:
6810
          return 1 <= Version && 2147483647 >= Version;
6811
        case OMPC_copyin:
6812
          return 1 <= Version && 2147483647 >= Version;
6813
        case OMPC_default:
6814
          return 1 <= Version && 2147483647 >= Version;
6815
        case OMPC_firstprivate:
6816
          return 1 <= Version && 2147483647 >= Version;
6817
        case OMPC_private:
6818
          return 1 <= Version && 2147483647 >= Version;
6819
        case OMPC_reduction:
6820
          return 1 <= Version && 2147483647 >= Version;
6821
        case OMPC_shared:
6822
          return 1 <= Version && 2147483647 >= Version;
6823
        case OMPC_if:
6824
          return 1 <= Version && 2147483647 >= Version;
6825
        case OMPC_num_threads:
6826
          return 1 <= Version && 2147483647 >= Version;
6827
        case OMPC_proc_bind:
6828
          return 1 <= Version && 2147483647 >= Version;
6829
        default:
6830
          return false;
6831
      }
6832
      break;
6833
    case OMPD_requires:
6834
      switch (C) {
6835
        case OMPC_unified_address:
6836
          return 1 <= Version && 2147483647 >= Version;
6837
        case OMPC_unified_shared_memory:
6838
          return 1 <= Version && 2147483647 >= Version;
6839
        case OMPC_reverse_offload:
6840
          return 99 <= Version && 2147483647 >= Version;
6841
        case OMPC_dynamic_allocators:
6842
          return 1 <= Version && 2147483647 >= Version;
6843
        case OMPC_atomic_default_mem_order:
6844
          return 1 <= Version && 2147483647 >= Version;
6845
        default:
6846
          return false;
6847
      }
6848
      break;
6849
    case OMPD_scan:
6850
      switch (C) {
6851
        case OMPC_inclusive:
6852
          return 50 <= Version && 2147483647 >= Version;
6853
        case OMPC_exclusive:
6854
          return 50 <= Version && 2147483647 >= Version;
6855
        default:
6856
          return false;
6857
      }
6858
      break;
6859
    case OMPD_section:
6860
      return false;
6861
      break;
6862
    case OMPD_sections:
6863
      switch (C) {
6864
        case OMPC_private:
6865
          return 1 <= Version && 2147483647 >= Version;
6866
        case OMPC_lastprivate:
6867
          return 1 <= Version && 2147483647 >= Version;
6868
        case OMPC_firstprivate:
6869
          return 1 <= Version && 2147483647 >= Version;
6870
        case OMPC_reduction:
6871
          return 1 <= Version && 2147483647 >= Version;
6872
        case OMPC_nowait:
6873
          return 1 <= Version && 2147483647 >= Version;
6874
        case OMPC_allocate:
6875
          return 1 <= Version && 2147483647 >= Version;
6876
        default:
6877
          return false;
6878
      }
6879
      break;
6880
    case OMPD_simd:
6881
      switch (C) {
6882
        case OMPC_private:
6883
          return 1 <= Version && 2147483647 >= Version;
6884
        case OMPC_lastprivate:
6885
          return 1 <= Version && 2147483647 >= Version;
6886
        case OMPC_linear:
6887
          return 1 <= Version && 2147483647 >= Version;
6888
        case OMPC_aligned:
6889
          return 1 <= Version && 2147483647 >= Version;
6890
        case OMPC_reduction:
6891
          return 1 <= Version && 2147483647 >= Version;
6892
        case OMPC_allocate:
6893
          return 1 <= Version && 2147483647 >= Version;
6894
        case OMPC_nontemporal:
6895
          return 50 <= Version && 2147483647 >= Version;
6896
        case OMPC_order:
6897
          return 50 <= Version && 2147483647 >= Version;
6898
        case OMPC_collapse:
6899
          return 1 <= Version && 2147483647 >= Version;
6900
        case OMPC_safelen:
6901
          return 1 <= Version && 2147483647 >= Version;
6902
        case OMPC_simdlen:
6903
          return 1 <= Version && 2147483647 >= Version;
6904
        case OMPC_if:
6905
          return 50 <= Version && 2147483647 >= Version;
6906
        default:
6907
          return false;
6908
      }
6909
      break;
6910
    case OMPD_single:
6911
      switch (C) {
6912
        case OMPC_private:
6913
          return 1 <= Version && 2147483647 >= Version;
6914
        case OMPC_firstprivate:
6915
          return 1 <= Version && 2147483647 >= Version;
6916
        case OMPC_copyprivate:
6917
          return 1 <= Version && 2147483647 >= Version;
6918
        case OMPC_nowait:
6919
          return 1 <= Version && 2147483647 >= Version;
6920
        case OMPC_allocate:
6921
          return 1 <= Version && 2147483647 >= Version;
6922
        default:
6923
          return false;
6924
      }
6925
      break;
6926
    case OMPD_target:
6927
      switch (C) {
6928
        case OMPC_if:
6929
          return 1 <= Version && 2147483647 >= Version;
6930
        case OMPC_map:
6931
          return 1 <= Version && 2147483647 >= Version;
6932
        case OMPC_private:
6933
          return 1 <= Version && 2147483647 >= Version;
6934
        case OMPC_depend:
6935
          return 1 <= Version && 2147483647 >= Version;
6936
        case OMPC_firstprivate:
6937
          return 1 <= Version && 2147483647 >= Version;
6938
        case OMPC_is_device_ptr:
6939
          return 1 <= Version && 2147483647 >= Version;
6940
        case OMPC_has_device_addr:
6941
          return 51 <= Version && 2147483647 >= Version;
6942
        case OMPC_reduction:
6943
          return 1 <= Version && 2147483647 >= Version;
6944
        case OMPC_in_reduction:
6945
          return 50 <= Version && 2147483647 >= Version;
6946
        case OMPC_allocate:
6947
          return 1 <= Version && 2147483647 >= Version;
6948
        case OMPC_uses_allocators:
6949
          return 50 <= Version && 2147483647 >= Version;
6950
        case OMPC_device:
6951
          return 1 <= Version && 2147483647 >= Version;
6952
        case OMPC_thread_limit:
6953
          return 51 <= Version && 2147483647 >= Version;
6954
        case OMPC_defaultmap:
6955
          return 1 <= Version && 2147483647 >= Version;
6956
        case OMPC_nowait:
6957
          return 1 <= Version && 2147483647 >= Version;
6958
        case OMPC_ompx_dyn_cgroup_mem:
6959
          return 1 <= Version && 2147483647 >= Version;
6960
        default:
6961
          return false;
6962
      }
6963
      break;
6964
    case OMPD_target_data:
6965
      switch (C) {
6966
        case OMPC_use_device_ptr:
6967
          return 1 <= Version && 2147483647 >= Version;
6968
        case OMPC_use_device_addr:
6969
          return 50 <= Version && 2147483647 >= Version;
6970
        case OMPC_device:
6971
          return 1 <= Version && 2147483647 >= Version;
6972
        case OMPC_if:
6973
          return 1 <= Version && 2147483647 >= Version;
6974
        case OMPC_map:
6975
          return 1 <= Version && 2147483647 >= Version;
6976
        default:
6977
          return false;
6978
      }
6979
      break;
6980
    case OMPD_target_enter_data:
6981
      switch (C) {
6982
        case OMPC_depend:
6983
          return 1 <= Version && 2147483647 >= Version;
6984
        case OMPC_if:
6985
          return 1 <= Version && 2147483647 >= Version;
6986
        case OMPC_device:
6987
          return 1 <= Version && 2147483647 >= Version;
6988
        case OMPC_nowait:
6989
          return 1 <= Version && 2147483647 >= Version;
6990
        case OMPC_map:
6991
          return 1 <= Version && 2147483647 >= Version;
6992
        default:
6993
          return false;
6994
      }
6995
      break;
6996
    case OMPD_target_exit_data:
6997
      switch (C) {
6998
        case OMPC_depend:
6999
          return 1 <= Version && 2147483647 >= Version;
7000
        case OMPC_device:
7001
          return 1 <= Version && 2147483647 >= Version;
7002
        case OMPC_if:
7003
          return 1 <= Version && 2147483647 >= Version;
7004
        case OMPC_nowait:
7005
          return 1 <= Version && 2147483647 >= Version;
7006
        case OMPC_map:
7007
          return 1 <= Version && 2147483647 >= Version;
7008
        default:
7009
          return false;
7010
      }
7011
      break;
7012
    case OMPD_target_parallel:
7013
      switch (C) {
7014
        case OMPC_map:
7015
          return 1 <= Version && 2147483647 >= Version;
7016
        case OMPC_nowait:
7017
          return 1 <= Version && 2147483647 >= Version;
7018
        case OMPC_depend:
7019
          return 1 <= Version && 2147483647 >= Version;
7020
        case OMPC_private:
7021
          return 1 <= Version && 2147483647 >= Version;
7022
        case OMPC_firstprivate:
7023
          return 1 <= Version && 2147483647 >= Version;
7024
        case OMPC_default:
7025
          return 1 <= Version && 2147483647 >= Version;
7026
        case OMPC_shared:
7027
          return 1 <= Version && 2147483647 >= Version;
7028
        case OMPC_reduction:
7029
          return 1 <= Version && 2147483647 >= Version;
7030
        case OMPC_is_device_ptr:
7031
          return 1 <= Version && 2147483647 >= Version;
7032
        case OMPC_has_device_addr:
7033
          return 51 <= Version && 2147483647 >= Version;
7034
        case OMPC_allocate:
7035
          return 1 <= Version && 2147483647 >= Version;
7036
        case OMPC_uses_allocators:
7037
          return 50 <= Version && 2147483647 >= Version;
7038
        case OMPC_defaultmap:
7039
          return 1 <= Version && 2147483647 >= Version;
7040
        case OMPC_device:
7041
          return 1 <= Version && 2147483647 >= Version;
7042
        case OMPC_if:
7043
          return 1 <= Version && 2147483647 >= Version;
7044
        case OMPC_num_threads:
7045
          return 1 <= Version && 2147483647 >= Version;
7046
        case OMPC_proc_bind:
7047
          return 1 <= Version && 2147483647 >= Version;
7048
        case OMPC_ompx_dyn_cgroup_mem:
7049
          return 1 <= Version && 2147483647 >= Version;
7050
        default:
7051
          return false;
7052
      }
7053
      break;
7054
    case OMPD_target_parallel_do:
7055
      switch (C) {
7056
        case OMPC_map:
7057
          return 1 <= Version && 2147483647 >= Version;
7058
        case OMPC_private:
7059
          return 1 <= Version && 2147483647 >= Version;
7060
        case OMPC_firstprivate:
7061
          return 1 <= Version && 2147483647 >= Version;
7062
        case OMPC_lastprivate:
7063
          return 1 <= Version && 2147483647 >= Version;
7064
        case OMPC_depend:
7065
          return 1 <= Version && 2147483647 >= Version;
7066
        case OMPC_shared:
7067
          return 1 <= Version && 2147483647 >= Version;
7068
        case OMPC_reduction:
7069
          return 1 <= Version && 2147483647 >= Version;
7070
        case OMPC_linear:
7071
          return 1 <= Version && 2147483647 >= Version;
7072
        case OMPC_is_device_ptr:
7073
          return 1 <= Version && 2147483647 >= Version;
7074
        case OMPC_has_device_addr:
7075
          return 51 <= Version && 2147483647 >= Version;
7076
        case OMPC_allocator:
7077
          return 1 <= Version && 2147483647 >= Version;
7078
        case OMPC_order:
7079
          return 1 <= Version && 2147483647 >= Version;
7080
        case OMPC_uses_allocators:
7081
          return 1 <= Version && 2147483647 >= Version;
7082
        case OMPC_default:
7083
          return 1 <= Version && 2147483647 >= Version;
7084
        case OMPC_copyin:
7085
          return 1 <= Version && 2147483647 >= Version;
7086
        case OMPC_if:
7087
          return 1 <= Version && 2147483647 >= Version;
7088
        case OMPC_num_threads:
7089
          return 1 <= Version && 2147483647 >= Version;
7090
        case OMPC_proc_bind:
7091
          return 1 <= Version && 2147483647 >= Version;
7092
        case OMPC_device:
7093
          return 1 <= Version && 2147483647 >= Version;
7094
        case OMPC_defaultmap:
7095
          return 1 <= Version && 2147483647 >= Version;
7096
        case OMPC_schedule:
7097
          return 1 <= Version && 2147483647 >= Version;
7098
        case OMPC_collapse:
7099
          return 1 <= Version && 2147483647 >= Version;
7100
        case OMPC_ordered:
7101
          return 1 <= Version && 2147483647 >= Version;
7102
        case OMPC_nowait:
7103
          return 1 <= Version && 2147483647 >= Version;
7104
        default:
7105
          return false;
7106
      }
7107
      break;
7108
    case OMPD_target_parallel_do_simd:
7109
      switch (C) {
7110
        case OMPC_if:
7111
          return 1 <= Version && 2147483647 >= Version;
7112
        case OMPC_device:
7113
          return 1 <= Version && 2147483647 >= Version;
7114
        case OMPC_map:
7115
          return 1 <= Version && 2147483647 >= Version;
7116
        case OMPC_private:
7117
          return 1 <= Version && 2147483647 >= Version;
7118
        case OMPC_firstprivate:
7119
          return 1 <= Version && 2147483647 >= Version;
7120
        case OMPC_lastprivate:
7121
          return 1 <= Version && 2147483647 >= Version;
7122
        case OMPC_nowait:
7123
          return 1 <= Version && 2147483647 >= Version;
7124
        case OMPC_depend:
7125
          return 1 <= Version && 2147483647 >= Version;
7126
        case OMPC_defaultmap:
7127
          return 1 <= Version && 2147483647 >= Version;
7128
        case OMPC_num_threads:
7129
          return 1 <= Version && 2147483647 >= Version;
7130
        case OMPC_default:
7131
          return 1 <= Version && 2147483647 >= Version;
7132
        case OMPC_proc_bind:
7133
          return 1 <= Version && 2147483647 >= Version;
7134
        case OMPC_shared:
7135
          return 1 <= Version && 2147483647 >= Version;
7136
        case OMPC_reduction:
7137
          return 1 <= Version && 2147483647 >= Version;
7138
        case OMPC_collapse:
7139
          return 1 <= Version && 2147483647 >= Version;
7140
        case OMPC_schedule:
7141
          return 1 <= Version && 2147483647 >= Version;
7142
        case OMPC_ordered:
7143
          return 1 <= Version && 2147483647 >= Version;
7144
        case OMPC_linear:
7145
          return 1 <= Version && 2147483647 >= Version;
7146
        case OMPC_safelen:
7147
          return 1 <= Version && 2147483647 >= Version;
7148
        case OMPC_simdlen:
7149
          return 1 <= Version && 2147483647 >= Version;
7150
        case OMPC_aligned:
7151
          return 1 <= Version && 2147483647 >= Version;
7152
        case OMPC_is_device_ptr:
7153
          return 1 <= Version && 2147483647 >= Version;
7154
        case OMPC_has_device_addr:
7155
          return 51 <= Version && 2147483647 >= Version;
7156
        case OMPC_allocate:
7157
          return 1 <= Version && 2147483647 >= Version;
7158
        case OMPC_nontemporal:
7159
          return 1 <= Version && 2147483647 >= Version;
7160
        case OMPC_order:
7161
          return 1 <= Version && 2147483647 >= Version;
7162
        case OMPC_uses_allocators:
7163
          return 1 <= Version && 2147483647 >= Version;
7164
        default:
7165
          return false;
7166
      }
7167
      break;
7168
    case OMPD_target_parallel_for:
7169
      switch (C) {
7170
        case OMPC_if:
7171
          return 1 <= Version && 2147483647 >= Version;
7172
        case OMPC_device:
7173
          return 1 <= Version && 2147483647 >= Version;
7174
        case OMPC_map:
7175
          return 1 <= Version && 2147483647 >= Version;
7176
        case OMPC_private:
7177
          return 1 <= Version && 2147483647 >= Version;
7178
        case OMPC_firstprivate:
7179
          return 1 <= Version && 2147483647 >= Version;
7180
        case OMPC_lastprivate:
7181
          return 1 <= Version && 2147483647 >= Version;
7182
        case OMPC_nowait:
7183
          return 1 <= Version && 2147483647 >= Version;
7184
        case OMPC_depend:
7185
          return 1 <= Version && 2147483647 >= Version;
7186
        case OMPC_defaultmap:
7187
          return 1 <= Version && 2147483647 >= Version;
7188
        case OMPC_num_threads:
7189
          return 1 <= Version && 2147483647 >= Version;
7190
        case OMPC_default:
7191
          return 1 <= Version && 2147483647 >= Version;
7192
        case OMPC_proc_bind:
7193
          return 1 <= Version && 2147483647 >= Version;
7194
        case OMPC_shared:
7195
          return 1 <= Version && 2147483647 >= Version;
7196
        case OMPC_reduction:
7197
          return 1 <= Version && 2147483647 >= Version;
7198
        case OMPC_collapse:
7199
          return 1 <= Version && 2147483647 >= Version;
7200
        case OMPC_schedule:
7201
          return 1 <= Version && 2147483647 >= Version;
7202
        case OMPC_ordered:
7203
          return 1 <= Version && 2147483647 >= Version;
7204
        case OMPC_linear:
7205
          return 1 <= Version && 2147483647 >= Version;
7206
        case OMPC_is_device_ptr:
7207
          return 1 <= Version && 2147483647 >= Version;
7208
        case OMPC_has_device_addr:
7209
          return 51 <= Version && 2147483647 >= Version;
7210
        case OMPC_allocate:
7211
          return 1 <= Version && 2147483647 >= Version;
7212
        case OMPC_order:
7213
          return 50 <= Version && 2147483647 >= Version;
7214
        case OMPC_uses_allocators:
7215
          return 50 <= Version && 2147483647 >= Version;
7216
        case OMPC_ompx_dyn_cgroup_mem:
7217
          return 1 <= Version && 2147483647 >= Version;
7218
        default:
7219
          return false;
7220
      }
7221
      break;
7222
    case OMPD_target_parallel_for_simd:
7223
      switch (C) {
7224
        case OMPC_if:
7225
          return 1 <= Version && 2147483647 >= Version;
7226
        case OMPC_device:
7227
          return 1 <= Version && 2147483647 >= Version;
7228
        case OMPC_map:
7229
          return 1 <= Version && 2147483647 >= Version;
7230
        case OMPC_private:
7231
          return 1 <= Version && 2147483647 >= Version;
7232
        case OMPC_firstprivate:
7233
          return 1 <= Version && 2147483647 >= Version;
7234
        case OMPC_lastprivate:
7235
          return 1 <= Version && 2147483647 >= Version;
7236
        case OMPC_nowait:
7237
          return 1 <= Version && 2147483647 >= Version;
7238
        case OMPC_depend:
7239
          return 1 <= Version && 2147483647 >= Version;
7240
        case OMPC_defaultmap:
7241
          return 1 <= Version && 2147483647 >= Version;
7242
        case OMPC_num_threads:
7243
          return 1 <= Version && 2147483647 >= Version;
7244
        case OMPC_default:
7245
          return 1 <= Version && 2147483647 >= Version;
7246
        case OMPC_proc_bind:
7247
          return 1 <= Version && 2147483647 >= Version;
7248
        case OMPC_shared:
7249
          return 1 <= Version && 2147483647 >= Version;
7250
        case OMPC_reduction:
7251
          return 1 <= Version && 2147483647 >= Version;
7252
        case OMPC_collapse:
7253
          return 1 <= Version && 2147483647 >= Version;
7254
        case OMPC_schedule:
7255
          return 1 <= Version && 2147483647 >= Version;
7256
        case OMPC_ordered:
7257
          return 1 <= Version && 2147483647 >= Version;
7258
        case OMPC_linear:
7259
          return 1 <= Version && 2147483647 >= Version;
7260
        case OMPC_safelen:
7261
          return 1 <= Version && 2147483647 >= Version;
7262
        case OMPC_simdlen:
7263
          return 1 <= Version && 2147483647 >= Version;
7264
        case OMPC_aligned:
7265
          return 1 <= Version && 2147483647 >= Version;
7266
        case OMPC_is_device_ptr:
7267
          return 1 <= Version && 2147483647 >= Version;
7268
        case OMPC_has_device_addr:
7269
          return 51 <= Version && 2147483647 >= Version;
7270
        case OMPC_allocate:
7271
          return 1 <= Version && 2147483647 >= Version;
7272
        case OMPC_nontemporal:
7273
          return 50 <= Version && 2147483647 >= Version;
7274
        case OMPC_order:
7275
          return 50 <= Version && 2147483647 >= Version;
7276
        case OMPC_uses_allocators:
7277
          return 50 <= Version && 2147483647 >= Version;
7278
        case OMPC_ompx_dyn_cgroup_mem:
7279
          return 1 <= Version && 2147483647 >= Version;
7280
        default:
7281
          return false;
7282
      }
7283
      break;
7284
    case OMPD_target_simd:
7285
      switch (C) {
7286
        case OMPC_aligned:
7287
          return 1 <= Version && 2147483647 >= Version;
7288
        case OMPC_allocate:
7289
          return 1 <= Version && 2147483647 >= Version;
7290
        case OMPC_depend:
7291
          return 1 <= Version && 2147483647 >= Version;
7292
        case OMPC_firstprivate:
7293
          return 1 <= Version && 2147483647 >= Version;
7294
        case OMPC_is_device_ptr:
7295
          return 1 <= Version && 2147483647 >= Version;
7296
        case OMPC_has_device_addr:
7297
          return 51 <= Version && 2147483647 >= Version;
7298
        case OMPC_lastprivate:
7299
          return 1 <= Version && 2147483647 >= Version;
7300
        case OMPC_linear:
7301
          return 1 <= Version && 2147483647 >= Version;
7302
        case OMPC_map:
7303
          return 1 <= Version && 2147483647 >= Version;
7304
        case OMPC_nontemporal:
7305
          return 50 <= Version && 2147483647 >= Version;
7306
        case OMPC_nowait:
7307
          return 1 <= Version && 2147483647 >= Version;
7308
        case OMPC_order:
7309
          return 50 <= Version && 2147483647 >= Version;
7310
        case OMPC_private:
7311
          return 1 <= Version && 2147483647 >= Version;
7312
        case OMPC_reduction:
7313
          return 1 <= Version && 2147483647 >= Version;
7314
        case OMPC_shared:
7315
          return 1 <= Version && 2147483647 >= Version;
7316
        case OMPC_uses_allocators:
7317
          return 50 <= Version && 2147483647 >= Version;
7318
        case OMPC_collapse:
7319
          return 1 <= Version && 2147483647 >= Version;
7320
        case OMPC_safelen:
7321
          return 1 <= Version && 2147483647 >= Version;
7322
        case OMPC_simdlen:
7323
          return 1 <= Version && 2147483647 >= Version;
7324
        case OMPC_if:
7325
          return 1 <= Version && 2147483647 >= Version;
7326
        case OMPC_num_threads:
7327
          return 1 <= Version && 2147483647 >= Version;
7328
        case OMPC_proc_bind:
7329
          return 1 <= Version && 2147483647 >= Version;
7330
        case OMPC_device:
7331
          return 1 <= Version && 2147483647 >= Version;
7332
        case OMPC_defaultmap:
7333
          return 1 <= Version && 2147483647 >= Version;
7334
        case OMPC_schedule:
7335
          return 1 <= Version && 2147483647 >= Version;
7336
        case OMPC_ompx_dyn_cgroup_mem:
7337
          return 1 <= Version && 2147483647 >= Version;
7338
        default:
7339
          return false;
7340
      }
7341
      break;
7342
    case OMPD_target_teams:
7343
      switch (C) {
7344
        case OMPC_if:
7345
          return 1 <= Version && 2147483647 >= Version;
7346
        case OMPC_map:
7347
          return 1 <= Version && 2147483647 >= Version;
7348
        case OMPC_private:
7349
          return 1 <= Version && 2147483647 >= Version;
7350
        case OMPC_depend:
7351
          return 1 <= Version && 2147483647 >= Version;
7352
        case OMPC_firstprivate:
7353
          return 1 <= Version && 2147483647 >= Version;
7354
        case OMPC_is_device_ptr:
7355
          return 1 <= Version && 2147483647 >= Version;
7356
        case OMPC_has_device_addr:
7357
          return 51 <= Version && 2147483647 >= Version;
7358
        case OMPC_reduction:
7359
          return 1 <= Version && 2147483647 >= Version;
7360
        case OMPC_allocate:
7361
          return 1 <= Version && 2147483647 >= Version;
7362
        case OMPC_uses_allocators:
7363
          return 50 <= Version && 2147483647 >= Version;
7364
        case OMPC_shared:
7365
          return 1 <= Version && 2147483647 >= Version;
7366
        case OMPC_device:
7367
          return 1 <= Version && 2147483647 >= Version;
7368
        case OMPC_nowait:
7369
          return 1 <= Version && 2147483647 >= Version;
7370
        case OMPC_defaultmap:
7371
          return 1 <= Version && 2147483647 >= Version;
7372
        case OMPC_default:
7373
          return 1 <= Version && 2147483647 >= Version;
7374
        case OMPC_num_teams:
7375
          return 1 <= Version && 2147483647 >= Version;
7376
        case OMPC_thread_limit:
7377
          return 1 <= Version && 2147483647 >= Version;
7378
        case OMPC_ompx_dyn_cgroup_mem:
7379
          return 1 <= Version && 2147483647 >= Version;
7380
        default:
7381
          return false;
7382
      }
7383
      break;
7384
    case OMPD_target_teams_distribute:
7385
      switch (C) {
7386
        case OMPC_if:
7387
          return 1 <= Version && 2147483647 >= Version;
7388
        case OMPC_map:
7389
          return 1 <= Version && 2147483647 >= Version;
7390
        case OMPC_private:
7391
          return 1 <= Version && 2147483647 >= Version;
7392
        case OMPC_depend:
7393
          return 1 <= Version && 2147483647 >= Version;
7394
        case OMPC_firstprivate:
7395
          return 1 <= Version && 2147483647 >= Version;
7396
        case OMPC_is_device_ptr:
7397
          return 1 <= Version && 2147483647 >= Version;
7398
        case OMPC_has_device_addr:
7399
          return 51 <= Version && 2147483647 >= Version;
7400
        case OMPC_reduction:
7401
          return 1 <= Version && 2147483647 >= Version;
7402
        case OMPC_allocate:
7403
          return 1 <= Version && 2147483647 >= Version;
7404
        case OMPC_uses_allocators:
7405
          return 50 <= Version && 2147483647 >= Version;
7406
        case OMPC_shared:
7407
          return 1 <= Version && 2147483647 >= Version;
7408
        case OMPC_lastprivate:
7409
          return 1 <= Version && 2147483647 >= Version;
7410
        case OMPC_device:
7411
          return 1 <= Version && 2147483647 >= Version;
7412
        case OMPC_nowait:
7413
          return 1 <= Version && 2147483647 >= Version;
7414
        case OMPC_defaultmap:
7415
          return 1 <= Version && 2147483647 >= Version;
7416
        case OMPC_default:
7417
          return 1 <= Version && 2147483647 >= Version;
7418
        case OMPC_num_teams:
7419
          return 1 <= Version && 2147483647 >= Version;
7420
        case OMPC_thread_limit:
7421
          return 1 <= Version && 2147483647 >= Version;
7422
        case OMPC_collapse:
7423
          return 1 <= Version && 2147483647 >= Version;
7424
        case OMPC_dist_schedule:
7425
          return 1 <= Version && 2147483647 >= Version;
7426
        case OMPC_ompx_dyn_cgroup_mem:
7427
          return 1 <= Version && 2147483647 >= Version;
7428
        default:
7429
          return false;
7430
      }
7431
      break;
7432
    case OMPD_target_teams_distribute_parallel_do:
7433
      switch (C) {
7434
        case OMPC_if:
7435
          return 1 <= Version && 2147483647 >= Version;
7436
        case OMPC_map:
7437
          return 1 <= Version && 2147483647 >= Version;
7438
        case OMPC_private:
7439
          return 1 <= Version && 2147483647 >= Version;
7440
        case OMPC_depend:
7441
          return 1 <= Version && 2147483647 >= Version;
7442
        case OMPC_firstprivate:
7443
          return 1 <= Version && 2147483647 >= Version;
7444
        case OMPC_is_device_ptr:
7445
          return 1 <= Version && 2147483647 >= Version;
7446
        case OMPC_has_device_addr:
7447
          return 51 <= Version && 2147483647 >= Version;
7448
        case OMPC_reduction:
7449
          return 1 <= Version && 2147483647 >= Version;
7450
        case OMPC_allocate:
7451
          return 1 <= Version && 2147483647 >= Version;
7452
        case OMPC_uses_allocators:
7453
          return 1 <= Version && 2147483647 >= Version;
7454
        case OMPC_shared:
7455
          return 1 <= Version && 2147483647 >= Version;
7456
        case OMPC_lastprivate:
7457
          return 1 <= Version && 2147483647 >= Version;
7458
        case OMPC_copyin:
7459
          return 1 <= Version && 2147483647 >= Version;
7460
        case OMPC_linear:
7461
          return 1 <= Version && 2147483647 >= Version;
7462
        case OMPC_ordered:
7463
          return 1 <= Version && 2147483647 >= Version;
7464
        case OMPC_order:
7465
          return 1 <= Version && 2147483647 >= Version;
7466
        case OMPC_device:
7467
          return 1 <= Version && 2147483647 >= Version;
7468
        case OMPC_defaultmap:
7469
          return 1 <= Version && 2147483647 >= Version;
7470
        case OMPC_nowait:
7471
          return 1 <= Version && 2147483647 >= Version;
7472
        case OMPC_default:
7473
          return 1 <= Version && 2147483647 >= Version;
7474
        case OMPC_num_teams:
7475
          return 1 <= Version && 2147483647 >= Version;
7476
        case OMPC_thread_limit:
7477
          return 1 <= Version && 2147483647 >= Version;
7478
        case OMPC_collapse:
7479
          return 1 <= Version && 2147483647 >= Version;
7480
        case OMPC_dist_schedule:
7481
          return 1 <= Version && 2147483647 >= Version;
7482
        case OMPC_num_threads:
7483
          return 1 <= Version && 2147483647 >= Version;
7484
        case OMPC_proc_bind:
7485
          return 1 <= Version && 2147483647 >= Version;
7486
        case OMPC_schedule:
7487
          return 1 <= Version && 2147483647 >= Version;
7488
        default:
7489
          return false;
7490
      }
7491
      break;
7492
    case OMPD_target_teams_distribute_parallel_do_simd:
7493
      switch (C) {
7494
        case OMPC_map:
7495
          return 1 <= Version && 2147483647 >= Version;
7496
        case OMPC_private:
7497
          return 1 <= Version && 2147483647 >= Version;
7498
        case OMPC_depend:
7499
          return 1 <= Version && 2147483647 >= Version;
7500
        case OMPC_firstprivate:
7501
          return 1 <= Version && 2147483647 >= Version;
7502
        case OMPC_is_device_ptr:
7503
          return 1 <= Version && 2147483647 >= Version;
7504
        case OMPC_has_device_addr:
7505
          return 51 <= Version && 2147483647 >= Version;
7506
        case OMPC_reduction:
7507
          return 1 <= Version && 2147483647 >= Version;
7508
        case OMPC_allocate:
7509
          return 1 <= Version && 2147483647 >= Version;
7510
        case OMPC_uses_allocators:
7511
          return 1 <= Version && 2147483647 >= Version;
7512
        case OMPC_shared:
7513
          return 1 <= Version && 2147483647 >= Version;
7514
        case OMPC_lastprivate:
7515
          return 1 <= Version && 2147483647 >= Version;
7516
        case OMPC_copyin:
7517
          return 1 <= Version && 2147483647 >= Version;
7518
        case OMPC_linear:
7519
          return 1 <= Version && 2147483647 >= Version;
7520
        case OMPC_ordered:
7521
          return 1 <= Version && 2147483647 >= Version;
7522
        case OMPC_order:
7523
          return 1 <= Version && 2147483647 >= Version;
7524
        case OMPC_aligned:
7525
          return 1 <= Version && 2147483647 >= Version;
7526
        case OMPC_nontemporal:
7527
          return 1 <= Version && 2147483647 >= Version;
7528
        case OMPC_if:
7529
          return 1 <= Version && 2147483647 >= Version;
7530
        case OMPC_device:
7531
          return 1 <= Version && 2147483647 >= Version;
7532
        case OMPC_nowait:
7533
          return 1 <= Version && 2147483647 >= Version;
7534
        case OMPC_defaultmap:
7535
          return 1 <= Version && 2147483647 >= Version;
7536
        case OMPC_default:
7537
          return 1 <= Version && 2147483647 >= Version;
7538
        case OMPC_num_teams:
7539
          return 1 <= Version && 2147483647 >= Version;
7540
        case OMPC_thread_limit:
7541
          return 1 <= Version && 2147483647 >= Version;
7542
        case OMPC_collapse:
7543
          return 1 <= Version && 2147483647 >= Version;
7544
        case OMPC_dist_schedule:
7545
          return 1 <= Version && 2147483647 >= Version;
7546
        case OMPC_num_threads:
7547
          return 1 <= Version && 2147483647 >= Version;
7548
        case OMPC_proc_bind:
7549
          return 1 <= Version && 2147483647 >= Version;
7550
        case OMPC_schedule:
7551
          return 1 <= Version && 2147483647 >= Version;
7552
        case OMPC_safelen:
7553
          return 1 <= Version && 2147483647 >= Version;
7554
        case OMPC_simdlen:
7555
          return 1 <= Version && 2147483647 >= Version;
7556
        default:
7557
          return false;
7558
      }
7559
      break;
7560
    case OMPD_target_teams_distribute_parallel_for:
7561
      switch (C) {
7562
        case OMPC_if:
7563
          return 1 <= Version && 2147483647 >= Version;
7564
        case OMPC_device:
7565
          return 1 <= Version && 2147483647 >= Version;
7566
        case OMPC_map:
7567
          return 1 <= Version && 2147483647 >= Version;
7568
        case OMPC_private:
7569
          return 1 <= Version && 2147483647 >= Version;
7570
        case OMPC_nowait:
7571
          return 1 <= Version && 2147483647 >= Version;
7572
        case OMPC_depend:
7573
          return 1 <= Version && 2147483647 >= Version;
7574
        case OMPC_defaultmap:
7575
          return 1 <= Version && 2147483647 >= Version;
7576
        case OMPC_firstprivate:
7577
          return 1 <= Version && 2147483647 >= Version;
7578
        case OMPC_is_device_ptr:
7579
          return 1 <= Version && 2147483647 >= Version;
7580
        case OMPC_has_device_addr:
7581
          return 51 <= Version && 2147483647 >= Version;
7582
        case OMPC_default:
7583
          return 1 <= Version && 2147483647 >= Version;
7584
        case OMPC_shared:
7585
          return 1 <= Version && 2147483647 >= Version;
7586
        case OMPC_reduction:
7587
          return 1 <= Version && 2147483647 >= Version;
7588
        case OMPC_num_teams:
7589
          return 1 <= Version && 2147483647 >= Version;
7590
        case OMPC_thread_limit:
7591
          return 1 <= Version && 2147483647 >= Version;
7592
        case OMPC_lastprivate:
7593
          return 1 <= Version && 2147483647 >= Version;
7594
        case OMPC_collapse:
7595
          return 1 <= Version && 2147483647 >= Version;
7596
        case OMPC_dist_schedule:
7597
          return 1 <= Version && 2147483647 >= Version;
7598
        case OMPC_num_threads:
7599
          return 1 <= Version && 2147483647 >= Version;
7600
        case OMPC_proc_bind:
7601
          return 1 <= Version && 2147483647 >= Version;
7602
        case OMPC_schedule:
7603
          return 1 <= Version && 2147483647 >= Version;
7604
        case OMPC_allocate:
7605
          return 1 <= Version && 2147483647 >= Version;
7606
        case OMPC_order:
7607
          return 50 <= Version && 2147483647 >= Version;
7608
        case OMPC_uses_allocators:
7609
          return 50 <= Version && 2147483647 >= Version;
7610
        case OMPC_ompx_dyn_cgroup_mem:
7611
          return 1 <= Version && 2147483647 >= Version;
7612
        default:
7613
          return false;
7614
      }
7615
      break;
7616
    case OMPD_target_teams_distribute_parallel_for_simd:
7617
      switch (C) {
7618
        case OMPC_if:
7619
          return 1 <= Version && 2147483647 >= Version;
7620
        case OMPC_device:
7621
          return 1 <= Version && 2147483647 >= Version;
7622
        case OMPC_map:
7623
          return 1 <= Version && 2147483647 >= Version;
7624
        case OMPC_private:
7625
          return 1 <= Version && 2147483647 >= Version;
7626
        case OMPC_nowait:
7627
          return 1 <= Version && 2147483647 >= Version;
7628
        case OMPC_depend:
7629
          return 1 <= Version && 2147483647 >= Version;
7630
        case OMPC_defaultmap:
7631
          return 1 <= Version && 2147483647 >= Version;
7632
        case OMPC_firstprivate:
7633
          return 1 <= Version && 2147483647 >= Version;
7634
        case OMPC_is_device_ptr:
7635
          return 1 <= Version && 2147483647 >= Version;
7636
        case OMPC_has_device_addr:
7637
          return 51 <= Version && 2147483647 >= Version;
7638
        case OMPC_default:
7639
          return 1 <= Version && 2147483647 >= Version;
7640
        case OMPC_shared:
7641
          return 1 <= Version && 2147483647 >= Version;
7642
        case OMPC_reduction:
7643
          return 1 <= Version && 2147483647 >= Version;
7644
        case OMPC_num_teams:
7645
          return 1 <= Version && 2147483647 >= Version;
7646
        case OMPC_thread_limit:
7647
          return 1 <= Version && 2147483647 >= Version;
7648
        case OMPC_lastprivate:
7649
          return 1 <= Version && 2147483647 >= Version;
7650
        case OMPC_collapse:
7651
          return 1 <= Version && 2147483647 >= Version;
7652
        case OMPC_dist_schedule:
7653
          return 1 <= Version && 2147483647 >= Version;
7654
        case OMPC_num_threads:
7655
          return 1 <= Version && 2147483647 >= Version;
7656
        case OMPC_proc_bind:
7657
          return 1 <= Version && 2147483647 >= Version;
7658
        case OMPC_schedule:
7659
          return 1 <= Version && 2147483647 >= Version;
7660
        case OMPC_linear:
7661
          return 1 <= Version && 2147483647 >= Version;
7662
        case OMPC_aligned:
7663
          return 1 <= Version && 2147483647 >= Version;
7664
        case OMPC_safelen:
7665
          return 1 <= Version && 2147483647 >= Version;
7666
        case OMPC_simdlen:
7667
          return 1 <= Version && 2147483647 >= Version;
7668
        case OMPC_allocate:
7669
          return 1 <= Version && 2147483647 >= Version;
7670
        case OMPC_nontemporal:
7671
          return 50 <= Version && 2147483647 >= Version;
7672
        case OMPC_order:
7673
          return 50 <= Version && 2147483647 >= Version;
7674
        case OMPC_uses_allocators:
7675
          return 50 <= Version && 2147483647 >= Version;
7676
        case OMPC_ompx_dyn_cgroup_mem:
7677
          return 1 <= Version && 2147483647 >= Version;
7678
        default:
7679
          return false;
7680
      }
7681
      break;
7682
    case OMPD_target_teams_distribute_simd:
7683
      switch (C) {
7684
        case OMPC_aligned:
7685
          return 1 <= Version && 2147483647 >= Version;
7686
        case OMPC_allocate:
7687
          return 1 <= Version && 2147483647 >= Version;
7688
        case OMPC_depend:
7689
          return 1 <= Version && 2147483647 >= Version;
7690
        case OMPC_firstprivate:
7691
          return 1 <= Version && 2147483647 >= Version;
7692
        case OMPC_if:
7693
          return 1 <= Version && 2147483647 >= Version;
7694
        case OMPC_is_device_ptr:
7695
          return 1 <= Version && 2147483647 >= Version;
7696
        case OMPC_has_device_addr:
7697
          return 51 <= Version && 2147483647 >= Version;
7698
        case OMPC_lastprivate:
7699
          return 1 <= Version && 2147483647 >= Version;
7700
        case OMPC_linear:
7701
          return 1 <= Version && 2147483647 >= Version;
7702
        case OMPC_map:
7703
          return 1 <= Version && 2147483647 >= Version;
7704
        case OMPC_nontemporal:
7705
          return 50 <= Version && 2147483647 >= Version;
7706
        case OMPC_order:
7707
          return 50 <= Version && 2147483647 >= Version;
7708
        case OMPC_private:
7709
          return 1 <= Version && 2147483647 >= Version;
7710
        case OMPC_reduction:
7711
          return 1 <= Version && 2147483647 >= Version;
7712
        case OMPC_shared:
7713
          return 1 <= Version && 2147483647 >= Version;
7714
        case OMPC_uses_allocators:
7715
          return 50 <= Version && 2147483647 >= Version;
7716
        case OMPC_device:
7717
          return 1 <= Version && 2147483647 >= Version;
7718
        case OMPC_defaultmap:
7719
          return 1 <= Version && 2147483647 >= Version;
7720
        case OMPC_nowait:
7721
          return 1 <= Version && 2147483647 >= Version;
7722
        case OMPC_num_teams:
7723
          return 1 <= Version && 2147483647 >= Version;
7724
        case OMPC_thread_limit:
7725
          return 1 <= Version && 2147483647 >= Version;
7726
        case OMPC_collapse:
7727
          return 1 <= Version && 2147483647 >= Version;
7728
        case OMPC_dist_schedule:
7729
          return 1 <= Version && 2147483647 >= Version;
7730
        case OMPC_safelen:
7731
          return 1 <= Version && 2147483647 >= Version;
7732
        case OMPC_simdlen:
7733
          return 1 <= Version && 2147483647 >= Version;
7734
        case OMPC_ompx_dyn_cgroup_mem:
7735
          return 1 <= Version && 2147483647 >= Version;
7736
        default:
7737
          return false;
7738
      }
7739
      break;
7740
    case OMPD_target_update:
7741
      switch (C) {
7742
        case OMPC_to:
7743
          return 1 <= Version && 2147483647 >= Version;
7744
        case OMPC_from:
7745
          return 1 <= Version && 2147483647 >= Version;
7746
        case OMPC_depend:
7747
          return 1 <= Version && 2147483647 >= Version;
7748
        case OMPC_device:
7749
          return 1 <= Version && 2147483647 >= Version;
7750
        case OMPC_if:
7751
          return 1 <= Version && 2147483647 >= Version;
7752
        case OMPC_nowait:
7753
          return 1 <= Version && 2147483647 >= Version;
7754
        default:
7755
          return false;
7756
      }
7757
      break;
7758
    case OMPD_task:
7759
      switch (C) {
7760
        case OMPC_private:
7761
          return 1 <= Version && 2147483647 >= Version;
7762
        case OMPC_firstprivate:
7763
          return 1 <= Version && 2147483647 >= Version;
7764
        case OMPC_shared:
7765
          return 1 <= Version && 2147483647 >= Version;
7766
        case OMPC_untied:
7767
          return 1 <= Version && 2147483647 >= Version;
7768
        case OMPC_mergeable:
7769
          return 1 <= Version && 2147483647 >= Version;
7770
        case OMPC_depend:
7771
          return 1 <= Version && 2147483647 >= Version;
7772
        case OMPC_in_reduction:
7773
          return 1 <= Version && 2147483647 >= Version;
7774
        case OMPC_allocate:
7775
          return 1 <= Version && 2147483647 >= Version;
7776
        case OMPC_detach:
7777
          return 50 <= Version && 2147483647 >= Version;
7778
        case OMPC_affinity:
7779
          return 50 <= Version && 2147483647 >= Version;
7780
        case OMPC_default:
7781
          return 1 <= Version && 2147483647 >= Version;
7782
        case OMPC_if:
7783
          return 1 <= Version && 2147483647 >= Version;
7784
        case OMPC_final:
7785
          return 1 <= Version && 2147483647 >= Version;
7786
        case OMPC_priority:
7787
          return 1 <= Version && 2147483647 >= Version;
7788
        default:
7789
          return false;
7790
      }
7791
      break;
7792
    case OMPD_taskgroup:
7793
      switch (C) {
7794
        case OMPC_task_reduction:
7795
          return 50 <= Version && 2147483647 >= Version;
7796
        case OMPC_allocate:
7797
          return 50 <= Version && 2147483647 >= Version;
7798
        default:
7799
          return false;
7800
      }
7801
      break;
7802
    case OMPD_taskloop:
7803
      switch (C) {
7804
        case OMPC_shared:
7805
          return 1 <= Version && 2147483647 >= Version;
7806
        case OMPC_private:
7807
          return 1 <= Version && 2147483647 >= Version;
7808
        case OMPC_firstprivate:
7809
          return 1 <= Version && 2147483647 >= Version;
7810
        case OMPC_lastprivate:
7811
          return 1 <= Version && 2147483647 >= Version;
7812
        case OMPC_untied:
7813
          return 1 <= Version && 2147483647 >= Version;
7814
        case OMPC_mergeable:
7815
          return 1 <= Version && 2147483647 >= Version;
7816
        case OMPC_nogroup:
7817
          return 1 <= Version && 2147483647 >= Version;
7818
        case OMPC_reduction:
7819
          return 1 <= Version && 2147483647 >= Version;
7820
        case OMPC_in_reduction:
7821
          return 1 <= Version && 2147483647 >= Version;
7822
        case OMPC_allocate:
7823
          return 1 <= Version && 2147483647 >= Version;
7824
        case OMPC_default:
7825
          return 1 <= Version && 2147483647 >= Version;
7826
        case OMPC_if:
7827
          return 1 <= Version && 2147483647 >= Version;
7828
        case OMPC_collapse:
7829
          return 1 <= Version && 2147483647 >= Version;
7830
        case OMPC_final:
7831
          return 1 <= Version && 2147483647 >= Version;
7832
        case OMPC_priority:
7833
          return 1 <= Version && 2147483647 >= Version;
7834
        case OMPC_grainsize:
7835
          return 1 <= Version && 2147483647 >= Version;
7836
        case OMPC_num_tasks:
7837
          return 1 <= Version && 2147483647 >= Version;
7838
        default:
7839
          return false;
7840
      }
7841
      break;
7842
    case OMPD_taskloop_simd:
7843
      switch (C) {
7844
        case OMPC_aligned:
7845
          return 1 <= Version && 2147483647 >= Version;
7846
        case OMPC_allocate:
7847
          return 1 <= Version && 2147483647 >= Version;
7848
        case OMPC_default:
7849
          return 1 <= Version && 2147483647 >= Version;
7850
        case OMPC_firstprivate:
7851
          return 1 <= Version && 2147483647 >= Version;
7852
        case OMPC_in_reduction:
7853
          return 1 <= Version && 2147483647 >= Version;
7854
        case OMPC_lastprivate:
7855
          return 1 <= Version && 2147483647 >= Version;
7856
        case OMPC_linear:
7857
          return 1 <= Version && 2147483647 >= Version;
7858
        case OMPC_mergeable:
7859
          return 1 <= Version && 2147483647 >= Version;
7860
        case OMPC_nogroup:
7861
          return 1 <= Version && 2147483647 >= Version;
7862
        case OMPC_nontemporal:
7863
          return 50 <= Version && 2147483647 >= Version;
7864
        case OMPC_order:
7865
          return 50 <= Version && 2147483647 >= Version;
7866
        case OMPC_private:
7867
          return 1 <= Version && 2147483647 >= Version;
7868
        case OMPC_reduction:
7869
          return 1 <= Version && 2147483647 >= Version;
7870
        case OMPC_shared:
7871
          return 1 <= Version && 2147483647 >= Version;
7872
        case OMPC_untied:
7873
          return 1 <= Version && 2147483647 >= Version;
7874
        case OMPC_if:
7875
          return 1 <= Version && 2147483647 >= Version;
7876
        case OMPC_collapse:
7877
          return 1 <= Version && 2147483647 >= Version;
7878
        case OMPC_safelen:
7879
          return 1 <= Version && 2147483647 >= Version;
7880
        case OMPC_simdlen:
7881
          return 1 <= Version && 2147483647 >= Version;
7882
        case OMPC_final:
7883
          return 1 <= Version && 2147483647 >= Version;
7884
        case OMPC_priority:
7885
          return 1 <= Version && 2147483647 >= Version;
7886
        case OMPC_grainsize:
7887
          return 1 <= Version && 2147483647 >= Version;
7888
        case OMPC_num_tasks:
7889
          return 1 <= Version && 2147483647 >= Version;
7890
        default:
7891
          return false;
7892
      }
7893
      break;
7894
    case OMPD_taskwait:
7895
      switch (C) {
7896
        case OMPC_depend:
7897
          return 50 <= Version && 2147483647 >= Version;
7898
        case OMPC_nowait:
7899
          return 51 <= Version && 2147483647 >= Version;
7900
        default:
7901
          return false;
7902
      }
7903
      break;
7904
    case OMPD_taskyield:
7905
      return false;
7906
      break;
7907
    case OMPD_teams:
7908
      switch (C) {
7909
        case OMPC_private:
7910
          return 1 <= Version && 2147483647 >= Version;
7911
        case OMPC_firstprivate:
7912
          return 1 <= Version && 2147483647 >= Version;
7913
        case OMPC_shared:
7914
          return 1 <= Version && 2147483647 >= Version;
7915
        case OMPC_reduction:
7916
          return 1 <= Version && 2147483647 >= Version;
7917
        case OMPC_allocate:
7918
          return 1 <= Version && 2147483647 >= Version;
7919
        case OMPC_default:
7920
          return 1 <= Version && 2147483647 >= Version;
7921
        case OMPC_num_teams:
7922
          return 1 <= Version && 2147483647 >= Version;
7923
        case OMPC_thread_limit:
7924
          return 1 <= Version && 2147483647 >= Version;
7925
        default:
7926
          return false;
7927
      }
7928
      break;
7929
    case OMPD_teams_distribute:
7930
      switch (C) {
7931
        case OMPC_default:
7932
          return 1 <= Version && 2147483647 >= Version;
7933
        case OMPC_private:
7934
          return 1 <= Version && 2147483647 >= Version;
7935
        case OMPC_firstprivate:
7936
          return 1 <= Version && 2147483647 >= Version;
7937
        case OMPC_shared:
7938
          return 1 <= Version && 2147483647 >= Version;
7939
        case OMPC_reduction:
7940
          return 1 <= Version && 2147483647 >= Version;
7941
        case OMPC_num_teams:
7942
          return 1 <= Version && 2147483647 >= Version;
7943
        case OMPC_thread_limit:
7944
          return 1 <= Version && 2147483647 >= Version;
7945
        case OMPC_lastprivate:
7946
          return 1 <= Version && 2147483647 >= Version;
7947
        case OMPC_collapse:
7948
          return 1 <= Version && 2147483647 >= Version;
7949
        case OMPC_dist_schedule:
7950
          return 1 <= Version && 2147483647 >= Version;
7951
        case OMPC_allocate:
7952
          return 1 <= Version && 2147483647 >= Version;
7953
        default:
7954
          return false;
7955
      }
7956
      break;
7957
    case OMPD_teams_distribute_parallel_do:
7958
      switch (C) {
7959
        case OMPC_private:
7960
          return 1 <= Version && 2147483647 >= Version;
7961
        case OMPC_firstprivate:
7962
          return 1 <= Version && 2147483647 >= Version;
7963
        case OMPC_lastprivate:
7964
          return 1 <= Version && 2147483647 >= Version;
7965
        case OMPC_shared:
7966
          return 1 <= Version && 2147483647 >= Version;
7967
        case OMPC_reduction:
7968
          return 1 <= Version && 2147483647 >= Version;
7969
        case OMPC_allocate:
7970
          return 1 <= Version && 2147483647 >= Version;
7971
        case OMPC_copyin:
7972
          return 1 <= Version && 2147483647 >= Version;
7973
        case OMPC_linear:
7974
          return 1 <= Version && 2147483647 >= Version;
7975
        case OMPC_num_teams:
7976
          return 1 <= Version && 2147483647 >= Version;
7977
        case OMPC_thread_limit:
7978
          return 1 <= Version && 2147483647 >= Version;
7979
        case OMPC_default:
7980
          return 1 <= Version && 2147483647 >= Version;
7981
        case OMPC_collapse:
7982
          return 1 <= Version && 2147483647 >= Version;
7983
        case OMPC_dist_schedule:
7984
          return 1 <= Version && 2147483647 >= Version;
7985
        case OMPC_ordered:
7986
          return 1 <= Version && 2147483647 >= Version;
7987
        case OMPC_order:
7988
          return 1 <= Version && 2147483647 >= Version;
7989
        case OMPC_if:
7990
          return 1 <= Version && 2147483647 >= Version;
7991
        case OMPC_num_threads:
7992
          return 1 <= Version && 2147483647 >= Version;
7993
        case OMPC_proc_bind:
7994
          return 1 <= Version && 2147483647 >= Version;
7995
        case OMPC_schedule:
7996
          return 1 <= Version && 2147483647 >= Version;
7997
        default:
7998
          return false;
7999
      }
8000
      break;
8001
    case OMPD_teams_distribute_parallel_do_simd:
8002
      switch (C) {
8003
        case OMPC_private:
8004
          return 1 <= Version && 2147483647 >= Version;
8005
        case OMPC_firstprivate:
8006
          return 1 <= Version && 2147483647 >= Version;
8007
        case OMPC_lastprivate:
8008
          return 1 <= Version && 2147483647 >= Version;
8009
        case OMPC_allocate:
8010
          return 1 <= Version && 2147483647 >= Version;
8011
        case OMPC_shared:
8012
          return 1 <= Version && 2147483647 >= Version;
8013
        case OMPC_reduction:
8014
          return 1 <= Version && 2147483647 >= Version;
8015
        case OMPC_linear:
8016
          return 1 <= Version && 2147483647 >= Version;
8017
        case OMPC_order:
8018
          return 1 <= Version && 2147483647 >= Version;
8019
        case OMPC_aligned:
8020
          return 1 <= Version && 2147483647 >= Version;
8021
        case OMPC_nontemporal:
8022
          return 1 <= Version && 2147483647 >= Version;
8023
        case OMPC_default:
8024
          return 1 <= Version && 2147483647 >= Version;
8025
        case OMPC_num_teams:
8026
          return 1 <= Version && 2147483647 >= Version;
8027
        case OMPC_thread_limit:
8028
          return 1 <= Version && 2147483647 >= Version;
8029
        case OMPC_collapse:
8030
          return 1 <= Version && 2147483647 >= Version;
8031
        case OMPC_dist_schedule:
8032
          return 1 <= Version && 2147483647 >= Version;
8033
        case OMPC_num_threads:
8034
          return 1 <= Version && 2147483647 >= Version;
8035
        case OMPC_proc_bind:
8036
          return 1 <= Version && 2147483647 >= Version;
8037
        case OMPC_schedule:
8038
          return 1 <= Version && 2147483647 >= Version;
8039
        case OMPC_safelen:
8040
          return 1 <= Version && 2147483647 >= Version;
8041
        case OMPC_simdlen:
8042
          return 1 <= Version && 2147483647 >= Version;
8043
        case OMPC_if:
8044
          return 1 <= Version && 2147483647 >= Version;
8045
        default:
8046
          return false;
8047
      }
8048
      break;
8049
    case OMPD_teams_distribute_parallel_for:
8050
      switch (C) {
8051
        case OMPC_firstprivate:
8052
          return 1 <= Version && 2147483647 >= Version;
8053
        case OMPC_lastprivate:
8054
          return 1 <= Version && 2147483647 >= Version;
8055
        case OMPC_collapse:
8056
          return 1 <= Version && 2147483647 >= Version;
8057
        case OMPC_dist_schedule:
8058
          return 1 <= Version && 2147483647 >= Version;
8059
        case OMPC_if:
8060
          return 1 <= Version && 2147483647 >= Version;
8061
        case OMPC_num_threads:
8062
          return 1 <= Version && 2147483647 >= Version;
8063
        case OMPC_default:
8064
          return 1 <= Version && 2147483647 >= Version;
8065
        case OMPC_proc_bind:
8066
          return 1 <= Version && 2147483647 >= Version;
8067
        case OMPC_private:
8068
          return 1 <= Version && 2147483647 >= Version;
8069
        case OMPC_shared:
8070
          return 1 <= Version && 2147483647 >= Version;
8071
        case OMPC_reduction:
8072
          return 1 <= Version && 2147483647 >= Version;
8073
        case OMPC_schedule:
8074
          return 1 <= Version && 2147483647 >= Version;
8075
        case OMPC_num_teams:
8076
          return 1 <= Version && 2147483647 >= Version;
8077
        case OMPC_thread_limit:
8078
          return 1 <= Version && 2147483647 >= Version;
8079
        case OMPC_copyin:
8080
          return 1 <= Version && 2147483647 >= Version;
8081
        case OMPC_allocate:
8082
          return 1 <= Version && 2147483647 >= Version;
8083
        case OMPC_order:
8084
          return 50 <= Version && 2147483647 >= Version;
8085
        default:
8086
          return false;
8087
      }
8088
      break;
8089
    case OMPD_teams_distribute_parallel_for_simd:
8090
      switch (C) {
8091
        case OMPC_firstprivate:
8092
          return 1 <= Version && 2147483647 >= Version;
8093
        case OMPC_lastprivate:
8094
          return 1 <= Version && 2147483647 >= Version;
8095
        case OMPC_collapse:
8096
          return 1 <= Version && 2147483647 >= Version;
8097
        case OMPC_dist_schedule:
8098
          return 1 <= Version && 2147483647 >= Version;
8099
        case OMPC_if:
8100
          return 1 <= Version && 2147483647 >= Version;
8101
        case OMPC_num_threads:
8102
          return 1 <= Version && 2147483647 >= Version;
8103
        case OMPC_default:
8104
          return 1 <= Version && 2147483647 >= Version;
8105
        case OMPC_proc_bind:
8106
          return 1 <= Version && 2147483647 >= Version;
8107
        case OMPC_private:
8108
          return 1 <= Version && 2147483647 >= Version;
8109
        case OMPC_shared:
8110
          return 1 <= Version && 2147483647 >= Version;
8111
        case OMPC_reduction:
8112
          return 1 <= Version && 2147483647 >= Version;
8113
        case OMPC_schedule:
8114
          return 1 <= Version && 2147483647 >= Version;
8115
        case OMPC_linear:
8116
          return 1 <= Version && 2147483647 >= Version;
8117
        case OMPC_aligned:
8118
          return 1 <= Version && 2147483647 >= Version;
8119
        case OMPC_safelen:
8120
          return 1 <= Version && 2147483647 >= Version;
8121
        case OMPC_simdlen:
8122
          return 1 <= Version && 2147483647 >= Version;
8123
        case OMPC_num_teams:
8124
          return 1 <= Version && 2147483647 >= Version;
8125
        case OMPC_thread_limit:
8126
          return 1 <= Version && 2147483647 >= Version;
8127
        case OMPC_allocate:
8128
          return 1 <= Version && 2147483647 >= Version;
8129
        case OMPC_nontemporal:
8130
          return 50 <= Version && 2147483647 >= Version;
8131
        case OMPC_order:
8132
          return 50 <= Version && 2147483647 >= Version;
8133
        default:
8134
          return false;
8135
      }
8136
      break;
8137
    case OMPD_teams_distribute_simd:
8138
      switch (C) {
8139
        case OMPC_aligned:
8140
          return 1 <= Version && 2147483647 >= Version;
8141
        case OMPC_allocate:
8142
          return 1 <= Version && 2147483647 >= Version;
8143
        case OMPC_firstprivate:
8144
          return 1 <= Version && 2147483647 >= Version;
8145
        case OMPC_lastprivate:
8146
          return 1 <= Version && 2147483647 >= Version;
8147
        case OMPC_linear:
8148
          return 1 <= Version && 2147483647 >= Version;
8149
        case OMPC_nontemporal:
8150
          return 50 <= Version && 2147483647 >= Version;
8151
        case OMPC_order:
8152
          return 50 <= Version && 2147483647 >= Version;
8153
        case OMPC_private:
8154
          return 1 <= Version && 2147483647 >= Version;
8155
        case OMPC_reduction:
8156
          return 1 <= Version && 2147483647 >= Version;
8157
        case OMPC_shared:
8158
          return 1 <= Version && 2147483647 >= Version;
8159
        case OMPC_collapse:
8160
          return 1 <= Version && 2147483647 >= Version;
8161
        case OMPC_default:
8162
          return 1 <= Version && 2147483647 >= Version;
8163
        case OMPC_dist_schedule:
8164
          return 1 <= Version && 2147483647 >= Version;
8165
        case OMPC_if:
8166
          return 50 <= Version && 2147483647 >= Version;
8167
        case OMPC_num_teams:
8168
          return 1 <= Version && 2147483647 >= Version;
8169
        case OMPC_safelen:
8170
          return 1 <= Version && 2147483647 >= Version;
8171
        case OMPC_simdlen:
8172
          return 1 <= Version && 2147483647 >= Version;
8173
        case OMPC_thread_limit:
8174
          return 1 <= Version && 2147483647 >= Version;
8175
        default:
8176
          return false;
8177
      }
8178
      break;
8179
    case OMPD_threadprivate:
8180
      return false;
8181
      break;
8182
    case OMPD_tile:
8183
      switch (C) {
8184
        case OMPC_sizes:
8185
          return 51 <= Version && 2147483647 >= Version;
8186
        default:
8187
          return false;
8188
      }
8189
      break;
8190
    case OMPD_unknown:
8191
      return false;
8192
      break;
8193
    case OMPD_unroll:
8194
      switch (C) {
8195
        case OMPC_full:
8196
          return 51 <= Version && 2147483647 >= Version;
8197
        case OMPC_partial:
8198
          return 51 <= Version && 2147483647 >= Version;
8199
        default:
8200
          return false;
8201
      }
8202
      break;
8203
    case OMPD_workshare:
8204
      return false;
8205
      break;
8206
    case OMPD_dispatch:
8207
      switch (C) {
8208
        case OMPC_device:
8209
          return 1 <= Version && 2147483647 >= Version;
8210
        case OMPC_is_device_ptr:
8211
          return 1 <= Version && 2147483647 >= Version;
8212
        case OMPC_has_device_addr:
8213
          return 51 <= Version && 2147483647 >= Version;
8214
        case OMPC_nowait:
8215
          return 1 <= Version && 2147483647 >= Version;
8216
        case OMPC_depend:
8217
          return 1 <= Version && 2147483647 >= Version;
8218
        case OMPC_novariants:
8219
          return 1 <= Version && 2147483647 >= Version;
8220
        case OMPC_nocontext:
8221
          return 1 <= Version && 2147483647 >= Version;
8222
        default:
8223
          return false;
8224
      }
8225
      break;
8226
    case OMPD_interop:
8227
      switch (C) {
8228
        case OMPC_device:
8229
          return 1 <= Version && 2147483647 >= Version;
8230
        case OMPC_depend:
8231
          return 1 <= Version && 2147483647 >= Version;
8232
        case OMPC_destroy:
8233
          return 1 <= Version && 2147483647 >= Version;
8234
        case OMPC_init:
8235
          return 1 <= Version && 2147483647 >= Version;
8236
        case OMPC_nowait:
8237
          return 1 <= Version && 2147483647 >= Version;
8238
        case OMPC_use:
8239
          return 1 <= Version && 2147483647 >= Version;
8240
        default:
8241
          return false;
8242
      }
8243
      break;
8244
    case OMPD_loop:
8245
      switch (C) {
8246
        case OMPC_lastprivate:
8247
          return 1 <= Version && 2147483647 >= Version;
8248
        case OMPC_private:
8249
          return 1 <= Version && 2147483647 >= Version;
8250
        case OMPC_reduction:
8251
          return 1 <= Version && 2147483647 >= Version;
8252
        case OMPC_bind:
8253
          return 50 <= Version && 2147483647 >= Version;
8254
        case OMPC_collapse:
8255
          return 1 <= Version && 2147483647 >= Version;
8256
        case OMPC_order:
8257
          return 1 <= Version && 2147483647 >= Version;
8258
        default:
8259
          return false;
8260
      }
8261
      break;
8262
    case OMPD_masked:
8263
      switch (C) {
8264
        case OMPC_filter:
8265
          return 1 <= Version && 2147483647 >= Version;
8266
        default:
8267
          return false;
8268
      }
8269
      break;
8270
    case OMPD_parallel_loop:
8271
      switch (C) {
8272
        case OMPC_allocate:
8273
          return 1 <= Version && 2147483647 >= Version;
8274
        case OMPC_copyin:
8275
          return 1 <= Version && 2147483647 >= Version;
8276
        case OMPC_firstprivate:
8277
          return 1 <= Version && 2147483647 >= Version;
8278
        case OMPC_lastprivate:
8279
          return 1 <= Version && 2147483647 >= Version;
8280
        case OMPC_private:
8281
          return 1 <= Version && 2147483647 >= Version;
8282
        case OMPC_reduction:
8283
          return 1 <= Version && 2147483647 >= Version;
8284
        case OMPC_shared:
8285
          return 1 <= Version && 2147483647 >= Version;
8286
        case OMPC_bind:
8287
          return 50 <= Version && 2147483647 >= Version;
8288
        case OMPC_collapse:
8289
          return 1 <= Version && 2147483647 >= Version;
8290
        case OMPC_default:
8291
          return 1 <= Version && 2147483647 >= Version;
8292
        case OMPC_if:
8293
          return 1 <= Version && 2147483647 >= Version;
8294
        case OMPC_num_threads:
8295
          return 1 <= Version && 2147483647 >= Version;
8296
        case OMPC_order:
8297
          return 1 <= Version && 2147483647 >= Version;
8298
        case OMPC_proc_bind:
8299
          return 1 <= Version && 2147483647 >= Version;
8300
        default:
8301
          return false;
8302
      }
8303
      break;
8304
    case OMPD_target_parallel_loop:
8305
      switch (C) {
8306
        case OMPC_allocate:
8307
          return 1 <= Version && 2147483647 >= Version;
8308
        case OMPC_copyin:
8309
          return 1 <= Version && 2147483647 >= Version;
8310
        case OMPC_depend:
8311
          return 1 <= Version && 2147483647 >= Version;
8312
        case OMPC_device:
8313
          return 1 <= Version && 2147483647 >= Version;
8314
        case OMPC_firstprivate:
8315
          return 1 <= Version && 2147483647 >= Version;
8316
        case OMPC_is_device_ptr:
8317
          return 1 <= Version && 2147483647 >= Version;
8318
        case OMPC_has_device_addr:
8319
          return 51 <= Version && 2147483647 >= Version;
8320
        case OMPC_lastprivate:
8321
          return 1 <= Version && 2147483647 >= Version;
8322
        case OMPC_map:
8323
          return 1 <= Version && 2147483647 >= Version;
8324
        case OMPC_private:
8325
          return 1 <= Version && 2147483647 >= Version;
8326
        case OMPC_reduction:
8327
          return 1 <= Version && 2147483647 >= Version;
8328
        case OMPC_shared:
8329
          return 1 <= Version && 2147483647 >= Version;
8330
        case OMPC_uses_allocators:
8331
          return 50 <= Version && 2147483647 >= Version;
8332
        case OMPC_bind:
8333
          return 50 <= Version && 2147483647 >= Version;
8334
        case OMPC_collapse:
8335
          return 1 <= Version && 2147483647 >= Version;
8336
        case OMPC_default:
8337
          return 1 <= Version && 2147483647 >= Version;
8338
        case OMPC_defaultmap:
8339
          return 1 <= Version && 2147483647 >= Version;
8340
        case OMPC_if:
8341
          return 1 <= Version && 2147483647 >= Version;
8342
        case OMPC_nowait:
8343
          return 1 <= Version && 2147483647 >= Version;
8344
        case OMPC_num_threads:
8345
          return 1 <= Version && 2147483647 >= Version;
8346
        case OMPC_order:
8347
          return 1 <= Version && 2147483647 >= Version;
8348
        case OMPC_proc_bind:
8349
          return 1 <= Version && 2147483647 >= Version;
8350
        case OMPC_ompx_dyn_cgroup_mem:
8351
          return 1 <= Version && 2147483647 >= Version;
8352
        default:
8353
          return false;
8354
      }
8355
      break;
8356
    case OMPD_target_teams_loop:
8357
      switch (C) {
8358
        case OMPC_allocate:
8359
          return 1 <= Version && 2147483647 >= Version;
8360
        case OMPC_depend:
8361
          return 1 <= Version && 2147483647 >= Version;
8362
        case OMPC_defaultmap:
8363
          return 1 <= Version && 2147483647 >= Version;
8364
        case OMPC_device:
8365
          return 1 <= Version && 2147483647 >= Version;
8366
        case OMPC_firstprivate:
8367
          return 1 <= Version && 2147483647 >= Version;
8368
        case OMPC_is_device_ptr:
8369
          return 1 <= Version && 2147483647 >= Version;
8370
        case OMPC_has_device_addr:
8371
          return 51 <= Version && 2147483647 >= Version;
8372
        case OMPC_lastprivate:
8373
          return 1 <= Version && 2147483647 >= Version;
8374
        case OMPC_map:
8375
          return 1 <= Version && 2147483647 >= Version;
8376
        case OMPC_private:
8377
          return 1 <= Version && 2147483647 >= Version;
8378
        case OMPC_reduction:
8379
          return 1 <= Version && 2147483647 >= Version;
8380
        case OMPC_shared:
8381
          return 1 <= Version && 2147483647 >= Version;
8382
        case OMPC_uses_allocators:
8383
          return 50 <= Version && 2147483647 >= Version;
8384
        case OMPC_bind:
8385
          return 50 <= Version && 2147483647 >= Version;
8386
        case OMPC_collapse:
8387
          return 1 <= Version && 2147483647 >= Version;
8388
        case OMPC_default:
8389
          return 1 <= Version && 2147483647 >= Version;
8390
        case OMPC_if:
8391
          return 1 <= Version && 2147483647 >= Version;
8392
        case OMPC_nowait:
8393
          return 1 <= Version && 2147483647 >= Version;
8394
        case OMPC_num_teams:
8395
          return 1 <= Version && 2147483647 >= Version;
8396
        case OMPC_order:
8397
          return 1 <= Version && 2147483647 >= Version;
8398
        case OMPC_thread_limit:
8399
          return 1 <= Version && 2147483647 >= Version;
8400
        case OMPC_ompx_dyn_cgroup_mem:
8401
          return 1 <= Version && 2147483647 >= Version;
8402
        default:
8403
          return false;
8404
      }
8405
      break;
8406
    case OMPD_teams_loop:
8407
      switch (C) {
8408
        case OMPC_allocate:
8409
          return 1 <= Version && 2147483647 >= Version;
8410
        case OMPC_firstprivate:
8411
          return 1 <= Version && 2147483647 >= Version;
8412
        case OMPC_lastprivate:
8413
          return 1 <= Version && 2147483647 >= Version;
8414
        case OMPC_private:
8415
          return 1 <= Version && 2147483647 >= Version;
8416
        case OMPC_reduction:
8417
          return 1 <= Version && 2147483647 >= Version;
8418
        case OMPC_shared:
8419
          return 1 <= Version && 2147483647 >= Version;
8420
        case OMPC_bind:
8421
          return 50 <= Version && 2147483647 >= Version;
8422
        case OMPC_collapse:
8423
          return 1 <= Version && 2147483647 >= Version;
8424
        case OMPC_default:
8425
          return 1 <= Version && 2147483647 >= Version;
8426
        case OMPC_num_teams:
8427
          return 1 <= Version && 2147483647 >= Version;
8428
        case OMPC_order:
8429
          return 1 <= Version && 2147483647 >= Version;
8430
        case OMPC_thread_limit:
8431
          return 1 <= Version && 2147483647 >= Version;
8432
        default:
8433
          return false;
8434
      }
8435
      break;
8436
  }
8437
  llvm_unreachable("Invalid OpenMP Directive kind");
8438
}
8439
 
8440
#endif // GEN_DIRECTIVES_IMPL
8441