This is an archive of the discontinued LLVM Phabricator instance.

Differential D82982

[openmp] Move isAllowedClauseForDirective to tablegen + add clause version to OMP.td
ClosedPublic

Authored by clementval on Jul 1 2020, 9:41 AM.

Details

Reviewers
jdoerfert
jdenny
Commits
rG65482e8a703d: [openmp] Move isAllowedClauseForDirective to tablegen + add clause version to…
Summary

Generate the isAllowedClauseForDirective function from tablegen. This patch introduce
the VersionedClause in the tablegen file so that clause can be encapsulated in this class to
specify a range of validity on a directive.

VersionedClause has default minVersion, maxVersion so it can be used without them or
minVersion.

Diff Detail

Event Timeline

clementval created this revision.Jul 1 2020, 9:41 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 1 2020, 9:41 AM
Herald added subscribers: llvm-commits, aaron.ballman, sstefan1 and 4 others. · View Herald Transcript
clementval updated this revision to Diff 274857.Jul 1 2020, 10:10 AM

MIssing new line at the end of llvm/test/TableGen/directive2.td

Harbormaster failed remote builds in B62538: Diff 274849!Jul 1 2020, 10:48 AM
Harbormaster failed remote builds in B62540: Diff 274857!Jul 1 2020, 11:23 AM
clementval edited the summary of this revision. (Show Details)Jul 1 2020, 12:27 PM
jdoerfert added a comment.Jul 1 2020, 2:02 PM

I browsed over it and it looks great. Thanks.

@jdenny can you take a look and do the review :)

jdenny added a comment.Jul 6 2020, 10:51 AM

Thanks for working on this.

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

Please add punctuation to all comments.

65

Why not unsigned as in the original?

69

What does "the list" refer to?

llvm/include/llvm/Frontend/OpenMP/OMP.td
278

The closing ] is inconsistently placed here and in some other cases.

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def
1881

This patch loses this TODO and the next one. I'm not sure what they mean. Do we need to keep them?

llvm/test/TableGen/directive1.td
109

I know the original code used a giant if-else block, but shouldn't this be a switch?

llvm/utils/TableGen/DirectiveEmitter.cpp
55–56

Any reason not to call getFormattedName here instead of twice below?

182–184

Call getFormattedName(DefaultName) once here?

215

Hoist getFormattedName(DirectiveName) out of the loop?

224

I'd drop this comment's last two sentences, which don't seem like they will be meaningful after pushing.

297

Why is an empty line needed?

clementval updated this revision to Diff 275788.Jul 6 2020, 12:08 PM
clementval marked 19 inline comments as done.

Address review comments

Harbormaster failed remote builds in B63061: Diff 275788!Jul 6 2020, 12:09 PM
clementval added a comment.Jul 6 2020, 12:09 PM

Thanks for the review @jdenny. The patch is updated with your comments and some comments as well.

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

TableGen type does not have an unsigned type so I went with the closest one.

69

I updated the comment and dropped the list. I think it is clearer now.

llvm/include/llvm/Frontend/OpenMP/OMP.td
278

Good catch. I updated the file as well.

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def
1881

I updated the patch to keep it. Same for depobj.

llvm/test/TableGen/directive1.td
109

The idea was to migrate to TableGen with the exact same code generated and to update this in a follow up patch. It would be replace with at least a switch for the Directive and probably an inner switch for the Clause or we keep the ifs inside the Directives' switch.

llvm/utils/TableGen/DirectiveEmitter.cpp
55–56

Updated in the patch.

182–184

Updated as well.

297

Just to be consistent with clang-format in the generated file.

jdenny marked 2 inline comments as done.Jul 6 2020, 2:14 PM
jdenny added inline comments.
llvm/include/llvm/Frontend/Directive/DirectiveBase.td
65

Ah, I thought I had seen it used elsewhere, but it looks like I'm mistaken.

69

I don't see the change.

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def
1881

@jdoerfert : If I read git blame correctly, you wrote this TODO originally. Can you help us to understand whether it's worth preserving?

llvm/test/TableGen/directive1.td
109

Sure, makes sense to do it in a separate patch.

It seems like both switches makes sense, but the inner switches might benefit from default cases.

llvm/utils/TableGen/DirectiveEmitter.cpp
297

It's surprising that clang-format would require an empty line at the end of the file. Any idea why?

clementval updated this revision to Diff 275837.Jul 6 2020, 2:45 PM
clementval marked 4 inline comments as done.

Address more comment from @jdenny

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

Forgot this one. Sorry.

llvm/utils/TableGen/DirectiveEmitter.cpp
297

Sorry, it is not clang-format but Phabricator which signal a missing empty line at end of file. This is not mandatory and can be removed. The file is generated. I just wanted to be consistent with the style.

Harbormaster failed remote builds in B63087: Diff 275837!Jul 6 2020, 2:52 PM
jdenny added inline comments.Jul 6 2020, 3:15 PM
llvm/utils/TableGen/DirectiveEmitter.cpp
297

Are you referring to, for example, the version of directive2.td on the left side of this diff? Here, phabricator points out that the final line in the file is not newline-terminated. I don't recall seeing phabricator suggest an additional empty line.

Likewise, in EmitDirectivesImpl, the final GenerateIsAllowedClause call already newline-terminates the final line of the generated file, so I don't see a need for an additional empty line.

clementval marked 2 inline comments as done.Jul 6 2020, 3:20 PM
clementval added inline comments.
llvm/utils/TableGen/DirectiveEmitter.cpp
297

Your are correct. I removed this since it was a confusion on my side.

clementval updated this revision to Diff 275850.Jul 6 2020, 3:21 PM
clementval marked an inline comment as done.

Rebase + remove useless new line generation

jdenny accepted this revision.Jul 6 2020, 3:31 PM

LGTM. Thanks for addressing my concerns.

The TODOs we talked about can be handled later, once @jdoerfert replies.

This revision is now accepted and ready to land.Jul 6 2020, 3:31 PM
Harbormaster failed remote builds in B63093: Diff 275850!Jul 6 2020, 3:35 PM
jdenny added a comment.Jul 6 2020, 3:45 PM
In D82982#2134458, @jdenny wrote:

The TODOs we talked about can be handled later, once @jdoerfert replies.

To be clear, by "later", I meant another patch. I think this is ready to land.

clementval updated this revision to Diff 275877.Jul 6 2020, 6:16 PM

Rebase

Harbormaster completed remote builds in B63110: Diff 275877.Jul 6 2020, 7:18 PM
Closed by commit rG65482e8a703d: [openmp] Move isAllowedClauseForDirective to tablegen + add clause version to… (authored by clementval). · Explain WhyJul 6 2020, 7:20 PM
This revision was automatically updated to reflect the committed changes.
jdoerfert added a comment.Jul 7 2020, 4:24 PM
In D82982#2134458, @jdenny wrote:

The TODOs we talked about can be handled later, once @jdoerfert replies.

FWIW, you seem to have a pretty good handle on this (and I am a bit behind in my review list), thanks!

Revision Contents

PathSize
llvm/
include/
llvm/
Frontend/
Directive/
20 lines
OpenMP/
929 lines
3 lines
743 lines
lib/
Frontend/
OpenMP/
11 lines
test/
TableGen/
18 lines
21 lines
utils/
TableGen/
102 lines

Diff 275837

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

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Linesclass Clause<string c> {
// be return in get<LanguageName>ClauseKind instead of their own kind. // be return in get<LanguageName>ClauseKind instead of their own kind.
bit isImplicit = 0; bit isImplicit = 0;
// Set directive used by default when unknown. Function returning the kind // Set directive used by default when unknown. Function returning the kind
// of enumeration will use this clause as the default. // of enumeration will use this clause as the default.
bit isDefault = 0; bit isDefault = 0;
} }
// Information about a specific directive // Hold information about clause validity by version.
jdennyUnsubmitted
Done
ReplyInline Actions

Please add punctuation to all comments.

jdenny: Please add punctuation to all comments.
class VersionedClause<Clause c, int min = 1, int max = 0x7FFFFFFF> {
jdennyUnsubmitted
Done
ReplyInline Actions

Why not unsigned as in the original?

jdenny: Why not unsigned as in the original?
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

TableGen type does not have an unsigned type so I went with the closest one.

clementval: TableGen type does not have an `unsigned` type so I went with the closest one.
jdennyUnsubmitted
Done
ReplyInline Actions

Ah, I thought I had seen it used elsewhere, but it looks like I'm mistaken.

jdenny: Ah, I thought I had seen it used elsewhere, but it looks like I'm mistaken.
// Actual clause.
Clause clause = c;
// Mininum version number where this clause is valid.
jdennyUnsubmitted
Done
ReplyInline Actions

What does "the list" refer to?

jdenny: What does "the list" refer to?
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

I updated the comment and dropped the list. I think it is clearer now.

clementval: I updated the comment and dropped the list. I think it is clearer now.
jdennyUnsubmitted
Done
ReplyInline Actions

I don't see the change.

jdenny: I don't see the change.
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

Forgot this one. Sorry.

clementval: Forgot this one. Sorry.
int minVersion = min;
// Maximum version number where this clause is valid.
int maxVersion = max;
}
// Information about a specific directive.
class Directive<string d> { class Directive<string d> {
// Name of the directive. Can be composite directive sepearted by whitespace. // Name of the directive. Can be composite directive sepearted by whitespace.
string name = d; string name = d;
// Define an alternative name return in get<LanguageName>DirectiveName // Define an alternative name return in get<LanguageName>DirectiveName
// function. // function.
string alternativeName = ""; string alternativeName = "";
// List of allowed clauses for the directive. // List of allowed clauses for the directive.
list<Clause> allowedClauses = ?; list<VersionedClause> allowedClauses = [];
// List of clauses that are allowed to appear only once. // List of clauses that are allowed to appear only once.
list<Clause> allowedOnceClauses = ?; list<VersionedClause> allowedOnceClauses = [];
// List of clauses that are required. // List of clauses that are required.
list<Clause> requiredClauses = ?; list<VersionedClause> requiredClauses = [];
// Set directive used by default when unknown. // Set directive used by default when unknown.
bit isDefault = 0; bit isDefault = 0;
} }

llvm/include/llvm/Frontend/OpenMP/OMP.td

Show First 20 Lines • Show All 190 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Definition of OpenMP directives // Definition of OpenMP directives
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def OMP_ThreadPrivate : Directive<"threadprivate"> {} def OMP_ThreadPrivate : Directive<"threadprivate"> {}
def OMP_Parallel : Directive<"parallel"> { def OMP_Parallel : Directive<"parallel"> {
let allowedClauses = [OMPC_If, OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, let allowedClauses = [
OMPC_Private, OMPC_FirstPrivate, OMPC_Shared, OMPC_Reduction, OMPC_Copyin, VersionedClause<OMPC_If>,
OMPC_Allocate]; 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_Allocate>
];
} }
def OMP_Task : Directive<"task"> { def OMP_Task : Directive<"task"> {
let allowedClauses = [OMPC_If, OMPC_Final, OMPC_Default, OMPC_Private, let allowedClauses = [
OMPC_FirstPrivate, OMPC_Shared, OMPC_Untied, OMPC_Mergeable, OMPC_Depend, VersionedClause<OMPC_If>,
OMPC_Priority, OMPC_InReduction, OMPC_Allocate, OMPC_Detach, VersionedClause<OMPC_Final>,
OMPC_Affinity]; VersionedClause<OMPC_Default>,
VersionedClause<OMPC_Private>,
VersionedClause<OMPC_FirstPrivate>,
VersionedClause<OMPC_Shared>,
VersionedClause<OMPC_Untied>,
VersionedClause<OMPC_Mergeable>,
VersionedClause<OMPC_Depend>,
VersionedClause<OMPC_Priority>,
VersionedClause<OMPC_InReduction>,
VersionedClause<OMPC_Allocate>,
VersionedClause<OMPC_Detach, 50>,
VersionedClause<OMPC_Affinity, 50>
];
} }
def OMP_Simd : Directive<"simd"> { def OMP_Simd : Directive<"simd"> {
let allowedClauses = [OMPC_Private, OMPC_LastPrivate, OMPC_Linear, let allowedClauses = [
OMPC_Aligned, OMPC_SafeLen, OMPC_SimdLen, OMPC_Collapse, OMPC_Reduction, VersionedClause<OMPC_Private>,
OMPC_Allocate, OMPC_If, OMPC_NonTemporal, OMPC_Order]; VersionedClause<OMPC_LastPrivate>,
VersionedClause<OMPC_Linear>,
VersionedClause<OMPC_Aligned>,
VersionedClause<OMPC_SafeLen>,
VersionedClause<OMPC_SimdLen>,
VersionedClause<OMPC_Collapse>,
VersionedClause<OMPC_Reduction>,
VersionedClause<OMPC_Allocate>,
VersionedClause<OMPC_If, 50>,
VersionedClause<OMPC_NonTemporal, 50>,
VersionedClause<OMPC_Order, 50>
];
} }
def OMP_For : Directive<"for"> { def OMP_For : Directive<"for"> {
let allowedClauses = [OMPC_Private, OMPC_LastPrivate, OMPC_FirstPrivate, let allowedClauses = [
OMPC_Reduction, OMPC_Collapse, OMPC_Schedule, OMPC_Ordered, OMPC_NoWait, VersionedClause<OMPC_Private>,
OMPC_Linear, OMPC_Allocate, OMPC_Order]; 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_Sections : Directive<"sections"> { def OMP_Sections : Directive<"sections"> {
let allowedClauses = [OMPC_Private, OMPC_LastPrivate, OMPC_FirstPrivate, let allowedClauses = [
OMPC_Reduction, OMPC_NoWait, OMPC_Allocate]; 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_Section : Directive<"section"> {}
def OMP_Single : Directive<"single"> { def OMP_Single : Directive<"single"> {
let allowedClauses = [OMPC_Private, OMPC_FirstPrivate, OMPC_CopyPrivate, let allowedClauses = [
OMPC_NoWait, OMPC_Allocate]; VersionedClause<OMPC_Private>,
VersionedClause<OMPC_FirstPrivate>,
VersionedClause<OMPC_CopyPrivate>,
VersionedClause<OMPC_NoWait>,
VersionedClause<OMPC_Allocate>
jdennyUnsubmitted
Done
ReplyInline Actions

The closing ] is inconsistently placed here and in some other cases.

jdenny: The closing `]` is inconsistently placed here and in some other cases.
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

Good catch. I updated the file as well.

clementval: Good catch. I updated the file as well.
];
} }
def OMP_Master : Directive<"master"> {} def OMP_Master : Directive<"master"> {}
def OMP_Critical : Directive<"critical"> { def OMP_Critical : Directive<"critical"> {
let allowedClauses = [OMPC_Hint]; let allowedClauses = [
VersionedClause<OMPC_Hint>
];
} }
def OMP_TaskYield : Directive<"taskyield"> {} def OMP_TaskYield : Directive<"taskyield"> {}
def OMP_Barrier : Directive<"barrier"> {} def OMP_Barrier : Directive<"barrier"> {}
def OMP_TaskWait : Directive<"taskwait"> {} def OMP_TaskWait : Directive<"taskwait"> {}
def OMP_TaskGroup : Directive<"taskgroup"> { def OMP_TaskGroup : Directive<"taskgroup"> {
let allowedClauses = [OMPC_TaskReduction, OMPC_Allocate]; let allowedClauses = [
VersionedClause<OMPC_TaskReduction>,
VersionedClause<OMPC_Allocate>
];
} }
def OMP_Flush : Directive<"flush"> { def OMP_Flush : Directive<"flush"> {
let allowedClauses = [OMPC_AcqRel, OMPC_Acquire, OMPC_Release, OMPC_Flush]; let allowedClauses = [
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"> { def OMP_Ordered : Directive<"ordered"> {
let allowedClauses = [OMPC_Threads, OMPC_Simd, OMPC_Depend]; let allowedClauses = [
VersionedClause<OMPC_Threads>,
VersionedClause<OMPC_Simd>,
VersionedClause<OMPC_Depend>
];
} }
def OMP_Atomic : Directive<"atomic"> { def OMP_Atomic : Directive<"atomic"> {
let allowedClauses = [OMPC_Read, OMPC_Write, OMPC_Update, OMPC_Capture, let allowedClauses = [
OMPC_SeqCst, OMPC_AcqRel, OMPC_Acquire, OMPC_Release, OMPC_Relaxed, VersionedClause<OMPC_Read>,
OMPC_Hint]; VersionedClause<OMPC_Write>,
VersionedClause<OMPC_Update>,
VersionedClause<OMPC_Capture>,
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"> { def OMP_Target : Directive<"target"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_Private, let allowedClauses = [
OMPC_NoWait, OMPC_Depend, OMPC_DefaultMap, OMPC_FirstPrivate, VersionedClause<OMPC_If>,
OMPC_IsDevicePtr, OMPC_Reduction, OMPC_Allocate, OMPC_UsesAllocators]; 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_Reduction>,
VersionedClause<OMPC_Allocate>,
VersionedClause<OMPC_UsesAllocators, 50>
];
} }
def OMP_Teams : Directive<"teams"> { def OMP_Teams : Directive<"teams"> {
let allowedClauses = [OMPC_Default, OMPC_Private, OMPC_FirstPrivate, let allowedClauses = [
OMPC_Shared, OMPC_Reduction, OMPC_NumTeams, OMPC_ThreadLimit, VersionedClause<OMPC_Default>,
OMPC_Allocate]; VersionedClause<OMPC_Private>,
VersionedClause<OMPC_FirstPrivate>,
VersionedClause<OMPC_Shared>,
VersionedClause<OMPC_Reduction>,
VersionedClause<OMPC_NumTeams>,
VersionedClause<OMPC_ThreadLimit>,
VersionedClause<OMPC_Allocate>
];
} }
def OMP_Cancel : Directive<"cancel"> { def OMP_Cancel : Directive<"cancel"> {
let allowedClauses = [OMPC_If]; let allowedClauses = [
VersionedClause<OMPC_If>
];
} }
def OMP_Requires : Directive<"requires"> { def OMP_Requires : Directive<"requires"> {
let allowedClauses = [OMPC_UnifiedAddress, OMPC_UnifiedSharedMemory, let allowedClauses = [
OMPC_ReverseOffload, OMPC_DynamicAllocators, OMPC_AtomicDefaultMemOrder]; VersionedClause<OMPC_UnifiedAddress>,
VersionedClause<OMPC_UnifiedSharedMemory>,
VersionedClause<OMPC_ReverseOffload>,
VersionedClause<OMPC_DynamicAllocators>,
VersionedClause<OMPC_AtomicDefaultMemOrder>
];
} }
def OMP_TargetData : Directive<"target data"> { def OMP_TargetData : Directive<"target data"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_UseDevicePtr, let allowedClauses = [
OMPC_UseDevicePtr]; VersionedClause<OMPC_If>,
VersionedClause<OMPC_Device>,
VersionedClause<OMPC_Map>,
VersionedClause<OMPC_UseDevicePtr>,
VersionedClause<OMPC_UseDeviceAddr, 50>
];
} }
def OMP_TargetEnterData : Directive<"target enter data"> { def OMP_TargetEnterData : Directive<"target enter data"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_NoWait, let allowedClauses = [
OMPC_Depend]; VersionedClause<OMPC_If>,
VersionedClause<OMPC_Device>,
VersionedClause<OMPC_Map>,
VersionedClause<OMPC_NoWait>,
VersionedClause<OMPC_Depend>
];
} }
def OMP_TargetExitData : Directive<"target exit data"> { def OMP_TargetExitData : Directive<"target exit data"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_NoWait, let allowedClauses = [
OMPC_Depend]; VersionedClause<OMPC_If>,
VersionedClause<OMPC_Device>,
VersionedClause<OMPC_Map>,
VersionedClause<OMPC_NoWait>,
VersionedClause<OMPC_Depend>
];
} }
def OMP_TargetParallel : Directive<"target parallel"> { def OMP_TargetParallel : Directive<"target parallel"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_NoWait, let allowedClauses = [
OMPC_Depend, OMPC_Private, OMPC_FirstPrivate, OMPC_DefaultMap, VersionedClause<OMPC_If>,
OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, OMPC_Shared, OMPC_Reduction, VersionedClause<OMPC_Device>,
OMPC_IsDevicePtr, OMPC_Allocator, OMPC_UsesAllocators]; VersionedClause<OMPC_Map>,
VersionedClause<OMPC_NoWait>,
VersionedClause<OMPC_Depend>,
VersionedClause<OMPC_Private>,
VersionedClause<OMPC_FirstPrivate>,
VersionedClause<OMPC_DefaultMap>,
VersionedClause<OMPC_NumThreads>,
VersionedClause<OMPC_Default>,
VersionedClause<OMPC_ProcBind>,
VersionedClause<OMPC_Shared>,
VersionedClause<OMPC_Reduction>,
VersionedClause<OMPC_IsDevicePtr>,
VersionedClause<OMPC_Allocate>,
VersionedClause<OMPC_UsesAllocators, 50>
];
} }
def OMP_TargetParallelFor : Directive<"target parallel for"> { def OMP_TargetParallelFor : Directive<"target parallel for"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_Private, let allowedClauses = [
OMPC_FirstPrivate, OMPC_LastPrivate, OMPC_NoWait, OMPC_Depend, VersionedClause<OMPC_If>,
OMPC_DefaultMap, OMPC_NumThreads, OMPC_DefaultMap, OMPC_ProcBind, VersionedClause<OMPC_Device>,
OMPC_Shared, OMPC_Reduction, OMPC_Collapse, OMPC_Schedule, OMPC_Ordered, VersionedClause<OMPC_Map>,
OMPC_Linear, OMPC_IsDevicePtr, OMPC_Allocator, OMPC_Order, VersionedClause<OMPC_Private>,
OMPC_UsesAllocators]; 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_TargetUpdate : Directive<"target update"> { def OMP_TargetUpdate : Directive<"target update"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_To, OMPC_From, OMPC_NoWait, let allowedClauses = [
OMPC_Depend]; VersionedClause<OMPC_If>,
VersionedClause<OMPC_Device>,
VersionedClause<OMPC_To>,
VersionedClause<OMPC_From>,
VersionedClause<OMPC_NoWait>,
VersionedClause<OMPC_Depend>
];
} }
def OMP_ParallelFor : Directive<"parallel for"> { def OMP_ParallelFor : Directive<"parallel for"> {
let allowedClauses = [OMPC_If, OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, let allowedClauses = [
OMPC_Private, OMPC_FirstPrivate, OMPC_Shared, OMPC_Reduction, OMPC_Copyin, VersionedClause<OMPC_If>,
OMPC_LastPrivate, OMPC_Collapse, OMPC_Schedule, OMPC_Ordered, OMPC_Linear, VersionedClause<OMPC_NumThreads>,
OMPC_Allocate, OMPC_Order]; 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_ParallelForSimd : Directive<"parallel for simd"> { def OMP_ParallelForSimd : Directive<"parallel for simd"> {
let allowedClauses = [OMPC_If, OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, let allowedClauses = [
OMPC_Private, OMPC_FirstPrivate, OMPC_Shared, OMPC_Reduction, OMPC_Copyin, VersionedClause<OMPC_If>,
OMPC_LastPrivate, OMPC_Collapse, OMPC_Schedule, OMPC_SafeLen, VersionedClause<OMPC_NumThreads>,
OMPC_SimdLen, OMPC_Linear, OMPC_Aligned, OMPC_Ordered, OMPC_Allocate, VersionedClause<OMPC_Default>,
OMPC_NonTemporal, OMPC_Order]; 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_ParallelMaster : Directive<"parallel master"> { def OMP_ParallelMaster : Directive<"parallel master"> {
let allowedClauses = [OMPC_If, OMPC_NumThreads, OMPC_Default, OMPC_Private, let allowedClauses = [
OMPC_FirstPrivate, OMPC_Shared, OMPC_Copyin, OMPC_Reduction, VersionedClause<OMPC_If>,
OMPC_ProcBind, OMPC_Allocate]; 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"> { def OMP_ParallelSections : Directive<"parallel sections"> {
let allowedClauses = [OMPC_If, OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, let allowedClauses = [
OMPC_Private, OMPC_FirstPrivate, OMPC_Shared, OMPC_Reduction, OMPC_Copyin, VersionedClause<OMPC_If>,
OMPC_LastPrivate, OMPC_Allocate]; 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_Allocate>
];
} }
def OMP_ForSimd : Directive<"for simd"> { def OMP_ForSimd : Directive<"for simd"> {
let allowedClauses = [OMPC_Private, OMPC_FirstPrivate, OMPC_LastPrivate, let allowedClauses = [
OMPC_Reduction, OMPC_Schedule, OMPC_Collapse, OMPC_NoWait, OMPC_SafeLen, VersionedClause<OMPC_Private>,
OMPC_SimdLen, OMPC_Linear, OMPC_Aligned, OMPC_Ordered, OMPC_Allocate, VersionedClause<OMPC_FirstPrivate>,
OMPC_If, OMPC_NonTemporal, OMPC_Order]; 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_CancellationPoint : Directive<"cancellation point"> {} def OMP_CancellationPoint : Directive<"cancellation point"> {}
def OMP_DeclareReduction : Directive<"declare reduction"> {} def OMP_DeclareReduction : Directive<"declare reduction"> {}
def OMP_DeclareMapper : Directive<"declare mapper"> { def OMP_DeclareMapper : Directive<"declare mapper"> {
let allowedClauses = [OMPC_Map]; let allowedClauses = [
VersionedClause<OMPC_Map>
];
} }
def OMP_DeclareSimd : Directive<"declare simd"> {} def OMP_DeclareSimd : Directive<"declare simd"> {}
def OMP_TaskLoop : Directive<"taskloop"> { def OMP_TaskLoop : Directive<"taskloop"> {
let allowedClauses = [OMPC_If, OMPC_Shared, OMPC_Private, OMPC_FirstPrivate, let allowedClauses = [
OMPC_LastPrivate, OMPC_Default, OMPC_Collapse, OMPC_Final, OMPC_Untied, VersionedClause<OMPC_If>,
OMPC_Mergeable, OMPC_Priority, OMPC_GrainSize, OMPC_NoGroup, VersionedClause<OMPC_Shared>,
OMPC_NumTasks, OMPC_Reduction, OMPC_InReduction, OMPC_Allocate]; 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_TaskLoopSimd : Directive<"taskloop simd"> { def OMP_TaskLoopSimd : Directive<"taskloop simd"> {
let allowedClauses = [OMPC_If, OMPC_Shared, OMPC_Private, OMPC_FirstPrivate, let allowedClauses = [
OMPC_LastPrivate, OMPC_Default, OMPC_Collapse, OMPC_Final, OMPC_Untied, VersionedClause<OMPC_If>,
OMPC_Mergeable, OMPC_Priority, OMPC_Linear, OMPC_Aligned, OMPC_SafeLen, VersionedClause<OMPC_Shared>,
OMPC_SimdLen, OMPC_GrainSize, OMPC_NoGroup, OMPC_NumTasks, OMPC_Reduction, VersionedClause<OMPC_Private>,
OMPC_InReduction, OMPC_Allocator, OMPC_NonTemporal, OMPC_Order]; 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_Distribute : Directive<"distribute"> { def OMP_Distribute : Directive<"distribute"> {
let allowedClauses = [OMPC_Private, OMPC_FirstPrivate, OMPC_LastPrivate, let allowedClauses = [
OMPC_Collapse, OMPC_DistSchedule, OMPC_Allocate]; VersionedClause<OMPC_Private>,
VersionedClause<OMPC_FirstPrivate>,
VersionedClause<OMPC_LastPrivate>,
VersionedClause<OMPC_Collapse>,
VersionedClause<OMPC_DistSchedule>,
VersionedClause<OMPC_Allocate>
];
} }
def OMP_DeclareTarget : Directive<"declare target"> {} def OMP_DeclareTarget : Directive<"declare target"> {}
def OMP_EndDeclareTarget : Directive<"end declare target"> {} def OMP_EndDeclareTarget : Directive<"end declare target"> {}
def OMP_DistributeParallelFor : Directive<"distribute parallel for"> { def OMP_DistributeParallelFor : Directive<"distribute parallel for"> {
let allowedClauses = [OMPC_FirstPrivate, OMPC_LastPrivate, OMPC_Collapse, let allowedClauses = [
OMPC_DistSchedule, OMPC_If, OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, VersionedClause<OMPC_FirstPrivate>,
OMPC_Private, OMPC_Shared, OMPC_Reduction, OMPC_Copyin, OMPC_Schedule, VersionedClause<OMPC_LastPrivate>,
OMPC_Allocate, OMPC_Order]; 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_DistributeParallelForSimd : Directive<"distribute parallel for simd"> { def OMP_DistributeParallelForSimd : Directive<"distribute parallel for simd"> {
let allowedClauses = [OMPC_FirstPrivate, OMPC_LastPrivate, OMPC_Collapse, let allowedClauses = [
OMPC_DistSchedule, OMPC_If, OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, VersionedClause<OMPC_FirstPrivate>,
OMPC_Private, OMPC_Shared, OMPC_Reduction, OMPC_Copyin, OMPC_Schedule, VersionedClause<OMPC_LastPrivate>,
OMPC_Linear, OMPC_Aligned, OMPC_SafeLen, OMPC_SimdLen, OMPC_Allocate, VersionedClause<OMPC_Collapse>,
OMPC_NonTemporal, OMPC_Order]; 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_DistributeSimd : Directive<"distribute simd"> { def OMP_DistributeSimd : Directive<"distribute simd"> {
let allowedClauses = [OMPC_Private, OMPC_FirstPrivate, OMPC_LastPrivate, let allowedClauses = [
OMPC_Collapse, OMPC_DistSchedule, OMPC_Linear, OMPC_Aligned, OMPC_SafeLen, VersionedClause<OMPC_Private>,
OMPC_SimdLen, OMPC_Reduction, OMPC_Allocate, OMPC_If, OMPC_NonTemporal, VersionedClause<OMPC_FirstPrivate>,
OMPC_Order]; VersionedClause<OMPC_LastPrivate>,
VersionedClause<OMPC_Collapse>,
VersionedClause<OMPC_DistSchedule>,
VersionedClause<OMPC_Linear>,
VersionedClause<OMPC_Aligned>,
VersionedClause<OMPC_SafeLen>,
VersionedClause<OMPC_SimdLen>,
VersionedClause<OMPC_Reduction>,
VersionedClause<OMPC_Allocate>,
VersionedClause<OMPC_If, 50>,
VersionedClause<OMPC_NonTemporal, 50>,
VersionedClause<OMPC_Order, 50>
];
} }
def OMP_TargetParallelForSimd : Directive<"target parallel for simd"> { def OMP_TargetParallelForSimd : Directive<"target parallel for simd"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_Private, let allowedClauses = [
OMPC_FirstPrivate, OMPC_LastPrivate, OMPC_NoWait, OMPC_Depend, VersionedClause<OMPC_If>,
OMPC_DefaultMap, OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, VersionedClause<OMPC_Device>,
OMPC_Shared, OMPC_Reduction, OMPC_Collapse, OMPC_Schedule, OMPC_Ordered, VersionedClause<OMPC_Map>,
OMPC_Linear, OMPC_SafeLen, OMPC_SimdLen, OMPC_Aligned, OMPC_IsDevicePtr, VersionedClause<OMPC_Private>,
OMPC_Allocate, OMPC_NonTemporal, OMPC_Order, OMPC_UsesAllocators]; 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_TargetSimd : Directive<"target simd"> { def OMP_TargetSimd : Directive<"target simd"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_Private, let allowedClauses = [
OMPC_NoWait, OMPC_Depend, OMPC_DefaultMap, OMPC_FirstPrivate, VersionedClause<OMPC_If>,
OMPC_IsDevicePtr, OMPC_LastPrivate, OMPC_Linear, OMPC_Aligned, VersionedClause<OMPC_Device>,
OMPC_SafeLen, OMPC_SimdLen, OMPC_Collapse, OMPC_Reduction, OMPC_Allocate, VersionedClause<OMPC_Map>,
OMPC_NonTemporal, OMPC_Order, OMPC_UsesAllocators]; VersionedClause<OMPC_Private>,
VersionedClause<OMPC_NoWait>,
VersionedClause<OMPC_Depend>,
VersionedClause<OMPC_DefaultMap>,
VersionedClause<OMPC_FirstPrivate>,
VersionedClause<OMPC_IsDevicePtr>,
VersionedClause<OMPC_LastPrivate>,
VersionedClause<OMPC_Linear>,
VersionedClause<OMPC_Aligned>,
VersionedClause<OMPC_SafeLen>,
VersionedClause<OMPC_SimdLen>,
VersionedClause<OMPC_Collapse>,
VersionedClause<OMPC_Reduction>,
VersionedClause<OMPC_Allocate>,
VersionedClause<OMPC_NonTemporal, 50>,
VersionedClause<OMPC_Order, 50>,
VersionedClause<OMPC_UsesAllocators, 50>
];
} }
def OMP_TeamsDistribute : Directive<"teams distribute"> { def OMP_TeamsDistribute : Directive<"teams distribute"> {
let allowedClauses = [OMPC_Default, OMPC_Private, OMPC_FirstPrivate, let allowedClauses = [
OMPC_Shared, OMPC_Reduction, OMPC_NumTeams, OMPC_ThreadLimit, VersionedClause<OMPC_Default>,
OMPC_LastPrivate, OMPC_Collapse, OMPC_DistSchedule, OMPC_Allocate]; 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"> { def OMP_TeamsDistributeSimd : Directive<"teams distribute simd"> {
let allowedClauses = [OMPC_Default, OMPC_Private, OMPC_FirstPrivate, let allowedClauses = [
OMPC_Shared, OMPC_Reduction, OMPC_NumTeams, OMPC_ThreadLimit, VersionedClause<OMPC_Default>,
OMPC_LastPrivate, OMPC_Collapse, OMPC_DistSchedule, OMPC_Linear, VersionedClause<OMPC_Private>,
OMPC_Aligned, OMPC_SafeLen, OMPC_SimdLen, OMPC_Allocate, OMPC_If, VersionedClause<OMPC_FirstPrivate>,
OMPC_NonTemporal, OMPC_Order]; VersionedClause<OMPC_Shared>,
VersionedClause<OMPC_Reduction>,
VersionedClause<OMPC_NumTeams>,
VersionedClause<OMPC_ThreadLimit>,
VersionedClause<OMPC_LastPrivate>,
VersionedClause<OMPC_Collapse>,
VersionedClause<OMPC_DistSchedule>,
VersionedClause<OMPC_Linear>,
VersionedClause<OMPC_Aligned>,
VersionedClause<OMPC_SafeLen>,
VersionedClause<OMPC_SimdLen>,
VersionedClause<OMPC_Allocate>,
VersionedClause<OMPC_If, 50>,
VersionedClause<OMPC_NonTemporal, 50>,
VersionedClause<OMPC_Order, 50>
];
} }
def OMP_TeamsDistributeParallelForSimd : def OMP_TeamsDistributeParallelForSimd :
Directive<"teams distribute parallel for simd"> { Directive<"teams distribute parallel for simd"> {
let allowedClauses = [OMPC_FirstPrivate, OMPC_LastPrivate, OMPC_Collapse, let allowedClauses = [
OMPC_DistSchedule, OMPC_If, OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, VersionedClause<OMPC_FirstPrivate>,
OMPC_Private, OMPC_Shared, OMPC_Reduction, OMPC_Schedule, OMPC_Linear, VersionedClause<OMPC_LastPrivate>,
OMPC_Aligned, OMPC_SafeLen, OMPC_SimdLen, OMPC_NumTeams, OMPC_ThreadLimit, VersionedClause<OMPC_Collapse>,
OMPC_Allocate, OMPC_NonTemporal, OMPC_Order]; 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_TeamsDistributeParallelFor : def OMP_TeamsDistributeParallelFor :
Directive<"teams distribute parallel for"> { Directive<"teams distribute parallel for"> {
let allowedClauses = [OMPC_FirstPrivate, OMPC_LastPrivate, OMPC_Collapse, let allowedClauses = [
OMPC_DistSchedule, OMPC_If, OMPC_NumThreads, OMPC_Default, OMPC_ProcBind, VersionedClause<OMPC_FirstPrivate>,
OMPC_Private, OMPC_Shared, OMPC_Reduction, OMPC_Schedule, OMPC_NumTeams, VersionedClause<OMPC_LastPrivate>,
OMPC_ThreadLimit, OMPC_Copyin, OMPC_Allocate, OMPC_Order]; 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_TargetTeams : Directive<"target teams"> { def OMP_TargetTeams : Directive<"target teams"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_Private, let allowedClauses = [
OMPC_NoWait, OMPC_Depend, OMPC_DefaultMap, OMPC_FirstPrivate, VersionedClause<OMPC_If>,
OMPC_IsDevicePtr, OMPC_Default, OMPC_Shared, OMPC_Reduction, VersionedClause<OMPC_Device>,
OMPC_NumTeams, OMPC_ThreadLimit, OMPC_Allocate, OMPC_UsesAllocators]; 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_Allocate>,
VersionedClause<OMPC_UsesAllocators, 50>
];
} }
def OMP_TargetTeamsDistribute : Directive<"target teams distribute"> { def OMP_TargetTeamsDistribute : Directive<"target teams distribute"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_Private, let allowedClauses = [
OMPC_NoWait, OMPC_Depend, OMPC_DefaultMap, OMPC_FirstPrivate, VersionedClause<OMPC_If>,
OMPC_IsDevicePtr, OMPC_Default, OMPC_Shared, OMPC_Reduction, VersionedClause<OMPC_Device>,
OMPC_NumTeams, OMPC_ThreadLimit, OMPC_LastPrivate, OMPC_Collapse, VersionedClause<OMPC_Map>,
OMPC_DistSchedule, OMPC_Allocate, OMPC_UsesAllocators]; 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_Allocate>,
VersionedClause<OMPC_UsesAllocators, 50>
];
} }
def OMP_TargetTeamsDistributeParallelFor : def OMP_TargetTeamsDistributeParallelFor :
Directive<"target teams distribute parallel for"> { Directive<"target teams distribute parallel for"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_Private, let allowedClauses = [
OMPC_NoWait, OMPC_Depend, OMPC_DefaultMap, OMPC_FirstPrivate, VersionedClause<OMPC_If>,
OMPC_IsDevicePtr, OMPC_Default, OMPC_Shared, OMPC_Reduction, VersionedClause<OMPC_Device>,
OMPC_NumTeams, OMPC_ThreadLimit, OMPC_LastPrivate, OMPC_Collapse, VersionedClause<OMPC_Map>,
OMPC_DistSchedule, OMPC_NumThreads, OMPC_ProcBind, OMPC_Schedule, VersionedClause<OMPC_Private>,
OMPC_Allocate, OMPC_Order, OMPC_UsesAllocators]; 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_TargetTeamsDistributeParallelForSimd : def OMP_TargetTeamsDistributeParallelForSimd :
Directive<"target teams distribute parallel for simd"> { Directive<"target teams distribute parallel for simd"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_Private, let allowedClauses = [
OMPC_NoWait, OMPC_Depend, OMPC_DefaultMap, OMPC_FirstPrivate, VersionedClause<OMPC_If>,
OMPC_IsDevicePtr, OMPC_Default, OMPC_Shared, OMPC_Reduction, VersionedClause<OMPC_Device>,
OMPC_NumTeams, OMPC_ThreadLimit, OMPC_LastPrivate, OMPC_Collapse, VersionedClause<OMPC_Map>,
OMPC_DistSchedule, OMPC_NumThreads, OMPC_ProcBind, OMPC_Schedule, VersionedClause<OMPC_Private>,
OMPC_Linear, OMPC_Aligned, OMPC_SafeLen, OMPC_SimdLen, OMPC_Allocate, VersionedClause<OMPC_NoWait>,
OMPC_NonTemporal, OMPC_Order, OMPC_UsesAllocators]; 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_TargetTeamsDistributeSimd : def OMP_TargetTeamsDistributeSimd :
Directive<"target teams distribute simd"> { Directive<"target teams distribute simd"> {
let allowedClauses = [OMPC_If, OMPC_Device, OMPC_Map, OMPC_Private, let allowedClauses = [
OMPC_NoWait, OMPC_Depend, OMPC_DefaultMap, OMPC_FirstPrivate, VersionedClause<OMPC_If>,
OMPC_LastPrivate, OMPC_IsDevicePtr, OMPC_Shared, OMPC_Reduction, VersionedClause<OMPC_Device>,
OMPC_NumTeams, OMPC_ThreadLimit, OMPC_Collapse, OMPC_DistSchedule, VersionedClause<OMPC_Map>,
OMPC_Linear, OMPC_Aligned, OMPC_SafeLen, OMPC_SimdLen, OMPC_Allocate, VersionedClause<OMPC_Private>,
OMPC_NonTemporal, OMPC_Order, OMPC_UsesAllocators]; VersionedClause<OMPC_NoWait>,
VersionedClause<OMPC_Depend>,
VersionedClause<OMPC_DefaultMap>,
VersionedClause<OMPC_FirstPrivate>,
VersionedClause<OMPC_LastPrivate>,
VersionedClause<OMPC_IsDevicePtr>,
VersionedClause<OMPC_Shared>,
VersionedClause<OMPC_Reduction>,
VersionedClause<OMPC_NumTeams>,
VersionedClause<OMPC_ThreadLimit>,
VersionedClause<OMPC_Collapse>,
VersionedClause<OMPC_DistSchedule>,
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_Allocate : Directive<"allocate"> { def OMP_Allocate : Directive<"allocate"> {
let allowedClauses = [OMPC_Allocator]; let allowedClauses = [
VersionedClause<OMPC_Allocator>
];
} }
def OMP_DeclareVariant : Directive<"declare variant"> { def OMP_DeclareVariant : Directive<"declare variant"> {
let allowedClauses = [OMPC_Match]; let allowedClauses = [
VersionedClause<OMPC_Match>
];
} }
def OMP_MasterTaskloop : Directive<"master taskloop"> { def OMP_MasterTaskloop : Directive<"master taskloop"> {
let allowedClauses = [ let allowedClauses = [
OMPC_If, OMPC_Shared, OMPC_Private, OMPC_FirstPrivate, OMPC_LastPrivate, VersionedClause<OMPC_If>,
OMPC_Default, OMPC_Collapse, OMPC_Final, OMPC_Untied, OMPC_Mergeable, VersionedClause<OMPC_Shared>,
OMPC_Priority, OMPC_GrainSize, OMPC_NoGroup, OMPC_NumTasks, VersionedClause<OMPC_Private>,
OMPC_Reduction, OMPC_InReduction, OMPC_Allocate]; 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 : def OMP_ParallelMasterTaskloop :
Directive<"parallel master taskloop"> { Directive<"parallel master taskloop"> {
let allowedClauses = [OMPC_If, OMPC_Shared, OMPC_Private, OMPC_FirstPrivate, let allowedClauses = [
OMPC_LastPrivate, OMPC_Default, OMPC_Collapse, OMPC_Final, OMPC_Untied, VersionedClause<OMPC_If>,
OMPC_Mergeable, OMPC_Priority, OMPC_GrainSize, OMPC_NoGroup, VersionedClause<OMPC_Shared>,
OMPC_NumTasks, OMPC_Reduction, OMPC_Allocate, OMPC_NumThreads, VersionedClause<OMPC_Private>,
OMPC_ProcBind, OMPC_Copyin]; 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"> { def OMP_MasterTaskloopSimd : Directive<"master taskloop simd"> {
let allowedClauses = [OMPC_If, OMPC_Shared, OMPC_Private, OMPC_FirstPrivate, let allowedClauses = [
OMPC_LastPrivate, OMPC_DefaultMap, OMPC_Collapse, OMPC_Final, OMPC_Untied, VersionedClause<OMPC_If>,
OMPC_Mergeable, OMPC_Priority, OMPC_Linear, OMPC_Aligned, OMPC_SafeLen, VersionedClause<OMPC_Shared>,
OMPC_SimdLen, OMPC_GrainSize, OMPC_NoGroup, OMPC_NumTasks, OMPC_Reduction, VersionedClause<OMPC_Private>,
OMPC_InReduction, OMPC_Allocate, OMPC_NonTemporal, OMPC_Order]; 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 : def OMP_ParallelMasterTaskloopSimd :
Directive<"parallel master taskloop simd"> { Directive<"parallel master taskloop simd"> {
let allowedClauses = [OMPC_If, OMPC_Shared, OMPC_Private, OMPC_FirstPrivate, let allowedClauses = [
OMPC_LastPrivate, OMPC_Default, OMPC_Collapse, OMPC_Final, OMPC_Untied, VersionedClause<OMPC_If>,
OMPC_Mergeable, OMPC_Priority, OMPC_GrainSize, OMPC_NoGroup, VersionedClause<OMPC_Shared>,
OMPC_NumTasks, OMPC_Reduction, OMPC_Allocate, OMPC_NumThreads, VersionedClause<OMPC_Private>,
OMPC_ProcBind, OMPC_Copyin, OMPC_Linear, OMPC_Aligned, OMPC_SafeLen, VersionedClause<OMPC_FirstPrivate>,
OMPC_SimdLen, OMPC_NonTemporal, OMPC_Order]; 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"> { def OMP_Depobj : Directive<"depobj"> {
let allowedClauses = [OMPC_Depend, OMPC_Destroy, OMPC_Update, OMPC_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"> { def OMP_Scan : Directive<"scan"> {
let allowedClauses = [OMPC_Inclusive, OMPC_Exclusive]; let allowedClauses = [
VersionedClause<OMPC_Inclusive, 50>,
VersionedClause<OMPC_Exclusive, 50>
];
} }
def OMP_BeginDeclareVariant : Directive<"begin declare variant"> {} def OMP_BeginDeclareVariant : Directive<"begin declare variant"> {}
def OMP_EndDeclareVariant : Directive<"end declare variant"> {} def OMP_EndDeclareVariant : Directive<"end declare variant"> {}
def OMP_Unknown : Directive<"unknown"> { def OMP_Unknown : Directive<"unknown"> {
let isDefault = 1; let isDefault = 1;
} }

llvm/include/llvm/Frontend/OpenMP/OMPConstants.h

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines
#define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value, #define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value,
#include "llvm/Frontend/OpenMP/OMPKinds.def" #include "llvm/Frontend/OpenMP/OMPKinds.def"
LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF) LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF)
}; };
#define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum; #define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def" #include "llvm/Frontend/OpenMP/OMPKinds.def"
/// Return true if \p C is a valid clause for \p D in version \p Version.
bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);
/// Forward declarations for LLVM-IR types (simple, function and structure) are /// Forward declarations for LLVM-IR types (simple, function and structure) are
/// generated below. Their names are defined and used in OpenMP/OMPKinds.def. /// generated below. Their names are defined and used in OpenMP/OMPKinds.def.
/// Here we provide the forward declarations, the initializeTypes function will /// Here we provide the forward declarations, the initializeTypes function will
/// provide the values. /// provide the values.
/// ///
///{ ///{
namespace types { namespace types {
Show All 26 Lines

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

Show First 20 Lines • Show All 1,141 Lines • ▼ Show 20 Lines
#undef OMP_TRAIT_SELECTOR #undef OMP_TRAIT_SELECTOR
#undef __OMP_TRAIT_SELECTOR #undef __OMP_TRAIT_SELECTOR
#undef OMP_TRAIT_PROPERTY #undef OMP_TRAIT_PROPERTY
#undef OMP_LAST_TRAIT_PROPERTY #undef OMP_LAST_TRAIT_PROPERTY
#undef __OMP_TRAIT_PROPERTY #undef __OMP_TRAIT_PROPERTY
#undef __OMP_REQUIRES_TRAIT #undef __OMP_REQUIRES_TRAIT
#undef OMP_REQUIRES_TRAIT #undef OMP_REQUIRES_TRAIT
///} ///}
/// Clauses allowed per directive
///
///{
#ifndef OMP_DIRECTIVE_CLAUSE
#define OMP_DIRECTIVE_CLAUSE(Directive, MinVersion, MaxVersion, Clause)
#endif
#define __OMP_DIRECTIVE_CLAUSE(Directive, MinVersion, MaxVersion, Clause) \
OMP_DIRECTIVE_CLAUSE(OMPD_##Directive, unsigned(MinVersion), \
unsigned(MaxVersion), OMPC_##Clause)
__OMP_DIRECTIVE_CLAUSE(scan, 50, ~0, inclusive)
__OMP_DIRECTIVE_CLAUSE(scan, 50, ~0, exclusive)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(simd, 50, ~0, if)
__OMP_DIRECTIVE_CLAUSE(simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, ordered)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(for_simd, 50, ~0, if)
__OMP_DIRECTIVE_CLAUSE(for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, copyprivate)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(cancel, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(task, 50, ~0, detach)
__OMP_DIRECTIVE_CLAUSE(task, 50, ~0, affinity)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, read)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, write)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, update)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, capture)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, seq_cst)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, acq_rel)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, acquire)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, release)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, relaxed)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, hint)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target, 50, ~0, uses_allocators)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, unified_address)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, unified_shared_memory)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, reverse_offload)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, dynamic_allocators)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, atomic_default_mem_order)
__OMP_DIRECTIVE_CLAUSE(allocate, 1, ~0, allocator)
__OMP_DIRECTIVE_CLAUSE(target_data, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_data, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_data, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_data, 1, ~0, use_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_data, 50, ~0, use_device_addr)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 50, ~0, uses_allocators)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 50, ~0, uses_allocators)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, to)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, from)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(ordered, 1, ~0, threads)
__OMP_DIRECTIVE_CLAUSE(ordered, 1, ~0, simd)
__OMP_DIRECTIVE_CLAUSE(ordered, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(critical, 1, ~0, hint)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 50, ~0, if)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 50, ~0, uses_allocators)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(target_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_simd, 50, ~0, uses_allocators)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 50, ~0, if)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams, 50, ~0, uses_allocators)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 50, ~0, uses_allocators)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0,
firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0,
is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0,
thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0,
dist_schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 50, ~0,
uses_allocators)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
private)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
default)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
collapse)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
dist_schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
num_threads)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
aligned)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
safelen)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
simdlen)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 50, ~0,
nontemporal)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 50, ~0,
uses_allocators)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 50, ~0, uses_allocators)
__OMP_DIRECTIVE_CLAUSE(taskgroup, 1, ~0, task_reduction)
__OMP_DIRECTIVE_CLAUSE(taskgroup, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(declare_mapper, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(declare_variant, 1, ~0, match)
__OMP_DIRECTIVE_CLAUSE(flush, 50, ~0, acq_rel)
__OMP_DIRECTIVE_CLAUSE(flush, 50, ~0, acquire)
__OMP_DIRECTIVE_CLAUSE(flush, 50, ~0, release)
// TODO This should ne `none` instead
jdennyUnsubmitted
Done
ReplyInline Actions

This patch loses this TODO and the next one. I'm not sure what they mean. Do we need to keep them?

jdenny: This patch loses this TODO and the next one. I'm not sure what they mean. Do we need to keep…
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

I updated the patch to keep it. Same for depobj.

clementval: I updated the patch to keep it. Same for `depobj`.
jdennyUnsubmitted
Not Done
ReplyInline Actions

@jdoerfert : If I read git blame correctly, you wrote this TODO originally. Can you help us to understand whether it's worth preserving?

jdenny: @jdoerfert : If I read git blame correctly, you wrote this TODO originally. Can you help us to…
__OMP_DIRECTIVE_CLAUSE(flush, 1, ~0, flush)
__OMP_DIRECTIVE_CLAUSE(depobj, 50, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(depobj, 50, ~0, destroy)
__OMP_DIRECTIVE_CLAUSE(depobj, 50, ~0, update)
// TODO This should ne `none` instead
__OMP_DIRECTIVE_CLAUSE(depobj, 50, ~0, depobj)
#undef __OMP_DIRECTIVE_CLAUSE
#undef OMP_DIRECTIVE_CLAUSE
///}

llvm/lib/Frontend/OpenMP/OMPConstants.cpp

Show All 15 Lines
#include "llvm/IR/Type.h" #include "llvm/IR/Type.h"
using namespace llvm; using namespace llvm;
using namespace omp; using namespace omp;
using namespace types; using namespace types;
#include "llvm/Frontend/OpenMP/OMP.cpp.inc" #include "llvm/Frontend/OpenMP/OMP.cpp.inc"
bool llvm::omp::isAllowedClauseForDirective(Directive D, Clause C,
unsigned Version) {
assert(unsigned(D) <= llvm::omp::Directive_enumSize);
assert(unsigned(C) <= llvm::omp::Clause_enumSize);
#define OMP_DIRECTIVE_CLAUSE(Dir, MinVersion, MaxVersion, Cl) \
if (D == Dir && C == Cl && MinVersion <= Version && MaxVersion >= Version) \
return true;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
return false;
}
/// Declarations for LLVM-IR types (simple, array, function and structure) are /// Declarations for LLVM-IR types (simple, array, function and structure) are
/// generated below. Their names are defined and used in OpenMPKinds.def. Here /// generated below. Their names are defined and used in OpenMPKinds.def. Here
/// we provide the declarations, the initializeTypes function will provide the /// we provide the declarations, the initializeTypes function will provide the
/// values. /// values.
/// ///
///{ ///{
#define OMP_TYPE(VarName, InitValue) Type *llvm::omp::types::VarName = nullptr; #define OMP_TYPE(VarName, InitValue) Type *llvm::omp::types::VarName = nullptr;
#define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) \ #define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) \
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/TableGen/directive1.td

Show All 13 Lines
} }
def TDLC_ClauseA : Clause<"clausea"> {} def TDLC_ClauseA : Clause<"clausea"> {}
def TDLC_ClauseB : Clause<"clauseb"> { def TDLC_ClauseB : Clause<"clauseb"> {
let isDefault = 1; let isDefault = 1;
} }
def TDL_DirA : Directive<"dira"> { def TDL_DirA : Directive<"dira"> {
let allowedClauses = [TDLC_ClauseA, TDLC_ClauseB]; let allowedClauses = [
VersionedClause<TDLC_ClauseA>,
VersionedClause<TDLC_ClauseB>
];
let isDefault = 1; let isDefault = 1;
} }
// CHECK: #ifndef LLVM_Tdl_INC // CHECK: #ifndef LLVM_Tdl_INC
// CHECK-NEXT: #define LLVM_Tdl_INC // CHECK-NEXT: #define LLVM_Tdl_INC
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: #include "llvm/ADT/BitmaskEnum.h" // CHECK-NEXT: #include "llvm/ADT/BitmaskEnum.h"
// CHECK-EMPTY: // CHECK-EMPTY:
Show All 25 Lines
// CHECK-NEXT: Directive getTdlDirectiveKind(llvm::StringRef Str); // CHECK-NEXT: Directive getTdlDirectiveKind(llvm::StringRef Str);
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: llvm::StringRef getTdlDirectiveName(Directive D); // CHECK-NEXT: llvm::StringRef getTdlDirectiveName(Directive D);
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: Clause getTdlClauseKind(llvm::StringRef Str); // CHECK-NEXT: Clause getTdlClauseKind(llvm::StringRef Str);
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: llvm::StringRef getTdlClauseName(Clause C); // CHECK-NEXT: llvm::StringRef getTdlClauseName(Clause C);
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: /// Return true if \p C is a valid clause for \p D in version \p Version.
// CHECK-NEXT: bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);
// CHECK-EMPTY:
// CHECK-NEXT: } // namespace tdl // CHECK-NEXT: } // namespace tdl
// CHECK-NEXT: } // namespace llvm // CHECK-NEXT: } // namespace llvm
// CHECK-NEXT: #endif // LLVM_Tdl_INC // CHECK-NEXT: #endif // LLVM_Tdl_INC
// IMPL: Directive llvm::tdl::getTdlDirectiveKind(llvm::StringRef Str) { // IMPL: Directive llvm::tdl::getTdlDirectiveKind(llvm::StringRef Str) {
// IMPL-NEXT: return llvm::StringSwitch<Directive>(Str) // IMPL-NEXT: return llvm::StringSwitch<Directive>(Str)
// IMPL-NEXT: .Case("dira",TDLD_dira) // IMPL-NEXT: .Case("dira",TDLD_dira)
Show All 19 Lines
// IMPL-NEXT: switch (Kind) { // IMPL-NEXT: switch (Kind) {
// IMPL-NEXT: case TDLC_clausea: // IMPL-NEXT: case TDLC_clausea:
// IMPL-NEXT: return "clausea"; // IMPL-NEXT: return "clausea";
// IMPL-NEXT: case TDLC_clauseb: // IMPL-NEXT: case TDLC_clauseb:
// IMPL-NEXT: return "clauseb"; // IMPL-NEXT: return "clauseb";
// IMPL-NEXT: } // IMPL-NEXT: }
// IMPL-NEXT: llvm_unreachable("Invalid Tdl Clause kind"); // IMPL-NEXT: llvm_unreachable("Invalid Tdl Clause kind");
// IMPL-NEXT: } // IMPL-NEXT: }
// IMPL-EMPTY:
// IMPL-NEXT: bool llvm::tdl::isAllowedClauseForDirective(Directive D, Clause C, unsigned Version) {
// IMPL-NEXT: assert(unsigned(D) <= llvm::tdl::Directive_enumSize);
// IMPL-NEXT: assert(unsigned(C) <= llvm::tdl::Clause_enumSize);
// IMPL-NEXT: if (D == TDLD_dira && C == TDLC_clausea && 1 <= Version && 2147483647 >= Version)
jdennyUnsubmitted
Done
ReplyInline Actions

I know the original code used a giant if-else block, but shouldn't this be a switch?

jdenny: I know the original code used a giant if-else block, but shouldn't this be a switch?
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

The idea was to migrate to TableGen with the exact same code generated and to update this in a follow up patch. It would be replace with at least a switch for the Directive and probably an inner switch for the Clause or we keep the ifs inside the Directives' switch.

clementval: The idea was to migrate to TableGen with the exact same code generated and to update this in a…
jdennyUnsubmitted
Done
ReplyInline Actions

Sure, makes sense to do it in a separate patch.

It seems like both switches makes sense, but the inner switches might benefit from default cases.

jdenny: Sure, makes sense to do it in a separate patch. It seems like both switches makes sense, but…
// IMPL-NEXT: return true;
// IMPL-NEXT: if (D == TDLD_dira && C == TDLC_clauseb && 1 <= Version && 2147483647 >= Version)
// IMPL-NEXT: return true;
// IMPL-NEXT: return false;
// IMPL-NEXT: }

llvm/test/TableGen/directive2.td

Show All 13 Lines
def TDLC_ClauseA : Clause<"clausea"> { def TDLC_ClauseA : Clause<"clausea"> {
let isImplicit = 1; let isImplicit = 1;
} }
def TDLC_ClauseB : Clause<"clauseb"> { def TDLC_ClauseB : Clause<"clauseb"> {
let isDefault = 1; let isDefault = 1;
} }
def TDL_DirA : Directive<"dira"> { def TDL_DirA : Directive<"dira"> {
let allowedClauses = [TDLC_ClauseA, TDLC_ClauseB]; let allowedClauses = [
VersionedClause<TDLC_ClauseA, 2, 4>,
VersionedClause<TDLC_ClauseB, 2>
];
let isDefault = 1; let isDefault = 1;
} }
// CHECK: #ifndef LLVM_Tdl_INC // CHECK: #ifndef LLVM_Tdl_INC
// CHECK-NEXT: #define LLVM_Tdl_INC // CHECK-NEXT: #define LLVM_Tdl_INC
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: namespace llvm { // CHECK-NEXT: namespace llvm {
// CHECK-NEXT: class StringRef; // CHECK-NEXT: class StringRef;
Show All 16 Lines
// CHECK-NEXT: Directive getTdlDirectiveKind(llvm::StringRef Str); // CHECK-NEXT: Directive getTdlDirectiveKind(llvm::StringRef Str);
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: llvm::StringRef getTdlDirectiveName(Directive D); // CHECK-NEXT: llvm::StringRef getTdlDirectiveName(Directive D);
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: Clause getTdlClauseKind(llvm::StringRef Str); // CHECK-NEXT: Clause getTdlClauseKind(llvm::StringRef Str);
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: llvm::StringRef getTdlClauseName(Clause C); // CHECK-NEXT: llvm::StringRef getTdlClauseName(Clause C);
// CHECK-EMPTY: // CHECK-EMPTY:
// CHECK-NEXT: /// Return true if \p C is a valid clause for \p D in version \p Version.
// CHECK-NEXT: bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);
// CHECK-EMPTY:
// CHECK-NEXT: } // namespace tdl // CHECK-NEXT: } // namespace tdl
// CHECK-NEXT: } // namespace llvm // CHECK-NEXT: } // namespace llvm
// CHECK-NEXT: #endif // LLVM_Tdl_INC // CHECK-NEXT: #endif // LLVM_Tdl_INC
// IMPL: Directive llvm::tdl::getTdlDirectiveKind(llvm::StringRef Str) { // IMPL: Directive llvm::tdl::getTdlDirectiveKind(llvm::StringRef Str) {
// IMPL-NEXT: return llvm::StringSwitch<Directive>(Str) // IMPL-NEXT: return llvm::StringSwitch<Directive>(Str)
// IMPL-NEXT: .Case("dira",TDLD_dira) // IMPL-NEXT: .Case("dira",TDLD_dira)
Show All 18 Lines
// IMPL-NEXT: llvm::StringRef llvm::tdl::getTdlClauseName(Clause Kind) { // IMPL-NEXT: llvm::StringRef llvm::tdl::getTdlClauseName(Clause Kind) {
// IMPL-NEXT: switch (Kind) { // IMPL-NEXT: switch (Kind) {
// IMPL-NEXT: case TDLC_clausea: // IMPL-NEXT: case TDLC_clausea:
// IMPL-NEXT: return "clausea"; // IMPL-NEXT: return "clausea";
// IMPL-NEXT: case TDLC_clauseb: // IMPL-NEXT: case TDLC_clauseb:
// IMPL-NEXT: return "clauseb"; // IMPL-NEXT: return "clauseb";
// IMPL-NEXT: } // IMPL-NEXT: }
// IMPL-NEXT: llvm_unreachable("Invalid Tdl Clause kind"); // IMPL-NEXT: llvm_unreachable("Invalid Tdl Clause kind");
// IMPL-NEXT: } // IMPL-NEXT: }
No newline at end of file // IMPL-EMPTY:
// IMPL-NEXT: bool llvm::tdl::isAllowedClauseForDirective(Directive D, Clause C, unsigned Version) {
// IMPL-NEXT: assert(unsigned(D) <= llvm::tdl::Directive_enumSize);
// IMPL-NEXT: assert(unsigned(C) <= llvm::tdl::Clause_enumSize);
// IMPL-NEXT: if (D == TDLD_dira && C == TDLC_clausea && 2 <= Version && 4 >= Version)
// IMPL-NEXT: return true;
// IMPL-NEXT: if (D == TDLD_dira && C == TDLC_clauseb && 2 <= Version && 2147483647 >= Version)
// IMPL-NEXT: return true;
// IMPL-NEXT: return false;
// IMPL-NEXT: }

llvm/utils/TableGen/DirectiveEmitter.cpp

Show All 16 Lines
#include "llvm/TableGen/Error.h" #include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h" #include "llvm/TableGen/Record.h"
#include "llvm/TableGen/TableGenBackend.h" #include "llvm/TableGen/TableGenBackend.h"
using namespace llvm; using namespace llvm;
namespace llvm { namespace llvm {
// Get Directive or Clause name formatted by replacing whitespaces with
// underscores.
std::string getFormattedName(StringRef Name) {
std::string N = Name.str();
std::replace(N.begin(), N.end(), ' ', '_');
return N;
}
// Generate enum class // Generate enum class
void GenerateEnumClass(const std::vector<Record *> &Records, raw_ostream &OS, void GenerateEnumClass(const std::vector<Record *> &Records, raw_ostream &OS,
StringRef Enum, StringRef Prefix, StringRef CppNamespace, StringRef Enum, StringRef Prefix, StringRef CppNamespace,
bool MakeEnumAvailableInNamespace) { bool MakeEnumAvailableInNamespace) {
OS << "\n"; OS << "\n";
OS << "enum class " << Enum << " {\n"; OS << "enum class " << Enum << " {\n";
for (const auto &R : Records) { for (const auto &R : Records) {
const auto Name = R->getValueAsString("name"); const auto Name = R->getValueAsString("name");
std::string N = Name.str(); OS << " " << Prefix << getFormattedName(Name) << ",\n";
std::replace(N.begin(), N.end(), ' ', '_');
OS << " " << Prefix << N << ",\n";
} }
OS << "};\n"; OS << "};\n";
OS << "\n"; OS << "\n";
OS << "static constexpr std::size_t " << Enum OS << "static constexpr std::size_t " << Enum
<< "_enumSize = " << Records.size() << ";\n"; << "_enumSize = " << Records.size() << ";\n";
// Make the enum values available in the defined namespace. This allows us to // Make the enum values available in the defined namespace. This allows us to
// write something like Enum_X if we have a `using namespace <CppNamespace>`. // write something like Enum_X if we have a `using namespace <CppNamespace>`.
// At the same time we do not loose the strong type guarantees of the enum // At the same time we do not loose the strong type guarantees of the enum
// class, that is we cannot pass an unsigned as Directive without an explicit // class, that is we cannot pass an unsigned as Directive without an explicit
// cast. // cast.
if (MakeEnumAvailableInNamespace) { if (MakeEnumAvailableInNamespace) {
OS << "\n"; OS << "\n";
for (const auto &R : Records) { for (const auto &R : Records) {
const auto Name = R->getValueAsString("name"); const auto FormattedName = getFormattedName(R->getValueAsString("name"));
jdennyUnsubmitted
Done
ReplyInline Actions

Any reason not to call getFormattedName here instead of twice below?

jdenny: Any reason not to call `getFormattedName` here instead of twice below?
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

Updated in the patch.

clementval: Updated in the patch.
std::string N = Name.str(); OS << "constexpr auto " << Prefix << FormattedName << " = "
std::replace(N.begin(), N.end(), ' ', '_'); << "llvm::" << CppNamespace << "::" << Enum << "::" << Prefix
OS << "constexpr auto " << Prefix << N << " = " << FormattedName << ";\n";
<< "llvm::" << CppNamespace << "::" << Enum << "::" << Prefix << N
<< ";\n";
} }
} }
} }
// Generate the declaration section for the enumeration in the directive // Generate the declaration section for the enumeration in the directive
// language // language
void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) { void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linesvoid EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
OS << "\n"; OS << "\n";
OS << "llvm::StringRef get" << LanguageName OS << "llvm::StringRef get" << LanguageName
<< "DirectiveName(Directive D);\n"; << "DirectiveName(Directive D);\n";
OS << "\n"; OS << "\n";
OS << "Clause get" << LanguageName << "ClauseKind(llvm::StringRef Str);\n"; OS << "Clause get" << LanguageName << "ClauseKind(llvm::StringRef Str);\n";
OS << "\n"; OS << "\n";
OS << "llvm::StringRef get" << LanguageName << "ClauseName(Clause C);\n"; OS << "llvm::StringRef get" << LanguageName << "ClauseName(Clause C);\n";
OS << "\n"; OS << "\n";
OS << "/// Return true if \\p C is a valid clause for \\p D in version \\p "
<< "Version.\n";
OS << "bool isAllowedClauseForDirective(Directive D, "
<< "Clause C, unsigned Version);\n";
OS << "\n";
// Closing namespaces // Closing namespaces
for (auto Ns : llvm::reverse(Namespaces)) for (auto Ns : llvm::reverse(Namespaces))
OS << "} // namespace " << Ns << "\n"; OS << "} // namespace " << Ns << "\n";
OS << "} // namespace llvm\n"; OS << "} // namespace llvm\n";
OS << "#endif // LLVM_" << LanguageName << "_INC\n"; OS << "#endif // LLVM_" << LanguageName << "_INC\n";
} }
// Generate function implementation for get<Enum>Name(StringRef Str) // Generate function implementation for get<Enum>Name(StringRef Str)
void GenerateGetName(const std::vector<Record *> &Records, raw_ostream &OS, void GenerateGetName(const std::vector<Record *> &Records, raw_ostream &OS,
StringRef Enum, StringRef Prefix, StringRef LanguageName, StringRef Enum, StringRef Prefix, StringRef LanguageName,
StringRef Namespace) { StringRef Namespace) {
OS << "\n"; OS << "\n";
OS << "llvm::StringRef llvm::" << Namespace << "::get" << LanguageName << Enum OS << "llvm::StringRef llvm::" << Namespace << "::get" << LanguageName << Enum
<< "Name(" << Enum << " Kind) {\n"; << "Name(" << Enum << " Kind) {\n";
OS << " switch (Kind) {\n"; OS << " switch (Kind) {\n";
for (const auto &R : Records) { for (const auto &R : Records) {
const auto Name = R->getValueAsString("name"); const auto Name = R->getValueAsString("name");
const auto AlternativeName = R->getValueAsString("alternativeName"); const auto AlternativeName = R->getValueAsString("alternativeName");
std::string N = Name.str(); OS << " case " << Prefix << getFormattedName(Name) << ":\n";
std::replace(N.begin(), N.end(), ' ', '_');
OS << " case " << Prefix << N << ":\n";
OS << " return \""; OS << " return \"";
if (AlternativeName.empty()) if (AlternativeName.empty())
OS << Name; OS << Name;
else else
OS << AlternativeName; OS << AlternativeName;
OS << "\";\n"; OS << "\";\n";
} }
OS << " }\n"; // switch OS << " }\n"; // switch
Show All 10 Linesvoid GenerateGetKind(const std::vector<Record *> &Records, raw_ostream &OS,
auto DefaultIt = std::find_if(Records.begin(), Records.end(), [](Record *R) { auto DefaultIt = std::find_if(Records.begin(), Records.end(), [](Record *R) {
return R->getValueAsBit("isDefault") == true; return R->getValueAsBit("isDefault") == true;
}); });
if (DefaultIt == Records.end()) { if (DefaultIt == Records.end()) {
PrintError("A least one " + Enum + " must be defined as default."); PrintError("A least one " + Enum + " must be defined as default.");
return; return;
} }
const auto DefaultName = (*DefaultIt)->getValueAsString("name"); const auto FormattedDefaultName =
std::string DefaultEnum = DefaultName.str(); getFormattedName((*DefaultIt)->getValueAsString("name"));
jdennyUnsubmitted
Done
ReplyInline Actions

Call getFormattedName(DefaultName) once here?

jdenny: Call `getFormattedName(DefaultName)` once here?
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

Updated as well.

clementval: Updated as well.
std::replace(DefaultEnum.begin(), DefaultEnum.end(), ' ', '_');
OS << "\n"; OS << "\n";
OS << Enum << " llvm::" << Namespace << "::get" << LanguageName << Enum OS << Enum << " llvm::" << Namespace << "::get" << LanguageName << Enum
<< "Kind(llvm::StringRef Str) {\n"; << "Kind(llvm::StringRef Str) {\n";
OS << " return llvm::StringSwitch<" << Enum << ">(Str)\n"; OS << " return llvm::StringSwitch<" << Enum << ">(Str)\n";
for (const auto &R : Records) { for (const auto &R : Records) {
const auto Name = R->getValueAsString("name"); const auto Name = R->getValueAsString("name");
std::string N = Name.str();
std::replace(N.begin(), N.end(), ' ', '_');
if (ImplicitAsUnknown && R->getValueAsBit("isImplicit")) { if (ImplicitAsUnknown && R->getValueAsBit("isImplicit")) {
OS << " .Case(\"" << Name << "\"," << Prefix << DefaultEnum << ")\n"; OS << " .Case(\"" << Name << "\"," << Prefix << FormattedDefaultName
<< ")\n";
} else { } else {
OS << " .Case(\"" << Name << "\"," << Prefix << N << ")\n"; OS << " .Case(\"" << Name << "\"," << Prefix << getFormattedName(Name)
<< ")\n";
}
}
OS << " .Default(" << Prefix << FormattedDefaultName << ");\n";
OS << "}\n";
}
void GenerateTestForAllowedClauses(const std::vector<Record *> &Clauses,
raw_ostream &OS, StringRef DirectiveName,
StringRef DirectivePrefix,
StringRef ClausePrefix) {
const auto FormattedDirectiveName = getFormattedName(DirectiveName);
for (const auto &C : Clauses) {
const auto MinVersion = C->getValueAsInt("minVersion");
const auto MaxVersion = C->getValueAsInt("maxVersion");
const auto SpecificClause = C->getValueAsDef("clause");
const auto ClauseName = SpecificClause->getValueAsString("name");
jdennyUnsubmitted
Done
ReplyInline Actions

Hoist getFormattedName(DirectiveName) out of the loop?

jdenny: Hoist `getFormattedName(DirectiveName)` out of the loop?
OS << " if (D == " << DirectivePrefix << FormattedDirectiveName
<< " && C == " << ClausePrefix << getFormattedName(ClauseName) << " && "
<< MinVersion << " <= Version && " << MaxVersion << " >= Version)\n";
OS << " return true;\n";
}
} }
// Generate the isAllowedClauseForDirective function implementation.
jdennyUnsubmitted
Done
ReplyInline Actions

I'd drop this comment's last two sentences, which don't seem like they will be meaningful after pushing.

jdenny: I'd drop this comment's last two sentences, which don't seem like they will be meaningful after…
void GenerateIsAllowedClause(const std::vector<Record *> &Directives,
raw_ostream &OS, StringRef DirectivePrefix,
StringRef ClausePrefix, StringRef CppNamespace) {
OS << "\n";
OS << "bool llvm::" << CppNamespace << "::isAllowedClauseForDirective("
<< "Directive D, Clause C, unsigned Version) {\n";
OS << " assert(unsigned(D) <= llvm::" << CppNamespace
<< "::Directive_enumSize);\n";
OS << " assert(unsigned(C) <= llvm::" << CppNamespace
<< "::Clause_enumSize);\n";
for (const auto &D : Directives) {
const auto DirectiveName = D->getValueAsString("name");
const auto &AllowedClauses = D->getValueAsListOfDefs("allowedClauses");
GenerateTestForAllowedClauses(AllowedClauses, OS, DirectiveName,
DirectivePrefix, ClausePrefix);
const auto &AllowedOnceClauses =
D->getValueAsListOfDefs("allowedOnceClauses");
GenerateTestForAllowedClauses(AllowedOnceClauses, OS, DirectiveName,
DirectivePrefix, ClausePrefix);
const auto &RequiredClauses = D->getValueAsListOfDefs("requiredClauses");
GenerateTestForAllowedClauses(RequiredClauses, OS, DirectiveName,
DirectivePrefix, ClausePrefix);
} }
OS << " .Default(" << Prefix << DefaultEnum << ");\n"; OS << " return false;\n";
OS << "}\n"; OS << "}\n";
} }
// Generate the implemenation section for the enumeration in the directive // Generate the implemenation section for the enumeration in the directive
// language // language
void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) { void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
const auto &DirectiveLanguages = const auto &DirectiveLanguages =
Show All 24 Linesvoid EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
// getClauseKind(StringRef Str) // getClauseKind(StringRef Str)
GenerateGetKind(Clauses, OS, "Clause", ClausePrefix, LanguageName, GenerateGetKind(Clauses, OS, "Clause", ClausePrefix, LanguageName,
CppNamespace, /*ImplicitAsUnknown=*/true); CppNamespace, /*ImplicitAsUnknown=*/true);
// getClauseName(Clause Kind) // getClauseName(Clause Kind)
GenerateGetName(Clauses, OS, "Clause", ClausePrefix, LanguageName, GenerateGetName(Clauses, OS, "Clause", ClausePrefix, LanguageName,
CppNamespace); CppNamespace);
GenerateIsAllowedClause(Directives, OS, DirectivePrefix, ClausePrefix,
CppNamespace);
OS << "\n"; // Empty line at end of file
jdennyUnsubmitted
Done
ReplyInline Actions

Why is an empty line needed?

jdenny: Why is an empty line needed?
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

Just to be consistent with clang-format in the generated file.

clementval: Just to be consistent with clang-format in the generated file.
jdennyUnsubmitted
Done
ReplyInline Actions

It's surprising that clang-format would require an empty line at the end of the file. Any idea why?

jdenny: It's surprising that clang-format would require an empty line at the end of the file. Any idea…
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

Sorry, it is not clang-format but Phabricator which signal a missing empty line at end of file. This is not mandatory and can be removed. The file is generated. I just wanted to be consistent with the style.

clementval: Sorry, it is not clang-format but Phabricator which signal a missing empty line at end of file.
jdennyUnsubmitted
Done
ReplyInline Actions

Are you referring to, for example, the version of directive2.td on the left side of this diff? Here, phabricator points out that the final line in the file is not newline-terminated. I don't recall seeing phabricator suggest an additional empty line.

Likewise, in EmitDirectivesImpl, the final GenerateIsAllowedClause call already newline-terminates the final line of the generated file, so I don't see a need for an additional empty line.

jdenny: Are you referring to, for example, the version of `directive2.td` on the left side of this diff?
clementvalAuthorUnsubmitted
Done
ReplyInline Actions

Your are correct. I removed this since it was a confusion on my side.

clementval: Your are correct. I removed this since it was a confusion on my side.
} }
} // namespace llvm } // namespace llvm