1//===-- Clauses.h -- OpenMP clause handling -------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8#ifndef FORTRAN_LOWER_OPENMP_CLAUSES_H
9#define FORTRAN_LOWER_OPENMP_CLAUSES_H
10
11#include "flang/Evaluate/expression.h"
12#include "flang/Evaluate/type.h"
13#include "flang/Parser/parse-tree.h"
14#include "flang/Semantics/expression.h"
15#include "flang/Semantics/semantics.h"
16#include "flang/Semantics/symbol.h"
17
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/Frontend/OpenMP/ClauseT.h"
20#include "llvm/Frontend/OpenMP/OMP.h.inc"
21
22#include <optional>
23#include <type_traits>
24#include <utility>
25
26namespace Fortran::semantics {
27class Symbol;
28}
29
30namespace Fortran::lower::omp {
31using namespace Fortran;
32using SomeExpr = semantics::SomeExpr;
33using MaybeExpr = semantics::MaybeExpr;
34using TypeTy = evaluate::DynamicType;
35
36template <typename ExprTy>
37struct IdTyTemplate {
38 // "symbol" is always non-null for id's of actual objects.
39 Fortran::semantics::Symbol *symbol;
40 std::optional<ExprTy> designator;
41
42 bool operator==(const IdTyTemplate &other) const {
43 // If symbols are different, then the objects are different.
44 if (symbol != other.symbol)
45 return false;
46 if (symbol == nullptr)
47 return true;
48 // Equal symbols don't necessarily indicate identical objects,
49 // for example, a derived object component may use a single symbol,
50 // which will refer to different objects for different designators,
51 // e.g. a%c and b%c.
52 return designator == other.designator;
53 }
54
55 // Defining an "ordering" which allows types derived from this to be
56 // utilised in maps and other containers that require comparison
57 // operators for ordering
58 bool operator<(const IdTyTemplate &other) const {
59 return symbol < other.symbol;
60 }
61
62 operator bool() const { return symbol != nullptr; }
63};
64
65using ExprTy = SomeExpr;
66
67template <typename T>
68using List = tomp::ListT<T>;
69} // namespace Fortran::lower::omp
70
71// Specialization of the ObjectT template
72namespace tomp::type {
73template <>
74struct ObjectT<Fortran::lower::omp::IdTyTemplate<Fortran::lower::omp::ExprTy>,
75 Fortran::lower::omp::ExprTy> {
76 using IdTy = Fortran::lower::omp::IdTyTemplate<Fortran::lower::omp::ExprTy>;
77 using ExprTy = Fortran::lower::omp::ExprTy;
78
79 IdTy id() const { return identity; }
80 Fortran::semantics::Symbol *sym() const { return identity.symbol; }
81 const std::optional<ExprTy> &ref() const { return identity.designator; }
82
83 bool operator<(const ObjectT<IdTy, ExprTy> &other) const {
84 return identity < other.identity;
85 }
86
87 IdTy identity;
88};
89} // namespace tomp::type
90
91namespace Fortran::lower::omp {
92using IdTy = IdTyTemplate<ExprTy>;
93}
94
95namespace std {
96template <>
97struct hash<Fortran::lower::omp::IdTy> {
98 size_t operator()(const Fortran::lower::omp::IdTy &id) const {
99 return static_cast<size_t>(reinterpret_cast<uintptr_t>(id.symbol));
100 }
101};
102} // namespace std
103
104namespace Fortran::lower::omp {
105using Object = tomp::ObjectT<IdTy, ExprTy>;
106using ObjectList = tomp::ObjectListT<IdTy, ExprTy>;
107
108Object makeObject(const parser::OmpObject &object,
109 semantics::SemanticsContext &semaCtx);
110Object makeObject(const parser::Name &name,
111 semantics::SemanticsContext &semaCtx);
112Object makeObject(const parser::Designator &dsg,
113 semantics::SemanticsContext &semaCtx);
114Object makeObject(const parser::StructureComponent &comp,
115 semantics::SemanticsContext &semaCtx);
116
117inline auto makeObjectFn(semantics::SemanticsContext &semaCtx) {
118 return [&](auto &&s) { return makeObject(s, semaCtx); };
119}
120
121template <typename T>
122SomeExpr makeExpr(T &&pftExpr, semantics::SemanticsContext &semaCtx) {
123 auto maybeExpr = evaluate::ExpressionAnalyzer(semaCtx).Analyze(pftExpr);
124 assert(maybeExpr);
125 return std::move(*maybeExpr);
126}
127
128inline auto makeExprFn(semantics::SemanticsContext &semaCtx) {
129 return [&](auto &&s) { return makeExpr(s, semaCtx); };
130}
131
132template <
133 typename ContainerTy, typename FunctionTy,
134 typename ElemTy = typename llvm::remove_cvref_t<ContainerTy>::value_type,
135 typename ResultTy = std::invoke_result_t<FunctionTy, ElemTy>>
136List<ResultTy> makeList(ContainerTy &&container, FunctionTy &&func) {
137 List<ResultTy> v;
138 llvm::transform(container, std::back_inserter(v), func);
139 return v;
140}
141
142inline ObjectList makeObjects(const parser::OmpObjectList &objects,
143 semantics::SemanticsContext &semaCtx) {
144 return makeList(objects.v, makeObjectFn(semaCtx));
145}
146
147ObjectList makeObjects(const parser::OmpArgumentList &objects,
148 semantics::SemanticsContext &semaCtx);
149
150template <typename FuncTy, //
151 typename ArgTy, //
152 typename ResultTy = std::invoke_result_t<FuncTy, ArgTy>>
153std::optional<ResultTy> maybeApply(FuncTy &&func,
154 const std::optional<ArgTy> &arg) {
155 if (!arg)
156 return std::nullopt;
157 return func(*arg);
158}
159
160template < //
161 typename FuncTy, //
162 typename ArgTy, //
163 typename ResultTy =
164 std::invoke_result_t<FuncTy, decltype(std::declval<ArgTy>().v)>>
165std::optional<ResultTy> maybeApplyToV(FuncTy &&func, const ArgTy *arg) {
166 if (!arg)
167 return std::nullopt;
168 return func(arg->v);
169}
170
171std::optional<Object> getBaseObject(const Object &object,
172 semantics::SemanticsContext &semaCtx);
173
174namespace clause {
175using Range = tomp::type::RangeT<ExprTy>;
176using Mapper = tomp::type::MapperT<IdTy, ExprTy>;
177using Iterator = tomp::type::IteratorT<TypeTy, IdTy, ExprTy>;
178using IteratorSpecifier = tomp::type::IteratorSpecifierT<TypeTy, IdTy, ExprTy>;
179using DefinedOperator = tomp::type::DefinedOperatorT<IdTy, ExprTy>;
180using ProcedureDesignator = tomp::type::ProcedureDesignatorT<IdTy, ExprTy>;
181using ReductionOperator = tomp::type::ReductionIdentifierT<IdTy, ExprTy>;
182using DependenceType = tomp::type::DependenceType;
183using Prescriptiveness = tomp::type::Prescriptiveness;
184
185// "Requires" clauses are handled early on, and the aggregated information
186// is stored in the Symbol details of modules, programs, and subprograms.
187// These clauses are still handled here to cover all alternatives in the
188// main clause variant.
189
190using Absent = tomp::clause::AbsentT<TypeTy, IdTy, ExprTy>;
191using AcqRel = tomp::clause::AcqRelT<TypeTy, IdTy, ExprTy>;
192using Acquire = tomp::clause::AcquireT<TypeTy, IdTy, ExprTy>;
193using AdjustArgs = tomp::clause::AdjustArgsT<TypeTy, IdTy, ExprTy>;
194using Affinity = tomp::clause::AffinityT<TypeTy, IdTy, ExprTy>;
195using Aligned = tomp::clause::AlignedT<TypeTy, IdTy, ExprTy>;
196using Align = tomp::clause::AlignT<TypeTy, IdTy, ExprTy>;
197using Allocate = tomp::clause::AllocateT<TypeTy, IdTy, ExprTy>;
198using Allocator = tomp::clause::AllocatorT<TypeTy, IdTy, ExprTy>;
199using AppendArgs = tomp::clause::AppendArgsT<TypeTy, IdTy, ExprTy>;
200using AtomicDefaultMemOrder =
201 tomp::clause::AtomicDefaultMemOrderT<TypeTy, IdTy, ExprTy>;
202using At = tomp::clause::AtT<TypeTy, IdTy, ExprTy>;
203using Bind = tomp::clause::BindT<TypeTy, IdTy, ExprTy>;
204using Capture = tomp::clause::CaptureT<TypeTy, IdTy, ExprTy>;
205using Collapse = tomp::clause::CollapseT<TypeTy, IdTy, ExprTy>;
206using Compare = tomp::clause::CompareT<TypeTy, IdTy, ExprTy>;
207using Contains = tomp::clause::ContainsT<TypeTy, IdTy, ExprTy>;
208using Copyin = tomp::clause::CopyinT<TypeTy, IdTy, ExprTy>;
209using Copyprivate = tomp::clause::CopyprivateT<TypeTy, IdTy, ExprTy>;
210using Defaultmap = tomp::clause::DefaultmapT<TypeTy, IdTy, ExprTy>;
211using Default = tomp::clause::DefaultT<TypeTy, IdTy, ExprTy>;
212using Depend = tomp::clause::DependT<TypeTy, IdTy, ExprTy>;
213using Destroy = tomp::clause::DestroyT<TypeTy, IdTy, ExprTy>;
214using Detach = tomp::clause::DetachT<TypeTy, IdTy, ExprTy>;
215using Device = tomp::clause::DeviceT<TypeTy, IdTy, ExprTy>;
216using DeviceType = tomp::clause::DeviceTypeT<TypeTy, IdTy, ExprTy>;
217using DistSchedule = tomp::clause::DistScheduleT<TypeTy, IdTy, ExprTy>;
218using Doacross = tomp::clause::DoacrossT<TypeTy, IdTy, ExprTy>;
219using DynamicAllocators =
220 tomp::clause::DynamicAllocatorsT<TypeTy, IdTy, ExprTy>;
221using Enter = tomp::clause::EnterT<TypeTy, IdTy, ExprTy>;
222using Exclusive = tomp::clause::ExclusiveT<TypeTy, IdTy, ExprTy>;
223using Fail = tomp::clause::FailT<TypeTy, IdTy, ExprTy>;
224using Filter = tomp::clause::FilterT<TypeTy, IdTy, ExprTy>;
225using Final = tomp::clause::FinalT<TypeTy, IdTy, ExprTy>;
226using Firstprivate = tomp::clause::FirstprivateT<TypeTy, IdTy, ExprTy>;
227using From = tomp::clause::FromT<TypeTy, IdTy, ExprTy>;
228using Full = tomp::clause::FullT<TypeTy, IdTy, ExprTy>;
229using Grainsize = tomp::clause::GrainsizeT<TypeTy, IdTy, ExprTy>;
230using HasDeviceAddr = tomp::clause::HasDeviceAddrT<TypeTy, IdTy, ExprTy>;
231using Hint = tomp::clause::HintT<TypeTy, IdTy, ExprTy>;
232using Holds = tomp::clause::HoldsT<TypeTy, IdTy, ExprTy>;
233using If = tomp::clause::IfT<TypeTy, IdTy, ExprTy>;
234using Inbranch = tomp::clause::InbranchT<TypeTy, IdTy, ExprTy>;
235using Inclusive = tomp::clause::InclusiveT<TypeTy, IdTy, ExprTy>;
236using Indirect = tomp::clause::IndirectT<TypeTy, IdTy, ExprTy>;
237using Init = tomp::clause::InitT<TypeTy, IdTy, ExprTy>;
238using Initializer = tomp::clause::InitializerT<TypeTy, IdTy, ExprTy>;
239using InReduction = tomp::clause::InReductionT<TypeTy, IdTy, ExprTy>;
240using IsDevicePtr = tomp::clause::IsDevicePtrT<TypeTy, IdTy, ExprTy>;
241using Lastprivate = tomp::clause::LastprivateT<TypeTy, IdTy, ExprTy>;
242using Linear = tomp::clause::LinearT<TypeTy, IdTy, ExprTy>;
243using Link = tomp::clause::LinkT<TypeTy, IdTy, ExprTy>;
244using Map = tomp::clause::MapT<TypeTy, IdTy, ExprTy>;
245using Match = tomp::clause::MatchT<TypeTy, IdTy, ExprTy>;
246using Mergeable = tomp::clause::MergeableT<TypeTy, IdTy, ExprTy>;
247using Message = tomp::clause::MessageT<TypeTy, IdTy, ExprTy>;
248using NoOpenmp = tomp::clause::NoOpenmpT<TypeTy, IdTy, ExprTy>;
249using NoOpenmpRoutines = tomp::clause::NoOpenmpRoutinesT<TypeTy, IdTy, ExprTy>;
250using NoOpenmpConstructs =
251 tomp::clause::NoOpenmpConstructsT<TypeTy, IdTy, ExprTy>;
252using NoParallelism = tomp::clause::NoParallelismT<TypeTy, IdTy, ExprTy>;
253using Nocontext = tomp::clause::NocontextT<TypeTy, IdTy, ExprTy>;
254using Nogroup = tomp::clause::NogroupT<TypeTy, IdTy, ExprTy>;
255using Nontemporal = tomp::clause::NontemporalT<TypeTy, IdTy, ExprTy>;
256using Notinbranch = tomp::clause::NotinbranchT<TypeTy, IdTy, ExprTy>;
257using Novariants = tomp::clause::NovariantsT<TypeTy, IdTy, ExprTy>;
258using Nowait = tomp::clause::NowaitT<TypeTy, IdTy, ExprTy>;
259using NumTasks = tomp::clause::NumTasksT<TypeTy, IdTy, ExprTy>;
260using NumTeams = tomp::clause::NumTeamsT<TypeTy, IdTy, ExprTy>;
261using NumThreads = tomp::clause::NumThreadsT<TypeTy, IdTy, ExprTy>;
262using OmpxAttribute = tomp::clause::OmpxAttributeT<TypeTy, IdTy, ExprTy>;
263using OmpxBare = tomp::clause::OmpxBareT<TypeTy, IdTy, ExprTy>;
264using OmpxDynCgroupMem = tomp::clause::OmpxDynCgroupMemT<TypeTy, IdTy, ExprTy>;
265using Ordered = tomp::clause::OrderedT<TypeTy, IdTy, ExprTy>;
266using Order = tomp::clause::OrderT<TypeTy, IdTy, ExprTy>;
267using Otherwise = tomp::clause::OtherwiseT<TypeTy, IdTy, ExprTy>;
268using Partial = tomp::clause::PartialT<TypeTy, IdTy, ExprTy>;
269using Priority = tomp::clause::PriorityT<TypeTy, IdTy, ExprTy>;
270using Private = tomp::clause::PrivateT<TypeTy, IdTy, ExprTy>;
271using ProcBind = tomp::clause::ProcBindT<TypeTy, IdTy, ExprTy>;
272using Read = tomp::clause::ReadT<TypeTy, IdTy, ExprTy>;
273using Reduction = tomp::clause::ReductionT<TypeTy, IdTy, ExprTy>;
274using Relaxed = tomp::clause::RelaxedT<TypeTy, IdTy, ExprTy>;
275using Release = tomp::clause::ReleaseT<TypeTy, IdTy, ExprTy>;
276using ReverseOffload = tomp::clause::ReverseOffloadT<TypeTy, IdTy, ExprTy>;
277using Safelen = tomp::clause::SafelenT<TypeTy, IdTy, ExprTy>;
278using Schedule = tomp::clause::ScheduleT<TypeTy, IdTy, ExprTy>;
279using SeqCst = tomp::clause::SeqCstT<TypeTy, IdTy, ExprTy>;
280using Severity = tomp::clause::SeverityT<TypeTy, IdTy, ExprTy>;
281using Shared = tomp::clause::SharedT<TypeTy, IdTy, ExprTy>;
282using Simdlen = tomp::clause::SimdlenT<TypeTy, IdTy, ExprTy>;
283using Simd = tomp::clause::SimdT<TypeTy, IdTy, ExprTy>;
284using Sizes = tomp::clause::SizesT<TypeTy, IdTy, ExprTy>;
285using Permutation = tomp::clause::PermutationT<TypeTy, IdTy, ExprTy>;
286using TaskReduction = tomp::clause::TaskReductionT<TypeTy, IdTy, ExprTy>;
287using ThreadLimit = tomp::clause::ThreadLimitT<TypeTy, IdTy, ExprTy>;
288using Threads = tomp::clause::ThreadsT<TypeTy, IdTy, ExprTy>;
289using To = tomp::clause::ToT<TypeTy, IdTy, ExprTy>;
290using UnifiedAddress = tomp::clause::UnifiedAddressT<TypeTy, IdTy, ExprTy>;
291using UnifiedSharedMemory =
292 tomp::clause::UnifiedSharedMemoryT<TypeTy, IdTy, ExprTy>;
293using SelfMaps = tomp::clause::SelfMapsT<TypeTy, IdTy, ExprTy>;
294using Uniform = tomp::clause::UniformT<TypeTy, IdTy, ExprTy>;
295using Unknown = tomp::clause::UnknownT<TypeTy, IdTy, ExprTy>;
296using Untied = tomp::clause::UntiedT<TypeTy, IdTy, ExprTy>;
297using Update = tomp::clause::UpdateT<TypeTy, IdTy, ExprTy>;
298using UseDeviceAddr = tomp::clause::UseDeviceAddrT<TypeTy, IdTy, ExprTy>;
299using UseDevicePtr = tomp::clause::UseDevicePtrT<TypeTy, IdTy, ExprTy>;
300using UsesAllocators = tomp::clause::UsesAllocatorsT<TypeTy, IdTy, ExprTy>;
301using Use = tomp::clause::UseT<TypeTy, IdTy, ExprTy>;
302using Weak = tomp::clause::WeakT<TypeTy, IdTy, ExprTy>;
303using When = tomp::clause::WhenT<TypeTy, IdTy, ExprTy>;
304using Write = tomp::clause::WriteT<TypeTy, IdTy, ExprTy>;
305} // namespace clause
306
307using tomp::type::operator==;
308
309struct CancellationConstructType {
310 using WrapperTrait = std::true_type;
311 llvm::omp::CancellationConstructType v;
312};
313struct Depobj {
314 using EmptyTrait = std::true_type;
315};
316struct Flush {
317 using EmptyTrait = std::true_type;
318};
319struct MemoryOrder {
320 using EmptyTrait = std::true_type;
321};
322struct Threadprivate {
323 using EmptyTrait = std::true_type;
324};
325
326using ClauseBase = tomp::ClauseT<TypeTy, IdTy, ExprTy,
327 // Extras...
328 CancellationConstructType, Depobj, Flush,
329 MemoryOrder, Threadprivate>;
330
331struct Clause : public ClauseBase {
332 Clause(ClauseBase &&base, const parser::CharBlock source = {})
333 : ClauseBase(std::move(base)), source(source) {}
334 // "source" will be ignored by tomp::type::operator==.
335 parser::CharBlock source;
336};
337
338template <typename Specific>
339Clause makeClause(llvm::omp::Clause id, Specific &&specific,
340 parser::CharBlock source = {}) {
341 return Clause(typename Clause::BaseT{id, specific}, source);
342}
343
344Clause makeClause(const parser::OmpClause &cls,
345 semantics::SemanticsContext &semaCtx);
346
347List<Clause> makeClauses(const parser::OmpClauseList &clauses,
348 semantics::SemanticsContext &semaCtx);
349
350bool transferLocations(const List<Clause> &from, List<Clause> &to);
351} // namespace Fortran::lower::omp
352
353#endif // FORTRAN_LOWER_OPENMP_CLAUSES_H
354

source code of flang/lib/Lower/OpenMP/Clauses.h