Back to home page

EIC code displayed by LXR
 
 

    

Warning, /include/llvm/Frontend/OpenACC/ACC.inc is written in an unsupported language. File is not indexed. 

0001 #ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
0002 #undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
0003 
0004 namespace llvm {
0005 namespace acc {
0006 
0007   // Sets for atomic
0008 
0009   static AccClauseSet allowedClauses_ACCD_atomic {
0010   };
0011 
0012   static AccClauseSet allowedOnceClauses_ACCD_atomic {
0013   };
0014 
0015   static AccClauseSet allowedExclusiveClauses_ACCD_atomic {
0016   };
0017 
0018   static AccClauseSet requiredClauses_ACCD_atomic {
0019   };
0020 
0021   // Sets for cache
0022 
0023   static AccClauseSet allowedClauses_ACCD_cache {
0024   };
0025 
0026   static AccClauseSet allowedOnceClauses_ACCD_cache {
0027   };
0028 
0029   static AccClauseSet allowedExclusiveClauses_ACCD_cache {
0030   };
0031 
0032   static AccClauseSet requiredClauses_ACCD_cache {
0033   };
0034 
0035   // Sets for data
0036 
0037   static AccClauseSet allowedClauses_ACCD_data {
0038     llvm::acc::Clause::ACCC_device_type,
0039     llvm::acc::Clause::ACCC_wait,
0040   };
0041 
0042   static AccClauseSet allowedOnceClauses_ACCD_data {
0043     llvm::acc::Clause::ACCC_async,
0044     llvm::acc::Clause::ACCC_if,
0045     llvm::acc::Clause::ACCC_default,
0046   };
0047 
0048   static AccClauseSet allowedExclusiveClauses_ACCD_data {
0049   };
0050 
0051   static AccClauseSet requiredClauses_ACCD_data {
0052     llvm::acc::Clause::ACCC_attach,
0053     llvm::acc::Clause::ACCC_copy,
0054     llvm::acc::Clause::ACCC_copyin,
0055     llvm::acc::Clause::ACCC_copyout,
0056     llvm::acc::Clause::ACCC_create,
0057     llvm::acc::Clause::ACCC_default,
0058     llvm::acc::Clause::ACCC_deviceptr,
0059     llvm::acc::Clause::ACCC_no_create,
0060     llvm::acc::Clause::ACCC_present,
0061   };
0062 
0063   // Sets for declare
0064 
0065   static AccClauseSet allowedClauses_ACCD_declare {
0066     llvm::acc::Clause::ACCC_copy,
0067     llvm::acc::Clause::ACCC_copyin,
0068     llvm::acc::Clause::ACCC_copyout,
0069     llvm::acc::Clause::ACCC_create,
0070     llvm::acc::Clause::ACCC_present,
0071     llvm::acc::Clause::ACCC_deviceptr,
0072     llvm::acc::Clause::ACCC_device_resident,
0073     llvm::acc::Clause::ACCC_link,
0074   };
0075 
0076   static AccClauseSet allowedOnceClauses_ACCD_declare {
0077   };
0078 
0079   static AccClauseSet allowedExclusiveClauses_ACCD_declare {
0080   };
0081 
0082   static AccClauseSet requiredClauses_ACCD_declare {
0083   };
0084 
0085   // Sets for enter data
0086 
0087   static AccClauseSet allowedClauses_ACCD_enter_data {
0088     llvm::acc::Clause::ACCC_wait,
0089   };
0090 
0091   static AccClauseSet allowedOnceClauses_ACCD_enter_data {
0092     llvm::acc::Clause::ACCC_async,
0093     llvm::acc::Clause::ACCC_if,
0094   };
0095 
0096   static AccClauseSet allowedExclusiveClauses_ACCD_enter_data {
0097   };
0098 
0099   static AccClauseSet requiredClauses_ACCD_enter_data {
0100     llvm::acc::Clause::ACCC_attach,
0101     llvm::acc::Clause::ACCC_create,
0102     llvm::acc::Clause::ACCC_copyin,
0103   };
0104 
0105   // Sets for exit data
0106 
0107   static AccClauseSet allowedClauses_ACCD_exit_data {
0108     llvm::acc::Clause::ACCC_wait,
0109   };
0110 
0111   static AccClauseSet allowedOnceClauses_ACCD_exit_data {
0112     llvm::acc::Clause::ACCC_async,
0113     llvm::acc::Clause::ACCC_if,
0114     llvm::acc::Clause::ACCC_finalize,
0115   };
0116 
0117   static AccClauseSet allowedExclusiveClauses_ACCD_exit_data {
0118   };
0119 
0120   static AccClauseSet requiredClauses_ACCD_exit_data {
0121     llvm::acc::Clause::ACCC_copyout,
0122     llvm::acc::Clause::ACCC_delete,
0123     llvm::acc::Clause::ACCC_detach,
0124   };
0125 
0126   // Sets for host_data
0127 
0128   static AccClauseSet allowedClauses_ACCD_host_data {
0129   };
0130 
0131   static AccClauseSet allowedOnceClauses_ACCD_host_data {
0132     llvm::acc::Clause::ACCC_if,
0133     llvm::acc::Clause::ACCC_if_present,
0134   };
0135 
0136   static AccClauseSet allowedExclusiveClauses_ACCD_host_data {
0137   };
0138 
0139   static AccClauseSet requiredClauses_ACCD_host_data {
0140     llvm::acc::Clause::ACCC_use_device,
0141   };
0142 
0143   // Sets for init
0144 
0145   static AccClauseSet allowedClauses_ACCD_init {
0146   };
0147 
0148   static AccClauseSet allowedOnceClauses_ACCD_init {
0149     llvm::acc::Clause::ACCC_device_num,
0150     llvm::acc::Clause::ACCC_device_type,
0151     llvm::acc::Clause::ACCC_if,
0152   };
0153 
0154   static AccClauseSet allowedExclusiveClauses_ACCD_init {
0155   };
0156 
0157   static AccClauseSet requiredClauses_ACCD_init {
0158   };
0159 
0160   // Sets for kernels
0161 
0162   static AccClauseSet allowedClauses_ACCD_kernels {
0163     llvm::acc::Clause::ACCC_attach,
0164     llvm::acc::Clause::ACCC_copy,
0165     llvm::acc::Clause::ACCC_copyin,
0166     llvm::acc::Clause::ACCC_copyout,
0167     llvm::acc::Clause::ACCC_create,
0168     llvm::acc::Clause::ACCC_device_type,
0169     llvm::acc::Clause::ACCC_no_create,
0170     llvm::acc::Clause::ACCC_present,
0171     llvm::acc::Clause::ACCC_deviceptr,
0172     llvm::acc::Clause::ACCC_wait,
0173   };
0174 
0175   static AccClauseSet allowedOnceClauses_ACCD_kernels {
0176     llvm::acc::Clause::ACCC_async,
0177     llvm::acc::Clause::ACCC_default,
0178     llvm::acc::Clause::ACCC_if,
0179     llvm::acc::Clause::ACCC_num_gangs,
0180     llvm::acc::Clause::ACCC_num_workers,
0181     llvm::acc::Clause::ACCC_self,
0182     llvm::acc::Clause::ACCC_vector_length,
0183   };
0184 
0185   static AccClauseSet allowedExclusiveClauses_ACCD_kernels {
0186   };
0187 
0188   static AccClauseSet requiredClauses_ACCD_kernels {
0189   };
0190 
0191   // Sets for kernels loop
0192 
0193   static AccClauseSet allowedClauses_ACCD_kernels_loop {
0194     llvm::acc::Clause::ACCC_attach,
0195     llvm::acc::Clause::ACCC_collapse,
0196     llvm::acc::Clause::ACCC_copy,
0197     llvm::acc::Clause::ACCC_copyin,
0198     llvm::acc::Clause::ACCC_copyout,
0199     llvm::acc::Clause::ACCC_create,
0200     llvm::acc::Clause::ACCC_deviceptr,
0201     llvm::acc::Clause::ACCC_device_type,
0202     llvm::acc::Clause::ACCC_gang,
0203     llvm::acc::Clause::ACCC_no_create,
0204     llvm::acc::Clause::ACCC_num_gangs,
0205     llvm::acc::Clause::ACCC_num_workers,
0206     llvm::acc::Clause::ACCC_present,
0207     llvm::acc::Clause::ACCC_private,
0208     llvm::acc::Clause::ACCC_reduction,
0209     llvm::acc::Clause::ACCC_shortloop,
0210     llvm::acc::Clause::ACCC_tile,
0211     llvm::acc::Clause::ACCC_vector,
0212     llvm::acc::Clause::ACCC_vector_length,
0213     llvm::acc::Clause::ACCC_wait,
0214     llvm::acc::Clause::ACCC_worker,
0215   };
0216 
0217   static AccClauseSet allowedOnceClauses_ACCD_kernels_loop {
0218     llvm::acc::Clause::ACCC_async,
0219     llvm::acc::Clause::ACCC_default,
0220     llvm::acc::Clause::ACCC_if,
0221     llvm::acc::Clause::ACCC_self,
0222   };
0223 
0224   static AccClauseSet allowedExclusiveClauses_ACCD_kernels_loop {
0225     llvm::acc::Clause::ACCC_auto,
0226     llvm::acc::Clause::ACCC_independent,
0227     llvm::acc::Clause::ACCC_seq,
0228   };
0229 
0230   static AccClauseSet requiredClauses_ACCD_kernels_loop {
0231   };
0232 
0233   // Sets for loop
0234 
0235   static AccClauseSet allowedClauses_ACCD_loop {
0236     llvm::acc::Clause::ACCC_device_type,
0237     llvm::acc::Clause::ACCC_private,
0238     llvm::acc::Clause::ACCC_reduction,
0239     llvm::acc::Clause::ACCC_collapse,
0240     llvm::acc::Clause::ACCC_gang,
0241     llvm::acc::Clause::ACCC_shortloop,
0242     llvm::acc::Clause::ACCC_tile,
0243     llvm::acc::Clause::ACCC_vector,
0244     llvm::acc::Clause::ACCC_worker,
0245   };
0246 
0247   static AccClauseSet allowedOnceClauses_ACCD_loop {
0248   };
0249 
0250   static AccClauseSet allowedExclusiveClauses_ACCD_loop {
0251     llvm::acc::Clause::ACCC_auto,
0252     llvm::acc::Clause::ACCC_independent,
0253     llvm::acc::Clause::ACCC_seq,
0254   };
0255 
0256   static AccClauseSet requiredClauses_ACCD_loop {
0257   };
0258 
0259   // Sets for parallel
0260 
0261   static AccClauseSet allowedClauses_ACCD_parallel {
0262     llvm::acc::Clause::ACCC_attach,
0263     llvm::acc::Clause::ACCC_async,
0264     llvm::acc::Clause::ACCC_copy,
0265     llvm::acc::Clause::ACCC_copyin,
0266     llvm::acc::Clause::ACCC_copyout,
0267     llvm::acc::Clause::ACCC_create,
0268     llvm::acc::Clause::ACCC_deviceptr,
0269     llvm::acc::Clause::ACCC_device_type,
0270     llvm::acc::Clause::ACCC_no_create,
0271     llvm::acc::Clause::ACCC_num_gangs,
0272     llvm::acc::Clause::ACCC_num_workers,
0273     llvm::acc::Clause::ACCC_present,
0274     llvm::acc::Clause::ACCC_private,
0275     llvm::acc::Clause::ACCC_firstprivate,
0276     llvm::acc::Clause::ACCC_reduction,
0277     llvm::acc::Clause::ACCC_wait,
0278     llvm::acc::Clause::ACCC_vector_length,
0279   };
0280 
0281   static AccClauseSet allowedOnceClauses_ACCD_parallel {
0282     llvm::acc::Clause::ACCC_default,
0283     llvm::acc::Clause::ACCC_if,
0284     llvm::acc::Clause::ACCC_self,
0285   };
0286 
0287   static AccClauseSet allowedExclusiveClauses_ACCD_parallel {
0288   };
0289 
0290   static AccClauseSet requiredClauses_ACCD_parallel {
0291   };
0292 
0293   // Sets for parallel loop
0294 
0295   static AccClauseSet allowedClauses_ACCD_parallel_loop {
0296     llvm::acc::Clause::ACCC_attach,
0297     llvm::acc::Clause::ACCC_collapse,
0298     llvm::acc::Clause::ACCC_copy,
0299     llvm::acc::Clause::ACCC_copyin,
0300     llvm::acc::Clause::ACCC_copyout,
0301     llvm::acc::Clause::ACCC_create,
0302     llvm::acc::Clause::ACCC_deviceptr,
0303     llvm::acc::Clause::ACCC_device_type,
0304     llvm::acc::Clause::ACCC_firstprivate,
0305     llvm::acc::Clause::ACCC_gang,
0306     llvm::acc::Clause::ACCC_no_create,
0307     llvm::acc::Clause::ACCC_num_gangs,
0308     llvm::acc::Clause::ACCC_num_workers,
0309     llvm::acc::Clause::ACCC_present,
0310     llvm::acc::Clause::ACCC_private,
0311     llvm::acc::Clause::ACCC_reduction,
0312     llvm::acc::Clause::ACCC_shortloop,
0313     llvm::acc::Clause::ACCC_tile,
0314     llvm::acc::Clause::ACCC_vector,
0315     llvm::acc::Clause::ACCC_vector_length,
0316     llvm::acc::Clause::ACCC_wait,
0317     llvm::acc::Clause::ACCC_worker,
0318   };
0319 
0320   static AccClauseSet allowedOnceClauses_ACCD_parallel_loop {
0321     llvm::acc::Clause::ACCC_async,
0322     llvm::acc::Clause::ACCC_default,
0323     llvm::acc::Clause::ACCC_if,
0324     llvm::acc::Clause::ACCC_self,
0325   };
0326 
0327   static AccClauseSet allowedExclusiveClauses_ACCD_parallel_loop {
0328     llvm::acc::Clause::ACCC_auto,
0329     llvm::acc::Clause::ACCC_independent,
0330     llvm::acc::Clause::ACCC_seq,
0331   };
0332 
0333   static AccClauseSet requiredClauses_ACCD_parallel_loop {
0334   };
0335 
0336   // Sets for routine
0337 
0338   static AccClauseSet allowedClauses_ACCD_routine {
0339     llvm::acc::Clause::ACCC_bind,
0340     llvm::acc::Clause::ACCC_device_type,
0341     llvm::acc::Clause::ACCC_gang,
0342     llvm::acc::Clause::ACCC_seq,
0343     llvm::acc::Clause::ACCC_vector,
0344     llvm::acc::Clause::ACCC_worker,
0345   };
0346 
0347   static AccClauseSet allowedOnceClauses_ACCD_routine {
0348     llvm::acc::Clause::ACCC_nohost,
0349   };
0350 
0351   static AccClauseSet allowedExclusiveClauses_ACCD_routine {
0352   };
0353 
0354   static AccClauseSet requiredClauses_ACCD_routine {
0355   };
0356 
0357   // Sets for serial
0358 
0359   static AccClauseSet allowedClauses_ACCD_serial {
0360     llvm::acc::Clause::ACCC_attach,
0361     llvm::acc::Clause::ACCC_copy,
0362     llvm::acc::Clause::ACCC_copyin,
0363     llvm::acc::Clause::ACCC_copyout,
0364     llvm::acc::Clause::ACCC_create,
0365     llvm::acc::Clause::ACCC_deviceptr,
0366     llvm::acc::Clause::ACCC_device_type,
0367     llvm::acc::Clause::ACCC_no_create,
0368     llvm::acc::Clause::ACCC_present,
0369     llvm::acc::Clause::ACCC_private,
0370     llvm::acc::Clause::ACCC_firstprivate,
0371     llvm::acc::Clause::ACCC_reduction,
0372     llvm::acc::Clause::ACCC_wait,
0373   };
0374 
0375   static AccClauseSet allowedOnceClauses_ACCD_serial {
0376     llvm::acc::Clause::ACCC_async,
0377     llvm::acc::Clause::ACCC_default,
0378     llvm::acc::Clause::ACCC_if,
0379     llvm::acc::Clause::ACCC_self,
0380   };
0381 
0382   static AccClauseSet allowedExclusiveClauses_ACCD_serial {
0383   };
0384 
0385   static AccClauseSet requiredClauses_ACCD_serial {
0386   };
0387 
0388   // Sets for serial loop
0389 
0390   static AccClauseSet allowedClauses_ACCD_serial_loop {
0391     llvm::acc::Clause::ACCC_attach,
0392     llvm::acc::Clause::ACCC_collapse,
0393     llvm::acc::Clause::ACCC_copy,
0394     llvm::acc::Clause::ACCC_copyin,
0395     llvm::acc::Clause::ACCC_copyout,
0396     llvm::acc::Clause::ACCC_create,
0397     llvm::acc::Clause::ACCC_deviceptr,
0398     llvm::acc::Clause::ACCC_device_type,
0399     llvm::acc::Clause::ACCC_firstprivate,
0400     llvm::acc::Clause::ACCC_gang,
0401     llvm::acc::Clause::ACCC_no_create,
0402     llvm::acc::Clause::ACCC_present,
0403     llvm::acc::Clause::ACCC_private,
0404     llvm::acc::Clause::ACCC_reduction,
0405     llvm::acc::Clause::ACCC_shortloop,
0406     llvm::acc::Clause::ACCC_tile,
0407     llvm::acc::Clause::ACCC_vector,
0408     llvm::acc::Clause::ACCC_wait,
0409     llvm::acc::Clause::ACCC_worker,
0410   };
0411 
0412   static AccClauseSet allowedOnceClauses_ACCD_serial_loop {
0413     llvm::acc::Clause::ACCC_async,
0414     llvm::acc::Clause::ACCC_default,
0415     llvm::acc::Clause::ACCC_if,
0416     llvm::acc::Clause::ACCC_self,
0417   };
0418 
0419   static AccClauseSet allowedExclusiveClauses_ACCD_serial_loop {
0420     llvm::acc::Clause::ACCC_auto,
0421     llvm::acc::Clause::ACCC_independent,
0422     llvm::acc::Clause::ACCC_seq,
0423   };
0424 
0425   static AccClauseSet requiredClauses_ACCD_serial_loop {
0426   };
0427 
0428   // Sets for set
0429 
0430   static AccClauseSet allowedClauses_ACCD_set {
0431   };
0432 
0433   static AccClauseSet allowedOnceClauses_ACCD_set {
0434     llvm::acc::Clause::ACCC_default_async,
0435     llvm::acc::Clause::ACCC_device_num,
0436     llvm::acc::Clause::ACCC_device_type,
0437     llvm::acc::Clause::ACCC_if,
0438   };
0439 
0440   static AccClauseSet allowedExclusiveClauses_ACCD_set {
0441   };
0442 
0443   static AccClauseSet requiredClauses_ACCD_set {
0444     llvm::acc::Clause::ACCC_default_async,
0445     llvm::acc::Clause::ACCC_device_num,
0446     llvm::acc::Clause::ACCC_device_type,
0447   };
0448 
0449   // Sets for shutdown
0450 
0451   static AccClauseSet allowedClauses_ACCD_shutdown {
0452   };
0453 
0454   static AccClauseSet allowedOnceClauses_ACCD_shutdown {
0455     llvm::acc::Clause::ACCC_device_num,
0456     llvm::acc::Clause::ACCC_device_type,
0457     llvm::acc::Clause::ACCC_if,
0458   };
0459 
0460   static AccClauseSet allowedExclusiveClauses_ACCD_shutdown {
0461   };
0462 
0463   static AccClauseSet requiredClauses_ACCD_shutdown {
0464   };
0465 
0466   // Sets for unknown
0467 
0468   static AccClauseSet allowedClauses_ACCD_unknown {
0469   };
0470 
0471   static AccClauseSet allowedOnceClauses_ACCD_unknown {
0472   };
0473 
0474   static AccClauseSet allowedExclusiveClauses_ACCD_unknown {
0475   };
0476 
0477   static AccClauseSet requiredClauses_ACCD_unknown {
0478   };
0479 
0480   // Sets for update
0481 
0482   static AccClauseSet allowedClauses_ACCD_update {
0483     llvm::acc::Clause::ACCC_device_type,
0484     llvm::acc::Clause::ACCC_wait,
0485   };
0486 
0487   static AccClauseSet allowedOnceClauses_ACCD_update {
0488     llvm::acc::Clause::ACCC_async,
0489     llvm::acc::Clause::ACCC_if,
0490     llvm::acc::Clause::ACCC_if_present,
0491   };
0492 
0493   static AccClauseSet allowedExclusiveClauses_ACCD_update {
0494   };
0495 
0496   static AccClauseSet requiredClauses_ACCD_update {
0497     llvm::acc::Clause::ACCC_device,
0498     llvm::acc::Clause::ACCC_host,
0499     llvm::acc::Clause::ACCC_self,
0500   };
0501 
0502   // Sets for wait
0503 
0504   static AccClauseSet allowedClauses_ACCD_wait {
0505   };
0506 
0507   static AccClauseSet allowedOnceClauses_ACCD_wait {
0508     llvm::acc::Clause::ACCC_async,
0509     llvm::acc::Clause::ACCC_if,
0510   };
0511 
0512   static AccClauseSet allowedExclusiveClauses_ACCD_wait {
0513   };
0514 
0515   static AccClauseSet requiredClauses_ACCD_wait {
0516   };
0517 } // namespace acc
0518 } // namespace llvm
0519 
0520 #endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS
0521 
0522 #ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
0523 #undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
0524 
0525 {
0526   {llvm::acc::Directive::ACCD_atomic,
0527     {
0528       llvm::acc::allowedClauses_ACCD_atomic,
0529       llvm::acc::allowedOnceClauses_ACCD_atomic,
0530       llvm::acc::allowedExclusiveClauses_ACCD_atomic,
0531       llvm::acc::requiredClauses_ACCD_atomic,
0532     }
0533   },
0534   {llvm::acc::Directive::ACCD_cache,
0535     {
0536       llvm::acc::allowedClauses_ACCD_cache,
0537       llvm::acc::allowedOnceClauses_ACCD_cache,
0538       llvm::acc::allowedExclusiveClauses_ACCD_cache,
0539       llvm::acc::requiredClauses_ACCD_cache,
0540     }
0541   },
0542   {llvm::acc::Directive::ACCD_data,
0543     {
0544       llvm::acc::allowedClauses_ACCD_data,
0545       llvm::acc::allowedOnceClauses_ACCD_data,
0546       llvm::acc::allowedExclusiveClauses_ACCD_data,
0547       llvm::acc::requiredClauses_ACCD_data,
0548     }
0549   },
0550   {llvm::acc::Directive::ACCD_declare,
0551     {
0552       llvm::acc::allowedClauses_ACCD_declare,
0553       llvm::acc::allowedOnceClauses_ACCD_declare,
0554       llvm::acc::allowedExclusiveClauses_ACCD_declare,
0555       llvm::acc::requiredClauses_ACCD_declare,
0556     }
0557   },
0558   {llvm::acc::Directive::ACCD_enter_data,
0559     {
0560       llvm::acc::allowedClauses_ACCD_enter_data,
0561       llvm::acc::allowedOnceClauses_ACCD_enter_data,
0562       llvm::acc::allowedExclusiveClauses_ACCD_enter_data,
0563       llvm::acc::requiredClauses_ACCD_enter_data,
0564     }
0565   },
0566   {llvm::acc::Directive::ACCD_exit_data,
0567     {
0568       llvm::acc::allowedClauses_ACCD_exit_data,
0569       llvm::acc::allowedOnceClauses_ACCD_exit_data,
0570       llvm::acc::allowedExclusiveClauses_ACCD_exit_data,
0571       llvm::acc::requiredClauses_ACCD_exit_data,
0572     }
0573   },
0574   {llvm::acc::Directive::ACCD_host_data,
0575     {
0576       llvm::acc::allowedClauses_ACCD_host_data,
0577       llvm::acc::allowedOnceClauses_ACCD_host_data,
0578       llvm::acc::allowedExclusiveClauses_ACCD_host_data,
0579       llvm::acc::requiredClauses_ACCD_host_data,
0580     }
0581   },
0582   {llvm::acc::Directive::ACCD_init,
0583     {
0584       llvm::acc::allowedClauses_ACCD_init,
0585       llvm::acc::allowedOnceClauses_ACCD_init,
0586       llvm::acc::allowedExclusiveClauses_ACCD_init,
0587       llvm::acc::requiredClauses_ACCD_init,
0588     }
0589   },
0590   {llvm::acc::Directive::ACCD_kernels,
0591     {
0592       llvm::acc::allowedClauses_ACCD_kernels,
0593       llvm::acc::allowedOnceClauses_ACCD_kernels,
0594       llvm::acc::allowedExclusiveClauses_ACCD_kernels,
0595       llvm::acc::requiredClauses_ACCD_kernels,
0596     }
0597   },
0598   {llvm::acc::Directive::ACCD_kernels_loop,
0599     {
0600       llvm::acc::allowedClauses_ACCD_kernels_loop,
0601       llvm::acc::allowedOnceClauses_ACCD_kernels_loop,
0602       llvm::acc::allowedExclusiveClauses_ACCD_kernels_loop,
0603       llvm::acc::requiredClauses_ACCD_kernels_loop,
0604     }
0605   },
0606   {llvm::acc::Directive::ACCD_loop,
0607     {
0608       llvm::acc::allowedClauses_ACCD_loop,
0609       llvm::acc::allowedOnceClauses_ACCD_loop,
0610       llvm::acc::allowedExclusiveClauses_ACCD_loop,
0611       llvm::acc::requiredClauses_ACCD_loop,
0612     }
0613   },
0614   {llvm::acc::Directive::ACCD_parallel,
0615     {
0616       llvm::acc::allowedClauses_ACCD_parallel,
0617       llvm::acc::allowedOnceClauses_ACCD_parallel,
0618       llvm::acc::allowedExclusiveClauses_ACCD_parallel,
0619       llvm::acc::requiredClauses_ACCD_parallel,
0620     }
0621   },
0622   {llvm::acc::Directive::ACCD_parallel_loop,
0623     {
0624       llvm::acc::allowedClauses_ACCD_parallel_loop,
0625       llvm::acc::allowedOnceClauses_ACCD_parallel_loop,
0626       llvm::acc::allowedExclusiveClauses_ACCD_parallel_loop,
0627       llvm::acc::requiredClauses_ACCD_parallel_loop,
0628     }
0629   },
0630   {llvm::acc::Directive::ACCD_routine,
0631     {
0632       llvm::acc::allowedClauses_ACCD_routine,
0633       llvm::acc::allowedOnceClauses_ACCD_routine,
0634       llvm::acc::allowedExclusiveClauses_ACCD_routine,
0635       llvm::acc::requiredClauses_ACCD_routine,
0636     }
0637   },
0638   {llvm::acc::Directive::ACCD_serial,
0639     {
0640       llvm::acc::allowedClauses_ACCD_serial,
0641       llvm::acc::allowedOnceClauses_ACCD_serial,
0642       llvm::acc::allowedExclusiveClauses_ACCD_serial,
0643       llvm::acc::requiredClauses_ACCD_serial,
0644     }
0645   },
0646   {llvm::acc::Directive::ACCD_serial_loop,
0647     {
0648       llvm::acc::allowedClauses_ACCD_serial_loop,
0649       llvm::acc::allowedOnceClauses_ACCD_serial_loop,
0650       llvm::acc::allowedExclusiveClauses_ACCD_serial_loop,
0651       llvm::acc::requiredClauses_ACCD_serial_loop,
0652     }
0653   },
0654   {llvm::acc::Directive::ACCD_set,
0655     {
0656       llvm::acc::allowedClauses_ACCD_set,
0657       llvm::acc::allowedOnceClauses_ACCD_set,
0658       llvm::acc::allowedExclusiveClauses_ACCD_set,
0659       llvm::acc::requiredClauses_ACCD_set,
0660     }
0661   },
0662   {llvm::acc::Directive::ACCD_shutdown,
0663     {
0664       llvm::acc::allowedClauses_ACCD_shutdown,
0665       llvm::acc::allowedOnceClauses_ACCD_shutdown,
0666       llvm::acc::allowedExclusiveClauses_ACCD_shutdown,
0667       llvm::acc::requiredClauses_ACCD_shutdown,
0668     }
0669   },
0670   {llvm::acc::Directive::ACCD_unknown,
0671     {
0672       llvm::acc::allowedClauses_ACCD_unknown,
0673       llvm::acc::allowedOnceClauses_ACCD_unknown,
0674       llvm::acc::allowedExclusiveClauses_ACCD_unknown,
0675       llvm::acc::requiredClauses_ACCD_unknown,
0676     }
0677   },
0678   {llvm::acc::Directive::ACCD_update,
0679     {
0680       llvm::acc::allowedClauses_ACCD_update,
0681       llvm::acc::allowedOnceClauses_ACCD_update,
0682       llvm::acc::allowedExclusiveClauses_ACCD_update,
0683       llvm::acc::requiredClauses_ACCD_update,
0684     }
0685   },
0686   {llvm::acc::Directive::ACCD_wait,
0687     {
0688       llvm::acc::allowedClauses_ACCD_wait,
0689       llvm::acc::allowedOnceClauses_ACCD_wait,
0690       llvm::acc::allowedExclusiveClauses_ACCD_wait,
0691       llvm::acc::requiredClauses_ACCD_wait,
0692     }
0693   },
0694 }
0695 
0696 #endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
0697 
0698 #ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES
0699 #undef GEN_FLANG_CLAUSE_PARSER_CLASSES
0700 
0701 WRAPPER_CLASS(Async, std::optional<ScalarIntExpr>);
0702 WRAPPER_CLASS(Attach, AccObjectList);
0703 EMPTY_CLASS(Auto);
0704 WRAPPER_CLASS(Bind, AccBindClause);
0705 EMPTY_CLASS(Capture);
0706 WRAPPER_CLASS(Collapse, AccCollapseArg);
0707 WRAPPER_CLASS(Copy, AccObjectList);
0708 WRAPPER_CLASS(Copyin, AccObjectListWithModifier);
0709 WRAPPER_CLASS(Copyout, AccObjectListWithModifier);
0710 WRAPPER_CLASS(Create, AccObjectListWithModifier);
0711 WRAPPER_CLASS(Default, AccDefaultClause);
0712 WRAPPER_CLASS(DefaultAsync, ScalarIntExpr);
0713 WRAPPER_CLASS(Delete, AccObjectList);
0714 WRAPPER_CLASS(Detach, AccObjectList);
0715 WRAPPER_CLASS(Device, AccObjectList);
0716 WRAPPER_CLASS(DeviceNum, ScalarIntExpr);
0717 WRAPPER_CLASS(Deviceptr, AccObjectList);
0718 WRAPPER_CLASS(DeviceResident, AccObjectList);
0719 WRAPPER_CLASS(DeviceType, AccDeviceTypeExprList);
0720 EMPTY_CLASS(Finalize);
0721 WRAPPER_CLASS(Firstprivate, AccObjectList);
0722 WRAPPER_CLASS(Gang, std::optional<AccGangArgList>);
0723 WRAPPER_CLASS(Host, AccObjectList);
0724 WRAPPER_CLASS(If, ScalarExpr);
0725 EMPTY_CLASS(IfPresent);
0726 EMPTY_CLASS(Independent);
0727 WRAPPER_CLASS(Link, AccObjectList);
0728 WRAPPER_CLASS(NoCreate, AccObjectList);
0729 EMPTY_CLASS(Nohost);
0730 WRAPPER_CLASS(NumGangs, std::list<ScalarIntExpr>);
0731 WRAPPER_CLASS(NumWorkers, ScalarIntExpr);
0732 WRAPPER_CLASS(Present, AccObjectList);
0733 WRAPPER_CLASS(Private, AccObjectList);
0734 EMPTY_CLASS(Read);
0735 WRAPPER_CLASS(Reduction, AccObjectListWithReduction);
0736 WRAPPER_CLASS(Self, std::optional<AccSelfClause>);
0737 EMPTY_CLASS(Seq);
0738 EMPTY_CLASS(Shortloop);
0739 WRAPPER_CLASS(Tile, AccTileExprList);
0740 EMPTY_CLASS(Unknown);
0741 WRAPPER_CLASS(UseDevice, AccObjectList);
0742 WRAPPER_CLASS(Vector, std::optional<ScalarIntExpr>);
0743 WRAPPER_CLASS(VectorLength, ScalarIntExpr);
0744 WRAPPER_CLASS(Wait, std::optional<AccWaitArgument>);
0745 WRAPPER_CLASS(Worker, std::optional<ScalarIntExpr>);
0746 EMPTY_CLASS(Write);
0747 
0748 #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
0749 
0750 #ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
0751 #undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
0752 
0753 Async
0754 , Attach
0755 , Auto
0756 , Bind
0757 , Capture
0758 , Collapse
0759 , Copy
0760 , Copyin
0761 , Copyout
0762 , Create
0763 , Default
0764 , DefaultAsync
0765 , Delete
0766 , Detach
0767 , Device
0768 , DeviceNum
0769 , Deviceptr
0770 , DeviceResident
0771 , DeviceType
0772 , Finalize
0773 , Firstprivate
0774 , Gang
0775 , Host
0776 , If
0777 , IfPresent
0778 , Independent
0779 , Link
0780 , NoCreate
0781 , Nohost
0782 , NumGangs
0783 , NumWorkers
0784 , Present
0785 , Private
0786 , Read
0787 , Reduction
0788 , Self
0789 , Seq
0790 , Shortloop
0791 , Tile
0792 , Unknown
0793 , UseDevice
0794 , Vector
0795 , VectorLength
0796 , Wait
0797 , Worker
0798 , Write
0799 
0800 #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
0801 
0802 #ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
0803 #undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
0804 
0805 NODE(AccClause, Async)
0806 NODE(AccClause, Attach)
0807 NODE(AccClause, Auto)
0808 NODE(AccClause, Bind)
0809 NODE(AccClause, Capture)
0810 NODE(AccClause, Collapse)
0811 NODE(AccClause, Copy)
0812 NODE(AccClause, Copyin)
0813 NODE(AccClause, Copyout)
0814 NODE(AccClause, Create)
0815 NODE(AccClause, Default)
0816 NODE(AccClause, DefaultAsync)
0817 NODE(AccClause, Delete)
0818 NODE(AccClause, Detach)
0819 NODE(AccClause, Device)
0820 NODE(AccClause, DeviceNum)
0821 NODE(AccClause, Deviceptr)
0822 NODE(AccClause, DeviceResident)
0823 NODE(AccClause, DeviceType)
0824 NODE(AccClause, Finalize)
0825 NODE(AccClause, Firstprivate)
0826 NODE(AccClause, Gang)
0827 NODE(AccClause, Host)
0828 NODE(AccClause, If)
0829 NODE(AccClause, IfPresent)
0830 NODE(AccClause, Independent)
0831 NODE(AccClause, Link)
0832 NODE(AccClause, NoCreate)
0833 NODE(AccClause, Nohost)
0834 NODE(AccClause, NumGangs)
0835 NODE(AccClause, NumWorkers)
0836 NODE(AccClause, Present)
0837 NODE(AccClause, Private)
0838 NODE(AccClause, Read)
0839 NODE(AccClause, Reduction)
0840 NODE(AccClause, Self)
0841 NODE(AccClause, Seq)
0842 NODE(AccClause, Shortloop)
0843 NODE(AccClause, Tile)
0844 NODE(AccClause, Unknown)
0845 NODE(AccClause, UseDevice)
0846 NODE(AccClause, Vector)
0847 NODE(AccClause, VectorLength)
0848 NODE(AccClause, Wait)
0849 NODE(AccClause, Worker)
0850 NODE(AccClause, Write)
0851 
0852 #endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
0853 
0854 #ifdef GEN_FLANG_CLAUSE_UNPARSE
0855 #undef GEN_FLANG_CLAUSE_UNPARSE
0856 
0857 void Unparse(const AccClause::Async &x) {
0858   Word("ASYNC");
0859   Walk("(", x.v, ")");
0860 }
0861 void Unparse(const AccClause::Attach &x) {
0862   Word("ATTACH");
0863   Put("(");
0864   Walk(x.v);
0865   Put(")");
0866 }
0867 void Before(const AccClause::Auto &) { Word("AUTO"); }
0868 void Unparse(const AccClause::Bind &x) {
0869   Word("BIND");
0870   Put("(");
0871   Walk(x.v);
0872   Put(")");
0873 }
0874 void Before(const AccClause::Capture &) { Word("CAPTURE"); }
0875 void Unparse(const AccClause::Collapse &x) {
0876   Word("COLLAPSE");
0877   Put("(");
0878   Walk(x.v);
0879   Put(")");
0880 }
0881 void Unparse(const AccClause::Copy &x) {
0882   Word("COPY");
0883   Put("(");
0884   Walk(x.v);
0885   Put(")");
0886 }
0887 void Unparse(const AccClause::Copyin &x) {
0888   Word("COPYIN");
0889   Put("(");
0890   Walk(x.v);
0891   Put(")");
0892 }
0893 void Unparse(const AccClause::Copyout &x) {
0894   Word("COPYOUT");
0895   Put("(");
0896   Walk(x.v);
0897   Put(")");
0898 }
0899 void Unparse(const AccClause::Create &x) {
0900   Word("CREATE");
0901   Put("(");
0902   Walk(x.v);
0903   Put(")");
0904 }
0905 void Unparse(const AccClause::Default &x) {
0906   Word("DEFAULT");
0907   Put("(");
0908   Walk(x.v);
0909   Put(")");
0910 }
0911 void Unparse(const AccClause::DefaultAsync &x) {
0912   Word("DEFAULT_ASYNC");
0913   Put("(");
0914   Walk(x.v);
0915   Put(")");
0916 }
0917 void Unparse(const AccClause::Delete &x) {
0918   Word("DELETE");
0919   Put("(");
0920   Walk(x.v);
0921   Put(")");
0922 }
0923 void Unparse(const AccClause::Detach &x) {
0924   Word("DETACH");
0925   Put("(");
0926   Walk(x.v);
0927   Put(")");
0928 }
0929 void Unparse(const AccClause::Device &x) {
0930   Word("DEVICE");
0931   Put("(");
0932   Walk(x.v);
0933   Put(")");
0934 }
0935 void Unparse(const AccClause::DeviceNum &x) {
0936   Word("DEVICE_NUM");
0937   Put("(");
0938   Walk(x.v);
0939   Put(")");
0940 }
0941 void Unparse(const AccClause::Deviceptr &x) {
0942   Word("DEVICEPTR");
0943   Put("(");
0944   Walk(x.v);
0945   Put(")");
0946 }
0947 void Unparse(const AccClause::DeviceResident &x) {
0948   Word("DEVICE_RESIDENT");
0949   Put("(");
0950   Walk(x.v);
0951   Put(")");
0952 }
0953 void Unparse(const AccClause::DeviceType &x) {
0954   Word("DEVICE_TYPE");
0955   Put("(");
0956   Walk(x.v);
0957   Put(")");
0958 }
0959 void Before(const AccClause::Finalize &) { Word("FINALIZE"); }
0960 void Unparse(const AccClause::Firstprivate &x) {
0961   Word("FIRSTPRIVATE");
0962   Put("(");
0963   Walk(x.v);
0964   Put(")");
0965 }
0966 void Unparse(const AccClause::Gang &x) {
0967   Word("GANG");
0968   Walk("(", x.v, ")");
0969 }
0970 void Unparse(const AccClause::Host &x) {
0971   Word("HOST");
0972   Put("(");
0973   Walk(x.v);
0974   Put(")");
0975 }
0976 void Unparse(const AccClause::If &x) {
0977   Word("IF");
0978   Put("(");
0979   Walk(x.v);
0980   Put(")");
0981 }
0982 void Before(const AccClause::IfPresent &) { Word("IF_PRESENT"); }
0983 void Before(const AccClause::Independent &) { Word("INDEPENDENT"); }
0984 void Unparse(const AccClause::Link &x) {
0985   Word("LINK");
0986   Put("(");
0987   Walk(x.v);
0988   Put(")");
0989 }
0990 void Unparse(const AccClause::NoCreate &x) {
0991   Word("NO_CREATE");
0992   Put("(");
0993   Walk(x.v);
0994   Put(")");
0995 }
0996 void Before(const AccClause::Nohost &) { Word("NOHOST"); }
0997 void Unparse(const AccClause::NumGangs &x) {
0998   Word("NUM_GANGS");
0999   Put("(");
1000   Walk(x.v, ",");
1001   Put(")");
1002 }
1003 void Unparse(const AccClause::NumWorkers &x) {
1004   Word("NUM_WORKERS");
1005   Put("(");
1006   Walk(x.v);
1007   Put(")");
1008 }
1009 void Unparse(const AccClause::Present &x) {
1010   Word("PRESENT");
1011   Put("(");
1012   Walk(x.v);
1013   Put(")");
1014 }
1015 void Unparse(const AccClause::Private &x) {
1016   Word("PRIVATE");
1017   Put("(");
1018   Walk(x.v);
1019   Put(")");
1020 }
1021 void Before(const AccClause::Read &) { Word("READ"); }
1022 void Unparse(const AccClause::Reduction &x) {
1023   Word("REDUCTION");
1024   Put("(");
1025   Walk(x.v);
1026   Put(")");
1027 }
1028 void Unparse(const AccClause::Self &x) {
1029   Word("SELF");
1030   Walk("(", x.v, ")");
1031 }
1032 void Before(const AccClause::Seq &) { Word("SEQ"); }
1033 void Before(const AccClause::Shortloop &) { Word("SHORTLOOP"); }
1034 void Unparse(const AccClause::Tile &x) {
1035   Word("TILE");
1036   Put("(");
1037   Walk(x.v);
1038   Put(")");
1039 }
1040 void Before(const AccClause::Unknown &) { Word("UNKNOWN"); }
1041 void Unparse(const AccClause::UseDevice &x) {
1042   Word("USE_DEVICE");
1043   Put("(");
1044   Walk(x.v);
1045   Put(")");
1046 }
1047 void Unparse(const AccClause::Vector &x) {
1048   Word("VECTOR");
1049   Walk("(", x.v, ")");
1050 }
1051 void Unparse(const AccClause::VectorLength &x) {
1052   Word("VECTOR_LENGTH");
1053   Put("(");
1054   Walk(x.v);
1055   Put(")");
1056 }
1057 void Unparse(const AccClause::Wait &x) {
1058   Word("WAIT");
1059   Walk("(", x.v, ")");
1060 }
1061 void Unparse(const AccClause::Worker &x) {
1062   Word("WORKER");
1063   Walk("(", x.v, ")");
1064 }
1065 void Before(const AccClause::Write &) { Word("WRITE"); }
1066 
1067 #endif // GEN_FLANG_CLAUSE_UNPARSE
1068 
1069 #ifdef GEN_FLANG_CLAUSE_CHECK_ENTER
1070 #undef GEN_FLANG_CLAUSE_CHECK_ENTER
1071 
1072 void Enter(const parser::AccClause::Async &);
1073 void Enter(const parser::AccClause::Attach &);
1074 void Enter(const parser::AccClause::Auto &);
1075 void Enter(const parser::AccClause::Bind &);
1076 void Enter(const parser::AccClause::Capture &);
1077 void Enter(const parser::AccClause::Collapse &);
1078 void Enter(const parser::AccClause::Copy &);
1079 void Enter(const parser::AccClause::Copyin &);
1080 void Enter(const parser::AccClause::Copyout &);
1081 void Enter(const parser::AccClause::Create &);
1082 void Enter(const parser::AccClause::Default &);
1083 void Enter(const parser::AccClause::DefaultAsync &);
1084 void Enter(const parser::AccClause::Delete &);
1085 void Enter(const parser::AccClause::Detach &);
1086 void Enter(const parser::AccClause::Device &);
1087 void Enter(const parser::AccClause::DeviceNum &);
1088 void Enter(const parser::AccClause::Deviceptr &);
1089 void Enter(const parser::AccClause::DeviceResident &);
1090 void Enter(const parser::AccClause::DeviceType &);
1091 void Enter(const parser::AccClause::Finalize &);
1092 void Enter(const parser::AccClause::Firstprivate &);
1093 void Enter(const parser::AccClause::Gang &);
1094 void Enter(const parser::AccClause::Host &);
1095 void Enter(const parser::AccClause::If &);
1096 void Enter(const parser::AccClause::IfPresent &);
1097 void Enter(const parser::AccClause::Independent &);
1098 void Enter(const parser::AccClause::Link &);
1099 void Enter(const parser::AccClause::NoCreate &);
1100 void Enter(const parser::AccClause::Nohost &);
1101 void Enter(const parser::AccClause::NumGangs &);
1102 void Enter(const parser::AccClause::NumWorkers &);
1103 void Enter(const parser::AccClause::Present &);
1104 void Enter(const parser::AccClause::Private &);
1105 void Enter(const parser::AccClause::Read &);
1106 void Enter(const parser::AccClause::Reduction &);
1107 void Enter(const parser::AccClause::Self &);
1108 void Enter(const parser::AccClause::Seq &);
1109 void Enter(const parser::AccClause::Shortloop &);
1110 void Enter(const parser::AccClause::Tile &);
1111 void Enter(const parser::AccClause::Unknown &);
1112 void Enter(const parser::AccClause::UseDevice &);
1113 void Enter(const parser::AccClause::Vector &);
1114 void Enter(const parser::AccClause::VectorLength &);
1115 void Enter(const parser::AccClause::Wait &);
1116 void Enter(const parser::AccClause::Worker &);
1117 void Enter(const parser::AccClause::Write &);
1118 
1119 #endif // GEN_FLANG_CLAUSE_CHECK_ENTER
1120 
1121 #ifdef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
1122 #undef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
1123 
1124 if constexpr (std::is_same_v<A, parser::AccClause::Async>)
1125   return llvm::acc::Clause::ACCC_async;
1126 if constexpr (std::is_same_v<A, parser::AccClause::Attach>)
1127   return llvm::acc::Clause::ACCC_attach;
1128 if constexpr (std::is_same_v<A, parser::AccClause::Auto>)
1129   return llvm::acc::Clause::ACCC_auto;
1130 if constexpr (std::is_same_v<A, parser::AccClause::Bind>)
1131   return llvm::acc::Clause::ACCC_bind;
1132 if constexpr (std::is_same_v<A, parser::AccClause::Capture>)
1133   return llvm::acc::Clause::ACCC_capture;
1134 if constexpr (std::is_same_v<A, parser::AccClause::Collapse>)
1135   return llvm::acc::Clause::ACCC_collapse;
1136 if constexpr (std::is_same_v<A, parser::AccClause::Copy>)
1137   return llvm::acc::Clause::ACCC_copy;
1138 if constexpr (std::is_same_v<A, parser::AccClause::Copyin>)
1139   return llvm::acc::Clause::ACCC_copyin;
1140 if constexpr (std::is_same_v<A, parser::AccClause::Copyout>)
1141   return llvm::acc::Clause::ACCC_copyout;
1142 if constexpr (std::is_same_v<A, parser::AccClause::Create>)
1143   return llvm::acc::Clause::ACCC_create;
1144 if constexpr (std::is_same_v<A, parser::AccClause::Default>)
1145   return llvm::acc::Clause::ACCC_default;
1146 if constexpr (std::is_same_v<A, parser::AccClause::DefaultAsync>)
1147   return llvm::acc::Clause::ACCC_default_async;
1148 if constexpr (std::is_same_v<A, parser::AccClause::Delete>)
1149   return llvm::acc::Clause::ACCC_delete;
1150 if constexpr (std::is_same_v<A, parser::AccClause::Detach>)
1151   return llvm::acc::Clause::ACCC_detach;
1152 if constexpr (std::is_same_v<A, parser::AccClause::Device>)
1153   return llvm::acc::Clause::ACCC_device;
1154 if constexpr (std::is_same_v<A, parser::AccClause::DeviceNum>)
1155   return llvm::acc::Clause::ACCC_device_num;
1156 if constexpr (std::is_same_v<A, parser::AccClause::Deviceptr>)
1157   return llvm::acc::Clause::ACCC_deviceptr;
1158 if constexpr (std::is_same_v<A, parser::AccClause::DeviceResident>)
1159   return llvm::acc::Clause::ACCC_device_resident;
1160 if constexpr (std::is_same_v<A, parser::AccClause::DeviceType>)
1161   return llvm::acc::Clause::ACCC_device_type;
1162 if constexpr (std::is_same_v<A, parser::AccClause::Finalize>)
1163   return llvm::acc::Clause::ACCC_finalize;
1164 if constexpr (std::is_same_v<A, parser::AccClause::Firstprivate>)
1165   return llvm::acc::Clause::ACCC_firstprivate;
1166 if constexpr (std::is_same_v<A, parser::AccClause::Gang>)
1167   return llvm::acc::Clause::ACCC_gang;
1168 if constexpr (std::is_same_v<A, parser::AccClause::Host>)
1169   return llvm::acc::Clause::ACCC_host;
1170 if constexpr (std::is_same_v<A, parser::AccClause::If>)
1171   return llvm::acc::Clause::ACCC_if;
1172 if constexpr (std::is_same_v<A, parser::AccClause::IfPresent>)
1173   return llvm::acc::Clause::ACCC_if_present;
1174 if constexpr (std::is_same_v<A, parser::AccClause::Independent>)
1175   return llvm::acc::Clause::ACCC_independent;
1176 if constexpr (std::is_same_v<A, parser::AccClause::Link>)
1177   return llvm::acc::Clause::ACCC_link;
1178 if constexpr (std::is_same_v<A, parser::AccClause::NoCreate>)
1179   return llvm::acc::Clause::ACCC_no_create;
1180 if constexpr (std::is_same_v<A, parser::AccClause::Nohost>)
1181   return llvm::acc::Clause::ACCC_nohost;
1182 if constexpr (std::is_same_v<A, parser::AccClause::NumGangs>)
1183   return llvm::acc::Clause::ACCC_num_gangs;
1184 if constexpr (std::is_same_v<A, parser::AccClause::NumWorkers>)
1185   return llvm::acc::Clause::ACCC_num_workers;
1186 if constexpr (std::is_same_v<A, parser::AccClause::Present>)
1187   return llvm::acc::Clause::ACCC_present;
1188 if constexpr (std::is_same_v<A, parser::AccClause::Private>)
1189   return llvm::acc::Clause::ACCC_private;
1190 if constexpr (std::is_same_v<A, parser::AccClause::Read>)
1191   return llvm::acc::Clause::ACCC_read;
1192 if constexpr (std::is_same_v<A, parser::AccClause::Reduction>)
1193   return llvm::acc::Clause::ACCC_reduction;
1194 if constexpr (std::is_same_v<A, parser::AccClause::Self>)
1195   return llvm::acc::Clause::ACCC_self;
1196 if constexpr (std::is_same_v<A, parser::AccClause::Seq>)
1197   return llvm::acc::Clause::ACCC_seq;
1198 if constexpr (std::is_same_v<A, parser::AccClause::Shortloop>)
1199   return llvm::acc::Clause::ACCC_shortloop;
1200 if constexpr (std::is_same_v<A, parser::AccClause::Tile>)
1201   return llvm::acc::Clause::ACCC_tile;
1202 if constexpr (std::is_same_v<A, parser::AccClause::Unknown>)
1203   return llvm::acc::Clause::ACCC_unknown;
1204 if constexpr (std::is_same_v<A, parser::AccClause::UseDevice>)
1205   return llvm::acc::Clause::ACCC_use_device;
1206 if constexpr (std::is_same_v<A, parser::AccClause::Vector>)
1207   return llvm::acc::Clause::ACCC_vector;
1208 if constexpr (std::is_same_v<A, parser::AccClause::VectorLength>)
1209   return llvm::acc::Clause::ACCC_vector_length;
1210 if constexpr (std::is_same_v<A, parser::AccClause::Wait>)
1211   return llvm::acc::Clause::ACCC_wait;
1212 if constexpr (std::is_same_v<A, parser::AccClause::Worker>)
1213   return llvm::acc::Clause::ACCC_worker;
1214 if constexpr (std::is_same_v<A, parser::AccClause::Write>)
1215   return llvm::acc::Clause::ACCC_write;
1216 llvm_unreachable("Invalid OpenACC Parser clause");
1217 
1218 #endif // GEN_FLANG_CLAUSE_PARSER_KIND_MAP
1219 
1220 #ifdef GEN_FLANG_CLAUSES_PARSER
1221 #undef GEN_FLANG_CLAUSES_PARSER
1222 
1223 TYPE_PARSER(
1224   "write" >> construct<AccClause>(construct<AccClause::Write>()) ||
1225   "worker" >> construct<AccClause>(construct<AccClause::Worker>(maybe(parenthesized("num:" >> scalarIntExpr || scalarIntExpr)))) ||
1226   "wait" >> construct<AccClause>(construct<AccClause::Wait>(maybe(parenthesized(Parser<AccWaitArgument>{})))) ||
1227   "vector_length" >> construct<AccClause>(construct<AccClause::VectorLength>(parenthesized(scalarIntExpr))) ||
1228   "vector" >> construct<AccClause>(construct<AccClause::Vector>(maybe(parenthesized("length:" >> scalarIntExpr || scalarIntExpr)))) ||
1229   "use_device" >> construct<AccClause>(construct<AccClause::UseDevice>(parenthesized(Parser<AccObjectList>{}))) ||
1230   "unknown" >> construct<AccClause>(construct<AccClause::Unknown>()) ||
1231   "tile" >> construct<AccClause>(construct<AccClause::Tile>(parenthesized(Parser<AccTileExprList>{}))) ||
1232   "shortloop" >> construct<AccClause>(construct<AccClause::Shortloop>()) ||
1233   "seq" >> construct<AccClause>(construct<AccClause::Seq>()) ||
1234   "self" >> construct<AccClause>(construct<AccClause::Self>(maybe(parenthesized(Parser<AccSelfClause>{})))) ||
1235   "reduction" >> construct<AccClause>(construct<AccClause::Reduction>(parenthesized(Parser<AccObjectListWithReduction>{}))) ||
1236   "read" >> construct<AccClause>(construct<AccClause::Read>()) ||
1237   "private" >> construct<AccClause>(construct<AccClause::Private>(parenthesized(Parser<AccObjectList>{}))) ||
1238   "present" >> construct<AccClause>(construct<AccClause::Present>(parenthesized(Parser<AccObjectList>{}))) ||
1239   "num_workers" >> construct<AccClause>(construct<AccClause::NumWorkers>(parenthesized(scalarIntExpr))) ||
1240   "num_gangs" >> construct<AccClause>(construct<AccClause::NumGangs>(parenthesized(nonemptyList(scalarIntExpr)))) ||
1241   "nohost" >> construct<AccClause>(construct<AccClause::Nohost>()) ||
1242   "no_create" >> construct<AccClause>(construct<AccClause::NoCreate>(parenthesized(Parser<AccObjectList>{}))) ||
1243   "link" >> construct<AccClause>(construct<AccClause::Link>(parenthesized(Parser<AccObjectList>{}))) ||
1244   "independent" >> construct<AccClause>(construct<AccClause::Independent>()) ||
1245   "if_present" >> construct<AccClause>(construct<AccClause::IfPresent>()) ||
1246   "if" >> construct<AccClause>(construct<AccClause::If>(parenthesized(scalarExpr))) ||
1247   "host" >> construct<AccClause>(construct<AccClause::Host>(parenthesized(Parser<AccObjectList>{}))) ||
1248   "gang" >> construct<AccClause>(construct<AccClause::Gang>(maybe(parenthesized(Parser<AccGangArgList>{})))) ||
1249   "firstprivate" >> construct<AccClause>(construct<AccClause::Firstprivate>(parenthesized(Parser<AccObjectList>{}))) ||
1250   "finalize" >> construct<AccClause>(construct<AccClause::Finalize>()) ||
1251   "deviceptr" >> construct<AccClause>(construct<AccClause::Deviceptr>(parenthesized(Parser<AccObjectList>{}))) ||
1252   ("device_type"_tok || "dtype"_tok) >> construct<AccClause>(construct<AccClause::DeviceType>(parenthesized(Parser<AccDeviceTypeExprList>{}))) ||
1253   "device_resident" >> construct<AccClause>(construct<AccClause::DeviceResident>(parenthesized(Parser<AccObjectList>{}))) ||
1254   "device_num" >> construct<AccClause>(construct<AccClause::DeviceNum>(parenthesized(scalarIntExpr))) ||
1255   "device" >> construct<AccClause>(construct<AccClause::Device>(parenthesized(Parser<AccObjectList>{}))) ||
1256   "detach" >> construct<AccClause>(construct<AccClause::Detach>(parenthesized(Parser<AccObjectList>{}))) ||
1257   "delete" >> construct<AccClause>(construct<AccClause::Delete>(parenthesized(Parser<AccObjectList>{}))) ||
1258   "default_async" >> construct<AccClause>(construct<AccClause::DefaultAsync>(parenthesized(scalarIntExpr))) ||
1259   "default" >> construct<AccClause>(construct<AccClause::Default>(parenthesized(Parser<AccDefaultClause>{}))) ||
1260   ("create"_tok || "present_or_create"_tok || "pcreate"_tok) >> construct<AccClause>(construct<AccClause::Create>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1261   ("copyout"_tok || "present_or_copyout"_tok || "pcopyout"_tok) >> construct<AccClause>(construct<AccClause::Copyout>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1262   ("copyin"_tok || "present_or_copyin"_tok || "pcopyin"_tok) >> construct<AccClause>(construct<AccClause::Copyin>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1263   ("copy"_tok || "present_or_copy"_tok || "pcopy"_tok) >> construct<AccClause>(construct<AccClause::Copy>(parenthesized(Parser<AccObjectList>{}))) ||
1264   "collapse" >> construct<AccClause>(construct<AccClause::Collapse>(parenthesized(Parser<AccCollapseArg>{}))) ||
1265   "capture" >> construct<AccClause>(construct<AccClause::Capture>()) ||
1266   "bind" >> construct<AccClause>(construct<AccClause::Bind>(parenthesized(Parser<AccBindClause>{}))) ||
1267   "auto" >> construct<AccClause>(construct<AccClause::Auto>()) ||
1268   "attach" >> construct<AccClause>(construct<AccClause::Attach>(parenthesized(Parser<AccObjectList>{}))) ||
1269   "async" >> construct<AccClause>(construct<AccClause::Async>(maybe(parenthesized(scalarIntExpr))))
1270 )
1271 
1272 #endif // GEN_FLANG_CLAUSES_PARSER
1273 
1274 #ifdef GEN_CLANG_CLAUSE_CLASS
1275 #undef GEN_CLANG_CLAUSE_CLASS
1276 
1277 #ifndef CLAUSE
1278 #define CLAUSE(Enum, Str, Implicit)
1279 #endif
1280 #ifndef CLAUSE_CLASS
1281 #define CLAUSE_CLASS(Enum, Str, Class)
1282 #endif
1283 #ifndef CLAUSE_NO_CLASS
1284 #define CLAUSE_NO_CLASS(Enum, Str)
1285 #endif
1286 
1287 #define __CLAUSE(Name, Class)                      \
1288   CLAUSE(ACCC_##Name, #Name, /* Implicit */ false) \
1289   CLAUSE_CLASS(ACCC_##Name, #Name, Class)
1290 #define __CLAUSE_NO_CLASS(Name)                    \
1291   CLAUSE(ACCC_##Name, #Name, /* Implicit */ false) \
1292   CLAUSE_NO_CLASS(ACCC_##Name, #Name)
1293 #define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class)  \
1294   CLAUSE(ACCC_##Name, Str, /* Implicit */ true)    \
1295   CLAUSE_CLASS(ACCC_##Name, Str, Class)
1296 #define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \
1297   CLAUSE(ACCC_##Name, Str, /* Implicit */ true)    \
1298   CLAUSE_NO_CLASS(ACCC_##Name, Str)
1299 
1300 __CLAUSE_NO_CLASS(async)
1301 __CLAUSE_NO_CLASS(attach)
1302 __CLAUSE_NO_CLASS(auto)
1303 __CLAUSE_NO_CLASS(bind)
1304 __CLAUSE_NO_CLASS(capture)
1305 __CLAUSE_NO_CLASS(collapse)
1306 __CLAUSE_NO_CLASS(copy)
1307 __CLAUSE_NO_CLASS(copyin)
1308 __CLAUSE_NO_CLASS(copyout)
1309 __CLAUSE_NO_CLASS(create)
1310 __CLAUSE_NO_CLASS(default)
1311 __CLAUSE_NO_CLASS(default_async)
1312 __CLAUSE_NO_CLASS(delete)
1313 __CLAUSE_NO_CLASS(detach)
1314 __CLAUSE_NO_CLASS(device)
1315 __CLAUSE_NO_CLASS(device_num)
1316 __CLAUSE_NO_CLASS(deviceptr)
1317 __CLAUSE_NO_CLASS(device_resident)
1318 __CLAUSE_NO_CLASS(device_type)
1319 __CLAUSE_NO_CLASS(finalize)
1320 __CLAUSE_NO_CLASS(firstprivate)
1321 __CLAUSE_NO_CLASS(gang)
1322 __CLAUSE_NO_CLASS(host)
1323 __CLAUSE_NO_CLASS(if)
1324 __CLAUSE_NO_CLASS(if_present)
1325 __CLAUSE_NO_CLASS(independent)
1326 __CLAUSE_NO_CLASS(link)
1327 __CLAUSE_NO_CLASS(no_create)
1328 __CLAUSE_NO_CLASS(nohost)
1329 __CLAUSE_NO_CLASS(num_gangs)
1330 __CLAUSE_NO_CLASS(num_workers)
1331 __CLAUSE_NO_CLASS(present)
1332 __CLAUSE_NO_CLASS(private)
1333 __CLAUSE_NO_CLASS(read)
1334 __CLAUSE_NO_CLASS(reduction)
1335 __CLAUSE_NO_CLASS(self)
1336 __CLAUSE_NO_CLASS(seq)
1337 __CLAUSE_NO_CLASS(shortloop)
1338 __CLAUSE_NO_CLASS(tile)
1339 __CLAUSE_NO_CLASS(unknown)
1340 __CLAUSE_NO_CLASS(use_device)
1341 __CLAUSE_NO_CLASS(vector)
1342 __CLAUSE_NO_CLASS(vector_length)
1343 __CLAUSE_NO_CLASS(wait)
1344 __CLAUSE_NO_CLASS(worker)
1345 __CLAUSE_NO_CLASS(write)
1346 
1347 #undef __IMPLICIT_CLAUSE_NO_CLASS
1348 #undef __IMPLICIT_CLAUSE_CLASS
1349 #undef __CLAUSE_NO_CLASS
1350 #undef __CLAUSE
1351 #undef CLAUSE_NO_CLASS
1352 #undef CLAUSE_CLASS
1353 #undef CLAUSE
1354 
1355 #endif // GEN_CLANG_CLAUSE_CLASS
1356 
1357 #ifdef GEN_DIRECTIVES_IMPL
1358 #undef GEN_DIRECTIVES_IMPL
1359 
1360 #include "llvm/Support/ErrorHandling.h"
1361 
1362 Directive llvm::acc::getOpenACCDirectiveKind(llvm::StringRef Str) {
1363   return llvm::StringSwitch<Directive>(Str)
1364     .Case("atomic",ACCD_atomic)
1365     .Case("cache",ACCD_cache)
1366     .Case("data",ACCD_data)
1367     .Case("declare",ACCD_declare)
1368     .Case("enter data",ACCD_enter_data)
1369     .Case("exit data",ACCD_exit_data)
1370     .Case("host_data",ACCD_host_data)
1371     .Case("init",ACCD_init)
1372     .Case("kernels",ACCD_kernels)
1373     .Case("kernels loop",ACCD_kernels_loop)
1374     .Case("loop",ACCD_loop)
1375     .Case("parallel",ACCD_parallel)
1376     .Case("parallel loop",ACCD_parallel_loop)
1377     .Case("routine",ACCD_routine)
1378     .Case("serial",ACCD_serial)
1379     .Case("serial loop",ACCD_serial_loop)
1380     .Case("set",ACCD_set)
1381     .Case("shutdown",ACCD_shutdown)
1382     .Case("unknown",ACCD_unknown)
1383     .Case("update",ACCD_update)
1384     .Case("wait",ACCD_wait)
1385     .Default(ACCD_unknown);
1386 }
1387 
1388 llvm::StringRef llvm::acc::getOpenACCDirectiveName(Directive Kind) {
1389   switch (Kind) {
1390     case ACCD_atomic:
1391       return "atomic";
1392     case ACCD_cache:
1393       return "cache";
1394     case ACCD_data:
1395       return "data";
1396     case ACCD_declare:
1397       return "declare";
1398     case ACCD_enter_data:
1399       return "enter data";
1400     case ACCD_exit_data:
1401       return "exit data";
1402     case ACCD_host_data:
1403       return "host_data";
1404     case ACCD_init:
1405       return "init";
1406     case ACCD_kernels:
1407       return "kernels";
1408     case ACCD_kernels_loop:
1409       return "kernels loop";
1410     case ACCD_loop:
1411       return "loop";
1412     case ACCD_parallel:
1413       return "parallel";
1414     case ACCD_parallel_loop:
1415       return "parallel loop";
1416     case ACCD_routine:
1417       return "routine";
1418     case ACCD_serial:
1419       return "serial";
1420     case ACCD_serial_loop:
1421       return "serial loop";
1422     case ACCD_set:
1423       return "set";
1424     case ACCD_shutdown:
1425       return "shutdown";
1426     case ACCD_unknown:
1427       return "unknown";
1428     case ACCD_update:
1429       return "update";
1430     case ACCD_wait:
1431       return "wait";
1432   }
1433   llvm_unreachable("Invalid OpenACC Directive kind");
1434 }
1435 
1436 Clause llvm::acc::getOpenACCClauseKind(llvm::StringRef Str) {
1437   return llvm::StringSwitch<Clause>(Str)
1438     .Case("async",ACCC_async)
1439     .Case("attach",ACCC_attach)
1440     .Case("auto",ACCC_auto)
1441     .Case("bind",ACCC_bind)
1442     .Case("capture",ACCC_capture)
1443     .Case("collapse",ACCC_collapse)
1444     .Case("copy",ACCC_copy)
1445     .Case("copyin",ACCC_copyin)
1446     .Case("copyout",ACCC_copyout)
1447     .Case("create",ACCC_create)
1448     .Case("default",ACCC_default)
1449     .Case("default_async",ACCC_default_async)
1450     .Case("delete",ACCC_delete)
1451     .Case("detach",ACCC_detach)
1452     .Case("device",ACCC_device)
1453     .Case("device_num",ACCC_device_num)
1454     .Case("deviceptr",ACCC_deviceptr)
1455     .Case("device_resident",ACCC_device_resident)
1456     .Case("device_type",ACCC_device_type)
1457     .Case("finalize",ACCC_finalize)
1458     .Case("firstprivate",ACCC_firstprivate)
1459     .Case("gang",ACCC_gang)
1460     .Case("host",ACCC_host)
1461     .Case("if",ACCC_if)
1462     .Case("if_present",ACCC_if_present)
1463     .Case("independent",ACCC_independent)
1464     .Case("link",ACCC_link)
1465     .Case("no_create",ACCC_no_create)
1466     .Case("nohost",ACCC_nohost)
1467     .Case("num_gangs",ACCC_num_gangs)
1468     .Case("num_workers",ACCC_num_workers)
1469     .Case("present",ACCC_present)
1470     .Case("private",ACCC_private)
1471     .Case("read",ACCC_read)
1472     .Case("reduction",ACCC_reduction)
1473     .Case("self",ACCC_self)
1474     .Case("seq",ACCC_seq)
1475     .Case("shortloop",ACCC_shortloop)
1476     .Case("tile",ACCC_tile)
1477     .Case("unknown",ACCC_unknown)
1478     .Case("use_device",ACCC_use_device)
1479     .Case("vector",ACCC_vector)
1480     .Case("vector_length",ACCC_vector_length)
1481     .Case("wait",ACCC_wait)
1482     .Case("worker",ACCC_worker)
1483     .Case("write",ACCC_write)
1484     .Default(ACCC_unknown);
1485 }
1486 
1487 llvm::StringRef llvm::acc::getOpenACCClauseName(Clause Kind) {
1488   switch (Kind) {
1489     case ACCC_async:
1490       return "async";
1491     case ACCC_attach:
1492       return "attach";
1493     case ACCC_auto:
1494       return "auto";
1495     case ACCC_bind:
1496       return "bind";
1497     case ACCC_capture:
1498       return "capture";
1499     case ACCC_collapse:
1500       return "collapse";
1501     case ACCC_copy:
1502       return "copy";
1503     case ACCC_copyin:
1504       return "copyin";
1505     case ACCC_copyout:
1506       return "copyout";
1507     case ACCC_create:
1508       return "create";
1509     case ACCC_default:
1510       return "default";
1511     case ACCC_default_async:
1512       return "default_async";
1513     case ACCC_delete:
1514       return "delete";
1515     case ACCC_detach:
1516       return "detach";
1517     case ACCC_device:
1518       return "device";
1519     case ACCC_device_num:
1520       return "device_num";
1521     case ACCC_deviceptr:
1522       return "deviceptr";
1523     case ACCC_device_resident:
1524       return "device_resident";
1525     case ACCC_device_type:
1526       return "device_type";
1527     case ACCC_finalize:
1528       return "finalize";
1529     case ACCC_firstprivate:
1530       return "firstprivate";
1531     case ACCC_gang:
1532       return "gang";
1533     case ACCC_host:
1534       return "host";
1535     case ACCC_if:
1536       return "if";
1537     case ACCC_if_present:
1538       return "if_present";
1539     case ACCC_independent:
1540       return "independent";
1541     case ACCC_link:
1542       return "link";
1543     case ACCC_no_create:
1544       return "no_create";
1545     case ACCC_nohost:
1546       return "nohost";
1547     case ACCC_num_gangs:
1548       return "num_gangs";
1549     case ACCC_num_workers:
1550       return "num_workers";
1551     case ACCC_present:
1552       return "present";
1553     case ACCC_private:
1554       return "private";
1555     case ACCC_read:
1556       return "read";
1557     case ACCC_reduction:
1558       return "reduction";
1559     case ACCC_self:
1560       return "self";
1561     case ACCC_seq:
1562       return "seq";
1563     case ACCC_shortloop:
1564       return "shortloop";
1565     case ACCC_tile:
1566       return "tile";
1567     case ACCC_unknown:
1568       return "unknown";
1569     case ACCC_use_device:
1570       return "use_device";
1571     case ACCC_vector:
1572       return "vector";
1573     case ACCC_vector_length:
1574       return "vector_length";
1575     case ACCC_wait:
1576       return "wait";
1577     case ACCC_worker:
1578       return "worker";
1579     case ACCC_write:
1580       return "write";
1581   }
1582   llvm_unreachable("Invalid OpenACC Clause kind");
1583 }
1584 
1585 DefaultValue llvm::acc::getDefaultValue(llvm::StringRef Str) {
1586   return llvm::StringSwitch<DefaultValue>(Str)
1587     .Case("present",ACC_Default_present)
1588     .Case("none",ACC_Default_none)
1589     .Default(ACC_Default_none);
1590 }
1591 
1592 llvm::StringRef llvm::acc::getOpenACCDefaultValueName(llvm::acc::DefaultValue x) {
1593   switch (x) {
1594     case ACC_Default_present:
1595       return "present";
1596     case ACC_Default_none:
1597       return "none";
1598   }
1599   llvm_unreachable("Invalid OpenACC DefaultValue kind");
1600 }
1601 
1602 bool llvm::acc::isAllowedClauseForDirective(Directive D, Clause C, unsigned Version) {
1603   assert(unsigned(D) <= llvm::acc::Directive_enumSize);
1604   assert(unsigned(C) <= llvm::acc::Clause_enumSize);
1605   switch (D) {
1606     case ACCD_atomic:
1607       return false;
1608       break;
1609     case ACCD_cache:
1610       return false;
1611       break;
1612     case ACCD_data:
1613       switch (C) {
1614         case ACCC_device_type:
1615           return 32 <= Version && 2147483647 >= Version;
1616         case ACCC_wait:
1617           return 32 <= Version && 2147483647 >= Version;
1618         case ACCC_async:
1619           return 32 <= Version && 2147483647 >= Version;
1620         case ACCC_if:
1621           return 1 <= Version && 2147483647 >= Version;
1622         case ACCC_default:
1623           return 1 <= Version && 2147483647 >= Version;
1624         case ACCC_attach:
1625           return 1 <= Version && 2147483647 >= Version;
1626         case ACCC_copy:
1627           return 1 <= Version && 2147483647 >= Version;
1628         case ACCC_copyin:
1629           return 1 <= Version && 2147483647 >= Version;
1630         case ACCC_copyout:
1631           return 1 <= Version && 2147483647 >= Version;
1632         case ACCC_create:
1633           return 1 <= Version && 2147483647 >= Version;
1634         case ACCC_deviceptr:
1635           return 1 <= Version && 2147483647 >= Version;
1636         case ACCC_no_create:
1637           return 1 <= Version && 2147483647 >= Version;
1638         case ACCC_present:
1639           return 1 <= Version && 2147483647 >= Version;
1640         default:
1641           return false;
1642       }
1643       break;
1644     case ACCD_declare:
1645       switch (C) {
1646         case ACCC_copy:
1647           return 1 <= Version && 2147483647 >= Version;
1648         case ACCC_copyin:
1649           return 1 <= Version && 2147483647 >= Version;
1650         case ACCC_copyout:
1651           return 1 <= Version && 2147483647 >= Version;
1652         case ACCC_create:
1653           return 1 <= Version && 2147483647 >= Version;
1654         case ACCC_present:
1655           return 1 <= Version && 2147483647 >= Version;
1656         case ACCC_deviceptr:
1657           return 1 <= Version && 2147483647 >= Version;
1658         case ACCC_device_resident:
1659           return 1 <= Version && 2147483647 >= Version;
1660         case ACCC_link:
1661           return 1 <= Version && 2147483647 >= Version;
1662         default:
1663           return false;
1664       }
1665       break;
1666     case ACCD_enter_data:
1667       switch (C) {
1668         case ACCC_wait:
1669           return 1 <= Version && 2147483647 >= Version;
1670         case ACCC_async:
1671           return 1 <= Version && 2147483647 >= Version;
1672         case ACCC_if:
1673           return 1 <= Version && 2147483647 >= Version;
1674         case ACCC_attach:
1675           return 1 <= Version && 2147483647 >= Version;
1676         case ACCC_create:
1677           return 1 <= Version && 2147483647 >= Version;
1678         case ACCC_copyin:
1679           return 1 <= Version && 2147483647 >= Version;
1680         default:
1681           return false;
1682       }
1683       break;
1684     case ACCD_exit_data:
1685       switch (C) {
1686         case ACCC_wait:
1687           return 1 <= Version && 2147483647 >= Version;
1688         case ACCC_async:
1689           return 1 <= Version && 2147483647 >= Version;
1690         case ACCC_if:
1691           return 1 <= Version && 2147483647 >= Version;
1692         case ACCC_finalize:
1693           return 1 <= Version && 2147483647 >= Version;
1694         case ACCC_copyout:
1695           return 1 <= Version && 2147483647 >= Version;
1696         case ACCC_delete:
1697           return 1 <= Version && 2147483647 >= Version;
1698         case ACCC_detach:
1699           return 1 <= Version && 2147483647 >= Version;
1700         default:
1701           return false;
1702       }
1703       break;
1704     case ACCD_host_data:
1705       switch (C) {
1706         case ACCC_if:
1707           return 1 <= Version && 2147483647 >= Version;
1708         case ACCC_if_present:
1709           return 1 <= Version && 2147483647 >= Version;
1710         case ACCC_use_device:
1711           return 1 <= Version && 2147483647 >= Version;
1712         default:
1713           return false;
1714       }
1715       break;
1716     case ACCD_init:
1717       switch (C) {
1718         case ACCC_device_num:
1719           return 1 <= Version && 2147483647 >= Version;
1720         case ACCC_device_type:
1721           return 1 <= Version && 2147483647 >= Version;
1722         case ACCC_if:
1723           return 1 <= Version && 2147483647 >= Version;
1724         default:
1725           return false;
1726       }
1727       break;
1728     case ACCD_kernels:
1729       switch (C) {
1730         case ACCC_attach:
1731           return 1 <= Version && 2147483647 >= Version;
1732         case ACCC_copy:
1733           return 1 <= Version && 2147483647 >= Version;
1734         case ACCC_copyin:
1735           return 1 <= Version && 2147483647 >= Version;
1736         case ACCC_copyout:
1737           return 1 <= Version && 2147483647 >= Version;
1738         case ACCC_create:
1739           return 1 <= Version && 2147483647 >= Version;
1740         case ACCC_device_type:
1741           return 1 <= Version && 2147483647 >= Version;
1742         case ACCC_no_create:
1743           return 1 <= Version && 2147483647 >= Version;
1744         case ACCC_present:
1745           return 1 <= Version && 2147483647 >= Version;
1746         case ACCC_deviceptr:
1747           return 1 <= Version && 2147483647 >= Version;
1748         case ACCC_wait:
1749           return 1 <= Version && 2147483647 >= Version;
1750         case ACCC_async:
1751           return 1 <= Version && 2147483647 >= Version;
1752         case ACCC_default:
1753           return 1 <= Version && 2147483647 >= Version;
1754         case ACCC_if:
1755           return 1 <= Version && 2147483647 >= Version;
1756         case ACCC_num_gangs:
1757           return 1 <= Version && 2147483647 >= Version;
1758         case ACCC_num_workers:
1759           return 1 <= Version && 2147483647 >= Version;
1760         case ACCC_self:
1761           return 1 <= Version && 2147483647 >= Version;
1762         case ACCC_vector_length:
1763           return 1 <= Version && 2147483647 >= Version;
1764         default:
1765           return false;
1766       }
1767       break;
1768     case ACCD_kernels_loop:
1769       switch (C) {
1770         case ACCC_attach:
1771           return 1 <= Version && 2147483647 >= Version;
1772         case ACCC_collapse:
1773           return 1 <= Version && 2147483647 >= Version;
1774         case ACCC_copy:
1775           return 1 <= Version && 2147483647 >= Version;
1776         case ACCC_copyin:
1777           return 1 <= Version && 2147483647 >= Version;
1778         case ACCC_copyout:
1779           return 1 <= Version && 2147483647 >= Version;
1780         case ACCC_create:
1781           return 1 <= Version && 2147483647 >= Version;
1782         case ACCC_deviceptr:
1783           return 1 <= Version && 2147483647 >= Version;
1784         case ACCC_device_type:
1785           return 1 <= Version && 2147483647 >= Version;
1786         case ACCC_gang:
1787           return 1 <= Version && 2147483647 >= Version;
1788         case ACCC_no_create:
1789           return 1 <= Version && 2147483647 >= Version;
1790         case ACCC_num_gangs:
1791           return 1 <= Version && 2147483647 >= Version;
1792         case ACCC_num_workers:
1793           return 1 <= Version && 2147483647 >= Version;
1794         case ACCC_present:
1795           return 1 <= Version && 2147483647 >= Version;
1796         case ACCC_private:
1797           return 1 <= Version && 2147483647 >= Version;
1798         case ACCC_reduction:
1799           return 1 <= Version && 2147483647 >= Version;
1800         case ACCC_shortloop:
1801           return 1 <= Version && 2147483647 >= Version;
1802         case ACCC_tile:
1803           return 1 <= Version && 2147483647 >= Version;
1804         case ACCC_vector:
1805           return 1 <= Version && 2147483647 >= Version;
1806         case ACCC_vector_length:
1807           return 1 <= Version && 2147483647 >= Version;
1808         case ACCC_wait:
1809           return 1 <= Version && 2147483647 >= Version;
1810         case ACCC_worker:
1811           return 1 <= Version && 2147483647 >= Version;
1812         case ACCC_async:
1813           return 1 <= Version && 2147483647 >= Version;
1814         case ACCC_default:
1815           return 1 <= Version && 2147483647 >= Version;
1816         case ACCC_if:
1817           return 1 <= Version && 2147483647 >= Version;
1818         case ACCC_self:
1819           return 1 <= Version && 2147483647 >= Version;
1820         case ACCC_auto:
1821           return 1 <= Version && 2147483647 >= Version;
1822         case ACCC_independent:
1823           return 1 <= Version && 2147483647 >= Version;
1824         case ACCC_seq:
1825           return 1 <= Version && 2147483647 >= Version;
1826         default:
1827           return false;
1828       }
1829       break;
1830     case ACCD_loop:
1831       switch (C) {
1832         case ACCC_device_type:
1833           return 1 <= Version && 2147483647 >= Version;
1834         case ACCC_private:
1835           return 1 <= Version && 2147483647 >= Version;
1836         case ACCC_reduction:
1837           return 1 <= Version && 2147483647 >= Version;
1838         case ACCC_collapse:
1839           return 1 <= Version && 2147483647 >= Version;
1840         case ACCC_gang:
1841           return 1 <= Version && 2147483647 >= Version;
1842         case ACCC_shortloop:
1843           return 1 <= Version && 2147483647 >= Version;
1844         case ACCC_tile:
1845           return 1 <= Version && 2147483647 >= Version;
1846         case ACCC_vector:
1847           return 1 <= Version && 2147483647 >= Version;
1848         case ACCC_worker:
1849           return 1 <= Version && 2147483647 >= Version;
1850         case ACCC_auto:
1851           return 1 <= Version && 2147483647 >= Version;
1852         case ACCC_independent:
1853           return 1 <= Version && 2147483647 >= Version;
1854         case ACCC_seq:
1855           return 1 <= Version && 2147483647 >= Version;
1856         default:
1857           return false;
1858       }
1859       break;
1860     case ACCD_parallel:
1861       switch (C) {
1862         case ACCC_attach:
1863           return 1 <= Version && 2147483647 >= Version;
1864         case ACCC_async:
1865           return 1 <= Version && 2147483647 >= Version;
1866         case ACCC_copy:
1867           return 1 <= Version && 2147483647 >= Version;
1868         case ACCC_copyin:
1869           return 1 <= Version && 2147483647 >= Version;
1870         case ACCC_copyout:
1871           return 1 <= Version && 2147483647 >= Version;
1872         case ACCC_create:
1873           return 1 <= Version && 2147483647 >= Version;
1874         case ACCC_deviceptr:
1875           return 1 <= Version && 2147483647 >= Version;
1876         case ACCC_device_type:
1877           return 1 <= Version && 2147483647 >= Version;
1878         case ACCC_no_create:
1879           return 1 <= Version && 2147483647 >= Version;
1880         case ACCC_num_gangs:
1881           return 1 <= Version && 2147483647 >= Version;
1882         case ACCC_num_workers:
1883           return 1 <= Version && 2147483647 >= Version;
1884         case ACCC_present:
1885           return 1 <= Version && 2147483647 >= Version;
1886         case ACCC_private:
1887           return 1 <= Version && 2147483647 >= Version;
1888         case ACCC_firstprivate:
1889           return 1 <= Version && 2147483647 >= Version;
1890         case ACCC_reduction:
1891           return 1 <= Version && 2147483647 >= Version;
1892         case ACCC_wait:
1893           return 1 <= Version && 2147483647 >= Version;
1894         case ACCC_vector_length:
1895           return 1 <= Version && 2147483647 >= Version;
1896         case ACCC_default:
1897           return 1 <= Version && 2147483647 >= Version;
1898         case ACCC_if:
1899           return 1 <= Version && 2147483647 >= Version;
1900         case ACCC_self:
1901           return 1 <= Version && 2147483647 >= Version;
1902         default:
1903           return false;
1904       }
1905       break;
1906     case ACCD_parallel_loop:
1907       switch (C) {
1908         case ACCC_attach:
1909           return 1 <= Version && 2147483647 >= Version;
1910         case ACCC_collapse:
1911           return 1 <= Version && 2147483647 >= Version;
1912         case ACCC_copy:
1913           return 1 <= Version && 2147483647 >= Version;
1914         case ACCC_copyin:
1915           return 1 <= Version && 2147483647 >= Version;
1916         case ACCC_copyout:
1917           return 1 <= Version && 2147483647 >= Version;
1918         case ACCC_create:
1919           return 1 <= Version && 2147483647 >= Version;
1920         case ACCC_deviceptr:
1921           return 1 <= Version && 2147483647 >= Version;
1922         case ACCC_device_type:
1923           return 1 <= Version && 2147483647 >= Version;
1924         case ACCC_firstprivate:
1925           return 1 <= Version && 2147483647 >= Version;
1926         case ACCC_gang:
1927           return 1 <= Version && 2147483647 >= Version;
1928         case ACCC_no_create:
1929           return 1 <= Version && 2147483647 >= Version;
1930         case ACCC_num_gangs:
1931           return 1 <= Version && 2147483647 >= Version;
1932         case ACCC_num_workers:
1933           return 1 <= Version && 2147483647 >= Version;
1934         case ACCC_present:
1935           return 1 <= Version && 2147483647 >= Version;
1936         case ACCC_private:
1937           return 1 <= Version && 2147483647 >= Version;
1938         case ACCC_reduction:
1939           return 1 <= Version && 2147483647 >= Version;
1940         case ACCC_shortloop:
1941           return 1 <= Version && 2147483647 >= Version;
1942         case ACCC_tile:
1943           return 1 <= Version && 2147483647 >= Version;
1944         case ACCC_vector:
1945           return 1 <= Version && 2147483647 >= Version;
1946         case ACCC_vector_length:
1947           return 1 <= Version && 2147483647 >= Version;
1948         case ACCC_wait:
1949           return 1 <= Version && 2147483647 >= Version;
1950         case ACCC_worker:
1951           return 1 <= Version && 2147483647 >= Version;
1952         case ACCC_async:
1953           return 1 <= Version && 2147483647 >= Version;
1954         case ACCC_default:
1955           return 1 <= Version && 2147483647 >= Version;
1956         case ACCC_if:
1957           return 1 <= Version && 2147483647 >= Version;
1958         case ACCC_self:
1959           return 1 <= Version && 2147483647 >= Version;
1960         case ACCC_auto:
1961           return 1 <= Version && 2147483647 >= Version;
1962         case ACCC_independent:
1963           return 1 <= Version && 2147483647 >= Version;
1964         case ACCC_seq:
1965           return 1 <= Version && 2147483647 >= Version;
1966         default:
1967           return false;
1968       }
1969       break;
1970     case ACCD_routine:
1971       switch (C) {
1972         case ACCC_bind:
1973           return 1 <= Version && 2147483647 >= Version;
1974         case ACCC_device_type:
1975           return 1 <= Version && 2147483647 >= Version;
1976         case ACCC_gang:
1977           return 1 <= Version && 2147483647 >= Version;
1978         case ACCC_seq:
1979           return 1 <= Version && 2147483647 >= Version;
1980         case ACCC_vector:
1981           return 1 <= Version && 2147483647 >= Version;
1982         case ACCC_worker:
1983           return 1 <= Version && 2147483647 >= Version;
1984         case ACCC_nohost:
1985           return 1 <= Version && 2147483647 >= Version;
1986         default:
1987           return false;
1988       }
1989       break;
1990     case ACCD_serial:
1991       switch (C) {
1992         case ACCC_attach:
1993           return 1 <= Version && 2147483647 >= Version;
1994         case ACCC_copy:
1995           return 1 <= Version && 2147483647 >= Version;
1996         case ACCC_copyin:
1997           return 1 <= Version && 2147483647 >= Version;
1998         case ACCC_copyout:
1999           return 1 <= Version && 2147483647 >= Version;
2000         case ACCC_create:
2001           return 1 <= Version && 2147483647 >= Version;
2002         case ACCC_deviceptr:
2003           return 1 <= Version && 2147483647 >= Version;
2004         case ACCC_device_type:
2005           return 1 <= Version && 2147483647 >= Version;
2006         case ACCC_no_create:
2007           return 1 <= Version && 2147483647 >= Version;
2008         case ACCC_present:
2009           return 1 <= Version && 2147483647 >= Version;
2010         case ACCC_private:
2011           return 1 <= Version && 2147483647 >= Version;
2012         case ACCC_firstprivate:
2013           return 1 <= Version && 2147483647 >= Version;
2014         case ACCC_reduction:
2015           return 1 <= Version && 2147483647 >= Version;
2016         case ACCC_wait:
2017           return 1 <= Version && 2147483647 >= Version;
2018         case ACCC_async:
2019           return 1 <= Version && 2147483647 >= Version;
2020         case ACCC_default:
2021           return 1 <= Version && 2147483647 >= Version;
2022         case ACCC_if:
2023           return 1 <= Version && 2147483647 >= Version;
2024         case ACCC_self:
2025           return 1 <= Version && 2147483647 >= Version;
2026         default:
2027           return false;
2028       }
2029       break;
2030     case ACCD_serial_loop:
2031       switch (C) {
2032         case ACCC_attach:
2033           return 1 <= Version && 2147483647 >= Version;
2034         case ACCC_collapse:
2035           return 1 <= Version && 2147483647 >= Version;
2036         case ACCC_copy:
2037           return 1 <= Version && 2147483647 >= Version;
2038         case ACCC_copyin:
2039           return 1 <= Version && 2147483647 >= Version;
2040         case ACCC_copyout:
2041           return 1 <= Version && 2147483647 >= Version;
2042         case ACCC_create:
2043           return 1 <= Version && 2147483647 >= Version;
2044         case ACCC_deviceptr:
2045           return 1 <= Version && 2147483647 >= Version;
2046         case ACCC_device_type:
2047           return 1 <= Version && 2147483647 >= Version;
2048         case ACCC_firstprivate:
2049           return 1 <= Version && 2147483647 >= Version;
2050         case ACCC_gang:
2051           return 1 <= Version && 2147483647 >= Version;
2052         case ACCC_no_create:
2053           return 1 <= Version && 2147483647 >= Version;
2054         case ACCC_present:
2055           return 1 <= Version && 2147483647 >= Version;
2056         case ACCC_private:
2057           return 1 <= Version && 2147483647 >= Version;
2058         case ACCC_reduction:
2059           return 1 <= Version && 2147483647 >= Version;
2060         case ACCC_shortloop:
2061           return 1 <= Version && 2147483647 >= Version;
2062         case ACCC_tile:
2063           return 1 <= Version && 2147483647 >= Version;
2064         case ACCC_vector:
2065           return 1 <= Version && 2147483647 >= Version;
2066         case ACCC_wait:
2067           return 1 <= Version && 2147483647 >= Version;
2068         case ACCC_worker:
2069           return 1 <= Version && 2147483647 >= Version;
2070         case ACCC_async:
2071           return 1 <= Version && 2147483647 >= Version;
2072         case ACCC_default:
2073           return 1 <= Version && 2147483647 >= Version;
2074         case ACCC_if:
2075           return 1 <= Version && 2147483647 >= Version;
2076         case ACCC_self:
2077           return 1 <= Version && 2147483647 >= Version;
2078         case ACCC_auto:
2079           return 1 <= Version && 2147483647 >= Version;
2080         case ACCC_independent:
2081           return 1 <= Version && 2147483647 >= Version;
2082         case ACCC_seq:
2083           return 1 <= Version && 2147483647 >= Version;
2084         default:
2085           return false;
2086       }
2087       break;
2088     case ACCD_set:
2089       switch (C) {
2090         case ACCC_default_async:
2091           return 1 <= Version && 2147483647 >= Version;
2092         case ACCC_device_num:
2093           return 1 <= Version && 2147483647 >= Version;
2094         case ACCC_device_type:
2095           return 1 <= Version && 2147483647 >= Version;
2096         case ACCC_if:
2097           return 1 <= Version && 2147483647 >= Version;
2098         default:
2099           return false;
2100       }
2101       break;
2102     case ACCD_shutdown:
2103       switch (C) {
2104         case ACCC_device_num:
2105           return 1 <= Version && 2147483647 >= Version;
2106         case ACCC_device_type:
2107           return 1 <= Version && 2147483647 >= Version;
2108         case ACCC_if:
2109           return 1 <= Version && 2147483647 >= Version;
2110         default:
2111           return false;
2112       }
2113       break;
2114     case ACCD_unknown:
2115       return false;
2116       break;
2117     case ACCD_update:
2118       switch (C) {
2119         case ACCC_device_type:
2120           return 1 <= Version && 2147483647 >= Version;
2121         case ACCC_wait:
2122           return 1 <= Version && 2147483647 >= Version;
2123         case ACCC_async:
2124           return 1 <= Version && 2147483647 >= Version;
2125         case ACCC_if:
2126           return 1 <= Version && 2147483647 >= Version;
2127         case ACCC_if_present:
2128           return 1 <= Version && 2147483647 >= Version;
2129         case ACCC_device:
2130           return 1 <= Version && 2147483647 >= Version;
2131         case ACCC_host:
2132           return 1 <= Version && 2147483647 >= Version;
2133         case ACCC_self:
2134           return 1 <= Version && 2147483647 >= Version;
2135         default:
2136           return false;
2137       }
2138       break;
2139     case ACCD_wait:
2140       switch (C) {
2141         case ACCC_async:
2142           return 1 <= Version && 2147483647 >= Version;
2143         case ACCC_if:
2144           return 1 <= Version && 2147483647 >= Version;
2145         default:
2146           return false;
2147       }
2148       break;
2149   }
2150   llvm_unreachable("Invalid OpenACC Directive kind");
2151 }
2152 
2153 llvm::acc::Association llvm::acc::getDirectiveAssociation(llvm::acc::Directive Dir) {
2154   switch (Dir) {
2155   case llvm::acc::Directive::ACCD_atomic:
2156     return llvm::acc::Association::Block;
2157   case llvm::acc::Directive::ACCD_cache:
2158     return llvm::acc::Association::None;
2159   case llvm::acc::Directive::ACCD_data:
2160     return llvm::acc::Association::Block;
2161   case llvm::acc::Directive::ACCD_declare:
2162     return llvm::acc::Association::None;
2163   case llvm::acc::Directive::ACCD_enter_data:
2164     return llvm::acc::Association::None;
2165   case llvm::acc::Directive::ACCD_exit_data:
2166     return llvm::acc::Association::None;
2167   case llvm::acc::Directive::ACCD_host_data:
2168     return llvm::acc::Association::Block;
2169   case llvm::acc::Directive::ACCD_init:
2170     return llvm::acc::Association::None;
2171   case llvm::acc::Directive::ACCD_kernels:
2172     return llvm::acc::Association::Block;
2173   case llvm::acc::Directive::ACCD_kernels_loop:
2174     return llvm::acc::Association::Loop;
2175   case llvm::acc::Directive::ACCD_loop:
2176     return llvm::acc::Association::Loop;
2177   case llvm::acc::Directive::ACCD_parallel:
2178     return llvm::acc::Association::Block;
2179   case llvm::acc::Directive::ACCD_parallel_loop:
2180     return llvm::acc::Association::Loop;
2181   case llvm::acc::Directive::ACCD_routine:
2182     return llvm::acc::Association::Declaration;
2183   case llvm::acc::Directive::ACCD_serial:
2184     return llvm::acc::Association::Block;
2185   case llvm::acc::Directive::ACCD_serial_loop:
2186     return llvm::acc::Association::Loop;
2187   case llvm::acc::Directive::ACCD_set:
2188     return llvm::acc::Association::None;
2189   case llvm::acc::Directive::ACCD_shutdown:
2190     return llvm::acc::Association::None;
2191   case llvm::acc::Directive::ACCD_unknown:
2192     return llvm::acc::Association::None;
2193   case llvm::acc::Directive::ACCD_update:
2194     return llvm::acc::Association::None;
2195   case llvm::acc::Directive::ACCD_wait:
2196     return llvm::acc::Association::None;
2197   } // switch (Dir)
2198   llvm_unreachable("Unexpected directive");
2199 }
2200 
2201 llvm::acc::Category llvm::acc::getDirectiveCategory(llvm::acc::Directive Dir) {
2202   switch (Dir) {
2203   case llvm::acc::ACCD_atomic:
2204     return llvm::acc::Category::Executable;
2205   case llvm::acc::ACCD_cache:
2206     return llvm::acc::Category::Executable;
2207   case llvm::acc::ACCD_data:
2208     return llvm::acc::Category::Executable;
2209   case llvm::acc::ACCD_declare:
2210     return llvm::acc::Category::Declarative;
2211   case llvm::acc::ACCD_enter_data:
2212     return llvm::acc::Category::Executable;
2213   case llvm::acc::ACCD_exit_data:
2214     return llvm::acc::Category::Executable;
2215   case llvm::acc::ACCD_host_data:
2216     return llvm::acc::Category::Executable;
2217   case llvm::acc::ACCD_init:
2218     return llvm::acc::Category::Executable;
2219   case llvm::acc::ACCD_kernels:
2220     return llvm::acc::Category::Executable;
2221   case llvm::acc::ACCD_kernels_loop:
2222     return llvm::acc::Category::Executable;
2223   case llvm::acc::ACCD_loop:
2224     return llvm::acc::Category::Executable;
2225   case llvm::acc::ACCD_parallel:
2226     return llvm::acc::Category::Executable;
2227   case llvm::acc::ACCD_parallel_loop:
2228     return llvm::acc::Category::Executable;
2229   case llvm::acc::ACCD_routine:
2230     return llvm::acc::Category::Declarative;
2231   case llvm::acc::ACCD_serial:
2232     return llvm::acc::Category::Executable;
2233   case llvm::acc::ACCD_serial_loop:
2234     return llvm::acc::Category::Executable;
2235   case llvm::acc::ACCD_set:
2236     return llvm::acc::Category::Executable;
2237   case llvm::acc::ACCD_shutdown:
2238     return llvm::acc::Category::Executable;
2239   case llvm::acc::ACCD_unknown:
2240     return llvm::acc::Category::Utility;
2241   case llvm::acc::ACCD_update:
2242     return llvm::acc::Category::Executable;
2243   case llvm::acc::ACCD_wait:
2244     return llvm::acc::Category::Executable;
2245   } // switch (Dir)
2246   llvm_unreachable("Unexpected directive");
2247 }
2248 
2249 static_assert(sizeof(llvm::acc::Directive) == sizeof(int));
2250 [[maybe_unused]] static const llvm::acc::Directive LeafConstructTable[][4] = {
2251     {llvm::acc::ACCD_atomic, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2252     {llvm::acc::ACCD_cache, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2253     {llvm::acc::ACCD_data, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2254     {llvm::acc::ACCD_declare, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2255     {llvm::acc::ACCD_enter_data, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2256     {llvm::acc::ACCD_exit_data, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2257     {llvm::acc::ACCD_host_data, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2258     {llvm::acc::ACCD_init, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2259     {llvm::acc::ACCD_kernels, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2260     {llvm::acc::ACCD_loop, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2261     {llvm::acc::ACCD_parallel, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2262     {llvm::acc::ACCD_routine, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2263     {llvm::acc::ACCD_serial, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2264     {llvm::acc::ACCD_set, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2265     {llvm::acc::ACCD_shutdown, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2266     {llvm::acc::ACCD_unknown, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2267     {llvm::acc::ACCD_update, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2268     {llvm::acc::ACCD_wait, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2269     {llvm::acc::ACCD_kernels_loop, static_cast<llvm::acc::Directive>(2), llvm::acc::ACCD_kernels, llvm::acc::ACCD_loop,},
2270     {llvm::acc::ACCD_parallel_loop, static_cast<llvm::acc::Directive>(2), llvm::acc::ACCD_parallel, llvm::acc::ACCD_loop,},
2271     {llvm::acc::ACCD_serial_loop, static_cast<llvm::acc::Directive>(2), llvm::acc::ACCD_serial, llvm::acc::ACCD_loop,},
2272 };
2273 
2274 [[maybe_unused]] static auto LeafConstructTableEndDirective = LeafConstructTable + 21;
2275 
2276 [[maybe_unused]] static const int LeafConstructTableOrdering[] = {
2277     0, 1, 2, 3, 4, 5, 6, 7, 8, 18, 9, 10, 19, 11, 12, 20, 13, 14, 15, 16, 17,
2278 };
2279 
2280 #endif // GEN_DIRECTIVES_IMPL
2281
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!