3d3fab17f5
The ALLOCATE directive has two forms:
- A declarative form with a standalone directive:
```
!$OMP ALLOCATE (variable-list-item...)
```
- An executable form that consists of several directives followed by an
ALLOCATE statement:
```
!$OMP ALLOCATE (variable-list-item...)
!$OMP ALLOCATE (variable-list-item...)
...
ALLOCATE (...)
```
The second form was deprecated in OpenMP 5.2 in favor of the ALLOCATORS
construct.
Since in the parse tree every type corresponding to a directive only
corresponds to a single directive, the executable form is represented by
a sequence of nested OmpAllocateDirectives, e.g.
```
!$OMP ALLOCATE(x)
!$OMP ALLOCATE(y)
ALLOCATE(x, y)
```
will become
```
OmpAllocateDirective
|- ALLOCATE(x) // begin directive
`- OmpAllocateDirective // block
|- ALLOCATE(y) // begin directive
`- ALLOCATE(x, y) // block
```
With this change all AST nodes for directives use
OmpDirectiveSpecification as the directive representation.
129 lines
4.2 KiB
C++
129 lines
4.2 KiB
C++
//===-- flang/Parser/openmp-utils.cpp -------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Common OpenMP utilities.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "flang/Parser/openmp-utils.h"
|
|
|
|
#include "flang/Common/indirection.h"
|
|
#include "flang/Common/template.h"
|
|
#include "flang/Common/visit.h"
|
|
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <variant>
|
|
|
|
namespace Fortran::parser::omp {
|
|
|
|
const OpenMPDeclarativeConstruct *GetOmp(const DeclarationConstruct &x) {
|
|
if (auto *y = std::get_if<SpecificationConstruct>(&x.u)) {
|
|
if (auto *z{std::get_if<common::Indirection<OpenMPDeclarativeConstruct>>(
|
|
&y->u)}) {
|
|
return &z->value();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const OpenMPConstruct *GetOmp(const ExecutionPartConstruct &x) {
|
|
if (auto *y{std::get_if<ExecutableConstruct>(&x.u)}) {
|
|
if (auto *z{std::get_if<common::Indirection<OpenMPConstruct>>(&y->u)}) {
|
|
return &z->value();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const OmpObjectList *GetOmpObjectList(const OmpClause &clause) {
|
|
// Clauses with OmpObjectList as its data member
|
|
using MemberObjectListClauses = std::tuple<OmpClause::Copyin,
|
|
OmpClause::Copyprivate, OmpClause::Exclusive, OmpClause::Firstprivate,
|
|
OmpClause::HasDeviceAddr, OmpClause::Inclusive, OmpClause::IsDevicePtr,
|
|
OmpClause::Link, OmpClause::Private, OmpClause::Shared,
|
|
OmpClause::UseDeviceAddr, OmpClause::UseDevicePtr>;
|
|
|
|
// Clauses with OmpObjectList in the tuple
|
|
using TupleObjectListClauses = std::tuple<OmpClause::AdjustArgs,
|
|
OmpClause::Affinity, OmpClause::Aligned, OmpClause::Allocate,
|
|
OmpClause::Enter, OmpClause::From, OmpClause::InReduction,
|
|
OmpClause::Lastprivate, OmpClause::Linear, OmpClause::Map,
|
|
OmpClause::Reduction, OmpClause::TaskReduction, OmpClause::To>;
|
|
|
|
// TODO:: Generate the tuples using TableGen.
|
|
return common::visit(
|
|
common::visitors{
|
|
[&](const OmpClause::Depend &x) -> const OmpObjectList * {
|
|
if (auto *taskDep{std::get_if<OmpDependClause::TaskDep>(&x.v.u)}) {
|
|
return &std::get<OmpObjectList>(taskDep->t);
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
},
|
|
[&](const auto &x) -> const OmpObjectList * {
|
|
using Ty = std::decay_t<decltype(x)>;
|
|
if constexpr (common::HasMember<Ty, MemberObjectListClauses>) {
|
|
return &x.v;
|
|
} else if constexpr (common::HasMember<Ty,
|
|
TupleObjectListClauses>) {
|
|
return &std::get<OmpObjectList>(x.v.t);
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
},
|
|
},
|
|
clause.u);
|
|
}
|
|
|
|
const BlockConstruct *GetFortranBlockConstruct(
|
|
const ExecutionPartConstruct &epc) {
|
|
// ExecutionPartConstruct -> ExecutableConstruct
|
|
// -> Indirection<BlockConstruct>
|
|
if (auto *ec{std::get_if<ExecutableConstruct>(&epc.u)}) {
|
|
if (auto *ind{std::get_if<common::Indirection<BlockConstruct>>(&ec->u)}) {
|
|
return &ind->value();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const OmpCombinerExpression *GetCombinerExpr(
|
|
const OmpReductionSpecifier &rspec) {
|
|
return addr_if(std::get<std::optional<OmpCombinerExpression>>(rspec.t));
|
|
}
|
|
|
|
const OmpInitializerExpression *GetInitializerExpr(const OmpClause &init) {
|
|
if (auto *wrapped{std::get_if<OmpClause::Initializer>(&init.u)}) {
|
|
return &wrapped->v.v;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static void SplitOmpAllocateHelper(
|
|
OmpAllocateInfo &n, const OmpAllocateDirective &x) {
|
|
n.dirs.push_back(&x);
|
|
const Block &body{std::get<Block>(x.t)};
|
|
if (!body.empty()) {
|
|
if (auto *omp{GetOmp(body.front())}) {
|
|
if (auto *ad{std::get_if<OmpAllocateDirective>(&omp->u)}) {
|
|
return SplitOmpAllocateHelper(n, *ad);
|
|
}
|
|
}
|
|
n.body = &body.front();
|
|
}
|
|
}
|
|
|
|
OmpAllocateInfo SplitOmpAllocate(const OmpAllocateDirective &x) {
|
|
OmpAllocateInfo info;
|
|
SplitOmpAllocateHelper(info, x);
|
|
return info;
|
|
}
|
|
|
|
} // namespace Fortran::parser::omp
|