22#include "llvm/ADT/SmallPtrSet.h"
23#include "llvm/Support/ErrorHandling.h"
36#define GEN_CLANG_CLAUSE_CLASS
37#define CLAUSE_CLASS(Enum, Str, Class) \
39 return static_cast<Class *>(this)->children();
40#include "llvm/Frontend/OpenMP/OMP.inc"
42 llvm_unreachable(
"unknown OMPClause");
47#define GEN_CLANG_CLAUSE_CLASS
48#define CLAUSE_CLASS(Enum, Str, Class) \
50 return static_cast<Class *>(this)->used_children();
51#define CLAUSE_NO_CLASS(Enum, Str) \
54#include "llvm/Frontend/OpenMP/OMP.inc"
56 llvm_unreachable(
"unknown OMPClause");
65 switch (
C->getClauseKind()) {
68 case OMPC_dist_schedule:
70 case OMPC_firstprivate:
72 case OMPC_lastprivate:
76 case OMPC_task_reduction:
78 case OMPC_in_reduction:
84 case OMPC_num_threads:
88 case OMPC_thread_limit:
100 case OMPC_novariants:
106 case OMPC_ompx_dyn_cgroup_mem:
122 case OMPC_copyprivate:
127 case OMPC_threadprivate:
128 case OMPC_groupprivate:
148 case OMPC_defaultmap:
153 case OMPC_use_device_ptr:
154 case OMPC_use_device_addr:
155 case OMPC_is_device_ptr:
156 case OMPC_has_device_addr:
157 case OMPC_unified_address:
158 case OMPC_unified_shared_memory:
159 case OMPC_reverse_offload:
160 case OMPC_dynamic_allocators:
161 case OMPC_atomic_default_mem_order:
165 case OMPC_device_type:
167 case OMPC_nontemporal:
173 case OMPC_uses_allocators:
192 switch (
C->getClauseKind()) {
193 case OMPC_lastprivate:
197 case OMPC_task_reduction:
199 case OMPC_in_reduction:
204 case OMPC_dist_schedule:
205 case OMPC_firstprivate:
210 case OMPC_num_threads:
221 case OMPC_copyprivate:
226 case OMPC_threadprivate:
227 case OMPC_groupprivate:
247 case OMPC_thread_limit:
253 case OMPC_defaultmap:
258 case OMPC_use_device_ptr:
259 case OMPC_use_device_addr:
260 case OMPC_is_device_ptr:
261 case OMPC_has_device_addr:
262 case OMPC_unified_address:
263 case OMPC_unified_shared_memory:
264 case OMPC_reverse_offload:
265 case OMPC_dynamic_allocators:
266 case OMPC_atomic_default_mem_order:
271 case OMPC_device_type:
273 case OMPC_nontemporal:
276 case OMPC_novariants:
281 case OMPC_uses_allocators:
298 if (
auto *DS = dyn_cast<DeclStmt>(S)) {
299 assert(DS->isSingleDecl() &&
"Only single expression must be captured.");
300 if (
auto *OED = dyn_cast<OMPCapturedExprDecl>(DS->getSingleDecl()))
301 return OED->getInitAddress();
353 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
355 new (Mem) OMPOrderedClause(
Num, NumLoops, StartLoc, LParenLoc, EndLoc);
356 for (
unsigned I = 0; I < NumLoops; ++I) {
357 Clause->setLoopNumIterations(I,
nullptr);
358 Clause->setLoopCounter(I,
nullptr);
365 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
366 auto *Clause =
new (Mem) OMPOrderedClause(NumLoops);
367 for (
unsigned I = 0; I < NumLoops; ++I) {
368 Clause->setLoopNumIterations(I,
nullptr);
369 Clause->setLoopCounter(I,
nullptr);
375 Expr *NumIterations) {
376 assert(NumLoop < NumberOfLoops &&
"out of loops number.");
377 getTrailingObjects()[NumLoop] = NumIterations;
381 return getTrailingObjects(NumberOfLoops);
385 assert(NumLoop < NumberOfLoops &&
"out of loops number.");
386 getTrailingObjects()[NumberOfLoops + NumLoop] = Counter;
390 assert(NumLoop < NumberOfLoops &&
"out of loops number.");
391 return getTrailingObjects()[NumberOfLoops + NumLoop];
395 assert(NumLoop < NumberOfLoops &&
"out of loops number.");
396 return getTrailingObjects()[NumberOfLoops + NumLoop];
402 return new (
C) OMPUpdateClause(StartLoc, EndLoc,
false);
410 C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPDependClauseKind>(2, 1),
411 alignof(OMPUpdateClause));
413 new (Mem) OMPUpdateClause(StartLoc, EndLoc,
true);
414 Clause->setLParenLoc(LParenLoc);
415 Clause->setArgumentLoc(ArgumentLoc);
416 Clause->setDependencyKind(DK);
423 return new (
C) OMPUpdateClause(
false);
425 C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPDependClauseKind>(2, 1),
426 alignof(OMPUpdateClause));
427 auto *Clause =
new (Mem) OMPUpdateClause(
true);
428 Clause->IsExtended =
true;
434 "Number of private copies is not the same as the preallocated buffer");
443 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
444 OMPPrivateClause *Clause =
445 new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
446 Clause->setVarRefs(VL);
447 Clause->setPrivateCopies(PrivateVL);
453 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
454 return new (Mem) OMPPrivateClause(N);
459 "Number of private copies is not the same as the preallocated buffer");
465 "Number of inits is not the same as the preallocated buffer");
466 llvm::copy(VL, getPrivateCopies().end());
474 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
475 OMPFirstprivateClause *Clause =
476 new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
477 Clause->setVarRefs(VL);
478 Clause->setPrivateCopies(PrivateVL);
479 Clause->setInits(InitVL);
480 Clause->setPreInitStmt(PreInit);
486 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
487 return new (Mem) OMPFirstprivateClause(N);
492 "Number of private copies is not the same as the preallocated buffer");
497 assert(SrcExprs.size() ==
varlist_size() &&
"Number of source expressions is "
498 "not the same as the "
499 "preallocated buffer");
500 llvm::copy(SrcExprs, getPrivateCopies().end());
504 assert(DstExprs.size() ==
varlist_size() &&
"Number of destination "
505 "expressions is not the same as "
506 "the preallocated buffer");
507 llvm::copy(DstExprs, getSourceExprs().end());
510void OMPLastprivateClause::setAssignmentOps(
ArrayRef<Expr *> AssignmentOps) {
512 "Number of assignment expressions is not the same as the preallocated "
514 llvm::copy(AssignmentOps, getDestinationExprs().end());
523 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
524 OMPLastprivateClause *Clause =
new (Mem) OMPLastprivateClause(
525 StartLoc, LParenLoc, EndLoc, LPKind, LPKindLoc, ColonLoc, VL.size());
526 Clause->setVarRefs(VL);
527 Clause->setSourceExprs(SrcExprs);
528 Clause->setDestinationExprs(DstExprs);
529 Clause->setAssignmentOps(AssignmentOps);
530 Clause->setPreInitStmt(PreInit);
531 Clause->setPostUpdateExpr(PostUpdate);
537 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
538 return new (Mem) OMPLastprivateClause(N);
546 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
547 OMPSharedClause *Clause =
548 new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
549 Clause->setVarRefs(VL);
554 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N));
555 return new (Mem) OMPSharedClause(N);
560 "Number of privates is not the same as the preallocated buffer");
566 "Number of inits is not the same as the preallocated buffer");
567 llvm::copy(IL, getPrivates().end());
572 "Number of updates is not the same as the preallocated buffer");
573 llvm::copy(UL, getInits().end());
578 "Number of final updates is not the same as the preallocated buffer");
579 llvm::copy(FL, getUpdates().end());
585 "Number of used expressions is not the same as the preallocated buffer");
586 llvm::copy(UE, getFinals().end() + 2);
599 C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
600 OMPLinearClause *Clause =
601 new (Mem) OMPLinearClause(StartLoc, LParenLoc, Modifier, ModifierLoc,
602 ColonLoc, StepModifierLoc, EndLoc, VL.size());
603 Clause->setVarRefs(VL);
604 Clause->setPrivates(PL);
605 Clause->setInits(IL);
608 std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
610 std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
612 std::fill(Clause->getUsedExprs().begin(), Clause->getUsedExprs().end(),
614 Clause->setStep(Step);
615 Clause->setCalcStep(CalcStep);
616 Clause->setPreInitStmt(PreInit);
617 Clause->setPostUpdateExpr(PostUpdate);
625 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars +1));
626 return new (Mem) OMPLinearClause(NumVars);
632 reinterpret_cast<Stmt **
>(getUsedExprs().begin()),
633 reinterpret_cast<Stmt **
>(llvm::find(getUsedExprs(),
nullptr)));
640 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
641 OMPAlignedClause *Clause =
new (Mem)
642 OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
643 Clause->setVarRefs(VL);
644 Clause->setAlignment(A);
650 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
651 return new (Mem) OMPAlignedClause(NumVars);
658 return new (
C) OMPAlignClause(A, StartLoc, LParenLoc, EndLoc);
662 assert(SrcExprs.size() ==
varlist_size() &&
"Number of source expressions is "
663 "not the same as the "
664 "preallocated buffer");
669 assert(DstExprs.size() ==
varlist_size() &&
"Number of destination "
670 "expressions is not the same as "
671 "the preallocated buffer");
672 llvm::copy(DstExprs, getSourceExprs().end());
677 "Number of assignment expressions is not the same as the preallocated "
679 llvm::copy(AssignmentOps, getDestinationExprs().end());
686 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
687 OMPCopyinClause *Clause =
688 new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
689 Clause->setVarRefs(VL);
690 Clause->setSourceExprs(SrcExprs);
691 Clause->setDestinationExprs(DstExprs);
692 Clause->setAssignmentOps(AssignmentOps);
697 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
698 return new (Mem) OMPCopyinClause(N);
702 assert(SrcExprs.size() ==
varlist_size() &&
"Number of source expressions is "
703 "not the same as the "
704 "preallocated buffer");
709 assert(DstExprs.size() ==
varlist_size() &&
"Number of destination "
710 "expressions is not the same as "
711 "the preallocated buffer");
712 llvm::copy(DstExprs, getSourceExprs().end());
715void OMPCopyprivateClause::setAssignmentOps(
ArrayRef<Expr *> AssignmentOps) {
717 "Number of assignment expressions is not the same as the preallocated "
719 llvm::copy(AssignmentOps, getDestinationExprs().end());
726 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
727 OMPCopyprivateClause *Clause =
728 new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
729 Clause->setVarRefs(VL);
730 Clause->setSourceExprs(SrcExprs);
731 Clause->setDestinationExprs(DstExprs);
732 Clause->setAssignmentOps(AssignmentOps);
738 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
739 return new (Mem) OMPCopyprivateClause(N);
744 "Number of private copies is not the same as the preallocated buffer");
751 "Number of LHS expressions is not the same as the preallocated buffer");
752 llvm::copy(LHSExprs, getPrivates().end());
758 "Number of RHS expressions is not the same as the preallocated buffer");
759 llvm::copy(RHSExprs, getLHSExprs().end());
763 assert(ReductionOps.size() ==
varlist_size() &&
"Number of reduction "
764 "expressions is not the same "
765 "as the preallocated buffer");
766 llvm::copy(ReductionOps, getRHSExprs().end());
770 assert(Modifier == OMPC_REDUCTION_inscan &&
"Expected inscan reduction.");
771 assert(Ops.size() ==
varlist_size() &&
"Number of copy "
772 "expressions is not the same "
773 "as the preallocated buffer");
774 llvm::copy(Ops, getReductionOps().end());
777void OMPReductionClause::setInscanCopyArrayTemps(
779 assert(Modifier == OMPC_REDUCTION_inscan &&
"Expected inscan reduction.");
781 "Number of copy temp expressions is not the same as the preallocated "
783 llvm::copy(CopyArrayTemps, getInscanCopyOps().end());
786void OMPReductionClause::setInscanCopyArrayElems(
788 assert(Modifier == OMPC_REDUCTION_inscan &&
"Expected inscan reduction.");
790 "Number of copy temp expressions is not the same as the preallocated "
792 llvm::copy(CopyArrayElems, getInscanCopyArrayTemps().end());
806 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *, bool>(
807 (Modifier == OMPC_REDUCTION_inscan ? 8 : 5) * VL.size(), VL.size()));
808 auto *Clause =
new (Mem) OMPReductionClause(
809 StartLoc, LParenLoc, ModifierLoc, EndLoc, ColonLoc, Modifier,
810 OrignalSharingModifier, VL.size(), QualifierLoc, NameInfo);
811 Clause->setVarRefs(VL);
812 Clause->setPrivates(Privates);
813 Clause->setLHSExprs(LHSExprs);
814 Clause->setRHSExprs(RHSExprs);
815 Clause->setReductionOps(ReductionOps);
816 Clause->setPreInitStmt(PreInit);
817 Clause->setPostUpdateExpr(PostUpdate);
818 Clause->setPrivateVariableReductionFlags(IsPrivateVarReduction);
819 if (Modifier == OMPC_REDUCTION_inscan) {
820 Clause->setInscanCopyOps(CopyOps);
821 Clause->setInscanCopyArrayTemps(CopyArrayTemps);
822 Clause->setInscanCopyArrayElems(CopyArrayElems);
824 assert(CopyOps.empty() &&
825 "copy operations are expected in inscan reductions only.");
826 assert(CopyArrayTemps.empty() &&
827 "copy array temps are expected in inscan reductions only.");
828 assert(CopyArrayElems.empty() &&
829 "copy array temps are expected in inscan reductions only.");
837 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *, bool>(
838 (Modifier == OMPC_REDUCTION_inscan ? 8 : 5) * N, N));
839 auto *Clause =
new (Mem) OMPReductionClause(N);
840 Clause->setModifier(Modifier);
846 "Number of private copies is not the same as the preallocated buffer");
853 "Number of LHS expressions is not the same as the preallocated buffer");
854 llvm::copy(LHSExprs, getPrivates().end());
860 "Number of RHS expressions is not the same as the preallocated buffer");
861 llvm::copy(RHSExprs, getLHSExprs().end());
864void OMPTaskReductionClause::setReductionOps(
ArrayRef<Expr *> ReductionOps) {
865 assert(ReductionOps.size() ==
varlist_size() &&
"Number of task reduction "
866 "expressions is not the same "
867 "as the preallocated buffer");
868 llvm::copy(ReductionOps, getRHSExprs().end());
878 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
879 OMPTaskReductionClause *Clause =
new (Mem) OMPTaskReductionClause(
880 StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
881 Clause->setVarRefs(VL);
882 Clause->setPrivates(Privates);
883 Clause->setLHSExprs(LHSExprs);
884 Clause->setRHSExprs(RHSExprs);
885 Clause->setReductionOps(ReductionOps);
886 Clause->setPreInitStmt(PreInit);
887 Clause->setPostUpdateExpr(PostUpdate);
893 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
894 return new (Mem) OMPTaskReductionClause(N);
899 "Number of private copies is not the same as the preallocated buffer");
906 "Number of LHS expressions is not the same as the preallocated buffer");
907 llvm::copy(LHSExprs, getPrivates().end());
913 "Number of RHS expressions is not the same as the preallocated buffer");
914 llvm::copy(RHSExprs, getLHSExprs().end());
918 assert(ReductionOps.size() ==
varlist_size() &&
"Number of in reduction "
919 "expressions is not the same "
920 "as the preallocated buffer");
921 llvm::copy(ReductionOps, getRHSExprs().end());
924void OMPInReductionClause::setTaskgroupDescriptors(
927 "Number of in reduction descriptors is not the same as the "
928 "preallocated buffer");
929 llvm::copy(TaskgroupDescriptors, getReductionOps().end());
939 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(6 * VL.size()));
940 OMPInReductionClause *Clause =
new (Mem) OMPInReductionClause(
941 StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
942 Clause->setVarRefs(VL);
943 Clause->setPrivates(Privates);
944 Clause->setLHSExprs(LHSExprs);
945 Clause->setRHSExprs(RHSExprs);
946 Clause->setReductionOps(ReductionOps);
947 Clause->setTaskgroupDescriptors(TaskgroupDescriptors);
948 Clause->setPreInitStmt(PreInit);
949 Clause->setPostUpdateExpr(PostUpdate);
955 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(6 * N));
956 return new (Mem) OMPInReductionClause(N);
965 Clause->setLocStart(StartLoc);
966 Clause->setLParenLoc(LParenLoc);
967 Clause->setLocEnd(EndLoc);
968 Clause->setSizesRefs(Sizes);
974 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(NumSizes));
975 return new (Mem) OMPSizesClause(NumSizes);
983 OMPPermutationClause *Clause =
CreateEmpty(
C, Args.size());
984 Clause->setLocStart(StartLoc);
985 Clause->setLParenLoc(LParenLoc);
986 Clause->setLocEnd(EndLoc);
987 Clause->setArgRefs(Args);
993 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(NumLoops));
994 return new (Mem) OMPPermutationClause(NumLoops);
1001 Clause->setLocStart(StartLoc);
1002 Clause->setLocEnd(EndLoc);
1007 return new (
C) OMPFullClause();
1016 Clause->setLocStart(StartLoc);
1017 Clause->setLParenLoc(LParenLoc);
1018 Clause->setLocEnd(EndLoc);
1019 Clause->setFactor(Factor);
1024 return new (
C) OMPPartialClause();
1033 Clause->setLocStart(StartLoc);
1034 Clause->setLParenLoc(LParenLoc);
1035 Clause->setFirstLoc(FirstLoc);
1036 Clause->setCountLoc(CountLoc);
1037 Clause->setLocEnd(EndLoc);
1038 Clause->setFirst(
First);
1039 Clause->setCount(Count);
1044 return new (
C) OMPLoopRangeClause();
1055 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1056 auto *Clause =
new (Mem) OMPAllocateClause(
1057 StartLoc, LParenLoc, Allocator, Alignment, ColonLoc, Modifier1,
1058 Modifier1Loc, Modifier2, Modifier2Loc, EndLoc, VL.size());
1060 Clause->setVarRefs(VL);
1066 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N));
1067 return new (Mem) OMPAllocateClause(N);
1075 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
1076 OMPFlushClause *Clause =
1077 new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
1078 Clause->setVarRefs(VL);
1083 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N));
1084 return new (Mem) OMPFlushClause(N);
1092 auto *Clause =
new (
C) OMPDepobjClause(StartLoc, LParenLoc, RParenLoc);
1093 Clause->setDepobj(Depobj);
1098 return new (
C) OMPDepobjClause();
1106 void *Mem =
C.Allocate(
1107 totalSizeToAlloc<Expr *>(VL.size() + 1 + NumLoops),
1108 alignof(OMPDependClause));
1109 OMPDependClause *Clause =
new (Mem)
1110 OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
1111 Clause->setDependencyKind(Data.DepKind);
1112 Clause->setDependencyLoc(Data.DepLoc);
1113 Clause->setColonLoc(Data.ColonLoc);
1114 Clause->setOmpAllMemoryLoc(Data.OmpAllMemoryLoc);
1115 Clause->setModifier(DepModifier);
1116 Clause->setVarRefs(VL);
1117 for (
unsigned I = 0 ; I < NumLoops; ++I)
1118 Clause->setLoopData(I,
nullptr);
1123 unsigned NumLoops) {
1125 C.Allocate(totalSizeToAlloc<Expr *>(N + 1 + NumLoops),
1126 alignof(OMPDependClause));
1127 return new (Mem) OMPDependClause(N, NumLoops);
1133 NumLoop < NumLoops &&
1134 "Expected sink or source depend + loop index must be less number of "
1136 auto *It = std::next(
getVarRefs().end(), NumLoop + 1);
1143 NumLoop < NumLoops &&
1144 "Expected sink or source depend + loop index must be less number of "
1146 auto *It = std::next(
getVarRefs().end(), NumLoop + 1);
1153 NumLoop < NumLoops &&
1154 "Expected sink or source depend + loop index must be less number of "
1156 const auto *It = std::next(
getVarRefs().end(), NumLoop + 1);
1160void OMPDependClause::setModifier(
Expr *DepModifier) {
1167 unsigned TotalNum = 0u;
1168 for (
auto &
C : ComponentLists)
1169 TotalNum +=
C.size();
1176 for (
const ValueDecl *D : Declarations) {
1178 UniqueDecls.insert(VD);
1180 return UniqueDecls.size();
1186 "Cannot get element-type from array-shaping expr.");
1200 if (
const auto *ATy = BaseType->getAsArrayTypeUnsafe())
1201 ElemTy = ATy->getElementType();
1209std::pair<const Expr *, std::optional<size_t>>
1215 if (Components.size() < 2)
1216 return {
nullptr, std::nullopt};
1221 if (Components.back().isNonContiguous() && CurDirKind == OMPD_target_update)
1222 return {
nullptr, std::nullopt};
1228 for (
auto [I, Component] : llvm::enumerate(Components)) {
1233 const Expr *CurExpr = Component.getAssociatedExpression();
1248 return {CurExpr, Components.size() - I};
1251 return {
nullptr, std::nullopt};
1278 void *Mem =
C.Allocate(
1284 OMPMapClause *Clause =
new (Mem)
1285 OMPMapClause(MapModifiers, MapModifiersLoc, UDMQualifierLoc, MapperId,
1288 Clause->setVarRefs(Vars);
1289 Clause->setUDMapperRefs(UDMapperRefs);
1290 Clause->setIteratorModifier(IteratorModifier);
1291 Clause->setClauseInfo(Declarations, ComponentLists);
1292 Clause->setMapType(
Type);
1300 void *Mem =
C.Allocate(
1306 OMPMapClause *Clause =
new (Mem) OMPMapClause(Sizes);
1307 Clause->setIteratorModifier(
nullptr);
1334 void *Mem =
C.Allocate(
1341 auto *Clause =
new (Mem) OMPToClause(MotionModifiers, MotionModifiersLoc,
1342 UDMQualifierLoc, MapperId, Locs, Sizes);
1344 Clause->setVarRefs(Vars);
1345 Clause->setUDMapperRefs(UDMapperRefs);
1346 Clause->setClauseInfo(Declarations, ComponentLists);
1352 void *Mem =
C.Allocate(
1358 return new (Mem) OMPToClause(Sizes);
1384 void *Mem =
C.Allocate(
1392 new (Mem) OMPFromClause(MotionModifiers, MotionModifiersLoc,
1393 UDMQualifierLoc, MapperId, Locs, Sizes);
1395 Clause->setVarRefs(Vars);
1396 Clause->setUDMapperRefs(UDMapperRefs);
1397 Clause->setClauseInfo(Declarations, ComponentLists);
1404 void *Mem =
C.Allocate(
1410 return new (Mem) OMPFromClause(Sizes);
1415 "Number of private copies is not the same as the preallocated buffer");
1421 "Number of inits is not the same as the preallocated buffer");
1422 llvm::copy(VL, getPrivateCopies().end());
1446 void *Mem =
C.Allocate(
1453 OMPUseDevicePtrClause *Clause =
new (Mem) OMPUseDevicePtrClause(Locs, Sizes);
1455 Clause->setVarRefs(Vars);
1456 Clause->setPrivateCopies(PrivateVars);
1457 Clause->setInits(Inits);
1458 Clause->setClauseInfo(Declarations, ComponentLists);
1465 void *Mem =
C.Allocate(
1471 return new (Mem) OMPUseDevicePtrClause(Sizes);
1495 void *Mem =
C.Allocate(
1502 auto *Clause =
new (Mem) OMPUseDeviceAddrClause(Locs, Sizes);
1504 Clause->setVarRefs(Vars);
1505 Clause->setClauseInfo(Declarations, ComponentLists);
1512 void *Mem =
C.Allocate(
1518 return new (Mem) OMPUseDeviceAddrClause(Sizes);
1542 void *Mem =
C.Allocate(
1549 OMPIsDevicePtrClause *Clause =
new (Mem) OMPIsDevicePtrClause(Locs, Sizes);
1551 Clause->setVarRefs(Vars);
1552 Clause->setClauseInfo(Declarations, ComponentLists);
1559 void *Mem =
C.Allocate(
1565 return new (Mem) OMPIsDevicePtrClause(Sizes);
1589 void *Mem =
C.Allocate(
1596 auto *Clause =
new (Mem) OMPHasDeviceAddrClause(Locs, Sizes);
1598 Clause->setVarRefs(Vars);
1599 Clause->setClauseInfo(Declarations, ComponentLists);
1606 void *Mem =
C.Allocate(
1612 return new (Mem) OMPHasDeviceAddrClause(Sizes);
1621 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
1623 new (Mem) OMPNontemporalClause(StartLoc, LParenLoc, EndLoc, VL.size());
1624 Clause->setVarRefs(VL);
1630 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
1631 return new (Mem) OMPNontemporalClause(N);
1635 assert(VL.size() ==
varlist_size() &&
"Number of private references is not "
1636 "the same as the preallocated buffer");
1645 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1647 new (Mem) OMPInclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size());
1648 Clause->setVarRefs(VL);
1654 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N));
1655 return new (Mem) OMPInclusiveClause(N);
1663 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1665 new (Mem) OMPExclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size());
1666 Clause->setVarRefs(VL);
1672 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N));
1673 return new (Mem) OMPExclusiveClause(N);
1676void OMPUsesAllocatorsClause::setAllocatorsData(
1678 assert(
Data.size() == NumOfAllocators &&
1679 "Size of allocators data is not the same as the preallocated buffer.");
1680 for (
unsigned I = 0, E =
Data.size(); I < E; ++I) {
1682 getTrailingObjects<Expr *>()[I *
static_cast<int>(ExprOffsets::Total) +
1683 static_cast<int>(ExprOffsets::Allocator)] =
1685 getTrailingObjects<Expr *>()[I *
static_cast<int>(ExprOffsets::Total) +
1687 ExprOffsets::AllocatorTraits)] =
1690 SourceLocation>()[I *
static_cast<int>(ParenLocsOffsets::Total) +
1691 static_cast<int>(ParenLocsOffsets::LParen)] =
1694 SourceLocation>()[I *
static_cast<int>(ParenLocsOffsets::Total) +
1695 static_cast<int>(ParenLocsOffsets::RParen)] =
1704 getTrailingObjects<Expr *>()[I *
static_cast<int>(ExprOffsets::Total) +
1705 static_cast<int>(ExprOffsets::Allocator)];
1707 getTrailingObjects<Expr *>()[I *
static_cast<int>(ExprOffsets::Total) +
1709 ExprOffsets::AllocatorTraits)];
1711 SourceLocation>()[I *
static_cast<int>(ParenLocsOffsets::Total) +
1712 static_cast<int>(ParenLocsOffsets::LParen)];
1714 SourceLocation>()[I *
static_cast<int>(ParenLocsOffsets::Total) +
1715 static_cast<int>(ParenLocsOffsets::RParen)];
1723 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *, SourceLocation>(
1724 static_cast<int>(ExprOffsets::Total) *
Data.size(),
1725 static_cast<int>(ParenLocsOffsets::Total) *
Data.size()));
1726 auto *Clause =
new (Mem)
1727 OMPUsesAllocatorsClause(StartLoc, LParenLoc, EndLoc,
Data.size());
1728 Clause->setAllocatorsData(
Data);
1734 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *, SourceLocation>(
1735 static_cast<int>(ExprOffsets::Total) * N,
1736 static_cast<int>(ParenLocsOffsets::Total) * N));
1737 return new (Mem) OMPUsesAllocatorsClause(N);
1745 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(Locators.size() + 1));
1746 auto *Clause =
new (Mem)
1747 OMPAffinityClause(StartLoc, LParenLoc, ColonLoc, EndLoc, Locators.size());
1748 Clause->setModifier(Modifier);
1749 Clause->setVarRefs(Locators);
1755 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N + 1));
1756 return new (Mem) OMPAffinityClause(N);
1767 C.Allocate(totalSizeToAlloc<Expr *>(InteropInfo.
PreferTypes.size() + 1));
1768 auto *Clause =
new (Mem) OMPInitClause(
1770 VarLoc, EndLoc, InteropInfo.
PreferTypes.size() + 1);
1771 Clause->setInteropVar(InteropVar);
1772 llvm::copy(InteropInfo.
PreferTypes, Clause->getTrailingObjects() + 1);
1777 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N));
1778 return new (Mem) OMPInitClause(N);
1785 return new (
C) OMPBindClause(K, KLoc, StartLoc, LParenLoc, EndLoc);
1789 return new (
C) OMPBindClause();
1798 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + NumLoops),
1799 alignof(OMPDoacrossClause));
1800 OMPDoacrossClause *Clause =
new (Mem)
1801 OMPDoacrossClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
1802 Clause->setDependenceType(DepType);
1803 Clause->setDependenceLoc(DepLoc);
1804 Clause->setColonLoc(ColonLoc);
1805 Clause->setVarRefs(VL);
1806 for (
unsigned I = 0; I < NumLoops; ++I)
1807 Clause->setLoopData(I,
nullptr);
1813 unsigned NumLoops) {
1814 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N + NumLoops),
1815 alignof(OMPDoacrossClause));
1816 return new (Mem) OMPDoacrossClause(N, NumLoops);
1820 assert(NumLoop < NumLoops &&
"Loop index must be less number of loops.");
1821 auto *It = std::next(
getVarRefs().end(), NumLoop);
1826 assert(NumLoop < NumLoops &&
"Loop index must be less number of loops.");
1827 auto *It = std::next(
getVarRefs().end(), NumLoop);
1832 assert(NumLoop < NumLoops &&
"Loop index must be less number of loops.");
1833 const auto *It = std::next(
getVarRefs().end(), NumLoop);
1842 void *Mem =
C.Allocate(totalSizeToAlloc<OpenMPDirectiveKind>(DKVec.size()),
1843 alignof(OMPAbsentClause));
1844 auto *AC =
new (Mem) OMPAbsentClause(Loc, LLoc, RLoc, DKVec.size());
1845 AC->setDirectiveKinds(DKVec);
1850 void *Mem =
C.Allocate(totalSizeToAlloc<OpenMPDirectiveKind>(K),
1851 alignof(OMPAbsentClause));
1852 return new (Mem) OMPAbsentClause(K);
1858 void *Mem =
C.Allocate(totalSizeToAlloc<OpenMPDirectiveKind>(DKVec.size()),
1859 alignof(OMPContainsClause));
1860 auto *CC =
new (Mem) OMPContainsClause(Loc, LLoc, RLoc, DKVec.size());
1861 CC->setDirectiveKinds(DKVec);
1867 void *Mem =
C.Allocate(totalSizeToAlloc<OpenMPDirectiveKind>(K),
1868 alignof(OMPContainsClause));
1869 return new (Mem) OMPContainsClause(K);
1876 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1877 OMPNumTeamsClause *Clause =
1878 new (Mem) OMPNumTeamsClause(
C, StartLoc, LParenLoc, EndLoc, VL.size());
1879 Clause->setVarRefs(VL);
1880 Clause->setPreInitStmt(PreInit, CaptureRegion);
1886 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N));
1887 return new (Mem) OMPNumTeamsClause(N);
1894 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1895 OMPThreadLimitClause *Clause =
1896 new (Mem) OMPThreadLimitClause(
C, StartLoc, LParenLoc, EndLoc, VL.size());
1897 Clause->setVarRefs(VL);
1898 Clause->setPreInitStmt(PreInit, CaptureRegion);
1904 void *Mem =
C.Allocate(totalSizeToAlloc<Expr *>(N));
1905 return new (Mem) OMPThreadLimitClause(N);
1912void OMPClausePrinter::VisitOMPIfClause(
OMPIfClause *Node) {
1915 OS << getOpenMPDirectiveName(Node->
getNameModifier(), Version) <<
": ";
1920void OMPClausePrinter::VisitOMPFinalClause(
OMPFinalClause *Node) {
1927 OS <<
"num_threads(";
1937void OMPClausePrinter::VisitOMPAlignClause(
OMPAlignClause *Node) {
1955void OMPClausePrinter::VisitOMPSizesClause(
OMPSizesClause *Node) {
1961 Size->printPretty(OS,
nullptr, Policy, 0);
1968 OS <<
"permutation(";
1969 llvm::interleaveComma(Node->
getArgsRefs(), OS, [&](
const Expr *E) {
1970 E->printPretty(OS, nullptr, Policy, 0);
1975void OMPClausePrinter::VisitOMPFullClause(
OMPFullClause *Node) { OS <<
"full"; }
1982 Factor->printPretty(OS,
nullptr, Policy, 0);
1993 if (
First && Count) {
1995 First->printPretty(OS,
nullptr, Policy, 0);
2024 if (Version >= 60 && Node->
getDefaultVC() != OMPC_DEFAULT_VC_all) {
2040 OS <<
"unified_address";
2043void OMPClausePrinter::VisitOMPUnifiedSharedMemoryClause(
2045 OS <<
"unified_shared_memory";
2049 OS <<
"reverse_offload";
2052void OMPClausePrinter::VisitOMPDynamicAllocatorsClause(
2054 OS <<
"dynamic_allocators";
2057void OMPClausePrinter::VisitOMPAtomicDefaultMemOrderClause(
2059 OS <<
"atomic_default_mem_order("
2069void OMPClausePrinter::VisitOMPAtClause(
OMPAtClause *Node) {
2083 E->printPretty(OS,
nullptr, Policy);
2102 E->printPretty(OS,
nullptr, Policy);
2111 Num->printPretty(OS,
nullptr, Policy, 0);
2132void OMPClausePrinter::VisitOMPReadClause(
OMPReadClause *) { OS <<
"read"; }
2134void OMPClausePrinter::VisitOMPWriteClause(
OMPWriteClause *) { OS <<
"write"; }
2154void OMPClausePrinter::VisitOMPFailClause(
OMPFailClause *Node) {
2170 OS << getOpenMPDirectiveName(D, Version);
2176void OMPClausePrinter::VisitOMPHoldsClause(
OMPHoldsClause *Node) {
2188 OS << getOpenMPDirectiveName(D, Version);
2198void OMPClausePrinter::VisitOMPNoOpenMPRoutinesClause(
2200 OS <<
"no_openmp_routines";
2203void OMPClausePrinter::VisitOMPNoOpenMPConstructsClause(
2205 OS <<
"no_openmp_constructs";
2209 OS <<
"no_parallelism";
2232void OMPClausePrinter::VisitOMPWeakClause(
OMPWeakClause *) { OS <<
"weak"; }
2238void OMPClausePrinter::VisitOMPSIMDClause(
OMPSIMDClause *) { OS <<
"simd"; }
2254 VisitOMPClauseList(Node,
'(');
2261 OS <<
"thread_limit";
2262 VisitOMPClauseList(Node,
'(');
2295void OMPClausePrinter::VisitOMPHintClause(
OMPHintClause *Node) {
2301void OMPClausePrinter::VisitOMPInitClause(
OMPInitClause *Node) {
2304 for (
const Expr *E : Node->
prefs()) {
2306 OS <<
"prefer_type(";
2309 E->printPretty(OS,
nullptr, Policy);
2326void OMPClausePrinter::VisitOMPUseClause(
OMPUseClause *Node) {
2336 E->printPretty(OS,
nullptr, Policy);
2345 E->printPretty(OS,
nullptr, Policy, 0);
2354 E->printPretty(OS,
nullptr, Policy, 0);
2360void OMPClausePrinter::VisitOMPClauseList(
T *Node,
char StartSym) {
2361 for (
typename T::varlist_iterator I = Node->varlist_begin(),
2362 E = Node->varlist_end();
2364 assert(*I &&
"Expected non-null Stmt");
2365 OS << (I == Node->varlist_begin() ? StartSym :
',');
2366 if (
auto *DRE = dyn_cast<DeclRefExpr>(*I)) {
2368 DRE->printPretty(OS,
nullptr, Policy, 0);
2370 DRE->getDecl()->printQualifiedName(OS);
2372 (*I)->printPretty(OS,
nullptr, Policy, 0);
2380 Expr *FirstModifier =
nullptr;
2381 Expr *SecondModifier =
nullptr;
2386 if (FirstAllocMod == OMPC_ALLOCATE_allocator ||
2397 if (FirstModifier) {
2399 if (!FirstUnknown) {
2403 FirstModifier->
printPretty(OS,
nullptr, Policy, 0);
2406 if (SecondModifier) {
2408 if (!SecondUnknown) {
2413 SecondModifier->
printPretty(OS,
nullptr, Policy, 0);
2418 VisitOMPClauseList(Node,
' ');
2421 VisitOMPClauseList(Node,
'(');
2429 VisitOMPClauseList(Node,
'(');
2436 OS <<
"firstprivate";
2437 VisitOMPClauseList(Node,
'(');
2444 OS <<
"lastprivate";
2459 VisitOMPClauseList(Node,
'(');
2474 if (!Qualifier && OOK !=
OO_None) {
2483 VisitOMPClauseList(Node,
' ');
2488void OMPClausePrinter::VisitOMPTaskReductionClause(
2491 OS <<
"task_reduction(";
2496 if (!Qualifier && OOK !=
OO_None) {
2505 VisitOMPClauseList(Node,
' ');
2512 OS <<
"in_reduction(";
2517 if (!Qualifier && OOK !=
OO_None) {
2526 VisitOMPClauseList(Node,
' ');
2534 VisitOMPClauseList(Node,
'(');
2541 if (Node->
getStep() !=
nullptr) {
2556 VisitOMPClauseList(Node,
'(');
2568 VisitOMPClauseList(Node,
'(');
2575 OS <<
"copyprivate";
2576 VisitOMPClauseList(Node,
'(');
2581void OMPClausePrinter::VisitOMPFlushClause(
OMPFlushClause *Node) {
2583 VisitOMPClauseList(Node,
'(');
2602 bool IsOmpAllMemory =
false;
2603 if (PrintKind == OMPC_DEPEND_outallmemory) {
2604 PrintKind = OMPC_DEPEND_out;
2605 IsOmpAllMemory =
true;
2606 }
else if (PrintKind == OMPC_DEPEND_inoutallmemory) {
2607 PrintKind = OMPC_DEPEND_inout;
2608 IsOmpAllMemory =
true;
2613 VisitOMPClauseList(Node,
' ');
2614 if (IsOmpAllMemory) {
2616 OS <<
"omp_all_memory";
2621template <
typename T>
2626 Node->getMapperQualifierLoc().getNestedNameSpecifier();
2627 MapperNNS.
print(OS, Policy);
2628 OS << Node->getMapperIdInfo() <<
')';
2631template <
typename T>
2634 if (
Expr *IteratorModifier = Node->getIteratorModifier())
2635 IteratorModifier->printPretty(OS,
nullptr, Policy);
2638void OMPClausePrinter::VisitOMPMapClause(
OMPMapClause *Node) {
2658 VisitOMPClauseList(Node,
' ');
2663template <
typename T>
void OMPClausePrinter::VisitOMPMotionClause(
T *Node) {
2664 if (Node->varlist_empty())
2666 OS << getOpenMPClauseName(Node->getClauseKind());
2667 unsigned ModifierCount = 0;
2672 if (ModifierCount) {
2677 Node->getMotionModifier(I));
2678 if (Node->getMotionModifier(I) == OMPC_MOTION_MODIFIER_mapper)
2680 if (I < ModifierCount - 1)
2685 VisitOMPClauseList(Node,
' ');
2687 VisitOMPClauseList(Node,
'(');
2692void OMPClausePrinter::VisitOMPToClause(
OMPToClause *Node) {
2693 VisitOMPMotionClause(Node);
2696void OMPClausePrinter::VisitOMPFromClause(
OMPFromClause *Node) {
2697 VisitOMPMotionClause(Node);
2705 E->printPretty(OS,
nullptr, Policy);
2711 OS <<
"defaultmap(";
2724 OS <<
"use_device_ptr";
2725 VisitOMPClauseList(Node,
'(');
2730void OMPClausePrinter::VisitOMPUseDeviceAddrClause(
2733 OS <<
"use_device_addr";
2734 VisitOMPClauseList(Node,
'(');
2741 OS <<
"is_device_ptr";
2742 VisitOMPClauseList(Node,
'(');
2749 OS <<
"has_device_addr";
2750 VisitOMPClauseList(Node,
'(');
2757 OS <<
"nontemporal";
2758 VisitOMPClauseList(Node,
'(');
2763void OMPClausePrinter::VisitOMPOrderClause(
OMPOrderClause *Node) {
2775 VisitOMPClauseList(Node,
'(');
2783 VisitOMPClauseList(Node,
'(');
2788void OMPClausePrinter::VisitOMPUsesAllocatorsClause(
2792 OS <<
"uses_allocators(";
2796 if (
Data.AllocatorTraits) {
2798 Data.AllocatorTraits->printPretty(OS,
nullptr, Policy);
2811 char StartSym =
'(';
2814 Modifier->printPretty(OS,
nullptr, Policy);
2818 VisitOMPClauseList(Node, StartSym);
2828void OMPClausePrinter::VisitOMPBindClause(
OMPBindClause *Node) {
2834void OMPClausePrinter::VisitOMPXDynCGroupMemClause(
2836 OS <<
"ompx_dyn_cgroup_mem(";
2846 case OMPC_DOACROSS_source:
2849 case OMPC_DOACROSS_sink:
2852 case OMPC_DOACROSS_source_omp_cur_iteration:
2853 OS <<
"source: omp_cur_iteration";
2855 case OMPC_DOACROSS_sink_omp_cur_iteration:
2856 OS <<
"sink: omp_cur_iteration - 1";
2859 llvm_unreachable(
"unknown docaross modifier");
2861 VisitOMPClauseList(Node,
' ');
2866 OS <<
"ompx_attribute(";
2868 for (
auto &Attr : Node->
getAttrs()) {
2871 Attr->printPretty(OS, Policy);
2877void OMPClausePrinter::VisitOMPXBareClause(
OMPXBareClause *Node) {
2882 VariantMatchInfo &VMI)
const {
2887 if (
Selector.Kind == TraitSelector::user_condition) {
2888 assert(
Selector.ScoreOrCondition &&
2889 "Ill-formed user condition, expected condition expression!");
2890 assert(
Selector.Properties.size() == 1 &&
2891 Selector.Properties.front().Kind ==
2892 TraitProperty::user_condition_unknown &&
2893 "Ill-formed user condition, expected unknown trait property!");
2895 if (std::optional<APSInt> CondVal =
2896 Selector.ScoreOrCondition->getIntegerConstantExpr(ASTCtx))
2897 VMI.addTrait(CondVal->isZero() ? TraitProperty::user_condition_false
2898 : TraitProperty::user_condition_true,
2901 VMI.addTrait(TraitProperty::user_condition_false,
"<condition>");
2905 std::optional<llvm::APSInt> Score;
2906 llvm::APInt *ScorePtr =
nullptr;
2908 if ((Score =
Selector.ScoreOrCondition->getIntegerConstantExpr(ASTCtx)))
2911 VMI.addTrait(TraitProperty::user_condition_false,
2912 "<non-constant-score>");
2918 if (
Set.Kind != TraitSet::construct)
2922 assert(
Selector.Properties.size() == 1 &&
2923 Selector.Properties.front().Kind ==
2924 getOpenMPContextTraitPropertyForSelector(
2926 "Ill-formed construct selector!");
2933 bool FirstSet =
true;
2938 OS << getOpenMPContextTraitSetName(
Set.Kind) <<
"={";
2940 bool FirstSelector =
true;
2944 FirstSelector =
false;
2945 OS << getOpenMPContextTraitSelectorName(
Selector.Kind);
2947 bool AllowsTraitScore =
false;
2948 bool RequiresProperty =
false;
2949 isValidTraitSelectorForTraitSet(
2950 Selector.Kind,
Set.Kind, AllowsTraitScore, RequiresProperty);
2952 if (!RequiresProperty)
2956 if (
Selector.Kind == TraitSelector::user_condition) {
2958 Selector.ScoreOrCondition->printPretty(OS,
nullptr, Policy);
2965 Selector.ScoreOrCondition->printPretty(OS,
nullptr, Policy);
2969 bool FirstProperty =
true;
2973 FirstProperty =
false;
2974 OS << getOpenMPContextTraitPropertyName(
Property.Kind,
2985 std::string MangledName;
2986 llvm::raw_string_ostream OS(MangledName);
2991 bool AllowsTraitScore =
false;
2992 bool RequiresProperty =
false;
2993 isValidTraitSelectorForTraitSet(
2994 Selector.Kind,
Set.Kind, AllowsTraitScore, RequiresProperty);
2997 if (!RequiresProperty ||
2998 Selector.Kind == TraitSelector::user_condition)
3003 << getOpenMPContextTraitPropertyName(
Property.Kind,
3010OMPTraitInfo::OMPTraitInfo(StringRef MangledName) {
3013 if (!MangledName.consume_front(
"$S"))
3015 if (MangledName.consumeInteger(10,
U))
3019 Set.Kind = TraitSet(
U);
3021 if (!MangledName.consume_front(
"$s"))
3023 if (MangledName.consumeInteger(10,
U))
3029 if (!MangledName.consume_front(
"$P"))
3033 std::pair<StringRef, StringRef> PropRestPair = MangledName.split(
'$');
3034 Property.RawString = PropRestPair.first;
3035 Property.Kind = getOpenMPContextTraitPropertyKind(
3037 MangledName = MangledName.drop_front(PropRestPair.first.size());
3047 TI.
print(OS, Policy);
3052 return TI ? OS << *TI : OS;
3059 : OMPContext(ASTCtx.getLangOpts().OpenMPIsTargetDevice,
3060 ASTCtx.getTargetInfo().getTriple(),
3061 ASTCtx.getLangOpts().OMPTargetTriples.empty()
3063 : ASTCtx.getLangOpts().OMPTargetTriples[0],
3065 FeatureValidityCheck([&](StringRef FeatureName) {
3066 return ASTCtx.
getTargetInfo().isValidFeatureName(FeatureName);
3068 DiagUnknownTrait(std::move(DiagUnknownTrait)) {
3071 for (llvm::omp::TraitProperty
Property : ConstructTraits)
3076 auto It = FeatureMap.find(RawString);
3077 if (It != FeatureMap.end())
3079 if (!FeatureValidityCheck(RawString))
3080 DiagUnknownTrait(RawString);
Defines the clang::ASTContext interface.
This file defines OpenMP nodes for declarative directives.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
static Stmt ** getAddrOfExprAsWritten(Stmt *S)
Gets the address of the original, non-captured, expression used in the clause as the preinitializer.
static void PrintIterator(raw_ostream &OS, T *Node, const PrintingPolicy &Policy)
static void PrintMapper(raw_ostream &OS, T *Node, const PrintingPolicy &Policy)
This file defines OpenMP AST classes for clauses.
Defines some OpenMP-specific enums and functions.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const TargetInfo & getTargetInfo() const
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
This represents one expression.
Represents a function declaration or definition.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
A C++ nested-name-specifier augmented with source location information.
NestedNameSpecifier getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false, bool PrintFinalScopeResOp=true) const
Print this nested name specifier to the given output stream.
This represents the 'absent' clause in the 'pragma omp assume' directive.
static OMPAbsentClause * CreateEmpty(const ASTContext &C, unsigned NumKinds)
static OMPAbsentClause * Create(const ASTContext &C, ArrayRef< OpenMPDirectiveKind > DKVec, SourceLocation Loc, SourceLocation LLoc, SourceLocation RLoc)
This represents 'acq_rel' clause in the 'pragma omp atomic|flush' directives.
This represents 'acquire' clause in the 'pragma omp atomic|flush' directives.
This represents clause 'affinity' in the 'pragma omp task'-based directives.
static OMPAffinityClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, Expr *Modifier, ArrayRef< Expr * > Locators)
Creates clause with a modifier a list of locator items.
Expr * getModifier()
Gets affinity modifier.
static OMPAffinityClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N locator items.
This represents the 'align' clause in the 'pragma omp allocate' directive.
Expr * getAlignment() const
Returns alignment.
static OMPAlignClause * Create(const ASTContext &C, Expr *A, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'align' clause with the given alignment.
This represents clause 'aligned' in the 'pragma omp ...' directives.
Expr * getAlignment()
Returns alignment.
static OMPAlignedClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, Expr *A)
Creates clause with a list of variables VL and alignment A.
static OMPAlignedClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
This represents clause 'allocate' in the 'pragma omp ...' directives.
static OMPAllocateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, Expr *Allocator, Expr *Alignment, SourceLocation ColonLoc, OpenMPAllocateClauseModifier Modifier1, SourceLocation Modifier1Loc, OpenMPAllocateClauseModifier Modifier2, SourceLocation Modifier2Loc, SourceLocation EndLoc, ArrayRef< Expr * > VL)
Creates clause with a list of variables VL.
OpenMPAllocateClauseModifier getSecondAllocateModifier() const
Get the second modifier of the clause.
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.
static OMPAllocateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'allocator' clause in the 'pragma omp ...' directive.
Expr * getAllocator() const
Returns allocator.
This represents 'at' clause in the 'pragma omp error' directive.
OpenMPAtClauseKind getAtKind() const
Returns kind of the clause.
This represents 'atomic_default_mem_order' clause in the 'pragma omp requires' directive.
OpenMPAtomicDefaultMemOrderClauseKind getAtomicDefaultMemOrderKind() const
Returns kind of the clause.
This represents 'bind' clause in the 'pragma omp ...' directives.
OpenMPBindClauseKind getBindKind() const
Returns kind of the clause.
static OMPBindClause * Create(const ASTContext &C, OpenMPBindClauseKind K, SourceLocation KLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'bind' clause with kind K ('teams', 'parallel', or 'thread').
static OMPBindClause * CreateEmpty(const ASTContext &C)
Build an empty 'bind' clause.
This represents 'capture' clause in the 'pragma omp atomic' directive.
Class that represents a component of a mappable expression.
ArrayRef< MappableExprComponentList > MappableExprComponentListsRef
static unsigned getUniqueDeclarationsTotalNumber(ArrayRef< const ValueDecl * > Declarations)
static unsigned getComponentsTotalNumber(MappableExprComponentListsRef ComponentLists)
ArrayRef< MappableComponent > MappableExprComponentListRef
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.
static OMPClauseWithPostUpdate * get(OMPClause *C)
OMPClauseWithPostUpdate(const OMPClause *This)
const Stmt * getPreInitStmt() const
Get pre-initialization statement for the clause.
OMPClauseWithPreInit(const OMPClause *This)
static OMPClauseWithPreInit * get(OMPClause *C)
This is a basic class for representing single OpenMP clause.
child_range used_children()
Get the iterator range for the expressions used in the clauses.
llvm::iterator_range< child_iterator > child_range
OpenMPClauseKind getClauseKind() const
Returns kind of OpenMP clause (private, shared, reduction, etc.).
This represents 'collapse' clause in the 'pragma omp ...' directive.
Expr * getNumForLoops() const
Return the number of associated for-loops.
This represents 'compare' clause in the 'pragma omp atomic' directive.
This represents the 'contains' clause in the 'pragma omp assume' directive.
static OMPContainsClause * CreateEmpty(const ASTContext &C, unsigned NumKinds)
static OMPContainsClause * Create(const ASTContext &C, ArrayRef< OpenMPDirectiveKind > DKVec, SourceLocation Loc, SourceLocation LLoc, SourceLocation RLoc)
This represents clause 'copyin' in the 'pragma omp ...' directives.
static OMPCopyinClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > SrcExprs, ArrayRef< Expr * > DstExprs, ArrayRef< Expr * > AssignmentOps)
Creates clause with a list of variables VL.
static OMPCopyinClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents clause 'copyprivate' in the 'pragma omp ...' directives.
static OMPCopyprivateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > SrcExprs, ArrayRef< Expr * > DstExprs, ArrayRef< Expr * > AssignmentOps)
Creates clause with a list of variables VL.
static OMPCopyprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents 'default' clause in the 'pragma omp ...' directive.
llvm::omp::DefaultKind getDefaultKind() const
Returns kind of the clause.
OpenMPDefaultClauseVariableCategory getDefaultVC() const
This represents 'defaultmap' clause in the 'pragma omp ...' directive.
OpenMPDefaultmapClauseModifier getDefaultmapModifier() const
Get the modifier of the clause.
OpenMPDefaultmapClauseKind getDefaultmapKind() const
Get kind of the clause.
This represents implicit clause 'depend' for the 'pragma omp task' directive.
static OMPDependClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, DependDataTy Data, Expr *DepModifier, ArrayRef< Expr * > VL, unsigned NumLoops)
Creates clause with a list of variables VL.
Expr * getModifier()
Return optional depend modifier.
Expr * getLoopData(unsigned NumLoop)
Get the loop data.
void setLoopData(unsigned NumLoop, Expr *Cnt)
Set the loop data for the depend clauses with 'sink|source' kind of dependency.
static OMPDependClause * CreateEmpty(const ASTContext &C, unsigned N, unsigned NumLoops)
Creates an empty clause with N variables.
OpenMPDependClauseKind getDependencyKind() const
Get dependency type.
This represents implicit clause 'depobj' for the 'pragma omp depobj' directive.
static OMPDepobjClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, Expr *Depobj)
Creates clause.
static OMPDepobjClause * CreateEmpty(const ASTContext &C)
Creates an empty clause.
Expr * getDepobj()
Returns depobj expression associated with the clause.
This represents 'destroy' clause in the 'pragma omp depobj' directive or the 'pragma omp interop' dir...
Expr * getInteropVar() const
Returns the interop variable.
This represents 'detach' clause in the 'pragma omp task' directive.
Expr * getEventHandler() const
Returns event-handler expression.
This represents 'device' clause in the 'pragma omp ...' directive.
OpenMPDeviceClauseModifier getModifier() const
Gets modifier.
Expr * getDevice()
Return device number.
MutableArrayRef< OpenMPDirectiveKind > getDirectiveKinds()
This represents 'dist_schedule' clause in the 'pragma omp ...' directive.
OpenMPDistScheduleClauseKind getDistScheduleKind() const
Get kind of the clause.
Expr * getChunkSize()
Get chunk size.
This represents the 'doacross' clause for the 'pragma omp ordered' directive.
void setLoopData(unsigned NumLoop, Expr *Cnt)
Set the loop data.
Expr * getLoopData(unsigned NumLoop)
Get the loop data.
static OMPDoacrossClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, OpenMPDoacrossClauseModifier DepType, SourceLocation DepLoc, SourceLocation ColonLoc, ArrayRef< Expr * > VL, unsigned NumLoops)
Creates clause with a list of expressions VL.
static OMPDoacrossClause * CreateEmpty(const ASTContext &C, unsigned N, unsigned NumLoops)
Creates an empty clause with N expressions.
OpenMPDoacrossClauseModifier getDependenceType() const
Get dependence type.
This represents 'dynamic_allocators' clause in the 'pragma omp requires' directive.
This represents clause 'exclusive' in the 'pragma omp scan' directive.
static OMPExclusiveClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
static OMPExclusiveClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL)
Creates clause with a list of variables VL.
This represents 'fail' clause in the 'pragma omp atomic' directive.
OpenMPClauseKind getFailParameter() const
Gets the parameter (type memory-order-clause) in Fail clause.
This represents 'filter' clause in the 'pragma omp ...' directive.
Expr * getThreadID() const
Return thread identifier.
This represents 'final' clause in the 'pragma omp ...' directive.
child_range used_children()
Expr * getCondition() const
Returns condition.
This represents clause 'firstprivate' in the 'pragma omp ...' directives.
static OMPFirstprivateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > PrivateVL, ArrayRef< Expr * > InitVL, Stmt *PreInit)
Creates clause with a list of variables VL.
static OMPFirstprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents implicit clause 'flush' for the 'pragma omp flush' directive.
static OMPFlushClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
static OMPFlushClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL)
Creates clause with a list of variables VL.
This represents clause 'from' in the 'pragma omp ...' directives.
static OMPFromClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
static OMPFromClause * Create(const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef< Expr * > Vars, ArrayRef< ValueDecl * > Declarations, MappableExprComponentListsRef ComponentLists, ArrayRef< Expr * > UDMapperRefs, ArrayRef< OpenMPMotionModifierKind > MotionModifiers, ArrayRef< SourceLocation > MotionModifiersLoc, NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId)
Creates clause with a list of variables Vars.
Representation of the 'full' clause of the 'pragma omp unroll' directive.
static OMPFullClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Build an AST node for a 'full' clause.
static OMPFullClause * CreateEmpty(const ASTContext &C)
Build an empty 'full' AST node for deserialization.
This represents 'grainsize' clause in the 'pragma omp ...' directive.
Expr * getGrainsize() const
Return safe iteration space distance.
child_range used_children()
OpenMPGrainsizeClauseModifier getModifier() const
Gets modifier.
This represents clause 'has_device_ptr' in the 'pragma omp ...' directives.
static OMPHasDeviceAddrClause * Create(const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef< Expr * > Vars, ArrayRef< ValueDecl * > Declarations, MappableExprComponentListsRef ComponentLists)
Creates clause with a list of variables Vars.
static OMPHasDeviceAddrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents 'hint' clause in the 'pragma omp ...' directive.
Expr * getHint() const
Returns number of threads.
This represents the 'holds' clause in the 'pragma omp assume' directive.
This represents 'if' clause in the 'pragma omp ...' directive.
child_range used_children()
Expr * getCondition() const
Returns condition.
OpenMPDirectiveKind getNameModifier() const
Return directive name modifier associated with the clause.
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.
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
static OMPInReductionClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, ArrayRef< Expr * > Privates, ArrayRef< Expr * > LHSExprs, ArrayRef< Expr * > RHSExprs, ArrayRef< Expr * > ReductionOps, ArrayRef< Expr * > TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL.
This represents clause 'inclusive' in the 'pragma omp scan' directive.
static OMPInclusiveClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL)
Creates clause with a list of variables VL.
static OMPInclusiveClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents the 'init' clause in 'pragma omp ...' directives.
bool getIsTarget() const
Returns true is interop-type 'target' is used.
bool getIsTargetSync() const
Returns true is interop-type 'targetsync' is used.
static OMPInitClause * Create(const ASTContext &C, Expr *InteropVar, OMPInteropInfo &InteropInfo, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc)
Creates a fully specified clause.
static OMPInitClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N expressions.
Expr * getInteropVar()
Returns the interop variable.
This represents clause 'is_device_ptr' in the 'pragma omp ...' directives.
static OMPIsDevicePtrClause * Create(const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef< Expr * > Vars, ArrayRef< ValueDecl * > Declarations, MappableExprComponentListsRef ComponentLists)
Creates clause with a list of variables Vars.
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.
void setPrivateCopies(ArrayRef< Expr * > PrivateCopies)
Set list of helper expressions, required for generation of private copies of original lastprivate var...
static OMPLastprivateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > SrcExprs, ArrayRef< Expr * > DstExprs, ArrayRef< Expr * > AssignmentOps, OpenMPLastprivateModifier LPKind, SourceLocation LPKindLoc, SourceLocation ColonLoc, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL.
OpenMPLastprivateModifier getKind() const
Lastprivate kind.
This represents clause 'linear' in the 'pragma omp ...' directives.
child_range used_children()
SourceLocation getModifierLoc() const
Return modifier location.
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.
void setFinals(ArrayRef< Expr * > FL)
Sets the list of final update expressions for linear variables.
void setUsedExprs(ArrayRef< Expr * > UE)
Sets the list of used expressions for the linear clause.
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation StepModifierLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > PL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
OpenMPLinearClauseKind getModifier() const
Return modifier.
This class represents the 'looprange' clause in the 'pragma omp fuse' directive.
Expr * getFirst() const
Get looprange 'first' expression.
static OMPLoopRangeClause * CreateEmpty(const ASTContext &C)
Build an empty 'looprange' clause node.
static OMPLoopRangeClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation FirstLoc, SourceLocation CountLoc, SourceLocation EndLoc, Expr *First, Expr *Count)
Build a 'looprange' clause AST node.
Expr * getCount() const
Get looprange 'count' expression.
This represents clause 'map' in the 'pragma omp ...' directives.
OpenMPMapClauseKind getMapType() const LLVM_READONLY
Fetches mapping kind for the clause.
static OMPMapClause * Create(const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef< Expr * > Vars, ArrayRef< ValueDecl * > Declarations, MappableExprComponentListsRef ComponentLists, ArrayRef< Expr * > UDMapperRefs, Expr *IteratorModifier, ArrayRef< OpenMPMapModifierKind > MapModifiers, ArrayRef< SourceLocation > MapModifiersLoc, NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId, OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc)
Creates clause with a list of variables VL.
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.
This represents 'mergeable' clause in the 'pragma omp ...' directive.
This represents the 'message' clause in the 'pragma omp error' and the 'pragma omp parallel' directiv...
Expr * getMessageString() const
Returns message string of the clause.
This represents the 'no_openmp' clause in the 'pragma omp assume' directive.
This represents the 'no_openmp_constructs' clause in the.
This represents the 'no_openmp_routines' clause in the 'pragma omp assume' directive.
This represents the 'no_parallelism' clause in the 'pragma omp assume' directive.
This represents 'nocontext' clause in the 'pragma omp ...' directive.
Expr * getCondition() const
Returns condition.
child_range used_children()
This represents 'nogroup' clause in the 'pragma omp ...' directive.
This represents clause 'nontemporal' in the 'pragma omp ...' directives.
static OMPNontemporalClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
static OMPNontemporalClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL)
Creates clause with a list of variables VL.
void setPrivateRefs(ArrayRef< Expr * > VL)
Sets the list of references to private copies created in private clauses.
This represents 'novariants' clause in the 'pragma omp ...' directive.
child_range used_children()
Expr * getCondition() const
Returns condition.
This represents 'nowait' clause in the 'pragma omp ...' directive.
This represents 'num_tasks' clause in the 'pragma omp ...' directive.
Expr * getNumTasks() const
Return safe iteration space distance.
child_range used_children()
OpenMPNumTasksClauseModifier getModifier() const
Gets modifier.
This represents 'num_teams' clause in the 'pragma omp ...' directive.
static OMPNumTeamsClause * Create(const ASTContext &C, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, Stmt *PreInit)
Creates clause with a list of variables VL.
static OMPNumTeamsClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents 'num_threads' clause in the 'pragma omp ...' directive.
OpenMPNumThreadsClauseModifier getModifier() const
Gets modifier.
Expr * getNumThreads() const
Returns number of threads.
llvm::iterator_range< child_iterator > child_range
This represents 'order' clause in the 'pragma omp ...' directive.
OpenMPOrderClauseKind getKind() const
Returns kind of the clause.
OpenMPOrderClauseModifier getModifier() const
Returns Modifier of the clause.
This represents 'ordered' clause in the 'pragma omp ...' directive.
void setLoopCounter(unsigned NumLoop, Expr *Counter)
Set loop counter for the specified loop.
Expr * getNumForLoops() const
Return the number of associated for-loops.
void setLoopNumIterations(unsigned NumLoop, Expr *NumIterations)
Set number of iterations for the specified loop.
ArrayRef< Expr * > getLoopNumIterations() const
Get number of iterations for all the loops.
static OMPOrderedClause * Create(const ASTContext &C, Expr *Num, unsigned NumLoops, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build 'ordered' clause.
static OMPOrderedClause * CreateEmpty(const ASTContext &C, unsigned NumLoops)
Build an empty clause.
Expr * getLoopCounter(unsigned NumLoop)
Get loops counter for the specified loop.
Representation of the 'partial' clause of the 'pragma omp unroll' directive.
static OMPPartialClause * CreateEmpty(const ASTContext &C)
Build an empty 'partial' AST node for deserialization.
static OMPPartialClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, Expr *Factor)
Build an AST node for a 'partial' clause.
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.
MutableArrayRef< Expr * > getArgsRefs()
Returns the permutation index expressions.
static OMPPermutationClause * CreateEmpty(const ASTContext &C, unsigned NumLoops)
Build an empty 'permutation' AST node for deserialization.
static OMPPermutationClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > Args)
Build a 'permutation' clause AST node.
This represents 'priority' clause in the 'pragma omp ...' directive.
child_range used_children()
Expr * getPriority()
Return Priority number.
This represents clause 'private' in the 'pragma omp ...' directives.
static OMPPrivateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > PrivateVL)
Creates clause with a list of variables VL.
static OMPPrivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'proc_bind' clause in the 'pragma omp ...' directive.
llvm::omp::ProcBindKind getProcBindKind() const
Returns kind of the clause.
This represents 'read' clause in the 'pragma omp atomic' directive.
This represents clause 'reduction' in the 'pragma omp ...' directives.
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
static OMPReductionClause * CreateEmpty(const ASTContext &C, unsigned N, OpenMPReductionClauseModifier Modifier)
Creates an empty clause with the place for N variables.
static OMPReductionClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, OpenMPReductionClauseModifier Modifier, ArrayRef< Expr * > VL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, ArrayRef< Expr * > Privates, ArrayRef< Expr * > LHSExprs, ArrayRef< Expr * > RHSExprs, ArrayRef< Expr * > ReductionOps, ArrayRef< Expr * > CopyOps, ArrayRef< Expr * > CopyArrayTemps, ArrayRef< Expr * > CopyArrayElems, Stmt *PreInit, Expr *PostUpdate, ArrayRef< bool > IsPrivateVarReduction, OpenMPOriginalSharingModifier OriginalSharingModifier)
Creates clause with a list of variables VL.
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
OpenMPReductionClauseModifier getModifier() const
Returns modifier.
SourceLocation getModifierLoc() const
Returns modifier location.
This represents 'relaxed' clause in the 'pragma omp atomic' directives.
This represents 'release' clause in the 'pragma omp atomic|flush' directives.
This represents 'reverse_offload' clause in the 'pragma omp requires' directive.
This represents 'simd' clause in the 'pragma omp ...' directive.
This represents 'safelen' clause in the 'pragma omp ...' directive.
Expr * getSafelen() const
Return safe iteration space distance.
This represents 'schedule' clause in the 'pragma omp ...' directive.
OpenMPScheduleClauseKind getScheduleKind() const
Get kind of the clause.
OpenMPScheduleClauseModifier getSecondScheduleModifier() const
Get the second modifier of the clause.
OpenMPScheduleClauseModifier getFirstScheduleModifier() const
Get the first modifier of the clause.
Expr * getChunkSize()
Get chunk size.
This represents 'self_maps' clause in the 'pragma omp requires' directive.
This represents 'seq_cst' clause in the 'pragma omp atomic|flush' directives.
This represents the 'severity' clause in the 'pragma omp error' and the 'pragma omp parallel' directi...
OpenMPSeverityClauseKind getSeverityKind() const
Returns kind of the clause.
This represents clause 'shared' in the 'pragma omp ...' directives.
static OMPSharedClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL)
Creates clause with a list of variables VL.
static OMPSharedClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents 'simdlen' clause in the 'pragma omp ...' directive.
Expr * getSimdlen() const
Return safe iteration space distance.
This represents the 'sizes' clause in the 'pragma omp tile' directive.
static OMPSizesClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > Sizes)
Build a 'sizes' AST node.
MutableArrayRef< Expr * > getSizesRefs()
Returns the tile size expressions.
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.
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
static OMPTaskReductionClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, ArrayRef< Expr * > Privates, ArrayRef< Expr * > LHSExprs, ArrayRef< Expr * > RHSExprs, ArrayRef< Expr * > ReductionOps, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL.
static OMPTaskReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'thread_limit' clause in the 'pragma omp ...' directive.
static OMPThreadLimitClause * Create(const ASTContext &C, OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, Stmt *PreInit)
Creates clause with a list of variables VL.
static OMPThreadLimitClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents 'threads' clause in the 'pragma omp ...' directive.
This represents clause 'to' in the 'pragma omp ...' directives.
static OMPToClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
static OMPToClause * Create(const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef< Expr * > Vars, ArrayRef< ValueDecl * > Declarations, MappableExprComponentListsRef ComponentLists, ArrayRef< Expr * > UDMapperRefs, ArrayRef< OpenMPMotionModifierKind > MotionModifiers, ArrayRef< SourceLocation > MotionModifiersLoc, NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId)
Creates clause with a list of variables Vars.
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
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.
This represents 'unified_address' clause in the 'pragma omp requires' directive.
This represents 'unified_shared_memory' clause in the 'pragma omp requires' directive.
This represents 'untied' clause in the 'pragma omp ...' directive.
This represents 'update' clause in the 'pragma omp atomic' directive.
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.
static OMPUpdateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates clause for 'atomic' directive.
bool isExtended() const
Checks if the clause is the extended clauses for 'depobj' directive.
This represents the 'use' clause in 'pragma omp ...' directives.
Expr * getInteropVar() const
Returns the interop variable.
This represents clause 'use_device_addr' in the 'pragma omp ...' directives.
static OMPUseDeviceAddrClause * Create(const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef< Expr * > Vars, ArrayRef< ValueDecl * > Declarations, MappableExprComponentListsRef ComponentLists)
Creates clause with a list of variables Vars.
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.
static OMPUseDevicePtrClause * Create(const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef< Expr * > Vars, ArrayRef< Expr * > PrivateVars, ArrayRef< Expr * > Inits, ArrayRef< ValueDecl * > Declarations, MappableExprComponentListsRef ComponentLists)
Creates clause with a list of variables Vars.
static OMPUseDevicePtrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents clause 'uses_allocators' in the 'pragma omp target'-based directives.
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.
static OMPUsesAllocatorsClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< OMPUsesAllocatorsClause::Data > Data)
Creates clause with a list of allocators Data.
MutableArrayRef< Expr * > getVarRefs()
varlist_iterator varlist_end()
bool varlist_empty() const
unsigned varlist_size() const
This represents 'weak' clause in the 'pragma omp atomic' directives.
This represents 'write' clause in the 'pragma omp atomic' directive.
This represents 'ompx_attribute' clause in a directive that might generate an outlined function.
ArrayRef< const Attr * > getAttrs() const
Returned the attributes parsed from this clause.
This represents 'ompx_bare' clause in the 'pragma omp target teams ...' directive.
This represents 'ompx_dyn_cgroup_mem' clause in the 'pragma omp target ...' directive.
Expr * getSize()
Return the size expression.
A (possibly-)qualified type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
Smart pointer class that efficiently represents Objective-C method names.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
Stmt - This represents one statement.
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
Base wrapper for a particular "section" of type source info.
The base class of the type hierarchy.
bool isPointerType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Defines the clang::TargetInfo interface.
The JSON file list parser is used to communicate input to InstallAPI.
OpenMPOriginalSharingModifier
OpenMP 6.0 original sharing modifiers.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
bool isa(CodeGen::Address addr)
@ OMPC_ORDER_MODIFIER_unknown
OpenMPReductionClauseModifier
OpenMP modifiers for 'reduction' clause.
@ DeviceNum
'device_num' clause, allowed on 'init', 'shutdown', and 'set' constructs.
@ OMPC_SCHEDULE_MODIFIER_unknown
const char * getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, unsigned Type)
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.
@ OMPC_LASTPRIVATE_unknown
OpenMPDependClauseKind
OpenMP attributes for 'depend' clause.
OpenMPGrainsizeClauseModifier
OpenMPNumTasksClauseModifier
static constexpr unsigned NumberOfOMPMotionModifiers
Number of allowed motion-modifiers.
@ OMPC_MOTION_MODIFIER_unknown
@ 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
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword.
U cast(CodeGen::Address addr)
const char * getOpenMPDefaultVariableCategoryName(unsigned VC)
OpenMPDeviceClauseModifier
OpenMP modifiers for 'device' clause.
@ OMPC_MAP_MODIFIER_unknown
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...
DeclarationName getName() const
getName - Returns the embedded declaration name.
llvm::SmallVector< Expr *, 4 > PreferTypes
This structure contains all sizes needed for by an OMPMappableExprListClause.
unsigned NumComponentLists
Number of component lists.
unsigned NumVars
Number of expressions listed.
unsigned NumUniqueDeclarations
Number of unique base declarations.
unsigned NumComponents
Total number of expression components.
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.
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.