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