1//===-- OMP.td - OpenMP directive definition file ----------*- tablegen -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This is the definition file for OpenMP directives and clauses. 10// 11//===----------------------------------------------------------------------===// 12 13include "llvm/Frontend/Directive/DirectiveBase.td" 14 15//===----------------------------------------------------------------------===// 16// Definition of general OpenMP information 17//===----------------------------------------------------------------------===// 18 19def OpenMP : DirectiveLanguage { 20 let name = "OpenMP"; 21 let cppNamespace = "omp"; // final namespace will be llvm::omp 22 let directivePrefix = "OMPD_"; 23 let clausePrefix = "OMPC_"; 24 let makeEnumAvailableInNamespace = true; 25 let enableBitmaskEnumInNamespace = true; 26 let clauseEnumSetClass = "OmpClauseSet"; 27 let flangClauseBaseClass = "OmpClause"; 28} 29 30//===----------------------------------------------------------------------===// 31// Definition of OpenMP clauses 32//===----------------------------------------------------------------------===// 33 34def OMPC_Allocator : Clause<"allocator"> { 35 let clangClass = "OMPAllocatorClause"; 36 let flangClass = "ScalarIntExpr"; 37} 38def OMPC_If : Clause<"if"> { 39 let clangClass = "OMPIfClause"; 40 let flangClass = "OmpIfClause"; 41} 42def OMPC_Final : Clause<"final"> { 43 let clangClass = "OMPFinalClause"; 44 let flangClass = "ScalarLogicalExpr"; 45} 46def OMPC_NumThreads : Clause<"num_threads"> { 47 let clangClass = "OMPNumThreadsClause"; 48 let flangClass = "ScalarIntExpr"; 49} 50def OMPC_SafeLen : Clause<"safelen"> { 51 let clangClass = "OMPSafelenClause"; 52 let flangClass = "ScalarIntConstantExpr"; 53} 54def OMPC_SimdLen : Clause<"simdlen"> { 55 let clangClass = "OMPSimdlenClause"; 56 let flangClass = "ScalarIntConstantExpr"; 57} 58def OMPC_Collapse : Clause<"collapse"> { 59 let clangClass = "OMPCollapseClause"; 60 let flangClass = "ScalarIntConstantExpr"; 61} 62def OMPC_Default : Clause<"default"> { 63 let clangClass = "OMPDefaultClause"; 64 let flangClass = "OmpDefaultClause"; 65} 66def OMPC_Private : Clause<"private"> { 67 let clangClass = "OMPPrivateClause"; 68 let flangClass = "OmpObjectList"; 69} 70def OMPC_Sizes: Clause<"sizes"> { 71 let clangClass = "OMPSizesClause"; 72 let flangClass = "ScalarIntExpr"; 73 let isValueList = true; 74 } 75def OMPC_Full: Clause<"full"> { 76 let clangClass = "OMPFullClause"; 77} 78def OMPC_Partial: Clause<"partial"> { 79 let clangClass = "OMPPartialClause"; 80 let flangClass = "ScalarIntConstantExpr"; 81 let isValueOptional = true; 82 } 83def OMPC_FirstPrivate : Clause<"firstprivate"> { 84 let clangClass = "OMPFirstprivateClause"; 85 let flangClass = "OmpObjectList"; 86} 87def OMPC_LastPrivate : Clause<"lastprivate"> { 88 let clangClass = "OMPLastprivateClause"; 89 let flangClass = "OmpObjectList"; 90} 91def OMPC_Shared : Clause<"shared"> { 92 let clangClass = "OMPSharedClause"; 93 let flangClass = "OmpObjectList"; 94} 95def OMPC_Reduction : Clause<"reduction"> { 96 let clangClass = "OMPReductionClause"; 97 let flangClass = "OmpReductionClause"; 98} 99def OMPC_Linear : Clause<"linear"> { 100 let clangClass = "OMPLinearClause"; 101 let flangClass = "OmpLinearClause"; 102} 103def OMPC_Aligned : Clause<"aligned"> { 104 let clangClass = "OMPAlignedClause"; 105 let flangClass = "OmpAlignedClause"; 106} 107def OMPC_Copyin : Clause<"copyin"> { 108 let clangClass = "OMPCopyinClause"; 109 let flangClass = "OmpObjectList"; 110} 111def OMPC_CopyPrivate : Clause<"copyprivate"> { 112 let clangClass = "OMPCopyprivateClause"; 113 let flangClass = "OmpObjectList"; 114} 115def OMP_PROC_BIND_master : ClauseVal<"master",2,1> {} 116def OMP_PROC_BIND_close : ClauseVal<"close",3,1> {} 117def OMP_PROC_BIND_spread : ClauseVal<"spread",4,1> {} 118def OMP_PROC_BIND_primary : ClauseVal<"primary",5,1> {} 119def OMP_PROC_BIND_default : ClauseVal<"default",6,0> {} 120def OMP_PROC_BIND_unknown : ClauseVal<"unknown",7,0> { let isDefault = true; } 121def OMPC_ProcBind : Clause<"proc_bind"> { 122 let clangClass = "OMPProcBindClause"; 123 let flangClass = "OmpProcBindClause"; 124 let enumClauseValue = "ProcBindKind"; 125 let allowedClauseValues = [ 126 OMP_PROC_BIND_primary, 127 OMP_PROC_BIND_master, 128 OMP_PROC_BIND_close, 129 OMP_PROC_BIND_spread, 130 OMP_PROC_BIND_default, 131 OMP_PROC_BIND_unknown 132 ]; 133} 134 135def OMP_SCHEDULE_Static : ClauseVal<"static", 2, 1> {} 136def OMP_SCHEDULE_Dynamic : ClauseVal<"dynamic", 3, 1> {} 137def OMP_SCHEDULE_Guided : ClauseVal<"guided", 4, 1> {} 138def OMP_SCHEDULE_Auto : ClauseVal<"auto", 5, 1> {} 139def OMP_SCHEDULE_Runtime : ClauseVal<"runtime", 6, 1> {} 140def OMP_SCHEDULE_Default : ClauseVal<"default", 7, 0> { let isDefault = 1; } 141 142def OMPC_Schedule : Clause<"schedule"> { 143 let clangClass = "OMPScheduleClause"; 144 let flangClass = "OmpScheduleClause"; 145 let enumClauseValue = "ScheduleKind"; 146 let allowedClauseValues = [ 147 OMP_SCHEDULE_Static, 148 OMP_SCHEDULE_Dynamic, 149 OMP_SCHEDULE_Guided, 150 OMP_SCHEDULE_Auto, 151 OMP_SCHEDULE_Runtime, 152 OMP_SCHEDULE_Default 153 ]; 154} 155 156def OMP_MEMORY_ORDER_SeqCst : ClauseVal<"seq_cst", 1, 1> {} 157def OMP_MEMORY_ORDER_AcqRel : ClauseVal<"acq_rel", 2, 1> {} 158def OMP_MEMORY_ORDER_Acquire : ClauseVal<"acquire", 3, 1> {} 159def OMP_MEMORY_ORDER_Release : ClauseVal<"release", 4, 1> {} 160def OMP_MEMORY_ORDER_Relaxed : ClauseVal<"relaxed", 5, 1> {} 161def OMP_MEMORY_ORDER_Default : ClauseVal<"default", 6, 0> { 162 let isDefault = 1; 163} 164def OMPC_MemoryOrder : Clause<"memory_order"> { 165 let enumClauseValue = "MemoryOrderKind"; 166 let allowedClauseValues = [ 167 OMP_MEMORY_ORDER_SeqCst, 168 OMP_MEMORY_ORDER_AcqRel, 169 OMP_MEMORY_ORDER_Acquire, 170 OMP_MEMORY_ORDER_Release, 171 OMP_MEMORY_ORDER_Relaxed, 172 OMP_MEMORY_ORDER_Default 173 ]; 174} 175 176def OMP_CANCELLATION_CONSTRUCT_Parallel : ClauseVal<"parallel", 1, 1> {} 177def OMP_CANCELLATION_CONSTRUCT_Loop : ClauseVal<"loop", 2, 1> {} 178def OMP_CANCELLATION_CONSTRUCT_Sections : ClauseVal<"sections", 3, 1> {} 179def OMP_CANCELLATION_CONSTRUCT_Taskgroup : ClauseVal<"taskgroup", 4, 1> {} 180def OMP_CANCELLATION_CONSTRUCT_None : ClauseVal<"none", 5, 0> { 181 let isDefault = 1; 182} 183 184def OMPC_CancellationConstructType : Clause<"cancellation_construct_type"> { 185 let enumClauseValue = "CancellationConstructType"; 186 let allowedClauseValues = [ 187 OMP_CANCELLATION_CONSTRUCT_Parallel, 188 OMP_CANCELLATION_CONSTRUCT_Loop, 189 OMP_CANCELLATION_CONSTRUCT_Sections, 190 OMP_CANCELLATION_CONSTRUCT_Taskgroup, 191 OMP_CANCELLATION_CONSTRUCT_None 192 ]; 193} 194 195def OMPC_Ordered : Clause<"ordered"> { 196 let clangClass = "OMPOrderedClause"; 197 let flangClass = "ScalarIntConstantExpr"; 198 let isValueOptional = true; 199} 200def OMPC_NoWait : Clause<"nowait"> { 201 let clangClass = "OMPNowaitClause"; 202} 203def OMPC_Untied : Clause<"untied"> { let clangClass = "OMPUntiedClause"; } 204def OMPC_Mergeable : Clause<"mergeable"> { 205 let clangClass = "OMPMergeableClause"; 206} 207def OMPC_Read : Clause<"read"> { let clangClass = "OMPReadClause"; } 208def OMPC_Write : Clause<"write"> { let clangClass = "OMPWriteClause"; } 209def OMPC_Update : Clause<"update"> { let clangClass = "OMPUpdateClause"; } 210def OMPC_Capture : Clause<"capture"> { let clangClass = "OMPCaptureClause"; } 211def OMPC_Compare : Clause<"compare"> { let clangClass = "OMPCompareClause"; } 212def OMPC_SeqCst : Clause<"seq_cst"> { let clangClass = "OMPSeqCstClause"; } 213def OMPC_AcqRel : Clause<"acq_rel"> { let clangClass = "OMPAcqRelClause"; } 214def OMPC_Acquire : Clause<"acquire"> { let clangClass = "OMPAcquireClause"; } 215def OMPC_Release : Clause<"release"> { let clangClass = "OMPReleaseClause"; } 216def OMPC_Relaxed : Clause<"relaxed"> { let clangClass = "OMPRelaxedClause"; } 217def OMPC_Depend : Clause<"depend"> { 218 let clangClass = "OMPDependClause"; 219 let flangClass = "OmpDependClause"; 220} 221def OMPC_Device : Clause<"device"> { 222 let clangClass = "OMPDeviceClause"; 223 let flangClass = "OmpDeviceClause"; 224} 225def OMPC_DeviceType : Clause<"device_type"> { 226 let flangClass = "OmpDeviceTypeClause"; 227} 228def OMPC_Threads : Clause<"threads"> { let clangClass = "OMPThreadsClause"; } 229def OMPC_Simd : Clause<"simd"> { let clangClass = "OMPSIMDClause"; } 230def OMPC_Map : Clause<"map"> { 231 let clangClass = "OMPMapClause"; 232 let flangClass = "OmpMapClause"; 233} 234def OMPC_NumTeams : Clause<"num_teams"> { 235 let clangClass = "OMPNumTeamsClause"; 236 let flangClass = "ScalarIntExpr"; 237} 238def OMPC_ThreadLimit : Clause<"thread_limit"> { 239 let clangClass = "OMPThreadLimitClause"; 240 let flangClass = "ScalarIntExpr"; 241} 242def OMPC_Priority : Clause<"priority"> { 243 let clangClass = "OMPPriorityClause"; 244 let flangClass = "ScalarIntExpr"; 245} 246 247def OMP_GRAINSIZE_Strict : ClauseVal<"strict", 1, 1> {} 248def OMP_GRAINSIZE_Unknown : ClauseVal<"unkonwn", 2, 0> { let isDefault = 1; } 249 250def OMPC_GrainSize : Clause<"grainsize"> { 251 let clangClass = "OMPGrainsizeClause"; 252 let flangClass = "ScalarIntExpr"; 253 let enumClauseValue = "GrainsizeType"; 254 let allowedClauseValues = [ 255 OMP_GRAINSIZE_Strict, 256 OMP_GRAINSIZE_Unknown 257 ]; 258} 259def OMPC_NoGroup : Clause<"nogroup"> { 260 let clangClass = "OMPNogroupClause"; 261} 262 263def OMP_NUMTASKS_Strict : ClauseVal<"strict", 1, 1> {} 264def OMP_NUMTASKS_Unknown : ClauseVal<"unkonwn", 2, 0> { let isDefault = 1; } 265 266def OMPC_NumTasks : Clause<"num_tasks"> { 267 let clangClass = "OMPNumTasksClause"; 268 let flangClass = "ScalarIntExpr"; 269 let enumClauseValue = "NumTasksType"; 270 let allowedClauseValues = [ 271 OMP_NUMTASKS_Strict, 272 OMP_NUMTASKS_Unknown 273 ]; 274} 275def OMPC_Hint : Clause<"hint"> { 276 let clangClass = "OMPHintClause"; 277 let flangClass = "ConstantExpr"; 278} 279def OMPC_DistSchedule : Clause<"dist_schedule"> { 280 let clangClass = "OMPDistScheduleClause"; 281 let flangClass = "ScalarIntExpr"; 282 let isValueOptional = true; 283} 284def OMPC_DefaultMap : Clause<"defaultmap"> { 285 let clangClass = "OMPDefaultmapClause"; 286 let flangClass = "OmpDefaultmapClause"; 287} 288def OMPC_To : Clause<"to"> { 289 let clangClass = "OMPToClause"; 290 let flangClass = "OmpObjectList"; 291} 292def OMPC_From : Clause<"from"> { 293 let clangClass = "OMPFromClause"; 294 let flangClass = "OmpObjectList"; 295} 296def OMPC_UseDevicePtr : Clause<"use_device_ptr"> { 297 let clangClass = "OMPUseDevicePtrClause"; 298 let flangClass = "OmpObjectList"; 299} 300def OMPC_IsDevicePtr : Clause<"is_device_ptr"> { 301 let clangClass = "OMPIsDevicePtrClause"; 302 let flangClass = "Name"; 303 let isValueList = true; 304} 305def OMPC_HasDeviceAddr : Clause<"has_device_addr"> { 306 let clangClass = "OMPHasDeviceAddrClause"; 307 let flangClass = "Name"; 308 let isValueList = true; 309} 310def OMPC_TaskReduction : Clause<"task_reduction"> { 311 let clangClass = "OMPTaskReductionClause"; 312 let flangClass = "OmpReductionClause"; 313} 314def OMPC_InReduction : Clause<"in_reduction"> { 315 let clangClass = "OMPInReductionClause"; 316 let flangClass = "OmpInReductionClause"; 317} 318def OMPC_UnifiedAddress : Clause<"unified_address"> { 319 let clangClass = "OMPUnifiedAddressClause"; 320} 321def OMPC_UnifiedSharedMemory : Clause<"unified_shared_memory"> { 322 let clangClass = "OMPUnifiedSharedMemoryClause"; 323} 324def OMPC_ReverseOffload : Clause<"reverse_offload"> { 325 let clangClass = "OMPReverseOffloadClause"; 326} 327def OMPC_DynamicAllocators : Clause<"dynamic_allocators"> { 328 let clangClass = "OMPDynamicAllocatorsClause"; 329} 330def OMPC_AtomicDefaultMemOrder : Clause<"atomic_default_mem_order"> { 331 let clangClass = "OMPAtomicDefaultMemOrderClause"; 332 let flangClass = "OmpAtomicDefaultMemOrderClause"; 333} 334def OMPC_At : Clause<"at"> { 335 let clangClass = "OMPAtClause"; 336} 337def OMPC_Severity : Clause<"severity"> { 338 let clangClass = "OMPSeverityClause"; 339} 340def OMPC_Message : Clause<"message"> { 341 let clangClass = "OMPMessageClause"; 342} 343def OMPC_Allocate : Clause<"allocate"> { 344 let clangClass = "OMPAllocateClause"; 345 let flangClass = "OmpAllocateClause"; 346} 347def OMPC_NonTemporal : Clause<"nontemporal"> { 348 let clangClass = "OMPNontemporalClause"; 349 let flangClass = "Name"; 350 let isValueList = true; 351} 352 353def OMP_ORDER_concurrent : ClauseVal<"concurrent",1,1> {} 354def OMP_ORDER_unknown : ClauseVal<"unknown",2,0> { let isDefault = 1; } 355def OMPC_Order : Clause<"order"> { 356 let clangClass = "OMPOrderClause"; 357 let flangClass = "OmpOrderClause"; 358 let enumClauseValue = "OrderKind"; 359 let allowedClauseValues = [ 360 OMP_ORDER_unknown, 361 OMP_ORDER_concurrent 362 ]; 363} 364def OMPC_Init : Clause<"init"> { 365 let clangClass = "OMPInitClause"; 366} 367def OMPC_Use : Clause<"use"> { 368 let clangClass = "OMPUseClause"; 369} 370def OMPC_Destroy : Clause<"destroy"> { 371 let clangClass = "OMPDestroyClause"; 372} 373def OMPC_Novariants : Clause<"novariants"> { 374 let clangClass = "OMPNovariantsClause"; 375 let flangClass = "ScalarLogicalExpr"; 376} 377def OMPC_Nocontext : Clause<"nocontext"> { 378 let clangClass = "OMPNocontextClause"; 379 let flangClass = "ScalarLogicalExpr"; 380} 381def OMPC_Detach : Clause<"detach"> { 382 let clangClass = "OMPDetachClause"; 383} 384def OMPC_Inclusive : Clause<"inclusive"> { 385 let clangClass = "OMPInclusiveClause"; 386} 387def OMPC_Exclusive : Clause<"exclusive"> { 388 let clangClass = "OMPExclusiveClause"; 389} 390def OMPC_UsesAllocators : Clause<"uses_allocators"> { 391 let clangClass = "OMPUsesAllocatorsClause"; 392} 393def OMPC_Affinity : Clause<"affinity"> { 394 let clangClass = "OMPAffinityClause"; 395} 396def OMPC_UseDeviceAddr : Clause<"use_device_addr"> { 397 let clangClass = "OMPUseDeviceAddrClause"; 398 let flangClass = "OmpObjectList"; 399} 400def OMPC_Uniform : Clause<"uniform"> { 401 let flangClass = "Name"; 402 let isValueList = true; 403} 404def OMPC_Match : Clause<"match"> {} 405def OMPC_AdjustArgs : Clause<"adjust_args"> { } 406def OMPC_AppendArgs : Clause<"append_args"> { } 407def OMPC_Depobj : Clause<"depobj"> { 408 let clangClass = "OMPDepobjClause"; 409 let isImplicit = true; 410} 411def OMPC_Flush : Clause<"flush"> { 412 let clangClass = "OMPFlushClause"; 413 let isImplicit = true; 414} 415def OMPC_ThreadPrivate : Clause<"threadprivate"> { 416 let alternativeName = "threadprivate or thread local"; 417 let isImplicit = true; 418} 419def OMPC_Unknown : Clause<"unknown"> { 420 let isImplicit = true; 421 let isDefault = true; 422} 423def OMPC_Link : Clause<"link"> { 424 let flangClass = "OmpObjectList"; 425} 426def OMPC_Indirect : Clause<"indirect"> {} 427def OMPC_Inbranch : Clause<"inbranch"> {} 428def OMPC_Notinbranch : Clause<"notinbranch"> {} 429def OMPC_Filter : Clause<"filter"> { 430 let clangClass = "OMPFilterClause"; 431 let flangClass = "ScalarIntExpr"; 432} 433def OMPC_Align : Clause<"align"> { 434 let clangClass = "OMPAlignClause"; 435} 436def OMPC_When: Clause<"when"> {} 437 438def OMPC_Bind : Clause<"bind"> { 439 let clangClass = "OMPBindClause"; 440} 441 442def OMPC_OMPX_DynCGroupMem : Clause<"ompx_dyn_cgroup_mem"> { 443 let clangClass = "OMPXDynCGroupMemClause"; 444 let flangClass = "ScalarIntExpr"; 445} 446 447def OMPC_Doacross : Clause<"doacross"> { 448 let clangClass = "OMPDoacrossClause"; 449} 450 451//===----------------------------------------------------------------------===// 452// Definition of OpenMP directives 453//===----------------------------------------------------------------------===// 454 455def OMP_ThreadPrivate : Directive<"threadprivate"> {} 456def OMP_Parallel : Directive<"parallel"> { 457 let allowedClauses = [ 458 VersionedClause<OMPC_Private>, 459 VersionedClause<OMPC_FirstPrivate>, 460 VersionedClause<OMPC_Shared>, 461 VersionedClause<OMPC_Reduction>, 462 VersionedClause<OMPC_Copyin>, 463 VersionedClause<OMPC_Allocate> 464 ]; 465 let allowedOnceClauses = [ 466 VersionedClause<OMPC_Default>, 467 VersionedClause<OMPC_If>, 468 VersionedClause<OMPC_NumThreads>, 469 VersionedClause<OMPC_ProcBind>, 470 ]; 471} 472def OMP_Task : Directive<"task"> { 473 let allowedClauses = [ 474 VersionedClause<OMPC_Private>, 475 VersionedClause<OMPC_FirstPrivate>, 476 VersionedClause<OMPC_Shared>, 477 VersionedClause<OMPC_Untied>, 478 VersionedClause<OMPC_Mergeable>, 479 VersionedClause<OMPC_Depend>, 480 VersionedClause<OMPC_InReduction>, 481 VersionedClause<OMPC_Allocate>, 482 VersionedClause<OMPC_Detach, 50>, 483 VersionedClause<OMPC_Affinity, 50> 484 ]; 485 let allowedOnceClauses = [ 486 VersionedClause<OMPC_Default>, 487 VersionedClause<OMPC_If>, 488 VersionedClause<OMPC_Final>, 489 VersionedClause<OMPC_Priority> 490 ]; 491} 492def OMP_Simd : Directive<"simd"> { 493 let allowedClauses = [ 494 VersionedClause<OMPC_Private>, 495 VersionedClause<OMPC_LastPrivate>, 496 VersionedClause<OMPC_Linear>, 497 VersionedClause<OMPC_Aligned>, 498 VersionedClause<OMPC_Reduction>, 499 VersionedClause<OMPC_Allocate>, 500 VersionedClause<OMPC_NonTemporal, 50>, 501 ]; 502 let allowedOnceClauses = [ 503 VersionedClause<OMPC_Collapse>, 504 VersionedClause<OMPC_SafeLen>, 505 VersionedClause<OMPC_SimdLen>, 506 VersionedClause<OMPC_If, 50>, 507 VersionedClause<OMPC_Order, 50> 508 ]; 509} 510def OMP_Tile : Directive<"tile"> { 511 let allowedOnceClauses = [ 512 VersionedClause<OMPC_Sizes, 51>, 513 ]; 514} 515def OMP_Unroll : Directive<"unroll"> { 516 let allowedOnceClauses = [ 517 VersionedClause<OMPC_Full, 51>, 518 VersionedClause<OMPC_Partial, 51>, 519 ]; 520} 521def OMP_For : Directive<"for"> { 522 let allowedClauses = [ 523 VersionedClause<OMPC_Private>, 524 VersionedClause<OMPC_LastPrivate>, 525 VersionedClause<OMPC_FirstPrivate>, 526 VersionedClause<OMPC_Reduction>, 527 VersionedClause<OMPC_Collapse>, 528 VersionedClause<OMPC_Schedule>, 529 VersionedClause<OMPC_Ordered>, 530 VersionedClause<OMPC_NoWait>, 531 VersionedClause<OMPC_Linear>, 532 VersionedClause<OMPC_Allocate>, 533 VersionedClause<OMPC_Order, 50> 534 ]; 535} 536def OMP_Do : Directive<"do"> { 537 let allowedClauses = [ 538 VersionedClause<OMPC_Private>, 539 VersionedClause<OMPC_FirstPrivate>, 540 VersionedClause<OMPC_LastPrivate>, 541 VersionedClause<OMPC_Linear>, 542 VersionedClause<OMPC_Reduction> 543 ]; 544 let allowedOnceClauses = [ 545 VersionedClause<OMPC_Schedule>, 546 VersionedClause<OMPC_Collapse>, 547 VersionedClause<OMPC_Ordered>, 548 VersionedClause<OMPC_NoWait>, 549 VersionedClause<OMPC_Order, 50> 550 ]; 551} 552def OMP_Sections : Directive<"sections"> { 553 let allowedClauses = [ 554 VersionedClause<OMPC_Private>, 555 VersionedClause<OMPC_LastPrivate>, 556 VersionedClause<OMPC_FirstPrivate>, 557 VersionedClause<OMPC_Reduction>, 558 VersionedClause<OMPC_NoWait>, 559 VersionedClause<OMPC_Allocate> 560 ]; 561} 562def OMP_Section : Directive<"section"> {} 563def OMP_Single : Directive<"single"> { 564 let allowedClauses = [ 565 VersionedClause<OMPC_Private>, 566 VersionedClause<OMPC_FirstPrivate>, 567 VersionedClause<OMPC_CopyPrivate>, 568 VersionedClause<OMPC_NoWait>, 569 VersionedClause<OMPC_Allocate> 570 ]; 571} 572def OMP_Master : Directive<"master"> {} 573def OMP_Critical : Directive<"critical"> { 574 let allowedClauses = [ 575 VersionedClause<OMPC_Hint> 576 ]; 577} 578def OMP_TaskYield : Directive<"taskyield"> {} 579def OMP_Barrier : Directive<"barrier"> {} 580def OMP_Error : Directive<"error"> { 581 let allowedClauses = [ 582 VersionedClause<OMPC_At, 51>, 583 VersionedClause<OMPC_Severity, 51>, 584 VersionedClause<OMPC_Message, 51> 585 ]; 586} 587def OMP_TaskWait : Directive<"taskwait"> { 588 let allowedClauses = [ 589 VersionedClause<OMPC_Depend, 50>, 590 VersionedClause<OMPC_NoWait, 51> 591 ]; 592} 593def OMP_TaskGroup : Directive<"taskgroup"> { 594 let allowedClauses = [ 595 VersionedClause<OMPC_TaskReduction, 50>, 596 VersionedClause<OMPC_Allocate, 50> 597 ]; 598} 599def OMP_Flush : Directive<"flush"> { 600 let allowedOnceClauses = [ 601 VersionedClause<OMPC_AcqRel, 50>, 602 VersionedClause<OMPC_Acquire, 50>, 603 VersionedClause<OMPC_Release, 50>, 604 // TODO This should ne `none` instead. Comment carried over from 605 // OMPKinds.def. 606 VersionedClause<OMPC_Flush> 607 ]; 608} 609def OMP_Ordered : Directive<"ordered"> { 610 let allowedClauses = [ 611 VersionedClause<OMPC_Depend>, 612 VersionedClause<OMPC_Doacross, 52> 613 ]; 614 let allowedOnceClauses = [ 615 VersionedClause<OMPC_Threads>, 616 VersionedClause<OMPC_Simd> 617 ]; 618} 619def OMP_Atomic : Directive<"atomic"> { 620 let allowedClauses = [ 621 VersionedClause<OMPC_Read>, 622 VersionedClause<OMPC_Write>, 623 VersionedClause<OMPC_Update>, 624 VersionedClause<OMPC_Capture>, 625 VersionedClause<OMPC_Compare, 51> 626 ]; 627 let allowedOnceClauses = [ 628 VersionedClause<OMPC_SeqCst>, 629 VersionedClause<OMPC_AcqRel, 50>, 630 VersionedClause<OMPC_Acquire, 50>, 631 VersionedClause<OMPC_Release, 50>, 632 VersionedClause<OMPC_Relaxed, 50>, 633 VersionedClause<OMPC_Hint, 50> 634 ]; 635} 636def OMP_Target : Directive<"target"> { 637 let allowedClauses = [ 638 VersionedClause<OMPC_If>, 639 VersionedClause<OMPC_Map>, 640 VersionedClause<OMPC_Private>, 641 VersionedClause<OMPC_Depend>, 642 VersionedClause<OMPC_FirstPrivate>, 643 VersionedClause<OMPC_IsDevicePtr>, 644 VersionedClause<OMPC_HasDeviceAddr, 51>, 645 VersionedClause<OMPC_Reduction>, 646 VersionedClause<OMPC_InReduction, 50>, 647 VersionedClause<OMPC_Allocate>, 648 VersionedClause<OMPC_UsesAllocators, 50> 649 ]; 650 let allowedOnceClauses = [ 651 VersionedClause<OMPC_Device>, 652 VersionedClause<OMPC_ThreadLimit, 51>, 653 VersionedClause<OMPC_DefaultMap>, 654 VersionedClause<OMPC_NoWait>, 655 VersionedClause<OMPC_OMPX_DynCGroupMem>, 656 ]; 657} 658def OMP_Teams : Directive<"teams"> { 659 let allowedClauses = [ 660 VersionedClause<OMPC_Private>, 661 VersionedClause<OMPC_FirstPrivate>, 662 VersionedClause<OMPC_Shared>, 663 VersionedClause<OMPC_Reduction>, 664 VersionedClause<OMPC_Allocate> 665 ]; 666 let allowedOnceClauses = [ 667 VersionedClause<OMPC_Default>, 668 VersionedClause<OMPC_NumTeams>, 669 VersionedClause<OMPC_ThreadLimit> 670 ]; 671} 672def OMP_Cancel : Directive<"cancel"> { 673 let allowedClauses = [ 674 VersionedClause<OMPC_If> 675 ]; 676} 677def OMP_Requires : Directive<"requires"> { 678 let allowedOnceClauses = [ 679 VersionedClause<OMPC_UnifiedAddress>, 680 VersionedClause<OMPC_UnifiedSharedMemory>, 681 // OpenMP 5.2 Spec: If an implementation is not supporting a requirement 682 // (reverse offload in this case) then it should give compile-time error 683 // termination. 684 // Seeting supported version for reverse_offload to a distant future version 685 // 9.9 so that its partial support can be tested in the meantime. 686 // 687 // TODO: Correct this supprted version number whenever complete 688 // implementation of reverse_offload is available. 689 VersionedClause<OMPC_ReverseOffload, 99>, 690 VersionedClause<OMPC_DynamicAllocators>, 691 VersionedClause<OMPC_AtomicDefaultMemOrder> 692 ]; 693} 694def OMP_Nothing : Directive<"nothing"> {} 695def OMP_TargetData : Directive<"target data"> { 696 let allowedClauses = [ 697 VersionedClause<OMPC_UseDevicePtr>, 698 VersionedClause<OMPC_UseDeviceAddr, 50> 699 ]; 700 let allowedOnceClauses = [ 701 VersionedClause<OMPC_Device>, 702 VersionedClause<OMPC_If> 703 ]; 704 let requiredClauses = [ 705 VersionedClause<OMPC_Map> 706 ]; 707} 708def OMP_TargetEnterData : Directive<"target enter data"> { 709 let allowedClauses = [ 710 VersionedClause<OMPC_Depend> 711 ]; 712 let allowedOnceClauses = [ 713 VersionedClause<OMPC_If>, 714 VersionedClause<OMPC_Device>, 715 VersionedClause<OMPC_NoWait> 716 ]; 717 let requiredClauses = [ 718 VersionedClause<OMPC_Map> 719 ]; 720} 721def OMP_TargetExitData : Directive<"target exit data"> { 722 let allowedClauses = [ 723 VersionedClause<OMPC_Depend> 724 ]; 725 let allowedOnceClauses = [ 726 VersionedClause<OMPC_Device>, 727 VersionedClause<OMPC_If>, 728 VersionedClause<OMPC_NoWait> 729 ]; 730 let requiredClauses = [ 731 VersionedClause<OMPC_Map> 732 ]; 733} 734def OMP_TargetParallel : Directive<"target parallel"> { 735 let allowedClauses = [ 736 VersionedClause<OMPC_Map>, 737 VersionedClause<OMPC_NoWait>, 738 VersionedClause<OMPC_Depend>, 739 VersionedClause<OMPC_Private>, 740 VersionedClause<OMPC_FirstPrivate>, 741 VersionedClause<OMPC_Default>, 742 VersionedClause<OMPC_Shared>, 743 VersionedClause<OMPC_Reduction>, 744 VersionedClause<OMPC_IsDevicePtr>, 745 VersionedClause<OMPC_HasDeviceAddr, 51>, 746 VersionedClause<OMPC_Allocate>, 747 VersionedClause<OMPC_UsesAllocators, 50> 748 ]; 749 let allowedOnceClauses = [ 750 VersionedClause<OMPC_DefaultMap>, 751 VersionedClause<OMPC_Device>, 752 VersionedClause<OMPC_If>, 753 VersionedClause<OMPC_NumThreads>, 754 VersionedClause<OMPC_ProcBind>, 755 VersionedClause<OMPC_OMPX_DynCGroupMem>, 756 ]; 757} 758def OMP_TargetParallelFor : Directive<"target parallel for"> { 759 let allowedClauses = [ 760 VersionedClause<OMPC_If>, 761 VersionedClause<OMPC_Device>, 762 VersionedClause<OMPC_Map>, 763 VersionedClause<OMPC_Private>, 764 VersionedClause<OMPC_FirstPrivate>, 765 VersionedClause<OMPC_LastPrivate>, 766 VersionedClause<OMPC_NoWait>, 767 VersionedClause<OMPC_Depend>, 768 VersionedClause<OMPC_DefaultMap>, 769 VersionedClause<OMPC_NumThreads>, 770 VersionedClause<OMPC_Default>, 771 VersionedClause<OMPC_ProcBind>, 772 VersionedClause<OMPC_Shared>, 773 VersionedClause<OMPC_Reduction>, 774 VersionedClause<OMPC_Collapse>, 775 VersionedClause<OMPC_Schedule>, 776 VersionedClause<OMPC_Ordered>, 777 VersionedClause<OMPC_Linear>, 778 VersionedClause<OMPC_IsDevicePtr>, 779 VersionedClause<OMPC_HasDeviceAddr, 51>, 780 VersionedClause<OMPC_Allocate>, 781 VersionedClause<OMPC_Order, 50>, 782 VersionedClause<OMPC_UsesAllocators, 50> 783 ]; 784 let allowedOnceClauses = [ 785 VersionedClause<OMPC_OMPX_DynCGroupMem>, 786 ]; 787} 788def OMP_TargetParallelDo : Directive<"target parallel do"> { 789 let allowedClauses = [ 790 VersionedClause<OMPC_Map>, 791 VersionedClause<OMPC_Private>, 792 VersionedClause<OMPC_FirstPrivate>, 793 VersionedClause<OMPC_LastPrivate>, 794 VersionedClause<OMPC_Depend>, 795 VersionedClause<OMPC_Shared>, 796 VersionedClause<OMPC_Reduction>, 797 VersionedClause<OMPC_Linear>, 798 VersionedClause<OMPC_IsDevicePtr>, 799 VersionedClause<OMPC_HasDeviceAddr, 51>, 800 VersionedClause<OMPC_Allocator>, 801 VersionedClause<OMPC_UsesAllocators>, 802 VersionedClause<OMPC_Default>, 803 VersionedClause<OMPC_Copyin> 804 ]; 805 let allowedOnceClauses = [ 806 VersionedClause<OMPC_If>, 807 VersionedClause<OMPC_NumThreads>, 808 VersionedClause<OMPC_ProcBind>, 809 VersionedClause<OMPC_Device>, 810 VersionedClause<OMPC_DefaultMap>, 811 VersionedClause<OMPC_Schedule>, 812 VersionedClause<OMPC_Collapse>, 813 VersionedClause<OMPC_Ordered>, 814 VersionedClause<OMPC_NoWait>, 815 VersionedClause<OMPC_Order, 50> 816 ]; 817} 818def OMP_TargetUpdate : Directive<"target update"> { 819 let allowedClauses = [ 820 VersionedClause<OMPC_To>, 821 VersionedClause<OMPC_From>, 822 VersionedClause<OMPC_Depend> 823 ]; 824 let allowedOnceClauses = [ 825 VersionedClause<OMPC_Device>, 826 VersionedClause<OMPC_If>, 827 VersionedClause<OMPC_NoWait> 828 ]; 829} 830def OMP_ParallelFor : Directive<"parallel for"> { 831 let allowedClauses = [ 832 VersionedClause<OMPC_If>, 833 VersionedClause<OMPC_NumThreads>, 834 VersionedClause<OMPC_Default>, 835 VersionedClause<OMPC_ProcBind>, 836 VersionedClause<OMPC_Private>, 837 VersionedClause<OMPC_FirstPrivate>, 838 VersionedClause<OMPC_Shared>, 839 VersionedClause<OMPC_Reduction>, 840 VersionedClause<OMPC_Copyin>, 841 VersionedClause<OMPC_LastPrivate>, 842 VersionedClause<OMPC_Collapse>, 843 VersionedClause<OMPC_Schedule>, 844 VersionedClause<OMPC_Ordered>, 845 VersionedClause<OMPC_Linear>, 846 VersionedClause<OMPC_Allocate>, 847 VersionedClause<OMPC_Order, 50> 848 ]; 849} 850def OMP_ParallelDo : Directive<"parallel do"> { 851 let allowedClauses = [ 852 VersionedClause<OMPC_Default>, 853 VersionedClause<OMPC_Private>, 854 VersionedClause<OMPC_FirstPrivate>, 855 VersionedClause<OMPC_Shared>, 856 VersionedClause<OMPC_Reduction>, 857 VersionedClause<OMPC_Copyin>, 858 VersionedClause<OMPC_LastPrivate>, 859 VersionedClause<OMPC_Linear> 860 ]; 861 let allowedOnceClauses = [ 862 VersionedClause<OMPC_If>, 863 VersionedClause<OMPC_NumThreads>, 864 VersionedClause<OMPC_ProcBind>, 865 VersionedClause<OMPC_Schedule>, 866 VersionedClause<OMPC_Ordered>, 867 VersionedClause<OMPC_Collapse>, 868 VersionedClause<OMPC_Order, 50> 869 ]; 870} 871def OMP_ParallelForSimd : Directive<"parallel for simd"> { 872 let allowedClauses = [ 873 VersionedClause<OMPC_If>, 874 VersionedClause<OMPC_NumThreads>, 875 VersionedClause<OMPC_Default>, 876 VersionedClause<OMPC_ProcBind>, 877 VersionedClause<OMPC_Private>, 878 VersionedClause<OMPC_FirstPrivate>, 879 VersionedClause<OMPC_Shared>, 880 VersionedClause<OMPC_Reduction>, 881 VersionedClause<OMPC_Copyin>, 882 VersionedClause<OMPC_LastPrivate>, 883 VersionedClause<OMPC_Collapse>, 884 VersionedClause<OMPC_Schedule>, 885 VersionedClause<OMPC_SafeLen>, 886 VersionedClause<OMPC_SimdLen>, 887 VersionedClause<OMPC_Linear>, 888 VersionedClause<OMPC_Aligned>, 889 VersionedClause<OMPC_Ordered>, 890 VersionedClause<OMPC_Allocate>, 891 VersionedClause<OMPC_NonTemporal, 50>, 892 VersionedClause<OMPC_Order, 50> 893 ]; 894} 895def OMP_ParallelDoSimd : Directive<"parallel do simd"> { 896 let allowedClauses = [ 897 VersionedClause<OMPC_Default>, 898 VersionedClause<OMPC_Private>, 899 VersionedClause<OMPC_FirstPrivate>, 900 VersionedClause<OMPC_Shared>, 901 VersionedClause<OMPC_Reduction>, 902 VersionedClause<OMPC_Copyin>, 903 VersionedClause<OMPC_LastPrivate>, 904 VersionedClause<OMPC_Linear>, 905 VersionedClause<OMPC_Aligned>, 906 VersionedClause<OMPC_Allocate>, 907 VersionedClause<OMPC_NonTemporal>, 908 ]; 909 let allowedOnceClauses = [ 910 VersionedClause<OMPC_If>, 911 VersionedClause<OMPC_NumThreads>, 912 VersionedClause<OMPC_ProcBind>, 913 VersionedClause<OMPC_Schedule>, 914 VersionedClause<OMPC_Ordered>, 915 VersionedClause<OMPC_Collapse>, 916 VersionedClause<OMPC_SafeLen>, 917 VersionedClause<OMPC_SimdLen>, 918 VersionedClause<OMPC_Order, 50> 919 ]; 920} 921def OMP_ParallelMaster : Directive<"parallel master"> { 922 let allowedClauses = [ 923 VersionedClause<OMPC_If>, 924 VersionedClause<OMPC_NumThreads>, 925 VersionedClause<OMPC_Default>, 926 VersionedClause<OMPC_Private>, 927 VersionedClause<OMPC_FirstPrivate>, 928 VersionedClause<OMPC_Shared>, 929 VersionedClause<OMPC_Copyin>, 930 VersionedClause<OMPC_Reduction>, 931 VersionedClause<OMPC_ProcBind>, 932 VersionedClause<OMPC_Allocate> 933 ]; 934} 935def OMP_ParallelMasked : Directive<"parallel masked"> { 936 let allowedClauses = [ 937 VersionedClause<OMPC_If>, 938 VersionedClause<OMPC_NumThreads>, 939 VersionedClause<OMPC_Default>, 940 VersionedClause<OMPC_Private>, 941 VersionedClause<OMPC_FirstPrivate>, 942 VersionedClause<OMPC_Shared>, 943 VersionedClause<OMPC_Copyin>, 944 VersionedClause<OMPC_Reduction>, 945 VersionedClause<OMPC_ProcBind>, 946 VersionedClause<OMPC_Allocate>, 947 VersionedClause<OMPC_Filter> 948 ]; 949} 950def OMP_ParallelSections : Directive<"parallel sections"> { 951 let allowedClauses = [ 952 VersionedClause<OMPC_If>, 953 VersionedClause<OMPC_Default>, 954 VersionedClause<OMPC_ProcBind>, 955 VersionedClause<OMPC_Private>, 956 VersionedClause<OMPC_FirstPrivate>, 957 VersionedClause<OMPC_Shared>, 958 VersionedClause<OMPC_Reduction>, 959 VersionedClause<OMPC_Copyin>, 960 VersionedClause<OMPC_LastPrivate>, 961 VersionedClause<OMPC_Allocate> 962 ]; 963 let allowedOnceClauses = [ 964 VersionedClause<OMPC_NumThreads> 965 ]; 966} 967def OMP_ForSimd : Directive<"for simd"> { 968 let allowedClauses = [ 969 VersionedClause<OMPC_Private>, 970 VersionedClause<OMPC_FirstPrivate>, 971 VersionedClause<OMPC_LastPrivate>, 972 VersionedClause<OMPC_Reduction>, 973 VersionedClause<OMPC_Schedule>, 974 VersionedClause<OMPC_Collapse>, 975 VersionedClause<OMPC_NoWait>, 976 VersionedClause<OMPC_SafeLen>, 977 VersionedClause<OMPC_SimdLen>, 978 VersionedClause<OMPC_Linear>, 979 VersionedClause<OMPC_Aligned>, 980 VersionedClause<OMPC_Ordered>, 981 VersionedClause<OMPC_Allocate>, 982 VersionedClause<OMPC_If, 50>, 983 VersionedClause<OMPC_NonTemporal, 50>, 984 VersionedClause<OMPC_Order, 50> 985 ]; 986} 987def OMP_DoSimd : Directive<"do simd"> { 988 let allowedClauses = [ 989 VersionedClause<OMPC_Aligned>, 990 VersionedClause<OMPC_Private>, 991 VersionedClause<OMPC_FirstPrivate>, 992 VersionedClause<OMPC_LastPrivate>, 993 VersionedClause<OMPC_Linear>, 994 VersionedClause<OMPC_Reduction> 995 ]; 996 let allowedOnceClauses = [ 997 VersionedClause<OMPC_Schedule>, 998 VersionedClause<OMPC_Collapse>, 999 VersionedClause<OMPC_Ordered>, 1000 VersionedClause<OMPC_SafeLen>, 1001 VersionedClause<OMPC_SimdLen>, 1002 VersionedClause<OMPC_NoWait>, 1003 VersionedClause<OMPC_Order, 50> 1004 ]; 1005} 1006def OMP_CancellationPoint : Directive<"cancellation point"> {} 1007def OMP_DeclareReduction : Directive<"declare reduction"> {} 1008def OMP_DeclareMapper : Directive<"declare mapper"> { 1009 let allowedClauses = [ 1010 VersionedClause<OMPC_Map> 1011 ]; 1012} 1013def OMP_DeclareSimd : Directive<"declare simd"> { 1014 let allowedClauses = [ 1015 VersionedClause<OMPC_Linear>, 1016 VersionedClause<OMPC_Aligned>, 1017 VersionedClause<OMPC_Uniform> 1018 ]; 1019 let allowedOnceClauses = [ 1020 VersionedClause<OMPC_SimdLen> 1021 ]; 1022 let allowedExclusiveClauses = [ 1023 VersionedClause<OMPC_Inbranch>, 1024 VersionedClause<OMPC_Notinbranch> 1025 ]; 1026} 1027def OMP_TaskLoop : Directive<"taskloop"> { 1028 let allowedClauses = [ 1029 VersionedClause<OMPC_Shared>, 1030 VersionedClause<OMPC_Private>, 1031 VersionedClause<OMPC_FirstPrivate>, 1032 VersionedClause<OMPC_LastPrivate>, 1033 VersionedClause<OMPC_Untied>, 1034 VersionedClause<OMPC_Mergeable>, 1035 VersionedClause<OMPC_NoGroup>, 1036 VersionedClause<OMPC_Reduction>, 1037 VersionedClause<OMPC_InReduction>, 1038 VersionedClause<OMPC_Allocate> 1039 ]; 1040 let allowedOnceClauses = [ 1041 VersionedClause<OMPC_Default>, 1042 VersionedClause<OMPC_If>, 1043 VersionedClause<OMPC_Collapse>, 1044 VersionedClause<OMPC_Final>, 1045 VersionedClause<OMPC_Priority>, 1046 ]; 1047 let allowedExclusiveClauses = [ 1048 VersionedClause<OMPC_GrainSize>, 1049 VersionedClause<OMPC_NumTasks> 1050 ]; 1051} 1052def OMP_TaskLoopSimd : Directive<"taskloop simd"> { 1053 let allowedClauses = [ 1054 VersionedClause<OMPC_Aligned>, 1055 VersionedClause<OMPC_Allocate>, 1056 VersionedClause<OMPC_Default>, 1057 VersionedClause<OMPC_FirstPrivate>, 1058 VersionedClause<OMPC_InReduction>, 1059 VersionedClause<OMPC_LastPrivate>, 1060 VersionedClause<OMPC_Linear>, 1061 VersionedClause<OMPC_Mergeable>, 1062 VersionedClause<OMPC_NoGroup>, 1063 VersionedClause<OMPC_NonTemporal, 50>, 1064 VersionedClause<OMPC_Private>, 1065 VersionedClause<OMPC_Reduction>, 1066 VersionedClause<OMPC_Shared>, 1067 VersionedClause<OMPC_Untied> 1068 ]; 1069 let allowedOnceClauses = [ 1070 VersionedClause<OMPC_If>, 1071 VersionedClause<OMPC_Collapse>, 1072 VersionedClause<OMPC_SafeLen>, 1073 VersionedClause<OMPC_SimdLen>, 1074 VersionedClause<OMPC_Final>, 1075 VersionedClause<OMPC_Priority>, 1076 VersionedClause<OMPC_Order, 50> 1077 ]; 1078 let allowedExclusiveClauses = [ 1079 VersionedClause<OMPC_GrainSize>, 1080 VersionedClause<OMPC_NumTasks> 1081 ]; 1082} 1083def OMP_Distribute : Directive<"distribute"> { 1084 let allowedClauses = [ 1085 VersionedClause<OMPC_Private>, 1086 VersionedClause<OMPC_FirstPrivate>, 1087 VersionedClause<OMPC_LastPrivate>, 1088 VersionedClause<OMPC_Allocate> 1089 ]; 1090 let allowedOnceClauses = [ 1091 VersionedClause<OMPC_Collapse>, 1092 VersionedClause<OMPC_DistSchedule> 1093 ]; 1094} 1095def OMP_BeginDeclareTarget : Directive<"begin declare target"> { 1096 let allowedClauses = [ 1097 VersionedClause<OMPC_To>, 1098 VersionedClause<OMPC_Link>, 1099 VersionedClause<OMPC_DeviceType>, 1100 VersionedClause<OMPC_Indirect> 1101 ]; 1102} 1103def OMP_DeclareTarget : Directive<"declare target"> { 1104 let allowedClauses = [ 1105 VersionedClause<OMPC_To>, 1106 VersionedClause<OMPC_Link>, 1107 VersionedClause<OMPC_Indirect> 1108 ]; 1109 let allowedOnceClauses = [ 1110 VersionedClause<OMPC_DeviceType, 50> 1111 ]; 1112} 1113def OMP_EndDeclareTarget : Directive<"end declare target"> {} 1114def OMP_DistributeParallelFor : Directive<"distribute parallel for"> { 1115 let allowedClauses = [ 1116 VersionedClause<OMPC_FirstPrivate>, 1117 VersionedClause<OMPC_LastPrivate>, 1118 VersionedClause<OMPC_Collapse>, 1119 VersionedClause<OMPC_DistSchedule>, 1120 VersionedClause<OMPC_If>, 1121 VersionedClause<OMPC_NumThreads>, 1122 VersionedClause<OMPC_Default>, 1123 VersionedClause<OMPC_ProcBind>, 1124 VersionedClause<OMPC_Private>, 1125 VersionedClause<OMPC_Shared>, 1126 VersionedClause<OMPC_Reduction>, 1127 VersionedClause<OMPC_Copyin>, 1128 VersionedClause<OMPC_Schedule>, 1129 VersionedClause<OMPC_Allocate>, 1130 VersionedClause<OMPC_Order, 50> 1131 ]; 1132} 1133def OMP_DistributeParallelDo : Directive<"distribute parallel do"> { 1134 let allowedClauses = [ 1135 VersionedClause<OMPC_Private>, 1136 VersionedClause<OMPC_FirstPrivate>, 1137 VersionedClause<OMPC_LastPrivate>, 1138 VersionedClause<OMPC_Allocate>, 1139 VersionedClause<OMPC_Default>, 1140 VersionedClause<OMPC_Shared>, 1141 VersionedClause<OMPC_Reduction>, 1142 VersionedClause<OMPC_Copyin>, 1143 VersionedClause<OMPC_Linear> 1144 ]; 1145 let allowedOnceClauses = [ 1146 VersionedClause<OMPC_Collapse>, 1147 VersionedClause<OMPC_DistSchedule>, 1148 VersionedClause<OMPC_If>, 1149 VersionedClause<OMPC_NumThreads>, 1150 VersionedClause<OMPC_ProcBind>, 1151 VersionedClause<OMPC_Schedule>, 1152 VersionedClause<OMPC_Ordered>, 1153 VersionedClause<OMPC_Order, 50> 1154 ]; 1155} 1156def OMP_DistributeParallelForSimd : Directive<"distribute parallel for simd"> { 1157 let allowedClauses = [ 1158 VersionedClause<OMPC_FirstPrivate>, 1159 VersionedClause<OMPC_LastPrivate>, 1160 VersionedClause<OMPC_Collapse>, 1161 VersionedClause<OMPC_DistSchedule>, 1162 VersionedClause<OMPC_If>, 1163 VersionedClause<OMPC_NumThreads>, 1164 VersionedClause<OMPC_Default>, 1165 VersionedClause<OMPC_ProcBind>, 1166 VersionedClause<OMPC_Private>, 1167 VersionedClause<OMPC_Shared>, 1168 VersionedClause<OMPC_Reduction>, 1169 VersionedClause<OMPC_Copyin>, 1170 VersionedClause<OMPC_Schedule>, 1171 VersionedClause<OMPC_Linear>, 1172 VersionedClause<OMPC_Aligned>, 1173 VersionedClause<OMPC_SafeLen>, 1174 VersionedClause<OMPC_SimdLen>, 1175 VersionedClause<OMPC_Allocate>, 1176 VersionedClause<OMPC_NonTemporal, 50>, 1177 VersionedClause<OMPC_Order, 50> 1178 ]; 1179} 1180def OMP_DistributeParallelDoSimd : Directive<"distribute parallel do simd"> { 1181 let allowedClauses = [ 1182 VersionedClause<OMPC_FirstPrivate>, 1183 VersionedClause<OMPC_LastPrivate>, 1184 VersionedClause<OMPC_Collapse>, 1185 VersionedClause<OMPC_DistSchedule>, 1186 VersionedClause<OMPC_If>, 1187 VersionedClause<OMPC_NumThreads>, 1188 VersionedClause<OMPC_Default>, 1189 VersionedClause<OMPC_ProcBind>, 1190 VersionedClause<OMPC_Private>, 1191 VersionedClause<OMPC_Shared>, 1192 VersionedClause<OMPC_Reduction>, 1193 VersionedClause<OMPC_Copyin>, 1194 VersionedClause<OMPC_Schedule>, 1195 VersionedClause<OMPC_Linear>, 1196 VersionedClause<OMPC_Aligned>, 1197 VersionedClause<OMPC_SafeLen>, 1198 VersionedClause<OMPC_SimdLen>, 1199 VersionedClause<OMPC_Allocate>, 1200 VersionedClause<OMPC_NonTemporal>, 1201 VersionedClause<OMPC_Order, 50> 1202 ]; 1203} 1204def OMP_DistributeSimd : Directive<"distribute simd"> { 1205 let allowedClauses = [ 1206 VersionedClause<OMPC_Aligned>, 1207 VersionedClause<OMPC_Allocate>, 1208 VersionedClause<OMPC_Copyin>, 1209 VersionedClause<OMPC_Default>, 1210 VersionedClause<OMPC_Linear>, 1211 VersionedClause<OMPC_FirstPrivate>, 1212 VersionedClause<OMPC_LastPrivate>, 1213 VersionedClause<OMPC_NonTemporal, 50>, 1214 VersionedClause<OMPC_Private>, 1215 VersionedClause<OMPC_Reduction> 1216 ]; 1217 let allowedOnceClauses = [ 1218 VersionedClause<OMPC_Collapse>, 1219 VersionedClause<OMPC_DistSchedule>, 1220 VersionedClause<OMPC_If, 50>, 1221 VersionedClause<OMPC_NumThreads>, 1222 VersionedClause<OMPC_Ordered>, 1223 VersionedClause<OMPC_ProcBind>, 1224 VersionedClause<OMPC_Schedule>, 1225 VersionedClause<OMPC_SafeLen>, 1226 VersionedClause<OMPC_SimdLen>, 1227 VersionedClause<OMPC_Order, 50> 1228 ]; 1229} 1230 1231def OMP_TargetParallelForSimd : Directive<"target parallel for simd"> { 1232 let allowedClauses = [ 1233 VersionedClause<OMPC_If>, 1234 VersionedClause<OMPC_Device>, 1235 VersionedClause<OMPC_Map>, 1236 VersionedClause<OMPC_Private>, 1237 VersionedClause<OMPC_FirstPrivate>, 1238 VersionedClause<OMPC_LastPrivate>, 1239 VersionedClause<OMPC_NoWait>, 1240 VersionedClause<OMPC_Depend>, 1241 VersionedClause<OMPC_DefaultMap>, 1242 VersionedClause<OMPC_NumThreads>, 1243 VersionedClause<OMPC_Default>, 1244 VersionedClause<OMPC_ProcBind>, 1245 VersionedClause<OMPC_Shared>, 1246 VersionedClause<OMPC_Reduction>, 1247 VersionedClause<OMPC_Collapse>, 1248 VersionedClause<OMPC_Schedule>, 1249 VersionedClause<OMPC_Ordered>, 1250 VersionedClause<OMPC_Linear>, 1251 VersionedClause<OMPC_SafeLen>, 1252 VersionedClause<OMPC_SimdLen>, 1253 VersionedClause<OMPC_Aligned>, 1254 VersionedClause<OMPC_IsDevicePtr>, 1255 VersionedClause<OMPC_HasDeviceAddr, 51>, 1256 VersionedClause<OMPC_Allocate>, 1257 VersionedClause<OMPC_NonTemporal, 50>, 1258 VersionedClause<OMPC_Order, 50>, 1259 VersionedClause<OMPC_UsesAllocators, 50> 1260 ]; 1261 let allowedOnceClauses = [ 1262 VersionedClause<OMPC_OMPX_DynCGroupMem>, 1263 ]; 1264} 1265def OMP_TargetParallelDoSimd : Directive<"target parallel do simd"> { 1266 let allowedClauses = [ 1267 VersionedClause<OMPC_If>, 1268 VersionedClause<OMPC_Device>, 1269 VersionedClause<OMPC_Map>, 1270 VersionedClause<OMPC_Private>, 1271 VersionedClause<OMPC_FirstPrivate>, 1272 VersionedClause<OMPC_LastPrivate>, 1273 VersionedClause<OMPC_NoWait>, 1274 VersionedClause<OMPC_Depend>, 1275 VersionedClause<OMPC_DefaultMap>, 1276 VersionedClause<OMPC_NumThreads>, 1277 VersionedClause<OMPC_Default>, 1278 VersionedClause<OMPC_ProcBind>, 1279 VersionedClause<OMPC_Shared>, 1280 VersionedClause<OMPC_Reduction>, 1281 VersionedClause<OMPC_Collapse>, 1282 VersionedClause<OMPC_Schedule>, 1283 VersionedClause<OMPC_Ordered>, 1284 VersionedClause<OMPC_Linear>, 1285 VersionedClause<OMPC_SafeLen>, 1286 VersionedClause<OMPC_SimdLen>, 1287 VersionedClause<OMPC_Aligned>, 1288 VersionedClause<OMPC_IsDevicePtr>, 1289 VersionedClause<OMPC_HasDeviceAddr, 51>, 1290 VersionedClause<OMPC_Allocate>, 1291 VersionedClause<OMPC_NonTemporal>, 1292 VersionedClause<OMPC_Order, 50>, 1293 VersionedClause<OMPC_UsesAllocators> 1294 ]; 1295} 1296def OMP_TargetSimd : Directive<"target simd"> { 1297 let allowedClauses = [ 1298 VersionedClause<OMPC_Aligned>, 1299 VersionedClause<OMPC_Allocate>, 1300 VersionedClause<OMPC_Depend>, 1301 VersionedClause<OMPC_FirstPrivate>, 1302 VersionedClause<OMPC_IsDevicePtr>, 1303 VersionedClause<OMPC_HasDeviceAddr, 51>, 1304 VersionedClause<OMPC_LastPrivate>, 1305 VersionedClause<OMPC_Linear>, 1306 VersionedClause<OMPC_Map>, 1307 VersionedClause<OMPC_NonTemporal, 50>, 1308 VersionedClause<OMPC_NoWait>, 1309 VersionedClause<OMPC_Private>, 1310 VersionedClause<OMPC_Reduction>, 1311 VersionedClause<OMPC_Shared>, 1312 VersionedClause<OMPC_UsesAllocators, 50> 1313 ]; 1314 let allowedOnceClauses = [ 1315 VersionedClause<OMPC_Collapse>, 1316 VersionedClause<OMPC_SafeLen>, 1317 VersionedClause<OMPC_SimdLen>, 1318 VersionedClause<OMPC_If>, 1319 VersionedClause<OMPC_NumThreads>, 1320 VersionedClause<OMPC_ProcBind>, 1321 VersionedClause<OMPC_Device>, 1322 VersionedClause<OMPC_DefaultMap>, 1323 VersionedClause<OMPC_Schedule>, 1324 VersionedClause<OMPC_OMPX_DynCGroupMem>, 1325 VersionedClause<OMPC_Order, 50> 1326 ]; 1327} 1328def OMP_TeamsDistribute : Directive<"teams distribute"> { 1329 let allowedClauses = [ 1330 VersionedClause<OMPC_Default>, 1331 VersionedClause<OMPC_Private>, 1332 VersionedClause<OMPC_FirstPrivate>, 1333 VersionedClause<OMPC_Shared>, 1334 VersionedClause<OMPC_Reduction>, 1335 VersionedClause<OMPC_NumTeams>, 1336 VersionedClause<OMPC_ThreadLimit>, 1337 VersionedClause<OMPC_LastPrivate>, 1338 VersionedClause<OMPC_Collapse>, 1339 VersionedClause<OMPC_DistSchedule>, 1340 VersionedClause<OMPC_Allocate> 1341 ]; 1342} 1343def OMP_TeamsDistributeSimd : Directive<"teams distribute simd"> { 1344 let allowedClauses = [ 1345 VersionedClause<OMPC_Aligned>, 1346 VersionedClause<OMPC_Allocate>, 1347 VersionedClause<OMPC_FirstPrivate>, 1348 VersionedClause<OMPC_LastPrivate>, 1349 VersionedClause<OMPC_Linear>, 1350 VersionedClause<OMPC_NonTemporal, 50>, 1351 VersionedClause<OMPC_Private>, 1352 VersionedClause<OMPC_Reduction>, 1353 VersionedClause<OMPC_Shared> 1354 ]; 1355 let allowedOnceClauses = [ 1356 VersionedClause<OMPC_Collapse>, 1357 VersionedClause<OMPC_Default>, 1358 VersionedClause<OMPC_DistSchedule>, 1359 VersionedClause<OMPC_If, 50>, 1360 VersionedClause<OMPC_NumTeams>, 1361 VersionedClause<OMPC_SafeLen>, 1362 VersionedClause<OMPC_SimdLen>, 1363 VersionedClause<OMPC_ThreadLimit>, 1364 VersionedClause<OMPC_Order, 50> 1365 ]; 1366} 1367 1368def OMP_TeamsDistributeParallelForSimd : 1369 Directive<"teams distribute parallel for simd"> { 1370 let allowedClauses = [ 1371 VersionedClause<OMPC_FirstPrivate>, 1372 VersionedClause<OMPC_LastPrivate>, 1373 VersionedClause<OMPC_Collapse>, 1374 VersionedClause<OMPC_DistSchedule>, 1375 VersionedClause<OMPC_If>, 1376 VersionedClause<OMPC_NumThreads>, 1377 VersionedClause<OMPC_Default>, 1378 VersionedClause<OMPC_ProcBind>, 1379 VersionedClause<OMPC_Private>, 1380 VersionedClause<OMPC_Shared>, 1381 VersionedClause<OMPC_Reduction>, 1382 VersionedClause<OMPC_Schedule>, 1383 VersionedClause<OMPC_Linear>, 1384 VersionedClause<OMPC_Aligned>, 1385 VersionedClause<OMPC_SafeLen>, 1386 VersionedClause<OMPC_SimdLen>, 1387 VersionedClause<OMPC_NumTeams>, 1388 VersionedClause<OMPC_ThreadLimit>, 1389 VersionedClause<OMPC_Allocate>, 1390 VersionedClause<OMPC_NonTemporal, 50>, 1391 VersionedClause<OMPC_Order, 50> 1392 ]; 1393} 1394def OMP_TeamsDistributeParallelDoSimd : 1395 Directive<"teams distribute parallel do simd"> { 1396 let allowedClauses = [ 1397 VersionedClause<OMPC_Private>, 1398 VersionedClause<OMPC_FirstPrivate>, 1399 VersionedClause<OMPC_LastPrivate>, 1400 VersionedClause<OMPC_Allocate>, 1401 VersionedClause<OMPC_Shared>, 1402 VersionedClause<OMPC_Reduction>, 1403 VersionedClause<OMPC_Linear>, 1404 VersionedClause<OMPC_Aligned>, 1405 VersionedClause<OMPC_NonTemporal> 1406 ]; 1407 let allowedOnceClauses = [ 1408 VersionedClause<OMPC_Default>, 1409 VersionedClause<OMPC_NumTeams>, 1410 VersionedClause<OMPC_ThreadLimit>, 1411 VersionedClause<OMPC_Collapse>, 1412 VersionedClause<OMPC_DistSchedule>, 1413 VersionedClause<OMPC_NumThreads>, 1414 VersionedClause<OMPC_ProcBind>, 1415 VersionedClause<OMPC_Schedule>, 1416 VersionedClause<OMPC_SafeLen>, 1417 VersionedClause<OMPC_SimdLen>, 1418 VersionedClause<OMPC_If>, 1419 VersionedClause<OMPC_Order, 50> 1420 ]; 1421} 1422def OMP_TeamsDistributeParallelFor : 1423 Directive<"teams distribute parallel for"> { 1424 let allowedClauses = [ 1425 VersionedClause<OMPC_FirstPrivate>, 1426 VersionedClause<OMPC_LastPrivate>, 1427 VersionedClause<OMPC_Collapse>, 1428 VersionedClause<OMPC_DistSchedule>, 1429 VersionedClause<OMPC_If>, 1430 VersionedClause<OMPC_NumThreads>, 1431 VersionedClause<OMPC_Default>, 1432 VersionedClause<OMPC_ProcBind>, 1433 VersionedClause<OMPC_Private>, 1434 VersionedClause<OMPC_Shared>, 1435 VersionedClause<OMPC_Reduction>, 1436 VersionedClause<OMPC_Schedule>, 1437 VersionedClause<OMPC_NumTeams>, 1438 VersionedClause<OMPC_ThreadLimit>, 1439 VersionedClause<OMPC_Copyin>, 1440 VersionedClause<OMPC_Allocate>, 1441 VersionedClause<OMPC_Order, 50> 1442 ]; 1443} 1444def OMP_TeamsDistributeParallelDo : 1445 Directive<"teams distribute parallel do"> { 1446 let allowedClauses = [ 1447 VersionedClause<OMPC_Private>, 1448 VersionedClause<OMPC_FirstPrivate>, 1449 VersionedClause<OMPC_LastPrivate>, 1450 VersionedClause<OMPC_Shared>, 1451 VersionedClause<OMPC_Reduction>, 1452 VersionedClause<OMPC_Allocate>, 1453 VersionedClause<OMPC_Copyin>, 1454 VersionedClause<OMPC_Linear> 1455 ]; 1456let allowedOnceClauses = [ 1457 VersionedClause<OMPC_NumTeams>, 1458 VersionedClause<OMPC_ThreadLimit>, 1459 VersionedClause<OMPC_Default>, 1460 VersionedClause<OMPC_Collapse>, 1461 VersionedClause<OMPC_DistSchedule>, 1462 VersionedClause<OMPC_Ordered>, 1463 VersionedClause<OMPC_If>, 1464 VersionedClause<OMPC_NumThreads>, 1465 VersionedClause<OMPC_ProcBind>, 1466 VersionedClause<OMPC_Schedule>, 1467 VersionedClause<OMPC_Order, 50> 1468 ]; 1469} 1470def OMP_TargetTeams : Directive<"target teams"> { 1471 let allowedClauses = [ 1472 VersionedClause<OMPC_If>, 1473 VersionedClause<OMPC_Map>, 1474 VersionedClause<OMPC_Private>, 1475 VersionedClause<OMPC_Depend>, 1476 VersionedClause<OMPC_FirstPrivate>, 1477 VersionedClause<OMPC_IsDevicePtr>, 1478 VersionedClause<OMPC_HasDeviceAddr, 51>, 1479 VersionedClause<OMPC_Reduction>, 1480 VersionedClause<OMPC_Allocate>, 1481 VersionedClause<OMPC_UsesAllocators, 50>, 1482 VersionedClause<OMPC_Shared> 1483 ]; 1484 1485 let allowedOnceClauses = [ 1486 VersionedClause<OMPC_Device>, 1487 VersionedClause<OMPC_NoWait>, 1488 VersionedClause<OMPC_DefaultMap>, 1489 VersionedClause<OMPC_Default>, 1490 VersionedClause<OMPC_NumTeams>, 1491 VersionedClause<OMPC_ThreadLimit>, 1492 VersionedClause<OMPC_OMPX_DynCGroupMem>, 1493 ]; 1494} 1495def OMP_TargetTeamsDistribute : Directive<"target teams distribute"> { 1496 let allowedClauses = [ 1497 VersionedClause<OMPC_If>, 1498 VersionedClause<OMPC_Map>, 1499 VersionedClause<OMPC_Private>, 1500 VersionedClause<OMPC_Depend>, 1501 VersionedClause<OMPC_FirstPrivate>, 1502 VersionedClause<OMPC_IsDevicePtr>, 1503 VersionedClause<OMPC_HasDeviceAddr, 51>, 1504 VersionedClause<OMPC_Reduction>, 1505 VersionedClause<OMPC_Allocate>, 1506 VersionedClause<OMPC_UsesAllocators, 50>, 1507 VersionedClause<OMPC_Shared>, 1508 VersionedClause<OMPC_LastPrivate> 1509 ]; 1510 let allowedOnceClauses = [ 1511 VersionedClause<OMPC_Device>, 1512 VersionedClause<OMPC_NoWait>, 1513 VersionedClause<OMPC_DefaultMap>, 1514 VersionedClause<OMPC_Default>, 1515 VersionedClause<OMPC_NumTeams>, 1516 VersionedClause<OMPC_ThreadLimit>, 1517 VersionedClause<OMPC_Collapse>, 1518 VersionedClause<OMPC_DistSchedule>, 1519 VersionedClause<OMPC_OMPX_DynCGroupMem>, 1520 ]; 1521} 1522 1523def OMP_TargetTeamsDistributeParallelFor : 1524 Directive<"target teams distribute parallel for"> { 1525 let allowedClauses = [ 1526 VersionedClause<OMPC_If>, 1527 VersionedClause<OMPC_Device>, 1528 VersionedClause<OMPC_Map>, 1529 VersionedClause<OMPC_Private>, 1530 VersionedClause<OMPC_NoWait>, 1531 VersionedClause<OMPC_Depend>, 1532 VersionedClause<OMPC_DefaultMap>, 1533 VersionedClause<OMPC_FirstPrivate>, 1534 VersionedClause<OMPC_IsDevicePtr>, 1535 VersionedClause<OMPC_HasDeviceAddr, 51>, 1536 VersionedClause<OMPC_Default>, 1537 VersionedClause<OMPC_Shared>, 1538 VersionedClause<OMPC_Reduction>, 1539 VersionedClause<OMPC_NumTeams>, 1540 VersionedClause<OMPC_ThreadLimit>, 1541 VersionedClause<OMPC_LastPrivate>, 1542 VersionedClause<OMPC_Collapse>, 1543 VersionedClause<OMPC_DistSchedule>, 1544 VersionedClause<OMPC_NumThreads>, 1545 VersionedClause<OMPC_ProcBind>, 1546 VersionedClause<OMPC_Schedule>, 1547 VersionedClause<OMPC_Allocate>, 1548 VersionedClause<OMPC_Order, 50>, 1549 VersionedClause<OMPC_UsesAllocators, 50> 1550 ]; 1551 let allowedOnceClauses = [ 1552 VersionedClause<OMPC_OMPX_DynCGroupMem>, 1553 ]; 1554} 1555def OMP_TargetTeamsDistributeParallelDo : 1556 Directive<"target teams distribute parallel do"> { 1557 let allowedClauses = [ 1558 VersionedClause<OMPC_If>, 1559 VersionedClause<OMPC_Map>, 1560 VersionedClause<OMPC_Private>, 1561 VersionedClause<OMPC_Depend>, 1562 VersionedClause<OMPC_FirstPrivate>, 1563 VersionedClause<OMPC_IsDevicePtr>, 1564 VersionedClause<OMPC_HasDeviceAddr, 51>, 1565 VersionedClause<OMPC_Reduction>, 1566 VersionedClause<OMPC_Allocate>, 1567 VersionedClause<OMPC_UsesAllocators>, 1568 VersionedClause<OMPC_Shared>, 1569 VersionedClause<OMPC_LastPrivate>, 1570 VersionedClause<OMPC_Copyin>, 1571 VersionedClause<OMPC_Linear>, 1572 VersionedClause<OMPC_Ordered>, 1573 ]; 1574 let allowedOnceClauses = [ 1575 VersionedClause<OMPC_Device>, 1576 VersionedClause<OMPC_DefaultMap>, 1577 VersionedClause<OMPC_NoWait>, 1578 VersionedClause<OMPC_Default>, 1579 VersionedClause<OMPC_NumTeams>, 1580 VersionedClause<OMPC_ThreadLimit>, 1581 VersionedClause<OMPC_Collapse>, 1582 VersionedClause<OMPC_DistSchedule>, 1583 VersionedClause<OMPC_NumThreads>, 1584 VersionedClause<OMPC_ProcBind>, 1585 VersionedClause<OMPC_Schedule>, 1586 VersionedClause<OMPC_Order, 50> 1587 ]; 1588} 1589def OMP_TargetTeamsDistributeParallelForSimd : 1590 Directive<"target teams distribute parallel for simd"> { 1591 let allowedClauses = [ 1592 VersionedClause<OMPC_If>, 1593 VersionedClause<OMPC_Device>, 1594 VersionedClause<OMPC_Map>, 1595 VersionedClause<OMPC_Private>, 1596 VersionedClause<OMPC_NoWait>, 1597 VersionedClause<OMPC_Depend>, 1598 VersionedClause<OMPC_DefaultMap>, 1599 VersionedClause<OMPC_FirstPrivate>, 1600 VersionedClause<OMPC_IsDevicePtr>, 1601 VersionedClause<OMPC_HasDeviceAddr, 51>, 1602 VersionedClause<OMPC_Default>, 1603 VersionedClause<OMPC_Shared>, 1604 VersionedClause<OMPC_Reduction>, 1605 VersionedClause<OMPC_NumTeams>, 1606 VersionedClause<OMPC_ThreadLimit>, 1607 VersionedClause<OMPC_LastPrivate>, 1608 VersionedClause<OMPC_Collapse>, 1609 VersionedClause<OMPC_DistSchedule>, 1610 VersionedClause<OMPC_NumThreads>, 1611 VersionedClause<OMPC_ProcBind>, 1612 VersionedClause<OMPC_Schedule>, 1613 VersionedClause<OMPC_Linear>, 1614 VersionedClause<OMPC_Aligned>, 1615 VersionedClause<OMPC_SafeLen>, 1616 VersionedClause<OMPC_SimdLen>, 1617 VersionedClause<OMPC_Allocate>, 1618 VersionedClause<OMPC_NonTemporal, 50>, 1619 VersionedClause<OMPC_Order, 50>, 1620 VersionedClause<OMPC_UsesAllocators, 50> 1621 ]; 1622 let allowedOnceClauses = [ 1623 VersionedClause<OMPC_OMPX_DynCGroupMem>, 1624 ]; 1625} 1626def OMP_TargetTeamsDistributeParallelDoSimd : 1627 Directive<"target teams distribute parallel do simd"> { 1628 let allowedClauses = [ 1629 VersionedClause<OMPC_Map>, 1630 VersionedClause<OMPC_Private>, 1631 VersionedClause<OMPC_Depend>, 1632 VersionedClause<OMPC_FirstPrivate>, 1633 VersionedClause<OMPC_IsDevicePtr>, 1634 VersionedClause<OMPC_HasDeviceAddr, 51>, 1635 VersionedClause<OMPC_Reduction>, 1636 VersionedClause<OMPC_Allocate>, 1637 VersionedClause<OMPC_UsesAllocators>, 1638 VersionedClause<OMPC_Shared>, 1639 VersionedClause<OMPC_LastPrivate>, 1640 VersionedClause<OMPC_Copyin>, 1641 VersionedClause<OMPC_Linear>, 1642 VersionedClause<OMPC_Ordered>, 1643 VersionedClause<OMPC_Aligned>, 1644 VersionedClause<OMPC_NonTemporal> 1645 ]; 1646 let allowedOnceClauses = [ 1647 VersionedClause<OMPC_If>, 1648 VersionedClause<OMPC_Device>, 1649 VersionedClause<OMPC_NoWait>, 1650 VersionedClause<OMPC_DefaultMap>, 1651 VersionedClause<OMPC_Default>, 1652 VersionedClause<OMPC_NumTeams>, 1653 VersionedClause<OMPC_ThreadLimit>, 1654 VersionedClause<OMPC_Collapse>, 1655 VersionedClause<OMPC_DistSchedule>, 1656 VersionedClause<OMPC_NumThreads>, 1657 VersionedClause<OMPC_ProcBind>, 1658 VersionedClause<OMPC_Schedule>, 1659 VersionedClause<OMPC_SafeLen>, 1660 VersionedClause<OMPC_SimdLen>, 1661 VersionedClause<OMPC_Order, 50> 1662 ]; 1663} 1664def OMP_TargetTeamsDistributeSimd : 1665 Directive<"target teams distribute simd"> { 1666 let allowedClauses = [ 1667 VersionedClause<OMPC_Aligned>, 1668 VersionedClause<OMPC_Allocate>, 1669 VersionedClause<OMPC_Depend>, 1670 VersionedClause<OMPC_FirstPrivate>, 1671 VersionedClause<OMPC_If>, 1672 VersionedClause<OMPC_IsDevicePtr>, 1673 VersionedClause<OMPC_HasDeviceAddr, 51>, 1674 VersionedClause<OMPC_LastPrivate>, 1675 VersionedClause<OMPC_Linear>, 1676 VersionedClause<OMPC_Map>, 1677 VersionedClause<OMPC_NonTemporal, 50>, 1678 VersionedClause<OMPC_Private>, 1679 VersionedClause<OMPC_Reduction>, 1680 VersionedClause<OMPC_Shared>, 1681 VersionedClause<OMPC_UsesAllocators, 50> 1682 ]; 1683 let allowedOnceClauses = [ 1684 VersionedClause<OMPC_Device>, 1685 VersionedClause<OMPC_DefaultMap>, 1686 VersionedClause<OMPC_NoWait>, 1687 VersionedClause<OMPC_NumTeams>, 1688 VersionedClause<OMPC_ThreadLimit>, 1689 VersionedClause<OMPC_Collapse>, 1690 VersionedClause<OMPC_DistSchedule>, 1691 VersionedClause<OMPC_SafeLen>, 1692 VersionedClause<OMPC_SimdLen>, 1693 VersionedClause<OMPC_OMPX_DynCGroupMem>, 1694 VersionedClause<OMPC_Order, 50> 1695 ]; 1696} 1697def OMP_Allocate : Directive<"allocate"> { 1698 let allowedOnceClauses = [ 1699 VersionedClause<OMPC_Allocator>, 1700 VersionedClause<OMPC_Align, 51> 1701 ]; 1702} 1703def OMP_DeclareVariant : Directive<"declare variant"> { 1704 let allowedClauses = [ 1705 VersionedClause<OMPC_Match> 1706 ]; 1707 let allowedExclusiveClauses = [ 1708 VersionedClause<OMPC_AdjustArgs, 51>, 1709 VersionedClause<OMPC_AppendArgs, 51> 1710 ]; 1711} 1712def OMP_MasterTaskloop : Directive<"master taskloop"> { 1713 let allowedClauses = [ 1714 VersionedClause<OMPC_If>, 1715 VersionedClause<OMPC_Shared>, 1716 VersionedClause<OMPC_Private>, 1717 VersionedClause<OMPC_FirstPrivate>, 1718 VersionedClause<OMPC_LastPrivate>, 1719 VersionedClause<OMPC_Default>, 1720 VersionedClause<OMPC_Collapse>, 1721 VersionedClause<OMPC_Final>, 1722 VersionedClause<OMPC_Untied>, 1723 VersionedClause<OMPC_Mergeable>, 1724 VersionedClause<OMPC_Priority>, 1725 VersionedClause<OMPC_GrainSize>, 1726 VersionedClause<OMPC_NoGroup>, 1727 VersionedClause<OMPC_NumTasks>, 1728 VersionedClause<OMPC_Reduction>, 1729 VersionedClause<OMPC_InReduction>, 1730 VersionedClause<OMPC_Allocate> 1731 ]; 1732} 1733def OMP_MaskedTaskloop : Directive<"masked taskloop"> { 1734 let allowedClauses = [ 1735 VersionedClause<OMPC_If>, 1736 VersionedClause<OMPC_Shared>, 1737 VersionedClause<OMPC_Private>, 1738 VersionedClause<OMPC_FirstPrivate>, 1739 VersionedClause<OMPC_LastPrivate>, 1740 VersionedClause<OMPC_Default>, 1741 VersionedClause<OMPC_Collapse>, 1742 VersionedClause<OMPC_Final>, 1743 VersionedClause<OMPC_Untied>, 1744 VersionedClause<OMPC_Mergeable>, 1745 VersionedClause<OMPC_Priority>, 1746 VersionedClause<OMPC_GrainSize>, 1747 VersionedClause<OMPC_NoGroup>, 1748 VersionedClause<OMPC_NumTasks>, 1749 VersionedClause<OMPC_Reduction>, 1750 VersionedClause<OMPC_InReduction>, 1751 VersionedClause<OMPC_Allocate>, 1752 VersionedClause<OMPC_Filter> 1753 ]; 1754} 1755def OMP_ParallelMasterTaskloop : 1756 Directive<"parallel master taskloop"> { 1757 let allowedClauses = [ 1758 VersionedClause<OMPC_If>, 1759 VersionedClause<OMPC_Shared>, 1760 VersionedClause<OMPC_Private>, 1761 VersionedClause<OMPC_FirstPrivate>, 1762 VersionedClause<OMPC_LastPrivate>, 1763 VersionedClause<OMPC_Default>, 1764 VersionedClause<OMPC_Collapse>, 1765 VersionedClause<OMPC_Final>, 1766 VersionedClause<OMPC_Untied>, 1767 VersionedClause<OMPC_Mergeable>, 1768 VersionedClause<OMPC_Priority>, 1769 VersionedClause<OMPC_GrainSize>, 1770 VersionedClause<OMPC_NoGroup>, 1771 VersionedClause<OMPC_NumTasks>, 1772 VersionedClause<OMPC_Reduction>, 1773 VersionedClause<OMPC_Allocate>, 1774 VersionedClause<OMPC_NumThreads>, 1775 VersionedClause<OMPC_ProcBind>, 1776 VersionedClause<OMPC_Copyin> 1777 ]; 1778} 1779def OMP_ParallelMaskedTaskloop : 1780 Directive<"parallel masked taskloop"> { 1781 let allowedClauses = [ 1782 VersionedClause<OMPC_If>, 1783 VersionedClause<OMPC_Shared>, 1784 VersionedClause<OMPC_Private>, 1785 VersionedClause<OMPC_FirstPrivate>, 1786 VersionedClause<OMPC_LastPrivate>, 1787 VersionedClause<OMPC_Default>, 1788 VersionedClause<OMPC_Collapse>, 1789 VersionedClause<OMPC_Final>, 1790 VersionedClause<OMPC_Untied>, 1791 VersionedClause<OMPC_Mergeable>, 1792 VersionedClause<OMPC_Priority>, 1793 VersionedClause<OMPC_GrainSize>, 1794 VersionedClause<OMPC_NoGroup>, 1795 VersionedClause<OMPC_NumTasks>, 1796 VersionedClause<OMPC_Reduction>, 1797 VersionedClause<OMPC_Allocate>, 1798 VersionedClause<OMPC_NumThreads>, 1799 VersionedClause<OMPC_ProcBind>, 1800 VersionedClause<OMPC_Copyin>, 1801 VersionedClause<OMPC_Filter> 1802 ]; 1803} 1804def OMP_MasterTaskloopSimd : Directive<"master taskloop simd"> { 1805 let allowedClauses = [ 1806 VersionedClause<OMPC_If>, 1807 VersionedClause<OMPC_Shared>, 1808 VersionedClause<OMPC_Private>, 1809 VersionedClause<OMPC_FirstPrivate>, 1810 VersionedClause<OMPC_LastPrivate>, 1811 VersionedClause<OMPC_Default>, 1812 VersionedClause<OMPC_Collapse>, 1813 VersionedClause<OMPC_Final>, 1814 VersionedClause<OMPC_Untied>, 1815 VersionedClause<OMPC_Mergeable>, 1816 VersionedClause<OMPC_Priority>, 1817 VersionedClause<OMPC_Linear>, 1818 VersionedClause<OMPC_Aligned>, 1819 VersionedClause<OMPC_SafeLen>, 1820 VersionedClause<OMPC_SimdLen>, 1821 VersionedClause<OMPC_GrainSize>, 1822 VersionedClause<OMPC_NoGroup>, 1823 VersionedClause<OMPC_NumTasks>, 1824 VersionedClause<OMPC_Reduction>, 1825 VersionedClause<OMPC_InReduction>, 1826 VersionedClause<OMPC_Allocate>, 1827 VersionedClause<OMPC_NonTemporal, 50>, 1828 VersionedClause<OMPC_Order, 50> 1829 ]; 1830} 1831def OMP_MaskedTaskloopSimd : Directive<"masked taskloop simd"> { 1832 let allowedClauses = [ 1833 VersionedClause<OMPC_If>, 1834 VersionedClause<OMPC_Shared>, 1835 VersionedClause<OMPC_Private>, 1836 VersionedClause<OMPC_FirstPrivate>, 1837 VersionedClause<OMPC_LastPrivate>, 1838 VersionedClause<OMPC_Default>, 1839 VersionedClause<OMPC_Collapse>, 1840 VersionedClause<OMPC_Final>, 1841 VersionedClause<OMPC_Untied>, 1842 VersionedClause<OMPC_Mergeable>, 1843 VersionedClause<OMPC_Priority>, 1844 VersionedClause<OMPC_Linear>, 1845 VersionedClause<OMPC_Aligned>, 1846 VersionedClause<OMPC_SafeLen>, 1847 VersionedClause<OMPC_SimdLen>, 1848 VersionedClause<OMPC_GrainSize>, 1849 VersionedClause<OMPC_NoGroup>, 1850 VersionedClause<OMPC_NumTasks>, 1851 VersionedClause<OMPC_Reduction>, 1852 VersionedClause<OMPC_InReduction>, 1853 VersionedClause<OMPC_Allocate>, 1854 VersionedClause<OMPC_NonTemporal, 50>, 1855 VersionedClause<OMPC_Order, 50>, 1856 VersionedClause<OMPC_Filter> 1857 ]; 1858} 1859def OMP_ParallelMasterTaskloopSimd : 1860 Directive<"parallel master taskloop simd"> { 1861 let allowedClauses = [ 1862 VersionedClause<OMPC_If>, 1863 VersionedClause<OMPC_Shared>, 1864 VersionedClause<OMPC_Private>, 1865 VersionedClause<OMPC_FirstPrivate>, 1866 VersionedClause<OMPC_LastPrivate>, 1867 VersionedClause<OMPC_Default>, 1868 VersionedClause<OMPC_Collapse>, 1869 VersionedClause<OMPC_Final>, 1870 VersionedClause<OMPC_Untied>, 1871 VersionedClause<OMPC_Mergeable>, 1872 VersionedClause<OMPC_Priority>, 1873 VersionedClause<OMPC_GrainSize>, 1874 VersionedClause<OMPC_NoGroup>, 1875 VersionedClause<OMPC_NumTasks>, 1876 VersionedClause<OMPC_Reduction>, 1877 VersionedClause<OMPC_Allocate>, 1878 VersionedClause<OMPC_NumThreads>, 1879 VersionedClause<OMPC_ProcBind>, 1880 VersionedClause<OMPC_Copyin>, 1881 VersionedClause<OMPC_Linear>, 1882 VersionedClause<OMPC_Aligned>, 1883 VersionedClause<OMPC_SafeLen>, 1884 VersionedClause<OMPC_SimdLen>, 1885 VersionedClause<OMPC_NonTemporal, 50>, 1886 VersionedClause<OMPC_Order, 50> 1887 ]; 1888} 1889def OMP_ParallelMaskedTaskloopSimd : 1890 Directive<"parallel masked taskloop simd"> { 1891 let allowedClauses = [ 1892 VersionedClause<OMPC_If>, 1893 VersionedClause<OMPC_Shared>, 1894 VersionedClause<OMPC_Private>, 1895 VersionedClause<OMPC_FirstPrivate>, 1896 VersionedClause<OMPC_LastPrivate>, 1897 VersionedClause<OMPC_Default>, 1898 VersionedClause<OMPC_Collapse>, 1899 VersionedClause<OMPC_Final>, 1900 VersionedClause<OMPC_Untied>, 1901 VersionedClause<OMPC_Mergeable>, 1902 VersionedClause<OMPC_Priority>, 1903 VersionedClause<OMPC_GrainSize>, 1904 VersionedClause<OMPC_NoGroup>, 1905 VersionedClause<OMPC_NumTasks>, 1906 VersionedClause<OMPC_Reduction>, 1907 VersionedClause<OMPC_Allocate>, 1908 VersionedClause<OMPC_NumThreads>, 1909 VersionedClause<OMPC_ProcBind>, 1910 VersionedClause<OMPC_Copyin>, 1911 VersionedClause<OMPC_Linear>, 1912 VersionedClause<OMPC_Aligned>, 1913 VersionedClause<OMPC_SafeLen>, 1914 VersionedClause<OMPC_SimdLen>, 1915 VersionedClause<OMPC_NonTemporal, 50>, 1916 VersionedClause<OMPC_Order, 50>, 1917 VersionedClause<OMPC_Filter> 1918 ]; 1919} 1920def OMP_Depobj : Directive<"depobj"> { 1921 let allowedClauses = [ 1922 VersionedClause<OMPC_Depend, 50>, 1923 VersionedClause<OMPC_Destroy, 50>, 1924 VersionedClause<OMPC_Update, 50>, 1925 // TODO This should ne `none` instead. Comment carried over from 1926 // OMPKinds.def. 1927 VersionedClause<OMPC_Depobj, 50> 1928 ]; 1929} 1930def OMP_Scan : Directive<"scan"> { 1931 let allowedClauses = [ 1932 VersionedClause<OMPC_Inclusive, 50>, 1933 VersionedClause<OMPC_Exclusive, 50> 1934 ]; 1935} 1936def OMP_Assumes : Directive<"assumes"> {} 1937def OMP_BeginAssumes : Directive<"begin assumes"> {} 1938def OMP_EndAssumes : Directive<"end assumes"> {} 1939def OMP_BeginDeclareVariant : Directive<"begin declare variant"> {} 1940def OMP_EndDeclareVariant : Directive<"end declare variant"> {} 1941def OMP_ParallelWorkshare : Directive<"parallel workshare"> { 1942 let allowedClauses = [ 1943 VersionedClause<OMPC_Allocate>, 1944 VersionedClause<OMPC_Copyin>, 1945 VersionedClause<OMPC_Default>, 1946 VersionedClause<OMPC_FirstPrivate>, 1947 VersionedClause<OMPC_Private>, 1948 VersionedClause<OMPC_Reduction>, 1949 VersionedClause<OMPC_Shared> 1950 ]; 1951 let allowedOnceClauses = [ 1952 VersionedClause<OMPC_If>, 1953 VersionedClause<OMPC_NumThreads>, 1954 VersionedClause<OMPC_ProcBind> 1955 ]; 1956} 1957def OMP_Workshare : Directive<"workshare"> {} 1958def OMP_EndDo : Directive<"end do"> {} 1959def OMP_EndDoSimd : Directive<"end do simd"> {} 1960def OMP_EndSections : Directive<"end sections"> { 1961 let allowedOnceClauses = [ 1962 VersionedClause<OMPC_NoWait> 1963 ]; 1964} 1965def OMP_EndSingle : Directive<"end single"> { 1966 let allowedClauses = [ 1967 VersionedClause<OMPC_CopyPrivate> 1968 ]; 1969 let allowedOnceClauses = [ 1970 VersionedClause<OMPC_NoWait> 1971 ]; 1972} 1973def OMP_EndWorkshare : Directive<"end workshare"> { 1974 let allowedClauses = [ 1975 VersionedClause<OMPC_NoWait> 1976 ]; 1977} 1978def OMP_interop : Directive<"interop"> { 1979 let allowedClauses = [ 1980 VersionedClause<OMPC_Device>, 1981 VersionedClause<OMPC_Depend>, 1982 VersionedClause<OMPC_Destroy>, 1983 VersionedClause<OMPC_Init>, 1984 VersionedClause<OMPC_NoWait>, 1985 VersionedClause<OMPC_Use>, 1986 ]; 1987} 1988def OMP_dispatch : Directive<"dispatch"> { 1989 let allowedClauses = [ 1990 VersionedClause<OMPC_Device>, 1991 VersionedClause<OMPC_IsDevicePtr>, 1992 VersionedClause<OMPC_HasDeviceAddr, 51>, 1993 VersionedClause<OMPC_NoWait>, 1994 VersionedClause<OMPC_Depend>, 1995 VersionedClause<OMPC_Novariants>, 1996 VersionedClause<OMPC_Nocontext> 1997 ]; 1998} 1999def OMP_masked : Directive<"masked"> { 2000 let allowedOnceClauses = [ 2001 VersionedClause<OMPC_Filter> 2002 ]; 2003} 2004def OMP_loop : Directive<"loop"> { 2005 let allowedClauses = [ 2006 VersionedClause<OMPC_LastPrivate>, 2007 VersionedClause<OMPC_Private>, 2008 VersionedClause<OMPC_Reduction>, 2009 ]; 2010 let allowedOnceClauses = [ 2011 VersionedClause<OMPC_Bind, 50>, 2012 VersionedClause<OMPC_Collapse>, 2013 VersionedClause<OMPC_Order, 50> 2014 ]; 2015} 2016def OMP_teams_loop : Directive<"teams loop"> { 2017 let allowedClauses = [ 2018 VersionedClause<OMPC_Allocate>, 2019 VersionedClause<OMPC_FirstPrivate>, 2020 VersionedClause<OMPC_LastPrivate>, 2021 VersionedClause<OMPC_Private>, 2022 VersionedClause<OMPC_Reduction>, 2023 VersionedClause<OMPC_Shared>, 2024 ]; 2025 let allowedOnceClauses = [ 2026 VersionedClause<OMPC_Bind, 50>, 2027 VersionedClause<OMPC_Collapse>, 2028 VersionedClause<OMPC_Default>, 2029 VersionedClause<OMPC_NumTeams>, 2030 VersionedClause<OMPC_Order>, 2031 VersionedClause<OMPC_ThreadLimit>, 2032 ]; 2033} 2034def OMP_target_teams_loop : Directive<"target teams loop"> { 2035 let allowedClauses = [ 2036 VersionedClause<OMPC_Allocate>, 2037 VersionedClause<OMPC_Depend>, 2038 VersionedClause<OMPC_DefaultMap>, 2039 VersionedClause<OMPC_Device>, 2040 VersionedClause<OMPC_FirstPrivate>, 2041 VersionedClause<OMPC_IsDevicePtr>, 2042 VersionedClause<OMPC_HasDeviceAddr, 51>, 2043 VersionedClause<OMPC_LastPrivate>, 2044 VersionedClause<OMPC_Map>, 2045 VersionedClause<OMPC_Private>, 2046 VersionedClause<OMPC_Reduction>, 2047 VersionedClause<OMPC_Shared>, 2048 VersionedClause<OMPC_UsesAllocators, 50> 2049 ]; 2050 let allowedOnceClauses = [ 2051 VersionedClause<OMPC_Bind, 50>, 2052 VersionedClause<OMPC_Collapse>, 2053 VersionedClause<OMPC_Default>, 2054 VersionedClause<OMPC_If>, 2055 VersionedClause<OMPC_NoWait>, 2056 VersionedClause<OMPC_NumTeams>, 2057 VersionedClause<OMPC_Order>, 2058 VersionedClause<OMPC_ThreadLimit>, 2059 VersionedClause<OMPC_OMPX_DynCGroupMem>, 2060 ]; 2061} 2062def OMP_parallel_loop : Directive<"parallel loop"> { 2063 let allowedClauses = [ 2064 VersionedClause<OMPC_Allocate>, 2065 VersionedClause<OMPC_Copyin>, 2066 VersionedClause<OMPC_FirstPrivate>, 2067 VersionedClause<OMPC_LastPrivate>, 2068 VersionedClause<OMPC_Private>, 2069 VersionedClause<OMPC_Reduction>, 2070 VersionedClause<OMPC_Shared>, 2071 ]; 2072 let allowedOnceClauses = [ 2073 VersionedClause<OMPC_Bind, 50>, 2074 VersionedClause<OMPC_Collapse>, 2075 VersionedClause<OMPC_Default>, 2076 VersionedClause<OMPC_If>, 2077 VersionedClause<OMPC_NumThreads>, 2078 VersionedClause<OMPC_Order>, 2079 VersionedClause<OMPC_ProcBind>, 2080 ]; 2081} 2082def OMP_target_parallel_loop : Directive<"target parallel loop"> { 2083 let allowedClauses = [ 2084 VersionedClause<OMPC_Allocate>, 2085 VersionedClause<OMPC_Copyin>, 2086 VersionedClause<OMPC_Depend>, 2087 VersionedClause<OMPC_Device>, 2088 VersionedClause<OMPC_FirstPrivate>, 2089 VersionedClause<OMPC_IsDevicePtr>, 2090 VersionedClause<OMPC_HasDeviceAddr, 51>, 2091 VersionedClause<OMPC_LastPrivate>, 2092 VersionedClause<OMPC_Map>, 2093 VersionedClause<OMPC_Private>, 2094 VersionedClause<OMPC_Reduction>, 2095 VersionedClause<OMPC_Shared>, 2096 VersionedClause<OMPC_UsesAllocators, 50>, 2097 ]; 2098 let allowedOnceClauses = [ 2099 VersionedClause<OMPC_Bind, 50>, 2100 VersionedClause<OMPC_Collapse>, 2101 VersionedClause<OMPC_Default>, 2102 VersionedClause<OMPC_DefaultMap>, 2103 VersionedClause<OMPC_If>, 2104 VersionedClause<OMPC_NoWait>, 2105 VersionedClause<OMPC_NumThreads>, 2106 VersionedClause<OMPC_Order>, 2107 VersionedClause<OMPC_ProcBind>, 2108 VersionedClause<OMPC_OMPX_DynCGroupMem>, 2109 ]; 2110} 2111def OMP_Metadirective : Directive<"metadirective"> { 2112 let allowedClauses = [VersionedClause<OMPC_When>]; 2113 let allowedOnceClauses = [VersionedClause<OMPC_Default>]; 2114} 2115def OMP_Unknown : Directive<"unknown"> { 2116 let isDefault = true; 2117} 2118