Lines Matching defs:clause
57 namespace clause {
62 using AcqRel = tomp::clause::AcqRelT<TypeTy, IdTy, ExprTy>;
63 using Acquire = tomp::clause::AcquireT<TypeTy, IdTy, ExprTy>;
64 using AdjustArgs = tomp::clause::AdjustArgsT<TypeTy, IdTy, ExprTy>;
65 using Affinity = tomp::clause::AffinityT<TypeTy, IdTy, ExprTy>;
66 using Aligned = tomp::clause::AlignedT<TypeTy, IdTy, ExprTy>;
67 using Align = tomp::clause::AlignT<TypeTy, IdTy, ExprTy>;
68 using Allocate = tomp::clause::AllocateT<TypeTy, IdTy, ExprTy>;
69 using Allocator = tomp::clause::AllocatorT<TypeTy, IdTy, ExprTy>;
70 using AppendArgs = tomp::clause::AppendArgsT<TypeTy, IdTy, ExprTy>;
72 tomp::clause::AtomicDefaultMemOrderT<TypeTy, IdTy, ExprTy>;
73 using At = tomp::clause::AtT<TypeTy, IdTy, ExprTy>;
74 using Bind = tomp::clause::BindT<TypeTy, IdTy, ExprTy>;
75 using Capture = tomp::clause::CaptureT<TypeTy, IdTy, ExprTy>;
76 using Collapse = tomp::clause::CollapseT<TypeTy, IdTy, ExprTy>;
77 using Compare = tomp::clause::CompareT<TypeTy, IdTy, ExprTy>;
78 using Copyin = tomp::clause::CopyinT<TypeTy, IdTy, ExprTy>;
79 using Copyprivate = tomp::clause::CopyprivateT<TypeTy, IdTy, ExprTy>;
80 using Defaultmap = tomp::clause::DefaultmapT<TypeTy, IdTy, ExprTy>;
81 using Default = tomp::clause::DefaultT<TypeTy, IdTy, ExprTy>;
82 using Depend = tomp::clause::DependT<TypeTy, IdTy, ExprTy>;
83 using Destroy = tomp::clause::DestroyT<TypeTy, IdTy, ExprTy>;
84 using Detach = tomp::clause::DetachT<TypeTy, IdTy, ExprTy>;
85 using Device = tomp::clause::DeviceT<TypeTy, IdTy, ExprTy>;
86 using DeviceType = tomp::clause::DeviceTypeT<TypeTy, IdTy, ExprTy>;
87 using DistSchedule = tomp::clause::DistScheduleT<TypeTy, IdTy, ExprTy>;
88 using Doacross = tomp::clause::DoacrossT<TypeTy, IdTy, ExprTy>;
90 tomp::clause::DynamicAllocatorsT<TypeTy, IdTy, ExprTy>;
91 using Enter = tomp::clause::EnterT<TypeTy, IdTy, ExprTy>;
92 using Exclusive = tomp::clause::ExclusiveT<TypeTy, IdTy, ExprTy>;
93 using Fail = tomp::clause::FailT<TypeTy, IdTy, ExprTy>;
94 using Filter = tomp::clause::FilterT<TypeTy, IdTy, ExprTy>;
95 using Final = tomp::clause::FinalT<TypeTy, IdTy, ExprTy>;
96 using Firstprivate = tomp::clause::FirstprivateT<TypeTy, IdTy, ExprTy>;
97 using From = tomp::clause::FromT<TypeTy, IdTy, ExprTy>;
98 using Full = tomp::clause::FullT<TypeTy, IdTy, ExprTy>;
99 using Grainsize = tomp::clause::GrainsizeT<TypeTy, IdTy, ExprTy>;
100 using HasDeviceAddr = tomp::clause::HasDeviceAddrT<TypeTy, IdTy, ExprTy>;
101 using Hint = tomp::clause::HintT<TypeTy, IdTy, ExprTy>;
102 using If = tomp::clause::IfT<TypeTy, IdTy, ExprTy>;
103 using Inbranch = tomp::clause::InbranchT<TypeTy, IdTy, ExprTy>;
104 using Inclusive = tomp::clause::InclusiveT<TypeTy, IdTy, ExprTy>;
105 using Indirect = tomp::clause::IndirectT<TypeTy, IdTy, ExprTy>;
106 using Init = tomp::clause::InitT<TypeTy, IdTy, ExprTy>;
107 using InReduction = tomp::clause::InReductionT<TypeTy, IdTy, ExprTy>;
108 using IsDevicePtr = tomp::clause::IsDevicePtrT<TypeTy, IdTy, ExprTy>;
109 using Lastprivate = tomp::clause::LastprivateT<TypeTy, IdTy, ExprTy>;
110 using Linear = tomp::clause::LinearT<TypeTy, IdTy, ExprTy>;
111 using Link = tomp::clause::LinkT<TypeTy, IdTy, ExprTy>;
112 using Map = tomp::clause::MapT<TypeTy, IdTy, ExprTy>;
113 using Match = tomp::clause::MatchT<TypeTy, IdTy, ExprTy>;
114 using Mergeable = tomp::clause::MergeableT<TypeTy, IdTy, ExprTy>;
115 using Message = tomp::clause::MessageT<TypeTy, IdTy, ExprTy>;
116 using Nocontext = tomp::clause::NocontextT<TypeTy, IdTy, ExprTy>;
117 using Nogroup = tomp::clause::NogroupT<TypeTy, IdTy, ExprTy>;
118 using Nontemporal = tomp::clause::NontemporalT<TypeTy, IdTy, ExprTy>;
119 using Notinbranch = tomp::clause::NotinbranchT<TypeTy, IdTy, ExprTy>;
120 using Novariants = tomp::clause::NovariantsT<TypeTy, IdTy, ExprTy>;
121 using Nowait = tomp::clause::NowaitT<TypeTy, IdTy, ExprTy>;
122 using NumTasks = tomp::clause::NumTasksT<TypeTy, IdTy, ExprTy>;
123 using NumTeams = tomp::clause::NumTeamsT<TypeTy, IdTy, ExprTy>;
124 using NumThreads = tomp::clause::NumThreadsT<TypeTy, IdTy, ExprTy>;
125 using OmpxAttribute = tomp::clause::OmpxAttributeT<TypeTy, IdTy, ExprTy>;
126 using OmpxBare = tomp::clause::OmpxBareT<TypeTy, IdTy, ExprTy>;
127 using OmpxDynCgroupMem = tomp::clause::OmpxDynCgroupMemT<TypeTy, IdTy, ExprTy>;
128 using Ordered = tomp::clause::OrderedT<TypeTy, IdTy, ExprTy>;
129 using Order = tomp::clause::OrderT<TypeTy, IdTy, ExprTy>;
130 using Partial = tomp::clause::PartialT<TypeTy, IdTy, ExprTy>;
131 using Priority = tomp::clause::PriorityT<TypeTy, IdTy, ExprTy>;
132 using Private = tomp::clause::PrivateT<TypeTy, IdTy, ExprTy>;
133 using ProcBind = tomp::clause::ProcBindT<TypeTy, IdTy, ExprTy>;
134 using Read = tomp::clause::ReadT<TypeTy, IdTy, ExprTy>;
135 using Reduction = tomp::clause::ReductionT<TypeTy, IdTy, ExprTy>;
136 using Relaxed = tomp::clause::RelaxedT<TypeTy, IdTy, ExprTy>;
137 using Release = tomp::clause::ReleaseT<TypeTy, IdTy, ExprTy>;
138 using ReverseOffload = tomp::clause::ReverseOffloadT<TypeTy, IdTy, ExprTy>;
139 using Safelen = tomp::clause::SafelenT<TypeTy, IdTy, ExprTy>;
140 using Schedule = tomp::clause::ScheduleT<TypeTy, IdTy, ExprTy>;
141 using SeqCst = tomp::clause::SeqCstT<TypeTy, IdTy, ExprTy>;
142 using Severity = tomp::clause::SeverityT<TypeTy, IdTy, ExprTy>;
143 using Shared = tomp::clause::SharedT<TypeTy, IdTy, ExprTy>;
144 using Simdlen = tomp::clause::SimdlenT<TypeTy, IdTy, ExprTy>;
145 using Simd = tomp::clause::SimdT<TypeTy, IdTy, ExprTy>;
146 using Sizes = tomp::clause::SizesT<TypeTy, IdTy, ExprTy>;
147 using TaskReduction = tomp::clause::TaskReductionT<TypeTy, IdTy, ExprTy>;
148 using ThreadLimit = tomp::clause::ThreadLimitT<TypeTy, IdTy, ExprTy>;
149 using Threads = tomp::clause::ThreadsT<TypeTy, IdTy, ExprTy>;
150 using To = tomp::clause::ToT<TypeTy, IdTy, ExprTy>;
151 using UnifiedAddress = tomp::clause::UnifiedAddressT<TypeTy, IdTy, ExprTy>;
153 tomp::clause::UnifiedSharedMemoryT<TypeTy, IdTy, ExprTy>;
154 using Uniform = tomp::clause::UniformT<TypeTy, IdTy, ExprTy>;
155 using Unknown = tomp::clause::UnknownT<TypeTy, IdTy, ExprTy>;
156 using Untied = tomp::clause::UntiedT<TypeTy, IdTy, ExprTy>;
157 using Update = tomp::clause::UpdateT<TypeTy, IdTy, ExprTy>;
158 using UseDeviceAddr = tomp::clause::UseDeviceAddrT<TypeTy, IdTy, ExprTy>;
159 using UseDevicePtr = tomp::clause::UseDevicePtrT<TypeTy, IdTy, ExprTy>;
160 using UsesAllocators = tomp::clause::UsesAllocatorsT<TypeTy, IdTy, ExprTy>;
161 using Use = tomp::clause::UseT<TypeTy, IdTy, ExprTy>;
162 using Weak = tomp::clause::WeakT<TypeTy, IdTy, ExprTy>;
163 using When = tomp::clause::WhenT<TypeTy, IdTy, ExprTy>;
164 using Write = tomp::clause::WriteT<TypeTy, IdTy, ExprTy>;
165 } // namespace clause
293 omp::clause::ReductionOperator
294 makeOp(omp::clause::DefinedOperator::IntrinsicOperator Op) {
295 return omp::clause::ReductionOperator{omp::clause::DefinedOperator{Op}};
317 // (1) The effect of the 1 private clause is as if it is applied only to the
323 {OMPC_private, omp::clause::Private{{x}}},
340 {OMPC_private, omp::clause::Private{{x}}},
359 // (3) The effect of the firstprivate clause is as if it is applied to one or
364 // (8) To a worksharing construct that accepts the clause if one is among the
369 // the clause is among them;
371 // the same list item neither appears in a lastprivate clause nor is the
373 // clause.
376 // effect is not as if the firstprivate clause is applied to it by the above
377 // rules, then the effect is as if the shared clause with the same list item is
380 // effect is not as if the firstprivate clause is applied to it by the above
381 // rules, then the effect is as if the shared clause with the same list item is
387 {OMPC_firstprivate, omp::clause::Firstprivate{{x}}},
404 {OMPC_firstprivate, omp::clause::Firstprivate{{x}}},
423 {OMPC_firstprivate, omp::clause::Firstprivate{{x}}},
424 {OMPC_lastprivate, omp::clause::Lastprivate{{std::nullopt, {x}}}},
443 {OMPC_firstprivate, omp::clause::Firstprivate{{x}}},
460 {OMPC_firstprivate, omp::clause::Firstprivate{{x}}},
479 {OMPC_firstprivate, omp::clause::Firstprivate{{x}}},
496 {OMPC_firstprivate, omp::clause::Firstprivate{{x}}},
515 // (21) The effect of the lastprivate clause is as if it is applied to all leaf
516 // constructs that permit the clause.
518 // list item is not also specified in the firstprivate clause, then the effect
519 // of the lastprivate clause is as if the shared clause with the same list item
522 // item is not also specified in the firstprivate clause, then the effect of the
523 // lastprivate clause is as if the shared clause with the same list item is
527 // a map clause, the effect of the lastprivate clause is as if the same list
528 // item appears in a map clause with a map-type of tofrom.
533 {OMPC_lastprivate, omp::clause::Lastprivate{{std::nullopt, {x}}}},
550 {OMPC_lastprivate, omp::clause::Lastprivate{{std::nullopt, {x}}}},
567 {OMPC_lastprivate, omp::clause::Lastprivate{{std::nullopt, {x}}}},
587 // (31) The effect of the shared, default, thread_limit, or order clause is as
588 // if it is applied to all leaf constructs that permit the clause.
593 {OMPC_shared, omp::clause::Shared{{x}}},
613 // (31) The effect of the shared, default, thread_limit, or order clause is as
614 // if it is applied to all leaf constructs that permit the clause.
620 omp::clause::Default{
621 omp::clause::Default::DataSharingAttribute::Firstprivate}},
641 // (31) The effect of the shared, default, thread_limit, or order clause is as
642 // if it is applied to all leaf constructs that permit the clause.
647 {OMPC_thread_limit, omp::clause::ThreadLimit{omp::ExprTy{}}},
667 // (31) The effect of the shared, default, thread_limit, or order clause is as
668 // if it is applied to all leaf constructs that permit the clause.
674 omp::clause::Order{{omp::clause::Order::OrderModifier::Unconstrained,
675 omp::clause::Order::Ordering::Concurrent}}},
703 // (33) The effect of the allocate clause is as if it is applied to all leaf
704 // constructs that permit the clause and to which a data-sharing attribute
705 // clause that may create a private copy of the same list item is applied.
711 {OMPC_allocate, omp::clause::Allocate{{std::nullopt, std::nullopt, {x}}}},
712 {OMPC_firstprivate, omp::clause::Firstprivate{{x}}},
727 auto Add = red::makeOp(omp::clause::DefinedOperator::IntrinsicOperator::Add);
731 {OMPC_allocate, omp::clause::Allocate{{std::nullopt, std::nullopt, {x}}}},
732 {OMPC_in_reduction, omp::clause::InReduction{{{Add}, {x}}}},
750 {OMPC_allocate, omp::clause::Allocate{{std::nullopt, std::nullopt, {x}}}},
751 {OMPC_linear, omp::clause::Linear{{std::nullopt, std::nullopt, {x}}}},
760 // The "shared" clause is duplicated---this isn't harmful, but it
772 {OMPC_allocate, omp::clause::Allocate{{std::nullopt, std::nullopt, {x}}}},
773 {OMPC_lastprivate, omp::clause::Lastprivate{{std::nullopt, {x}}}},
791 {OMPC_allocate, omp::clause::Allocate{{std::nullopt, std::nullopt, {x}}}},
792 {OMPC_private, omp::clause::Private{{x}}},
807 auto Add = red::makeOp(omp::clause::DefinedOperator::IntrinsicOperator::Add);
811 {OMPC_allocate, omp::clause::Allocate{{std::nullopt, std::nullopt, {x}}}},
812 {OMPC_reduction, omp::clause::Reduction{{std::nullopt, {Add}, {x}}}},
830 // (36) The effect of the reduction clause is as if it is applied to all leaf
831 // constructs that permit the clause, except for the following constructs:
836 // clause instead is as if each list item or, for any list item that is an array
837 // item, its corresponding base array or base pointer appears in a shared clause
840 // modifies the behavior of the reduction clause on the innermost leaf construct
843 // modifies the behavior of the reduction clause on all constructs of the
844 // combined construct to which the clause is applied and that accept the
846 // (10) If a list item in a reduction clause on a combined target construct does
848 // clause on the construct, then the effect is as if the list item in the
849 // reduction clause appears as a list item in a map clause with a map-type of
853 auto Add = red::makeOp(omp::clause::DefinedOperator::IntrinsicOperator::Add);
856 {OMPC_reduction, omp::clause::Reduction{{std::nullopt, {Add}, {x}}}},
871 auto Add = red::makeOp(omp::clause::DefinedOperator::IntrinsicOperator::Add);
874 {OMPC_reduction, omp::clause::Reduction{{std::nullopt, {Add}, {x}}}},
889 auto Add = red::makeOp(omp::clause::DefinedOperator::IntrinsicOperator::Add);
892 {OMPC_reduction, omp::clause::Reduction{{std::nullopt, {Add}, {x}}}},
906 auto Add = red::makeOp(omp::clause::DefinedOperator::IntrinsicOperator::Add);
909 {OMPC_reduction, omp::clause::Reduction{{std::nullopt, {Add}, {x}}}},
928 auto Add = red::makeOp(omp::clause::DefinedOperator::IntrinsicOperator::Add);
929 auto TaskMod = omp::clause::Reduction::ReductionModifier::Task;
932 {OMPC_reduction, omp::clause::Reduction{{TaskMod, {Add}, {x}}}},
951 auto Add = red::makeOp(omp::clause::DefinedOperator::IntrinsicOperator::Add);
952 auto InscanMod = omp::clause::Reduction::ReductionModifier::Inscan;
955 {OMPC_reduction, omp::clause::Reduction{{InscanMod, {Add}, {x}}}},
974 auto Add = red::makeOp(omp::clause::DefinedOperator::IntrinsicOperator::Add);
977 {OMPC_reduction, omp::clause::Reduction{{std::nullopt, {Add}, {x}}}},
998 // (15) For combined or composite constructs, the if clause only applies to the
1001 // specified then the if clause applies to all constituent constructs to which
1002 // an if clause can apply.
1006 omp::clause::If{{llvm::omp::Directive::OMPD_parallel, omp::ExprTy{}}}},
1024 {OMPC_if, omp::clause::If{{std::nullopt, omp::ExprTy{}}}},
1045 // (15.1) The effect of the linear clause is as if it is applied to the
1052 // (19) If a list item of the linear clause is the iteration variable of a simd
1055 // in a lastprivate clause on the combined or composite construct with the rules
1061 {OMPC_linear, omp::clause::Linear{{std::nullopt, std::nullopt, {x}}}},
1078 // (23) The effect of the nowait clause is as if it is applied to the outermost
1082 {OMPC_nowait, omp::clause::Nowait{}},
1103 {OMPC_linear, omp::clause::Linear{{std::nullopt, std::nullopt, {x}}}},