16#ifndef LLVM_CLANG_AST_OPENMPCLAUSE_H
17#define LLVM_CLANG_AST_OPENMPCLAUSE_H
29#include "llvm/ADT/ArrayRef.h"
30#include "llvm/ADT/MapVector.h"
31#include "llvm/ADT/PointerIntPair.h"
32#include "llvm/ADT/SmallVector.h"
33#include "llvm/ADT/iterator.h"
34#include "llvm/ADT/iterator_range.h"
35#include "llvm/Frontend/OpenMP/OMPAssume.h"
36#include "llvm/Frontend/OpenMP/OMPConstants.h"
37#include "llvm/Frontend/OpenMP/OMPContext.h"
38#include "llvm/Support/Casting.h"
39#include "llvm/Support/Compiler.h"
40#include "llvm/Support/TrailingObjects.h"
67 : StartLoc(StartLoc), EndLoc(EndLoc), Kind(K) {}
110template <OpenMPClauseKind ClauseKind>
117 :
OMPClause(ClauseKind, StartLoc, EndLoc) {}
139 return T->getClauseKind() == ClauseKind;
143template <OpenMPClauseKind ClauseKind,
class Base>
158 :
Base(ClauseKind, StartLoc, EndLoc), LParenLoc(LParenLoc), S(S) {}
163 template <
typename T>
T *
getStmtAs()
const {
return cast_or_null<T>(S); }
189 return T->getClauseKind() == ClauseKind;
199 Stmt *PreInit =
nullptr;
206 assert(
get(
This) &&
"get is not tuned for pre-init.");
214 CaptureRegion = ThisRegion;
237 Expr *PostUpdate =
nullptr;
241 assert(
get(
This) &&
"get is not tuned for post-update.");
294 :
OMPClause(K, StartLoc, EndLoc), LParenLoc(LParenLoc), NumVars(N) {}
298 return static_cast<T *
>(
this)->
template getTrailingObjectsNonStrict<Expr *>(
304 assert(VL.size() == NumVars &&
305 "Number of variables is not the same as the preallocated buffer");
338 return static_cast<const T *
>(
this)
339 ->
template getTrailingObjectsNonStrict<Expr *>(NumVars);
364 :
OMPClause(K, StartLoc, EndLoc), LParenLoc(LParenLoc),
383 return static_cast<T *
>(
this)
384 ->
template getTrailingObjectsNonStrict<OpenMPDirectiveKind>(
NumKinds);
390 "Number of directive kinds is not the same as the preallocated buffer");
441class OMPAlignClause final
468 static OMPAlignClause *
Create(
const ASTContext &
C, Expr *A,
469 SourceLocation StartLoc,
470 SourceLocation LParenLoc,
471 SourceLocation EndLoc);
485class OMPAllocateClause final
486 :
public OMPVarListClause<OMPAllocateClause>,
487 private llvm::TrailingObjects<OMPAllocateClause, Expr *> {
489 friend OMPVarListClause;
490 friend TrailingObjects;
494 Expr *Allocator =
nullptr;
497 Expr *Alignment =
nullptr;
508 enum { FIRST, SECOND, NUM_MODIFIERS };
518 Modifiers[FIRST] = M;
524 void setSecondAllocateModifier(OpenMPAllocateClauseModifier M) {
525 Modifiers[SECOND] = M;
529 void setFirstAllocateModifierLoc(SourceLocation Loc) {
530 ModifiersLoc[FIRST] = Loc;
534 void setSecondAllocateModifierLoc(SourceLocation Loc) {
535 ModifiersLoc[SECOND] = Loc;
548 OMPAllocateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
549 Expr *Allocator, Expr *Alignment, SourceLocation ColonLoc,
551 SourceLocation Modifier1Loc,
553 SourceLocation Modifier2Loc, SourceLocation EndLoc,
555 : OMPVarListClause<OMPAllocateClause>(llvm::omp::OMPC_allocate, StartLoc,
556 LParenLoc, EndLoc, N),
557 Allocator(Allocator), Alignment(Alignment), ColonLoc(ColonLoc) {
558 Modifiers[FIRST] = Modifier1;
559 Modifiers[SECOND] = Modifier2;
560 ModifiersLoc[FIRST] = Modifier1Loc;
561 ModifiersLoc[SECOND] = Modifier2Loc;
567 explicit OMPAllocateClause(
unsigned N)
568 : OMPVarListClause<OMPAllocateClause>(llvm::omp::OMPC_allocate,
569 SourceLocation(), SourceLocation(),
570 SourceLocation(), N) {
576 void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
578 void setAllocator(Expr *A) { Allocator = A; }
580 AllocatorModifier = AM;
582 void setAlignment(Expr *A) { Alignment = A; }
596 static OMPAllocateClause *
597 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
598 Expr *Allocator, Expr *Alignment, SourceLocation ColonLoc,
601 SourceLocation EndLoc, ArrayRef<Expr *> VL);
611 return AllocatorModifier;
616 return Modifiers[FIRST];
621 return ModifiersLoc[FIRST];
626 return Modifiers[SECOND];
631 return ModifiersLoc[SECOND];
638 return AllocatorModifierLoc;
665 return T->getClauseKind() == llvm::omp::OMPC_allocate;
683 Stmt *Condition =
nullptr;
701 void setNameModifierLoc(SourceLocation Loc) { NameModifierLoc = Loc; }
704 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
725 ColonLoc(ColonLoc), NameModifier(NameModifier),
726 NameModifierLoc(NameModifierLoc) {
766 return T->getClauseKind() == llvm::omp::OMPC_if;
841 void setNumThreads(Expr *NThreads) {
setStmt(NThreads); }
861 ModifierLoc(ModifierLoc) {
956class OMPSizesClause final
958 private llvm::TrailingObjects<OMPSizesClause, Expr *> {
960 friend class llvm::TrailingObjects<OMPSizesClause,
Expr *>;
969 explicit OMPSizesClause(
int NumSizes)
971 NumSizes(NumSizes) {}
1002 return getTrailingObjects(NumSizes);
1008 assert(VL.size() == NumSizes);
1015 reinterpret_cast<Stmt **
>(Sizes.end()));
1020 reinterpret_cast<Stmt *
const *
>(Sizes.end()));
1031 return T->getClauseKind() == llvm::omp::OMPC_sizes;
1043class OMPPermutationClause final
1045 private llvm::TrailingObjects<OMPSizesClause, Expr *> {
1058 assert(VL.size() == NumLoops &&
"Expecting one expression per loop");
1059 llvm::copy(VL, getTrailingObjects());
1066 NumLoops(NumLoops) {}
1076 static OMPPermutationClause *
1105 reinterpret_cast<Stmt **
>(Args.end()));
1110 reinterpret_cast<Stmt *
const *
>(Args.end()));
1121 return T->getClauseKind() == llvm::omp::OMPC_permutation;
1171 enum { FirstExpr, CountExpr, NumArgs };
1172 Stmt *Args[NumArgs] = {
nullptr,
nullptr};
1175 void setFirst(Expr *E) { Args[FirstExpr] = E; }
1178 void setCount(Expr *E) { Args[CountExpr] = E; }
1181 explicit OMPLoopRangeClause()
1182 :
OMPClause(llvm::omp::OMPC_looprange, {}, {}) {}
1186 static OMPLoopRangeClause *
1187 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
1188 SourceLocation FirstLoc, SourceLocation CountLoc,
1189 SourceLocation EndLoc, Expr *
First, Expr *Count);
1192 static OMPLoopRangeClause *
CreateEmpty(
const ASTContext &
C);
1222 return T->getClauseKind() == llvm::omp::OMPC_looprange;
1243 explicit OMPPartialClause() :
OMPClause(
llvm::omp::OMPC_partial, {}, {}) {}
1246 void setFactor(Expr *E) { Factor = E; }
1249 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
1259 static OMPPartialClause *
Create(
const ASTContext &
C, SourceLocation StartLoc,
1260 SourceLocation LParenLoc,
1261 SourceLocation EndLoc, Expr *Factor);
1266 static OMPPartialClause *
CreateEmpty(
const ASTContext &
C);
1287 return T->getClauseKind() == llvm::omp::OMPC_partial;
1341 llvm::omp::DefaultKind Kind = llvm::omp::OMP_DEFAULT_unknown;
1355 void setDefaultKind(llvm::omp::DefaultKind K) { Kind = K; }
1360 void setDefaultKindKwLoc(
SourceLocation KLoc) { KindKwLoc = KLoc; }
1363 void setDefaultVariableCategory(OpenMPDefaultClauseVariableCategory VC) {
1367 void setDefaultVariableCategoryLocation(SourceLocation VCLoc) {
1368 this->VCLoc = VCLoc;
1384 LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc), VC(VC), VCLoc(VCLoc) {}
1423 return T->getClauseKind() == llvm::omp::OMPC_default;
1442 llvm::omp::ProcBindKind Kind = llvm::omp::OMP_PROC_BIND_unknown;
1450 void setProcBindKind(llvm::omp::ProcBindKind K) { Kind = K; }
1455 void setProcBindKindKwLoc(
SourceLocation KLoc) { KindKwLoc = KLoc; }
1470 LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc) {}
1505 return T->getClauseKind() == llvm::omp::OMPC_proc_bind;
1548 :
OMPClause(
llvm::omp::OMPC_unified_shared_memory, StartLoc, EndLoc) {}
1571 return T->getClauseKind() == llvm::omp::OMPC_unified_shared_memory;
1591 :
OMPClause(
llvm::omp::OMPC_reverse_offload, StartLoc, EndLoc) {}
1614 return T->getClauseKind() == llvm::omp::OMPC_reverse_offload;
1634 :
OMPClause(
llvm::omp::OMPC_dynamic_allocators, StartLoc, EndLoc) {}
1657 return T->getClauseKind() == llvm::omp::OMPC_dynamic_allocators;
1709 :
OMPClause(
llvm::omp::OMPC_atomic_default_mem_order, StartLoc, EndLoc),
1710 LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc) {}
1747 return T->getClauseKind() == llvm::omp::OMPC_atomic_default_mem_order;
1790 return T->getClauseKind() == llvm::omp::OMPC_self_maps;
1824 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
1837 :
OMPClause(
llvm::omp::OMPC_at, StartLoc, EndLoc), LParenLoc(LParenLoc),
1838 Kind(A), KindKwLoc(ALoc) {}
1869 return T->getClauseKind() == llvm::omp::OMPC_at;
1901 void setSeverityKindKwLoc(
SourceLocation KLoc) { KindKwLoc = KLoc; }
1904 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
1918 LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc) {}
1950 return T->getClauseKind() == llvm::omp::OMPC_severity;
1997 return MessageExpr->tryEvaluateString(Ctx);
1998 return std::nullopt;
2019 enum {FIRST, SECOND, NUM_MODIFIERS};
2032 Expr *ChunkSize =
nullptr;
2042 void setFirstScheduleModifier(OpenMPScheduleClauseModifier M) {
2043 Modifiers[FIRST] = M;
2050 Modifiers[SECOND] = M;
2054 void setFirstScheduleModifierLoc(SourceLocation Loc) {
2055 ModifiersLoc[FIRST] = Loc;
2059 void setSecondScheduleModifierLoc(SourceLocation Loc) {
2060 ModifiersLoc[SECOND] = Loc;
2068 Modifiers[FIRST] = M;
2071 Modifiers[SECOND] = M;
2078 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
2083 void setScheduleKindLoc(SourceLocation KLoc) { KindLoc = KLoc; }
2088 void setCommaLoc(SourceLocation Loc) { CommaLoc = Loc; }
2093 void setChunkSize(Expr *E) { ChunkSize = E; }
2114 Expr *ChunkSize,
Stmt *HelperChunkSize,
2119 KindLoc(KLoc), CommaLoc(CommaLoc), ChunkSize(ChunkSize) {
2121 Modifiers[FIRST] = M1;
2122 Modifiers[SECOND] = M2;
2123 ModifiersLoc[FIRST] = M1Loc;
2124 ModifiersLoc[SECOND] = M2Loc;
2140 return Modifiers[FIRST];
2145 return Modifiers[SECOND];
2156 return ModifiersLoc[FIRST];
2161 return ModifiersLoc[SECOND];
2175 reinterpret_cast<Stmt **
>(&ChunkSize) + 1);
2191 return T->getClauseKind() == llvm::omp::OMPC_schedule;
2202class OMPOrderedClause final
2204 private llvm::TrailingObjects<OMPOrderedClause, Expr *> {
2206 friend TrailingObjects;
2212 Stmt *NumForLoops =
nullptr;
2215 unsigned NumberOfLoops = 0;
2227 LParenLoc(LParenLoc), NumForLoops(
Num), NumberOfLoops(NumLoops) {}
2232 NumberOfLoops(NumLoops) {}
2235 void setNumForLoops(Expr *Num) { NumForLoops = Num; }
2245 static OMPOrderedClause *
Create(
const ASTContext &
C, Expr *
Num,
2246 unsigned NumLoops, SourceLocation StartLoc,
2247 SourceLocation LParenLoc,
2248 SourceLocation EndLoc);
2251 static OMPOrderedClause*
CreateEmpty(
const ASTContext &
C,
unsigned NumLoops);
2287 return T->getClauseKind() == llvm::omp::OMPC_ordered;
2343 return T->getClauseKind() == llvm::omp::OMPC_untied;
2384 return T->getClauseKind() == llvm::omp::OMPC_mergeable;
2395class OMPAbsentClause final
2396 :
public OMPDirectiveListClause<OMPAbsentClause>,
2397 private llvm::TrailingObjects<OMPAbsentClause, OpenMPDirectiveKind> {
2398 friend OMPDirectiveListClause;
2399 friend TrailingObjects;
2409 : OMPDirectiveListClause<OMPAbsentClause>(
2410 llvm::omp::OMPC_absent, StartLoc, LParenLoc, EndLoc,
NumKinds) {}
2414 : OMPDirectiveListClause<OMPAbsentClause>(
2427 return C->getClauseKind() == llvm::omp::OMPC_absent;
2438class OMPContainsClause final
2439 :
public OMPDirectiveListClause<OMPContainsClause>,
2440 private llvm::TrailingObjects<OMPContainsClause, OpenMPDirectiveKind> {
2441 friend OMPDirectiveListClause;
2442 friend TrailingObjects;
2452 : OMPDirectiveListClause<OMPContainsClause>(
2453 llvm::omp::OMPC_contains, StartLoc, LParenLoc, EndLoc,
NumKinds) {}
2456 OMPContainsClause(
unsigned NumKinds)
2457 : OMPDirectiveListClause<OMPContainsClause>(
2470 return C->getClauseKind() == llvm::omp::OMPC_contains;
2623 return T->getClauseKind() == llvm::omp::OMPC_read;
2662 return T->getClauseKind() == llvm::omp::OMPC_write;
2681class OMPUpdateClause final
2683 private llvm::TrailingObjects<OMPUpdateClause, SourceLocation,
2684 OpenMPDependClauseKind> {
2686 friend TrailingObjects;
2689 bool IsExtended =
false;
2693 size_t numTrailingObjects(OverloadToken<SourceLocation>)
const {
2695 return IsExtended ? 2 : 0;
2700 assert(IsExtended &&
"Expected extended clause.");
2701 *getTrailingObjects<SourceLocation>() = Loc;
2705 void setArgumentLoc(SourceLocation Loc) {
2706 assert(IsExtended &&
"Expected extended clause.");
2707 *std::next(getTrailingObjects<SourceLocation>(), 1) = Loc;
2712 assert(IsExtended &&
"Expected extended clause.");
2713 *getTrailingObjects<OpenMPDependClauseKind>() = DK;
2720 OMPUpdateClause(SourceLocation StartLoc, SourceLocation EndLoc,
2722 :
OMPClause(llvm::omp::OMPC_update, StartLoc, EndLoc),
2723 IsExtended(IsExtended) {}
2726 OMPUpdateClause(
bool IsExtended)
2727 :
OMPClause(llvm::omp::OMPC_update, SourceLocation(), SourceLocation()),
2728 IsExtended(IsExtended) {}
2736 static OMPUpdateClause *
Create(
const ASTContext &
C, SourceLocation StartLoc,
2737 SourceLocation EndLoc);
2747 static OMPUpdateClause *
Create(
const ASTContext &
C, SourceLocation StartLoc,
2748 SourceLocation LParenLoc,
2749 SourceLocation ArgumentLoc,
2751 SourceLocation EndLoc);
2758 static OMPUpdateClause *
CreateEmpty(
const ASTContext &
C,
bool IsExtended);
2780 assert(IsExtended &&
"Expected extended clause.");
2781 return *getTrailingObjects<SourceLocation>();
2786 assert(IsExtended &&
"Expected extended clause.");
2787 return *std::next(getTrailingObjects<SourceLocation>(), 1);
2792 assert(IsExtended &&
"Expected extended clause.");
2793 return *getTrailingObjects<OpenMPDependClauseKind>();
2797 return T->getClauseKind() == llvm::omp::OMPC_update;
2838 return T->getClauseKind() == llvm::omp::OMPC_capture;
2879 return T->getClauseKind() == llvm::omp::OMPC_compare;
2920 return T->getClauseKind() == llvm::omp::OMPC_seq_cst;
2961 return T->getClauseKind() == llvm::omp::OMPC_acq_rel;
3002 return T->getClauseKind() == llvm::omp::OMPC_acquire;
3043 return T->getClauseKind() == llvm::omp::OMPC_release;
3084 return T->getClauseKind() == llvm::omp::OMPC_relaxed;
3124 return T->getClauseKind() == llvm::omp::OMPC_weak;
3149 void setFailParameterLoc(
SourceLocation Loc) { FailParameterLoc = Loc; }
3153 this->FailParameter = FailParameter;
3155 "Invalid fail clause parameter");
3170 FailParameterLoc(FailParameterLoc), LParenLoc(LParenLoc) {
3172 setFailParameter(FailParameter);
3195 return T->getClauseKind() == llvm::omp::OMPC_fail;
3218class OMPPrivateClause final
3219 :
public OMPVarListClause<OMPPrivateClause>,
3220 private llvm::TrailingObjects<OMPPrivateClause, Expr *> {
3222 friend OMPVarListClause;
3223 friend TrailingObjects;
3233 : OMPVarListClause<OMPPrivateClause>(
llvm::omp::OMPC_private, StartLoc,
3234 LParenLoc, EndLoc, N) {}
3251 MutableArrayRef<Expr *> getPrivateCopies() {
3254 ArrayRef<const Expr *> getPrivateCopies()
const {
3267 static OMPPrivateClause *
Create(
const ASTContext &
C, SourceLocation StartLoc,
3268 SourceLocation LParenLoc,
3269 SourceLocation EndLoc, ArrayRef<Expr *> VL,
3270 ArrayRef<Expr *> PrivateVL);
3276 static OMPPrivateClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
3282 llvm::iterator_range<private_copies_const_iterator>;
3286 getPrivateCopies().end());
3291 getPrivateCopies().end());
3312 return T->getClauseKind() == llvm::omp::OMPC_private;
3324class OMPFirstprivateClause final
3325 :
public OMPVarListClause<OMPFirstprivateClause>,
3327 private llvm::TrailingObjects<OMPFirstprivateClause, Expr *> {
3329 friend OMPVarListClause;
3330 friend TrailingObjects;
3340 : OMPVarListClause<OMPFirstprivateClause>(
llvm::omp::OMPC_firstprivate,
3341 StartLoc, LParenLoc, EndLoc, N),
3360 MutableArrayRef<Expr *> getPrivateCopies() {
3363 ArrayRef<const Expr *> getPrivateCopies()
const {
3370 void setInits(ArrayRef<Expr *> VL);
3374 MutableArrayRef<Expr *> getInits() {
3377 ArrayRef<const Expr *> getInits()
const {
3395 static OMPFirstprivateClause *
3396 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
3397 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
3398 ArrayRef<Expr *> InitVL, Stmt *PreInit);
3404 static OMPFirstprivateClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
3410 llvm::iterator_range<private_copies_const_iterator>;
3414 getPrivateCopies().end());
3418 getPrivateCopies().end());
3427 return inits_range(getInits().begin(), getInits().end());
3453 return T->getClauseKind() == llvm::omp::OMPC_firstprivate;
3465class OMPLastprivateClause final
3466 :
public OMPVarListClause<OMPLastprivateClause>,
3468 private llvm::TrailingObjects<OMPLastprivateClause, Expr *> {
3486 friend OMPVarListClause;
3487 friend TrailingObjects;
3506 : OMPVarListClause<OMPLastprivateClause>(
llvm::omp::OMPC_lastprivate,
3507 StartLoc, LParenLoc, EndLoc, N),
3509 ColonLoc(ColonLoc) {}
3522 MutableArrayRef<Expr *> getPrivateCopies() {
3525 ArrayRef<const Expr *> getPrivateCopies()
const {
3533 void setSourceExprs(ArrayRef<Expr *> SrcExprs);
3536 MutableArrayRef<Expr *> getSourceExprs() {
3539 ArrayRef<const Expr *> getSourceExprs()
const {
3547 void setDestinationExprs(ArrayRef<Expr *> DstExprs);
3550 MutableArrayRef<Expr *> getDestinationExprs() {
3553 ArrayRef<const Expr *> getDestinationExprs()
const {
3560 void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);
3563 MutableArrayRef<Expr *> getAssignmentOps() {
3566 ArrayRef<const Expr *> getAssignmentOps()
const {
3573 void setKindLoc(SourceLocation Loc) { LPKindLoc = Loc; }
3575 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
3605 static OMPLastprivateClause *
3606 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
3607 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
3608 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps,
3610 SourceLocation ColonLoc, Stmt *PreInit, Expr *PostUpdate);
3616 static OMPLastprivateClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
3629 llvm::iterator_range<helper_expr_const_iterator>;
3637 getPrivateCopies().end());
3642 getPrivateCopies().end());
3647 getSourceExprs().end());
3656 getDestinationExprs().end());
3661 getDestinationExprs().end());
3666 getAssignmentOps().end());
3671 getAssignmentOps().end());
3692 return T->getClauseKind() == llvm::omp::OMPC_lastprivate;
3703class OMPSharedClause final
3704 :
public OMPVarListClause<OMPSharedClause>,
3705 private llvm::TrailingObjects<OMPSharedClause, Expr *> {
3706 friend OMPVarListClause;
3707 friend TrailingObjects;
3717 : OMPVarListClause<OMPSharedClause>(llvm::omp::OMPC_shared, StartLoc,
3718 LParenLoc, EndLoc, N) {}
3723 explicit OMPSharedClause(
unsigned N)
3724 : OMPVarListClause<OMPSharedClause>(llvm::omp::OMPC_shared,
3764 return T->getClauseKind() == llvm::omp::OMPC_shared;
3776class OMPReductionClause final
3777 :
public OMPVarListClause<OMPReductionClause>,
3779 private llvm::TrailingObjects<OMPReductionClause, Expr *, bool> {
3781 friend OMPVarListClause;
3782 friend TrailingObjects;
3789 OMPC_ORIGINAL_SHARING_default;
3820 : OMPVarListClause<OMPReductionClause>(
llvm::omp::OMPC_reduction,
3821 StartLoc, LParenLoc, EndLoc, N),
3823 OriginalSharingModifier(OriginalSharingModifier),
3824 ModifierLoc(ModifierLoc), ColonLoc(ColonLoc),
3825 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
3837 void setModifier(OpenMPReductionClauseModifier M) { Modifier = M; }
3841 OriginalSharingModifier = M;
3845 void setModifierLoc(SourceLocation Loc) { ModifierLoc = Loc; }
3848 void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
3851 void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
3854 void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; }
3859 void setPrivates(ArrayRef<Expr *> Privates);
3862 MutableArrayRef<Expr *> getPrivates() {
3865 ArrayRef<const Expr *> getPrivates()
const {
3872 void setLHSExprs(ArrayRef<Expr *> LHSExprs);
3875 MutableArrayRef<Expr *> getLHSExprs() {
3878 ArrayRef<const Expr *> getLHSExprs()
const {
3887 void setRHSExprs(ArrayRef<Expr *> RHSExprs);
3890 void setPrivateVariableReductionFlags(ArrayRef<bool> Flags) {
3892 "Number of private flags does not match vars");
3893 llvm::copy(Flags, getTrailingObjects<bool>());
3897 MutableArrayRef<bool> getPrivateVariableReductionFlags() {
3900 ArrayRef<bool> getPrivateVariableReductionFlags()
const {
3905 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
3906 return varlist_size() * (Modifier == OMPC_REDUCTION_inscan ? 8 : 5);
3910 size_t numTrailingObjects(OverloadToken<bool>)
const {
3915 MutableArrayRef<Expr *> getRHSExprs() {
3916 return MutableArrayRef<Expr *>(getLHSExprs().end(),
varlist_size());
3918 ArrayRef<const Expr *> getRHSExprs()
const {
3926 void setReductionOps(ArrayRef<Expr *> ReductionOps);
3929 MutableArrayRef<Expr *> getReductionOps() {
3932 ArrayRef<const Expr *> getReductionOps()
const {
3938 void setInscanCopyOps(ArrayRef<Expr *> Ops);
3941 MutableArrayRef<Expr *> getInscanCopyOps() {
3944 ArrayRef<const Expr *> getInscanCopyOps()
const {
3949 void setInscanCopyArrayTemps(ArrayRef<Expr *> CopyArrayTemps);
3952 MutableArrayRef<Expr *> getInscanCopyArrayTemps() {
3955 ArrayRef<const Expr *> getInscanCopyArrayTemps()
const {
3960 void setInscanCopyArrayElems(ArrayRef<Expr *> CopyArrayElems);
3963 MutableArrayRef<Expr *> getInscanCopyArrayElems() {
3964 return {getInscanCopyArrayTemps().end(),
varlist_size()};
3966 ArrayRef<const Expr *> getInscanCopyArrayElems()
const {
3967 return {getInscanCopyArrayTemps().end(),
varlist_size()};
4011 static OMPReductionClause *
4012 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
4013 SourceLocation ModifierLoc, SourceLocation ColonLoc,
4015 ArrayRef<Expr *> VL, NestedNameSpecifierLoc QualifierLoc,
4016 const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
4017 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
4018 ArrayRef<Expr *> ReductionOps, ArrayRef<Expr *> CopyOps,
4019 ArrayRef<Expr *> CopyArrayTemps, ArrayRef<Expr *> CopyArrayElems,
4020 Stmt *PreInit, Expr *PostUpdate, ArrayRef<bool> IsPrivateVarReduction,
4028 static OMPReductionClause *
4037 return OriginalSharingModifier;
4056 llvm::iterator_range<helper_expr_const_iterator>;
4061 llvm::iterator_range<helper_flag_const_iterator>;
4089 getPrivateVariableReductionFlags().end());
4094 getPrivateVariableReductionFlags().end());
4099 getReductionOps().end());
4104 getReductionOps().end());
4109 getInscanCopyOps().end());
4114 getInscanCopyOps().end());
4119 getInscanCopyArrayTemps().end());
4124 getInscanCopyArrayTemps().end());
4129 getInscanCopyArrayElems().end());
4134 getInscanCopyArrayElems().end());
4157 return T->getClauseKind() == llvm::omp::OMPC_reduction;
4169class OMPTaskReductionClause final
4170 :
public OMPVarListClause<OMPTaskReductionClause>,
4172 private llvm::TrailingObjects<OMPTaskReductionClause, Expr *> {
4174 friend OMPVarListClause;
4175 friend TrailingObjects;
4199 : OMPVarListClause<OMPTaskReductionClause>(
4200 llvm::omp::OMPC_task_reduction, StartLoc, LParenLoc, EndLoc, N),
4202 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
4214 void setColonLoc(SourceLocation
CL) { ColonLoc =
CL; }
4217 void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
4220 void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; }
4224 void setPrivates(ArrayRef<Expr *> Privates);
4227 MutableArrayRef<Expr *> getPrivates() {
4230 ArrayRef<const Expr *> getPrivates()
const {
4237 void setLHSExprs(ArrayRef<Expr *> LHSExprs);
4240 MutableArrayRef<Expr *> getLHSExprs() {
4243 ArrayRef<const Expr *> getLHSExprs()
const {
4251 void setRHSExprs(ArrayRef<Expr *> RHSExprs);
4254 MutableArrayRef<Expr *> getRHSExprs() {
4257 ArrayRef<const Expr *> getRHSExprs()
const {
4265 void setReductionOps(ArrayRef<Expr *> ReductionOps);
4268 MutableArrayRef<Expr *> getReductionOps() {
4271 ArrayRef<const Expr *> getReductionOps()
const {
4308 static OMPTaskReductionClause *
4309 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
4310 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
4311 NestedNameSpecifierLoc QualifierLoc,
4312 const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
4313 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
4314 ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
4320 static OMPTaskReductionClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
4335 llvm::iterator_range<helper_expr_const_iterator>;
4363 getReductionOps().end());
4368 getReductionOps().end());
4389 return T->getClauseKind() == llvm::omp::OMPC_task_reduction;
4400class OMPInReductionClause final
4401 :
public OMPVarListClause<OMPInReductionClause>,
4403 private llvm::TrailingObjects<OMPInReductionClause, Expr *> {
4405 friend OMPVarListClause;
4406 friend TrailingObjects;
4430 : OMPVarListClause<OMPInReductionClause>(
llvm::omp::OMPC_in_reduction,
4431 StartLoc, LParenLoc, EndLoc, N),
4433 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
4445 void setColonLoc(SourceLocation
CL) { ColonLoc =
CL; }
4448 void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
4451 void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; }
4455 void setPrivates(ArrayRef<Expr *> Privates);
4458 MutableArrayRef<Expr *> getPrivates() {
4461 ArrayRef<const Expr *> getPrivates()
const {
4468 void setLHSExprs(ArrayRef<Expr *> LHSExprs);
4471 MutableArrayRef<Expr *> getLHSExprs() {
4474 ArrayRef<const Expr *> getLHSExprs()
const {
4482 void setRHSExprs(ArrayRef<Expr *> RHSExprs);
4485 MutableArrayRef<Expr *> getRHSExprs() {
4488 ArrayRef<const Expr *> getRHSExprs()
const {
4496 void setReductionOps(ArrayRef<Expr *> ReductionOps);
4499 MutableArrayRef<Expr *> getReductionOps() {
4502 ArrayRef<const Expr *> getReductionOps()
const {
4507 void setTaskgroupDescriptors(ArrayRef<Expr *> ReductionOps);
4510 MutableArrayRef<Expr *> getTaskgroupDescriptors() {
4513 ArrayRef<const Expr *> getTaskgroupDescriptors()
const {
4552 static OMPInReductionClause *
4553 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
4554 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
4555 NestedNameSpecifierLoc QualifierLoc,
4556 const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
4557 ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
4558 ArrayRef<Expr *> ReductionOps, ArrayRef<Expr *> TaskgroupDescriptors,
4559 Stmt *PreInit, Expr *PostUpdate);
4565 static OMPInReductionClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
4580 llvm::iterator_range<helper_expr_const_iterator>;
4608 getReductionOps().end());
4613 getReductionOps().end());
4618 getTaskgroupDescriptors().end());
4623 getTaskgroupDescriptors().end());
4644 return T->getClauseKind() == llvm::omp::OMPC_in_reduction;
4656class OMPLinearClause final
4657 :
public OMPVarListClause<OMPLinearClause>,
4659 private llvm::TrailingObjects<OMPLinearClause, Expr *> {
4661 friend OMPVarListClause;
4662 friend TrailingObjects;
4677 void setStep(
Expr *Step) { *(getFinals().end()) = Step; }
4680 void setCalcStep(
Expr *CalcStep) { *(getFinals().end() + 1) = CalcStep; }
4690 OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc,
4691 OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
4692 SourceLocation ColonLoc, SourceLocation StepModifierLoc,
4693 SourceLocation EndLoc,
unsigned NumVars)
4694 : OMPVarListClause<OMPLinearClause>(
llvm::omp::OMPC_linear, StartLoc,
4695 LParenLoc, EndLoc, NumVars),
4697 ModifierLoc(ModifierLoc), ColonLoc(ColonLoc),
4698 StepModifierLoc(StepModifierLoc) {}
4703 explicit OMPLinearClause(
unsigned NumVars)
4704 : OMPVarListClause<OMPLinearClause>(llvm::omp::OMPC_linear,
4705 SourceLocation(), SourceLocation(),
4706 SourceLocation(), NumVars),
4721 MutableArrayRef<Expr *> getPrivates() {
4724 ArrayRef<const Expr *> getPrivates()
const {
4728 MutableArrayRef<Expr *> getInits() {
4731 ArrayRef<const Expr *> getInits()
const {
4736 MutableArrayRef<Expr *> getUpdates() {
4739 ArrayRef<const Expr *> getUpdates()
const {
4744 MutableArrayRef<Expr *> getFinals() {
4747 ArrayRef<const Expr *> getFinals()
const {
4752 MutableArrayRef<Expr *> getUsedExprs() {
4755 ArrayRef<const Expr *> getUsedExprs()
const {
4761 void setPrivates(ArrayRef<Expr *> PL);
4765 void setInits(ArrayRef<Expr *> IL);
4788 static OMPLinearClause *
4789 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
4791 SourceLocation ColonLoc, SourceLocation StepModifierLoc,
4792 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> PL,
4793 ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit,
4800 static OMPLinearClause *
CreateEmpty(
const ASTContext &
C,
unsigned NumVars);
4855 return privates_range(getPrivates().begin(), getPrivates().end());
4868 return inits_range(getInits().begin(), getInits().end());
4881 return updates_range(getUpdates().begin(), getUpdates().end());
4894 return finals_range(getFinals().begin(), getFinals().end());
4904 llvm::iterator_range<used_expressions_iterator>;
4906 llvm::iterator_range<used_expressions_const_iterator>;
4909 return finals_range(getUsedExprs().begin(), getUsedExprs().end());
4934 return T->getClauseKind() == llvm::omp::OMPC_linear;
4946class OMPAlignedClause final
4947 :
public OMPVarListClause<OMPAlignedClause>,
4948 private llvm::TrailingObjects<OMPAlignedClause, Expr *> {
4950 friend OMPVarListClause;
4951 friend TrailingObjects;
4970 LParenLoc, EndLoc, NumVars),
4971 ColonLoc(ColonLoc) {}
4976 explicit OMPAlignedClause(
unsigned NumVars)
4977 : OMPVarListClause<OMPAlignedClause>(
llvm::omp::OMPC_aligned,
4978 SourceLocation(), SourceLocation(),
4979 SourceLocation(), NumVars) {}
4991 static OMPAlignedClause *
Create(
const ASTContext &
C, SourceLocation StartLoc,
4992 SourceLocation LParenLoc,
4993 SourceLocation ColonLoc,
4994 SourceLocation EndLoc, ArrayRef<Expr *> VL,
5001 static OMPAlignedClause *
CreateEmpty(
const ASTContext &
C,
unsigned NumVars);
5033 return T->getClauseKind() == llvm::omp::OMPC_aligned;
5044class OMPCopyinClause final
5045 :
public OMPVarListClause<OMPCopyinClause>,
5046 private llvm::TrailingObjects<OMPCopyinClause, Expr *> {
5061 friend OMPVarListClause;
5062 friend TrailingObjects;
5072 : OMPVarListClause<OMPCopyinClause>(
llvm::omp::OMPC_copyin, StartLoc,
5073 LParenLoc, EndLoc, N) {}
5089 MutableArrayRef<Expr *> getSourceExprs() {
5092 ArrayRef<const Expr *> getSourceExprs()
const {
5099 void setDestinationExprs(ArrayRef<Expr *> DstExprs);
5102 MutableArrayRef<Expr *> getDestinationExprs() {
5105 ArrayRef<const Expr *> getDestinationExprs()
const {
5113 void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);
5116 MutableArrayRef<Expr *> getAssignmentOps() {
5119 ArrayRef<const Expr *> getAssignmentOps()
const {
5145 static OMPCopyinClause *
5146 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
5147 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
5148 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps);
5154 static OMPCopyinClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
5160 llvm::iterator_range<helper_expr_const_iterator>;
5164 getSourceExprs().end());
5173 getDestinationExprs().end());
5178 getDestinationExprs().end());
5183 getAssignmentOps().end());
5188 getAssignmentOps().end());
5209 return T->getClauseKind() == llvm::omp::OMPC_copyin;
5221class OMPCopyprivateClause final
5222 :
public OMPVarListClause<OMPCopyprivateClause>,
5223 private llvm::TrailingObjects<OMPCopyprivateClause, Expr *> {
5225 friend OMPVarListClause;
5226 friend TrailingObjects;
5236 : OMPVarListClause<OMPCopyprivateClause>(
llvm::omp::OMPC_copyprivate,
5237 StartLoc, LParenLoc, EndLoc, N) {
5254 MutableArrayRef<Expr *> getSourceExprs() {
5257 ArrayRef<const Expr *> getSourceExprs()
const {
5264 void setDestinationExprs(ArrayRef<Expr *> DstExprs);
5267 MutableArrayRef<Expr *> getDestinationExprs() {
5270 ArrayRef<const Expr *> getDestinationExprs()
const {
5278 void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);
5281 MutableArrayRef<Expr *> getAssignmentOps() {
5284 ArrayRef<const Expr *> getAssignmentOps()
const {
5309 static OMPCopyprivateClause *
5310 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
5311 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
5312 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps);
5318 static OMPCopyprivateClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
5324 llvm::iterator_range<helper_expr_const_iterator>;
5328 getSourceExprs().end());
5337 getDestinationExprs().end());
5342 getDestinationExprs().end());
5347 getAssignmentOps().end());
5352 getAssignmentOps().end());
5373 return T->getClauseKind() == llvm::omp::OMPC_copyprivate;
5389class OMPFlushClause final
5390 :
public OMPVarListClause<OMPFlushClause>,
5391 private llvm::TrailingObjects<OMPFlushClause, Expr *> {
5392 friend OMPVarListClause;
5393 friend TrailingObjects;
5403 : OMPVarListClause<OMPFlushClause>(llvm::omp::OMPC_flush, StartLoc,
5404 LParenLoc, EndLoc, N) {}
5409 explicit OMPFlushClause(
unsigned N)
5410 : OMPVarListClause<OMPFlushClause>(llvm::omp::OMPC_flush,
5450 return T->getClauseKind() == llvm::omp::OMPC_flush;
5473 Expr *Depobj =
nullptr;
5483 LParenLoc(LParenLoc) {}
5490 void setDepobj(Expr *E) { Depobj = E; }
5493 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
5503 static OMPDepobjClause *
Create(
const ASTContext &
C, SourceLocation StartLoc,
5504 SourceLocation LParenLoc,
5505 SourceLocation EndLoc, Expr *Depobj);
5510 static OMPDepobjClause *
CreateEmpty(
const ASTContext &
C);
5521 reinterpret_cast<Stmt **
>(&Depobj) + 1);
5537 return T->getClauseKind() == llvm::omp::OMPC_depobj;
5549class OMPDependClause final
5550 :
public OMPVarListClause<OMPDependClause>,
5551 private llvm::TrailingObjects<OMPDependClause, Expr *> {
5553 friend OMPVarListClause;
5554 friend TrailingObjects;
5576 unsigned NumLoops = 0;
5588 : OMPVarListClause<OMPDependClause>(
llvm::omp::OMPC_depend, StartLoc,
5589 LParenLoc, EndLoc, N),
5590 NumLoops(NumLoops) {}
5601 NumLoops(NumLoops) {}
5604 void setDependencyKind(OpenMPDependClauseKind K) {
Data.DepKind = K; }
5607 void setDependencyLoc(SourceLocation Loc) { Data.DepLoc = Loc; }
5610 void setColonLoc(SourceLocation Loc) { Data.ColonLoc = Loc; }
5613 void setOmpAllMemoryLoc(SourceLocation Loc) { Data.OmpAllMemoryLoc = Loc; }
5616 void setModifier(Expr *DepModifier);
5629 static OMPDependClause *
Create(
const ASTContext &
C, SourceLocation StartLoc,
5630 SourceLocation LParenLoc,
5632 Expr *DepModifier, ArrayRef<Expr *> VL,
5641 static OMPDependClause *
CreateEmpty(
const ASTContext &
C,
unsigned N,
5659 return const_cast<OMPDependClause *
>(
this)->
getModifier();
5691 return T->getClauseKind() == llvm::omp::OMPC_depend;
5716 Stmt *Device =
nullptr;
5721 void setDevice(
Expr *E) { Device = E; }
5727 void setModifierLoc(SourceLocation Loc) { ModifierLoc = Loc; }
5746 ModifierLoc(ModifierLoc), Device(E) {
5787 return T->getClauseKind() == llvm::omp::OMPC_device;
5846 return T->getClauseKind() == llvm::omp::OMPC_simd;
5863 llvm::PointerIntPair<Expr *, 1, bool> AssociatedExpressionNonContiguousPr;
5868 ValueDecl *AssociatedDeclaration =
nullptr;
5874 bool IsNonContiguous)
5875 : AssociatedExpressionNonContiguousPr(AssociatedExpression,
5877 AssociatedDeclaration(
5878 AssociatedDeclaration
5883 return AssociatedExpressionNonContiguousPr.getPointer();
5887 return AssociatedExpressionNonContiguousPr.getInt();
5891 return AssociatedDeclaration;
5895 return AssociatedExpressionNonContiguousPr ==
5896 Other.AssociatedExpressionNonContiguousPr &&
5897 AssociatedDeclaration ==
Other.AssociatedDeclaration;
5997 static std::pair<const Expr *, std::optional<size_t>>
6040 unsigned NumUniqueDeclarations;
6043 unsigned NumComponentLists;
6046 unsigned NumComponents;
6051 const bool SupportsMapper;
6085 NumUniqueDeclarations(Sizes.NumUniqueDeclarations),
6086 NumComponentLists(Sizes.NumComponentLists),
6087 NumComponents(Sizes.NumComponents), SupportsMapper(SupportsMapper) {
6088 if (MapperQualifierLocPtr)
6089 MapperQualifierLoc = *MapperQualifierLocPtr;
6090 if (MapperIdInfoPtr)
6091 MapperIdInfo = *MapperIdInfoPtr;
6097 return static_cast<T *
>(
this)
6098 ->
template getTrailingObjectsNonStrict<ValueDecl *>(
6099 NumUniqueDeclarations);
6105 return static_cast<const T *
>(
this)
6106 ->
template getTrailingObjectsNonStrict<ValueDecl *>(
6107 NumUniqueDeclarations);
6113 assert(UDs.size() == NumUniqueDeclarations &&
6114 "Unexpected amount of unique declarations.");
6121 return static_cast<T *
>(
this)
6122 ->
template getTrailingObjectsNonStrict<unsigned>(NumUniqueDeclarations);
6128 return static_cast<const T *
>(
this)
6129 ->
template getTrailingObjectsNonStrict<unsigned>(NumUniqueDeclarations);
6135 assert(DNLs.size() == NumUniqueDeclarations &&
6136 "Unexpected amount of list numbers.");
6144 static_cast<T *
>(
this)
6145 ->
template getTrailingObjectsNonStrict<unsigned>() +
6146 NumUniqueDeclarations,
6154 static_cast<const T *
>(
this)
6155 ->
template getTrailingObjectsNonStrict<unsigned>() +
6156 NumUniqueDeclarations,
6163 assert(CLSs.size() == NumComponentLists &&
6164 "Unexpected amount of component lists.");
6170 return static_cast<T *
>(
this)
6171 ->
template getTrailingObjectsNonStrict<MappableComponent>(
6177 return static_cast<const T *
>(
this)
6178 ->
template getTrailingObjectsNonStrict<MappableComponent>(
6187 assert(Components.size() == NumComponents &&
6188 "Unexpected amount of component lists.");
6189 assert(CLSs.size() == NumComponentLists &&
6190 "Unexpected amount of list sizes.");
6201 NumUniqueDeclarations &&
6202 "Unexpected number of mappable expression info entries!");
6204 "Unexpected total number of components!");
6205 assert(Declarations.size() == ComponentLists.size() &&
6206 "Declaration and component lists size is not consistent!");
6207 assert(Declarations.size() == NumComponentLists &&
6208 "Unexpected declaration and component lists size!");
6213 llvm::MapVector<ValueDecl *, SmallVector<MappableExprComponentListRef, 8>>
6216 auto CI = ComponentLists.begin();
6217 for (
auto DI = Declarations.begin(), DE = Declarations.end(); DI != DE;
6219 assert(!CI->empty() &&
"Invalid component list!");
6220 ComponentListMap[*DI].push_back(*CI);
6226 auto UDI = UniqueDeclarations.begin();
6229 auto DNLI = DeclNumLists.begin();
6232 auto CLSI = ComponentListSizes.begin();
6235 auto CI = Components.begin();
6238 unsigned PrevSize = 0u;
6241 for (
auto &M : ComponentListMap) {
6258 PrevSize +=
C.size();
6265 CI = llvm::copy(
C, CI);
6272 MapperQualifierLoc = NNSL;
6277 MapperIdInfo = MapperId;
6283 assert(SupportsMapper &&
6284 "Must be a clause that is possible to have user-defined mappers");
6286 static_cast<T *
>(
this)->
template getTrailingObjects<Expr *>() +
6294 assert(SupportsMapper &&
6295 "Must be a clause that is possible to have user-defined mappers");
6297 static_cast<const T *
>(
this)->
template getTrailingObjects<Expr *>() +
6306 "Unexpected number of user-defined mappers.");
6307 assert(SupportsMapper &&
6308 "Must be a clause that is possible to have user-defined mappers");
6325 return MapperQualifierLoc;
6334 :
public llvm::iterator_adaptor_base<
6335 const_component_lists_iterator,
6336 MappableExprComponentListRef::const_iterator,
6337 std::forward_iterator_tag, MappableComponent, ptrdiff_t,
6338 MappableComponent, MappableComponent> {
6346 const bool SupportsMapper;
6352 unsigned RemainingLists = 0;
6356 unsigned PrevListSize = 0;
6364 MappableExprComponentListRef::const_iterator End;
6374 Components.begin()),
6375 DeclCur(UniqueDecls.begin()), NumListsCur(DeclsListNum.begin()),
6376 SupportsMapper(SupportsMapper),
6377 ListSizeCur(CumulativeListSizes.begin()),
6378 ListSizeEnd(CumulativeListSizes.end()), End(Components.end()) {
6379 assert(UniqueDecls.size() == DeclsListNum.size() &&
6380 "Inconsistent number of declarations and list sizes!");
6381 if (!DeclsListNum.empty())
6382 RemainingLists = *NumListsCur;
6384 MapperCur = Mappers.begin();
6395 CumulativeListSizes, Components,
6396 SupportsMapper, Mappers) {
6400 for (; DeclCur != UniqueDecls.end(); ++DeclCur, ++NumListsCur) {
6404 assert(*NumListsCur > 0 &&
"No lists associated with declaration??");
6408 std::advance(ListSizeCur, *NumListsCur - 1);
6409 PrevListSize = *ListSizeCur;
6418 if (ListSizeCur == CumulativeListSizes.end()) {
6420 RemainingLists = 0u;
6426 RemainingLists = *NumListsCur;
6429 ListSizeEnd = ListSizeCur;
6430 std::advance(ListSizeEnd, RemainingLists);
6434 std::advance(this->I, PrevListSize);
6442 assert(ListSizeCur != ListSizeEnd &&
"Invalid iterator!");
6444 if (SupportsMapper && *MapperCur)
6446 return std::make_tuple(
6459 assert(ListSizeCur != ListSizeEnd && RemainingLists &&
6460 "Invalid iterator!");
6464 if (std::next(ListSizeCur) == ListSizeEnd) {
6468 std::advance(this->I, *ListSizeCur - PrevListSize);
6469 PrevListSize = *ListSizeCur;
6472 if (!(--RemainingLists)) {
6475 RemainingLists = *NumListsCur;
6476 assert(RemainingLists &&
"No lists in the following declaration??");
6488 llvm::iterator_range<const_component_lists_iterator>;
6502 SupportsMapper, {});
6510 const_component_lists_iterator
6536 llvm::iterator_range<const_all_num_lists_iterator>;
6545 llvm::iterator_range<const_all_lists_sizes_iterator>;
6554 llvm::iterator_range<const_all_components_iterator>;
6565 llvm::iterator_range<mapperlist_const_iterator>;
6591class OMPMapClause final :
public OMPMappableExprListClause<OMPMapClause>,
6592 private llvm::TrailingObjects<
6593 OMPMapClause, Expr *, ValueDecl *, unsigned,
6594 OMPClauseMappableExprCommon::MappableComponent> {
6596 friend OMPMappableExprListClause;
6597 friend OMPVarListClause;
6598 friend TrailingObjects;
6602 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
6607 size_t numTrailingObjects(OverloadToken<ValueDecl *>)
const {
6610 size_t numTrailingObjects(OverloadToken<unsigned>)
const {
6629 bool MapTypeIsImplicit =
false;
6632 SourceLocation MapLoc;
6635 SourceLocation ColonLoc;
6657 explicit OMPMapClause(ArrayRef<OpenMPMapModifierKind> MapModifiers,
6658 ArrayRef<SourceLocation> MapModifiersLoc,
6659 NestedNameSpecifierLoc MapperQualifierLoc,
6660 DeclarationNameInfo MapperIdInfo,
6662 SourceLocation MapLoc,
const OMPVarListLocTy &Locs,
6663 const OMPMappableExprListSizeTy &Sizes)
6664 : OMPMappableExprListClause(llvm::omp::OMPC_map, Locs, Sizes,
6665 true, &MapperQualifierLoc,
6667 MapType(MapType), MapTypeIsImplicit(MapTypeIsImplicit), MapLoc(MapLoc) {
6668 assert(std::size(MapTypeModifiers) == MapModifiers.size() &&
6669 "Unexpected number of map type modifiers.");
6670 llvm::copy(MapModifiers, std::begin(MapTypeModifiers));
6672 assert(std::size(MapTypeModifiersLoc) == MapModifiersLoc.size() &&
6673 "Unexpected number of map type modifier locations.");
6674 llvm::copy(MapModifiersLoc, std::begin(MapTypeModifiersLoc));
6684 explicit OMPMapClause(
const OMPMappableExprListSizeTy &Sizes)
6685 : OMPMappableExprListClause(llvm::omp::OMPC_map, OMPVarListLocTy(), Sizes,
6694 "Unexpected index to store map type modifier, exceeds array size.");
6695 MapTypeModifiers[I] =
T;
6702 void setMapTypeModifierLoc(
unsigned I, SourceLocation TLoc) {
6704 "Index to store map type modifier location exceeds array size.");
6705 MapTypeModifiersLoc[I] = TLoc;
6716 void setMapLoc(SourceLocation TLoc) { MapLoc = TLoc; }
6719 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
6722 void setIteratorModifier(Expr *IteratorModifier) {
6723 getTrailingObjects<Expr *>()[2 *
varlist_size()] = IteratorModifier;
6747 static OMPMapClause *
6748 Create(
const ASTContext &
C,
const OMPVarListLocTy &Locs,
6749 ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
6751 ArrayRef<Expr *> UDMapperRefs, Expr *IteratorModifier,
6752 ArrayRef<OpenMPMapModifierKind> MapModifiers,
6753 ArrayRef<SourceLocation> MapModifiersLoc,
6754 NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId,
6768 const OMPMappableExprListSizeTy &Sizes);
6772 return getTrailingObjects<Expr *>()[2 *
varlist_size()];
6790 "Requested modifier exceeds the total number of modifiers.");
6791 return MapTypeModifiers[Cnt];
6800 "Requested modifier location exceeds total number of modifiers.");
6801 return MapTypeModifiersLoc[Cnt];
6806 return MapTypeModifiers;
6811 return MapTypeModifiersLoc;
6832 if (MapType == OMPC_MAP_to || MapType == OMPC_MAP_tofrom)
6844 return T->getClauseKind() == llvm::omp::OMPC_map;
6863class OMPNumTeamsClause final
6864 :
public OMPVarListClause<OMPNumTeamsClause>,
6866 private llvm::TrailingObjects<OMPNumTeamsClause, Expr *> {
6867 friend OMPVarListClause;
6868 friend TrailingObjects;
6875 : OMPVarListClause(llvm::omp::OMPC_num_teams, StartLoc, LParenLoc, EndLoc,
6880 OMPNumTeamsClause(
unsigned N)
6894 static OMPNumTeamsClause *
6916 return const_cast<OMPNumTeamsClause *
>(
this)->
getNumTeams();
6937 return T->getClauseKind() == llvm::omp::OMPC_num_teams;
6956class OMPThreadLimitClause final
6957 :
public OMPVarListClause<OMPThreadLimitClause>,
6959 private llvm::TrailingObjects<OMPThreadLimitClause, Expr *> {
6960 friend OMPVarListClause;
6961 friend TrailingObjects;
6969 : OMPVarListClause(llvm::omp::OMPC_thread_limit, StartLoc, LParenLoc,
6974 OMPThreadLimitClause(
unsigned N)
6975 : OMPVarListClause(llvm::omp::OMPC_thread_limit,
SourceLocation(),
6988 static OMPThreadLimitClause *
7010 return const_cast<OMPThreadLimitClause *
>(
this)->
getThreadLimit();
7031 return T->getClauseKind() == llvm::omp::OMPC_thread_limit;
7050 Stmt *Priority =
nullptr;
7055 void setPriority(
Expr *E) { Priority = E; }
7105 return T->getClauseKind() == llvm::omp::OMPC_priority;
7130 Stmt *Grainsize =
nullptr;
7133 void setGrainsize(
Expr *Size) { Grainsize = Size; }
7139 void setModifierLoc(SourceLocation Loc) { ModifierLoc = Loc; }
7159 ModifierLoc(ModifierLoc), Grainsize(Size) {
7197 return T->getClauseKind() == llvm::omp::OMPC_grainsize;
7237 return T->getClauseKind() == llvm::omp::OMPC_nogroup;
7262 Stmt *NumTasks =
nullptr;
7265 void setNumTasks(
Expr *Size) { NumTasks = Size; }
7271 void setModifierLoc(SourceLocation Loc) { ModifierLoc = Loc; }
7291 ModifierLoc(ModifierLoc), NumTasks(Size) {
7329 return T->getClauseKind() == llvm::omp::OMPC_num_tasks;
7347 Stmt *Hint =
nullptr;
7350 void setHint(
Expr *H) { Hint = H; }
7361 :
OMPClause(
llvm::omp::OMPC_hint, StartLoc, EndLoc), LParenLoc(LParenLoc),
7391 return T->getClauseKind() == llvm::omp::OMPC_hint;
7419 Expr *ChunkSize =
nullptr;
7434 void setDistScheduleKindLoc(SourceLocation KLoc) { KindLoc = KLoc; }
7439 void setCommaLoc(SourceLocation Loc) { CommaLoc = Loc; }
7444 void setChunkSize(Expr *E) { ChunkSize = E; }
7462 Stmt *HelperChunkSize)
7463 :
OMPClause(
llvm::omp::OMPC_dist_schedule, StartLoc, EndLoc),
7465 KindLoc(KLoc), CommaLoc(CommaLoc), ChunkSize(ChunkSize) {
7495 reinterpret_cast<Stmt **
>(&ChunkSize) + 1);
7511 return T->getClauseKind() == llvm::omp::OMPC_dist_schedule;
7553 void setDefaultmapModifierLoc(SourceLocation Loc) {
7560 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
7565 void setDefaultmapKindLoc(SourceLocation KLoc) { KindLoc = KLoc; }
7582 LParenLoc(LParenLoc), Modifier(M), ModifierLoc(MLoc), Kind(Kind),
7625 return T->getClauseKind() == llvm::omp::OMPC_defaultmap;
7637class OMPToClause final :
public OMPMappableExprListClause<OMPToClause>,
7638 private llvm::TrailingObjects<
7639 OMPToClause, Expr *, ValueDecl *, unsigned,
7640 OMPClauseMappableExprCommon::MappableComponent> {
7642 friend OMPMappableExprListClause;
7643 friend OMPVarListClause;
7644 friend TrailingObjects;
7678 true, &MapperQualifierLoc,
7680 assert(std::size(MotionModifiers) == TheMotionModifiers.size() &&
7681 "Unexpected number of motion modifiers.");
7682 llvm::copy(TheMotionModifiers, std::begin(MotionModifiers));
7684 assert(std::size(MotionModifiersLoc) == TheMotionModifiersLoc.size() &&
7685 "Unexpected number of motion modifier locations.");
7686 llvm::copy(TheMotionModifiersLoc, std::begin(MotionModifiersLoc));
7696 explicit OMPToClause(
const OMPMappableExprListSizeTy &Sizes)
7697 : OMPMappableExprListClause(
llvm::omp::OMPC_to, OMPVarListLocTy(), Sizes,
7706 "Unexpected index to store motion modifier, exceeds array size.");
7707 MotionModifiers[I] =
T;
7714 void setMotionModifierLoc(
unsigned I, SourceLocation TLoc) {
7716 "Index to store motion modifier location exceeds array size.");
7717 MotionModifiersLoc[I] = TLoc;
7721 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
7725 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
7730 size_t numTrailingObjects(OverloadToken<ValueDecl *>)
const {
7733 size_t numTrailingObjects(OverloadToken<unsigned>)
const {
7754 static OMPToClause *
Create(
const ASTContext &
C,
const OMPVarListLocTy &Locs,
7755 ArrayRef<Expr *> Vars,
7756 ArrayRef<ValueDecl *> Declarations,
7758 ArrayRef<Expr *> UDMapperRefs,
7759 ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
7760 ArrayRef<SourceLocation> MotionModifiersLoc,
7761 NestedNameSpecifierLoc UDMQualifierLoc,
7762 DeclarationNameInfo MapperId);
7773 const OMPMappableExprListSizeTy &Sizes);
7780 "Requested modifier exceeds the total number of modifiers.");
7781 return MotionModifiers[Cnt];
7790 "Requested modifier location exceeds total number of modifiers.");
7791 return MotionModifiersLoc[Cnt];
7796 return MotionModifiers;
7801 return MotionModifiersLoc;
7825 return T->getClauseKind() == llvm::omp::OMPC_to;
7837class OMPFromClause final
7838 :
public OMPMappableExprListClause<OMPFromClause>,
7839 private llvm::TrailingObjects<
7840 OMPFromClause, Expr *, ValueDecl *, unsigned,
7841 OMPClauseMappableExprCommon::MappableComponent> {
7843 friend OMPMappableExprListClause;
7844 friend OMPVarListClause;
7845 friend TrailingObjects;
7879 true, &MapperQualifierLoc,
7881 assert(std::size(MotionModifiers) == TheMotionModifiers.size() &&
7882 "Unexpected number of motion modifiers.");
7883 llvm::copy(TheMotionModifiers, std::begin(MotionModifiers));
7885 assert(std::size(MotionModifiersLoc) == TheMotionModifiersLoc.size() &&
7886 "Unexpected number of motion modifier locations.");
7887 llvm::copy(TheMotionModifiersLoc, std::begin(MotionModifiersLoc));
7897 explicit OMPFromClause(
const OMPMappableExprListSizeTy &Sizes)
7898 : OMPMappableExprListClause(
llvm::omp::OMPC_from, OMPVarListLocTy(),
7907 "Unexpected index to store motion modifier, exceeds array size.");
7908 MotionModifiers[I] =
T;
7915 void setMotionModifierLoc(
unsigned I, SourceLocation TLoc) {
7917 "Index to store motion modifier location exceeds array size.");
7918 MotionModifiersLoc[I] = TLoc;
7922 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
7926 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
7931 size_t numTrailingObjects(OverloadToken<ValueDecl *>)
const {
7934 size_t numTrailingObjects(OverloadToken<unsigned>)
const {
7955 static OMPFromClause *
7956 Create(
const ASTContext &
C,
const OMPVarListLocTy &Locs,
7957 ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
7959 ArrayRef<Expr *> UDMapperRefs,
7960 ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
7961 ArrayRef<SourceLocation> MotionModifiersLoc,
7962 NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId);
7973 const OMPMappableExprListSizeTy &Sizes);
7980 "Requested modifier exceeds the total number of modifiers.");
7981 return MotionModifiers[Cnt];
7990 "Requested modifier location exceeds total number of modifiers.");
7991 return MotionModifiersLoc[Cnt];
7996 return MotionModifiers;
8001 return MotionModifiersLoc;
8025 return T->getClauseKind() == llvm::omp::OMPC_from;
8037class OMPUseDevicePtrClause final
8038 :
public OMPMappableExprListClause<OMPUseDevicePtrClause>,
8039 private llvm::TrailingObjects<
8040 OMPUseDevicePtrClause, Expr *, ValueDecl *, unsigned,
8041 OMPClauseMappableExprCommon::MappableComponent> {
8043 friend OMPMappableExprListClause;
8044 friend OMPVarListClause;
8045 friend TrailingObjects;
8059 : OMPMappableExprListClause(
llvm::omp::OMPC_use_device_ptr, Locs, Sizes) {
8075 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
8078 size_t numTrailingObjects(OverloadToken<ValueDecl *>)
const {
8081 size_t numTrailingObjects(OverloadToken<unsigned>)
const {
8088 void setPrivateCopies(ArrayRef<Expr *> VL);
8092 MutableArrayRef<Expr *> getPrivateCopies() {
8095 ArrayRef<const Expr *> getPrivateCopies()
const {
8102 void setInits(ArrayRef<Expr *> VL);
8106 MutableArrayRef<Expr *> getInits() {
8109 ArrayRef<const Expr *> getInits()
const {
8125 static OMPUseDevicePtrClause *
8126 Create(
const ASTContext &
C,
const OMPVarListLocTy &Locs,
8127 ArrayRef<Expr *> Vars, ArrayRef<Expr *> PrivateVars,
8128 ArrayRef<Expr *> Inits, ArrayRef<ValueDecl *> Declarations,
8139 static OMPUseDevicePtrClause *
8140 CreateEmpty(
const ASTContext &
C,
const OMPMappableExprListSizeTy &Sizes);
8146 llvm::iterator_range<private_copies_const_iterator>;
8150 getPrivateCopies().end());
8155 getPrivateCopies().end());
8164 return inits_range(getInits().begin(), getInits().end());
8189 return T->getClauseKind() == llvm::omp::OMPC_use_device_ptr;
8201class OMPUseDeviceAddrClause final
8202 :
public OMPMappableExprListClause<OMPUseDeviceAddrClause>,
8203 private llvm::TrailingObjects<
8204 OMPUseDeviceAddrClause, Expr *, ValueDecl *, unsigned,
8205 OMPClauseMappableExprCommon::MappableComponent> {
8207 friend OMPMappableExprListClause;
8208 friend OMPVarListClause;
8209 friend TrailingObjects;
8223 : OMPMappableExprListClause(
llvm::omp::OMPC_use_device_addr, Locs,
8239 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
8242 size_t numTrailingObjects(OverloadToken<ValueDecl *>)
const {
8245 size_t numTrailingObjects(OverloadToken<unsigned>)
const {
8259 static OMPUseDeviceAddrClause *
8260 Create(
const ASTContext &
C,
const OMPVarListLocTy &Locs,
8261 ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
8272 static OMPUseDeviceAddrClause *
8273 CreateEmpty(
const ASTContext &
C,
const OMPMappableExprListSizeTy &Sizes);
8293 return T->getClauseKind() == llvm::omp::OMPC_use_device_addr;
8305class OMPIsDevicePtrClause final
8306 :
public OMPMappableExprListClause<OMPIsDevicePtrClause>,
8307 private llvm::TrailingObjects<
8308 OMPIsDevicePtrClause, Expr *, ValueDecl *, unsigned,
8309 OMPClauseMappableExprCommon::MappableComponent> {
8311 friend OMPMappableExprListClause;
8312 friend OMPVarListClause;
8313 friend TrailingObjects;
8327 : OMPMappableExprListClause(
llvm::omp::OMPC_is_device_ptr, Locs, Sizes) {}
8342 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
8345 size_t numTrailingObjects(OverloadToken<ValueDecl *>)
const {
8348 size_t numTrailingObjects(OverloadToken<unsigned>)
const {
8362 static OMPIsDevicePtrClause *
8363 Create(
const ASTContext &
C,
const OMPVarListLocTy &Locs,
8364 ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
8375 static OMPIsDevicePtrClause *
8376 CreateEmpty(
const ASTContext &
C,
const OMPMappableExprListSizeTy &Sizes);
8396 return T->getClauseKind() == llvm::omp::OMPC_is_device_ptr;
8408class OMPHasDeviceAddrClause final
8409 :
public OMPMappableExprListClause<OMPHasDeviceAddrClause>,
8410 private llvm::TrailingObjects<
8411 OMPHasDeviceAddrClause, Expr *, ValueDecl *, unsigned,
8412 OMPClauseMappableExprCommon::MappableComponent> {
8414 friend OMPMappableExprListClause;
8415 friend OMPVarListClause;
8416 friend TrailingObjects;
8430 : OMPMappableExprListClause(
llvm::omp::OMPC_has_device_addr, Locs,
8446 size_t numTrailingObjects(OverloadToken<Expr *>)
const {
8449 size_t numTrailingObjects(OverloadToken<ValueDecl *>)
const {
8452 size_t numTrailingObjects(OverloadToken<unsigned>)
const {
8466 static OMPHasDeviceAddrClause *
8467 Create(
const ASTContext &
C,
const OMPVarListLocTy &Locs,
8468 ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
8479 static OMPHasDeviceAddrClause *
8480 CreateEmpty(
const ASTContext &
C,
const OMPMappableExprListSizeTy &Sizes);
8500 return T->getClauseKind() == llvm::omp::OMPC_has_device_addr;
8511class OMPNontemporalClause final
8512 :
public OMPVarListClause<OMPNontemporalClause>,
8513 private llvm::TrailingObjects<OMPNontemporalClause, Expr *> {
8515 friend OMPVarListClause;
8516 friend TrailingObjects;
8526 : OMPVarListClause<OMPNontemporalClause>(
llvm::omp::OMPC_nontemporal,
8527 StartLoc, LParenLoc, EndLoc, N) {
8540 MutableArrayRef<Expr *> getPrivateRefs() {
8543 ArrayRef<const Expr *> getPrivateRefs()
const {
8555 static OMPNontemporalClause *
8556 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
8557 SourceLocation EndLoc, ArrayRef<Expr *> VL);
8563 static OMPNontemporalClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
8580 return child_range(
reinterpret_cast<Stmt **
>(getPrivateRefs().begin()),
8581 reinterpret_cast<Stmt **
>(getPrivateRefs().end()));
8597 return T->getClauseKind() == llvm::omp::OMPC_nontemporal;
8639 void setModifier(OpenMPOrderClauseModifier M) { Modifier = M; }
8644 void setModifierKwLoc(SourceLocation MLoc) { ModifierKwLoc = MLoc; }
8661 LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc), Modifier(Modifier),
8662 ModifierKwLoc(MLoc) {}
8702 return T->getClauseKind() == llvm::omp::OMPC_order;
8711class OMPInitClause final
8712 :
public OMPVarListClause<OMPInitClause>,
8713 private llvm::TrailingObjects<OMPInitClause, Expr *> {
8715 friend OMPVarListClause;
8716 friend TrailingObjects;
8721 bool IsTarget =
false;
8722 bool IsTargetSync =
false;
8726 void setIsTarget(
bool V) { IsTarget =
V; }
8728 void setIsTargetSync(
bool V) { IsTargetSync =
V; }
8731 void setVarLoc(SourceLocation Loc) { VarLoc = Loc; }
8742 OMPInitClause(
bool IsTarget,
bool IsTargetSync, SourceLocation StartLoc,
8743 SourceLocation LParenLoc, SourceLocation VarLoc,
8744 SourceLocation EndLoc,
unsigned N)
8745 : OMPVarListClause<OMPInitClause>(llvm::omp::OMPC_init, StartLoc,
8746 LParenLoc, EndLoc, N),
8747 VarLoc(VarLoc), IsTarget(IsTarget), IsTargetSync(IsTargetSync) {}
8750 OMPInitClause(
unsigned N)
8751 : OMPVarListClause<OMPInitClause>(llvm::omp::OMPC_init, SourceLocation(),
8752 SourceLocation(), SourceLocation(), N) {
8765 static OMPInitClause *
Create(
const ASTContext &
C, Expr *InteropVar,
8766 OMPInteropInfo &InteropInfo,
8767 SourceLocation StartLoc,
8768 SourceLocation LParenLoc, SourceLocation VarLoc,
8769 SourceLocation EndLoc);
8775 static OMPInitClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
8818 auto Prefs =
const_cast<OMPInitClause *
>(
this)->
prefs();
8823 return T->getClauseKind() == llvm::omp::OMPC_init;
8842 Stmt *InteropVar =
nullptr;
8845 void setInteropVar(
Expr *E) { InteropVar = E; }
8851 void setVarLoc(SourceLocation Loc) { VarLoc = Loc; }
8864 :
OMPClause(
llvm::omp::OMPC_use, StartLoc, EndLoc), LParenLoc(LParenLoc),
8865 VarLoc(VarLoc), InteropVar(InteropVar) {}
8894 return T->getClauseKind() == llvm::omp::OMPC_use;
8917 Stmt *InteropVar =
nullptr;
8920 void setInteropVar(
Expr *E) { InteropVar = E; }
8926 void setVarLoc(SourceLocation Loc) { VarLoc = Loc; }
8940 LParenLoc(LParenLoc), VarLoc(VarLoc), InteropVar(InteropVar) {}
8983 return T->getClauseKind() == llvm::omp::OMPC_destroy;
9119class OMPInclusiveClause final
9120 :
public OMPVarListClause<OMPInclusiveClause>,
9121 private llvm::TrailingObjects<OMPInclusiveClause, Expr *> {
9123 friend OMPVarListClause;
9124 friend TrailingObjects;
9134 : OMPVarListClause<OMPInclusiveClause>(
llvm::omp::OMPC_inclusive,
9135 StartLoc, LParenLoc, EndLoc, N) {}
9154 SourceLocation StartLoc,
9155 SourceLocation LParenLoc,
9182 return T->getClauseKind() == llvm::omp::OMPC_inclusive;
9193class OMPExclusiveClause final
9194 :
public OMPVarListClause<OMPExclusiveClause>,
9195 private llvm::TrailingObjects<OMPExclusiveClause, Expr *> {
9197 friend OMPVarListClause;
9198 friend TrailingObjects;
9208 : OMPVarListClause<OMPExclusiveClause>(
llvm::omp::OMPC_exclusive,
9209 StartLoc, LParenLoc, EndLoc, N) {}
9228 SourceLocation StartLoc,
9229 SourceLocation LParenLoc,
9256 return T->getClauseKind() == llvm::omp::OMPC_exclusive;
9268class OMPUsesAllocatorsClause final
9270 private llvm::TrailingObjects<OMPUsesAllocatorsClause, Expr *,
9285 friend TrailingObjects;
9287 enum class ExprOffsets {
9293 enum class ParenLocsOffsets {
9300 SourceLocation LParenLoc;
9302 unsigned NumOfAllocators = 0;
9310 OMPUsesAllocatorsClause(SourceLocation StartLoc, SourceLocation LParenLoc,
9311 SourceLocation EndLoc,
unsigned N)
9312 :
OMPClause(
llvm::omp::OMPC_uses_allocators, StartLoc, EndLoc),
9313 LParenLoc(LParenLoc), NumOfAllocators(N) {}
9318 explicit OMPUsesAllocatorsClause(
unsigned N)
9319 :
OMPClause(llvm::omp::OMPC_uses_allocators, SourceLocation(),
9321 NumOfAllocators(N) {}
9323 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
9324 return NumOfAllocators *
static_cast<int>(ExprOffsets::Total);
9328 void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
9331 void setAllocatorsData(ArrayRef<OMPUsesAllocatorsClause::Data>
Data);
9341 static OMPUsesAllocatorsClause *
9342 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
9343 SourceLocation EndLoc, ArrayRef<OMPUsesAllocatorsClause::Data>
Data);
9349 static OMPUsesAllocatorsClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
9362 Stmt **Begin =
reinterpret_cast<Stmt **
>(getTrailingObjects<Expr *>());
9363 return child_range(Begin, Begin + NumOfAllocators *
9364 static_cast<int>(ExprOffsets::Total));
9367 Stmt *
const *Begin =
9368 reinterpret_cast<Stmt *
const *
>(getTrailingObjects<Expr *>());
9370 Begin, Begin + NumOfAllocators *
static_cast<int>(ExprOffsets::Total));
9381 return T->getClauseKind() == llvm::omp::OMPC_uses_allocators;
9394class OMPAffinityClause final
9395 :
public OMPVarListClause<OMPAffinityClause>,
9396 private llvm::TrailingObjects<OMPAffinityClause, Expr *> {
9398 friend OMPVarListClause;
9399 friend TrailingObjects;
9413 : OMPVarListClause<OMPAffinityClause>(
llvm::omp::OMPC_affinity, StartLoc,
9414 LParenLoc, EndLoc, N) {}
9425 void setModifier(Expr *E) { getTrailingObjects()[
varlist_size()] = E; }
9428 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
9439 static OMPAffinityClause *
Create(
const ASTContext &
C, SourceLocation StartLoc,
9440 SourceLocation LParenLoc,
9441 SourceLocation ColonLoc,
9442 SourceLocation EndLoc, Expr *Modifier,
9443 ArrayRef<Expr *> Locators);
9449 static OMPAffinityClause *
CreateEmpty(
const ASTContext &
C,
unsigned N);
9478 return T->getClauseKind() == llvm::omp::OMPC_affinity;
9549 void setBindKindLoc(SourceLocation KLoc) { KindLoc = KLoc; }
9559 SourceLocation StartLoc, SourceLocation LParenLoc,
9560 SourceLocation EndLoc)
9577 SourceLocation KLoc, SourceLocation StartLoc,
9578 SourceLocation LParenLoc, SourceLocation EndLoc);
9583 static OMPBindClause *
CreateEmpty(
const ASTContext &
C);
9597template<
class ImplClass,
template <
typename>
class Ptr,
typename RetTy>
9600#define PTR(CLASS) Ptr<CLASS>
9601#define DISPATCH(CLASS) \
9602 return static_cast<ImplClass*>(this)->Visit##CLASS(static_cast<PTR(CLASS)>(S))
9604#define GEN_CLANG_CLAUSE_CLASS
9605#define CLAUSE_CLASS(Enum, Str, Class) \
9606 RetTy Visit##Class(PTR(Class) S) { DISPATCH(Class); }
9607#include "llvm/Frontend/OpenMP/OMP.inc"
9612#define GEN_CLANG_CLAUSE_CLASS
9613#define CLAUSE_CLASS(Enum, Str, Class) \
9614 case llvm::omp::Clause::Enum: \
9615 return Visit##Class(static_cast<PTR(Class)>(S));
9616#define CLAUSE_NO_CLASS(Enum, Str) \
9617 case llvm::omp::Clause::Enum: \
9619#include "llvm/Frontend/OpenMP/OMP.inc"
9628template <
typename T>
using const_ptr = std::add_pointer_t<std::add_const_t<T>>;
9630template <
class ImplClass,
typename RetTy =
void>
9633template<
class ImplClass,
typename RetTy =
void>
9643 template <
typename T>
void VisitOMPClauseList(
T *Node,
char StartSym);
9645 template <
typename T>
void VisitOMPMotionClause(
T *Node);
9649 unsigned OpenMPVersion)
9650 : OS(OS), Policy(Policy), Version(OpenMPVersion) {}
9652#define GEN_CLANG_CLAUSE_CLASS
9653#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
9654#include "llvm/Frontend/OpenMP/OMP.inc"
9658 llvm::omp::TraitProperty
Kind = llvm::omp::TraitProperty::invalid;
9667 llvm::omp::TraitSelector
Kind = llvm::omp::TraitSelector::invalid;
9672 llvm::omp::TraitSet
Kind = llvm::omp::TraitSet::invalid;
9688 OMPTraitInfo(StringRef MangledName);
9694 llvm::function_ref<
bool(
Expr *&,
bool )>
Cond) {
9696 return llvm::any_of(
9698 return Cond(Selector.ScoreOrCondition,
9700 llvm::omp::TraitSelector::user_condition);
9711 llvm::omp::VariantMatchInfo &VMI)
const;
9719 if (
Set.Kind != llvm::omp::TraitSet::implementation)
9722 if (
Selector.Kind != llvm::omp::TraitSelector::implementation_extension)
9736llvm::raw_ostream &
operator<<(llvm::raw_ostream &OS,
const OMPTraitInfo &TI);
9737llvm::raw_ostream &
operator<<(llvm::raw_ostream &OS,
const OMPTraitInfo *TI);
9755 llvm::StringMap<bool> FeatureMap;
9761class OMPChildren final
9762 :
private llvm::TrailingObjects<OMPChildren, OMPClause *, Stmt *> {
9763 friend TrailingObjects;
9769 unsigned NumClauses = 0;
9771 unsigned NumChildren = 0;
9773 bool HasAssociatedStmt =
false;
9777 size_t numTrailingObjects(OverloadToken<OMPClause *>)
const {
9783 OMPChildren(
unsigned NumClauses,
unsigned NumChildren,
bool HasAssociatedStmt)
9784 : NumClauses(NumClauses), NumChildren(NumChildren),
9785 HasAssociatedStmt(HasAssociatedStmt) {}
9787 static size_t size(
unsigned NumClauses,
bool HasAssociatedStmt,
9788 unsigned NumChildren);
9792 unsigned NumChildren = 0);
9793 static OMPChildren *
CreateEmpty(
void *Mem,
unsigned NumClauses,
9794 bool HasAssociatedStmt =
false,
9795 unsigned NumChildren = 0);
9804 getTrailingObjects<Stmt *>()[NumChildren] = S;
9820 assert(HasAssociatedStmt &&
9821 "Expected directive with the associated statement.");
9822 return getTrailingObjects<Stmt *>()[NumChildren];
9827 return getTrailingObjects<OMPClause *>(NumClauses);
9830 return const_cast<OMPChildren *
>(
this)->
getClauses();
9840 assert(llvm::is_contained(CaptureRegions, RegionKind) &&
9841 "RegionKind not found in OpenMP CaptureRegions.");
9843 for (
auto ThisCaptureRegion : CaptureRegions) {
9844 if (ThisCaptureRegion == RegionKind)
9848 llvm_unreachable(
"Incorrect RegionKind specified for directive.");
9855 assert(!CaptureRegions.empty() &&
9856 "At least one captured statement must be provided.");
9858 for (
unsigned Level = CaptureRegions.size(); Level > 1; --Level)
9871 return const_cast<OMPChildren *
>(
this)->
getChildren();
9875 assert(HasAssociatedStmt &&
9876 "Expected directive with the associated statement.");
9880 S = CS->getCapturedStmt();
9881 CS = dyn_cast<CapturedStmt>(S);
9888 return const_cast<OMPChildren *
>(
this)->
getRawStmt();
9892 if (!HasAssociatedStmt)
9895 &getTrailingObjects<Stmt *>()[NumChildren + 1]);
9949class OMPDoacrossClause final
9950 :
public OMPVarListClause<OMPDoacrossClause>,
9951 private llvm::TrailingObjects<OMPDoacrossClause, Expr *> {
9953 friend OMPVarListClause;
9954 friend TrailingObjects;
9966 unsigned NumLoops = 0;
9977 : OMPVarListClause<OMPDoacrossClause>(
llvm::omp::OMPC_doacross, StartLoc,
9978 LParenLoc, EndLoc, N),
9979 NumLoops(NumLoops) {}
9989 NumLoops(NumLoops) {}
9992 void setDependenceType(OpenMPDoacrossClauseModifier M) { DepType = M; }
9995 void setDependenceLoc(SourceLocation Loc) { DepLoc = Loc; }
9998 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
10012 static OMPDoacrossClause *
10013 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation LParenLoc,
10015 SourceLocation DepLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
10016 unsigned NumLoops);
10023 static OMPDoacrossClause *
CreateEmpty(
const ASTContext &
C,
unsigned N,
10024 unsigned NumLoops);
10063 return T->getClauseKind() == llvm::omp::OMPC_doacross;
10092 :
OMPNoChildClause(StartLoc, EndLoc), LParenLoc(LParenLoc), Attrs(Attrs) {
10111 Attrs.append(NewAttrs.begin(), NewAttrs.end());
Forward declaration of all AST node types.
static const Decl * getCanonicalDecl(const Decl *D)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines some OpenMP-specific enums and functions.
Defines the clang::SourceLocation class and associated facilities.
static OMPAtomicDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
a trap message and trap category.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
This captures a statement into a function.
This represents one expression.
Represents a function declaration or definition.
A C++ nested-name-specifier augmented with source location information.
static OMPAbsentClause * CreateEmpty(const ASTContext &C, unsigned NumKinds)
static bool classof(const OMPClause *C)
static bool classof(const OMPClause *T)
OMPAcqRelClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'ack_rel' clause.
const_child_range used_children() const
child_range used_children()
const_child_range children() const
OMPAcqRelClause()
Build an empty clause.
static bool classof(const OMPClause *T)
const_child_range children() const
OMPAcquireClause()
Build an empty clause.
child_range used_children()
const_child_range used_children() const
OMPAcquireClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'acquire' clause.
This represents clause 'affinity' in the 'pragma omp task'-based directives.
child_range used_children()
friend class OMPClauseReader
Expr * getModifier()
Gets affinity modifier.
const_child_range children() const
static OMPAffinityClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N locator items.
SourceLocation getColonLoc() const
Gets the location of ':' symbol.
const_child_range used_children() const
static bool classof(const OMPClause *T)
Expr * getModifier() const
This represents the 'align' clause in the 'pragma omp allocate' directive.
friend class OMPClauseReader
Expr * getAlignment() const
Returns alignment.
This represents clause 'aligned' in the 'pragma omp ...' directives.
friend class OMPClauseReader
Expr * getAlignment()
Returns alignment.
const Expr * getAlignment() const
Returns alignment.
void setColonLoc(SourceLocation Loc)
Sets the location of ':'.
const_child_range used_children() const
static OMPAlignedClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
const_child_range children() const
SourceLocation getColonLoc() const
Returns the location of ':'.
static bool classof(const OMPClause *T)
child_range used_children()
This represents clause 'allocate' in the 'pragma omp ...' directives.
const_child_range children() const
friend class OMPClauseReader
SourceLocation getAllocatorModifierLoc() const
Return the location of the modifier.
const_child_range used_children() const
OpenMPAllocateClauseModifier getAllocatorModifier() const
Return 'allocate' modifier.
OpenMPAllocateClauseModifier getSecondAllocateModifier() const
Get the second modifier of the clause.
SourceLocation getColonLoc() const
Returns the location of the ':' delimiter.
Expr * getAlignment() const
Returns the alignment expression or nullptr, if no alignment specified.
OpenMPAllocateClauseModifier getFirstAllocateModifier() const
Get the first modifier of the clause.
Expr * getAllocator() const
Returns the allocator expression or nullptr, if no allocator is specified.
SourceLocation getSecondAllocateModifierLoc() const
Get location of second modifier of the clause.
child_range used_children()
SourceLocation getFirstAllocateModifierLoc() const
Get location of first modifier of the clause.
static OMPAllocateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
static bool classof(const OMPClause *T)
friend class OMPClauseReader
OMPAllocatorClause(Expr *A, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'allocator' clause with the given allocator.
OMPAllocatorClause()
Build an empty clause.
Expr * getAllocator() const
Returns allocator.
friend class OMPClauseReader
OMPAtClause(OpenMPAtClauseKind A, SourceLocation ALoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'at' clause with argument A ('compilation' or 'execution').
SourceLocation getAtKindKwLoc() const
Returns location of clause kind.
static bool classof(const OMPClause *T)
OpenMPAtClauseKind getAtKind() const
Returns kind of the clause.
const_child_range used_children() const
child_range used_children()
SourceLocation getLParenLoc() const
Returns the locaiton of '('.
OMPAtClause()
Build an empty clause.
const_child_range children() const
friend class OMPClauseReader
const_child_range used_children() const
static bool classof(const OMPClause *T)
SourceLocation getLParenLoc() const
Returns the locaiton of '('.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
OpenMPAtomicDefaultMemOrderClauseKind getAtomicDefaultMemOrderKind() const
Returns kind of the clause.
OMPAtomicDefaultMemOrderClause(OpenMPAtomicDefaultMemOrderClauseKind A, SourceLocation ALoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'atomic_default_mem_order' clause with argument A ('seq_cst', 'acq_rel' or 'relaxed').
child_range used_children()
const_child_range children() const
OMPAtomicDefaultMemOrderClause()
Build an empty clause.
SourceLocation getAtomicDefaultMemOrderKindKwLoc() const
Returns location of clause kind.
OpenMPBindClauseKind getBindKind() const
Returns kind of the clause.
friend class OMPClauseReader
SourceLocation getLParenLoc() const
Returns the location of '('.
SourceLocation getBindKindLoc() const
Returns location of clause kind.
static OMPBindClause * CreateEmpty(const ASTContext &C)
Build an empty 'bind' clause.
OMPCaptureClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'capture' clause.
const_child_range used_children() const
child_range used_children()
const_child_range children() const
static bool classof(const OMPClause *T)
OMPCaptureClause()
Build an empty clause.
Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...
unsigned getNumClauses() const
const CapturedStmt * getCapturedStmt(OpenMPDirectiveKind RegionKind, ArrayRef< OpenMPDirectiveKind > CaptureRegions) const
Returns the captured statement associated with the component region within the (combined) directive.
friend class OMPClauseReader
bool hasAssociatedStmt() const
Stmt::child_range getAssociatedStmtAsRange()
void setClauses(ArrayRef< OMPClause * > Clauses)
Sets the list of variables for this clause.
friend class OMPDeclarativeDirective
unsigned getNumChildren() const
const Stmt * getAssociatedStmt() const
Returns statement associated with the directive.
Stmt * getAssociatedStmt()
void setChildren(ArrayRef< Stmt * > Children)
ArrayRef< Stmt * > getChildren() const
MutableArrayRef< OMPClause * > getClauses()
Get the clauses storage.
friend class OMPExecutableDirective
MutableArrayRef< Stmt * > getChildren()
const Stmt * getRawStmt() const
void setAssociatedStmt(Stmt *S)
Set associated statement.
CapturedStmt * getInnermostCapturedStmt(ArrayRef< OpenMPDirectiveKind > CaptureRegions)
Get innermost captured statement for the construct.
ArrayRef< OMPClause * > getClauses() const
const CapturedStmt * getInnermostCapturedStmt(ArrayRef< OpenMPDirectiveKind > CaptureRegions) const
Class that represents a component of a mappable expression.
bool operator==(const MappableComponent &Other) const
MappableComponent(Expr *AssociatedExpression, ValueDecl *AssociatedDeclaration, bool IsNonContiguous)
bool isNonContiguous() const
Expr * getAssociatedExpression() const
MappableComponent()=default
ValueDecl * getAssociatedDeclaration() const
Struct that defines common infrastructure to handle mappable expressions used in OpenMP clauses.
ArrayRef< MappableExprComponentList > MappableExprComponentListsRef
static unsigned getUniqueDeclarationsTotalNumber(ArrayRef< const ValueDecl * > Declarations)
static unsigned getComponentsTotalNumber(MappableExprComponentListsRef ComponentLists)
ArrayRef< MappableComponent > MappableExprComponentListRef
SmallVector< MappableComponent, 8 > MappableExprComponentList
friend llvm::hash_code hash_value(const MappableComponent &MC)
SmallVector< MappableExprComponentList, 8 > MappableExprComponentLists
static std::pair< const Expr *, std::optional< size_t > > findAttachPtrExpr(MappableExprComponentListRef Components, OpenMPDirectiveKind CurDirKind)
Find the attach pointer expression from a list of mappable expression components.
static QualType getComponentExprElementType(const Expr *Exp)
Get the type of an element of a ComponentList Expr Exp.
OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy, unsigned OpenMPVersion)
This class implements a simple visitor for OMPClause subclasses.
RetTy VisitOMPClause(PTR(OMPClause) Node)
RetTy Visit(PTR(OMPClause) S)
Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc.
friend class OMPClauseReader
void setPostUpdateExpr(Expr *S)
Set pre-initialization statement for the clause.
static OMPClauseWithPostUpdate * get(OMPClause *C)
Expr * getPostUpdateExpr()
Get post-update expression for the clause.
OMPClauseWithPostUpdate(const OMPClause *This)
const Expr * getPostUpdateExpr() const
Get post-update expression for the clause.
Class that handles pre-initialization statement for some clauses, like 'schedule',...
friend class OMPClauseReader
const Stmt * getPreInitStmt() const
Get pre-initialization statement for the clause.
OMPClauseWithPreInit(const OMPClause *This)
OpenMPDirectiveKind getCaptureRegion() const
Get capture region for the stmt in the clause.
Stmt * getPreInitStmt()
Get pre-initialization statement for the clause.
static OMPClauseWithPreInit * get(OMPClause *C)
void setPreInitStmt(Stmt *S, OpenMPDirectiveKind ThisRegion=llvm::omp::OMPD_unknown)
Set pre-initialization statement for the clause.
This is a basic class for representing single OpenMP clause.
const_child_range children() const
void setLocStart(SourceLocation Loc)
Sets the starting location of the clause.
static bool classof(const OMPClause *)
SourceLocation getBeginLoc() const
Returns the starting location of the clause.
llvm::iterator_range< const_child_iterator > const_child_range
ConstStmtIterator const_child_iterator
child_range used_children()
Get the iterator range for the expressions used in the clauses.
llvm::iterator_range< child_iterator > child_range
OMPClause(OpenMPClauseKind K, SourceLocation StartLoc, SourceLocation EndLoc)
void setLocEnd(SourceLocation Loc)
Sets the ending location of the clause.
StmtIterator child_iterator
SourceLocation getEndLoc() const
Returns the ending location of the clause.
OpenMPClauseKind getClauseKind() const
Returns kind of OpenMP clause (private, shared, reduction, etc.).
const_child_range used_children() const
friend class OMPClauseReader
OMPCollapseClause()
Build an empty clause.
Expr * getNumForLoops() const
Return the number of associated for-loops.
OMPCollapseClause(Expr *Num, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'collapse' clause.
const_child_range used_children() const
OMPCompareClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'compare' clause.
child_range used_children()
const_child_range children() const
OMPCompareClause()
Build an empty clause.
static bool classof(const OMPClause *T)
static OMPContainsClause * CreateEmpty(const ASTContext &C, unsigned NumKinds)
static bool classof(const OMPClause *C)
This represents clause 'copyin' in the 'pragma omp ...' directives.
friend class OMPClauseReader
helper_expr_range assignment_ops()
llvm::iterator_range< helper_expr_const_iterator > helper_expr_const_range
MutableArrayRef< Expr * >::iterator helper_expr_iterator
ArrayRef< const Expr * >::iterator helper_expr_const_iterator
const_child_range children() const
helper_expr_const_range source_exprs() const
llvm::iterator_range< helper_expr_iterator > helper_expr_range
helper_expr_range source_exprs()
static bool classof(const OMPClause *T)
const_child_range used_children() const
child_range used_children()
helper_expr_const_range destination_exprs() const
helper_expr_range destination_exprs()
helper_expr_const_range assignment_ops() const
static OMPCopyinClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents clause 'copyprivate' in the 'pragma omp ...' directives.
friend class OMPClauseReader
helper_expr_range source_exprs()
MutableArrayRef< Expr * >::iterator helper_expr_iterator
llvm::iterator_range< helper_expr_iterator > helper_expr_range
child_range used_children()
helper_expr_const_range destination_exprs() const
helper_expr_range destination_exprs()
const_child_range children() const
static bool classof(const OMPClause *T)
const_child_range used_children() const
helper_expr_const_range source_exprs() const
static OMPCopyprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
llvm::iterator_range< helper_expr_const_iterator > helper_expr_const_range
helper_expr_range assignment_ops()
ArrayRef< const Expr * >::iterator helper_expr_const_iterator
helper_expr_const_range assignment_ops() const
friend class OMPClauseReader
const_child_range used_children() const
OMPDefaultClause(llvm::omp::DefaultKind A, SourceLocation ALoc, OpenMPDefaultClauseVariableCategory VC, SourceLocation VCLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'default' clause with argument A ('none' or 'shared').
SourceLocation getLParenLoc() const
Returns the location of '('.
llvm::omp::DefaultKind getDefaultKind() const
Returns kind of the clause.
SourceLocation getDefaultKindKwLoc() const
Returns location of clause kind.
OpenMPDefaultClauseVariableCategory getDefaultVC() const
static bool classof(const OMPClause *T)
child_range used_children()
const_child_range children() const
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
OMPDefaultClause()
Build an empty clause.
SourceLocation getDefaultVCLoc() const
const_child_range children() const
SourceLocation getDefaultmapKindLoc()
Get kind location.
friend class OMPClauseReader
static bool classof(const OMPClause *T)
OMPDefaultmapClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc, SourceLocation KLoc, SourceLocation EndLoc, OpenMPDefaultmapClauseKind Kind, OpenMPDefaultmapClauseModifier M)
Build 'defaultmap' clause with defaultmap kind Kind.
child_range used_children()
OpenMPDefaultmapClauseModifier getDefaultmapModifier() const
Get the modifier of the clause.
OMPDefaultmapClause()
Build an empty clause.
SourceLocation getDefaultmapModifierLoc() const
Get the modifier location.
const_child_range used_children() const
SourceLocation getLParenLoc()
Get location of '('.
OpenMPDefaultmapClauseKind getDefaultmapKind() const
Get kind of the clause.
This represents implicit clause 'depend' for the 'pragma omp task' directive.
SourceLocation getDependencyLoc() const
Get dependency type location.
friend class OMPClauseReader
static bool classof(const OMPClause *T)
unsigned getNumLoops() const
Get number of loops associated with the clause.
Expr * getModifier()
Return optional depend modifier.
Expr * getLoopData(unsigned NumLoop)
Get the loop data.
SourceLocation getOmpAllMemoryLoc() const
Get 'omp_all_memory' location.
const_child_range used_children() const
void setLoopData(unsigned NumLoop, Expr *Cnt)
Set the loop data for the depend clauses with 'sink|source' kind of dependency.
const_child_range children() const
static OMPDependClause * CreateEmpty(const ASTContext &C, unsigned N, unsigned NumLoops)
Creates an empty clause with N variables.
const Expr * getModifier() const
child_range used_children()
SourceLocation getColonLoc() const
Get colon location.
OpenMPDependClauseKind getDependencyKind() const
Get dependency type.
This represents implicit clause 'depobj' for the 'pragma omp depobj' directive.
SourceLocation getLParenLoc() const
Returns the location of '('.
static bool classof(const OMPClause *T)
friend class OMPClauseReader
const_child_range used_children() const
const_child_range children() const
static OMPDepobjClause * CreateEmpty(const ASTContext &C)
Creates an empty clause.
Expr * getDepobj()
Returns depobj expression associated with the clause.
child_range used_children()
const Expr * getDepobj() const
friend class OMPClauseReader
static bool classof(const OMPClause *T)
SourceLocation getLParenLoc() const
Returns the location of '('.
OMPDestroyClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'destroy' clause.
child_range used_children()
const_child_range children() const
OMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc)
Build 'destroy' clause with an interop variable expression InteropVar.
SourceLocation getVarLoc() const
Returns the location of the interop variable.
Expr * getInteropVar() const
Returns the interop variable.
OMPDestroyClause()
Build an empty clause.
const_child_range used_children() const
OMPDetachClause(Expr *Evt, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'detach' clause with event-handler Evt.
friend class OMPClauseReader
OMPDetachClause()
Build an empty clause.
Expr * getEventHandler() const
Returns event-handler expression.
OMPDeviceClause()
Build an empty clause.
const_child_range used_children() const
friend class OMPClauseReader
OpenMPDeviceClauseModifier getModifier() const
Gets modifier.
child_range used_children()
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
const_child_range children() const
Expr * getDevice()
Return device number.
Expr * getDevice() const
Return device number.
OMPDeviceClause(OpenMPDeviceClauseModifier Modifier, Expr *E, Stmt *HelperE, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ModifierLoc, SourceLocation EndLoc)
Build 'device' clause.
SourceLocation getModifierLoc() const
Gets modifier location.
static bool classof(const OMPClause *T)
SourceLocation getLParenLoc() const
Returns the location of '('.
MutableArrayRef< OpenMPDirectiveKind > getDirectiveKinds()
void setDirectiveKinds(ArrayRef< OpenMPDirectiveKind > DK)
SourceLocation getLParenLoc()
const_child_range children() const
unsigned NumKinds
Number of directive kinds listed in the clause.
void setLParenLoc(SourceLocation S)
const_child_range used_children() const
OMPDirectiveListClause(OpenMPClauseKind K, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, unsigned NumKinds)
Build a clause with NumKinds directive kinds.
child_range used_children()
OMPDistScheduleClause()
Build an empty clause.
const_child_range used_children() const
friend class OMPClauseReader
SourceLocation getCommaLoc()
Get location of ','.
const_child_range children() const
SourceLocation getDistScheduleKindLoc()
Get kind location.
OMPDistScheduleClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KLoc, SourceLocation CommaLoc, SourceLocation EndLoc, OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, Stmt *HelperChunkSize)
Build 'dist_schedule' clause with schedule kind Kind and chunk size expression ChunkSize.
const Expr * getChunkSize() const
Get chunk size.
OpenMPDistScheduleClauseKind getDistScheduleKind() const
Get kind of the clause.
Expr * getChunkSize()
Get chunk size.
SourceLocation getLParenLoc()
Get location of '('.
child_range used_children()
static bool classof(const OMPClause *T)
This represents the 'doacross' clause for the 'pragma omp ordered' directive.
const_child_range children() const
friend class OMPClauseReader
const_child_range used_children() const
child_range used_children()
static bool classof(const OMPClause *T)
void setLoopData(unsigned NumLoop, Expr *Cnt)
Set the loop data.
Expr * getLoopData(unsigned NumLoop)
Get the loop data.
SourceLocation getColonLoc() const
Get colon location.
unsigned getNumLoops() const
Get number of loops associated with the clause.
static OMPDoacrossClause * CreateEmpty(const ASTContext &C, unsigned N, unsigned NumLoops)
Creates an empty clause with N expressions.
OpenMPDoacrossClauseModifier getDependenceType() const
Get dependence type.
SourceLocation getDependenceLoc() const
Get dependence type location.
OMPDynamicAllocatorsClause()
Build an empty clause.
friend class OMPClauseReader
OMPDynamicAllocatorsClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'dynamic_allocators' clause.
const_child_range children() const
const_child_range used_children() const
static bool classof(const OMPClause *T)
child_range used_children()
This represents clause 'exclusive' in the 'pragma omp scan' directive.
friend class OMPClauseReader
child_range used_children()
const_child_range used_children() const
static OMPExclusiveClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
const_child_range children() const
static bool classof(const OMPClause *T)
friend class OMPClauseReader
OMPFailClause(OpenMPClauseKind FailParameter, SourceLocation FailParameterLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
child_range used_children()
OMPFailClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'fail' clause.
static bool classof(const OMPClause *T)
const_child_range used_children() const
SourceLocation getLParenLoc() const
Gets the location of '(' (for the parameter) in fail clause.
const_child_range children() const
SourceLocation getFailParameterLoc() const
Gets the location of Fail Parameter (type memory-order-clause) in fail clause.
OMPFailClause()
Build an empty clause.
OpenMPClauseKind getFailParameter() const
Gets the parameter (type memory-order-clause) in Fail clause.
friend class OMPClauseReader
Expr * getThreadID() const
Return thread identifier.
Expr * getThreadID()
Return thread identifier.
OMPFilterClause(Expr *ThreadID, Stmt *HelperE, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'filter' clause with thread-id ThreadID.
OMPFilterClause()
Build an empty clause.
child_range used_children()
friend class OMPClauseReader
Expr * getCondition() const
Returns condition.
OMPFinalClause(Expr *Cond, Stmt *HelperCond, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'final' clause with condition Cond.
OMPFinalClause()
Build an empty clause.
const_child_range used_children() const
This represents clause 'firstprivate' in the 'pragma omp ...' directives.
MutableArrayRef< Expr * >::iterator private_copies_iterator
friend class OMPClauseReader
const_child_range children() const
static bool classof(const OMPClause *T)
inits_const_range inits() const
llvm::iterator_range< inits_const_iterator > inits_const_range
ArrayRef< const Expr * >::iterator inits_const_iterator
child_range used_children()
private_copies_const_range private_copies() const
llvm::iterator_range< private_copies_const_iterator > private_copies_const_range
llvm::iterator_range< inits_iterator > inits_range
llvm::iterator_range< private_copies_iterator > private_copies_range
const_child_range used_children() const
private_copies_range private_copies()
ArrayRef< const Expr * >::iterator private_copies_const_iterator
static OMPFirstprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
MutableArrayRef< Expr * >::iterator inits_iterator
child_range used_children()
static OMPFlushClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
const_child_range children() const
static bool classof(const OMPClause *T)
const_child_range used_children() const
This represents clause 'from' in the 'pragma omp ...' directives.
const_child_range used_children() const
friend class OMPClauseReader
SourceLocation getColonLoc() const
Get colon location.
OpenMPMotionModifierKind getMotionModifier(unsigned Cnt) const LLVM_READONLY
Fetches the motion-modifier at 'Cnt' index of array of modifiers.
ArrayRef< SourceLocation > getMotionModifiersLoc() const LLVM_READONLY
Fetches ArrayRef of location of motion-modifiers.
static bool classof(const OMPClause *T)
static OMPFromClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
ArrayRef< OpenMPMotionModifierKind > getMotionModifiers() const LLVM_READONLY
Fetches ArrayRef of motion-modifiers.
child_range used_children()
SourceLocation getMotionModifierLoc(unsigned Cnt) const LLVM_READONLY
Fetches the motion-modifier location at 'Cnt' index of array of modifiers' locations.
const_child_range children() const
Representation of the 'full' clause of the 'pragma omp unroll' directive.
friend class OMPClauseReader
static OMPFullClause * CreateEmpty(const ASTContext &C)
Build an empty 'full' AST node for deserialization.
const_child_range children() const
friend class OMPClauseReader
Expr * getGrainsize() const
Return safe iteration space distance.
SourceLocation getLParenLoc() const
Returns the location of '('.
child_range used_children()
SourceLocation getModifierLoc() const
Gets modifier location.
OMPGrainsizeClause(OpenMPGrainsizeClauseModifier Modifier, Expr *Size, Stmt *HelperSize, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ModifierLoc, SourceLocation EndLoc)
Build 'grainsize' clause.
static bool classof(const OMPClause *T)
const_child_range used_children() const
OMPGrainsizeClause()
Build an empty clause.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
OpenMPGrainsizeClauseModifier getModifier() const
Gets modifier.
This represents clause 'has_device_ptr' in the 'pragma omp ...' directives.
const_child_range used_children() const
friend class OMPClauseReader
const_child_range children() const
static bool classof(const OMPClause *T)
static OMPHasDeviceAddrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
child_range used_children()
friend class OMPClauseReader
static bool classof(const OMPClause *T)
Expr * getHint() const
Returns number of threads.
const_child_range children() const
OMPHintClause(Expr *Hint, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'hint' clause with expression Hint.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
SourceLocation getLParenLoc() const
Returns the location of '('.
const_child_range used_children() const
OMPHintClause()
Build an empty clause.
child_range used_children()
friend class OMPClauseReader
OMPHoldsClause(Expr *E, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'holds' clause.
OMPHoldsClause()
Build an empty clause.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
friend class OMPClauseReader
const_child_range used_children() const
SourceLocation getLParenLoc() const
Returns the location of '('.
SourceLocation getColonLoc() const
Return the location of ':'.
static bool classof(const OMPClause *T)
child_range used_children()
Expr * getCondition() const
Returns condition.
OpenMPDirectiveKind getNameModifier() const
Return directive name modifier associated with the clause.
OMPIfClause()
Build an empty clause.
const_child_range children() const
OMPIfClause(OpenMPDirectiveKind NameModifier, Expr *Cond, Stmt *HelperCond, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation NameModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc)
Build 'if' clause with condition Cond.
SourceLocation getNameModifierLoc() const
Return the location of directive name modifier.
This represents clause 'in_reduction' in the 'pragma omp task' directives.
static OMPInReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
static bool classof(const OMPClause *T)
friend class OMPClauseReader
helper_expr_const_range rhs_exprs() const
helper_expr_range taskgroup_descriptors()
MutableArrayRef< Expr * >::iterator helper_expr_iterator
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
ArrayRef< const Expr * >::iterator helper_expr_const_iterator
llvm::iterator_range< helper_expr_iterator > helper_expr_range
helper_expr_const_range lhs_exprs() const
helper_expr_const_range reduction_ops() const
helper_expr_const_range privates() const
llvm::iterator_range< helper_expr_const_iterator > helper_expr_const_range
SourceLocation getColonLoc() const
Gets location of ':' symbol in clause.
helper_expr_const_range taskgroup_descriptors() const
child_range used_children()
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
helper_expr_range reduction_ops()
const_child_range used_children() const
helper_expr_range rhs_exprs()
const_child_range children() const
helper_expr_range lhs_exprs()
helper_expr_range privates()
This represents clause 'inclusive' in the 'pragma omp scan' directive.
const_child_range children() const
friend class OMPClauseReader
static bool classof(const OMPClause *T)
child_range used_children()
static OMPInclusiveClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
const_child_range used_children() const
bool getIsTarget() const
Returns true is interop-type 'target' is used.
child_range used_children()
const_child_range children() const
friend class OMPClauseReader
const_prefs_range prefs() const
llvm::iterator_range< prefs_iterator > prefs_range
const Expr * getInteropVar() const
static bool classof(const OMPClause *T)
ArrayRef< const Expr * >::iterator const_prefs_iterator
SourceLocation getVarLoc() const
Returns the location of the interop variable.
bool getIsTargetSync() const
Returns true is interop-type 'targetsync' is used.
static OMPInitClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N expressions.
MutableArrayRef< Expr * >::iterator prefs_iterator
const_child_range used_children() const
Expr * getInteropVar()
Returns the interop variable.
llvm::iterator_range< const_prefs_iterator > const_prefs_range
This represents clause 'is_device_ptr' in the 'pragma omp ...' directives.
friend class OMPClauseReader
const_child_range used_children() const
const_child_range children() const
child_range used_children()
static bool classof(const OMPClause *T)
static OMPIsDevicePtrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents clause 'lastprivate' in the 'pragma omp ...' directives.
static OMPLastprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
helper_expr_range assignment_ops()
friend class OMPClauseReader
void setPrivateCopies(ArrayRef< Expr * > PrivateCopies)
Set list of helper expressions, required for generation of private copies of original lastprivate var...
SourceLocation getKindLoc() const
Returns the location of the lastprivate kind.
const_child_range used_children() const
helper_expr_const_range destination_exprs() const
helper_expr_const_range source_exprs() const
helper_expr_range destination_exprs()
llvm::iterator_range< helper_expr_const_iterator > helper_expr_const_range
static bool classof(const OMPClause *T)
helper_expr_range source_exprs()
const_child_range children() const
helper_expr_const_range assignment_ops() const
helper_expr_range private_copies()
MutableArrayRef< Expr * >::iterator helper_expr_iterator
SourceLocation getColonLoc() const
Returns the location of the ':' symbol, if any.
OpenMPLastprivateModifier getKind() const
Lastprivate kind.
ArrayRef< const Expr * >::iterator helper_expr_const_iterator
child_range used_children()
llvm::iterator_range< helper_expr_iterator > helper_expr_range
helper_expr_const_range private_copies() const
static bool classof(const OMPClause *T)
void setStepModifierLoc(SourceLocation Loc)
Sets the location of 'step' modifier.
updates_const_range updates() const
child_range used_children()
SourceLocation getModifierLoc() const
Return modifier location.
friend class OMPClauseReader
static OMPLinearClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
Expr * getStep()
Returns linear step.
void setUpdates(ArrayRef< Expr * > UL)
Sets the list of update expressions for linear variables.
privates_range privates()
void setFinals(ArrayRef< Expr * > FL)
Sets the list of final update expressions for linear variables.
privates_const_range privates() const
void setUsedExprs(ArrayRef< Expr * > UE)
Sets the list of used expressions for the linear clause.
const Expr * getStep() const
Returns linear step.
ArrayRef< const Expr * >::iterator used_expressions_const_iterator
llvm::iterator_range< finals_iterator > finals_range
llvm::iterator_range< updates_iterator > updates_range
MutableArrayRef< Expr * >::iterator inits_iterator
ArrayRef< const Expr * >::iterator finals_const_iterator
void setModifierLoc(SourceLocation Loc)
Set modifier location.
MutableArrayRef< Expr * >::iterator used_expressions_iterator
llvm::iterator_range< finals_const_iterator > finals_const_range
llvm::iterator_range< privates_iterator > privates_range
inits_const_range inits() const
const_child_range children() const
Expr * getCalcStep()
Returns expression to calculate linear step.
MutableArrayRef< Expr * >::iterator finals_iterator
ArrayRef< const Expr * >::iterator updates_const_iterator
void setColonLoc(SourceLocation Loc)
Sets the location of ':'.
const Expr * getCalcStep() const
Returns expression to calculate linear step.
llvm::iterator_range< used_expressions_iterator > used_expressions_range
ArrayRef< const Expr * >::iterator inits_const_iterator
llvm::iterator_range< used_expressions_const_iterator > used_expressions_const_range
llvm::iterator_range< updates_const_iterator > updates_const_range
SourceLocation getStepModifierLoc() const
Returns the location of 'step' modifier.
used_expressions_const_range used_expressions() const
used_expressions_range used_expressions()
llvm::iterator_range< privates_const_iterator > privates_const_range
finals_const_range finals() const
const_child_range used_children() const
void setModifier(OpenMPLinearClauseKind Kind)
Set modifier.
llvm::iterator_range< inits_const_iterator > inits_const_range
MutableArrayRef< Expr * >::iterator updates_iterator
llvm::iterator_range< inits_iterator > inits_range
ArrayRef< const Expr * >::iterator privates_const_iterator
OpenMPLinearClauseKind getModifier() const
Return modifier.
SourceLocation getColonLoc() const
Returns the location of ':'.
MutableArrayRef< Expr * >::iterator privates_iterator
friend class OMPClauseReader
Expr * getFirst() const
Get looprange 'first' expression.
static OMPLoopRangeClause * CreateEmpty(const ASTContext &C)
Build an empty 'looprange' clause node.
const_child_range used_children() const
void setFirstLoc(SourceLocation Loc)
child_range used_children()
void setCountLoc(SourceLocation Loc)
SourceLocation getFirstLoc() const
SourceLocation getLParenLoc() const
static bool classof(const OMPClause *T)
SourceLocation getCountLoc() const
const_child_range children() const
Expr * getCount() const
Get looprange 'count' expression.
void setLParenLoc(SourceLocation Loc)
OpenMPMapClauseKind getMapType() const LLVM_READONLY
Fetches mapping kind for the clause.
friend class OMPClauseReader
ArrayRef< SourceLocation > getMapTypeModifiersLoc() const LLVM_READONLY
Fetches ArrayRef of location of map-type-modifiers.
Expr * getIteratorModifier()
Fetches Expr * of iterator modifier.
child_range used_children()
bool isImplicitMapType() const LLVM_READONLY
Is this an implicit map type?
static bool classof(const OMPClause *T)
SourceLocation getMapTypeModifierLoc(unsigned Cnt) const LLVM_READONLY
Fetches the map-type-modifier location at 'Cnt' index of array of modifiers' locations.
const_child_range children() const
ArrayRef< OpenMPMapModifierKind > getMapTypeModifiers() const LLVM_READONLY
Fetches ArrayRef of map-type-modifiers.
SourceLocation getColonLoc() const
Get colon location.
const_child_range used_children() const
SourceLocation getMapLoc() const LLVM_READONLY
Fetches location of clause mapping kind.
static OMPMapClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars original expressions, NumUniqueDeclarations declar...
OpenMPMapModifierKind getMapTypeModifier(unsigned Cnt) const LLVM_READONLY
Fetches the map-type-modifier at 'Cnt' index of array of modifiers.
Iterator that browse the components by lists.
const_component_lists_iterator & operator++()
std::tuple< const ValueDecl *, MappableExprComponentListRef, const ValueDecl * > operator->() const
std::tuple< const ValueDecl *, MappableExprComponentListRef, const ValueDecl * > operator*() const
const_component_lists_iterator(ArrayRef< ValueDecl * > UniqueDecls, ArrayRef< unsigned > DeclsListNum, ArrayRef< unsigned > CumulativeListSizes, MappableExprComponentListRef Components, bool SupportsMapper, ArrayRef< Expr * > Mappers)
Construct an iterator that scans all lists.
const_component_lists_iterator(const ValueDecl *Declaration, ArrayRef< ValueDecl * > UniqueDecls, ArrayRef< unsigned > DeclsListNum, ArrayRef< unsigned > CumulativeListSizes, MappableExprComponentListRef Components, bool SupportsMapper, ArrayRef< Expr * > Mappers)
Construct an iterator that scan lists for a given declaration Declaration.
This represents clauses with a list of expressions that are mappable.
const_component_lists_range component_lists() const
ArrayRef< MappableComponent > getComponentsRef() const
Get the components that are in the trailing objects of the class.
OMPMappableExprListClause(OpenMPClauseKind K, const OMPVarListLocTy &Locs, const OMPMappableExprListSizeTy &Sizes, bool SupportsMapper=false, NestedNameSpecifierLoc *MapperQualifierLocPtr=nullptr, DeclarationNameInfo *MapperIdInfoPtr=nullptr)
Build a clause for NumUniqueDeclarations declarations, NumComponentLists total component lists,...
llvm::iterator_range< mapperlist_iterator > mapperlist_range
friend class OMPClauseReader
MutableArrayRef< ValueDecl * > getUniqueDeclsRef()
Get the unique declarations that are in the trailing objects of the class.
MutableArrayRef< MappableComponent > getComponentsRef()
Get the components that are in the trailing objects of the class.
void setUDMapperRefs(ArrayRef< Expr * > DMDs)
Set the user-defined mappers that are in the trailing objects of the class.
ArrayRef< unsigned >::iterator const_all_lists_sizes_iterator
mapperlist_iterator mapperlist_end()
llvm::iterator_range< const_all_num_lists_iterator > const_all_num_lists_range
const_all_decls_range all_decls() const
mapperlist_const_range mapperlists() const
void setDeclNumLists(ArrayRef< unsigned > DNLs)
Set the number of lists per declaration that are in the trailing objects of the class.
const_component_lists_iterator decl_component_lists_begin(const ValueDecl *VD) const
Iterators for component lists associated with the provided declaration.
void setMapperQualifierLoc(NestedNameSpecifierLoc NNSL)
Set the nested name specifier of associated user-defined mapper.
llvm::iterator_range< const_component_lists_iterator > const_component_lists_range
unsigned getTotalComponentsNum() const
Return the total number of components in all lists derived from the clause.
MutableArrayRef< unsigned > getComponentListSizesRef()
Get the cumulative component lists sizes that are in the trailing objects of the class.
ArrayRef< Expr * > getUDMapperRefs() const
Get the user-defined mappers references that are in the trailing objects of the class.
unsigned getUniqueDeclarationsNum() const
Return the number of unique base declarations in this clause.
ArrayRef< unsigned > getComponentListSizesRef() const
Get the cumulative component lists sizes that are in the trailing objects of the class.
ArrayRef< unsigned > getDeclNumListsRef() const
Get the number of lists per declaration that are in the trailing objects of the class.
const_all_lists_sizes_range all_lists_sizes() const
void setUniqueDecls(ArrayRef< ValueDecl * > UDs)
Set the unique declarations that are in the trailing objects of the class.
llvm::iterator_range< const_all_decls_iterator > const_all_decls_range
const DeclarationNameInfo & getMapperIdInfo() const
Gets the name info for associated user-defined mapper.
const_component_lists_iterator decl_component_lists_end() const
mapperlist_iterator mapperlist_begin()
ArrayRef< unsigned >::iterator const_all_num_lists_iterator
void setComponents(ArrayRef< MappableComponent > Components, ArrayRef< unsigned > CLSs)
Set the components that are in the trailing objects of the class.
MutableArrayRef< Expr * >::iterator mapperlist_iterator
MutableArrayRef< Expr * > getUDMapperRefs()
Get the user-defined mapper references that are in the trailing objects of the class.
mapperlist_const_iterator mapperlist_begin() const
ArrayRef< const Expr * >::iterator mapperlist_const_iterator
const_all_num_lists_range all_num_lists() const
llvm::iterator_range< mapperlist_const_iterator > mapperlist_const_range
llvm::iterator_range< const_all_components_iterator > const_all_components_range
void setClauseInfo(ArrayRef< ValueDecl * > Declarations, MappableExprComponentListsRef ComponentLists)
Fill the clause information from the list of declarations and associated component lists.
unsigned getTotalComponentListNum() const
Return the number of lists derived from the clause expressions.
const_component_lists_range decl_component_lists(const ValueDecl *VD) const
void setComponentListSizes(ArrayRef< unsigned > CLSs)
Set the cumulative component lists sizes that are in the trailing objects of the class.
NestedNameSpecifierLoc getMapperQualifierLoc() const
Gets the nested name specifier for associated user-defined mapper.
ArrayRef< ValueDecl * > getUniqueDeclsRef() const
Get the unique declarations that are in the trailing objects of the class.
mapperlist_range mapperlists()
llvm::iterator_range< const_all_lists_sizes_iterator > const_all_lists_sizes_range
MutableArrayRef< unsigned > getDeclNumListsRef()
Get the number of lists per declaration that are in the trailing objects of the class.
const_component_lists_iterator component_lists_end() const
const_component_lists_iterator component_lists_begin() const
Iterators for all component lists.
ArrayRef< MappableComponent >::iterator const_all_components_iterator
mapperlist_const_iterator mapperlist_end() const
const_all_components_range all_components() const
void setMapperIdInfo(DeclarationNameInfo MapperId)
Set the name of associated user-defined mapper.
ArrayRef< ValueDecl * >::iterator const_all_decls_iterator
Iterators to access all the declarations, number of lists, list sizes, and components.
OMPMergeableClause()
Build an empty clause.
OMPMergeableClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'mergeable' clause.
const_child_range children() const
const_child_range used_children() const
static bool classof(const OMPClause *T)
child_range used_children()
Expr * getMessageString() const
Returns message string of the clause.
friend class OMPClauseReader
OMPMessageClause(Expr *MS, Stmt *HelperMS, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'message' clause with message string argument.
std::optional< std::string > tryEvaluateString(ASTContext &Ctx) const
Try to evaluate the message string at compile time.
OMPMessageClause()
Build an empty clause.
OMPNoOpenMPClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'no_openmp' clause.
OMPNoOpenMPClause()
Build an empty clause.
OMPNoOpenMPConstructsClause()
Build an empty clause.
OMPNoOpenMPConstructsClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'no_openmp_constructs' clause.
OMPNoOpenMPRoutinesClause()
Build an empty clause.
OMPNoOpenMPRoutinesClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'no_openmp_routines' clause.
OMPNoParallelismClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'no_parallelism' clause.
OMPNoParallelismClause()
Build an empty clause.
OMPNocontextClause(Expr *Cond, Stmt *HelperCond, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'nocontext' clause with condition Cond.
friend class OMPClauseReader
const_child_range used_children() const
OMPNocontextClause()
Build an empty clause.
Expr * getCondition() const
Returns condition.
child_range used_children()
OMPNogroupClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'nogroup' clause.
static bool classof(const OMPClause *T)
OMPNogroupClause()
Build an empty clause.
const_child_range children() const
child_range used_children()
const_child_range used_children() const
This represents clause 'nontemporal' in the 'pragma omp ...' directives.
friend class OMPClauseReader
static OMPNontemporalClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
const_child_range private_refs() const
static bool classof(const OMPClause *T)
child_range private_refs()
child_range used_children()
void setPrivateRefs(ArrayRef< Expr * > VL)
Sets the list of references to private copies created in private clauses.
const_child_range children() const
const_child_range used_children() const
friend class OMPClauseReader
const_child_range used_children() const
OMPNovariantsClause()
Build an empty clause.
child_range used_children()
OMPNovariantsClause(Expr *Cond, Stmt *HelperCond, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'novariants' clause with condition Cond.
Expr * getCondition() const
Returns condition.
OMPNowaitClause(SourceLocation StartLoc=SourceLocation(), SourceLocation EndLoc=SourceLocation())
Build 'nowait' clause.
const_child_range children() const
friend class OMPClauseReader
Expr * getNumTasks() const
Return safe iteration space distance.
SourceLocation getModifierLoc() const
Gets modifier location.
SourceLocation getLParenLoc() const
Returns the location of '('.
OMPNumTasksClause(OpenMPNumTasksClauseModifier Modifier, Expr *Size, Stmt *HelperSize, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ModifierLoc, SourceLocation EndLoc)
Build 'num_tasks' clause.
static bool classof(const OMPClause *T)
const_child_range used_children() const
OMPNumTasksClause()
Build an empty clause.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
child_range used_children()
OpenMPNumTasksClauseModifier getModifier() const
Gets modifier.
SourceLocation getLParenLoc() const
Returns the location of '('.
const_child_range children() const
const_child_range used_children() const
static bool classof(const OMPClause *T)
child_range used_children()
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
ArrayRef< Expr * > getNumTeams() const
Return NumTeams expressions.
static OMPNumTeamsClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
ArrayRef< Expr * > getNumTeams()
Return NumTeams expressions.
OpenMPNumThreadsClauseModifier getModifier() const
Gets modifier.
friend class OMPClauseReader
SourceLocation getModifierLoc() const
Gets modifier location.
OMPNumThreadsClause()
Build an empty clause.
OMPNumThreadsClause(OpenMPNumThreadsClauseModifier Modifier, Expr *NumThreads, Stmt *HelperNumThreads, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ModifierLoc, SourceLocation EndLoc)
Build 'num_threads' clause with condition NumThreads.
Expr * getNumThreads() const
Returns number of threads.
const_child_range used_children() const
child_range used_children()
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
OMPOneStmtClause(Stmt *S, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
static bool classof(const OMPClause *T)
ConstStmtIterator const_child_iterator
const_child_range children() const
StmtIterator child_iterator
llvm::iterator_range< child_iterator > child_range
SourceLocation getLParenLoc() const
Returns the location of '('.
llvm::iterator_range< const_child_iterator > const_child_range
T * getStmtAs() const
Return the associated statement, potentially casted to T.
OMPOrderClause(OpenMPOrderClauseKind A, SourceLocation ALoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, OpenMPOrderClauseModifier Modifier, SourceLocation MLoc)
Build 'order' clause with argument A ('concurrent').
friend class OMPClauseReader
SourceLocation getLParenLoc() const
Returns the location of '('.
const_child_range children() const
const_child_range used_children() const
SourceLocation getKindKwLoc() const
Returns location of clause kind.
static bool classof(const OMPClause *T)
SourceLocation getModifierKwLoc() const
Returns location of clause modifier.
OpenMPOrderClauseKind getKind() const
Returns kind of the clause.
child_range used_children()
OMPOrderClause()
Build an empty clause.
OpenMPOrderClauseModifier getModifier() const
Returns Modifier of the clause.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
This represents 'ordered' clause in the 'pragma omp ...' directive.
friend class OMPClauseReader
const_child_range children() const
void setLoopCounter(unsigned NumLoop, Expr *Counter)
Set loop counter for the specified loop.
static bool classof(const OMPClause *T)
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
Expr * getNumForLoops() const
Return the number of associated for-loops.
void setLoopNumIterations(unsigned NumLoop, Expr *NumIterations)
Set number of iterations for the specified loop.
SourceLocation getLParenLoc() const
Returns the location of '('.
const_child_range used_children() const
ArrayRef< Expr * > getLoopNumIterations() const
Get number of iterations for all the loops.
child_range used_children()
static OMPOrderedClause * CreateEmpty(const ASTContext &C, unsigned NumLoops)
Build an empty clause.
Expr * getLoopCounter(unsigned NumLoop)
Get loops counter for the specified loop.
child_range used_children()
friend class OMPClauseReader
static OMPPartialClause * CreateEmpty(const ASTContext &C)
Build an empty 'partial' AST node for deserialization.
const_child_range used_children() const
SourceLocation getLParenLoc() const
Returns the location of '('.
const_child_range children() const
static bool classof(const OMPClause *T)
Expr * getFactor() const
Returns the argument of the clause or nullptr if not set.
This class represents the 'permutation' clause in the 'pragma omp interchange' directive.
static bool classof(const OMPClause *T)
friend class OMPClauseReader
ArrayRef< Expr * > getArgsRefs() const
unsigned getNumLoops() const
Returns the number of list items.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
SourceLocation getLParenLoc() const
Returns the location of '('.
child_range used_children()
MutableArrayRef< Expr * > getArgsRefs()
Returns the permutation index expressions.
static OMPPermutationClause * CreateEmpty(const ASTContext &C, unsigned NumLoops)
Build an empty 'permutation' AST node for deserialization.
const_child_range used_children() const
const_child_range children() const
OMPPriorityClause(Expr *Priority, Stmt *HelperPriority, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'priority' clause.
Expr * getPriority() const
Return Priority number.
friend class OMPClauseReader
const_child_range used_children() const
static bool classof(const OMPClause *T)
const_child_range children() const
child_range used_children()
OMPPriorityClause()
Build an empty clause.
SourceLocation getLParenLoc() const
Returns the location of '('.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
Expr * getPriority()
Return Priority number.
This represents clause 'private' in the 'pragma omp ...' directives.
const_child_range children() const
friend class OMPClauseReader
private_copies_range private_copies()
static bool classof(const OMPClause *T)
const_child_range used_children() const
child_range used_children()
llvm::iterator_range< private_copies_const_iterator > private_copies_const_range
llvm::iterator_range< private_copies_iterator > private_copies_range
ArrayRef< const Expr * >::iterator private_copies_const_iterator
private_copies_const_range private_copies() const
MutableArrayRef< Expr * >::iterator private_copies_iterator
static OMPPrivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
friend class OMPClauseReader
child_range used_children()
const_child_range used_children() const
SourceLocation getProcBindKindKwLoc() const
Returns location of clause kind.
const_child_range children() const
SourceLocation getLParenLoc() const
Returns the location of '('.
OMPProcBindClause()
Build an empty clause.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
OMPProcBindClause(llvm::omp::ProcBindKind A, SourceLocation ALoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'proc_bind' clause with argument A ('master', 'close' or 'spread').
llvm::omp::ProcBindKind getProcBindKind() const
Returns kind of the clause.
static bool classof(const OMPClause *T)
static bool classof(const OMPClause *T)
child_range used_children()
const_child_range children() const
const_child_range used_children() const
OMPReadClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'read' clause.
OMPReadClause()
Build an empty clause.
This represents clause 'reduction' in the 'pragma omp ...' directives.
llvm::iterator_range< helper_expr_const_iterator > helper_expr_const_range
friend class OMPClauseReader
child_range used_children()
OpenMPOriginalSharingModifier getOriginalSharingModifier() const
Returns Original Sharing Modifier.
MutableArrayRef< Expr * >::iterator helper_expr_iterator
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
helper_expr_const_range rhs_exprs() const
llvm::iterator_range< helper_expr_iterator > helper_expr_range
helper_expr_const_range lhs_exprs() const
helper_expr_range copy_array_temps()
static OMPReductionClause * CreateEmpty(const ASTContext &C, unsigned N, OpenMPReductionClauseModifier Modifier)
Creates an empty clause with the place for N variables.
helper_expr_range rhs_exprs()
helper_expr_range copy_array_elems()
helper_expr_range lhs_exprs()
helper_expr_const_range copy_array_temps() const
const_child_range used_children() const
helper_expr_const_range reduction_ops() const
helper_expr_range privates()
ArrayRef< const Expr * >::iterator helper_expr_const_iterator
ArrayRef< bool >::iterator helper_flag_const_iterator
helper_expr_const_range privates() const
MutableArrayRef< bool >::iterator helper_flag_iterator
llvm::iterator_range< helper_flag_const_iterator > helper_flag_const_range
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
static bool classof(const OMPClause *T)
helper_expr_const_range copy_array_elems() const
helper_expr_const_range copy_ops() const
helper_flag_const_range private_var_reduction_flags() const
OpenMPReductionClauseModifier getModifier() const
Returns modifier.
SourceLocation getModifierLoc() const
Returns modifier location.
helper_expr_range copy_ops()
const_child_range children() const
SourceLocation getColonLoc() const
Gets location of ':' symbol in clause.
llvm::iterator_range< helper_flag_iterator > helper_flag_range
helper_expr_range reduction_ops()
helper_flag_range private_var_reduction_flags()
static bool classof(const OMPClause *T)
const_child_range used_children() const
child_range used_children()
OMPRelaxedClause()
Build an empty clause.
const_child_range children() const
OMPRelaxedClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'relaxed' clause.
const_child_range children() const
child_range used_children()
OMPReleaseClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'release' clause.
OMPReleaseClause()
Build an empty clause.
static bool classof(const OMPClause *T)
const_child_range used_children() const
const_child_range children() const
const_child_range used_children() const
friend class OMPClauseReader
OMPReverseOffloadClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'reverse_offload' clause.
static bool classof(const OMPClause *T)
OMPReverseOffloadClause()
Build an empty clause.
child_range used_children()
OMPSIMDClause()
Build an empty clause.
const_child_range children() const
const_child_range used_children() const
child_range used_children()
static bool classof(const OMPClause *T)
OMPSIMDClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'simd' clause.
friend class OMPClauseReader
OMPSafelenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'safelen' clause.
Expr * getSafelen() const
Return safe iteration space distance.
OMPSafelenClause()
Build an empty clause.
static bool classof(const OMPClause *T)
friend class OMPClauseReader
SourceLocation getFirstScheduleModifierLoc() const
Get the first modifier location.
OMPScheduleClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KLoc, SourceLocation CommaLoc, SourceLocation EndLoc, OpenMPScheduleClauseKind Kind, Expr *ChunkSize, Stmt *HelperChunkSize, OpenMPScheduleClauseModifier M1, SourceLocation M1Loc, OpenMPScheduleClauseModifier M2, SourceLocation M2Loc)
Build 'schedule' clause with schedule kind Kind and chunk size expression ChunkSize.
SourceLocation getScheduleKindLoc()
Get kind location.
OpenMPScheduleClauseKind getScheduleKind() const
Get kind of the clause.
SourceLocation getLParenLoc()
Get location of '('.
const Expr * getChunkSize() const
Get chunk size.
OMPScheduleClause()
Build an empty clause.
OpenMPScheduleClauseModifier getSecondScheduleModifier() const
Get the second modifier of the clause.
SourceLocation getCommaLoc()
Get location of ','.
OpenMPScheduleClauseModifier getFirstScheduleModifier() const
Get the first modifier of the clause.
child_range used_children()
SourceLocation getSecondScheduleModifierLoc() const
Get the second modifier location.
const_child_range children() const
const_child_range used_children() const
Expr * getChunkSize()
Get chunk size.
child_range used_children()
friend class OMPClauseReader
static bool classof(const OMPClause *T)
OMPSelfMapsClause()
Build an empty clause.
OMPSelfMapsClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'self_maps' clause.
const_child_range used_children() const
const_child_range children() const
OMPSeqCstClause()
Build an empty clause.
const_child_range used_children() const
OMPSeqCstClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'seq_cst' clause.
child_range used_children()
const_child_range children() const
static bool classof(const OMPClause *T)
friend class OMPClauseReader
child_range used_children()
SourceLocation getLParenLoc() const
Returns the locaiton of '('.
const_child_range children() const
static bool classof(const OMPClause *T)
OMPSeverityClause()
Build an empty clause.
OMPSeverityClause(OpenMPSeverityClauseKind A, SourceLocation ALoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'severity' clause with argument A ('fatal' or 'warning').
OpenMPSeverityClauseKind getSeverityKind() const
Returns kind of the clause.
const_child_range used_children() const
SourceLocation getSeverityKindKwLoc() const
Returns location of clause kind.
child_range used_children()
const_child_range used_children() const
static OMPSharedClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
const_child_range children() const
static bool classof(const OMPClause *T)
friend class OMPClauseReader
OMPSimdlenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'simdlen' clause.
Expr * getSimdlen() const
Return safe iteration space distance.
OMPSimdlenClause()
Build an empty clause.
This represents the 'sizes' clause in the 'pragma omp tile' directive.
SourceLocation getLParenLoc() const
Returns the location of '('.
friend class OMPClauseReader
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
static bool classof(const OMPClause *T)
const_child_range used_children() const
void setSizesRefs(ArrayRef< Expr * > VL)
Sets the tile size expressions.
unsigned getNumSizes() const
Returns the number of list items.
child_range used_children()
MutableArrayRef< Expr * > getSizesRefs()
Returns the tile size expressions.
ArrayRef< Expr * > getSizesRefs() const
const_child_range children() const
static OMPSizesClause * CreateEmpty(const ASTContext &C, unsigned NumSizes)
Build an empty 'sizes' AST node for deserialization.
This represents clause 'task_reduction' in the 'pragma omp taskgroup' directives.
helper_expr_const_range rhs_exprs() const
friend class OMPClauseReader
llvm::iterator_range< helper_expr_iterator > helper_expr_range
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
helper_expr_const_range lhs_exprs() const
const_child_range used_children() const
helper_expr_const_range reduction_ops() const
helper_expr_range privates()
const_child_range children() const
SourceLocation getColonLoc() const
Gets location of ':' symbol in clause.
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
ArrayRef< const Expr * >::iterator helper_expr_const_iterator
MutableArrayRef< Expr * >::iterator helper_expr_iterator
llvm::iterator_range< helper_expr_const_iterator > helper_expr_const_range
helper_expr_range rhs_exprs()
helper_expr_range lhs_exprs()
helper_expr_range reduction_ops()
helper_expr_const_range privates() const
static OMPTaskReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
static bool classof(const OMPClause *T)
child_range used_children()
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
ArrayRef< Expr * > getThreadLimit()
Return ThreadLimit expressions.
const_child_range children() const
ArrayRef< Expr * > getThreadLimit() const
Return ThreadLimit expressions.
SourceLocation getLParenLoc() const
Returns the location of '('.
static OMPThreadLimitClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
child_range used_children()
const_child_range used_children() const
static bool classof(const OMPClause *T)
OMPThreadsClause()
Build an empty clause.
OMPThreadsClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'threads' clause.
This represents clause 'to' in the 'pragma omp ...' directives.
friend class OMPClauseReader
static OMPToClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
const_child_range used_children() const
SourceLocation getMotionModifierLoc(unsigned Cnt) const LLVM_READONLY
Fetches the motion-modifier location at 'Cnt' index of array of modifiers' locations.
ArrayRef< OpenMPMotionModifierKind > getMotionModifiers() const LLVM_READONLY
Fetches ArrayRef of motion-modifiers.
ArrayRef< SourceLocation > getMotionModifiersLoc() const LLVM_READONLY
Fetches ArrayRef of location of motion-modifiers.
const_child_range children() const
SourceLocation getColonLoc() const
Get colon location.
static bool classof(const OMPClause *T)
child_range used_children()
OpenMPMotionModifierKind getMotionModifier(unsigned Cnt) const LLVM_READONLY
Fetches the motion-modifier at 'Cnt' index of array of modifiers.
bool isExtensionActive(llvm::omp::TraitProperty TP)
Check the extension trait TP is active.
bool anyScoreOrCondition(llvm::function_ref< bool(Expr *&, bool)> Cond)
std::string getMangledName() const
Return a string representation identifying this context selector.
void print(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const
Print a human readable representation into OS.
void getAsVariantMatchInfo(ASTContext &ASTCtx, llvm::omp::VariantMatchInfo &VMI) const
Create a variant match info object from this trait info object.
llvm::SmallVector< OMPTraitSet, 2 > Sets
The outermost level of selector sets.
friend class OMPClauseReader
OMPUnifiedAddressClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'unified_address' clause.
OMPUnifiedAddressClause()
Build an empty clause.
OMPUnifiedSharedMemoryClause()
Build an empty clause.
friend class OMPClauseReader
static bool classof(const OMPClause *T)
const_child_range children() const
OMPUnifiedSharedMemoryClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'unified_shared_memory' clause.
const_child_range used_children() const
child_range used_children()
child_range used_children()
OMPUntiedClause()
Build an empty clause.
OMPUntiedClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'untied' clause.
static bool classof(const OMPClause *T)
const_child_range used_children() const
const_child_range children() const
friend class OMPClauseReader
const_child_range used_children() const
const_child_range children() const
OpenMPDependClauseKind getDependencyKind() const
Gets the dependence kind in clause for 'depobj' directive.
static OMPUpdateClause * CreateEmpty(const ASTContext &C, bool IsExtended)
Creates an empty clause with the place for N variables.
child_range used_children()
static bool classof(const OMPClause *T)
SourceLocation getLParenLoc() const
Gets the location of '(' in clause for 'depobj' directive.
SourceLocation getArgumentLoc() const
Gets the location of argument in clause for 'depobj' directive.
bool isExtended() const
Checks if the clause is the extended clauses for 'depobj' directive.
friend class OMPClauseReader
child_range used_children()
SourceLocation getVarLoc() const
Returns the location of the interop variable.
OMPUseClause()
Build an empty clause.
const_child_range used_children() const
const_child_range children() const
OMPUseClause(Expr *InteropVar, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc)
Build 'use' clause with and interop variable expression InteropVar.
static bool classof(const OMPClause *T)
SourceLocation getLParenLoc() const
Returns the location of '('.
Expr * getInteropVar() const
Returns the interop variable.
This represents clause 'use_device_addr' in the 'pragma omp ...' directives.
friend class OMPClauseReader
const_child_range used_children() const
static bool classof(const OMPClause *T)
child_range used_children()
const_child_range children() const
static OMPUseDeviceAddrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents clause 'use_device_ptr' in the 'pragma omp ...' directives.
ArrayRef< const Expr * >::iterator private_copies_const_iterator
friend class OMPClauseReader
llvm::iterator_range< private_copies_const_iterator > private_copies_const_range
private_copies_const_range private_copies() const
const_child_range used_children() const
const_child_range children() const
llvm::iterator_range< inits_iterator > inits_range
MutableArrayRef< Expr * >::iterator inits_iterator
inits_const_range inits() const
static OMPUseDevicePtrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
child_range used_children()
ArrayRef< const Expr * >::iterator inits_const_iterator
static bool classof(const OMPClause *T)
MutableArrayRef< Expr * >::iterator private_copies_iterator
private_copies_range private_copies()
llvm::iterator_range< inits_const_iterator > inits_const_range
llvm::iterator_range< private_copies_iterator > private_copies_range
static bool classof(const OMPClause *T)
friend class OMPClauseReader
SourceLocation getLParenLoc() const
Returns the location of '('.
child_range used_children()
const_child_range children() const
OMPUsesAllocatorsClause::Data getAllocatorData(unsigned I) const
Returns data for the specified allocator.
static OMPUsesAllocatorsClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N allocators.
unsigned getNumberOfAllocators() const
Returns number of allocators associated with the clause.
const_child_range used_children() const
This represents clauses with the list of variables like 'private', 'firstprivate',...
varlist_const_range varlist() const
friend class OMPClauseReader
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
ArrayRef< const Expr * > getVarRefs() const
Fetches list of all variables in the clause.
OMPVarListClause(OpenMPClauseKind K, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, unsigned N)
Build a clause with N variables.
MutableArrayRef< Expr * > getVarRefs()
Fetches list of variables associated with this clause.
varlist_const_iterator varlist_end() const
varlist_iterator varlist_end()
llvm::iterator_range< varlist_const_iterator > varlist_const_range
MutableArrayRef< Expr * >::iterator varlist_iterator
varlist_iterator varlist_begin()
ArrayRef< const Expr * >::iterator varlist_const_iterator
SourceLocation getLParenLoc() const
Returns the location of '('.
bool varlist_empty() const
unsigned varlist_size() const
varlist_const_iterator varlist_begin() const
llvm::iterator_range< varlist_iterator > varlist_range
void setVarRefs(ArrayRef< Expr * > VL)
Sets the list of variables for this clause.
const_child_range used_children() const
OMPWeakClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'weak' clause.
static bool classof(const OMPClause *T)
child_range used_children()
OMPWeakClause()
Build an empty clause.
const_child_range children() const
OMPWriteClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'write' clause.
const_child_range used_children() const
child_range used_children()
static bool classof(const OMPClause *T)
const_child_range children() const
OMPWriteClause()
Build an empty clause.
ArrayRef< const Attr * > getAttrs() const
Returned the attributes parsed from this clause.
OMPXAttributeClause()
Build an empty clause.
void setLParenLoc(SourceLocation Loc)
Sets the location of '('.
friend class OMPClauseReader
SourceLocation getLParenLoc() const
Returns the location of '('.
OMPXAttributeClause(ArrayRef< const Attr * > Attrs, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'ompx_attribute' clause.
OMPXBareClause()=default
Build an empty clause.
OMPXBareClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'ompx_bare' clause.
friend class OMPClauseReader
OMPXDynCGroupMemClause(Expr *Size, Stmt *HelperSize, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'ompx_dyn_cgroup_mem' clause.
Expr * getSize()
Return the size expression.
Expr * getSize() const
Return the size expression.
OMPXDynCGroupMemClause()
Build an empty clause.
A (possibly-)qualified type.
Smart pointer class that efficiently represents Objective-C method names.
Encodes a location in the source.
Stmt - This represents one statement.
StmtIterator child_iterator
Child Iterators: All subclasses must implement 'children' to permit easy iteration over the substatem...
llvm::iterator_range< child_iterator > child_range
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
The JSON file list parser is used to communicate input to InstallAPI.
OpenMPOriginalSharingModifier
OpenMP 6.0 original sharing modifiers.
bool checkFailClauseParameter(OpenMPClauseKind FailClauseParameter)
Checks if the parameter to the fail clause in "#pragma atomic compare fail" is restricted only to mem...
OpenMPDefaultClauseVariableCategory
OpenMP variable-category for 'default' clause.
OpenMPDefaultmapClauseModifier
OpenMP modifiers for 'defaultmap' clause.
@ OMPC_DEFAULTMAP_MODIFIER_unknown
OpenMPOrderClauseModifier
OpenMP modifiers for 'order' clause.
@ OMPC_ORDER_MODIFIER_unknown
std::add_pointer_t< std::add_const_t< T > > const_ptr
OpenMPAtClauseKind
OpenMP attributes for 'at' clause.
OpenMPReductionClauseModifier
OpenMP modifiers for 'reduction' clause.
@ DeviceNum
'device_num' clause, allowed on 'init', 'shutdown', and 'set' constructs.
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
OpenMPScheduleClauseModifier
OpenMP modifiers for 'schedule' clause.
@ OMPC_SCHEDULE_MODIFIER_unknown
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
@ OMPC_DIST_SCHEDULE_unknown
OpenMPDoacrossClauseModifier
OpenMP dependence types for 'doacross' clause.
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
static constexpr unsigned NumberOfOMPMapClauseModifiers
Number of allowed map-type-modifiers.
@ Property
The type of a property.
OpenMPBindClauseKind
OpenMP bindings for the 'bind' clause.
const FunctionProtoType * T
OpenMPLastprivateModifier
OpenMP 'lastprivate' clause modifier.
OpenMPDependClauseKind
OpenMP attributes for 'depend' clause.
OpenMPGrainsizeClauseModifier
OpenMPNumTasksClauseModifier
@ Type
The name was classified as a type.
OpenMPSeverityClauseKind
OpenMP attributes for 'severity' clause.
static constexpr unsigned NumberOfOMPMotionModifiers
Number of allowed motion-modifiers.
OpenMPMotionModifierKind
OpenMP modifier kind for 'to' or 'from' clause.
@ OMPC_MOTION_MODIFIER_unknown
OpenMPDefaultmapClauseKind
OpenMP attributes for 'defaultmap' clause.
@ OMPC_DEFAULTMAP_unknown
OpenMPAllocateClauseModifier
OpenMP modifiers for 'allocate' clause.
OpenMPLinearClauseKind
OpenMP attributes for 'linear' clause.
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
OpenMPNumThreadsClauseModifier
@ OMPC_NUMTHREADS_unknown
OpenMPAtomicDefaultMemOrderClauseKind
OpenMP attributes for 'atomic_default_mem_order' clause.
@ OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown
U cast(CodeGen::Address addr)
OpenMPDeviceClauseModifier
OpenMP modifiers for 'device' clause.
OpenMPMapModifierKind
OpenMP modifier kind for 'map' clause.
@ OMPC_MAP_MODIFIER_unknown
llvm::omp::Clause OpenMPClauseKind
OpenMP clauses.
@ Other
Other implicit parameter.
OpenMPOrderClauseKind
OpenMP attributes for 'order' clause.
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
OpenMPMapClauseKind
OpenMP mapping kind for 'map' clause.
Diagnostic wrappers for TextAPI types for error reporting.
int const char * function
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation OmpAllMemoryLoc
Location of 'omp_all_memory'.
SourceLocation ColonLoc
Colon location.
OpenMPDependClauseKind DepKind
Dependency type (one of in, out, inout).
SourceLocation DepLoc
Dependency type location.
This structure contains all sizes needed for by an OMPMappableExprListClause.
unsigned NumComponentLists
Number of component lists.
OMPMappableExprListSizeTy(unsigned NumVars, unsigned NumUniqueDeclarations, unsigned NumComponentLists, unsigned NumComponents)
unsigned NumVars
Number of expressions listed.
OMPMappableExprListSizeTy()=default
unsigned NumUniqueDeclarations
Number of unique base declarations.
unsigned NumComponents
Total number of expression components.
const_child_range used_children() const
static bool classof(const OMPClause *T)
OMPNoChildClause(SourceLocation StartLoc, SourceLocation EndLoc)
Build 'ClauseKind' clause.
child_range used_children()
OMPNoChildClause()
Build an empty clause.
const_child_range children() const
llvm::omp::TraitProperty Kind
StringRef RawString
The raw string as we parsed it.
llvm::omp::TraitSelector Kind
SmallVector< OMPTraitProperty, 1 > Properties
SmallVector< OMPTraitSelector, 2 > Selectors
Data for list of allocators.
SourceLocation LParenLoc
Locations of '(' and ')' symbols.
Expr * AllocatorTraits
Allocator traits.
Expr * Allocator
Allocator.
This structure contains most locations needed for by an OMPVarListClause.
SourceLocation StartLoc
Starting location of the clause (the clause keyword).
SourceLocation LParenLoc
Location of '('.
SourceLocation EndLoc
Ending location of the clause.
OMPVarListLocTy()=default
OMPVarListLocTy(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Describes how types, statements, expressions, and declarations should be printed.
TargetOMPContext(ASTContext &ASTCtx, std::function< void(StringRef)> &&DiagUnknownTrait, const FunctionDecl *CurrentFunctionDecl, ArrayRef< llvm::omp::TraitProperty > ConstructTraits, int DeviceNum)
bool matchesISATrait(StringRef RawString) const override
See llvm::omp::OMPContext::matchesISATrait.
virtual ~TargetOMPContext()=default