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