diff options
| author | Devtools Arcadia <arcadia-devtools@yandex-team.ru> | 2022-02-07 18:08:42 +0300 |
|---|---|---|
| committer | Devtools Arcadia <arcadia-devtools@mous.vla.yp-c.yandex.net> | 2022-02-07 18:08:42 +0300 |
| commit | 1110808a9d39d4b808aef724c861a2e1a38d2a69 (patch) | |
| tree | e26c9fed0de5d9873cce7e00bc214573dc2195b7 /contrib/libs/llvm12/include/llvm/Frontend | |
| download | ydb-1110808a9d39d4b808aef724c861a2e1a38d2a69.tar.gz | |
intermediate changes
ref:cde9a383711a11544ce7e107a78147fb96cc4029
Diffstat (limited to 'contrib/libs/llvm12/include/llvm/Frontend')
9 files changed, 8422 insertions, 0 deletions
diff --git a/contrib/libs/llvm12/include/llvm/Frontend/Directive/DirectiveBase.td b/contrib/libs/llvm12/include/llvm/Frontend/Directive/DirectiveBase.td new file mode 100644 index 0000000000..e40f40f74c --- /dev/null +++ b/contrib/libs/llvm12/include/llvm/Frontend/Directive/DirectiveBase.td @@ -0,0 +1,145 @@ +//===-- DirectiveBase.td - Base 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 base definition file directives and clauses. +// +//===----------------------------------------------------------------------===// + + +// General information about the directive language. +class DirectiveLanguage { + // Name of the directive language such as omp or acc. + string name = ?; + + // The C++ namespace that code of this directive language should be placed + // into. This namespace is nested in llvm namespace. + // + // By default, uses the name of the directive language as the only namespace. + // To avoid placing in any namespace, use "". To specify nested namespaces, + // use "::" as the delimiter, e.g., given "A::B", ops will be placed in + // `namespace A { namespace B { <directives-clauses> } }`. + string cppNamespace = name; + + // Optional prefix used for the generation of the enumerator in the Directive + // enum. + string directivePrefix = ""; + + // Optional prefix used for the generation of the enumerator in the Clause + // enum. + string clausePrefix = ""; + + // Make the enum values available in the namespace. This allows us to + // write something like Enum_X if we have a `using namespace cppNamespace`. + bit makeEnumAvailableInNamespace = false; + + // Generate include and macro to enable LLVM BitmaskEnum. + bit enableBitmaskEnumInNamespace = false; + + // Header file included in the implementation code generated. Ususally the + // output file of the declaration code generation. Can be left blank. + string includeHeader = ""; + + // EnumSet class name used for clauses to generated the allowed clauses map. + string clauseEnumSetClass = ""; + + // Class holding the clauses in the flang parse-tree. + string flangClauseBaseClass = ""; +} + +// Information about values accepted by enum-like clauses +class ClauseVal<string n, int v, bit uv> { + // Name of the clause value. + string name = n; + + // Integer value of the clause. + int value = v; + + // Can user specify this value? + bit isUserValue = uv; + + // Set clause value used by default when unknown. + bit isDefault = false; +} + +// Information about a specific clause. +class Clause<string c> { + // Name of the clause. + string name = c; + + // Define an alternative name return in get<LanguageName>ClauseName function. + string alternativeName = ""; + + // Optional class holding value of the clause in clang AST. + string clangClass = ""; + + // Optional class holding value of the clause in flang AST. + string flangClass = ""; + + // If set to true, value is optional. Not optional by default. + bit isValueOptional = false; + + // Name of enum when there is a list of allowed clause values. + string enumClauseValue = ""; + + // List of allowed clause values + list<ClauseVal> allowedClauseValues = []; + // If set to true, value class is part of a list. Single class by default. + bit isValueList = false; + + // Define a default value such as "*". + string defaultValue = ""; + + // Is clause implicit? If clause is set as implicit, the default kind will + // be return in get<LanguageName>ClauseKind instead of their own kind. + bit isImplicit = false; + + // Set clause used by default when unknown. Function returning the kind + // of enumeration will use this clause as the default. + bit isDefault = false; +} + +// Hold information about clause validity by version. +class VersionedClause<Clause c, int min = 1, int max = 0x7FFFFFFF> { + // Actual clause. + Clause clause = c; + + // Mininum version number where this clause is valid. + int minVersion = min; + + // Maximum version number where this clause is valid. + int maxVersion = max; +} + +// Information about a specific directive. +class Directive<string d> { + // Name of the directive. Can be composite directive sepearted by whitespace. + string name = d; + + // Define an alternative name return in get<LanguageName>DirectiveName + // function. + string alternativeName = ""; + + // Clauses cannot appear twice in the three allowed lists below. Also, since + // required implies allowed, the same clause cannot appear in both the + // allowedClauses and requiredClauses lists. + + // List of allowed clauses for the directive. + list<VersionedClause> allowedClauses = []; + + // List of clauses that are allowed to appear only once. + list<VersionedClause> allowedOnceClauses = []; + + // List of clauses that are allowed but mutually exclusive. + list<VersionedClause> allowedExclusiveClauses = []; + + // List of clauses that are required. + list<VersionedClause> requiredClauses = []; + + // Set directive used by default when unknown. + bit isDefault = false; +} diff --git a/contrib/libs/llvm12/include/llvm/Frontend/OpenACC/ACC.td b/contrib/libs/llvm12/include/llvm/Frontend/OpenACC/ACC.td new file mode 100644 index 0000000000..6045a9ac2a --- /dev/null +++ b/contrib/libs/llvm12/include/llvm/Frontend/OpenACC/ACC.td @@ -0,0 +1,630 @@ +//===-- 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 includeHeader = "llvm/Frontend/OpenACC/ACC.h.inc"; + 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 allowedOnceClauses = [ + VersionedClause<ACCC_Async>, + VersionedClause<ACCC_If>, + VersionedClause<ACCC_Wait> + ]; + let requiredClauses = [ + VersionedClause<ACCC_Attach>, + VersionedClause<ACCC_Create>, + VersionedClause<ACCC_Copyin> + ]; +} + +// 2.14.7 +def ACC_ExitData : Directive<"exit data"> { + let allowedClauses = [ + VersionedClause<ACCC_Async>, + VersionedClause<ACCC_If>, + VersionedClause<ACCC_Wait>, + VersionedClause<ACCC_Finalize> + ]; + let requiredClauses = [ + VersionedClause<ACCC_Copyout>, + VersionedClause<ACCC_Delete>, + VersionedClause<ACCC_Detach> + ]; +} + +// 2.8 +def ACC_HostData : Directive<"host_data"> { + let allowedClauses = [ + 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> + ]; + 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_Wait>, + 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; +} diff --git a/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMP.inc b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMP.inc new file mode 100644 index 0000000000..390fac5410 --- /dev/null +++ b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMP.inc @@ -0,0 +1,3507 @@ +#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS +#undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS + +namespace llvm { +namespace omp { + + // Sets for allocate + + static OmpClauseSet allowedClauses_OMPD_allocate { + llvm::omp::Clause::OMPC_allocator, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_allocate { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_allocate { + }; + + static OmpClauseSet requiredClauses_OMPD_allocate { + }; + + // Sets for assumes + + static OmpClauseSet allowedClauses_OMPD_assumes { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_assumes { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_assumes { + }; + + static OmpClauseSet requiredClauses_OMPD_assumes { + }; + + // Sets for atomic + + static OmpClauseSet allowedClauses_OMPD_atomic { + llvm::omp::Clause::OMPC_read, + llvm::omp::Clause::OMPC_write, + llvm::omp::Clause::OMPC_update, + llvm::omp::Clause::OMPC_capture, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_atomic { + llvm::omp::Clause::OMPC_seq_cst, + llvm::omp::Clause::OMPC_acq_rel, + llvm::omp::Clause::OMPC_acquire, + llvm::omp::Clause::OMPC_release, + llvm::omp::Clause::OMPC_relaxed, + llvm::omp::Clause::OMPC_hint, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_atomic { + }; + + static OmpClauseSet requiredClauses_OMPD_atomic { + }; + + // Sets for barrier + + static OmpClauseSet allowedClauses_OMPD_barrier { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_barrier { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_barrier { + }; + + static OmpClauseSet requiredClauses_OMPD_barrier { + }; + + // Sets for begin assumes + + static OmpClauseSet allowedClauses_OMPD_begin_assumes { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_begin_assumes { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_begin_assumes { + }; + + static OmpClauseSet requiredClauses_OMPD_begin_assumes { + }; + + // Sets for begin declare variant + + static OmpClauseSet allowedClauses_OMPD_begin_declare_variant { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_begin_declare_variant { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_begin_declare_variant { + }; + + static OmpClauseSet requiredClauses_OMPD_begin_declare_variant { + }; + + // Sets for cancel + + static OmpClauseSet allowedClauses_OMPD_cancel { + llvm::omp::Clause::OMPC_if, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_cancel { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_cancel { + }; + + static OmpClauseSet requiredClauses_OMPD_cancel { + }; + + // Sets for cancellation point + + static OmpClauseSet allowedClauses_OMPD_cancellation_point { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_cancellation_point { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_cancellation_point { + }; + + static OmpClauseSet requiredClauses_OMPD_cancellation_point { + }; + + // Sets for critical + + static OmpClauseSet allowedClauses_OMPD_critical { + llvm::omp::Clause::OMPC_hint, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_critical { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_critical { + }; + + static OmpClauseSet requiredClauses_OMPD_critical { + }; + + // Sets for declare mapper + + static OmpClauseSet allowedClauses_OMPD_declare_mapper { + llvm::omp::Clause::OMPC_map, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_declare_mapper { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_declare_mapper { + }; + + static OmpClauseSet requiredClauses_OMPD_declare_mapper { + }; + + // Sets for declare reduction + + static OmpClauseSet allowedClauses_OMPD_declare_reduction { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_declare_reduction { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_declare_reduction { + }; + + static OmpClauseSet requiredClauses_OMPD_declare_reduction { + }; + + // Sets for declare simd + + static OmpClauseSet allowedClauses_OMPD_declare_simd { + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_uniform, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_declare_simd { + llvm::omp::Clause::OMPC_simdlen, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_declare_simd { + llvm::omp::Clause::OMPC_inbranch, + llvm::omp::Clause::OMPC_notinbranch, + }; + + static OmpClauseSet requiredClauses_OMPD_declare_simd { + }; + + // Sets for declare target + + static OmpClauseSet allowedClauses_OMPD_declare_target { + llvm::omp::Clause::OMPC_to, + llvm::omp::Clause::OMPC_link, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_declare_target { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_declare_target { + }; + + static OmpClauseSet requiredClauses_OMPD_declare_target { + }; + + // Sets for declare variant + + static OmpClauseSet allowedClauses_OMPD_declare_variant { + llvm::omp::Clause::OMPC_match, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_declare_variant { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_declare_variant { + }; + + static OmpClauseSet requiredClauses_OMPD_declare_variant { + }; + + // Sets for depobj + + static OmpClauseSet allowedClauses_OMPD_depobj { + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_destroy, + llvm::omp::Clause::OMPC_update, + llvm::omp::Clause::OMPC_depobj, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_depobj { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_depobj { + }; + + static OmpClauseSet requiredClauses_OMPD_depobj { + }; + + // Sets for distribute + + static OmpClauseSet allowedClauses_OMPD_distribute { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_distribute { + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_distribute { + }; + + static OmpClauseSet requiredClauses_OMPD_distribute { + }; + + // Sets for distribute parallel do + + static OmpClauseSet allowedClauses_OMPD_distribute_parallel_do { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_linear, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_do { + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_ordered, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_do { + }; + + static OmpClauseSet requiredClauses_OMPD_distribute_parallel_do { + }; + + // Sets for distribute parallel do simd + + static OmpClauseSet allowedClauses_OMPD_distribute_parallel_do_simd { + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_do_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_do_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_distribute_parallel_do_simd { + }; + + // Sets for distribute parallel for + + static OmpClauseSet allowedClauses_OMPD_distribute_parallel_for { + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_for { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_for { + }; + + static OmpClauseSet requiredClauses_OMPD_distribute_parallel_for { + }; + + // Sets for distribute parallel for simd + + static OmpClauseSet allowedClauses_OMPD_distribute_parallel_for_simd { + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_for_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_for_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_distribute_parallel_for_simd { + }; + + // Sets for distribute simd + + static OmpClauseSet allowedClauses_OMPD_distribute_simd { + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_reduction, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_distribute_simd { + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_distribute_simd { + }; + + // Sets for do + + static OmpClauseSet allowedClauses_OMPD_do { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_reduction, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_do { + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_nowait, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_do { + }; + + static OmpClauseSet requiredClauses_OMPD_do { + }; + + // Sets for do simd + + static OmpClauseSet allowedClauses_OMPD_do_simd { + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_reduction, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_do_simd { + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_nowait, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_do_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_do_simd { + }; + + // Sets for end assumes + + static OmpClauseSet allowedClauses_OMPD_end_assumes { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_end_assumes { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_end_assumes { + }; + + static OmpClauseSet requiredClauses_OMPD_end_assumes { + }; + + // Sets for end declare target + + static OmpClauseSet allowedClauses_OMPD_end_declare_target { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_end_declare_target { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_end_declare_target { + }; + + static OmpClauseSet requiredClauses_OMPD_end_declare_target { + }; + + // Sets for end declare variant + + static OmpClauseSet allowedClauses_OMPD_end_declare_variant { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_end_declare_variant { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_end_declare_variant { + }; + + static OmpClauseSet requiredClauses_OMPD_end_declare_variant { + }; + + // Sets for end do + + static OmpClauseSet allowedClauses_OMPD_end_do { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_end_do { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_end_do { + }; + + static OmpClauseSet requiredClauses_OMPD_end_do { + }; + + // Sets for end do simd + + static OmpClauseSet allowedClauses_OMPD_end_do_simd { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_end_do_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_end_do_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_end_do_simd { + }; + + // Sets for end sections + + static OmpClauseSet allowedClauses_OMPD_end_sections { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_end_sections { + llvm::omp::Clause::OMPC_nowait, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_end_sections { + }; + + static OmpClauseSet requiredClauses_OMPD_end_sections { + }; + + // Sets for end single + + static OmpClauseSet allowedClauses_OMPD_end_single { + llvm::omp::Clause::OMPC_copyprivate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_end_single { + llvm::omp::Clause::OMPC_nowait, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_end_single { + }; + + static OmpClauseSet requiredClauses_OMPD_end_single { + }; + + // Sets for end workshare + + static OmpClauseSet allowedClauses_OMPD_end_workshare { + llvm::omp::Clause::OMPC_nowait, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_end_workshare { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_end_workshare { + }; + + static OmpClauseSet requiredClauses_OMPD_end_workshare { + }; + + // Sets for flush + + static OmpClauseSet allowedClauses_OMPD_flush { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_flush { + llvm::omp::Clause::OMPC_acq_rel, + llvm::omp::Clause::OMPC_acquire, + llvm::omp::Clause::OMPC_release, + llvm::omp::Clause::OMPC_flush, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_flush { + }; + + static OmpClauseSet requiredClauses_OMPD_flush { + }; + + // Sets for for + + static OmpClauseSet allowedClauses_OMPD_for { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_for { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_for { + }; + + static OmpClauseSet requiredClauses_OMPD_for { + }; + + // Sets for for simd + + static OmpClauseSet allowedClauses_OMPD_for_simd { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_for_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_for_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_for_simd { + }; + + // Sets for master + + static OmpClauseSet allowedClauses_OMPD_master { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_master { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_master { + }; + + static OmpClauseSet requiredClauses_OMPD_master { + }; + + // Sets for master taskloop + + static OmpClauseSet allowedClauses_OMPD_master_taskloop { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_final, + llvm::omp::Clause::OMPC_untied, + llvm::omp::Clause::OMPC_mergeable, + llvm::omp::Clause::OMPC_priority, + llvm::omp::Clause::OMPC_grainsize, + llvm::omp::Clause::OMPC_nogroup, + llvm::omp::Clause::OMPC_num_tasks, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_in_reduction, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_master_taskloop { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_master_taskloop { + }; + + static OmpClauseSet requiredClauses_OMPD_master_taskloop { + }; + + // Sets for master taskloop simd + + static OmpClauseSet allowedClauses_OMPD_master_taskloop_simd { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_final, + llvm::omp::Clause::OMPC_untied, + llvm::omp::Clause::OMPC_mergeable, + llvm::omp::Clause::OMPC_priority, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_grainsize, + llvm::omp::Clause::OMPC_nogroup, + llvm::omp::Clause::OMPC_num_tasks, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_in_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_master_taskloop_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_master_taskloop_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_master_taskloop_simd { + }; + + // Sets for ordered + + static OmpClauseSet allowedClauses_OMPD_ordered { + llvm::omp::Clause::OMPC_threads, + llvm::omp::Clause::OMPC_simd, + llvm::omp::Clause::OMPC_depend, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_ordered { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_ordered { + }; + + static OmpClauseSet requiredClauses_OMPD_ordered { + }; + + // Sets for parallel + + static OmpClauseSet allowedClauses_OMPD_parallel { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel { + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel { + }; + + // Sets for parallel do + + static OmpClauseSet allowedClauses_OMPD_parallel_do { + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_linear, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel_do { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_collapse, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_do { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel_do { + }; + + // Sets for parallel do simd + + static OmpClauseSet allowedClauses_OMPD_parallel_do_simd { + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel_do_simd { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_do_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel_do_simd { + }; + + // Sets for parallel for + + static OmpClauseSet allowedClauses_OMPD_parallel_for { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel_for { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_for { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel_for { + }; + + // Sets for parallel for simd + + static OmpClauseSet allowedClauses_OMPD_parallel_for_simd { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel_for_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_for_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel_for_simd { + }; + + // Sets for parallel master + + static OmpClauseSet allowedClauses_OMPD_parallel_master { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel_master { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel_master { + }; + + // Sets for parallel master taskloop + + static OmpClauseSet allowedClauses_OMPD_parallel_master_taskloop { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_final, + llvm::omp::Clause::OMPC_untied, + llvm::omp::Clause::OMPC_mergeable, + llvm::omp::Clause::OMPC_priority, + llvm::omp::Clause::OMPC_grainsize, + llvm::omp::Clause::OMPC_nogroup, + llvm::omp::Clause::OMPC_num_tasks, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_copyin, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel_master_taskloop { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master_taskloop { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel_master_taskloop { + }; + + // Sets for parallel master taskloop simd + + static OmpClauseSet allowedClauses_OMPD_parallel_master_taskloop_simd { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_final, + llvm::omp::Clause::OMPC_untied, + llvm::omp::Clause::OMPC_mergeable, + llvm::omp::Clause::OMPC_priority, + llvm::omp::Clause::OMPC_grainsize, + llvm::omp::Clause::OMPC_nogroup, + llvm::omp::Clause::OMPC_num_tasks, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel_master_taskloop_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master_taskloop_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel_master_taskloop_simd { + }; + + // Sets for parallel sections + + static OmpClauseSet allowedClauses_OMPD_parallel_sections { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel_sections { + llvm::omp::Clause::OMPC_num_threads, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_sections { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel_sections { + }; + + // Sets for parallel workshare + + static OmpClauseSet allowedClauses_OMPD_parallel_workshare { + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_shared, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_parallel_workshare { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_workshare { + }; + + static OmpClauseSet requiredClauses_OMPD_parallel_workshare { + }; + + // Sets for requires + + static OmpClauseSet allowedClauses_OMPD_requires { + llvm::omp::Clause::OMPC_unified_address, + llvm::omp::Clause::OMPC_unified_shared_memory, + llvm::omp::Clause::OMPC_reverse_offload, + llvm::omp::Clause::OMPC_dynamic_allocators, + llvm::omp::Clause::OMPC_atomic_default_mem_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_requires { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_requires { + }; + + static OmpClauseSet requiredClauses_OMPD_requires { + }; + + // Sets for scan + + static OmpClauseSet allowedClauses_OMPD_scan { + llvm::omp::Clause::OMPC_inclusive, + llvm::omp::Clause::OMPC_exclusive, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_scan { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_scan { + }; + + static OmpClauseSet requiredClauses_OMPD_scan { + }; + + // Sets for section + + static OmpClauseSet allowedClauses_OMPD_section { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_section { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_section { + }; + + static OmpClauseSet requiredClauses_OMPD_section { + }; + + // Sets for sections + + static OmpClauseSet allowedClauses_OMPD_sections { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_sections { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_sections { + }; + + static OmpClauseSet requiredClauses_OMPD_sections { + }; + + // Sets for simd + + static OmpClauseSet allowedClauses_OMPD_simd { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_simd { + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_if, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_simd { + }; + + // Sets for single + + static OmpClauseSet allowedClauses_OMPD_single { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_copyprivate, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_single { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_single { + }; + + static OmpClauseSet requiredClauses_OMPD_single { + }; + + // Sets for target + + static OmpClauseSet allowedClauses_OMPD_target { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_uses_allocators, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target { + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_nowait, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target { + }; + + static OmpClauseSet requiredClauses_OMPD_target { + }; + + // Sets for target data + + static OmpClauseSet allowedClauses_OMPD_target_data { + llvm::omp::Clause::OMPC_use_device_ptr, + llvm::omp::Clause::OMPC_use_device_addr, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_data { + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_if, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_data { + }; + + static OmpClauseSet requiredClauses_OMPD_target_data { + llvm::omp::Clause::OMPC_map, + }; + + // Sets for target enter data + + static OmpClauseSet allowedClauses_OMPD_target_enter_data { + llvm::omp::Clause::OMPC_depend, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_enter_data { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_nowait, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_enter_data { + }; + + static OmpClauseSet requiredClauses_OMPD_target_enter_data { + llvm::omp::Clause::OMPC_map, + }; + + // Sets for target exit data + + static OmpClauseSet allowedClauses_OMPD_target_exit_data { + llvm::omp::Clause::OMPC_depend, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_exit_data { + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_nowait, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_exit_data { + }; + + static OmpClauseSet requiredClauses_OMPD_target_exit_data { + llvm::omp::Clause::OMPC_map, + }; + + // Sets for target parallel + + static OmpClauseSet allowedClauses_OMPD_target_parallel { + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_uses_allocators, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_parallel { + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel { + }; + + static OmpClauseSet requiredClauses_OMPD_target_parallel { + }; + + // Sets for target parallel do + + static OmpClauseSet allowedClauses_OMPD_target_parallel_do { + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_allocator, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_uses_allocators, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_copyin, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_do { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_nowait, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_do { + }; + + static OmpClauseSet requiredClauses_OMPD_target_parallel_do { + }; + + // Sets for target parallel do simd + + static OmpClauseSet allowedClauses_OMPD_target_parallel_do_simd { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_uses_allocators, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_do_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_do_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_target_parallel_do_simd { + }; + + // Sets for target parallel for + + static OmpClauseSet allowedClauses_OMPD_target_parallel_for { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_uses_allocators, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_for { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_for { + }; + + static OmpClauseSet requiredClauses_OMPD_target_parallel_for { + }; + + // Sets for target parallel for simd + + static OmpClauseSet allowedClauses_OMPD_target_parallel_for_simd { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_uses_allocators, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_for_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_for_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_target_parallel_for_simd { + }; + + // Sets for target simd + + static OmpClauseSet allowedClauses_OMPD_target_simd { + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_uses_allocators, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_simd { + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_schedule, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_target_simd { + }; + + // Sets for target teams + + static OmpClauseSet allowedClauses_OMPD_target_teams { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_uses_allocators, + llvm::omp::Clause::OMPC_shared, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_teams { + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams { + }; + + static OmpClauseSet requiredClauses_OMPD_target_teams { + }; + + // Sets for target teams distribute + + static OmpClauseSet allowedClauses_OMPD_target_teams_distribute { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_uses_allocators, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_lastprivate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute { + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute { + }; + + static OmpClauseSet requiredClauses_OMPD_target_teams_distribute { + }; + + // Sets for target teams distribute parallel do + + static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_do { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_uses_allocators, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_do { + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do { + }; + + static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_do { + }; + + // Sets for target teams distribute parallel do simd + + static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_do_simd { + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_uses_allocators, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_nontemporal, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_do_simd { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_do_simd { + }; + + // Sets for target teams distribute parallel for + + static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_for { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_uses_allocators, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_for { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for { + }; + + static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_for { + }; + + // Sets for target teams distribute parallel for simd + + static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_for_simd { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_uses_allocators, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_for_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_for_simd { + }; + + // Sets for target teams distribute simd + + static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_simd { + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_is_device_ptr, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_map, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_uses_allocators, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_simd { + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_defaultmap, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_simd { + }; + + // Sets for target update + + static OmpClauseSet allowedClauses_OMPD_target_update { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_device, + llvm::omp::Clause::OMPC_to, + llvm::omp::Clause::OMPC_from, + llvm::omp::Clause::OMPC_nowait, + llvm::omp::Clause::OMPC_depend, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_target_update { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_target_update { + }; + + static OmpClauseSet requiredClauses_OMPD_target_update { + }; + + // Sets for task + + static OmpClauseSet allowedClauses_OMPD_task { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_untied, + llvm::omp::Clause::OMPC_mergeable, + llvm::omp::Clause::OMPC_depend, + llvm::omp::Clause::OMPC_in_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_detach, + llvm::omp::Clause::OMPC_affinity, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_task { + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_final, + llvm::omp::Clause::OMPC_priority, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_task { + }; + + static OmpClauseSet requiredClauses_OMPD_task { + }; + + // Sets for taskgroup + + static OmpClauseSet allowedClauses_OMPD_taskgroup { + llvm::omp::Clause::OMPC_task_reduction, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_taskgroup { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_taskgroup { + }; + + static OmpClauseSet requiredClauses_OMPD_taskgroup { + }; + + // Sets for taskloop + + static OmpClauseSet allowedClauses_OMPD_taskloop { + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_untied, + llvm::omp::Clause::OMPC_mergeable, + llvm::omp::Clause::OMPC_nogroup, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_in_reduction, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_taskloop { + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_final, + llvm::omp::Clause::OMPC_priority, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_taskloop { + llvm::omp::Clause::OMPC_grainsize, + llvm::omp::Clause::OMPC_num_tasks, + }; + + static OmpClauseSet requiredClauses_OMPD_taskloop { + }; + + // Sets for taskloop simd + + static OmpClauseSet allowedClauses_OMPD_taskloop_simd { + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_in_reduction, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_mergeable, + llvm::omp::Clause::OMPC_nogroup, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_untied, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_taskloop_simd { + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_final, + llvm::omp::Clause::OMPC_priority, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_taskloop_simd { + llvm::omp::Clause::OMPC_grainsize, + llvm::omp::Clause::OMPC_num_tasks, + }; + + static OmpClauseSet requiredClauses_OMPD_taskloop_simd { + }; + + // Sets for taskwait + + static OmpClauseSet allowedClauses_OMPD_taskwait { + llvm::omp::Clause::OMPC_depend, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_taskwait { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_taskwait { + }; + + static OmpClauseSet requiredClauses_OMPD_taskwait { + }; + + // Sets for taskyield + + static OmpClauseSet allowedClauses_OMPD_taskyield { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_taskyield { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_taskyield { + }; + + static OmpClauseSet requiredClauses_OMPD_taskyield { + }; + + // Sets for teams + + static OmpClauseSet allowedClauses_OMPD_teams { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_teams { + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_teams { + }; + + static OmpClauseSet requiredClauses_OMPD_teams { + }; + + // Sets for teams distribute + + static OmpClauseSet allowedClauses_OMPD_teams_distribute { + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_allocate, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute { + }; + + static OmpClauseSet requiredClauses_OMPD_teams_distribute { + }; + + // Sets for teams distribute parallel do + + static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_do { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_linear, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_do { + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_ordered, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_do { + }; + + static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_do { + }; + + // Sets for teams distribute parallel do simd + + static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_do_simd { + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_nontemporal, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_do_simd { + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_if, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_do_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_do_simd { + }; + + // Sets for teams distribute parallel for + + static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_for { + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_copyin, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_for { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_for { + }; + + static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_for { + }; + + // Sets for teams distribute parallel for simd + + static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_for_simd { + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_threads, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_proc_bind, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_shared, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_schedule, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_thread_limit, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_for_simd { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_for_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_for_simd { + }; + + // Sets for teams distribute simd + + static OmpClauseSet allowedClauses_OMPD_teams_distribute_simd { + llvm::omp::Clause::OMPC_aligned, + llvm::omp::Clause::OMPC_allocate, + llvm::omp::Clause::OMPC_firstprivate, + llvm::omp::Clause::OMPC_lastprivate, + llvm::omp::Clause::OMPC_linear, + llvm::omp::Clause::OMPC_nontemporal, + llvm::omp::Clause::OMPC_order, + llvm::omp::Clause::OMPC_private, + llvm::omp::Clause::OMPC_reduction, + llvm::omp::Clause::OMPC_shared, + }; + + static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_simd { + llvm::omp::Clause::OMPC_collapse, + llvm::omp::Clause::OMPC_default, + llvm::omp::Clause::OMPC_dist_schedule, + llvm::omp::Clause::OMPC_if, + llvm::omp::Clause::OMPC_num_teams, + llvm::omp::Clause::OMPC_safelen, + llvm::omp::Clause::OMPC_simdlen, + llvm::omp::Clause::OMPC_thread_limit, + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_simd { + }; + + static OmpClauseSet requiredClauses_OMPD_teams_distribute_simd { + }; + + // Sets for threadprivate + + static OmpClauseSet allowedClauses_OMPD_threadprivate { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_threadprivate { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_threadprivate { + }; + + static OmpClauseSet requiredClauses_OMPD_threadprivate { + }; + + // Sets for unknown + + static OmpClauseSet allowedClauses_OMPD_unknown { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_unknown { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_unknown { + }; + + static OmpClauseSet requiredClauses_OMPD_unknown { + }; + + // Sets for workshare + + static OmpClauseSet allowedClauses_OMPD_workshare { + }; + + static OmpClauseSet allowedOnceClauses_OMPD_workshare { + }; + + static OmpClauseSet allowedExclusiveClauses_OMPD_workshare { + }; + + static OmpClauseSet requiredClauses_OMPD_workshare { + }; +} // namespace omp +} // namespace llvm + +#endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS + +#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP +#undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP + +{ + {llvm::omp::Directive::OMPD_allocate, + { + llvm::omp::allowedClauses_OMPD_allocate, + llvm::omp::allowedOnceClauses_OMPD_allocate, + llvm::omp::allowedExclusiveClauses_OMPD_allocate, + llvm::omp::requiredClauses_OMPD_allocate, + } + }, + {llvm::omp::Directive::OMPD_assumes, + { + llvm::omp::allowedClauses_OMPD_assumes, + llvm::omp::allowedOnceClauses_OMPD_assumes, + llvm::omp::allowedExclusiveClauses_OMPD_assumes, + llvm::omp::requiredClauses_OMPD_assumes, + } + }, + {llvm::omp::Directive::OMPD_atomic, + { + llvm::omp::allowedClauses_OMPD_atomic, + llvm::omp::allowedOnceClauses_OMPD_atomic, + llvm::omp::allowedExclusiveClauses_OMPD_atomic, + llvm::omp::requiredClauses_OMPD_atomic, + } + }, + {llvm::omp::Directive::OMPD_barrier, + { + llvm::omp::allowedClauses_OMPD_barrier, + llvm::omp::allowedOnceClauses_OMPD_barrier, + llvm::omp::allowedExclusiveClauses_OMPD_barrier, + llvm::omp::requiredClauses_OMPD_barrier, + } + }, + {llvm::omp::Directive::OMPD_begin_assumes, + { + llvm::omp::allowedClauses_OMPD_begin_assumes, + llvm::omp::allowedOnceClauses_OMPD_begin_assumes, + llvm::omp::allowedExclusiveClauses_OMPD_begin_assumes, + llvm::omp::requiredClauses_OMPD_begin_assumes, + } + }, + {llvm::omp::Directive::OMPD_begin_declare_variant, + { + llvm::omp::allowedClauses_OMPD_begin_declare_variant, + llvm::omp::allowedOnceClauses_OMPD_begin_declare_variant, + llvm::omp::allowedExclusiveClauses_OMPD_begin_declare_variant, + llvm::omp::requiredClauses_OMPD_begin_declare_variant, + } + }, + {llvm::omp::Directive::OMPD_cancel, + { + llvm::omp::allowedClauses_OMPD_cancel, + llvm::omp::allowedOnceClauses_OMPD_cancel, + llvm::omp::allowedExclusiveClauses_OMPD_cancel, + llvm::omp::requiredClauses_OMPD_cancel, + } + }, + {llvm::omp::Directive::OMPD_cancellation_point, + { + llvm::omp::allowedClauses_OMPD_cancellation_point, + llvm::omp::allowedOnceClauses_OMPD_cancellation_point, + llvm::omp::allowedExclusiveClauses_OMPD_cancellation_point, + llvm::omp::requiredClauses_OMPD_cancellation_point, + } + }, + {llvm::omp::Directive::OMPD_critical, + { + llvm::omp::allowedClauses_OMPD_critical, + llvm::omp::allowedOnceClauses_OMPD_critical, + llvm::omp::allowedExclusiveClauses_OMPD_critical, + llvm::omp::requiredClauses_OMPD_critical, + } + }, + {llvm::omp::Directive::OMPD_declare_mapper, + { + llvm::omp::allowedClauses_OMPD_declare_mapper, + llvm::omp::allowedOnceClauses_OMPD_declare_mapper, + llvm::omp::allowedExclusiveClauses_OMPD_declare_mapper, + llvm::omp::requiredClauses_OMPD_declare_mapper, + } + }, + {llvm::omp::Directive::OMPD_declare_reduction, + { + llvm::omp::allowedClauses_OMPD_declare_reduction, + llvm::omp::allowedOnceClauses_OMPD_declare_reduction, + llvm::omp::allowedExclusiveClauses_OMPD_declare_reduction, + llvm::omp::requiredClauses_OMPD_declare_reduction, + } + }, + {llvm::omp::Directive::OMPD_declare_simd, + { + llvm::omp::allowedClauses_OMPD_declare_simd, + llvm::omp::allowedOnceClauses_OMPD_declare_simd, + llvm::omp::allowedExclusiveClauses_OMPD_declare_simd, + llvm::omp::requiredClauses_OMPD_declare_simd, + } + }, + {llvm::omp::Directive::OMPD_declare_target, + { + llvm::omp::allowedClauses_OMPD_declare_target, + llvm::omp::allowedOnceClauses_OMPD_declare_target, + llvm::omp::allowedExclusiveClauses_OMPD_declare_target, + llvm::omp::requiredClauses_OMPD_declare_target, + } + }, + {llvm::omp::Directive::OMPD_declare_variant, + { + llvm::omp::allowedClauses_OMPD_declare_variant, + llvm::omp::allowedOnceClauses_OMPD_declare_variant, + llvm::omp::allowedExclusiveClauses_OMPD_declare_variant, + llvm::omp::requiredClauses_OMPD_declare_variant, + } + }, + {llvm::omp::Directive::OMPD_depobj, + { + llvm::omp::allowedClauses_OMPD_depobj, + llvm::omp::allowedOnceClauses_OMPD_depobj, + llvm::omp::allowedExclusiveClauses_OMPD_depobj, + llvm::omp::requiredClauses_OMPD_depobj, + } + }, + {llvm::omp::Directive::OMPD_distribute, + { + llvm::omp::allowedClauses_OMPD_distribute, + llvm::omp::allowedOnceClauses_OMPD_distribute, + llvm::omp::allowedExclusiveClauses_OMPD_distribute, + llvm::omp::requiredClauses_OMPD_distribute, + } + }, + {llvm::omp::Directive::OMPD_distribute_parallel_do, + { + llvm::omp::allowedClauses_OMPD_distribute_parallel_do, + llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_do, + llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_do, + llvm::omp::requiredClauses_OMPD_distribute_parallel_do, + } + }, + {llvm::omp::Directive::OMPD_distribute_parallel_do_simd, + { + llvm::omp::allowedClauses_OMPD_distribute_parallel_do_simd, + llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_do_simd, + llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_do_simd, + llvm::omp::requiredClauses_OMPD_distribute_parallel_do_simd, + } + }, + {llvm::omp::Directive::OMPD_distribute_parallel_for, + { + llvm::omp::allowedClauses_OMPD_distribute_parallel_for, + llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_for, + llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_for, + llvm::omp::requiredClauses_OMPD_distribute_parallel_for, + } + }, + {llvm::omp::Directive::OMPD_distribute_parallel_for_simd, + { + llvm::omp::allowedClauses_OMPD_distribute_parallel_for_simd, + llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_for_simd, + llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_for_simd, + llvm::omp::requiredClauses_OMPD_distribute_parallel_for_simd, + } + }, + {llvm::omp::Directive::OMPD_distribute_simd, + { + llvm::omp::allowedClauses_OMPD_distribute_simd, + llvm::omp::allowedOnceClauses_OMPD_distribute_simd, + llvm::omp::allowedExclusiveClauses_OMPD_distribute_simd, + llvm::omp::requiredClauses_OMPD_distribute_simd, + } + }, + {llvm::omp::Directive::OMPD_do, + { + llvm::omp::allowedClauses_OMPD_do, + llvm::omp::allowedOnceClauses_OMPD_do, + llvm::omp::allowedExclusiveClauses_OMPD_do, + llvm::omp::requiredClauses_OMPD_do, + } + }, + {llvm::omp::Directive::OMPD_do_simd, + { + llvm::omp::allowedClauses_OMPD_do_simd, + llvm::omp::allowedOnceClauses_OMPD_do_simd, + llvm::omp::allowedExclusiveClauses_OMPD_do_simd, + llvm::omp::requiredClauses_OMPD_do_simd, + } + }, + {llvm::omp::Directive::OMPD_end_assumes, + { + llvm::omp::allowedClauses_OMPD_end_assumes, + llvm::omp::allowedOnceClauses_OMPD_end_assumes, + llvm::omp::allowedExclusiveClauses_OMPD_end_assumes, + llvm::omp::requiredClauses_OMPD_end_assumes, + } + }, + {llvm::omp::Directive::OMPD_end_declare_target, + { + llvm::omp::allowedClauses_OMPD_end_declare_target, + llvm::omp::allowedOnceClauses_OMPD_end_declare_target, + llvm::omp::allowedExclusiveClauses_OMPD_end_declare_target, + llvm::omp::requiredClauses_OMPD_end_declare_target, + } + }, + {llvm::omp::Directive::OMPD_end_declare_variant, + { + llvm::omp::allowedClauses_OMPD_end_declare_variant, + llvm::omp::allowedOnceClauses_OMPD_end_declare_variant, + llvm::omp::allowedExclusiveClauses_OMPD_end_declare_variant, + llvm::omp::requiredClauses_OMPD_end_declare_variant, + } + }, + {llvm::omp::Directive::OMPD_end_do, + { + llvm::omp::allowedClauses_OMPD_end_do, + llvm::omp::allowedOnceClauses_OMPD_end_do, + llvm::omp::allowedExclusiveClauses_OMPD_end_do, + llvm::omp::requiredClauses_OMPD_end_do, + } + }, + {llvm::omp::Directive::OMPD_end_do_simd, + { + llvm::omp::allowedClauses_OMPD_end_do_simd, + llvm::omp::allowedOnceClauses_OMPD_end_do_simd, + llvm::omp::allowedExclusiveClauses_OMPD_end_do_simd, + llvm::omp::requiredClauses_OMPD_end_do_simd, + } + }, + {llvm::omp::Directive::OMPD_end_sections, + { + llvm::omp::allowedClauses_OMPD_end_sections, + llvm::omp::allowedOnceClauses_OMPD_end_sections, + llvm::omp::allowedExclusiveClauses_OMPD_end_sections, + llvm::omp::requiredClauses_OMPD_end_sections, + } + }, + {llvm::omp::Directive::OMPD_end_single, + { + llvm::omp::allowedClauses_OMPD_end_single, + llvm::omp::allowedOnceClauses_OMPD_end_single, + llvm::omp::allowedExclusiveClauses_OMPD_end_single, + llvm::omp::requiredClauses_OMPD_end_single, + } + }, + {llvm::omp::Directive::OMPD_end_workshare, + { + llvm::omp::allowedClauses_OMPD_end_workshare, + llvm::omp::allowedOnceClauses_OMPD_end_workshare, + llvm::omp::allowedExclusiveClauses_OMPD_end_workshare, + llvm::omp::requiredClauses_OMPD_end_workshare, + } + }, + {llvm::omp::Directive::OMPD_flush, + { + llvm::omp::allowedClauses_OMPD_flush, + llvm::omp::allowedOnceClauses_OMPD_flush, + llvm::omp::allowedExclusiveClauses_OMPD_flush, + llvm::omp::requiredClauses_OMPD_flush, + } + }, + {llvm::omp::Directive::OMPD_for, + { + llvm::omp::allowedClauses_OMPD_for, + llvm::omp::allowedOnceClauses_OMPD_for, + llvm::omp::allowedExclusiveClauses_OMPD_for, + llvm::omp::requiredClauses_OMPD_for, + } + }, + {llvm::omp::Directive::OMPD_for_simd, + { + llvm::omp::allowedClauses_OMPD_for_simd, + llvm::omp::allowedOnceClauses_OMPD_for_simd, + llvm::omp::allowedExclusiveClauses_OMPD_for_simd, + llvm::omp::requiredClauses_OMPD_for_simd, + } + }, + {llvm::omp::Directive::OMPD_master, + { + llvm::omp::allowedClauses_OMPD_master, + llvm::omp::allowedOnceClauses_OMPD_master, + llvm::omp::allowedExclusiveClauses_OMPD_master, + llvm::omp::requiredClauses_OMPD_master, + } + }, + {llvm::omp::Directive::OMPD_master_taskloop, + { + llvm::omp::allowedClauses_OMPD_master_taskloop, + llvm::omp::allowedOnceClauses_OMPD_master_taskloop, + llvm::omp::allowedExclusiveClauses_OMPD_master_taskloop, + llvm::omp::requiredClauses_OMPD_master_taskloop, + } + }, + {llvm::omp::Directive::OMPD_master_taskloop_simd, + { + llvm::omp::allowedClauses_OMPD_master_taskloop_simd, + llvm::omp::allowedOnceClauses_OMPD_master_taskloop_simd, + llvm::omp::allowedExclusiveClauses_OMPD_master_taskloop_simd, + llvm::omp::requiredClauses_OMPD_master_taskloop_simd, + } + }, + {llvm::omp::Directive::OMPD_ordered, + { + llvm::omp::allowedClauses_OMPD_ordered, + llvm::omp::allowedOnceClauses_OMPD_ordered, + llvm::omp::allowedExclusiveClauses_OMPD_ordered, + llvm::omp::requiredClauses_OMPD_ordered, + } + }, + {llvm::omp::Directive::OMPD_parallel, + { + llvm::omp::allowedClauses_OMPD_parallel, + llvm::omp::allowedOnceClauses_OMPD_parallel, + llvm::omp::allowedExclusiveClauses_OMPD_parallel, + llvm::omp::requiredClauses_OMPD_parallel, + } + }, + {llvm::omp::Directive::OMPD_parallel_do, + { + llvm::omp::allowedClauses_OMPD_parallel_do, + llvm::omp::allowedOnceClauses_OMPD_parallel_do, + llvm::omp::allowedExclusiveClauses_OMPD_parallel_do, + llvm::omp::requiredClauses_OMPD_parallel_do, + } + }, + {llvm::omp::Directive::OMPD_parallel_do_simd, + { + llvm::omp::allowedClauses_OMPD_parallel_do_simd, + llvm::omp::allowedOnceClauses_OMPD_parallel_do_simd, + llvm::omp::allowedExclusiveClauses_OMPD_parallel_do_simd, + llvm::omp::requiredClauses_OMPD_parallel_do_simd, + } + }, + {llvm::omp::Directive::OMPD_parallel_for, + { + llvm::omp::allowedClauses_OMPD_parallel_for, + llvm::omp::allowedOnceClauses_OMPD_parallel_for, + llvm::omp::allowedExclusiveClauses_OMPD_parallel_for, + llvm::omp::requiredClauses_OMPD_parallel_for, + } + }, + {llvm::omp::Directive::OMPD_parallel_for_simd, + { + llvm::omp::allowedClauses_OMPD_parallel_for_simd, + llvm::omp::allowedOnceClauses_OMPD_parallel_for_simd, + llvm::omp::allowedExclusiveClauses_OMPD_parallel_for_simd, + llvm::omp::requiredClauses_OMPD_parallel_for_simd, + } + }, + {llvm::omp::Directive::OMPD_parallel_master, + { + llvm::omp::allowedClauses_OMPD_parallel_master, + llvm::omp::allowedOnceClauses_OMPD_parallel_master, + llvm::omp::allowedExclusiveClauses_OMPD_parallel_master, + llvm::omp::requiredClauses_OMPD_parallel_master, + } + }, + {llvm::omp::Directive::OMPD_parallel_master_taskloop, + { + llvm::omp::allowedClauses_OMPD_parallel_master_taskloop, + llvm::omp::allowedOnceClauses_OMPD_parallel_master_taskloop, + llvm::omp::allowedExclusiveClauses_OMPD_parallel_master_taskloop, + llvm::omp::requiredClauses_OMPD_parallel_master_taskloop, + } + }, + {llvm::omp::Directive::OMPD_parallel_master_taskloop_simd, + { + llvm::omp::allowedClauses_OMPD_parallel_master_taskloop_simd, + llvm::omp::allowedOnceClauses_OMPD_parallel_master_taskloop_simd, + llvm::omp::allowedExclusiveClauses_OMPD_parallel_master_taskloop_simd, + llvm::omp::requiredClauses_OMPD_parallel_master_taskloop_simd, + } + }, + {llvm::omp::Directive::OMPD_parallel_sections, + { + llvm::omp::allowedClauses_OMPD_parallel_sections, + llvm::omp::allowedOnceClauses_OMPD_parallel_sections, + llvm::omp::allowedExclusiveClauses_OMPD_parallel_sections, + llvm::omp::requiredClauses_OMPD_parallel_sections, + } + }, + {llvm::omp::Directive::OMPD_parallel_workshare, + { + llvm::omp::allowedClauses_OMPD_parallel_workshare, + llvm::omp::allowedOnceClauses_OMPD_parallel_workshare, + llvm::omp::allowedExclusiveClauses_OMPD_parallel_workshare, + llvm::omp::requiredClauses_OMPD_parallel_workshare, + } + }, + {llvm::omp::Directive::OMPD_requires, + { + llvm::omp::allowedClauses_OMPD_requires, + llvm::omp::allowedOnceClauses_OMPD_requires, + llvm::omp::allowedExclusiveClauses_OMPD_requires, + llvm::omp::requiredClauses_OMPD_requires, + } + }, + {llvm::omp::Directive::OMPD_scan, + { + llvm::omp::allowedClauses_OMPD_scan, + llvm::omp::allowedOnceClauses_OMPD_scan, + llvm::omp::allowedExclusiveClauses_OMPD_scan, + llvm::omp::requiredClauses_OMPD_scan, + } + }, + {llvm::omp::Directive::OMPD_section, + { + llvm::omp::allowedClauses_OMPD_section, + llvm::omp::allowedOnceClauses_OMPD_section, + llvm::omp::allowedExclusiveClauses_OMPD_section, + llvm::omp::requiredClauses_OMPD_section, + } + }, + {llvm::omp::Directive::OMPD_sections, + { + llvm::omp::allowedClauses_OMPD_sections, + llvm::omp::allowedOnceClauses_OMPD_sections, + llvm::omp::allowedExclusiveClauses_OMPD_sections, + llvm::omp::requiredClauses_OMPD_sections, + } + }, + {llvm::omp::Directive::OMPD_simd, + { + llvm::omp::allowedClauses_OMPD_simd, + llvm::omp::allowedOnceClauses_OMPD_simd, + llvm::omp::allowedExclusiveClauses_OMPD_simd, + llvm::omp::requiredClauses_OMPD_simd, + } + }, + {llvm::omp::Directive::OMPD_single, + { + llvm::omp::allowedClauses_OMPD_single, + llvm::omp::allowedOnceClauses_OMPD_single, + llvm::omp::allowedExclusiveClauses_OMPD_single, + llvm::omp::requiredClauses_OMPD_single, + } + }, + {llvm::omp::Directive::OMPD_target, + { + llvm::omp::allowedClauses_OMPD_target, + llvm::omp::allowedOnceClauses_OMPD_target, + llvm::omp::allowedExclusiveClauses_OMPD_target, + llvm::omp::requiredClauses_OMPD_target, + } + }, + {llvm::omp::Directive::OMPD_target_data, + { + llvm::omp::allowedClauses_OMPD_target_data, + llvm::omp::allowedOnceClauses_OMPD_target_data, + llvm::omp::allowedExclusiveClauses_OMPD_target_data, + llvm::omp::requiredClauses_OMPD_target_data, + } + }, + {llvm::omp::Directive::OMPD_target_enter_data, + { + llvm::omp::allowedClauses_OMPD_target_enter_data, + llvm::omp::allowedOnceClauses_OMPD_target_enter_data, + llvm::omp::allowedExclusiveClauses_OMPD_target_enter_data, + llvm::omp::requiredClauses_OMPD_target_enter_data, + } + }, + {llvm::omp::Directive::OMPD_target_exit_data, + { + llvm::omp::allowedClauses_OMPD_target_exit_data, + llvm::omp::allowedOnceClauses_OMPD_target_exit_data, + llvm::omp::allowedExclusiveClauses_OMPD_target_exit_data, + llvm::omp::requiredClauses_OMPD_target_exit_data, + } + }, + {llvm::omp::Directive::OMPD_target_parallel, + { + llvm::omp::allowedClauses_OMPD_target_parallel, + llvm::omp::allowedOnceClauses_OMPD_target_parallel, + llvm::omp::allowedExclusiveClauses_OMPD_target_parallel, + llvm::omp::requiredClauses_OMPD_target_parallel, + } + }, + {llvm::omp::Directive::OMPD_target_parallel_do, + { + llvm::omp::allowedClauses_OMPD_target_parallel_do, + llvm::omp::allowedOnceClauses_OMPD_target_parallel_do, + llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_do, + llvm::omp::requiredClauses_OMPD_target_parallel_do, + } + }, + {llvm::omp::Directive::OMPD_target_parallel_do_simd, + { + llvm::omp::allowedClauses_OMPD_target_parallel_do_simd, + llvm::omp::allowedOnceClauses_OMPD_target_parallel_do_simd, + llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_do_simd, + llvm::omp::requiredClauses_OMPD_target_parallel_do_simd, + } + }, + {llvm::omp::Directive::OMPD_target_parallel_for, + { + llvm::omp::allowedClauses_OMPD_target_parallel_for, + llvm::omp::allowedOnceClauses_OMPD_target_parallel_for, + llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_for, + llvm::omp::requiredClauses_OMPD_target_parallel_for, + } + }, + {llvm::omp::Directive::OMPD_target_parallel_for_simd, + { + llvm::omp::allowedClauses_OMPD_target_parallel_for_simd, + llvm::omp::allowedOnceClauses_OMPD_target_parallel_for_simd, + llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_for_simd, + llvm::omp::requiredClauses_OMPD_target_parallel_for_simd, + } + }, + {llvm::omp::Directive::OMPD_target_simd, + { + llvm::omp::allowedClauses_OMPD_target_simd, + llvm::omp::allowedOnceClauses_OMPD_target_simd, + llvm::omp::allowedExclusiveClauses_OMPD_target_simd, + llvm::omp::requiredClauses_OMPD_target_simd, + } + }, + {llvm::omp::Directive::OMPD_target_teams, + { + llvm::omp::allowedClauses_OMPD_target_teams, + llvm::omp::allowedOnceClauses_OMPD_target_teams, + llvm::omp::allowedExclusiveClauses_OMPD_target_teams, + llvm::omp::requiredClauses_OMPD_target_teams, + } + }, + {llvm::omp::Directive::OMPD_target_teams_distribute, + { + llvm::omp::allowedClauses_OMPD_target_teams_distribute, + llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute, + llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute, + llvm::omp::requiredClauses_OMPD_target_teams_distribute, + } + }, + {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do, + { + llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_do, + llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_do, + llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do, + llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_do, + } + }, + {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd, + { + llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_do_simd, + llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_do_simd, + llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do_simd, + llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_do_simd, + } + }, + {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for, + { + llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_for, + llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_for, + llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for, + llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_for, + } + }, + {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for_simd, + { + llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_for_simd, + llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_for_simd, + llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for_simd, + llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_for_simd, + } + }, + {llvm::omp::Directive::OMPD_target_teams_distribute_simd, + { + llvm::omp::allowedClauses_OMPD_target_teams_distribute_simd, + llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_simd, + llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_simd, + llvm::omp::requiredClauses_OMPD_target_teams_distribute_simd, + } + }, + {llvm::omp::Directive::OMPD_target_update, + { + llvm::omp::allowedClauses_OMPD_target_update, + llvm::omp::allowedOnceClauses_OMPD_target_update, + llvm::omp::allowedExclusiveClauses_OMPD_target_update, + llvm::omp::requiredClauses_OMPD_target_update, + } + }, + {llvm::omp::Directive::OMPD_task, + { + llvm::omp::allowedClauses_OMPD_task, + llvm::omp::allowedOnceClauses_OMPD_task, + llvm::omp::allowedExclusiveClauses_OMPD_task, + llvm::omp::requiredClauses_OMPD_task, + } + }, + {llvm::omp::Directive::OMPD_taskgroup, + { + llvm::omp::allowedClauses_OMPD_taskgroup, + llvm::omp::allowedOnceClauses_OMPD_taskgroup, + llvm::omp::allowedExclusiveClauses_OMPD_taskgroup, + llvm::omp::requiredClauses_OMPD_taskgroup, + } + }, + {llvm::omp::Directive::OMPD_taskloop, + { + llvm::omp::allowedClauses_OMPD_taskloop, + llvm::omp::allowedOnceClauses_OMPD_taskloop, + llvm::omp::allowedExclusiveClauses_OMPD_taskloop, + llvm::omp::requiredClauses_OMPD_taskloop, + } + }, + {llvm::omp::Directive::OMPD_taskloop_simd, + { + llvm::omp::allowedClauses_OMPD_taskloop_simd, + llvm::omp::allowedOnceClauses_OMPD_taskloop_simd, + llvm::omp::allowedExclusiveClauses_OMPD_taskloop_simd, + llvm::omp::requiredClauses_OMPD_taskloop_simd, + } + }, + {llvm::omp::Directive::OMPD_taskwait, + { + llvm::omp::allowedClauses_OMPD_taskwait, + llvm::omp::allowedOnceClauses_OMPD_taskwait, + llvm::omp::allowedExclusiveClauses_OMPD_taskwait, + llvm::omp::requiredClauses_OMPD_taskwait, + } + }, + {llvm::omp::Directive::OMPD_taskyield, + { + llvm::omp::allowedClauses_OMPD_taskyield, + llvm::omp::allowedOnceClauses_OMPD_taskyield, + llvm::omp::allowedExclusiveClauses_OMPD_taskyield, + llvm::omp::requiredClauses_OMPD_taskyield, + } + }, + {llvm::omp::Directive::OMPD_teams, + { + llvm::omp::allowedClauses_OMPD_teams, + llvm::omp::allowedOnceClauses_OMPD_teams, + llvm::omp::allowedExclusiveClauses_OMPD_teams, + llvm::omp::requiredClauses_OMPD_teams, + } + }, + {llvm::omp::Directive::OMPD_teams_distribute, + { + llvm::omp::allowedClauses_OMPD_teams_distribute, + llvm::omp::allowedOnceClauses_OMPD_teams_distribute, + llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute, + llvm::omp::requiredClauses_OMPD_teams_distribute, + } + }, + {llvm::omp::Directive::OMPD_teams_distribute_parallel_do, + { + llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_do, + llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_do, + llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_do, + llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_do, + } + }, + {llvm::omp::Directive::OMPD_teams_distribute_parallel_do_simd, + { + llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_do_simd, + llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_do_simd, + llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_do_simd, + llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_do_simd, + } + }, + {llvm::omp::Directive::OMPD_teams_distribute_parallel_for, + { + llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_for, + llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_for, + llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_for, + llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_for, + } + }, + {llvm::omp::Directive::OMPD_teams_distribute_parallel_for_simd, + { + llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_for_simd, + llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_for_simd, + llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_for_simd, + llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_for_simd, + } + }, + {llvm::omp::Directive::OMPD_teams_distribute_simd, + { + llvm::omp::allowedClauses_OMPD_teams_distribute_simd, + llvm::omp::allowedOnceClauses_OMPD_teams_distribute_simd, + llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_simd, + llvm::omp::requiredClauses_OMPD_teams_distribute_simd, + } + }, + {llvm::omp::Directive::OMPD_threadprivate, + { + llvm::omp::allowedClauses_OMPD_threadprivate, + llvm::omp::allowedOnceClauses_OMPD_threadprivate, + llvm::omp::allowedExclusiveClauses_OMPD_threadprivate, + llvm::omp::requiredClauses_OMPD_threadprivate, + } + }, + {llvm::omp::Directive::OMPD_unknown, + { + llvm::omp::allowedClauses_OMPD_unknown, + llvm::omp::allowedOnceClauses_OMPD_unknown, + llvm::omp::allowedExclusiveClauses_OMPD_unknown, + llvm::omp::requiredClauses_OMPD_unknown, + } + }, + {llvm::omp::Directive::OMPD_workshare, + { + llvm::omp::allowedClauses_OMPD_workshare, + llvm::omp::allowedOnceClauses_OMPD_workshare, + llvm::omp::allowedExclusiveClauses_OMPD_workshare, + llvm::omp::requiredClauses_OMPD_workshare, + } + }, +} + +#endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP + +#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES +#undef GEN_FLANG_CLAUSE_PARSER_CLASSES + +EMPTY_CLASS(AcqRel); +EMPTY_CLASS(Acquire); +EMPTY_CLASS(Affinity); +WRAPPER_CLASS(Aligned, OmpAlignedClause); +WRAPPER_CLASS(Allocate, OmpAllocateClause); +WRAPPER_CLASS(Allocator, ScalarIntExpr); +EMPTY_CLASS(AtomicDefaultMemOrder); +EMPTY_CLASS(Capture); +WRAPPER_CLASS(Collapse, ScalarIntConstantExpr); +WRAPPER_CLASS(Copyprivate, OmpObjectList); +WRAPPER_CLASS(Copyin, OmpObjectList); +WRAPPER_CLASS(Default, OmpDefaultClause); +WRAPPER_CLASS(Defaultmap, OmpDefaultmapClause); +WRAPPER_CLASS(Depend, OmpDependClause); +EMPTY_CLASS(Depobj); +EMPTY_CLASS(Destroy); +EMPTY_CLASS(Detach); +WRAPPER_CLASS(Device, ScalarIntExpr); +EMPTY_CLASS(DeviceType); +WRAPPER_CLASS(DistSchedule, std::optional<ScalarIntExpr>); +EMPTY_CLASS(DynamicAllocators); +EMPTY_CLASS(Exclusive); +WRAPPER_CLASS(Final, ScalarLogicalExpr); +WRAPPER_CLASS(Firstprivate, OmpObjectList); +EMPTY_CLASS(Flush); +WRAPPER_CLASS(From, OmpObjectList); +WRAPPER_CLASS(Grainsize, ScalarIntExpr); +WRAPPER_CLASS(Hint, ConstantExpr); +WRAPPER_CLASS(If, OmpIfClause); +EMPTY_CLASS(InReduction); +EMPTY_CLASS(Inbranch); +EMPTY_CLASS(Inclusive); +WRAPPER_CLASS(IsDevicePtr, std::list<Name>); +WRAPPER_CLASS(Lastprivate, OmpObjectList); +WRAPPER_CLASS(Linear, OmpLinearClause); +WRAPPER_CLASS(Link, OmpObjectList); +WRAPPER_CLASS(Map, OmpMapClause); +EMPTY_CLASS(Match); +EMPTY_CLASS(Mergeable); +EMPTY_CLASS(Nogroup); +EMPTY_CLASS(Nowait); +EMPTY_CLASS(Nontemporal); +EMPTY_CLASS(Notinbranch); +WRAPPER_CLASS(NumTasks, ScalarIntExpr); +WRAPPER_CLASS(NumTeams, ScalarIntExpr); +WRAPPER_CLASS(NumThreads, ScalarIntExpr); +EMPTY_CLASS(Order); +WRAPPER_CLASS(Ordered, std::optional<ScalarIntConstantExpr>); +WRAPPER_CLASS(Priority, ScalarIntExpr); +WRAPPER_CLASS(Private, OmpObjectList); +WRAPPER_CLASS(ProcBind, OmpProcBindClause); +EMPTY_CLASS(Read); +WRAPPER_CLASS(Reduction, OmpReductionClause); +EMPTY_CLASS(Relaxed); +EMPTY_CLASS(Release); +EMPTY_CLASS(ReverseOffload); +WRAPPER_CLASS(Safelen, ScalarIntConstantExpr); +WRAPPER_CLASS(Schedule, OmpScheduleClause); +EMPTY_CLASS(SeqCst); +WRAPPER_CLASS(Shared, OmpObjectList); +EMPTY_CLASS(Simd); +WRAPPER_CLASS(Simdlen, ScalarIntConstantExpr); +WRAPPER_CLASS(TaskReduction, OmpReductionClause); +WRAPPER_CLASS(ThreadLimit, ScalarIntExpr); +EMPTY_CLASS(Threadprivate); +EMPTY_CLASS(Threads); +WRAPPER_CLASS(To, OmpObjectList); +EMPTY_CLASS(UnifiedAddress); +EMPTY_CLASS(UnifiedSharedMemory); +WRAPPER_CLASS(Uniform, std::list<Name>); +EMPTY_CLASS(Unknown); +EMPTY_CLASS(Untied); +EMPTY_CLASS(Update); +EMPTY_CLASS(UseDeviceAddr); +WRAPPER_CLASS(UseDevicePtr, std::list<Name>); +EMPTY_CLASS(UsesAllocators); +EMPTY_CLASS(Write); + +#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES + +#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST +#undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST + +AcqRel +, Acquire +, Affinity +, Aligned +, Allocate +, Allocator +, AtomicDefaultMemOrder +, Capture +, Collapse +, Copyprivate +, Copyin +, Default +, Defaultmap +, Depend +, Depobj +, Destroy +, Detach +, Device +, DeviceType +, DistSchedule +, DynamicAllocators +, Exclusive +, Final +, Firstprivate +, Flush +, From +, Grainsize +, Hint +, If +, InReduction +, Inbranch +, Inclusive +, IsDevicePtr +, Lastprivate +, Linear +, Link +, Map +, Match +, Mergeable +, Nogroup +, Nowait +, Nontemporal +, Notinbranch +, NumTasks +, NumTeams +, NumThreads +, Order +, Ordered +, Priority +, Private +, ProcBind +, Read +, Reduction +, Relaxed +, Release +, ReverseOffload +, Safelen +, Schedule +, SeqCst +, Shared +, Simd +, Simdlen +, TaskReduction +, ThreadLimit +, Threadprivate +, Threads +, To +, UnifiedAddress +, UnifiedSharedMemory +, Uniform +, Unknown +, Untied +, Update +, UseDeviceAddr +, UseDevicePtr +, UsesAllocators +, Write + +#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST + +#ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES +#undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES + +NODE(OmpClause, AcqRel) +NODE(OmpClause, Acquire) +NODE(OmpClause, Affinity) +NODE(OmpClause, Aligned) +NODE(OmpClause, Allocate) +NODE(OmpClause, Allocator) +NODE(OmpClause, AtomicDefaultMemOrder) +NODE(OmpClause, Capture) +NODE(OmpClause, Collapse) +NODE(OmpClause, Copyprivate) +NODE(OmpClause, Copyin) +NODE(OmpClause, Default) +NODE(OmpClause, Defaultmap) +NODE(OmpClause, Depend) +NODE(OmpClause, Depobj) +NODE(OmpClause, Destroy) +NODE(OmpClause, Detach) +NODE(OmpClause, Device) +NODE(OmpClause, DeviceType) +NODE(OmpClause, DistSchedule) +NODE(OmpClause, DynamicAllocators) +NODE(OmpClause, Exclusive) +NODE(OmpClause, Final) +NODE(OmpClause, Firstprivate) +NODE(OmpClause, Flush) +NODE(OmpClause, From) +NODE(OmpClause, Grainsize) +NODE(OmpClause, Hint) +NODE(OmpClause, If) +NODE(OmpClause, InReduction) +NODE(OmpClause, Inbranch) +NODE(OmpClause, Inclusive) +NODE(OmpClause, IsDevicePtr) +NODE(OmpClause, Lastprivate) +NODE(OmpClause, Linear) +NODE(OmpClause, Link) +NODE(OmpClause, Map) +NODE(OmpClause, Match) +NODE(OmpClause, Mergeable) +NODE(OmpClause, Nogroup) +NODE(OmpClause, Nowait) +NODE(OmpClause, Nontemporal) +NODE(OmpClause, Notinbranch) +NODE(OmpClause, NumTasks) +NODE(OmpClause, NumTeams) +NODE(OmpClause, NumThreads) +NODE(OmpClause, Order) +NODE(OmpClause, Ordered) +NODE(OmpClause, Priority) +NODE(OmpClause, Private) +NODE(OmpClause, ProcBind) +NODE(OmpClause, Read) +NODE(OmpClause, Reduction) +NODE(OmpClause, Relaxed) +NODE(OmpClause, Release) +NODE(OmpClause, ReverseOffload) +NODE(OmpClause, Safelen) +NODE(OmpClause, Schedule) +NODE(OmpClause, SeqCst) +NODE(OmpClause, Shared) +NODE(OmpClause, Simd) +NODE(OmpClause, Simdlen) +NODE(OmpClause, TaskReduction) +NODE(OmpClause, ThreadLimit) +NODE(OmpClause, Threadprivate) +NODE(OmpClause, Threads) +NODE(OmpClause, To) +NODE(OmpClause, UnifiedAddress) +NODE(OmpClause, UnifiedSharedMemory) +NODE(OmpClause, Uniform) +NODE(OmpClause, Unknown) +NODE(OmpClause, Untied) +NODE(OmpClause, Update) +NODE(OmpClause, UseDeviceAddr) +NODE(OmpClause, UseDevicePtr) +NODE(OmpClause, UsesAllocators) +NODE(OmpClause, Write) + +#endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES + +#ifdef GEN_FLANG_CLAUSE_UNPARSE +#undef GEN_FLANG_CLAUSE_UNPARSE + +void Before(const OmpClause::AcqRel &) { Word("ACQ_REL"); } +void Before(const OmpClause::Acquire &) { Word("ACQUIRE"); } +void Before(const OmpClause::Affinity &) { Word("AFFINITY"); } +void Unparse(const OmpClause::Aligned &x) { + Word("ALIGNED"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Allocate &x) { + Word("ALLOCATE"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Allocator &x) { + Word("ALLOCATOR"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::AtomicDefaultMemOrder &) { Word("ATOMIC_DEFAULT_MEM_ORDER"); } +void Before(const OmpClause::Capture &) { Word("CAPTURE"); } +void Unparse(const OmpClause::Collapse &x) { + Word("COLLAPSE"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Copyprivate &x) { + Word("COPYPRIVATE"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Copyin &x) { + Word("COPYIN"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Default &x) { + Word("DEFAULT"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Defaultmap &x) { + Word("DEFAULTMAP"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Depend &x) { + Word("DEPEND"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::Depobj &) { Word("DEPOBJ"); } +void Before(const OmpClause::Destroy &) { Word("DESTROY"); } +void Before(const OmpClause::Detach &) { Word("DETACH"); } +void Unparse(const OmpClause::Device &x) { + Word("DEVICE"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::DeviceType &) { Word("DEVICE_TYPE"); } +void Unparse(const OmpClause::DistSchedule &x) { + Word("DIST_SCHEDULE"); + Walk("(", x.v, ")"); +} +void Before(const OmpClause::DynamicAllocators &) { Word("DYNAMIC_ALLOCATORS"); } +void Before(const OmpClause::Exclusive &) { Word("EXCLUSIVE"); } +void Unparse(const OmpClause::Final &x) { + Word("FINAL"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Firstprivate &x) { + Word("FIRSTPRIVATE"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::Flush &) { Word("FLUSH"); } +void Unparse(const OmpClause::From &x) { + Word("FROM"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Grainsize &x) { + Word("GRAINSIZE"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Hint &x) { + Word("HINT"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::If &x) { + Word("IF"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::InReduction &) { Word("IN_REDUCTION"); } +void Before(const OmpClause::Inbranch &) { Word("INBRANCH"); } +void Before(const OmpClause::Inclusive &) { Word("INCLUSIVE"); } +void Unparse(const OmpClause::IsDevicePtr &x) { + Word("IS_DEVICE_PTR"); + Put("("); + Walk(x.v, ","); + Put(")"); +} +void Unparse(const OmpClause::Lastprivate &x) { + Word("LASTPRIVATE"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Linear &x) { + Word("LINEAR"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Link &x) { + Word("LINK"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Map &x) { + Word("MAP"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::Match &) { Word("MATCH"); } +void Before(const OmpClause::Mergeable &) { Word("MERGEABLE"); } +void Before(const OmpClause::Nogroup &) { Word("NOGROUP"); } +void Before(const OmpClause::Nowait &) { Word("NOWAIT"); } +void Before(const OmpClause::Nontemporal &) { Word("NONTEMPORAL"); } +void Before(const OmpClause::Notinbranch &) { Word("NOTINBRANCH"); } +void Unparse(const OmpClause::NumTasks &x) { + Word("NUM_TASKS"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::NumTeams &x) { + Word("NUM_TEAMS"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::NumThreads &x) { + Word("NUM_THREADS"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::Order &) { Word("ORDER"); } +void Unparse(const OmpClause::Ordered &x) { + Word("ORDERED"); + Walk("(", x.v, ")"); +} +void Unparse(const OmpClause::Priority &x) { + Word("PRIORITY"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Private &x) { + Word("PRIVATE"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::ProcBind &x) { + Word("PROC_BIND"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::Read &) { Word("READ"); } +void Unparse(const OmpClause::Reduction &x) { + Word("REDUCTION"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::Relaxed &) { Word("RELAXED"); } +void Before(const OmpClause::Release &) { Word("RELEASE"); } +void Before(const OmpClause::ReverseOffload &) { Word("REVERSE_OFFLOAD"); } +void Unparse(const OmpClause::Safelen &x) { + Word("SAFELEN"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::Schedule &x) { + Word("SCHEDULE"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::SeqCst &) { Word("SEQ_CST"); } +void Unparse(const OmpClause::Shared &x) { + Word("SHARED"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::Simd &) { Word("SIMD"); } +void Unparse(const OmpClause::Simdlen &x) { + Word("SIMDLEN"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::TaskReduction &x) { + Word("TASK_REDUCTION"); + Put("("); + Walk(x.v); + Put(")"); +} +void Unparse(const OmpClause::ThreadLimit &x) { + Word("THREAD_LIMIT"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::Threadprivate &) { Word("THREADPRIVATE"); } +void Before(const OmpClause::Threads &) { Word("THREADS"); } +void Unparse(const OmpClause::To &x) { + Word("TO"); + Put("("); + Walk(x.v); + Put(")"); +} +void Before(const OmpClause::UnifiedAddress &) { Word("UNIFIED_ADDRESS"); } +void Before(const OmpClause::UnifiedSharedMemory &) { Word("UNIFIED_SHARED_MEMORY"); } +void Unparse(const OmpClause::Uniform &x) { + Word("UNIFORM"); + Put("("); + Walk(x.v, ","); + Put(")"); +} +void Before(const OmpClause::Unknown &) { Word("UNKNOWN"); } +void Before(const OmpClause::Untied &) { Word("UNTIED"); } +void Before(const OmpClause::Update &) { Word("UPDATE"); } +void Before(const OmpClause::UseDeviceAddr &) { Word("USE_DEVICE_ADDR"); } +void Unparse(const OmpClause::UseDevicePtr &x) { + Word("USE_DEVICE_PTR"); + Put("("); + Walk(x.v, ","); + Put(")"); +} +void Before(const OmpClause::UsesAllocators &) { Word("USES_ALLOCATORS"); } +void Before(const OmpClause::Write &) { Word("WRITE"); } + +#endif // GEN_FLANG_CLAUSE_UNPARSE + +#ifdef GEN_CLANG_CLAUSE_CLASS +#undef GEN_CLANG_CLAUSE_CLASS + +#ifndef CLAUSE +#define CLAUSE(Enum, Str, Implicit) +#endif +#ifndef CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) +#endif +#ifndef CLAUSE_NO_CLASS +#define CLAUSE_NO_CLASS(Enum, Str) +#endif + +#define __CLAUSE(Name, Class) \ + CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \ + CLAUSE_CLASS(OMPC_##Name, #Name, Class) +#define __CLAUSE_NO_CLASS(Name) \ + CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \ + CLAUSE_NO_CLASS(OMPC_##Name, #Name) +#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class) \ + CLAUSE(OMPC_##Name, Str, /* Implicit */ true) \ + CLAUSE_CLASS(OMPC_##Name, Str, Class) +#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str) \ + CLAUSE(OMPC_##Name, Str, /* Implicit */ true) \ + CLAUSE_NO_CLASS(OMPC_##Name, Str) + +__CLAUSE(acq_rel, OMPAcqRelClause) +__CLAUSE(acquire, OMPAcquireClause) +__CLAUSE(affinity, OMPAffinityClause) +__CLAUSE(aligned, OMPAlignedClause) +__CLAUSE(allocate, OMPAllocateClause) +__CLAUSE(allocator, OMPAllocatorClause) +__CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause) +__CLAUSE(capture, OMPCaptureClause) +__CLAUSE(collapse, OMPCollapseClause) +__CLAUSE(copyprivate, OMPCopyprivateClause) +__CLAUSE(copyin, OMPCopyinClause) +__CLAUSE(default, OMPDefaultClause) +__CLAUSE(defaultmap, OMPDefaultmapClause) +__CLAUSE(depend, OMPDependClause) +__IMPLICIT_CLAUSE_CLASS(depobj, "depobj", OMPDepobjClause) +__CLAUSE(destroy, OMPDestroyClause) +__CLAUSE(detach, OMPDetachClause) +__CLAUSE(device, OMPDeviceClause) +__CLAUSE_NO_CLASS(device_type) +__CLAUSE(dist_schedule, OMPDistScheduleClause) +__CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause) +__CLAUSE(exclusive, OMPExclusiveClause) +__CLAUSE(final, OMPFinalClause) +__CLAUSE(firstprivate, OMPFirstprivateClause) +__IMPLICIT_CLAUSE_CLASS(flush, "flush", OMPFlushClause) +__CLAUSE(from, OMPFromClause) +__CLAUSE(grainsize, OMPGrainsizeClause) +__CLAUSE(hint, OMPHintClause) +__CLAUSE(if, OMPIfClause) +__CLAUSE(in_reduction, OMPInReductionClause) +__CLAUSE_NO_CLASS(inbranch) +__CLAUSE(inclusive, OMPInclusiveClause) +__CLAUSE(is_device_ptr, OMPIsDevicePtrClause) +__CLAUSE(lastprivate, OMPLastprivateClause) +__CLAUSE(linear, OMPLinearClause) +__CLAUSE_NO_CLASS(link) +__CLAUSE(map, OMPMapClause) +__CLAUSE_NO_CLASS(match) +__CLAUSE(mergeable, OMPMergeableClause) +__CLAUSE(nogroup, OMPNogroupClause) +__CLAUSE(nowait, OMPNowaitClause) +__CLAUSE(nontemporal, OMPNontemporalClause) +__CLAUSE_NO_CLASS(notinbranch) +__CLAUSE(num_tasks, OMPNumTasksClause) +__CLAUSE(num_teams, OMPNumTeamsClause) +__CLAUSE(num_threads, OMPNumThreadsClause) +__CLAUSE(order, OMPOrderClause) +__CLAUSE(ordered, OMPOrderedClause) +__CLAUSE(priority, OMPPriorityClause) +__CLAUSE(private, OMPPrivateClause) +__CLAUSE(proc_bind, OMPProcBindClause) +__CLAUSE(read, OMPReadClause) +__CLAUSE(reduction, OMPReductionClause) +__CLAUSE(relaxed, OMPRelaxedClause) +__CLAUSE(release, OMPReleaseClause) +__CLAUSE(reverse_offload, OMPReverseOffloadClause) +__CLAUSE(safelen, OMPSafelenClause) +__CLAUSE(schedule, OMPScheduleClause) +__CLAUSE(seq_cst, OMPSeqCstClause) +__CLAUSE(shared, OMPSharedClause) +__CLAUSE(simd, OMPSIMDClause) +__CLAUSE(simdlen, OMPSimdlenClause) +__CLAUSE(task_reduction, OMPTaskReductionClause) +__CLAUSE(thread_limit, OMPThreadLimitClause) +__IMPLICIT_CLAUSE_NO_CLASS(threadprivate, "threadprivate") +__CLAUSE(threads, OMPThreadsClause) +__CLAUSE(to, OMPToClause) +__CLAUSE(unified_address, OMPUnifiedAddressClause) +__CLAUSE(unified_shared_memory, OMPUnifiedSharedMemoryClause) +__CLAUSE_NO_CLASS(uniform) +__IMPLICIT_CLAUSE_NO_CLASS(unknown, "unknown") +__CLAUSE(untied, OMPUntiedClause) +__CLAUSE(update, OMPUpdateClause) +__CLAUSE(use_device_addr, OMPUseDeviceAddrClause) +__CLAUSE(use_device_ptr, OMPUseDevicePtrClause) +__CLAUSE(uses_allocators, OMPUsesAllocatorsClause) +__CLAUSE(write, OMPWriteClause) + +#undef __IMPLICIT_CLAUSE_NO_CLASS +#undef __IMPLICIT_CLAUSE_CLASS +#undef __CLAUSE +#undef CLAUSE_NO_CLASS +#undef CLAUSE_CLASS +#undef CLAUSE + +#endif // GEN_CLANG_CLAUSE_CLASS + diff --git a/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMP.td b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMP.td new file mode 100644 index 0000000000..10fa5a37b8 --- /dev/null +++ b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMP.td @@ -0,0 +1,1639 @@ +//===-- OMP.td - OpenMP 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 OpenMP directives and clauses. +// +//===----------------------------------------------------------------------===// + +include "llvm/Frontend/Directive/DirectiveBase.td" + +//===----------------------------------------------------------------------===// +// Definition of general OpenMP information +//===----------------------------------------------------------------------===// + +def OpenMP : DirectiveLanguage { + let name = "OpenMP"; + let cppNamespace = "omp"; // final namespace will be llvm::omp + let directivePrefix = "OMPD_"; + let clausePrefix = "OMPC_"; + let makeEnumAvailableInNamespace = true; + let enableBitmaskEnumInNamespace = true; + let includeHeader = "llvm/Frontend/OpenMP/OMP.h.inc"; + let clauseEnumSetClass = "OmpClauseSet"; + let flangClauseBaseClass = "OmpClause"; +} + +//===----------------------------------------------------------------------===// +// Definition of OpenMP clauses +//===----------------------------------------------------------------------===// + +def OMPC_Allocator : Clause<"allocator"> { + let clangClass = "OMPAllocatorClause"; + let flangClass = "ScalarIntExpr"; +} +def OMPC_If : Clause<"if"> { + let clangClass = "OMPIfClause"; + let flangClass = "OmpIfClause"; +} +def OMPC_Final : Clause<"final"> { + let clangClass = "OMPFinalClause"; + let flangClass = "ScalarLogicalExpr"; +} +def OMPC_NumThreads : Clause<"num_threads"> { + let clangClass = "OMPNumThreadsClause"; + let flangClass = "ScalarIntExpr"; +} +def OMPC_SafeLen : Clause<"safelen"> { + let clangClass = "OMPSafelenClause"; + let flangClass = "ScalarIntConstantExpr"; +} +def OMPC_SimdLen : Clause<"simdlen"> { + let clangClass = "OMPSimdlenClause"; + let flangClass = "ScalarIntConstantExpr"; +} +def OMPC_Collapse : Clause<"collapse"> { + let clangClass = "OMPCollapseClause"; + let flangClass = "ScalarIntConstantExpr"; +} +def OMPC_Default : Clause<"default"> { + let clangClass = "OMPDefaultClause"; + let flangClass = "OmpDefaultClause"; +} +def OMPC_Private : Clause<"private"> { + let clangClass = "OMPPrivateClause"; + let flangClass = "OmpObjectList"; +} +def OMPC_FirstPrivate : Clause<"firstprivate"> { + let clangClass = "OMPFirstprivateClause"; + let flangClass = "OmpObjectList"; +} +def OMPC_LastPrivate : Clause<"lastprivate"> { + let clangClass = "OMPLastprivateClause"; + let flangClass = "OmpObjectList"; +} +def OMPC_Shared : Clause<"shared"> { + let clangClass = "OMPSharedClause"; + let flangClass = "OmpObjectList"; +} +def OMPC_Reduction : Clause<"reduction"> { + let clangClass = "OMPReductionClause"; + let flangClass = "OmpReductionClause"; +} +def OMPC_Linear : Clause<"linear"> { + let clangClass = "OMPLinearClause"; + let flangClass = "OmpLinearClause"; +} +def OMPC_Aligned : Clause<"aligned"> { + let clangClass = "OMPAlignedClause"; + let flangClass = "OmpAlignedClause"; +} +def OMPC_Copyin : Clause<"copyin"> { + let clangClass = "OMPCopyinClause"; + let flangClass = "OmpObjectList"; +} +def OMPC_CopyPrivate : Clause<"copyprivate"> { + let clangClass = "OMPCopyprivateClause"; + let flangClass = "OmpObjectList"; +} +def OMP_PROC_BIND_master : ClauseVal<"master",2,1> {} +def OMP_PROC_BIND_close : ClauseVal<"close",3,1> {} +def OMP_PROC_BIND_spread : ClauseVal<"spread",4,1> {} +def OMP_PROC_BIND_default : ClauseVal<"default",5,0> {} +def OMP_PROC_BIND_unknown : ClauseVal<"unknown",6,0> { let isDefault = true; } +def OMPC_ProcBind : Clause<"proc_bind"> { + let clangClass = "OMPProcBindClause"; + let flangClass = "OmpProcBindClause"; + let enumClauseValue = "ProcBindKind"; + let allowedClauseValues = [ + OMP_PROC_BIND_master, + OMP_PROC_BIND_close, + OMP_PROC_BIND_spread, + OMP_PROC_BIND_default, + OMP_PROC_BIND_unknown + ]; +} + +// static and auto are C++ keywords so need a capital to disambiguate. +def OMP_SCHEDULE_Static : ClauseVal<"Static", 2, 1> {} +def OMP_SCHEDULE_Dynamic : ClauseVal<"Dynamic", 3, 1> {} +def OMP_SCHEDULE_Guided : ClauseVal<"Guided", 4, 1> {} +def OMP_SCHEDULE_Auto : ClauseVal<"Auto", 5, 1> {} +def OMP_SCHEDULE_Runtime : ClauseVal<"Runtime", 6, 1> {} +def OMP_SCHEDULE_Default : ClauseVal<"Default", 7, 0> { let isDefault = 1; } + +def OMPC_Schedule : Clause<"schedule"> { + let clangClass = "OMPScheduleClause"; + let flangClass = "OmpScheduleClause"; + let enumClauseValue = "ScheduleKind"; + let allowedClauseValues = [ + OMP_SCHEDULE_Static, + OMP_SCHEDULE_Dynamic, + OMP_SCHEDULE_Guided, + OMP_SCHEDULE_Auto, + OMP_SCHEDULE_Runtime, + OMP_SCHEDULE_Default + ]; +} + +def OMPC_Ordered : Clause<"ordered"> { + let clangClass = "OMPOrderedClause"; + let flangClass = "ScalarIntConstantExpr"; + let isValueOptional = true; +} +def OMPC_NoWait : Clause<"nowait"> { + let clangClass = "OMPNowaitClause"; +} +def OMPC_Untied : Clause<"untied"> { let clangClass = "OMPUntiedClause"; } +def OMPC_Mergeable : Clause<"mergeable"> { + let clangClass = "OMPMergeableClause"; +} +def OMPC_Read : Clause<"read"> { let clangClass = "OMPReadClause"; } +def OMPC_Write : Clause<"write"> { let clangClass = "OMPWriteClause"; } +def OMPC_Update : Clause<"update"> { let clangClass = "OMPUpdateClause"; } +def OMPC_Capture : Clause<"capture"> { let clangClass = "OMPCaptureClause"; } +def OMPC_SeqCst : Clause<"seq_cst"> { let clangClass = "OMPSeqCstClause"; } +def OMPC_AcqRel : Clause<"acq_rel"> { let clangClass = "OMPAcqRelClause"; } +def OMPC_Acquire : Clause<"acquire"> { let clangClass = "OMPAcquireClause"; } +def OMPC_Release : Clause<"release"> { let clangClass = "OMPReleaseClause"; } +def OMPC_Relaxed : Clause<"relaxed"> { let clangClass = "OMPRelaxedClause"; } +def OMPC_Depend : Clause<"depend"> { + let clangClass = "OMPDependClause"; + let flangClass = "OmpDependClause"; +} +def OMPC_Device : Clause<"device"> { + let clangClass = "OMPDeviceClause"; + let flangClass = "ScalarIntExpr"; +} +def OMPC_Threads : Clause<"threads"> { let clangClass = "OMPThreadsClause"; } +def OMPC_Simd : Clause<"simd"> { let clangClass = "OMPSIMDClause"; } +def OMPC_Map : Clause<"map"> { + let clangClass = "OMPMapClause"; + let flangClass = "OmpMapClause"; +} +def OMPC_NumTeams : Clause<"num_teams"> { + let clangClass = "OMPNumTeamsClause"; + let flangClass = "ScalarIntExpr"; +} +def OMPC_ThreadLimit : Clause<"thread_limit"> { + let clangClass = "OMPThreadLimitClause"; + let flangClass = "ScalarIntExpr"; +} +def OMPC_Priority : Clause<"priority"> { + let clangClass = "OMPPriorityClause"; + let flangClass = "ScalarIntExpr"; +} +def OMPC_GrainSize : Clause<"grainsize"> { + let clangClass = "OMPGrainsizeClause"; + let flangClass = "ScalarIntExpr"; +} +def OMPC_NoGroup : Clause<"nogroup"> { + let clangClass = "OMPNogroupClause"; +} +def OMPC_NumTasks : Clause<"num_tasks"> { + let clangClass = "OMPNumTasksClause"; + let flangClass = "ScalarIntExpr"; +} +def OMPC_Hint : Clause<"hint"> { + let clangClass = "OMPHintClause"; + let flangClass = "ConstantExpr"; +} +def OMPC_DistSchedule : Clause<"dist_schedule"> { + let clangClass = "OMPDistScheduleClause"; + let flangClass = "ScalarIntExpr"; + let isValueOptional = true; +} +def OMPC_DefaultMap : Clause<"defaultmap"> { + let clangClass = "OMPDefaultmapClause"; + let flangClass = "OmpDefaultmapClause"; +} +def OMPC_To : Clause<"to"> { + let clangClass = "OMPToClause"; + let flangClass = "OmpObjectList"; +} +def OMPC_From : Clause<"from"> { + let clangClass = "OMPFromClause"; + let flangClass = "OmpObjectList"; +} +def OMPC_UseDevicePtr : Clause<"use_device_ptr"> { + let clangClass = "OMPUseDevicePtrClause"; + let flangClass = "Name"; + let isValueList = true; +} +def OMPC_IsDevicePtr : Clause<"is_device_ptr"> { + let clangClass = "OMPIsDevicePtrClause"; + let flangClass = "Name"; + let isValueList = true; +} +def OMPC_TaskReduction : Clause<"task_reduction"> { + let clangClass = "OMPTaskReductionClause"; + let flangClass = "OmpReductionClause"; +} +def OMPC_InReduction : Clause<"in_reduction"> { + let clangClass = "OMPInReductionClause"; +} +def OMPC_UnifiedAddress : Clause<"unified_address"> { + let clangClass = "OMPUnifiedAddressClause"; +} +def OMPC_UnifiedSharedMemory : Clause<"unified_shared_memory"> { + let clangClass = "OMPUnifiedSharedMemoryClause"; +} +def OMPC_ReverseOffload : Clause<"reverse_offload"> { + let clangClass = "OMPReverseOffloadClause"; +} +def OMPC_DynamicAllocators : Clause<"dynamic_allocators"> { + let clangClass = "OMPDynamicAllocatorsClause"; +} +def OMPC_AtomicDefaultMemOrder : Clause<"atomic_default_mem_order"> { + let clangClass = "OMPAtomicDefaultMemOrderClause"; +} +def OMPC_Allocate : Clause<"allocate"> { + let clangClass = "OMPAllocateClause"; + let flangClass = "OmpAllocateClause"; +} +def OMPC_NonTemporal : Clause<"nontemporal"> { + let clangClass = "OMPNontemporalClause"; +} + +def OMP_ORDER_concurrent : ClauseVal<"default",2,0> { let isDefault = 1; } +def OMPC_Order : Clause<"order"> { + let clangClass = "OMPOrderClause"; + let enumClauseValue = "OrderKind"; + let allowedClauseValues = [ + OMP_ORDER_concurrent + ]; +} +def OMPC_Destroy : Clause<"destroy"> { + let clangClass = "OMPDestroyClause"; +} +def OMPC_Detach : Clause<"detach"> { + let clangClass = "OMPDetachClause"; +} +def OMPC_Inclusive : Clause<"inclusive"> { + let clangClass = "OMPInclusiveClause"; +} +def OMPC_Exclusive : Clause<"exclusive"> { + let clangClass = "OMPExclusiveClause"; +} +def OMPC_UsesAllocators : Clause<"uses_allocators"> { + let clangClass = "OMPUsesAllocatorsClause"; +} +def OMPC_Affinity : Clause<"affinity"> { + let clangClass = "OMPAffinityClause"; +} +def OMPC_UseDeviceAddr : Clause<"use_device_addr"> { + let clangClass = "OMPUseDeviceAddrClause"; +} +def OMPC_Uniform : Clause<"uniform"> { + let flangClass = "Name"; + let isValueList = true; +} +def OMPC_DeviceType : Clause<"device_type"> {} +def OMPC_Match : Clause<"match"> {} +def OMPC_Depobj : Clause<"depobj"> { + let clangClass = "OMPDepobjClause"; + let isImplicit = true; +} +def OMPC_Flush : Clause<"flush"> { + let clangClass = "OMPFlushClause"; + let isImplicit = true; +} +def OMPC_ThreadPrivate : Clause<"threadprivate"> { + let alternativeName = "threadprivate or thread local"; + let isImplicit = true; +} +def OMPC_Unknown : Clause<"unknown"> { + let isImplicit = true; + let isDefault = true; +} +def OMPC_Link : Clause<"link"> { + let flangClass = "OmpObjectList"; +} +def OMPC_Inbranch : Clause<"inbranch"> {} +def OMPC_Notinbranch : Clause<"notinbranch"> {} + +//===----------------------------------------------------------------------===// +// Definition of OpenMP directives +//===----------------------------------------------------------------------===// + +def OMP_ThreadPrivate : Directive<"threadprivate"> {} +def OMP_Parallel : Directive<"parallel"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Allocate> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + ]; +} +def OMP_Task : Directive<"task"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Untied>, + VersionedClause<OMPC_Mergeable>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_InReduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Detach, 50>, + VersionedClause<OMPC_Affinity, 50> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Final>, + VersionedClause<OMPC_Priority> + ]; +} +def OMP_Simd : Directive<"simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_If, 50>, + ]; +} +def OMP_For : Directive<"for"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Order, 50> + ]; +} +def OMP_Do : Directive<"do"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Reduction> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_NoWait> + ]; +} +def OMP_Sections : Directive<"sections"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Allocate> + ]; +} +def OMP_Section : Directive<"section"> {} +def OMP_Single : Directive<"single"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_CopyPrivate>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Allocate> + ]; +} +def OMP_Master : Directive<"master"> {} +def OMP_Critical : Directive<"critical"> { + let allowedClauses = [ + VersionedClause<OMPC_Hint> + ]; +} +def OMP_TaskYield : Directive<"taskyield"> {} +def OMP_Barrier : Directive<"barrier"> {} +def OMP_TaskWait : Directive<"taskwait"> { + let allowedClauses = [ + VersionedClause<OMPC_Depend, 50> + ]; +} +def OMP_TaskGroup : Directive<"taskgroup"> { + let allowedClauses = [ + VersionedClause<OMPC_TaskReduction>, + VersionedClause<OMPC_Allocate> + ]; +} +def OMP_Flush : Directive<"flush"> { + let allowedOnceClauses = [ + VersionedClause<OMPC_AcqRel, 50>, + VersionedClause<OMPC_Acquire, 50>, + VersionedClause<OMPC_Release, 50>, + // TODO This should ne `none` instead. Comment carried over from + // OMPKinds.def. + VersionedClause<OMPC_Flush> + ]; +} +def OMP_Ordered : Directive<"ordered"> { + let allowedClauses = [ + VersionedClause<OMPC_Threads>, + VersionedClause<OMPC_Simd>, + VersionedClause<OMPC_Depend> + ]; +} +def OMP_Atomic : Directive<"atomic"> { + let allowedClauses = [ + VersionedClause<OMPC_Read>, + VersionedClause<OMPC_Write>, + VersionedClause<OMPC_Update>, + VersionedClause<OMPC_Capture>, + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_SeqCst>, + VersionedClause<OMPC_AcqRel, 50>, + VersionedClause<OMPC_Acquire, 50>, + VersionedClause<OMPC_Release, 50>, + VersionedClause<OMPC_Relaxed, 50>, + VersionedClause<OMPC_Hint, 50> + ]; +} +def OMP_Target : Directive<"target"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_UsesAllocators, 50> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_NoWait> + ]; +} +def OMP_Teams : Directive<"teams"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit> + ]; +} +def OMP_Cancel : Directive<"cancel"> { + let allowedClauses = [ + VersionedClause<OMPC_If> + ]; +} +def OMP_Requires : Directive<"requires"> { + let allowedClauses = [ + VersionedClause<OMPC_UnifiedAddress>, + VersionedClause<OMPC_UnifiedSharedMemory>, + VersionedClause<OMPC_ReverseOffload>, + VersionedClause<OMPC_DynamicAllocators>, + VersionedClause<OMPC_AtomicDefaultMemOrder> + ]; +} +def OMP_TargetData : Directive<"target data"> { + let allowedClauses = [ + VersionedClause<OMPC_UseDevicePtr>, + VersionedClause<OMPC_UseDeviceAddr, 50> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_If> + ]; + let requiredClauses = [ + VersionedClause<OMPC_Map> + ]; +} +def OMP_TargetEnterData : Directive<"target enter data"> { + let allowedClauses = [ + VersionedClause<OMPC_Depend> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_NoWait> + ]; + let requiredClauses = [ + VersionedClause<OMPC_Map> + ]; +} +def OMP_TargetExitData : Directive<"target exit data"> { + let allowedClauses = [ + VersionedClause<OMPC_Depend> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NoWait> + ]; + let requiredClauses = [ + VersionedClause<OMPC_Map> + ]; +} +def OMP_TargetParallel : Directive<"target parallel"> { + let allowedClauses = [ + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_UsesAllocators, 50> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind> + ]; +} +def OMP_TargetParallelFor : Directive<"target parallel for"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Order, 50>, + VersionedClause<OMPC_UsesAllocators, 50> + ]; +} +def OMP_TargetParallelDo : Directive<"target parallel do"> { + let allowedClauses = [ + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Allocator>, + VersionedClause<OMPC_Order>, + VersionedClause<OMPC_UsesAllocators>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Copyin> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_NoWait> + ]; +} +def OMP_TargetUpdate : Directive<"target update"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_To>, + VersionedClause<OMPC_From>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Depend> + ]; +} +def OMP_ParallelFor : Directive<"parallel for"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Order, 50> + ]; +} +def OMP_ParallelDo : Directive<"parallel do"> { + let allowedClauses = [ + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Linear> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Collapse> + ]; +} +def OMP_ParallelForSimd : Directive<"parallel for simd"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50> + ]; +} +def OMP_ParallelDoSimd : Directive<"parallel do simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal>, + VersionedClause<OMPC_Order> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen> + ]; +} +def OMP_ParallelMaster : Directive<"parallel master"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Allocate> + ]; +} +def OMP_ParallelSections : Directive<"parallel sections"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Allocate> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_NumThreads> + ]; +} +def OMP_ForSimd : Directive<"for simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_If, 50>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50>, + ]; +} +def OMP_DoSimd : Directive<"do simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Reduction> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_NoWait> + ]; +} +def OMP_CancellationPoint : Directive<"cancellation point"> {} +def OMP_DeclareReduction : Directive<"declare reduction"> {} +def OMP_DeclareMapper : Directive<"declare mapper"> { + let allowedClauses = [ + VersionedClause<OMPC_Map> + ]; +} +def OMP_DeclareSimd : Directive<"declare simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Uniform> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_SimdLen> + ]; + let allowedExclusiveClauses = [ + VersionedClause<OMPC_Inbranch>, + VersionedClause<OMPC_Notinbranch> + ]; +} +def OMP_TaskLoop : Directive<"taskloop"> { + let allowedClauses = [ + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Untied>, + VersionedClause<OMPC_Mergeable>, + VersionedClause<OMPC_NoGroup>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_InReduction>, + VersionedClause<OMPC_Allocate> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Final>, + VersionedClause<OMPC_Priority>, + ]; + let allowedExclusiveClauses = [ + VersionedClause<OMPC_GrainSize>, + VersionedClause<OMPC_NumTasks> + ]; +} +def OMP_TaskLoopSimd : Directive<"taskloop simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_InReduction>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Mergeable>, + VersionedClause<OMPC_NoGroup>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Untied> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_Final>, + VersionedClause<OMPC_Priority> + ]; + let allowedExclusiveClauses = [ + VersionedClause<OMPC_GrainSize>, + VersionedClause<OMPC_NumTasks> + ]; +} +def OMP_Distribute : Directive<"distribute"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Allocate> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule> + ]; +} +def OMP_DeclareTarget : Directive<"declare target"> { + let allowedClauses = [ + VersionedClause<OMPC_To>, + VersionedClause<OMPC_Link> + ]; +} +def OMP_EndDeclareTarget : Directive<"end declare target"> {} +def OMP_DistributeParallelFor : Directive<"distribute parallel for"> { + let allowedClauses = [ + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Order, 50> + ]; +} +def OMP_DistributeParallelDo : Directive<"distribute parallel do"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Order>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Linear> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Ordered> + ]; +} +def OMP_DistributeParallelForSimd : Directive<"distribute parallel for simd"> { + let allowedClauses = [ + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50> + ]; +} +def OMP_DistributeParallelDoSimd : Directive<"distribute parallel do simd"> { + let allowedClauses = [ + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal>, + VersionedClause<OMPC_Order> + ]; +} +def OMP_DistributeSimd : Directive<"distribute simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Reduction> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_If, 50>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen> + ]; +} + +def OMP_TargetParallelForSimd : Directive<"target parallel for simd"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50>, + VersionedClause<OMPC_UsesAllocators, 50> + ]; +} +def OMP_TargetParallelDoSimd : Directive<"target parallel do simd"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal>, + VersionedClause<OMPC_Order>, + VersionedClause<OMPC_UsesAllocators> + ]; +} +def OMP_TargetSimd : Directive<"target simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Order, 50>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_UsesAllocators, 50> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_Schedule> + ]; +} +def OMP_TeamsDistribute : Directive<"teams distribute"> { + let allowedClauses = [ + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_Allocate> + ]; +} +def OMP_TeamsDistributeSimd : Directive<"teams distribute simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Shared> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_If, 50>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_ThreadLimit> + ]; +} + +def OMP_TeamsDistributeParallelForSimd : + Directive<"teams distribute parallel for simd"> { + let allowedClauses = [ + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50> + ]; +} +def OMP_TeamsDistributeParallelDoSimd : + Directive<"teams distribute parallel do simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Order>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_NonTemporal> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_If>, + ]; +} +def OMP_TeamsDistributeParallelFor : + Directive<"teams distribute parallel for"> { + let allowedClauses = [ + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Order, 50> + ]; +} +def OMP_TeamsDistributeParallelDo : + Directive<"teams distribute parallel do"> { + let allowedClauses = [ + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Linear> + ]; +let allowedOnceClauses = [ + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Order>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule> + ]; +} +def OMP_TargetTeams : Directive<"target teams"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_UsesAllocators, 50>, + VersionedClause<OMPC_Shared> + ]; + + let allowedOnceClauses = [ + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit> + ]; +} +def OMP_TargetTeamsDistribute : Directive<"target teams distribute"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_UsesAllocators, 50>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_LastPrivate> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule> + ]; +} + +def OMP_TargetTeamsDistributeParallelFor : + Directive<"target teams distribute parallel for"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Order, 50>, + VersionedClause<OMPC_UsesAllocators, 50> + ]; +} +def OMP_TargetTeamsDistributeParallelDo : + Directive<"target teams distribute parallel do"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_UsesAllocators>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Order> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule>, + ]; +} +def OMP_TargetTeamsDistributeParallelForSimd : + Directive<"target teams distribute parallel for simd"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50>, + VersionedClause<OMPC_UsesAllocators, 50> + ]; +} +def OMP_TargetTeamsDistributeParallelDoSimd : + Directive<"target teams distribute parallel do simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_UsesAllocators>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Ordered>, + VersionedClause<OMPC_Order>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_NonTemporal> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Schedule>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen> + ]; +} +def OMP_TargetTeamsDistributeSimd : + Directive<"target teams distribute simd"> { + let allowedClauses = [ + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Depend>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_If>, + VersionedClause<OMPC_IsDevicePtr>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Map>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_UsesAllocators, 50> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_Device>, + VersionedClause<OMPC_DefaultMap>, + VersionedClause<OMPC_NoWait>, + VersionedClause<OMPC_NumTeams>, + VersionedClause<OMPC_ThreadLimit>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_DistSchedule>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + ]; +} +def OMP_Allocate : Directive<"allocate"> { + let allowedClauses = [ + VersionedClause<OMPC_Allocator> + ]; +} +def OMP_DeclareVariant : Directive<"declare variant"> { + let allowedClauses = [ + VersionedClause<OMPC_Match> + ]; +} +def OMP_MasterTaskloop : Directive<"master taskloop"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Final>, + VersionedClause<OMPC_Untied>, + VersionedClause<OMPC_Mergeable>, + VersionedClause<OMPC_Priority>, + VersionedClause<OMPC_GrainSize>, + VersionedClause<OMPC_NoGroup>, + VersionedClause<OMPC_NumTasks>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_InReduction>, + VersionedClause<OMPC_Allocate> + ]; +} +def OMP_ParallelMasterTaskloop : + Directive<"parallel master taskloop"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Final>, + VersionedClause<OMPC_Untied>, + VersionedClause<OMPC_Mergeable>, + VersionedClause<OMPC_Priority>, + VersionedClause<OMPC_GrainSize>, + VersionedClause<OMPC_NoGroup>, + VersionedClause<OMPC_NumTasks>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Copyin> + ]; +} +def OMP_MasterTaskloopSimd : Directive<"master taskloop simd"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Final>, + VersionedClause<OMPC_Untied>, + VersionedClause<OMPC_Mergeable>, + VersionedClause<OMPC_Priority>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_GrainSize>, + VersionedClause<OMPC_NoGroup>, + VersionedClause<OMPC_NumTasks>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_InReduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50> + ]; +} +def OMP_ParallelMasterTaskloopSimd : + Directive<"parallel master taskloop simd"> { + let allowedClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_Shared>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_LastPrivate>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_Collapse>, + VersionedClause<OMPC_Final>, + VersionedClause<OMPC_Untied>, + VersionedClause<OMPC_Mergeable>, + VersionedClause<OMPC_Priority>, + VersionedClause<OMPC_GrainSize>, + VersionedClause<OMPC_NoGroup>, + VersionedClause<OMPC_NumTasks>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Linear>, + VersionedClause<OMPC_Aligned>, + VersionedClause<OMPC_SafeLen>, + VersionedClause<OMPC_SimdLen>, + VersionedClause<OMPC_NonTemporal, 50>, + VersionedClause<OMPC_Order, 50> + ]; +} +def OMP_Depobj : Directive<"depobj"> { + let allowedClauses = [ + VersionedClause<OMPC_Depend, 50>, + VersionedClause<OMPC_Destroy, 50>, + VersionedClause<OMPC_Update, 50>, + // TODO This should ne `none` instead. Comment carried over from + // OMPKinds.def. + VersionedClause<OMPC_Depobj, 50> + ]; +} +def OMP_Scan : Directive<"scan"> { + let allowedClauses = [ + VersionedClause<OMPC_Inclusive, 50>, + VersionedClause<OMPC_Exclusive, 50> + ]; +} +def OMP_Assumes : Directive<"assumes"> {} +def OMP_BeginAssumes : Directive<"begin assumes"> {} +def OMP_EndAssumes : Directive<"end assumes"> {} +def OMP_BeginDeclareVariant : Directive<"begin declare variant"> {} +def OMP_EndDeclareVariant : Directive<"end declare variant"> {} +def OMP_ParallelWorkshare : Directive<"parallel workshare"> { + let allowedClauses = [ + VersionedClause<OMPC_Allocate>, + VersionedClause<OMPC_Copyin>, + VersionedClause<OMPC_Default>, + VersionedClause<OMPC_FirstPrivate>, + VersionedClause<OMPC_Private>, + VersionedClause<OMPC_Reduction>, + VersionedClause<OMPC_Shared> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_If>, + VersionedClause<OMPC_NumThreads>, + VersionedClause<OMPC_ProcBind> + ]; +} +def OMP_Workshare : Directive<"workshare"> {} +def OMP_EndDo : Directive<"end do"> {} +def OMP_EndDoSimd : Directive<"end do simd"> {} +def OMP_EndSections : Directive<"end sections"> { + let allowedOnceClauses = [ + VersionedClause<OMPC_NoWait> + ]; +} +def OMP_EndSingle : Directive<"end single"> { + let allowedClauses = [ + VersionedClause<OMPC_CopyPrivate> + ]; + let allowedOnceClauses = [ + VersionedClause<OMPC_NoWait> + ]; +} +def OMP_EndWorkshare : Directive<"end workshare"> { + let allowedClauses = [ + VersionedClause<OMPC_NoWait> + ]; +} +def OMP_Unknown : Directive<"unknown"> { + let isDefault = true; +} diff --git a/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPConstants.h b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPConstants.h new file mode 100644 index 0000000000..953321d47c --- /dev/null +++ b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPConstants.h @@ -0,0 +1,125 @@ +#pragma once + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + +//===- OMPConstants.h - OpenMP related constants and helpers ------ C++ -*-===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// \file +/// +/// This file defines constans and helpers used when dealing with OpenMP. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_OPENMP_CONSTANTS_H +#define LLVM_OPENMP_CONSTANTS_H + +#include "llvm/ADT/BitmaskEnum.h" + +#include "llvm/ADT/StringRef.h" +#include "llvm/Frontend/OpenMP/OMP.h.inc" + +namespace llvm { +class Type; +class Module; +class ArrayType; +class StructType; +class PointerType; +class StringRef; +class FunctionType; + +namespace omp { +LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(); + +/// IDs for all Internal Control Variables (ICVs). +enum class InternalControlVar { +#define ICV_DATA_ENV(Enum, ...) Enum, +#include "llvm/Frontend/OpenMP/OMPKinds.def" +}; + +#define ICV_DATA_ENV(Enum, ...) \ + constexpr auto Enum = omp::InternalControlVar::Enum; +#include "llvm/Frontend/OpenMP/OMPKinds.def" + +enum class ICVInitValue { +#define ICV_INIT_VALUE(Enum, Name) Enum, +#include "llvm/Frontend/OpenMP/OMPKinds.def" +}; + +#define ICV_INIT_VALUE(Enum, Name) \ + constexpr auto Enum = omp::ICVInitValue::Enum; +#include "llvm/Frontend/OpenMP/OMPKinds.def" + +/// IDs for all omp runtime library (RTL) functions. +enum class RuntimeFunction { +#define OMP_RTL(Enum, ...) Enum, +#include "llvm/Frontend/OpenMP/OMPKinds.def" +}; + +#define OMP_RTL(Enum, ...) constexpr auto Enum = omp::RuntimeFunction::Enum; +#include "llvm/Frontend/OpenMP/OMPKinds.def" + +/// IDs for the different default kinds. +enum class DefaultKind { +#define OMP_DEFAULT_KIND(Enum, Str) Enum, +#include "llvm/Frontend/OpenMP/OMPKinds.def" +}; + +#define OMP_DEFAULT_KIND(Enum, ...) \ + constexpr auto Enum = omp::DefaultKind::Enum; +#include "llvm/Frontend/OpenMP/OMPKinds.def" + +/// IDs for all omp runtime library ident_t flag encodings (see +/// their defintion in openmp/runtime/src/kmp.h). +enum class IdentFlag { +#define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value, +#include "llvm/Frontend/OpenMP/OMPKinds.def" + LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF) +}; + +#define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum; +#include "llvm/Frontend/OpenMP/OMPKinds.def" + +/// Helper to describe assume clauses. +struct AssumptionClauseMappingInfo { + /// The identifier describing the (beginning of the) clause. + llvm::StringLiteral Identifier; + /// Flag to determine if the identifier is a full name or the start of a name. + bool StartsWith; + /// Flag to determine if a directive lists follows. + bool HasDirectiveList; + /// Flag to determine if an expression follows. + bool HasExpression; +}; + +/// All known assume clauses. +static constexpr AssumptionClauseMappingInfo AssumptionClauseMappings[] = { +#define OMP_ASSUME_CLAUSE(Identifier, StartsWith, HasDirectiveList, \ + HasExpression) \ + {Identifier, StartsWith, HasDirectiveList, HasExpression}, +#include "llvm/Frontend/OpenMP/OMPKinds.def" +}; + +inline std::string getAllAssumeClauseOptions() { + std::string S; + for (const AssumptionClauseMappingInfo &ACMI : AssumptionClauseMappings) + S += (S.empty() ? "'" : "', '") + ACMI.Identifier.str(); + return S + "'"; +} + +} // end namespace omp + +} // end namespace llvm + +#endif // LLVM_OPENMP_CONSTANTS_H + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif diff --git a/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPContext.h b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPContext.h new file mode 100644 index 0000000000..4031468da9 --- /dev/null +++ b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPContext.h @@ -0,0 +1,221 @@ +#pragma once + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + +//===- OpenMP/OMPContext.h ----- OpenMP context helper functions - C++ -*-===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// \file +/// +/// This file provides helper functions and classes to deal with OpenMP +/// contexts as used by `[begin/end] declare variant` and `metadirective`. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_OPENMP_CONTEXT_H +#define LLVM_OPENMP_CONTEXT_H + +#include "llvm/ADT/APSInt.h" +#include "llvm/ADT/BitVector.h" +#include "llvm/ADT/SetVector.h" +#include "llvm/ADT/SmallSet.h" +#include "llvm/ADT/Triple.h" +#include "llvm/Frontend/OpenMP/OMPConstants.h" + +namespace llvm { +namespace omp { + +/// OpenMP Context related IDs and helpers +/// +///{ + +/// IDs for all OpenMP context selector trait sets (construct/device/...). +enum class TraitSet { +#define OMP_TRAIT_SET(Enum, ...) Enum, +#include "llvm/Frontend/OpenMP/OMPKinds.def" +}; + +/// IDs for all OpenMP context selector trait (device={kind/isa...}/...). +enum class TraitSelector { +#define OMP_TRAIT_SELECTOR(Enum, ...) Enum, +#include "llvm/Frontend/OpenMP/OMPKinds.def" +}; + +/// IDs for all OpenMP context trait properties (host/gpu/bsc/llvm/...) +enum class TraitProperty { +#define OMP_TRAIT_PROPERTY(Enum, ...) Enum, +#define OMP_LAST_TRAIT_PROPERTY(Enum) Last = Enum +#include "llvm/Frontend/OpenMP/OMPKinds.def" +}; + +/// Parse \p Str and return the trait set it matches or TraitSet::invalid. +TraitSet getOpenMPContextTraitSetKind(StringRef Str); + +/// Return the trait set for which \p Selector is a selector. +TraitSet getOpenMPContextTraitSetForSelector(TraitSelector Selector); + +/// Return the trait set for which \p Property is a property. +TraitSet getOpenMPContextTraitSetForProperty(TraitProperty Property); + +/// Return a textual representation of the trait set \p Kind. +StringRef getOpenMPContextTraitSetName(TraitSet Kind); + +/// Parse \p Str and return the trait set it matches or +/// TraitSelector::invalid. +TraitSelector getOpenMPContextTraitSelectorKind(StringRef Str); + +/// Return the trait selector for which \p Property is a property. +TraitSelector getOpenMPContextTraitSelectorForProperty(TraitProperty Property); + +/// Return a textual representation of the trait selector \p Kind. +StringRef getOpenMPContextTraitSelectorName(TraitSelector Kind); + +/// Parse \p Str and return the trait property it matches in the set \p Set and +/// selector \p Selector or TraitProperty::invalid. +TraitProperty getOpenMPContextTraitPropertyKind(TraitSet Set, + TraitSelector Selector, + StringRef Str); + +/// Return the trait property for a singleton selector \p Selector. +TraitProperty getOpenMPContextTraitPropertyForSelector(TraitSelector Selector); + +/// Return a textual representation of the trait property \p Kind, which might +/// be the raw string we parsed (\p RawString) if we do not translate the +/// property into a (distinct) enum. +StringRef getOpenMPContextTraitPropertyName(TraitProperty Kind, + StringRef RawString); + +/// Return a textual representation of the trait property \p Kind with selector +/// and set name included. +StringRef getOpenMPContextTraitPropertyFullName(TraitProperty Kind); + +/// Return a string listing all trait sets. +std::string listOpenMPContextTraitSets(); + +/// Return a string listing all trait selectors for \p Set. +std::string listOpenMPContextTraitSelectors(TraitSet Set); + +/// Return a string listing all trait properties for \p Set and \p Selector. +std::string listOpenMPContextTraitProperties(TraitSet Set, + TraitSelector Selector); +///} + +/// Return true if \p Selector can be nested in \p Set. Also sets +/// \p AllowsTraitScore and \p RequiresProperty to true/false if the user can +/// specify a score for properties in \p Selector and if the \p Selector +/// requires at least one property. +bool isValidTraitSelectorForTraitSet(TraitSelector Selector, TraitSet Set, + bool &AllowsTraitScore, + bool &RequiresProperty); + +/// Return true if \p Property can be nested in \p Selector and \p Set. +bool isValidTraitPropertyForTraitSetAndSelector(TraitProperty Property, + TraitSelector Selector, + TraitSet Set); + +/// Variant match information describes the required traits and how they are +/// scored (via the ScoresMap). In addition, the required consturct nesting is +/// decribed as well. +struct VariantMatchInfo { + /// Add the trait \p Property to the required trait set. \p RawString is the + /// string we parsed and derived \p Property from. If \p Score is not null, it + /// recorded as well. If \p Property is in the `construct` set it is recorded + /// in-order in the ConstructTraits as well. + void addTrait(TraitProperty Property, StringRef RawString, + APInt *Score = nullptr) { + addTrait(getOpenMPContextTraitSetForProperty(Property), Property, RawString, + Score); + } + /// Add the trait \p Property which is in set \p Set to the required trait + /// set. \p RawString is the string we parsed and derived \p Property from. If + /// \p Score is not null, it recorded as well. If \p Set is the `construct` + /// set it is recorded in-order in the ConstructTraits as well. + void addTrait(TraitSet Set, TraitProperty Property, StringRef RawString, + APInt *Score = nullptr) { + if (Score) + ScoreMap[Property] = *Score; + + // Special handling for `device={isa(...)}` as we do not match the enum but + // the raw string. + if (Property == TraitProperty::device_isa___ANY) + ISATraits.push_back(RawString); + + RequiredTraits.set(unsigned(Property)); + if (Set == TraitSet::construct) + ConstructTraits.push_back(Property); + } + + BitVector RequiredTraits = BitVector(unsigned(TraitProperty::Last) + 1); + SmallVector<StringRef, 8> ISATraits; + SmallVector<TraitProperty, 8> ConstructTraits; + SmallDenseMap<TraitProperty, APInt> ScoreMap; +}; + +/// The context for a source location is made up of active property traits, +/// e.g., device={kind(host)}, and constructs traits which describe the nesting +/// in OpenMP constructs at the location. +struct OMPContext { + OMPContext(bool IsDeviceCompilation, Triple TargetTriple); + virtual ~OMPContext() = default; + + void addTrait(TraitProperty Property) { + addTrait(getOpenMPContextTraitSetForProperty(Property), Property); + } + void addTrait(TraitSet Set, TraitProperty Property) { + ActiveTraits.set(unsigned(Property)); + if (Set == TraitSet::construct) + ConstructTraits.push_back(Property); + } + + /// Hook for users to check if an ISA trait matches. The trait is described as + /// the string that got parsed and it depends on the target and context if + /// this matches or not. + virtual bool matchesISATrait(StringRef) const { return false; } + + BitVector ActiveTraits = BitVector(unsigned(TraitProperty::Last) + 1); + SmallVector<TraitProperty, 8> ConstructTraits; +}; + +/// Return true if \p VMI is applicable in \p Ctx, that is, all traits required +/// by \p VMI are available in the OpenMP context \p Ctx. If \p DeviceSetOnly is +/// true, only the device selector set, if present, are checked. Note that we +/// still honor extension traits provided by the user. +bool isVariantApplicableInContext(const VariantMatchInfo &VMI, + const OMPContext &Ctx, + bool DeviceSetOnly = false); + +/// Return the index (into \p VMIs) of the variant with the highest score +/// from the ones applicble in \p Ctx. See llvm::isVariantApplicableInContext. +int getBestVariantMatchForContext(const SmallVectorImpl<VariantMatchInfo> &VMIs, + const OMPContext &Ctx); + +} // namespace omp + +template <> struct DenseMapInfo<omp::TraitProperty> { + static inline omp::TraitProperty getEmptyKey() { + return omp::TraitProperty(-1); + } + static inline omp::TraitProperty getTombstoneKey() { + return omp::TraitProperty(-2); + } + static unsigned getHashValue(omp::TraitProperty val) { + return std::hash<unsigned>{}(unsigned(val)); + } + static bool isEqual(omp::TraitProperty LHS, omp::TraitProperty RHS) { + return LHS == RHS; + } +}; + +} // end namespace llvm +#endif // LLVM_OPENMP_CONTEXT_H + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif diff --git a/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPGridValues.h b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPGridValues.h new file mode 100644 index 0000000000..da0c4d1f3f --- /dev/null +++ b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPGridValues.h @@ -0,0 +1,142 @@ +#pragma once + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + +//====--- OMPGridValues.h - Language-specific address spaces --*- C++ -*-====// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// \brief Provides definitions for Target specific Grid Values +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_OPENMP_GRIDVALUES_H +#define LLVM_OPENMP_GRIDVALUES_H + +namespace llvm { + +namespace omp { + +/// \brief Defines various target-specific GPU grid values that must be +/// consistent between host RTL (plugin), device RTL, and clang. +/// We can change grid values for a "fat" binary so that different +/// passes get the correct values when generating code for a +/// multi-target binary. Both amdgcn and nvptx values are stored in +/// this file. In the future, should there be differences between GPUs +/// of the same architecture, then simply make a different array and +/// use the new array name. +/// +/// Example usage in clang: +/// const unsigned slot_size = +/// ctx.GetTargetInfo().getGridValue(llvm::omp::GVIDX::GV_Warp_Size); +/// +/// Example usage in libomptarget/deviceRTLs: +/// #include "llvm/Frontend/OpenMP/OMPGridValues.h" +/// #ifdef __AMDGPU__ +/// #define GRIDVAL AMDGPUGpuGridValues +/// #else +/// #define GRIDVAL NVPTXGpuGridValues +/// #endif +/// ... Then use this reference for GV_Warp_Size in the deviceRTL source. +/// llvm::omp::GRIDVAL[llvm::omp::GVIDX::GV_Warp_Size] +/// +/// Example usage in libomptarget hsa plugin: +/// #include "llvm/Frontend/OpenMP/OMPGridValues.h" +/// #define GRIDVAL AMDGPUGpuGridValues +/// ... Then use this reference to access GV_Warp_Size in the hsa plugin. +/// llvm::omp::GRIDVAL[llvm::omp::GVIDX::GV_Warp_Size] +/// +/// Example usage in libomptarget cuda plugin: +/// #include "llvm/Frontend/OpenMP/OMPGridValues.h" +/// #define GRIDVAL NVPTXGpuGridValues +/// ... Then use this reference to access GV_Warp_Size in the cuda plugin. +/// llvm::omp::GRIDVAL[llvm::omp::GVIDX::GV_Warp_Size] +/// +enum GVIDX { + /// The maximum number of workers in a kernel. + /// (THREAD_ABSOLUTE_LIMIT) - (GV_Warp_Size), might be issue for blockDim.z + GV_Threads, + /// The size reserved for data in a shared memory slot. + GV_Slot_Size, + /// The default value of maximum number of threads in a worker warp. + GV_Warp_Size, + /// Alternate warp size for some AMDGCN architectures. Same as GV_Warp_Size + /// for NVPTX. + GV_Warp_Size_32, + /// The number of bits required to represent the max number of threads in warp + GV_Warp_Size_Log2, + /// GV_Warp_Size * GV_Slot_Size, + GV_Warp_Slot_Size, + /// the maximum number of teams. + GV_Max_Teams, + /// Global Memory Alignment + GV_Mem_Align, + /// (~0u >> (GV_Warp_Size - GV_Warp_Size_Log2)) + GV_Warp_Size_Log2_Mask, + // An alternative to the heavy data sharing infrastructure that uses global + // memory is one that uses device __shared__ memory. The amount of such space + // (in bytes) reserved by the OpenMP runtime is noted here. + GV_SimpleBufferSize, + // The absolute maximum team size for a working group + GV_Max_WG_Size, + // The default maximum team size for a working group + GV_Default_WG_Size, + // This is GV_Max_WG_Size / GV_WarpSize. 32 for NVPTX and 16 for AMDGCN. + GV_Max_Warp_Number, + /// The slot size that should be reserved for a working warp. + /// (~0u >> (GV_Warp_Size - GV_Warp_Size_Log2)) + GV_Warp_Size_Log2_MaskL +}; + +/// For AMDGPU GPUs +static constexpr unsigned AMDGPUGpuGridValues[] = { + 448, // GV_Threads + 256, // GV_Slot_Size + 64, // GV_Warp_Size + 32, // GV_Warp_Size_32 + 6, // GV_Warp_Size_Log2 + 64 * 256, // GV_Warp_Slot_Size + 128, // GV_Max_Teams + 256, // GV_Mem_Align + 63, // GV_Warp_Size_Log2_Mask + 896, // GV_SimpleBufferSize + 1024, // GV_Max_WG_Size, + 256, // GV_Defaut_WG_Size + 1024 / 64, // GV_Max_WG_Size / GV_WarpSize + 63 // GV_Warp_Size_Log2_MaskL +}; + +/// For Nvidia GPUs +static constexpr unsigned NVPTXGpuGridValues[] = { + 992, // GV_Threads + 256, // GV_Slot_Size + 32, // GV_Warp_Size + 32, // GV_Warp_Size_32 + 5, // GV_Warp_Size_Log2 + 32 * 256, // GV_Warp_Slot_Size + 1024, // GV_Max_Teams + 256, // GV_Mem_Align + (~0u >> (32 - 5)), // GV_Warp_Size_Log2_Mask + 896, // GV_SimpleBufferSize + 1024, // GV_Max_WG_Size + 128, // GV_Defaut_WG_Size + 1024 / 32, // GV_Max_WG_Size / GV_WarpSize + 31 // GV_Warp_Size_Log2_MaskL +}; + +} // namespace omp +} // namespace llvm + +#endif // LLVM_OPENMP_GRIDVALUES_H + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif diff --git a/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPIRBuilder.h b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPIRBuilder.h new file mode 100644 index 0000000000..612e362800 --- /dev/null +++ b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPIRBuilder.h @@ -0,0 +1,872 @@ +#pragma once + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + +//===- IR/OpenMPIRBuilder.h - OpenMP encoding builder for LLVM IR - C++ -*-===// +// +// 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 file defines the OpenMPIRBuilder class and helpers used as a convenient +// way to create LLVM instructions for OpenMP directives. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_OPENMP_IR_IRBUILDER_H +#define LLVM_OPENMP_IR_IRBUILDER_H + +#include "llvm/Frontend/OpenMP/OMPConstants.h" +#include "llvm/IR/DebugLoc.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/Support/Allocator.h" +#include <forward_list> + +namespace llvm { +class CanonicalLoopInfo; + +/// An interface to create LLVM-IR for OpenMP directives. +/// +/// Each OpenMP directive has a corresponding public generator method. +class OpenMPIRBuilder { +public: + /// Create a new OpenMPIRBuilder operating on the given module \p M. This will + /// not have an effect on \p M (see initialize). + OpenMPIRBuilder(Module &M) : M(M), Builder(M.getContext()) {} + + /// Initialize the internal state, this will put structures types and + /// potentially other helpers into the underlying module. Must be called + /// before any other method and only once! + void initialize(); + + /// Finalize the underlying module, e.g., by outlining regions. + /// \param AllowExtractorSinking Flag to include sinking instructions, + /// emitted by CodeExtractor, in the + /// outlined region. Default is false. + void finalize(bool AllowExtractorSinking = false); + + /// Add attributes known for \p FnID to \p Fn. + void addAttributes(omp::RuntimeFunction FnID, Function &Fn); + + /// Type used throughout for insertion points. + using InsertPointTy = IRBuilder<>::InsertPoint; + + /// Callback type for variable finalization (think destructors). + /// + /// \param CodeGenIP is the insertion point at which the finalization code + /// should be placed. + /// + /// A finalize callback knows about all objects that need finalization, e.g. + /// destruction, when the scope of the currently generated construct is left + /// at the time, and location, the callback is invoked. + using FinalizeCallbackTy = std::function<void(InsertPointTy CodeGenIP)>; + + struct FinalizationInfo { + /// The finalization callback provided by the last in-flight invocation of + /// createXXXX for the directive of kind DK. + FinalizeCallbackTy FiniCB; + + /// The directive kind of the innermost directive that has an associated + /// region which might require finalization when it is left. + omp::Directive DK; + + /// Flag to indicate if the directive is cancellable. + bool IsCancellable; + }; + + /// Push a finalization callback on the finalization stack. + /// + /// NOTE: Temporary solution until Clang CG is gone. + void pushFinalizationCB(const FinalizationInfo &FI) { + FinalizationStack.push_back(FI); + } + + /// Pop the last finalization callback from the finalization stack. + /// + /// NOTE: Temporary solution until Clang CG is gone. + void popFinalizationCB() { FinalizationStack.pop_back(); } + + /// Callback type for body (=inner region) code generation + /// + /// The callback takes code locations as arguments, each describing a + /// location at which code might need to be generated or a location that is + /// the target of control transfer. + /// + /// \param AllocaIP is the insertion point at which new alloca instructions + /// should be placed. + /// \param CodeGenIP is the insertion point at which the body code should be + /// placed. + /// \param ContinuationBB is the basic block target to leave the body. + /// + /// Note that all blocks pointed to by the arguments have terminators. + using BodyGenCallbackTy = + function_ref<void(InsertPointTy AllocaIP, InsertPointTy CodeGenIP, + BasicBlock &ContinuationBB)>; + + /// Callback type for loop body code generation. + /// + /// \param CodeGenIP is the insertion point where the loop's body code must be + /// placed. This will be a dedicated BasicBlock with a + /// conditional branch from the loop condition check and + /// terminated with an unconditional branch to the loop + /// latch. + /// \param IndVar is the induction variable usable at the insertion point. + using LoopBodyGenCallbackTy = + function_ref<void(InsertPointTy CodeGenIP, Value *IndVar)>; + + /// Callback type for variable privatization (think copy & default + /// constructor). + /// + /// \param AllocaIP is the insertion point at which new alloca instructions + /// should be placed. + /// \param CodeGenIP is the insertion point at which the privatization code + /// should be placed. + /// \param Original The value being copied/created, should not be used in the + /// generated IR. + /// \param Inner The equivalent of \p Original that should be used in the + /// generated IR; this is equal to \p Original if the value is + /// a pointer and can thus be passed directly, otherwise it is + /// an equivalent but different value. + /// \param ReplVal The replacement value, thus a copy or new created version + /// of \p Inner. + /// + /// \returns The new insertion point where code generation continues and + /// \p ReplVal the replacement value. + using PrivatizeCallbackTy = function_ref<InsertPointTy( + InsertPointTy AllocaIP, InsertPointTy CodeGenIP, Value &Original, + Value &Inner, Value *&ReplVal)>; + + /// Description of a LLVM-IR insertion point (IP) and a debug/source location + /// (filename, line, column, ...). + struct LocationDescription { + template <typename T, typename U> + LocationDescription(const IRBuilder<T, U> &IRB) + : IP(IRB.saveIP()), DL(IRB.getCurrentDebugLocation()) {} + LocationDescription(const InsertPointTy &IP) : IP(IP) {} + LocationDescription(const InsertPointTy &IP, const DebugLoc &DL) + : IP(IP), DL(DL) {} + InsertPointTy IP; + DebugLoc DL; + }; + + /// Emitter methods for OpenMP directives. + /// + ///{ + + /// Generator for '#omp barrier' + /// + /// \param Loc The location where the barrier directive was encountered. + /// \param DK The kind of directive that caused the barrier. + /// \param ForceSimpleCall Flag to force a simple (=non-cancellation) barrier. + /// \param CheckCancelFlag Flag to indicate a cancel barrier return value + /// should be checked and acted upon. + /// + /// \returns The insertion point after the barrier. + InsertPointTy createBarrier(const LocationDescription &Loc, omp::Directive DK, + bool ForceSimpleCall = false, + bool CheckCancelFlag = true); + + /// Generator for '#omp cancel' + /// + /// \param Loc The location where the directive was encountered. + /// \param IfCondition The evaluated 'if' clause expression, if any. + /// \param CanceledDirective The kind of directive that is cancled. + /// + /// \returns The insertion point after the barrier. + InsertPointTy createCancel(const LocationDescription &Loc, Value *IfCondition, + omp::Directive CanceledDirective); + + /// Generator for '#omp parallel' + /// + /// \param Loc The insert and source location description. + /// \param AllocaIP The insertion points to be used for alloca instructions. + /// \param BodyGenCB Callback that will generate the region code. + /// \param PrivCB Callback to copy a given variable (think copy constructor). + /// \param FiniCB Callback to finalize variable copies. + /// \param IfCondition The evaluated 'if' clause expression, if any. + /// \param NumThreads The evaluated 'num_threads' clause expression, if any. + /// \param ProcBind The value of the 'proc_bind' clause (see ProcBindKind). + /// \param IsCancellable Flag to indicate a cancellable parallel region. + /// + /// \returns The insertion position *after* the parallel. + IRBuilder<>::InsertPoint + createParallel(const LocationDescription &Loc, InsertPointTy AllocaIP, + BodyGenCallbackTy BodyGenCB, PrivatizeCallbackTy PrivCB, + FinalizeCallbackTy FiniCB, Value *IfCondition, + Value *NumThreads, omp::ProcBindKind ProcBind, + bool IsCancellable); + + /// Generator for the control flow structure of an OpenMP canonical loop. + /// + /// This generator operates on the logical iteration space of the loop, i.e. + /// the caller only has to provide a loop trip count of the loop as defined by + /// base language semantics. The trip count is interpreted as an unsigned + /// integer. The induction variable passed to \p BodyGenCB will be of the same + /// type and run from 0 to \p TripCount - 1. It is up to the callback to + /// convert the logical iteration variable to the loop counter variable in the + /// loop body. + /// + /// \param Loc The insert and source location description. The insert + /// location can be between two instructions or the end of a + /// degenerate block (e.g. a BB under construction). + /// \param BodyGenCB Callback that will generate the loop body code. + /// \param TripCount Number of iterations the loop body is executed. + /// \param Name Base name used to derive BB and instruction names. + /// + /// \returns An object representing the created control flow structure which + /// can be used for loop-associated directives. + CanonicalLoopInfo *createCanonicalLoop(const LocationDescription &Loc, + LoopBodyGenCallbackTy BodyGenCB, + Value *TripCount, + const Twine &Name = "loop"); + + /// Generator for the control flow structure of an OpenMP canonical loop. + /// + /// Instead of a logical iteration space, this allows specifying user-defined + /// loop counter values using increment, upper- and lower bounds. To + /// disambiguate the terminology when counting downwards, instead of lower + /// bounds we use \p Start for the loop counter value in the first body + /// iteration. + /// + /// Consider the following limitations: + /// + /// * A loop counter space over all integer values of its bit-width cannot be + /// represented. E.g using uint8_t, its loop trip count of 256 cannot be + /// stored into an 8 bit integer): + /// + /// DO I = 0, 255, 1 + /// + /// * Unsigned wrapping is only supported when wrapping only "once"; E.g. + /// effectively counting downwards: + /// + /// for (uint8_t i = 100u; i > 0; i += 127u) + /// + /// + /// TODO: May need to add additional parameters to represent: + /// + /// * Allow representing downcounting with unsigned integers. + /// + /// * Sign of the step and the comparison operator might disagree: + /// + /// for (int i = 0; i < 42; --i) + /// + // + /// \param Loc The insert and source location description. + /// \param BodyGenCB Callback that will generate the loop body code. + /// \param Start Value of the loop counter for the first iterations. + /// \param Stop Loop counter values past this will stop the the + /// iterations. + /// \param Step Loop counter increment after each iteration; negative + /// means counting down. \param IsSigned Whether Start, Stop + /// and Stop are signed integers. + /// \param InclusiveStop Whether \p Stop itself is a valid value for the loop + /// counter. + /// \param ComputeIP Insertion point for instructions computing the trip + /// count. Can be used to ensure the trip count is available + /// at the outermost loop of a loop nest. If not set, + /// defaults to the preheader of the generated loop. + /// \param Name Base name used to derive BB and instruction names. + /// + /// \returns An object representing the created control flow structure which + /// can be used for loop-associated directives. + CanonicalLoopInfo *createCanonicalLoop(const LocationDescription &Loc, + LoopBodyGenCallbackTy BodyGenCB, + Value *Start, Value *Stop, Value *Step, + bool IsSigned, bool InclusiveStop, + InsertPointTy ComputeIP = {}, + const Twine &Name = "loop"); + + /// Modifies the canonical loop to be a statically-scheduled workshare loop. + /// + /// This takes a \p LoopInfo representing a canonical loop, such as the one + /// created by \p createCanonicalLoop and emits additional instructions to + /// turn it into a workshare loop. In particular, it calls to an OpenMP + /// runtime function in the preheader to obtain the loop bounds to be used in + /// the current thread, updates the relevant instructions in the canonical + /// loop and calls to an OpenMP runtime finalization function after the loop. + /// + /// \param Loc The source location description, the insertion location + /// is not used. + /// \param CLI A descriptor of the canonical loop to workshare. + /// \param AllocaIP An insertion point for Alloca instructions usable in the + /// preheader of the loop. + /// \param NeedsBarrier Indicates whether a barrier must be insterted after + /// the loop. + /// \param Chunk The size of loop chunk considered as a unit when + /// scheduling. If \p nullptr, defaults to 1. + /// + /// \returns Updated CanonicalLoopInfo. + CanonicalLoopInfo *createStaticWorkshareLoop(const LocationDescription &Loc, + CanonicalLoopInfo *CLI, + InsertPointTy AllocaIP, + bool NeedsBarrier, + Value *Chunk = nullptr); + + /// Tile a loop nest. + /// + /// Tiles the loops of \p Loops by the tile sizes in \p TileSizes. Loops in + /// \p/ Loops must be perfectly nested, from outermost to innermost loop + /// (i.e. Loops.front() is the outermost loop). The trip count llvm::Value + /// of every loop and every tile sizes must be usable in the outermost + /// loop's preheader. This implies that the loop nest is rectangular. + /// + /// Example: + /// \code + /// for (int i = 0; i < 15; ++i) // Canonical loop "i" + /// for (int j = 0; j < 14; ++j) // Canonical loop "j" + /// body(i, j); + /// \endcode + /// + /// After tiling with Loops={i,j} and TileSizes={5,7}, the loop is changed to + /// \code + /// for (int i1 = 0; i1 < 3; ++i1) + /// for (int j1 = 0; j1 < 2; ++j1) + /// for (int i2 = 0; i2 < 5; ++i2) + /// for (int j2 = 0; j2 < 7; ++j2) + /// body(i1*3+i2, j1*3+j2); + /// \endcode + /// + /// The returned vector are the loops {i1,j1,i2,j2}. The loops i1 and j1 are + /// referred to the floor, and the loops i2 and j2 are the tiles. Tiling also + /// handles non-constant trip counts, non-constant tile sizes and trip counts + /// that are not multiples of the tile size. In the latter case the tile loop + /// of the last floor-loop iteration will have fewer iterations than specified + /// as its tile size. + /// + /// + /// @param DL Debug location for instructions added by tiling, for + /// instance the floor- and tile trip count computation. + /// @param Loops Loops to tile. The CanonicalLoopInfo objects are + /// invalidated by this method, i.e. should not used after + /// tiling. + /// @param TileSizes For each loop in \p Loops, the tile size for that + /// dimensions. + /// + /// \returns A list of generated loops. Contains twice as many loops as the + /// input loop nest; the first half are the floor loops and the + /// second half are the tile loops. + std::vector<CanonicalLoopInfo *> + tileLoops(DebugLoc DL, ArrayRef<CanonicalLoopInfo *> Loops, + ArrayRef<Value *> TileSizes); + + /// Generator for '#omp flush' + /// + /// \param Loc The location where the flush directive was encountered + void createFlush(const LocationDescription &Loc); + + /// Generator for '#omp taskwait' + /// + /// \param Loc The location where the taskwait directive was encountered. + void createTaskwait(const LocationDescription &Loc); + + /// Generator for '#omp taskyield' + /// + /// \param Loc The location where the taskyield directive was encountered. + void createTaskyield(const LocationDescription &Loc); + + ///} + + /// Return the insertion point used by the underlying IRBuilder. + InsertPointTy getInsertionPoint() { return Builder.saveIP(); } + + /// Update the internal location to \p Loc. + bool updateToLocation(const LocationDescription &Loc) { + Builder.restoreIP(Loc.IP); + Builder.SetCurrentDebugLocation(Loc.DL); + return Loc.IP.getBlock() != nullptr; + } + + /// Return the function declaration for the runtime function with \p FnID. + FunctionCallee getOrCreateRuntimeFunction(Module &M, + omp::RuntimeFunction FnID); + + Function *getOrCreateRuntimeFunctionPtr(omp::RuntimeFunction FnID); + + /// Return the (LLVM-IR) string describing the source location \p LocStr. + Constant *getOrCreateSrcLocStr(StringRef LocStr); + + /// Return the (LLVM-IR) string describing the default source location. + Constant *getOrCreateDefaultSrcLocStr(); + + /// Return the (LLVM-IR) string describing the source location identified by + /// the arguments. + Constant *getOrCreateSrcLocStr(StringRef FunctionName, StringRef FileName, + unsigned Line, unsigned Column); + + /// Return the (LLVM-IR) string describing the source location \p Loc. + Constant *getOrCreateSrcLocStr(const LocationDescription &Loc); + + /// Return an ident_t* encoding the source location \p SrcLocStr and \p Flags. + /// TODO: Create a enum class for the Reserve2Flags + Value *getOrCreateIdent(Constant *SrcLocStr, + omp::IdentFlag Flags = omp::IdentFlag(0), + unsigned Reserve2Flags = 0); + + // Get the type corresponding to __kmpc_impl_lanemask_t from the deviceRTL + Type *getLanemaskType(); + + /// Generate control flow and cleanup for cancellation. + /// + /// \param CancelFlag Flag indicating if the cancellation is performed. + /// \param CanceledDirective The kind of directive that is cancled. + void emitCancelationCheckImpl(Value *CancelFlag, + omp::Directive CanceledDirective); + + /// Generate a barrier runtime call. + /// + /// \param Loc The location at which the request originated and is fulfilled. + /// \param DK The directive which caused the barrier + /// \param ForceSimpleCall Flag to force a simple (=non-cancellation) barrier. + /// \param CheckCancelFlag Flag to indicate a cancel barrier return value + /// should be checked and acted upon. + /// + /// \returns The insertion point after the barrier. + InsertPointTy emitBarrierImpl(const LocationDescription &Loc, + omp::Directive DK, bool ForceSimpleCall, + bool CheckCancelFlag); + + /// Generate a flush runtime call. + /// + /// \param Loc The location at which the request originated and is fulfilled. + void emitFlush(const LocationDescription &Loc); + + /// The finalization stack made up of finalize callbacks currently in-flight, + /// wrapped into FinalizationInfo objects that reference also the finalization + /// target block and the kind of cancellable directive. + SmallVector<FinalizationInfo, 8> FinalizationStack; + + /// Return true if the last entry in the finalization stack is of kind \p DK + /// and cancellable. + bool isLastFinalizationInfoCancellable(omp::Directive DK) { + return !FinalizationStack.empty() && + FinalizationStack.back().IsCancellable && + FinalizationStack.back().DK == DK; + } + + /// Generate a taskwait runtime call. + /// + /// \param Loc The location at which the request originated and is fulfilled. + void emitTaskwaitImpl(const LocationDescription &Loc); + + /// Generate a taskyield runtime call. + /// + /// \param Loc The location at which the request originated and is fulfilled. + void emitTaskyieldImpl(const LocationDescription &Loc); + + /// Return the current thread ID. + /// + /// \param Ident The ident (ident_t*) describing the query origin. + Value *getOrCreateThreadID(Value *Ident); + + /// The underlying LLVM-IR module + Module &M; + + /// The LLVM-IR Builder used to create IR. + IRBuilder<> Builder; + + /// Map to remember source location strings + StringMap<Constant *> SrcLocStrMap; + + /// Map to remember existing ident_t*. + DenseMap<std::pair<Constant *, uint64_t>, Value *> IdentMap; + + /// Helper that contains information about regions we need to outline + /// during finalization. + struct OutlineInfo { + using PostOutlineCBTy = std::function<void(Function &)>; + PostOutlineCBTy PostOutlineCB; + BasicBlock *EntryBB, *ExitBB; + + /// Collect all blocks in between EntryBB and ExitBB in both the given + /// vector and set. + void collectBlocks(SmallPtrSetImpl<BasicBlock *> &BlockSet, + SmallVectorImpl<BasicBlock *> &BlockVector); + }; + + /// Collection of regions that need to be outlined during finalization. + SmallVector<OutlineInfo, 16> OutlineInfos; + + /// Collection of owned canonical loop objects that eventually need to be + /// free'd. + std::forward_list<CanonicalLoopInfo> LoopInfos; + + /// Add a new region that will be outlined later. + void addOutlineInfo(OutlineInfo &&OI) { OutlineInfos.emplace_back(OI); } + + /// An ordered map of auto-generated variables to their unique names. + /// It stores variables with the following names: 1) ".gomp_critical_user_" + + /// <critical_section_name> + ".var" for "omp critical" directives; 2) + /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate + /// variables. + StringMap<AssertingVH<Constant>, BumpPtrAllocator> InternalVars; + +public: + /// Generator for __kmpc_copyprivate + /// + /// \param Loc The source location description. + /// \param BufSize Number of elements in the buffer. + /// \param CpyBuf List of pointers to data to be copied. + /// \param CpyFn function to call for copying data. + /// \param DidIt flag variable; 1 for 'single' thread, 0 otherwise. + /// + /// \return The insertion position *after* the CopyPrivate call. + + InsertPointTy createCopyPrivate(const LocationDescription &Loc, + llvm::Value *BufSize, llvm::Value *CpyBuf, + llvm::Value *CpyFn, llvm::Value *DidIt); + + /// Generator for '#omp single' + /// + /// \param Loc The source location description. + /// \param BodyGenCB Callback that will generate the region code. + /// \param FiniCB Callback to finalize variable copies. + /// \param DidIt Local variable used as a flag to indicate 'single' thread + /// + /// \returns The insertion position *after* the single call. + InsertPointTy createSingle(const LocationDescription &Loc, + BodyGenCallbackTy BodyGenCB, + FinalizeCallbackTy FiniCB, llvm::Value *DidIt); + + /// Generator for '#omp master' + /// + /// \param Loc The insert and source location description. + /// \param BodyGenCB Callback that will generate the region code. + /// \param FiniCB Callback to finalize variable copies. + /// + /// \returns The insertion position *after* the master. + InsertPointTy createMaster(const LocationDescription &Loc, + BodyGenCallbackTy BodyGenCB, + FinalizeCallbackTy FiniCB); + + /// Generator for '#omp critical' + /// + /// \param Loc The insert and source location description. + /// \param BodyGenCB Callback that will generate the region body code. + /// \param FiniCB Callback to finalize variable copies. + /// \param CriticalName name of the lock used by the critical directive + /// \param HintInst Hint Instruction for hint clause associated with critical + /// + /// \returns The insertion position *after* the master. + InsertPointTy createCritical(const LocationDescription &Loc, + BodyGenCallbackTy BodyGenCB, + FinalizeCallbackTy FiniCB, + StringRef CriticalName, Value *HintInst); + + /// Generate conditional branch and relevant BasicBlocks through which private + /// threads copy the 'copyin' variables from Master copy to threadprivate + /// copies. + /// + /// \param IP insertion block for copyin conditional + /// \param MasterVarPtr a pointer to the master variable + /// \param PrivateVarPtr a pointer to the threadprivate variable + /// \param IntPtrTy Pointer size type + /// \param BranchtoEnd Create a branch between the copyin.not.master blocks + // and copy.in.end block + /// + /// \returns The insertion point where copying operation to be emitted. + InsertPointTy createCopyinClauseBlocks(InsertPointTy IP, Value *MasterAddr, + Value *PrivateAddr, + llvm::IntegerType *IntPtrTy, + bool BranchtoEnd = true); + + /// Create a runtime call for kmpc_Alloc + /// + /// \param Loc The insert and source location description. + /// \param Size Size of allocated memory space + /// \param Allocator Allocator information instruction + /// \param Name Name of call Instruction for OMP_alloc + /// + /// \returns CallInst to the OMP_Alloc call + CallInst *createOMPAlloc(const LocationDescription &Loc, Value *Size, + Value *Allocator, std::string Name = ""); + + /// Create a runtime call for kmpc_free + /// + /// \param Loc The insert and source location description. + /// \param Addr Address of memory space to be freed + /// \param Allocator Allocator information instruction + /// \param Name Name of call Instruction for OMP_Free + /// + /// \returns CallInst to the OMP_Free call + CallInst *createOMPFree(const LocationDescription &Loc, Value *Addr, + Value *Allocator, std::string Name = ""); + + /// Create a runtime call for kmpc_threadprivate_cached + /// + /// \param Loc The insert and source location description. + /// \param Pointer pointer to data to be cached + /// \param Size size of data to be cached + /// \param Name Name of call Instruction for callinst + /// + /// \returns CallInst to the thread private cache call. + CallInst *createCachedThreadPrivate(const LocationDescription &Loc, + llvm::Value *Pointer, + llvm::ConstantInt *Size, + const llvm::Twine &Name = Twine("")); + + /// Declarations for LLVM-IR types (simple, array, function and structure) are + /// generated below. Their names are defined and used in OpenMPKinds.def. Here + /// we provide the declarations, the initializeTypes function will provide the + /// values. + /// + ///{ +#define OMP_TYPE(VarName, InitValue) Type *VarName = nullptr; +#define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) \ + ArrayType *VarName##Ty = nullptr; \ + PointerType *VarName##PtrTy = nullptr; +#define OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...) \ + FunctionType *VarName = nullptr; \ + PointerType *VarName##Ptr = nullptr; +#define OMP_STRUCT_TYPE(VarName, StrName, ...) \ + StructType *VarName = nullptr; \ + PointerType *VarName##Ptr = nullptr; +#include "llvm/Frontend/OpenMP/OMPKinds.def" + + ///} + +private: + /// Create all simple and struct types exposed by the runtime and remember + /// the llvm::PointerTypes of them for easy access later. + void initializeTypes(Module &M); + + /// Common interface for generating entry calls for OMP Directives. + /// if the directive has a region/body, It will set the insertion + /// point to the body + /// + /// \param OMPD Directive to generate entry blocks for + /// \param EntryCall Call to the entry OMP Runtime Function + /// \param ExitBB block where the region ends. + /// \param Conditional indicate if the entry call result will be used + /// to evaluate a conditional of whether a thread will execute + /// body code or not. + /// + /// \return The insertion position in exit block + InsertPointTy emitCommonDirectiveEntry(omp::Directive OMPD, Value *EntryCall, + BasicBlock *ExitBB, + bool Conditional = false); + + /// Common interface to finalize the region + /// + /// \param OMPD Directive to generate exiting code for + /// \param FinIP Insertion point for emitting Finalization code and exit call + /// \param ExitCall Call to the ending OMP Runtime Function + /// \param HasFinalize indicate if the directive will require finalization + /// and has a finalization callback in the stack that + /// should be called. + /// + /// \return The insertion position in exit block + InsertPointTy emitCommonDirectiveExit(omp::Directive OMPD, + InsertPointTy FinIP, + Instruction *ExitCall, + bool HasFinalize = true); + + /// Common Interface to generate OMP inlined regions + /// + /// \param OMPD Directive to generate inlined region for + /// \param EntryCall Call to the entry OMP Runtime Function + /// \param ExitCall Call to the ending OMP Runtime Function + /// \param BodyGenCB Body code generation callback. + /// \param FiniCB Finalization Callback. Will be called when finalizing region + /// \param Conditional indicate if the entry call result will be used + /// to evaluate a conditional of whether a thread will execute + /// body code or not. + /// \param HasFinalize indicate if the directive will require finalization + /// and has a finalization callback in the stack that + /// should be called. + /// + /// \return The insertion point after the region + + InsertPointTy + EmitOMPInlinedRegion(omp::Directive OMPD, Instruction *EntryCall, + Instruction *ExitCall, BodyGenCallbackTy BodyGenCB, + FinalizeCallbackTy FiniCB, bool Conditional = false, + bool HasFinalize = true); + + /// Get the platform-specific name separator. + /// \param Parts different parts of the final name that needs separation + /// \param FirstSeparator First separator used between the initial two + /// parts of the name. + /// \param Separator separator used between all of the rest consecutive + /// parts of the name + static std::string getNameWithSeparators(ArrayRef<StringRef> Parts, + StringRef FirstSeparator, + StringRef Separator); + + /// Gets (if variable with the given name already exist) or creates + /// internal global variable with the specified Name. The created variable has + /// linkage CommonLinkage by default and is initialized by null value. + /// \param Ty Type of the global variable. If it is exist already the type + /// must be the same. + /// \param Name Name of the variable. + Constant *getOrCreateOMPInternalVariable(Type *Ty, const Twine &Name, + unsigned AddressSpace = 0); + + /// Returns corresponding lock object for the specified critical region + /// name. If the lock object does not exist it is created, otherwise the + /// reference to the existing copy is returned. + /// \param CriticalName Name of the critical region. + /// + Value *getOMPCriticalRegionLock(StringRef CriticalName); + + /// Create the control flow structure of a canonical OpenMP loop. + /// + /// The emitted loop will be disconnected, i.e. no edge to the loop's + /// preheader and no terminator in the AfterBB. The OpenMPIRBuilder's + /// IRBuilder location is not preserved. + /// + /// \param DL DebugLoc used for the instructions in the skeleton. + /// \param TripCount Value to be used for the trip count. + /// \param F Function in which to insert the BasicBlocks. + /// \param PreInsertBefore Where to insert BBs that execute before the body, + /// typically the body itself. + /// \param PostInsertBefore Where to insert BBs that execute after the body. + /// \param Name Base name used to derive BB + /// and instruction names. + /// + /// \returns The CanonicalLoopInfo that represents the emitted loop. + CanonicalLoopInfo *createLoopSkeleton(DebugLoc DL, Value *TripCount, + Function *F, + BasicBlock *PreInsertBefore, + BasicBlock *PostInsertBefore, + const Twine &Name = {}); +}; + +/// Class to represented the control flow structure of an OpenMP canonical loop. +/// +/// The control-flow structure is standardized for easy consumption by +/// directives associated with loops. For instance, the worksharing-loop +/// construct may change this control flow such that each loop iteration is +/// executed on only one thread. +/// +/// The control flow can be described as follows: +/// +/// Preheader +/// | +/// /-> Header +/// | | +/// | Cond---\ +/// | | | +/// | Body | +/// | | | | +/// | <...> | +/// | | | | +/// \--Latch | +/// | +/// Exit +/// | +/// After +/// +/// Code in the header, condition block, latch and exit block must not have any +/// side-effect. The body block is the single entry point into the loop body, +/// which may contain arbitrary control flow as long as all control paths +/// eventually branch to the latch block. +/// +/// Defined outside OpenMPIRBuilder because one cannot forward-declare nested +/// classes. +class CanonicalLoopInfo { + friend class OpenMPIRBuilder; + +private: + /// Whether this object currently represents a loop. + bool IsValid = false; + + BasicBlock *Preheader; + BasicBlock *Header; + BasicBlock *Cond; + BasicBlock *Body; + BasicBlock *Latch; + BasicBlock *Exit; + BasicBlock *After; + + /// Add the control blocks of this loop to \p BBs. + /// + /// This does not include any block from the body, including the one returned + /// by getBody(). + void collectControlBlocks(SmallVectorImpl<BasicBlock *> &BBs); + +public: + /// The preheader ensures that there is only a single edge entering the loop. + /// Code that must be execute before any loop iteration can be emitted here, + /// such as computing the loop trip count and begin lifetime markers. Code in + /// the preheader is not considered part of the canonical loop. + BasicBlock *getPreheader() const { return Preheader; } + + /// The header is the entry for each iteration. In the canonical control flow, + /// it only contains the PHINode for the induction variable. + BasicBlock *getHeader() const { return Header; } + + /// The condition block computes whether there is another loop iteration. If + /// yes, branches to the body; otherwise to the exit block. + BasicBlock *getCond() const { return Cond; } + + /// The body block is the single entry for a loop iteration and not controlled + /// by CanonicalLoopInfo. It can contain arbitrary control flow but must + /// eventually branch to the \p Latch block. + BasicBlock *getBody() const { return Body; } + + /// Reaching the latch indicates the end of the loop body code. In the + /// canonical control flow, it only contains the increment of the induction + /// variable. + BasicBlock *getLatch() const { return Latch; } + + /// Reaching the exit indicates no more iterations are being executed. + BasicBlock *getExit() const { return Exit; } + + /// The after block is intended for clean-up code such as lifetime end + /// markers. It is separate from the exit block to ensure, analogous to the + /// preheader, it having just a single entry edge and being free from PHI + /// nodes should there be multiple loop exits (such as from break + /// statements/cancellations). + BasicBlock *getAfter() const { return After; } + + /// Returns the llvm::Value containing the number of loop iterations. It must + /// be valid in the preheader and always interpreted as an unsigned integer of + /// any bit-width. + Value *getTripCount() const { + Instruction *CmpI = &Cond->front(); + assert(isa<CmpInst>(CmpI) && "First inst must compare IV with TripCount"); + return CmpI->getOperand(1); + } + + /// Returns the instruction representing the current logical induction + /// variable. Always unsigned, always starting at 0 with an increment of one. + Instruction *getIndVar() const { + Instruction *IndVarPHI = &Header->front(); + assert(isa<PHINode>(IndVarPHI) && "First inst must be the IV PHI"); + return IndVarPHI; + } + + /// Return the type of the induction variable (and the trip count). + Type *getIndVarType() const { return getIndVar()->getType(); } + + /// Return the insertion point for user code before the loop. + OpenMPIRBuilder::InsertPointTy getPreheaderIP() const { + return {Preheader, std::prev(Preheader->end())}; + }; + + /// Return the insertion point for user code in the body. + OpenMPIRBuilder::InsertPointTy getBodyIP() const { + return {Body, Body->begin()}; + }; + + /// Return the insertion point for user code after the loop. + OpenMPIRBuilder::InsertPointTy getAfterIP() const { + return {After, After->begin()}; + }; + + /// Consistency self-check. + void assertOK() const; +}; + +} // end namespace llvm + +#endif // LLVM_IR_IRBUILDER_H + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif diff --git a/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPKinds.def b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPKinds.def new file mode 100644 index 0000000000..75d360bf42 --- /dev/null +++ b/contrib/libs/llvm12/include/llvm/Frontend/OpenMP/OMPKinds.def @@ -0,0 +1,1141 @@ +//===--- OMPKinds.def - OpenMP directives, clauses, rt-calls -*- C++ -*-===// +// +// 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 +// +//===----------------------------------------------------------------------===// +/// \file +/// +/// This file defines the list of supported OpenMP runtime +/// calls, and other things that need to be listed in enums. +/// +/// This file is under transition to OMP.td with TableGen code generation. +/// +//===----------------------------------------------------------------------===// + +/// OpenMP Directives, combined directives and Clauses +/// - Moved to OMP.td + +/// Types used in runtime structs or runtime functions +/// +///{ + +#ifndef OMP_TYPE +#define OMP_TYPE(VarName, InitValue) +#endif + +#define __OMP_TYPE(VarName) OMP_TYPE(VarName, Type::get##VarName##Ty(Ctx)) + +__OMP_TYPE(Void) +__OMP_TYPE(Int1) +__OMP_TYPE(Int8) +__OMP_TYPE(Int16) +__OMP_TYPE(Int32) +__OMP_TYPE(Int64) +__OMP_TYPE(Int8Ptr) +__OMP_TYPE(Int16Ptr) +__OMP_TYPE(Int32Ptr) +__OMP_TYPE(Int64Ptr) + +OMP_TYPE(SizeTy, M.getDataLayout().getIntPtrType(Ctx)) +OMP_TYPE(LanemaskTy, getLanemaskType()) + +#define __OMP_PTR_TYPE(NAME, BASE) OMP_TYPE(NAME, BASE->getPointerTo()) + +__OMP_PTR_TYPE(VoidPtr, Int8) +__OMP_PTR_TYPE(VoidPtrPtr, VoidPtr) +__OMP_PTR_TYPE(VoidPtrPtrPtr, VoidPtrPtr) + +__OMP_PTR_TYPE(Int8PtrPtr, Int8Ptr) +__OMP_PTR_TYPE(Int8PtrPtrPtr, Int8PtrPtr) + +#undef __OMP_PTR_TYPE + +#undef __OMP_TYPE +#undef OMP_TYPE + +///} + +/// array types +/// +///{ + +#ifndef OMP_ARRAY_TYPE +#define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) +#endif + +#define __OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) \ + OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) + +__OMP_ARRAY_TYPE(KmpCriticalName, Int32, 8) + +#undef __OMP_ARRAY_TYPE +#undef OMP_ARRAY_TYPE + +///} + +/// Struct and function types +/// +///{ + +#ifndef OMP_STRUCT_TYPE +#define OMP_STRUCT_TYPE(VarName, StructName, ...) +#endif + +#define __OMP_STRUCT_TYPE(VarName, Name, ...) \ + OMP_STRUCT_TYPE(VarName, "struct." #Name, __VA_ARGS__) + +__OMP_STRUCT_TYPE(Ident, ident_t, Int32, Int32, Int32, Int32, Int8Ptr) +__OMP_STRUCT_TYPE(AsyncInfo, __tgt_async_info, Int8Ptr) + +#undef __OMP_STRUCT_TYPE +#undef OMP_STRUCT_TYPE + +#ifndef OMP_FUNCTION_TYPE +#define OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...) +#endif + +#define __OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...) \ + OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, __VA_ARGS__) + +__OMP_FUNCTION_TYPE(ParallelTask, true, Void, Int32Ptr, Int32Ptr) +__OMP_FUNCTION_TYPE(ReduceFunction, false, Void, VoidPtr, VoidPtr) +__OMP_FUNCTION_TYPE(CopyFunction, false, Void, VoidPtr, VoidPtr) +__OMP_FUNCTION_TYPE(KmpcCtor, false, VoidPtr, VoidPtr) +__OMP_FUNCTION_TYPE(KmpcDtor, false, Void, VoidPtr) +__OMP_FUNCTION_TYPE(KmpcCopyCtor, false, VoidPtr, VoidPtr, VoidPtr) +__OMP_FUNCTION_TYPE(TaskRoutineEntry, false, Int32, Int32, + /* kmp_task_t */ VoidPtr) +__OMP_FUNCTION_TYPE(ShuffleReduce, false, Void, VoidPtr, Int16, Int16, Int16) +__OMP_FUNCTION_TYPE(InterWarpCopy, false, Void, VoidPtr, Int32) +__OMP_FUNCTION_TYPE(GlobalList, false, Void, VoidPtr, Int32, VoidPtr) + +#undef __OMP_FUNCTION_TYPE +#undef OMP_FUNCTION_TYPE + +///} + +/// Internal Control Variables information +/// +///{ + +#ifndef ICV_INIT_VALUE +#define ICV_INIT_VALUE(Enum, Name) +#endif + +#define __ICV_INIT_VALUE(Name) ICV_INIT_VALUE(ICV_##Name, #Name) + +__ICV_INIT_VALUE(ZERO) +__ICV_INIT_VALUE(FALSE) +__ICV_INIT_VALUE(IMPLEMENTATION_DEFINED) +__ICV_INIT_VALUE(LAST) + +#undef __ICV_INIT_VALUE +#undef ICV_INIT_VALUE + +#ifndef ICV_DATA_ENV +#define ICV_DATA_ENV(Enum, Name, EnvVarName, Init) +#endif + +#define __ICV_DATA_ENV(Name, EnvVarName, Init) \ + ICV_DATA_ENV(ICV_##Name, #Name, #EnvVarName, Init) + +__ICV_DATA_ENV(nthreads, OMP_NUM_THREADS, ICV_IMPLEMENTATION_DEFINED) +__ICV_DATA_ENV(active_levels, NONE, ICV_ZERO) +__ICV_DATA_ENV(cancel, OMP_CANCELLATION, ICV_FALSE) +__ICV_DATA_ENV(proc_bind, OMP_PROC_BIND, ICV_IMPLEMENTATION_DEFINED) +__ICV_DATA_ENV(__last, last, ICV_LAST) + +#undef __ICV_DATA_ENV +#undef ICV_DATA_ENV + +#ifndef ICV_RT_SET +#define ICV_RT_SET(Name, RTL) +#endif + +#define __ICV_RT_SET(Name, RTL) ICV_RT_SET(ICV_##Name, OMPRTL_##RTL) + +__ICV_RT_SET(nthreads, omp_set_num_threads) + +#undef __ICV_RT_SET +#undef ICV_RT_SET + +#ifndef ICV_RT_GET +#define ICV_RT_GET(Name, RTL) +#endif + +#define __ICV_RT_GET(Name, RTL) ICV_RT_GET(ICV_##Name, OMPRTL_##RTL) + +__ICV_RT_GET(nthreads, omp_get_max_threads) +__ICV_RT_GET(active_levels, omp_get_active_level) +__ICV_RT_GET(cancel, omp_get_cancellation) +__ICV_RT_GET(proc_bind, omp_get_proc_bind) + +#undef __ICV_RT_GET +#undef ICV_RT_GET + +///} + +/// Runtime library function (and their attributes) +/// +///{ + +#ifndef OMP_RTL +#define OMP_RTL(Enum, Str, IsVarArg, ReturnType, ...) +#endif + +#define __OMP_RTL(Name, IsVarArg, ReturnType, ...) \ + OMP_RTL(OMPRTL_##Name, #Name, IsVarArg, ReturnType, __VA_ARGS__) + + + +__OMP_RTL(__kmpc_barrier, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_cancel, false, Int32, IdentPtr, Int32, Int32) +__OMP_RTL(__kmpc_cancel_barrier, false, Int32, IdentPtr, Int32) +__OMP_RTL(__kmpc_flush, false, Void, IdentPtr) +__OMP_RTL(__kmpc_global_thread_num, false, Int32, IdentPtr) +__OMP_RTL(__kmpc_fork_call, true, Void, IdentPtr, Int32, ParallelTaskPtr) +__OMP_RTL(__kmpc_omp_taskwait, false, Int32, IdentPtr, Int32) +__OMP_RTL(__kmpc_omp_taskyield, false, Int32, IdentPtr, Int32, /* Int */ Int32) +__OMP_RTL(__kmpc_push_num_threads, false, Void, IdentPtr, Int32, + /* Int */ Int32) +__OMP_RTL(__kmpc_push_proc_bind, false, Void, IdentPtr, Int32, /* Int */ Int32) +__OMP_RTL(__kmpc_omp_reg_task_with_affinity, false, Int32, IdentPtr, Int32, + /* kmp_task_t */ VoidPtr, Int32, + /* kmp_task_affinity_info_t */ VoidPtr) + +__OMP_RTL(omp_get_thread_num, false, Int32, ) +__OMP_RTL(omp_get_num_threads, false, Int32, ) +__OMP_RTL(omp_get_max_threads, false, Int32, ) +__OMP_RTL(omp_in_parallel, false, Int32, ) +__OMP_RTL(omp_get_dynamic, false, Int32, ) +__OMP_RTL(omp_get_cancellation, false, Int32, ) +__OMP_RTL(omp_get_nested, false, Int32, ) +__OMP_RTL(omp_get_schedule, false, Void, Int32Ptr, Int32Ptr) +__OMP_RTL(omp_get_thread_limit, false, Int32, ) +__OMP_RTL(omp_get_supported_active_levels, false, Int32, ) +__OMP_RTL(omp_get_max_active_levels, false, Int32, ) +__OMP_RTL(omp_get_level, false, Int32, ) +__OMP_RTL(omp_get_ancestor_thread_num, false, Int32, Int32) +__OMP_RTL(omp_get_team_size, false, Int32, Int32) +__OMP_RTL(omp_get_active_level, false, Int32, ) +__OMP_RTL(omp_in_final, false, Int32, ) +__OMP_RTL(omp_get_proc_bind, false, Int32, ) +__OMP_RTL(omp_get_num_places, false, Int32, ) +__OMP_RTL(omp_get_num_procs, false, Int32, ) +__OMP_RTL(omp_get_place_proc_ids, false, Void, Int32, Int32Ptr) +__OMP_RTL(omp_get_place_num, false, Int32, ) +__OMP_RTL(omp_get_partition_num_places, false, Int32, ) +__OMP_RTL(omp_get_partition_place_nums, false, Void, Int32Ptr) + +__OMP_RTL(omp_set_num_threads, false, Void, Int32) +__OMP_RTL(omp_set_dynamic, false, Void, Int32) +__OMP_RTL(omp_set_nested, false, Void, Int32) +__OMP_RTL(omp_set_schedule, false, Void, Int32, Int32) +__OMP_RTL(omp_set_max_active_levels, false, Void, Int32) + +__OMP_RTL(__kmpc_master, false, Int32, IdentPtr, Int32) +__OMP_RTL(__kmpc_end_master, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_critical, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy) +__OMP_RTL(__kmpc_critical_with_hint, false, Void, IdentPtr, Int32, + KmpCriticalNamePtrTy, Int32) +__OMP_RTL(__kmpc_end_critical, false, Void, IdentPtr, Int32, + KmpCriticalNamePtrTy) + +__OMP_RTL(__kmpc_begin, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_end, false, Void, IdentPtr) + +__OMP_RTL(__kmpc_reduce, false, Int32, IdentPtr, Int32, Int32, SizeTy, VoidPtr, + ReduceFunctionPtr, KmpCriticalNamePtrTy) +__OMP_RTL(__kmpc_reduce_nowait, false, Int32, IdentPtr, Int32, Int32, SizeTy, + VoidPtr, ReduceFunctionPtr, KmpCriticalNamePtrTy) +__OMP_RTL(__kmpc_end_reduce, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy) +__OMP_RTL(__kmpc_end_reduce_nowait, false, Void, IdentPtr, Int32, + KmpCriticalNamePtrTy) + +__OMP_RTL(__kmpc_ordered, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_end_ordered, false, Void, IdentPtr, Int32) + +__OMP_RTL(__kmpc_for_static_init_4, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32) +__OMP_RTL(__kmpc_for_static_init_4u, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32) +__OMP_RTL(__kmpc_for_static_init_8, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64) +__OMP_RTL(__kmpc_for_static_init_8u, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64) +__OMP_RTL(__kmpc_for_static_fini, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_dist_dispatch_init_4, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int32, Int32, Int32, Int32) +__OMP_RTL(__kmpc_dist_dispatch_init_4u, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int32, Int32, Int32, Int32) +__OMP_RTL(__kmpc_dist_dispatch_init_8, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int64, Int64, Int64, Int64) +__OMP_RTL(__kmpc_dist_dispatch_init_8u, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int64, Int64, Int64, Int64) +__OMP_RTL(__kmpc_dispatch_init_4, false, Void, IdentPtr, Int32, Int32, Int32, + Int32, Int32, Int32) +__OMP_RTL(__kmpc_dispatch_init_4u, false, Void, IdentPtr, Int32, Int32, Int32, + Int32, Int32, Int32) +__OMP_RTL(__kmpc_dispatch_init_8, false, Void, IdentPtr, Int32, Int32, Int64, + Int64, Int64, Int64) +__OMP_RTL(__kmpc_dispatch_init_8u, false, Void, IdentPtr, Int32, Int32, Int64, + Int64, Int64, Int64) +__OMP_RTL(__kmpc_dispatch_next_4, false, Int32, IdentPtr, Int32, Int32Ptr, + Int32Ptr, Int32Ptr, Int32Ptr) +__OMP_RTL(__kmpc_dispatch_next_4u, false, Int32, IdentPtr, Int32, Int32Ptr, + Int32Ptr, Int32Ptr, Int32Ptr) +__OMP_RTL(__kmpc_dispatch_next_8, false, Int32, IdentPtr, Int32, Int32Ptr, + Int64Ptr, Int64Ptr, Int64Ptr) +__OMP_RTL(__kmpc_dispatch_next_8u, false, Int32, IdentPtr, Int32, Int32Ptr, + Int64Ptr, Int64Ptr, Int64Ptr) +__OMP_RTL(__kmpc_dispatch_fini_4, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_dispatch_fini_4u, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_dispatch_fini_8, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_dispatch_fini_8u, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_team_static_init_4, false, Void, IdentPtr, Int32, Int32Ptr, + Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32) +__OMP_RTL(__kmpc_team_static_init_4u, false, Void, IdentPtr, Int32, Int32Ptr, + Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32) +__OMP_RTL(__kmpc_team_static_init_8, false, Void, IdentPtr, Int32, Int32Ptr, + Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64) +__OMP_RTL(__kmpc_team_static_init_8u, false, Void, IdentPtr, Int32, Int32Ptr, + Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64) +__OMP_RTL(__kmpc_dist_for_static_init_4, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32) +__OMP_RTL(__kmpc_dist_for_static_init_4u, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32) +__OMP_RTL(__kmpc_dist_for_static_init_8, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64) +__OMP_RTL(__kmpc_dist_for_static_init_8u, false, Void, IdentPtr, Int32, Int32, + Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64) + +__OMP_RTL(__kmpc_single, false, Int32, IdentPtr, Int32) +__OMP_RTL(__kmpc_end_single, false, Void, IdentPtr, Int32) + +__OMP_RTL(__kmpc_omp_task_alloc, false, /* kmp_task_t */ VoidPtr, IdentPtr, + Int32, Int32, SizeTy, SizeTy, TaskRoutineEntryPtr) +__OMP_RTL(__kmpc_omp_task, false, Int32, IdentPtr, Int32, + /* kmp_task_t */ VoidPtr) +__OMP_RTL(__kmpc_end_taskgroup, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_taskgroup, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_omp_task_begin_if0, false, Void, IdentPtr, Int32, + /* kmp_task_t */ VoidPtr) +__OMP_RTL(__kmpc_omp_task_complete_if0, false, Void, IdentPtr, Int32, + /* kmp_tasK_t */ VoidPtr) +__OMP_RTL(__kmpc_omp_task_with_deps, false, Int32, IdentPtr, Int32, + /* kmp_task_t */ VoidPtr, Int32, + /* kmp_depend_info_t */ VoidPtr, Int32, + /* kmp_depend_info_t */ VoidPtr) +__OMP_RTL(__kmpc_taskloop, false, Void, IdentPtr, /* Int */ Int32, VoidPtr, + /* Int */ Int32, Int64Ptr, Int64Ptr, Int64, /* Int */ Int32, + /* Int */ Int32, Int64, VoidPtr) +__OMP_RTL(__kmpc_omp_target_task_alloc, false, /* kmp_task_t */ VoidPtr, + IdentPtr, Int32, Int32, SizeTy, SizeTy, TaskRoutineEntryPtr, Int64) +__OMP_RTL(__kmpc_taskred_modifier_init, false, /* kmp_taskgroup */ VoidPtr, + IdentPtr, /* Int */ Int32, /* Int */ Int32, /* Int */ Int32, VoidPtr) +__OMP_RTL(__kmpc_taskred_init, false, /* kmp_taskgroup */ VoidPtr, + /* Int */ Int32, /* Int */ Int32, VoidPtr) +__OMP_RTL(__kmpc_task_reduction_modifier_fini, false, Void, IdentPtr, + /* Int */ Int32, /* Int */ Int32) +__OMP_RTL(__kmpc_task_reduction_get_th_data, false, VoidPtr, Int32, VoidPtr, + VoidPtr) +__OMP_RTL(__kmpc_task_reduction_init, false, VoidPtr, Int32, Int32, VoidPtr) +__OMP_RTL(__kmpc_task_reduction_modifier_init, false, VoidPtr, VoidPtr, Int32, + Int32, Int32, VoidPtr) +__OMP_RTL(__kmpc_proxy_task_completed_ooo, false, Void, VoidPtr) + +__OMP_RTL(__kmpc_omp_wait_deps, false, Void, IdentPtr, Int32, Int32, + /* kmp_depend_info_t */ VoidPtr, Int32, VoidPtr) +__OMP_RTL(__kmpc_cancellationpoint, false, Int32, IdentPtr, Int32, Int32) + +__OMP_RTL(__kmpc_fork_teams, true, Void, IdentPtr, Int32, ParallelTaskPtr) +__OMP_RTL(__kmpc_push_num_teams, false, Void, IdentPtr, Int32, Int32, Int32) + +__OMP_RTL(__kmpc_copyprivate, false, Void, IdentPtr, Int32, SizeTy, VoidPtr, + CopyFunctionPtr, Int32) +__OMP_RTL(__kmpc_threadprivate_cached, false, VoidPtr, IdentPtr, Int32, VoidPtr, + SizeTy, VoidPtrPtrPtr) +__OMP_RTL(__kmpc_threadprivate_register, false, Void, IdentPtr, VoidPtr, + KmpcCtorPtr, KmpcCopyCtorPtr, KmpcDtorPtr) + +__OMP_RTL(__kmpc_doacross_init, false, Void, IdentPtr, Int32, Int32, + /* kmp_dim */ VoidPtr) +__OMP_RTL(__kmpc_doacross_post, false, Void, IdentPtr, Int32, Int64Ptr) +__OMP_RTL(__kmpc_doacross_wait, false, Void, IdentPtr, Int32, Int64Ptr) +__OMP_RTL(__kmpc_doacross_fini, false, Void, IdentPtr, Int32) + +__OMP_RTL(__kmpc_alloc, false, VoidPtr, /* Int */ Int32, SizeTy, VoidPtr) +__OMP_RTL(__kmpc_free, false, Void, /* Int */ Int32, VoidPtr, VoidPtr) + +__OMP_RTL(__kmpc_init_allocator, false, /* omp_allocator_handle_t */ VoidPtr, + /* Int */ Int32, /* omp_memespace_handle_t */ VoidPtr, + /* Int */ Int32, /* omp_alloctrait_t */ VoidPtr) +__OMP_RTL(__kmpc_destroy_allocator, false, Void, /* Int */ Int32, + /* omp_allocator_handle_t */ VoidPtr) + +__OMP_RTL(__kmpc_push_target_tripcount_mapper, false, Void, IdentPtr, Int64, Int64) +__OMP_RTL(__tgt_target_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32, VoidPtrPtr, + VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr) +__OMP_RTL(__tgt_target_nowait_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32, + VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr) +__OMP_RTL(__tgt_target_teams_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32, + VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr, Int32, Int32) +__OMP_RTL(__tgt_target_teams_nowait_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32, + VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr, Int32, Int32) +__OMP_RTL(__tgt_register_requires, false, Void, Int64) +__OMP_RTL(__tgt_target_data_begin_mapper, false, Void, IdentPtr, Int64, Int32, VoidPtrPtr, + VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr) +__OMP_RTL(__tgt_target_data_begin_nowait_mapper, false, Void, IdentPtr, Int64, Int32, + VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr) +__OMP_RTL(__tgt_target_data_begin_mapper_issue, false, Void, IdentPtr, Int64, Int32, + VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr, AsyncInfoPtr) +__OMP_RTL(__tgt_target_data_begin_mapper_wait, false, Void, Int64, AsyncInfoPtr) +__OMP_RTL(__tgt_target_data_end_mapper, false, Void, IdentPtr, Int64, Int32, VoidPtrPtr, + VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr) +__OMP_RTL(__tgt_target_data_end_nowait_mapper, false, Void, IdentPtr, Int64, Int32, + VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr) +__OMP_RTL(__tgt_target_data_update_mapper, false, Void, IdentPtr, Int64, Int32, + VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr) +__OMP_RTL(__tgt_target_data_update_nowait_mapper, false, Void, IdentPtr, Int64, Int32, + VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr) +__OMP_RTL(__tgt_mapper_num_components, false, Int64, VoidPtr) +__OMP_RTL(__tgt_push_mapper_component, false, Void, VoidPtr, VoidPtr, VoidPtr, + Int64, Int64, VoidPtr) +__OMP_RTL(__kmpc_task_allow_completion_event, false, VoidPtr, IdentPtr, + /* Int */ Int32, /* kmp_task_t */ VoidPtr) + +/// OpenMP Device runtime functions +__OMP_RTL(__kmpc_kernel_init, false, Void, Int32, Int16) +__OMP_RTL(__kmpc_kernel_deinit, false, Void, Int16) +__OMP_RTL(__kmpc_spmd_kernel_init, false, Void, Int32, Int16) +__OMP_RTL(__kmpc_spmd_kernel_deinit_v2, false, Void, Int16) +__OMP_RTL(__kmpc_kernel_prepare_parallel, false, Void, VoidPtr) +__OMP_RTL(__kmpc_kernel_parallel, false, Int1, VoidPtrPtr) +__OMP_RTL(__kmpc_kernel_end_parallel, false, Void, ) +__OMP_RTL(__kmpc_serialized_parallel, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_end_serialized_parallel, false, Void, IdentPtr, Int32) +__OMP_RTL(__kmpc_shuffle_int32, false, Int32, Int32, Int16, Int16) +__OMP_RTL(__kmpc_nvptx_parallel_reduce_nowait_v2, false, Int32, IdentPtr, Int32, + Int32, SizeTy, VoidPtr, ShuffleReducePtr, InterWarpCopyPtr) +__OMP_RTL(__kmpc_nvptx_end_reduce_nowait, false, Void, Int32) +__OMP_RTL(__kmpc_nvptx_teams_reduce_nowait_v2, false, Int32, IdentPtr, Int32, + VoidPtr, Int32, VoidPtr, ShuffleReducePtr, InterWarpCopyPtr, + GlobalListPtr, GlobalListPtr, GlobalListPtr, GlobalListPtr) + +__OMP_RTL(__kmpc_shuffle_int64, false, Int64, Int64, Int16, Int16) +__OMP_RTL(__kmpc_data_sharing_init_stack, false, Void, ) +__OMP_RTL(__kmpc_data_sharing_init_stack_spmd, false, Void, ) + +__OMP_RTL(__kmpc_data_sharing_coalesced_push_stack, false, VoidPtr, SizeTy, Int16) +__OMP_RTL(__kmpc_data_sharing_push_stack, false, VoidPtr, SizeTy, Int16) +__OMP_RTL(__kmpc_data_sharing_pop_stack, false, Void, VoidPtr) +__OMP_RTL(__kmpc_begin_sharing_variables, false, Void, VoidPtrPtrPtr, SizeTy) +__OMP_RTL(__kmpc_end_sharing_variables, false, Void, ) +__OMP_RTL(__kmpc_get_shared_variables, false, Void, VoidPtrPtrPtr) +__OMP_RTL(__kmpc_parallel_level, false, Int16, IdentPtr, Int32) +__OMP_RTL(__kmpc_is_spmd_exec_mode, false, Int8, ) +__OMP_RTL(__kmpc_get_team_static_memory, false, Void, Int16, VoidPtr, SizeTy, + Int16, VoidPtrPtr) +__OMP_RTL(__kmpc_restore_team_static_memory, false, Void, Int16, Int16) +__OMP_RTL(__kmpc_barrier_simple_spmd, false, Void, IdentPtr, Int32) + +__OMP_RTL(__kmpc_warp_active_thread_mask, false, LanemaskTy,) +__OMP_RTL(__kmpc_syncwarp, false, Void, LanemaskTy) + +__OMP_RTL(__last, false, Void, ) + +#undef __OMP_RTL +#undef OMP_RTL + +#define ParamAttrs(...) ArrayRef<AttributeSet>({__VA_ARGS__}) +#define EnumAttr(Kind) Attribute::get(Ctx, Attribute::AttrKind::Kind) +#define EnumAttrInt(Kind, N) Attribute::get(Ctx, Attribute::AttrKind::Kind, N) +#define AttributeSet(...) \ + AttributeSet::get(Ctx, ArrayRef<Attribute>({__VA_ARGS__})) + +#ifndef OMP_ATTRS_SET +#define OMP_ATTRS_SET(VarName, AttrSet) +#endif + +#define __OMP_ATTRS_SET(VarName, AttrSet) OMP_ATTRS_SET(VarName, AttrSet) + +__OMP_ATTRS_SET(GetterAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(ReadOnly), + EnumAttr(NoSync), EnumAttr(NoFree), + EnumAttr(InaccessibleMemOnly), + EnumAttr(WillReturn)) + : AttributeSet(EnumAttr(NoUnwind))) +__OMP_ATTRS_SET(GetterArgWriteAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync), + EnumAttr(NoFree), + EnumAttr(InaccessibleMemOrArgMemOnly), + EnumAttr(WillReturn)) + : AttributeSet(EnumAttr(NoUnwind))) +__OMP_ATTRS_SET(SetterAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(WriteOnly), + EnumAttr(NoSync), EnumAttr(NoFree), + EnumAttr(InaccessibleMemOnly), + EnumAttr(WillReturn)) + : AttributeSet(EnumAttr(NoUnwind))) + +__OMP_ATTRS_SET(DefaultAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync), + EnumAttr(WillReturn), EnumAttr(NoFree)) + : AttributeSet(EnumAttr(NoUnwind))) + +__OMP_ATTRS_SET(BarrierAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(Convergent)) + : AttributeSet(EnumAttr(NoUnwind), EnumAttr(Convergent))) + +__OMP_ATTRS_SET(InaccessibleArgOnlyAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync), + EnumAttr(InaccessibleMemOrArgMemOnly), + EnumAttr(WillReturn), EnumAttr(NoFree)) + : AttributeSet(EnumAttr(NoUnwind))) + +#if 0 +__OMP_ATTRS_SET(InaccessibleOnlyAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync), + EnumAttr(InaccessibleMemOnly), + EnumAttr(WillReturn), EnumAttr(NoFree)) + : AttributeSet(EnumAttr(NoUnwind))) +#endif + +__OMP_ATTRS_SET(AllocAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync), + EnumAttr(WillReturn)) + : AttributeSet(EnumAttr(NoUnwind))) + +__OMP_ATTRS_SET(ForkAttrs, OptimisticAttributes + ? AttributeSet(EnumAttr(NoUnwind)) + : AttributeSet(EnumAttr(NoUnwind))) + +__OMP_ATTRS_SET(ReadOnlyPtrAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(ReadOnly), EnumAttr(NoFree), + EnumAttr(NoCapture)) + : AttributeSet()) + +#if 0 +__OMP_ATTRS_SET(WriteOnlyPtrAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(WriteOnly), EnumAttr(NoFree), + EnumAttr(NoCapture)) + : AttributeSet()) +#endif + +__OMP_ATTRS_SET(ArgPtrAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoCapture), EnumAttr(NoFree)) + : AttributeSet()) + +__OMP_ATTRS_SET(ReturnPtrAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoAlias)) + : AttributeSet()) + +#if 0 +__OMP_ATTRS_SET(ReturnAlignedPtrAttrs, + OptimisticAttributes + ? AttributeSet(EnumAttr(NoAlias), EnumAttrInt(Alignment, 8), + EnumAttrInt(DereferenceableOrNull, 8)) + : AttributeSet()) +#endif + +#undef __OMP_ATTRS_SET +#undef OMP_ATTRS_SET + +#ifndef OMP_RTL_ATTRS +#define OMP_RTL_ATTRS(Enum, FnAttrSet, RetAttrSet, ArgAttrSets) +#endif + +#define __OMP_RTL_ATTRS(Name, FnAttrSet, RetAttrSet, ArgAttrSets) \ + OMP_RTL_ATTRS(OMPRTL_##Name, FnAttrSet, RetAttrSet, ArgAttrSets) + +__OMP_RTL_ATTRS(__kmpc_barrier, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_barrier_simple_spmd, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_warp_active_thread_mask, BarrierAttrs, AttributeSet(), + ParamAttrs()) +__OMP_RTL_ATTRS(__kmpc_syncwarp, BarrierAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(__kmpc_cancel, InaccessibleArgOnlyAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_cancel_barrier, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_flush, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_global_thread_num, GetterAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_fork_call, ForkAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_omp_taskwait, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_omp_taskyield, InaccessibleArgOnlyAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_push_num_threads, InaccessibleArgOnlyAttrs, + AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_push_proc_bind, InaccessibleArgOnlyAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_serialized_parallel, InaccessibleArgOnlyAttrs, + AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_end_serialized_parallel, InaccessibleArgOnlyAttrs, + AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_omp_reg_task_with_affinity, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs, + AttributeSet(), ReadOnlyPtrAttrs)) + +__OMP_RTL_ATTRS(omp_get_thread_num, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_num_threads, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_max_threads, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_in_parallel, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_dynamic, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_cancellation, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_nested, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS( + omp_get_schedule, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(AttributeSet(EnumAttr(NoCapture), EnumAttr(WriteOnly)), + AttributeSet(EnumAttr(NoCapture), EnumAttr(WriteOnly)))) +__OMP_RTL_ATTRS(omp_get_thread_limit, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_supported_active_levels, GetterAttrs, AttributeSet(), + ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_max_active_levels, GetterAttrs, AttributeSet(), + ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_level, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_ancestor_thread_num, GetterAttrs, AttributeSet(), + ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_team_size, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_active_level, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_in_final, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_proc_bind, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_num_places, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_num_procs, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_place_proc_ids, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(AttributeSet(), AttributeSet(EnumAttr(NoCapture), + EnumAttr(WriteOnly)))) +__OMP_RTL_ATTRS(omp_get_place_num, GetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_partition_num_places, GetterAttrs, AttributeSet(), + ParamAttrs()) +__OMP_RTL_ATTRS(omp_get_partition_place_nums, GetterAttrs, AttributeSet(), + ParamAttrs()) + +__OMP_RTL_ATTRS(omp_set_num_threads, SetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_set_dynamic, SetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_set_nested, SetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_set_schedule, SetterAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(omp_set_max_active_levels, SetterAttrs, AttributeSet(), + ParamAttrs()) + +__OMP_RTL_ATTRS(__kmpc_master, InaccessibleArgOnlyAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_end_master, InaccessibleArgOnlyAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_critical, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_critical_with_hint, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_end_critical, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet())) + +__OMP_RTL_ATTRS(__kmpc_begin, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_end, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) + +__OMP_RTL_ATTRS(__kmpc_reduce, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + AttributeSet(), ReadOnlyPtrAttrs, AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_reduce_nowait, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + AttributeSet(), ReadOnlyPtrAttrs, AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_end_reduce, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_end_reduce_nowait, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet())) + +__OMP_RTL_ATTRS(__kmpc_ordered, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_end_ordered, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) + +__OMP_RTL_ATTRS(__kmpc_for_static_init_4, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, + AttributeSet(), AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_for_static_init_4u, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, + AttributeSet(), AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_for_static_init_8, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, + AttributeSet(), AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_for_static_init_8u, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, + AttributeSet(), AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_for_static_fini, InaccessibleArgOnlyAttrs, + AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_4, GetterArgWriteAttrs, + AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_4u, GetterArgWriteAttrs, + AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_8, GetterArgWriteAttrs, + AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_8u, GetterArgWriteAttrs, + AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_init_4, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_init_4u, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_init_8, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_init_8u, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_next_4, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs, + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_next_4u, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs, + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_next_8, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs, + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_next_8u, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs, + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_fini_4, InaccessibleArgOnlyAttrs, + AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_fini_4u, InaccessibleArgOnlyAttrs, + AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_fini_8, InaccessibleArgOnlyAttrs, + AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dispatch_fini_8u, InaccessibleArgOnlyAttrs, + AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_team_static_init_4, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs, + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_team_static_init_4u, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs, + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_team_static_init_8, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs, + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_team_static_init_8u, GetterArgWriteAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs, + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_4, GetterArgWriteAttrs, + AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, + ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_4u, GetterArgWriteAttrs, + AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, + ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_8, GetterArgWriteAttrs, + AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, + ArgPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_8u, GetterArgWriteAttrs, + AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, + ArgPtrAttrs)) + +__OMP_RTL_ATTRS(__kmpc_single, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_end_single, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) + +__OMP_RTL_ATTRS(__kmpc_omp_task_alloc, DefaultAttrs, ReturnPtrAttrs, + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + AttributeSet(), AttributeSet(), ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_omp_task, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_end_taskgroup, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_taskgroup, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_omp_task_begin_if0, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_omp_task_complete_if0, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_omp_task_with_deps, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + AttributeSet(), ReadOnlyPtrAttrs, AttributeSet(), + ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_taskloop, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + AttributeSet(), ArgPtrAttrs, ArgPtrAttrs, + AttributeSet(), AttributeSet(), AttributeSet(), + AttributeSet(), AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_omp_target_task_alloc, DefaultAttrs, ReturnPtrAttrs, + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + AttributeSet(), AttributeSet(), ReadOnlyPtrAttrs, + AttributeSet())) +__OMP_RTL_ATTRS(__kmpc_taskred_modifier_init, DefaultAttrs, ReturnPtrAttrs, + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_taskred_init, DefaultAttrs, AttributeSet(), ParamAttrs()) +__OMP_RTL_ATTRS(__kmpc_task_reduction_modifier_fini, BarrierAttrs, + AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_task_reduction_get_th_data, DefaultAttrs, ReturnPtrAttrs, + ParamAttrs()) +__OMP_RTL_ATTRS(__kmpc_task_reduction_init, DefaultAttrs, ReturnPtrAttrs, + ParamAttrs()) +__OMP_RTL_ATTRS(__kmpc_task_reduction_modifier_init, DefaultAttrs, + ReturnPtrAttrs, ParamAttrs()) +__OMP_RTL_ATTRS(__kmpc_proxy_task_completed_ooo, DefaultAttrs, AttributeSet(), + ParamAttrs()) + +__OMP_RTL_ATTRS(__kmpc_omp_wait_deps, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_cancellationpoint, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) + +__OMP_RTL_ATTRS(__kmpc_fork_teams, ForkAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_push_num_teams, InaccessibleArgOnlyAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) + +__OMP_RTL_ATTRS(__kmpc_copyprivate, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(), + ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_threadprivate_cached, DefaultAttrs, ReturnPtrAttrs, + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_threadprivate_register, DefaultAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs, + ReadOnlyPtrAttrs, ReadOnlyPtrAttrs)) + +__OMP_RTL_ATTRS(__kmpc_doacross_init, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_doacross_post, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_doacross_wait, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs)) +__OMP_RTL_ATTRS(__kmpc_doacross_fini, BarrierAttrs, AttributeSet(), + ParamAttrs(ReadOnlyPtrAttrs)) + +__OMP_RTL_ATTRS(__kmpc_alloc, DefaultAttrs, ReturnPtrAttrs, {}) +__OMP_RTL_ATTRS(__kmpc_free, AllocAttrs, AttributeSet(), {}) + +__OMP_RTL_ATTRS(__kmpc_init_allocator, DefaultAttrs, ReturnPtrAttrs, {}) +__OMP_RTL_ATTRS(__kmpc_destroy_allocator, AllocAttrs, AttributeSet(), {}) + +__OMP_RTL_ATTRS(__kmpc_push_target_tripcount_mapper, SetterAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_mapper, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_nowait_mapper, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_teams_mapper, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_teams_nowait_mapper, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_register_requires, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_data_begin_mapper, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_data_begin_nowait_mapper, ForkAttrs, + AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_data_end_mapper, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_data_end_nowait_mapper, ForkAttrs, + AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_data_update_mapper, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_target_data_update_nowait_mapper, ForkAttrs, + AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_mapper_num_components, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__tgt_push_mapper_component, ForkAttrs, AttributeSet(), {}) +__OMP_RTL_ATTRS(__kmpc_task_allow_completion_event, DefaultAttrs, + ReturnPtrAttrs, ParamAttrs(ReadOnlyPtrAttrs)) + +#undef __OMP_RTL_ATTRS +#undef OMP_RTL_ATTRS +#undef AttributeSet +#undef EnumAttr +#undef EnumAttrInt +#undef ParamAttrs + +///} + +/// KMP ident_t bit flags +/// +/// In accordance with the values in `openmp/runtime/src/kmp.h`. +/// +///{ + +#ifndef OMP_IDENT_FLAG +#define OMP_IDENT_FLAG(Enum, Str, Value) +#endif + +#define __OMP_IDENT_FLAG(Name, Value) \ + OMP_IDENT_FLAG(OMP_IDENT_FLAG_##Name, #Name, Value) + +__OMP_IDENT_FLAG(KMPC, 0x02) +__OMP_IDENT_FLAG(BARRIER_EXPL, 0x20) +__OMP_IDENT_FLAG(BARRIER_IMPL, 0x0040) +__OMP_IDENT_FLAG(BARRIER_IMPL_MASK, 0x01C0) +__OMP_IDENT_FLAG(BARRIER_IMPL_FOR, 0x0040) +__OMP_IDENT_FLAG(BARRIER_IMPL_SECTIONS, 0x00C0) +__OMP_IDENT_FLAG(BARRIER_IMPL_SINGLE, 0x0140) +__OMP_IDENT_FLAG(BARRIER_IMPL_WORKSHARE, 0x01C0) + +#undef __OMP_IDENT_FLAG +#undef OMP_IDENT_FLAG + +///} + +/// KMP cancel kind +/// +///{ + +#ifndef OMP_CANCEL_KIND +#define OMP_CANCEL_KIND(Enum, Str, DirectiveEnum, Value) +#endif + +#define __OMP_CANCEL_KIND(Name, Value) \ + OMP_CANCEL_KIND(OMP_CANCEL_KIND_##Name, #Name, OMPD_##Name, Value) + +__OMP_CANCEL_KIND(parallel, 1) +__OMP_CANCEL_KIND(for, 2) +__OMP_CANCEL_KIND(sections, 3) +__OMP_CANCEL_KIND(taskgroup, 4) + +#undef __OMP_CANCEL_KIND +#undef OMP_CANCEL_KIND + +///} + +/// Default kinds +/// +///{ + +#ifndef OMP_DEFAULT_KIND +#define OMP_DEFAULT_KIND(Enum, Str) +#endif + +#define __OMP_DEFAULT_KIND(Name) OMP_DEFAULT_KIND(OMP_DEFAULT_##Name, #Name) + +__OMP_DEFAULT_KIND(none) +__OMP_DEFAULT_KIND(shared) +__OMP_DEFAULT_KIND(firstprivate) +__OMP_DEFAULT_KIND(unknown) + +#undef __OMP_DEFAULT_KIND +#undef OMP_DEFAULT_KIND + +///} + +/// Proc bind kinds +/// +///{ + +#ifndef OMP_PROC_BIND_KIND +#define OMP_PROC_BIND_KIND(Enum, Str, Value) +#endif + +#define __OMP_PROC_BIND_KIND(Name, Value) \ + OMP_PROC_BIND_KIND(OMP_PROC_BIND_##Name, #Name, Value) + +__OMP_PROC_BIND_KIND(master, 2) +__OMP_PROC_BIND_KIND(close, 3) +__OMP_PROC_BIND_KIND(spread, 4) +__OMP_PROC_BIND_KIND(default, 6) +__OMP_PROC_BIND_KIND(unknown, 7) + +#undef __OMP_PROC_BIND_KIND +#undef OMP_PROC_BIND_KIND + +///} + +/// OpenMP context related definitions: +/// - trait set selector +/// - trait selector +/// - trait property +/// +///{ + +#ifndef OMP_TRAIT_SET +#define OMP_TRAIT_SET(Enum, Str) +#endif +#ifndef OMP_TRAIT_SELECTOR +#define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, RequiresProperty) +#endif +#ifndef OMP_TRAIT_PROPERTY +#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) +#endif +#ifndef OMP_LAST_TRAIT_PROPERTY +#define OMP_LAST_TRAIT_PROPERTY(Enum) +#endif + +#define __OMP_TRAIT_SET(Name) OMP_TRAIT_SET(Name, #Name) +#define __OMP_TRAIT_SELECTOR(TraitSet, Name, RequiresProperty) \ + OMP_TRAIT_SELECTOR(TraitSet##_##Name, TraitSet, #Name, RequiresProperty) +#define __OMP_TRAIT_SELECTOR_AND_PROPERTY(TraitSet, Name) \ + OMP_TRAIT_SELECTOR(TraitSet##_##Name, TraitSet, #Name, false) \ + OMP_TRAIT_PROPERTY(TraitSet##_##Name##_##Name, TraitSet, TraitSet##_##Name, \ + #Name) +#define __OMP_TRAIT_PROPERTY(TraitSet, TraitSelector, Name) \ + OMP_TRAIT_PROPERTY(TraitSet##_##TraitSelector##_##Name, TraitSet, \ + TraitSet##_##TraitSelector, #Name) + +// "invalid" must go first. +OMP_TRAIT_SET(invalid, "invalid") +OMP_TRAIT_SELECTOR(invalid, invalid, "invalid", false) +OMP_TRAIT_PROPERTY(invalid, invalid, invalid, "invalid") + +__OMP_TRAIT_SET(construct) +__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, target) +__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, teams) +__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, parallel) +__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, for) +__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, simd) + +__OMP_TRAIT_SET(device) + +__OMP_TRAIT_SELECTOR(device, kind, true) + +__OMP_TRAIT_PROPERTY(device, kind, host) +__OMP_TRAIT_PROPERTY(device, kind, nohost) +__OMP_TRAIT_PROPERTY(device, kind, cpu) +__OMP_TRAIT_PROPERTY(device, kind, gpu) +__OMP_TRAIT_PROPERTY(device, kind, fpga) +__OMP_TRAIT_PROPERTY(device, kind, any) + +__OMP_TRAIT_SELECTOR(device, arch, true) + +__OMP_TRAIT_PROPERTY(device, arch, arm) +__OMP_TRAIT_PROPERTY(device, arch, armeb) +__OMP_TRAIT_PROPERTY(device, arch, aarch64) +__OMP_TRAIT_PROPERTY(device, arch, aarch64_be) +__OMP_TRAIT_PROPERTY(device, arch, aarch64_32) +__OMP_TRAIT_PROPERTY(device, arch, ppc) +__OMP_TRAIT_PROPERTY(device, arch, ppcle) +__OMP_TRAIT_PROPERTY(device, arch, ppc64) +__OMP_TRAIT_PROPERTY(device, arch, ppc64le) +__OMP_TRAIT_PROPERTY(device, arch, x86) +__OMP_TRAIT_PROPERTY(device, arch, x86_64) +__OMP_TRAIT_PROPERTY(device, arch, amdgcn) +__OMP_TRAIT_PROPERTY(device, arch, nvptx) +__OMP_TRAIT_PROPERTY(device, arch, nvptx64) + +__OMP_TRAIT_SET(implementation) + +__OMP_TRAIT_SELECTOR(implementation, vendor, true) + +__OMP_TRAIT_PROPERTY(implementation, vendor, amd) +__OMP_TRAIT_PROPERTY(implementation, vendor, arm) +__OMP_TRAIT_PROPERTY(implementation, vendor, bsc) +__OMP_TRAIT_PROPERTY(implementation, vendor, cray) +__OMP_TRAIT_PROPERTY(implementation, vendor, fujitsu) +__OMP_TRAIT_PROPERTY(implementation, vendor, gnu) +__OMP_TRAIT_PROPERTY(implementation, vendor, ibm) +__OMP_TRAIT_PROPERTY(implementation, vendor, intel) +__OMP_TRAIT_PROPERTY(implementation, vendor, llvm) +__OMP_TRAIT_PROPERTY(implementation, vendor, pgi) +__OMP_TRAIT_PROPERTY(implementation, vendor, ti) +__OMP_TRAIT_PROPERTY(implementation, vendor, unknown) + +__OMP_TRAIT_SELECTOR(implementation, extension, true) +__OMP_TRAIT_PROPERTY(implementation, extension, match_all) +__OMP_TRAIT_PROPERTY(implementation, extension, match_any) +__OMP_TRAIT_PROPERTY(implementation, extension, match_none) +__OMP_TRAIT_PROPERTY(implementation, extension, disable_implicit_base) +__OMP_TRAIT_PROPERTY(implementation, extension, allow_templates) + +__OMP_TRAIT_SET(user) + +__OMP_TRAIT_SELECTOR(user, condition, true) + +__OMP_TRAIT_PROPERTY(user, condition, true) +__OMP_TRAIT_PROPERTY(user, condition, false) +__OMP_TRAIT_PROPERTY(user, condition, unknown) + + +// Note that we put isa last so that the other conditions are checked first. +// This allows us to issue warnings wrt. isa only if we match otherwise. +__OMP_TRAIT_SELECTOR(device, isa, true) + +// We use "__ANY" as a placeholder in the isa property to denote the +// conceptual "any", not the literal `any` used in kind. The string we +// we use is not important except that it will show up in diagnostics. +OMP_TRAIT_PROPERTY(device_isa___ANY, device, device_isa, + "<any, entirely target dependent>") + + +#undef OMP_TRAIT_SET +#undef __OMP_TRAIT_SET +///} + +/// Traits for the requires directive +/// +/// These will (potentially) become trait selectors for the OpenMP context if +/// the OMP_REQUIRES_TRAIT macro is not defined. +/// +///{ + +#ifdef OMP_REQUIRES_TRAIT +#define __OMP_REQUIRES_TRAIT(Name) \ + OMP_REQUIRES_TRAIT(OMP_REQUIRES_TRAIT_##Name, #Name) +#else +#define __OMP_REQUIRES_TRAIT(Name) \ + __OMP_TRAIT_SELECTOR_AND_PROPERTY(implementation, Name) +#endif + +__OMP_REQUIRES_TRAIT(unified_address) +__OMP_REQUIRES_TRAIT(unified_shared_memory) +__OMP_REQUIRES_TRAIT(reverse_offload) +__OMP_REQUIRES_TRAIT(dynamic_allocators) +__OMP_REQUIRES_TRAIT(atomic_default_mem_order) + +OMP_LAST_TRAIT_PROPERTY( + implementation_atomic_default_mem_order_atomic_default_mem_order) + +#undef __OMP_TRAIT_SELECTOR_AND_PROPERTY +#undef OMP_TRAIT_SELECTOR +#undef __OMP_TRAIT_SELECTOR +#undef OMP_TRAIT_PROPERTY +#undef OMP_LAST_TRAIT_PROPERTY +#undef __OMP_TRAIT_PROPERTY +#undef __OMP_REQUIRES_TRAIT +#undef OMP_REQUIRES_TRAIT +///} + + +/// Assumption clauses +/// +///{ + +#ifdef OMP_ASSUME_CLAUSE +#define __OMP_ASSUME_CLAUSE(Identifier, StartsWith, HasDirectiveList, HasExpression) \ +OMP_ASSUME_CLAUSE(Identifier, StartsWith, HasDirectiveList, HasExpression) +#else +#define __OMP_ASSUME_CLAUSE(...) +#endif + +__OMP_ASSUME_CLAUSE(llvm::StringLiteral("ext_"), true, false, false) +__OMP_ASSUME_CLAUSE(llvm::StringLiteral("absent"), false, true, false) +__OMP_ASSUME_CLAUSE(llvm::StringLiteral("contains"), false, true, false) +__OMP_ASSUME_CLAUSE(llvm::StringLiteral("holds"), false, false, true) +__OMP_ASSUME_CLAUSE(llvm::StringLiteral("no_openmp"), false, false, false) +__OMP_ASSUME_CLAUSE(llvm::StringLiteral("no_openmp_routines"), false, false, false) +__OMP_ASSUME_CLAUSE(llvm::StringLiteral("no_parallelism"), false, false, false) + +#undef __OMP_ASSUME_CLAUSE +#undef OMP_ASSUME_CLAUSE +///} |