path: root/contrib/libs/llvm14/include/llvm/Frontend/OpenACC/ACC.td

//===-- ACC.td - OpenACC directive definition file ---------*- tablegen -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This is the definition file for OpenACC 3.1 directives and clauses.
//
//===----------------------------------------------------------------------===//

include "llvm/Frontend/Directive/DirectiveBase.td"

//===----------------------------------------------------------------------===//
// Definition of general OpenACC information
//===----------------------------------------------------------------------===//

def OpenACC : DirectiveLanguage {
  let name = "OpenACC";
  let cppNamespace = "acc"; // final namespace will be llvm::acc
  let directivePrefix = "ACCD_";
  let clausePrefix = "ACCC_";
  let makeEnumAvailableInNamespace = true;
  let enableBitmaskEnumInNamespace = true;
  let clauseEnumSetClass = "AccClauseSet";
  let flangClauseBaseClass = "AccClause";
}

//===----------------------------------------------------------------------===//
// Definition of OpenACC clauses
//===----------------------------------------------------------------------===//

// 2.16.1
def ACCC_Async : Clause<"async"> {
  let flangClass = "ScalarIntExpr";
  let isValueOptional = true;
}

// 2.9.7
def ACCC_Auto : Clause<"auto"> {}

// 2.7.12
def ACCC_Attach : Clause<"attach"> {
  let flangClass = "AccObjectList";
}

// 2.15.1
def ACCC_Bind : Clause<"bind"> {
  let flangClass = "AccBindClause";
}

// 2.12
def ACCC_Capture : Clause<"capture"> {
}

// 2.9.1
def ACCC_Collapse : Clause<"collapse"> {
  let flangClass = "ScalarIntConstantExpr";
}

// 2.7.6
def ACCC_Copy : Clause<"copy"> {
  let flangClass = "AccObjectList";
}
// 2.7.7
def ACCC_Copyin : Clause<"copyin"> {
  let flangClass = "AccObjectListWithModifier";
}

// 2.7.8
def ACCC_Copyout : Clause<"copyout"> {
  let flangClass = "AccObjectListWithModifier";
}

// 2.7.9
def ACCC_Create : Clause<"create"> {
  let flangClass = "AccObjectListWithModifier";
}

// 2.5.15
def ACC_Default_none : ClauseVal<"none", 1, 1> { let isDefault = 1; }
def ACC_Default_present : ClauseVal<"present", 0, 1> {}

def ACCC_Default : Clause<"default"> {
  let flangClass = "AccDefaultClause";
  let enumClauseValue = "DefaultValue";
  let allowedClauseValues = [
    ACC_Default_present,
    ACC_Default_none
  ];
}

// 2.14.3
def ACCC_DefaultAsync : Clause<"default_async"> {
  let flangClass = "ScalarIntExpr";
}

// 2.7.11
def ACCC_Delete : Clause<"delete"> {
  let flangClass = "AccObjectList";
}

// 2.7.13
def ACCC_Detach : Clause<"detach"> {
  let flangClass = "AccObjectList";
}

// 2.14.4
def ACCC_Device : Clause<"device"> {
  let flangClass = "AccObjectList";
}

// 2.14.1 - 2.14.2
def ACCC_DeviceNum : Clause<"device_num">  {
  let flangClass = "ScalarIntExpr";
}

// 2.7.4
def ACCC_DevicePtr : Clause<"deviceptr"> {
  let flangClass = "AccObjectList";
}

// 2.13.1
def ACCC_DeviceResident : Clause<"device_resident"> {
  let flangClass = "AccObjectList";
}

// 2.4
def ACCC_DeviceType : Clause<"device_type"> {
  let flangClass = "ScalarIntExpr";
  let defaultValue = "*";
  let isValueOptional = true;
  let isValueList = true;
}

// 2.6.6
def ACCC_Finalize : Clause<"finalize"> {}

// 2.5.13
def ACCC_FirstPrivate : Clause<"firstprivate"> {
  let flangClass = "AccObjectList";
}

// 2.9.2
def ACCC_Gang : Clause<"gang"> {
  let flangClass = "AccGangArgument";
  let isValueOptional = true;
}

// 2.14.4
def ACCC_Host : Clause<"host"> {
  let flangClass = "AccObjectList";
}

// 2.5.5
def ACCC_If : Clause <"if"> {
  let flangClass = "ScalarLogicalExpr";
}

// 2.14.4
def ACCC_IfPresent : Clause<"if_present"> {}

// 2.9.6
def ACCC_Independent : Clause<"independent"> {}

// 2.13.3
def ACCC_Link : Clause<"link"> {
  let flangClass = "AccObjectList";
}

// 2.7.10
def ACCC_NoCreate : Clause<"no_create"> {
  let flangClass = "AccObjectList";
}

// 2.15.1
def ACCC_NoHost : Clause<"nohost"> {}

// 2.5.9
def ACCC_NumGangs : Clause<"num_gangs"> {
  let flangClass = "ScalarIntExpr";
}

// 2.5.10
def ACCC_NumWorkers : Clause<"num_workers"> {
  let flangClass = "ScalarIntExpr";
}

// 2.7.5
def ACCC_Present : Clause<"present"> {
  let flangClass = "AccObjectList";
}

// 2.5.12
def ACCC_Private : Clause<"private"> {
  let flangClass = "AccObjectList";
}

// 2.9.8
def ACCC_Tile : Clause <"tile"> {
  let flangClass = "AccTileExprList";
}

// 2.8.1
def ACCC_UseDevice : Clause <"use_device"> {
  let flangClass = "AccObjectList";
}

// 2.12
def ACCC_Read : Clause<"read"> {}

// 2.5.14
def ACCC_Reduction : Clause<"reduction"> {
  let flangClass = "AccObjectListWithReduction";
}

// 2.5.6
def ACCC_Self : Clause<"self"> {
  let flangClass = "AccSelfClause";
}

// 2.9.5
def ACCC_Seq : Clause<"seq"> {}

// 2.9.4
def ACCC_Vector : Clause<"vector"> {
  let flangClass = "ScalarIntExpr";
  let isValueOptional = true;
}

// 2.5.11
def ACCC_VectorLength : Clause<"vector_length"> {
  let flangClass = "ScalarIntExpr";
}

// 2.16.2
def ACCC_Wait : Clause<"wait"> {
  let flangClass = "AccWaitArgument";
  let isValueOptional = true;
}

// 2.9.3
def ACCC_Worker: Clause<"worker"> {
  let flangClass = "ScalarIntExpr";
  let isValueOptional = true;
}

// 2.12
def ACCC_Write : Clause<"write"> {}

def ACCC_Unknown : Clause<"unknown"> {
  let isDefault = true;
}

//===----------------------------------------------------------------------===//
// Definition of OpenACC directives
//===----------------------------------------------------------------------===//

// 2.12
def ACC_Atomic : Directive<"atomic"> {}

// 2.6.5
def ACC_Data : Directive<"data"> {
  let allowedOnceClauses = [
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_Default>
  ];
  let requiredClauses = [
    VersionedClause<ACCC_Attach>,
    VersionedClause<ACCC_Copy>,
    VersionedClause<ACCC_Copyin>,
    VersionedClause<ACCC_Copyout>,
    VersionedClause<ACCC_Create>,
    VersionedClause<ACCC_Default>,
    VersionedClause<ACCC_DevicePtr>,
    VersionedClause<ACCC_NoCreate>,
    VersionedClause<ACCC_Present>
  ];
}

// 2.13
def ACC_Declare : Directive<"declare"> {
  let allowedClauses = [
    VersionedClause<ACCC_Copy>,
    VersionedClause<ACCC_Copyin>,
    VersionedClause<ACCC_Copyout>,
    VersionedClause<ACCC_Create>,
    VersionedClause<ACCC_Present>,
    VersionedClause<ACCC_DevicePtr>,
    VersionedClause<ACCC_DeviceResident>,
    VersionedClause<ACCC_Link>
  ];
}

// 2.5.3
def ACC_Kernels : Directive<"kernels"> {
  let allowedClauses = [
    VersionedClause<ACCC_Attach>,
    VersionedClause<ACCC_Copy>,
    VersionedClause<ACCC_Copyin>,
    VersionedClause<ACCC_Copyout>,
    VersionedClause<ACCC_Create>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_NoCreate>,
    VersionedClause<ACCC_Present>,
    VersionedClause<ACCC_DevicePtr>,
    VersionedClause<ACCC_Wait>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_Default>,
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_NumGangs>,
    VersionedClause<ACCC_NumWorkers>,
    VersionedClause<ACCC_Self>,
    VersionedClause<ACCC_VectorLength>
  ];
}

// 2.5.1
def ACC_Parallel : Directive<"parallel"> {
  let allowedClauses = [
    VersionedClause<ACCC_Attach>,
    VersionedClause<ACCC_Copy>,
    VersionedClause<ACCC_Copyin>,
    VersionedClause<ACCC_Copyout>,
    VersionedClause<ACCC_Create>,
    VersionedClause<ACCC_DevicePtr>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_NoCreate>,
    VersionedClause<ACCC_Present>,
    VersionedClause<ACCC_Private>,
    VersionedClause<ACCC_FirstPrivate>,
    VersionedClause<ACCC_Wait>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_Default>,
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_NumGangs>,
    VersionedClause<ACCC_NumWorkers>,
    VersionedClause<ACCC_Reduction>,
    VersionedClause<ACCC_Self>,
    VersionedClause<ACCC_VectorLength>
  ];
}

// 2.5.2
def ACC_Serial : Directive<"serial"> {
  // Spec line 950-951: clause is as for the parallel construct except that the
  // num_gangs, num_workers, and vector_length clauses are not permitted.
  let allowedClauses = [
    VersionedClause<ACCC_Attach>,
    VersionedClause<ACCC_Copy>,
    VersionedClause<ACCC_Copyin>,
    VersionedClause<ACCC_Copyout>,
    VersionedClause<ACCC_Create>,
    VersionedClause<ACCC_DevicePtr>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_NoCreate>,
    VersionedClause<ACCC_Present>,
    VersionedClause<ACCC_Private>,
    VersionedClause<ACCC_FirstPrivate>,
    VersionedClause<ACCC_Wait>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_Default>,
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_Reduction>,
    VersionedClause<ACCC_Self>
  ];
}

// 2.9
def ACC_Loop : Directive<"loop"> {
  let allowedClauses = [
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_Private>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Collapse>,
    VersionedClause<ACCC_Gang>,
    VersionedClause<ACCC_Reduction>,
    VersionedClause<ACCC_Tile>,
    VersionedClause<ACCC_Vector>,
    VersionedClause<ACCC_Worker>
  ];
  let allowedExclusiveClauses = [
    VersionedClause<ACCC_Auto>,
    VersionedClause<ACCC_Independent>,
    VersionedClause<ACCC_Seq>
  ];
}

// 2.10
def ACC_Cache : Directive<"cache"> {}

// 2.14.1
def ACC_Init : Directive<"init"> {
  let allowedOnceClauses = [
    VersionedClause<ACCC_DeviceNum>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_If>
  ];
}

// 2.15.1
def ACC_Routine : Directive<"routine"> {
  let allowedOnceClauses = [
    VersionedClause<ACCC_Bind>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_NoHost>
  ];
  let requiredClauses = [
    VersionedClause<ACCC_Gang>,
    VersionedClause<ACCC_Seq>,
    VersionedClause<ACCC_Vector>,
    VersionedClause<ACCC_Worker>
  ];
}

// 2.14.3
def ACC_Set : Directive<"set"> {
  let allowedOnceClauses = [
    VersionedClause<ACCC_DefaultAsync>,
    VersionedClause<ACCC_DeviceNum>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_If>
  ];
  let requiredClauses = [
    // The three following clauses are also in allowedOnceClauses list due to
    // restriction 2255 - Two instances of the same clause may not appear on the
    // same directive.
    VersionedClause<ACCC_DefaultAsync>,
    VersionedClause<ACCC_DeviceNum>,
    VersionedClause<ACCC_DeviceType>
  ];
}

// 2.14.2
def ACC_Shutdown : Directive<"shutdown"> {
  let allowedOnceClauses = [
    VersionedClause<ACCC_DeviceNum>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_If>
  ];
}

// 2.14.4
def ACC_Update : Directive<"update"> {
  let allowedClauses = [
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_Wait>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_IfPresent>
  ];
  let requiredClauses = [
    VersionedClause<ACCC_Device>,
    VersionedClause<ACCC_Host>,
    VersionedClause<ACCC_Self>
  ];
}

// 2.16.3
def ACC_Wait : Directive<"wait"> {
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_If>
  ];
}

// 2.14.6
def ACC_EnterData : Directive<"enter data"> {
  let allowedClauses = [
    VersionedClause<ACCC_Wait>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_If>
  ];
  let requiredClauses = [
    VersionedClause<ACCC_Attach>,
    VersionedClause<ACCC_Create>,
    VersionedClause<ACCC_Copyin>
  ];
}

// 2.14.7
def ACC_ExitData : Directive<"exit data"> {
  let allowedClauses = [
    VersionedClause<ACCC_Wait>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_Finalize>
  ];
  let requiredClauses = [
    VersionedClause<ACCC_Copyout>,
    VersionedClause<ACCC_Delete>,
    VersionedClause<ACCC_Detach>
  ];
}

// 2.8
def ACC_HostData : Directive<"host_data"> {
  let allowedOnceClauses = [
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_IfPresent>
  ];
  let requiredClauses = [
    VersionedClause<ACCC_UseDevice>
  ];
}

// 2.11
def ACC_KernelsLoop : Directive<"kernels loop"> {
  let allowedClauses = [
    VersionedClause<ACCC_Copy>,
    VersionedClause<ACCC_Copyin>,
    VersionedClause<ACCC_Copyout>,
    VersionedClause<ACCC_Create>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_NoCreate>,
    VersionedClause<ACCC_Present>,
    VersionedClause<ACCC_Private>,
    VersionedClause<ACCC_DevicePtr>,
    VersionedClause<ACCC_Attach>,
    VersionedClause<ACCC_Wait>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_Collapse>,
    VersionedClause<ACCC_Default>,
    VersionedClause<ACCC_Gang>,
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_NumGangs>,
    VersionedClause<ACCC_NumWorkers>,
    VersionedClause<ACCC_Reduction>,
    VersionedClause<ACCC_Self>,
    VersionedClause<ACCC_Tile>,
    VersionedClause<ACCC_Vector>,
    VersionedClause<ACCC_VectorLength>,
    VersionedClause<ACCC_Worker>
  ];
  let allowedExclusiveClauses = [
    VersionedClause<ACCC_Auto>,
    VersionedClause<ACCC_Independent>,
    VersionedClause<ACCC_Seq>
  ];
}

// 2.11
def ACC_ParallelLoop : Directive<"parallel loop"> {
  let allowedClauses = [
    VersionedClause<ACCC_Attach>,
    VersionedClause<ACCC_Copy>,
    VersionedClause<ACCC_Copyin>,
    VersionedClause<ACCC_Copyout>,
    VersionedClause<ACCC_Create>,
    VersionedClause<ACCC_DevicePtr>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_FirstPrivate>,
    VersionedClause<ACCC_NoCreate>,
    VersionedClause<ACCC_Present>,
    VersionedClause<ACCC_Private>,
    VersionedClause<ACCC_Tile>,
    VersionedClause<ACCC_Wait>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_Collapse>,
    VersionedClause<ACCC_Default>,
    VersionedClause<ACCC_Gang>,
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_NumGangs>,
    VersionedClause<ACCC_NumWorkers>,
    VersionedClause<ACCC_Reduction>,
    VersionedClause<ACCC_Self>,
    VersionedClause<ACCC_Vector>,
    VersionedClause<ACCC_VectorLength>,
    VersionedClause<ACCC_Worker>
  ];
  let allowedExclusiveClauses = [
    VersionedClause<ACCC_Auto>,
    VersionedClause<ACCC_Independent>,
    VersionedClause<ACCC_Seq>
  ];
}

// 2.11
def ACC_SerialLoop : Directive<"serial loop"> {
  let allowedClauses = [
    VersionedClause<ACCC_Attach>,
    VersionedClause<ACCC_Copy>,
    VersionedClause<ACCC_Copyin>,
    VersionedClause<ACCC_Copyout>,
    VersionedClause<ACCC_Create>,
    VersionedClause<ACCC_DevicePtr>,
    VersionedClause<ACCC_DeviceType>,
    VersionedClause<ACCC_FirstPrivate>,
    VersionedClause<ACCC_NoCreate>,
    VersionedClause<ACCC_Present>,
    VersionedClause<ACCC_Private>,
    VersionedClause<ACCC_Wait>
  ];
  let allowedOnceClauses = [
    VersionedClause<ACCC_Async>,
    VersionedClause<ACCC_Collapse>,
    VersionedClause<ACCC_Default>,
    VersionedClause<ACCC_Gang>,
    VersionedClause<ACCC_If>,
    VersionedClause<ACCC_Reduction>,
    VersionedClause<ACCC_Self>,
    VersionedClause<ACCC_Tile>,
    VersionedClause<ACCC_Vector>,
    VersionedClause<ACCC_Worker>
  ];
  let allowedExclusiveClauses = [
    VersionedClause<ACCC_Auto>,
    VersionedClause<ACCC_Independent>,
    VersionedClause<ACCC_Seq>
  ];
}

def ACC_Unknown : Directive<"unknown"> {
  let isDefault = true;
}