1//===-- ACC.td - OpenACC 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 OpenACC 3.1 directives and clauses. 10// 11//===----------------------------------------------------------------------===// 12 13include "llvm/Frontend/Directive/DirectiveBase.td" 14 15//===----------------------------------------------------------------------===// 16// Definition of general OpenACC information 17//===----------------------------------------------------------------------===// 18 19def OpenACC : DirectiveLanguage { 20 let name = "OpenACC"; 21 let cppNamespace = "acc"; // final namespace will be llvm::acc 22 let directivePrefix = "ACCD_"; 23 let clausePrefix = "ACCC_"; 24 let makeEnumAvailableInNamespace = true; 25 let enableBitmaskEnumInNamespace = true; 26 let clauseEnumSetClass = "AccClauseSet"; 27 let flangClauseBaseClass = "AccClause"; 28} 29 30//===----------------------------------------------------------------------===// 31// Definition of OpenACC clauses 32//===----------------------------------------------------------------------===// 33 34// 2.16.1 35def ACCC_Async : Clause<"async"> { 36 let flangClass = "ScalarIntExpr"; 37 let isValueOptional = true; 38} 39 40// 2.9.7 41def ACCC_Auto : Clause<"auto"> {} 42 43// 2.7.12 44def ACCC_Attach : Clause<"attach"> { 45 let flangClass = "AccObjectList"; 46} 47 48// 2.15.1 49def ACCC_Bind : Clause<"bind"> { 50 let flangClass = "AccBindClause"; 51} 52 53// 2.12 54def ACCC_Capture : Clause<"capture"> { 55} 56 57// 2.9.1 58def ACCC_Collapse : Clause<"collapse"> { 59 let flangClass = "ScalarIntConstantExpr"; 60} 61 62// 2.7.6 63def ACCC_Copy : Clause<"copy"> { 64 let flangClass = "AccObjectList"; 65} 66// 2.7.7 67def ACCC_Copyin : Clause<"copyin"> { 68 let flangClass = "AccObjectListWithModifier"; 69} 70 71// 2.7.8 72def ACCC_Copyout : Clause<"copyout"> { 73 let flangClass = "AccObjectListWithModifier"; 74} 75 76// 2.7.9 77def ACCC_Create : Clause<"create"> { 78 let flangClass = "AccObjectListWithModifier"; 79} 80 81// 2.5.15 82def ACC_Default_none : ClauseVal<"none", 1, 1> { let isDefault = 1; } 83def ACC_Default_present : ClauseVal<"present", 0, 1> {} 84 85def ACCC_Default : Clause<"default"> { 86 let flangClass = "AccDefaultClause"; 87 let enumClauseValue = "DefaultValue"; 88 let allowedClauseValues = [ 89 ACC_Default_present, 90 ACC_Default_none 91 ]; 92} 93 94// 2.14.3 95def ACCC_DefaultAsync : Clause<"default_async"> { 96 let flangClass = "ScalarIntExpr"; 97} 98 99// 2.7.11 100def ACCC_Delete : Clause<"delete"> { 101 let flangClass = "AccObjectList"; 102} 103 104// 2.7.13 105def ACCC_Detach : Clause<"detach"> { 106 let flangClass = "AccObjectList"; 107} 108 109// 2.14.4 110def ACCC_Device : Clause<"device"> { 111 let flangClass = "AccObjectList"; 112} 113 114// 2.14.1 - 2.14.2 115def ACCC_DeviceNum : Clause<"device_num"> { 116 let flangClass = "ScalarIntExpr"; 117} 118 119// 2.7.4 120def ACCC_DevicePtr : Clause<"deviceptr"> { 121 let flangClass = "AccObjectList"; 122} 123 124// 2.13.1 125def ACCC_DeviceResident : Clause<"device_resident"> { 126 let flangClass = "AccObjectList"; 127} 128 129// 2.4 130def ACCC_DeviceType : Clause<"device_type"> { 131 let flangClass = "ScalarIntExpr"; 132 let defaultValue = "*"; 133 let isValueOptional = true; 134 let isValueList = true; 135} 136 137// 2.6.6 138def ACCC_Finalize : Clause<"finalize"> {} 139 140// 2.5.13 141def ACCC_FirstPrivate : Clause<"firstprivate"> { 142 let flangClass = "AccObjectList"; 143} 144 145// 2.9.2 146def ACCC_Gang : Clause<"gang"> { 147 let flangClass = "AccGangArgument"; 148 let isValueOptional = true; 149} 150 151// 2.14.4 152def ACCC_Host : Clause<"host"> { 153 let flangClass = "AccObjectList"; 154} 155 156// 2.5.5 157def ACCC_If : Clause <"if"> { 158 let flangClass = "ScalarLogicalExpr"; 159} 160 161// 2.14.4 162def ACCC_IfPresent : Clause<"if_present"> {} 163 164// 2.9.6 165def ACCC_Independent : Clause<"independent"> {} 166 167// 2.13.3 168def ACCC_Link : Clause<"link"> { 169 let flangClass = "AccObjectList"; 170} 171 172// 2.7.10 173def ACCC_NoCreate : Clause<"no_create"> { 174 let flangClass = "AccObjectList"; 175} 176 177// 2.15.1 178def ACCC_NoHost : Clause<"nohost"> {} 179 180// 2.5.9 181def ACCC_NumGangs : Clause<"num_gangs"> { 182 let flangClass = "ScalarIntExpr"; 183} 184 185// 2.5.10 186def ACCC_NumWorkers : Clause<"num_workers"> { 187 let flangClass = "ScalarIntExpr"; 188} 189 190// 2.7.5 191def ACCC_Present : Clause<"present"> { 192 let flangClass = "AccObjectList"; 193} 194 195// 2.5.12 196def ACCC_Private : Clause<"private"> { 197 let flangClass = "AccObjectList"; 198} 199 200// 2.9.8 201def ACCC_Tile : Clause <"tile"> { 202 let flangClass = "AccTileExprList"; 203} 204 205// 2.8.1 206def ACCC_UseDevice : Clause <"use_device"> { 207 let flangClass = "AccObjectList"; 208} 209 210// 2.12 211def ACCC_Read : Clause<"read"> {} 212 213// 2.5.14 214def ACCC_Reduction : Clause<"reduction"> { 215 let flangClass = "AccObjectListWithReduction"; 216} 217 218// 2.5.6 219def ACCC_Self : Clause<"self"> { 220 let flangClass = "AccSelfClause"; 221} 222 223// 2.9.5 224def ACCC_Seq : Clause<"seq"> {} 225 226// 2.9.4 227def ACCC_Vector : Clause<"vector"> { 228 let flangClass = "ScalarIntExpr"; 229 let isValueOptional = true; 230} 231 232// 2.5.11 233def ACCC_VectorLength : Clause<"vector_length"> { 234 let flangClass = "ScalarIntExpr"; 235} 236 237// 2.16.2 238def ACCC_Wait : Clause<"wait"> { 239 let flangClass = "AccWaitArgument"; 240 let isValueOptional = true; 241} 242 243// 2.9.3 244def ACCC_Worker: Clause<"worker"> { 245 let flangClass = "ScalarIntExpr"; 246 let isValueOptional = true; 247} 248 249// 2.12 250def ACCC_Write : Clause<"write"> {} 251 252def ACCC_Unknown : Clause<"unknown"> { 253 let isDefault = true; 254} 255 256//===----------------------------------------------------------------------===// 257// Definition of OpenACC directives 258//===----------------------------------------------------------------------===// 259 260// 2.12 261def ACC_Atomic : Directive<"atomic"> {} 262 263// 2.6.5 264def ACC_Data : Directive<"data"> { 265 let allowedOnceClauses = [ 266 VersionedClause<ACCC_If>, 267 VersionedClause<ACCC_Default> 268 ]; 269 let requiredClauses = [ 270 VersionedClause<ACCC_Attach>, 271 VersionedClause<ACCC_Copy>, 272 VersionedClause<ACCC_Copyin>, 273 VersionedClause<ACCC_Copyout>, 274 VersionedClause<ACCC_Create>, 275 VersionedClause<ACCC_Default>, 276 VersionedClause<ACCC_DevicePtr>, 277 VersionedClause<ACCC_NoCreate>, 278 VersionedClause<ACCC_Present> 279 ]; 280} 281 282// 2.13 283def ACC_Declare : Directive<"declare"> { 284 let allowedClauses = [ 285 VersionedClause<ACCC_Copy>, 286 VersionedClause<ACCC_Copyin>, 287 VersionedClause<ACCC_Copyout>, 288 VersionedClause<ACCC_Create>, 289 VersionedClause<ACCC_Present>, 290 VersionedClause<ACCC_DevicePtr>, 291 VersionedClause<ACCC_DeviceResident>, 292 VersionedClause<ACCC_Link> 293 ]; 294} 295 296// 2.5.3 297def ACC_Kernels : Directive<"kernels"> { 298 let allowedClauses = [ 299 VersionedClause<ACCC_Attach>, 300 VersionedClause<ACCC_Copy>, 301 VersionedClause<ACCC_Copyin>, 302 VersionedClause<ACCC_Copyout>, 303 VersionedClause<ACCC_Create>, 304 VersionedClause<ACCC_DeviceType>, 305 VersionedClause<ACCC_NoCreate>, 306 VersionedClause<ACCC_Present>, 307 VersionedClause<ACCC_DevicePtr>, 308 VersionedClause<ACCC_Wait> 309 ]; 310 let allowedOnceClauses = [ 311 VersionedClause<ACCC_Async>, 312 VersionedClause<ACCC_Default>, 313 VersionedClause<ACCC_If>, 314 VersionedClause<ACCC_NumGangs>, 315 VersionedClause<ACCC_NumWorkers>, 316 VersionedClause<ACCC_Self>, 317 VersionedClause<ACCC_VectorLength> 318 ]; 319} 320 321// 2.5.1 322def ACC_Parallel : Directive<"parallel"> { 323 let allowedClauses = [ 324 VersionedClause<ACCC_Attach>, 325 VersionedClause<ACCC_Copy>, 326 VersionedClause<ACCC_Copyin>, 327 VersionedClause<ACCC_Copyout>, 328 VersionedClause<ACCC_Create>, 329 VersionedClause<ACCC_DevicePtr>, 330 VersionedClause<ACCC_DeviceType>, 331 VersionedClause<ACCC_NoCreate>, 332 VersionedClause<ACCC_Present>, 333 VersionedClause<ACCC_Private>, 334 VersionedClause<ACCC_FirstPrivate>, 335 VersionedClause<ACCC_Wait> 336 ]; 337 let allowedOnceClauses = [ 338 VersionedClause<ACCC_Async>, 339 VersionedClause<ACCC_Default>, 340 VersionedClause<ACCC_If>, 341 VersionedClause<ACCC_NumGangs>, 342 VersionedClause<ACCC_NumWorkers>, 343 VersionedClause<ACCC_Reduction>, 344 VersionedClause<ACCC_Self>, 345 VersionedClause<ACCC_VectorLength> 346 ]; 347} 348 349// 2.5.2 350def ACC_Serial : Directive<"serial"> { 351 // Spec line 950-951: clause is as for the parallel construct except that the 352 // num_gangs, num_workers, and vector_length clauses are not permitted. 353 let allowedClauses = [ 354 VersionedClause<ACCC_Attach>, 355 VersionedClause<ACCC_Copy>, 356 VersionedClause<ACCC_Copyin>, 357 VersionedClause<ACCC_Copyout>, 358 VersionedClause<ACCC_Create>, 359 VersionedClause<ACCC_DevicePtr>, 360 VersionedClause<ACCC_DeviceType>, 361 VersionedClause<ACCC_NoCreate>, 362 VersionedClause<ACCC_Present>, 363 VersionedClause<ACCC_Private>, 364 VersionedClause<ACCC_FirstPrivate>, 365 VersionedClause<ACCC_Wait> 366 ]; 367 let allowedOnceClauses = [ 368 VersionedClause<ACCC_Async>, 369 VersionedClause<ACCC_Default>, 370 VersionedClause<ACCC_If>, 371 VersionedClause<ACCC_Reduction>, 372 VersionedClause<ACCC_Self> 373 ]; 374} 375 376// 2.9 377def ACC_Loop : Directive<"loop"> { 378 let allowedClauses = [ 379 VersionedClause<ACCC_DeviceType>, 380 VersionedClause<ACCC_Private> 381 ]; 382 let allowedOnceClauses = [ 383 VersionedClause<ACCC_Collapse>, 384 VersionedClause<ACCC_Gang>, 385 VersionedClause<ACCC_Reduction>, 386 VersionedClause<ACCC_Tile>, 387 VersionedClause<ACCC_Vector>, 388 VersionedClause<ACCC_Worker> 389 ]; 390 let allowedExclusiveClauses = [ 391 VersionedClause<ACCC_Auto>, 392 VersionedClause<ACCC_Independent>, 393 VersionedClause<ACCC_Seq> 394 ]; 395} 396 397// 2.10 398def ACC_Cache : Directive<"cache"> {} 399 400// 2.14.1 401def ACC_Init : Directive<"init"> { 402 let allowedOnceClauses = [ 403 VersionedClause<ACCC_DeviceNum>, 404 VersionedClause<ACCC_DeviceType>, 405 VersionedClause<ACCC_If> 406 ]; 407} 408 409// 2.15.1 410def ACC_Routine : Directive<"routine"> { 411 let allowedOnceClauses = [ 412 VersionedClause<ACCC_Bind>, 413 VersionedClause<ACCC_DeviceType>, 414 VersionedClause<ACCC_NoHost> 415 ]; 416 let requiredClauses = [ 417 VersionedClause<ACCC_Gang>, 418 VersionedClause<ACCC_Seq>, 419 VersionedClause<ACCC_Vector>, 420 VersionedClause<ACCC_Worker> 421 ]; 422} 423 424// 2.14.3 425def ACC_Set : Directive<"set"> { 426 let allowedOnceClauses = [ 427 VersionedClause<ACCC_DefaultAsync>, 428 VersionedClause<ACCC_DeviceNum>, 429 VersionedClause<ACCC_DeviceType>, 430 VersionedClause<ACCC_If> 431 ]; 432 let requiredClauses = [ 433 // The three following clauses are also in allowedOnceClauses list due to 434 // restriction 2255 - Two instances of the same clause may not appear on the 435 // same directive. 436 VersionedClause<ACCC_DefaultAsync>, 437 VersionedClause<ACCC_DeviceNum>, 438 VersionedClause<ACCC_DeviceType> 439 ]; 440} 441 442// 2.14.2 443def ACC_Shutdown : Directive<"shutdown"> { 444 let allowedOnceClauses = [ 445 VersionedClause<ACCC_DeviceNum>, 446 VersionedClause<ACCC_DeviceType>, 447 VersionedClause<ACCC_If> 448 ]; 449} 450 451// 2.14.4 452def ACC_Update : Directive<"update"> { 453 let allowedClauses = [ 454 VersionedClause<ACCC_DeviceType>, 455 VersionedClause<ACCC_Wait> 456 ]; 457 let allowedOnceClauses = [ 458 VersionedClause<ACCC_Async>, 459 VersionedClause<ACCC_If>, 460 VersionedClause<ACCC_IfPresent> 461 ]; 462 let requiredClauses = [ 463 VersionedClause<ACCC_Device>, 464 VersionedClause<ACCC_Host>, 465 VersionedClause<ACCC_Self> 466 ]; 467} 468 469// 2.16.3 470def ACC_Wait : Directive<"wait"> { 471 let allowedOnceClauses = [ 472 VersionedClause<ACCC_Async>, 473 VersionedClause<ACCC_If> 474 ]; 475} 476 477// 2.14.6 478def ACC_EnterData : Directive<"enter data"> { 479 let allowedClauses = [ 480 VersionedClause<ACCC_Wait> 481 ]; 482 let allowedOnceClauses = [ 483 VersionedClause<ACCC_Async>, 484 VersionedClause<ACCC_If> 485 ]; 486 let requiredClauses = [ 487 VersionedClause<ACCC_Attach>, 488 VersionedClause<ACCC_Create>, 489 VersionedClause<ACCC_Copyin> 490 ]; 491} 492 493// 2.14.7 494def ACC_ExitData : Directive<"exit data"> { 495 let allowedClauses = [ 496 VersionedClause<ACCC_Wait> 497 ]; 498 let allowedOnceClauses = [ 499 VersionedClause<ACCC_Async>, 500 VersionedClause<ACCC_If>, 501 VersionedClause<ACCC_Finalize> 502 ]; 503 let requiredClauses = [ 504 VersionedClause<ACCC_Copyout>, 505 VersionedClause<ACCC_Delete>, 506 VersionedClause<ACCC_Detach> 507 ]; 508} 509 510// 2.8 511def ACC_HostData : Directive<"host_data"> { 512 let allowedOnceClauses = [ 513 VersionedClause<ACCC_If>, 514 VersionedClause<ACCC_IfPresent> 515 ]; 516 let requiredClauses = [ 517 VersionedClause<ACCC_UseDevice> 518 ]; 519} 520 521// 2.11 522def ACC_KernelsLoop : Directive<"kernels loop"> { 523 let allowedClauses = [ 524 VersionedClause<ACCC_Copy>, 525 VersionedClause<ACCC_Copyin>, 526 VersionedClause<ACCC_Copyout>, 527 VersionedClause<ACCC_Create>, 528 VersionedClause<ACCC_DeviceType>, 529 VersionedClause<ACCC_NoCreate>, 530 VersionedClause<ACCC_Present>, 531 VersionedClause<ACCC_Private>, 532 VersionedClause<ACCC_DevicePtr>, 533 VersionedClause<ACCC_Attach>, 534 VersionedClause<ACCC_Wait> 535 ]; 536 let allowedOnceClauses = [ 537 VersionedClause<ACCC_Async>, 538 VersionedClause<ACCC_Collapse>, 539 VersionedClause<ACCC_Default>, 540 VersionedClause<ACCC_Gang>, 541 VersionedClause<ACCC_If>, 542 VersionedClause<ACCC_NumGangs>, 543 VersionedClause<ACCC_NumWorkers>, 544 VersionedClause<ACCC_Reduction>, 545 VersionedClause<ACCC_Self>, 546 VersionedClause<ACCC_Tile>, 547 VersionedClause<ACCC_Vector>, 548 VersionedClause<ACCC_VectorLength>, 549 VersionedClause<ACCC_Worker> 550 ]; 551 let allowedExclusiveClauses = [ 552 VersionedClause<ACCC_Auto>, 553 VersionedClause<ACCC_Independent>, 554 VersionedClause<ACCC_Seq> 555 ]; 556} 557 558// 2.11 559def ACC_ParallelLoop : Directive<"parallel loop"> { 560 let allowedClauses = [ 561 VersionedClause<ACCC_Attach>, 562 VersionedClause<ACCC_Copy>, 563 VersionedClause<ACCC_Copyin>, 564 VersionedClause<ACCC_Copyout>, 565 VersionedClause<ACCC_Create>, 566 VersionedClause<ACCC_DevicePtr>, 567 VersionedClause<ACCC_DeviceType>, 568 VersionedClause<ACCC_FirstPrivate>, 569 VersionedClause<ACCC_NoCreate>, 570 VersionedClause<ACCC_Present>, 571 VersionedClause<ACCC_Private>, 572 VersionedClause<ACCC_Tile>, 573 VersionedClause<ACCC_Wait> 574 ]; 575 let allowedOnceClauses = [ 576 VersionedClause<ACCC_Async>, 577 VersionedClause<ACCC_Collapse>, 578 VersionedClause<ACCC_Default>, 579 VersionedClause<ACCC_Gang>, 580 VersionedClause<ACCC_If>, 581 VersionedClause<ACCC_NumGangs>, 582 VersionedClause<ACCC_NumWorkers>, 583 VersionedClause<ACCC_Reduction>, 584 VersionedClause<ACCC_Self>, 585 VersionedClause<ACCC_Vector>, 586 VersionedClause<ACCC_VectorLength>, 587 VersionedClause<ACCC_Worker> 588 ]; 589 let allowedExclusiveClauses = [ 590 VersionedClause<ACCC_Auto>, 591 VersionedClause<ACCC_Independent>, 592 VersionedClause<ACCC_Seq> 593 ]; 594} 595 596// 2.11 597def ACC_SerialLoop : Directive<"serial loop"> { 598 let allowedClauses = [ 599 VersionedClause<ACCC_Attach>, 600 VersionedClause<ACCC_Copy>, 601 VersionedClause<ACCC_Copyin>, 602 VersionedClause<ACCC_Copyout>, 603 VersionedClause<ACCC_Create>, 604 VersionedClause<ACCC_DevicePtr>, 605 VersionedClause<ACCC_DeviceType>, 606 VersionedClause<ACCC_FirstPrivate>, 607 VersionedClause<ACCC_NoCreate>, 608 VersionedClause<ACCC_Present>, 609 VersionedClause<ACCC_Private>, 610 VersionedClause<ACCC_Wait> 611 ]; 612 let allowedOnceClauses = [ 613 VersionedClause<ACCC_Async>, 614 VersionedClause<ACCC_Collapse>, 615 VersionedClause<ACCC_Default>, 616 VersionedClause<ACCC_Gang>, 617 VersionedClause<ACCC_If>, 618 VersionedClause<ACCC_Reduction>, 619 VersionedClause<ACCC_Self>, 620 VersionedClause<ACCC_Tile>, 621 VersionedClause<ACCC_Vector>, 622 VersionedClause<ACCC_Worker> 623 ]; 624 let allowedExclusiveClauses = [ 625 VersionedClause<ACCC_Auto>, 626 VersionedClause<ACCC_Independent>, 627 VersionedClause<ACCC_Seq> 628 ]; 629} 630 631def ACC_Unknown : Directive<"unknown"> { 632 let isDefault = true; 633} 634