forked from OSchip/llvm-project
1157 lines
47 KiB
C++
1157 lines
47 KiB
C++
//===-- lib/Semantics/check-omp-structure.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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "check-omp-structure.h"
|
|
#include "flang/Parser/parse-tree.h"
|
|
#include "flang/Semantics/tools.h"
|
|
#include <unordered_map>
|
|
|
|
namespace Fortran::semantics {
|
|
|
|
static OmpClauseSet doAllowedClauses{llvm::omp::Clause::OMPC_private,
|
|
llvm::omp::Clause::OMPC_firstprivate, llvm::omp::Clause::OMPC_lastprivate,
|
|
llvm::omp::Clause::OMPC_linear, llvm::omp::Clause::OMPC_reduction};
|
|
static OmpClauseSet doAllowedOnceClauses{llvm::omp::Clause::OMPC_schedule,
|
|
llvm::omp::Clause::OMPC_collapse, llvm::omp::Clause::OMPC_ordered};
|
|
|
|
static OmpClauseSet simdAllowedClauses{llvm::omp::Clause::OMPC_linear,
|
|
llvm::omp::Clause::OMPC_aligned, llvm::omp::Clause::OMPC_private,
|
|
llvm::omp::Clause::OMPC_lastprivate, llvm::omp::Clause::OMPC_reduction};
|
|
static OmpClauseSet simdAllowedOnceClauses{llvm::omp::Clause::OMPC_collapse,
|
|
llvm::omp::Clause::OMPC_safelen, llvm::omp::Clause::OMPC_simdlen};
|
|
|
|
static OmpClauseSet parallelAllowedClauses{llvm::omp::Clause::OMPC_default,
|
|
llvm::omp::Clause::OMPC_private, llvm::omp::Clause::OMPC_firstprivate,
|
|
llvm::omp::Clause::OMPC_shared, llvm::omp::Clause::OMPC_copyin,
|
|
llvm::omp::Clause::OMPC_reduction};
|
|
static OmpClauseSet parallelAllowedOnceClauses{llvm::omp::Clause::OMPC_if,
|
|
llvm::omp::Clause::OMPC_num_threads, llvm::omp::Clause::OMPC_proc_bind};
|
|
|
|
static OmpClauseSet taskloopAllowedClauses{llvm::omp::Clause::OMPC_shared,
|
|
llvm::omp::Clause::OMPC_private, llvm::omp::Clause::OMPC_firstprivate,
|
|
llvm::omp::Clause::OMPC_lastprivate, llvm::omp::Clause::OMPC_default,
|
|
llvm::omp::Clause::OMPC_untied, llvm::omp::Clause::OMPC_mergeable,
|
|
llvm::omp::Clause::OMPC_nogroup};
|
|
static OmpClauseSet taskloopAllowedOnceClauses{llvm::omp::Clause::OMPC_collapse,
|
|
llvm::omp::Clause::OMPC_if, llvm::omp::Clause::OMPC_final,
|
|
llvm::omp::Clause::OMPC_priority};
|
|
static OmpClauseSet taskloopAllowedExclusiveClauses{
|
|
llvm::omp::Clause::OMPC_grainsize, llvm::omp::Clause::OMPC_num_tasks};
|
|
|
|
static OmpClauseSet distributeAllowedClauses{llvm::omp::Clause::OMPC_private,
|
|
llvm::omp::Clause::OMPC_firstprivate, llvm::omp::Clause::OMPC_lastprivate};
|
|
static OmpClauseSet distributeAllowedOnceClauses{
|
|
llvm::omp::Clause::OMPC_collapse, llvm::omp::Clause::OMPC_dist_schedule};
|
|
|
|
static OmpClauseSet targetAllowedClauses{llvm::omp::Clause::OMPC_if,
|
|
llvm::omp::Clause::OMPC_private, llvm::omp::Clause::OMPC_firstprivate,
|
|
llvm::omp::Clause::OMPC_map, llvm::omp::Clause::OMPC_is_device_ptr,
|
|
llvm::omp::Clause::OMPC_depend};
|
|
static OmpClauseSet targetAllowedOnceClauses{llvm::omp::Clause::OMPC_device,
|
|
llvm::omp::Clause::OMPC_defaultmap, llvm::omp::Clause::OMPC_nowait};
|
|
|
|
static OmpClauseSet teamsAllowedClauses{llvm::omp::Clause::OMPC_private,
|
|
llvm::omp::Clause::OMPC_firstprivate, llvm::omp::Clause::OMPC_shared,
|
|
llvm::omp::Clause::OMPC_reduction};
|
|
static OmpClauseSet teamsAllowedOnceClauses{llvm::omp::Clause::OMPC_num_teams,
|
|
llvm::omp::Clause::OMPC_thread_limit, llvm::omp::Clause::OMPC_default};
|
|
|
|
static OmpClauseSet sectionsAllowedClauses{llvm::omp::Clause::OMPC_private,
|
|
llvm::omp::Clause::OMPC_firstprivate, llvm::omp::Clause::OMPC_lastprivate,
|
|
llvm::omp::Clause::OMPC_reduction};
|
|
|
|
std::string OmpStructureChecker::ContextDirectiveAsFortran() {
|
|
auto dir = llvm::omp::getOpenMPDirectiveName(GetContext().directive).str();
|
|
std::transform(dir.begin(), dir.end(), dir.begin(),
|
|
[](unsigned char c) { return std::toupper(c); });
|
|
return dir;
|
|
}
|
|
|
|
void OmpStructureChecker::SayNotMatching(
|
|
const parser::CharBlock &beginSource, const parser::CharBlock &endSource) {
|
|
context_
|
|
.Say(endSource, "Unmatched %s directive"_err_en_US,
|
|
parser::ToUpperCaseLetters(endSource.ToString()))
|
|
.Attach(beginSource, "Does not match directive"_en_US);
|
|
}
|
|
|
|
bool OmpStructureChecker::HasInvalidWorksharingNesting(
|
|
const parser::CharBlock &source, const OmpDirectiveSet &set) {
|
|
// set contains all the invalid closely nested directives
|
|
// for the given directive (`source` here)
|
|
if (CurrentDirectiveIsNested() && set.test(GetContext().directive)) {
|
|
context_.Say(source,
|
|
"A worksharing region may not be closely nested inside a "
|
|
"worksharing, explicit task, taskloop, critical, ordered, atomic, or "
|
|
"master region"_err_en_US);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void OmpStructureChecker::CheckAllowed(llvm::omp::Clause type) {
|
|
if (!GetContext().allowedClauses.test(type) &&
|
|
!GetContext().allowedOnceClauses.test(type) &&
|
|
!GetContext().allowedExclusiveClauses.test(type)) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"%s clause is not allowed on the %s directive"_err_en_US,
|
|
parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(type).str()),
|
|
parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
|
|
return;
|
|
}
|
|
if ((GetContext().allowedOnceClauses.test(type) ||
|
|
GetContext().allowedExclusiveClauses.test(type)) &&
|
|
FindClause(type)) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"At most one %s clause can appear on the %s directive"_err_en_US,
|
|
parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(type).str()),
|
|
parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
|
|
return;
|
|
}
|
|
if (GetContext().allowedExclusiveClauses.test(type)) {
|
|
std::vector<llvm::omp::Clause> others;
|
|
GetContext().allowedExclusiveClauses.IterateOverMembers(
|
|
[&](llvm::omp::Clause o) {
|
|
if (FindClause(o)) {
|
|
others.emplace_back(o);
|
|
}
|
|
});
|
|
for (const auto &e : others) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"%s and %s are mutually exclusive and may not appear on the "
|
|
"same %s directive"_err_en_US,
|
|
parser::ToUpperCaseLetters(
|
|
llvm::omp::getOpenMPClauseName(type).str()),
|
|
parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(e).str()),
|
|
parser::ToUpperCaseLetters(GetContext().directiveSource.ToString()));
|
|
}
|
|
if (!others.empty()) {
|
|
return;
|
|
}
|
|
}
|
|
SetContextClauseInfo(type);
|
|
}
|
|
|
|
void OmpStructureChecker::CheckRequired(llvm::omp::Clause c) {
|
|
if (!FindClause(c)) {
|
|
context_.Say(GetContext().directiveSource,
|
|
"At least one %s clause must appear on the %s directive"_err_en_US,
|
|
parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(c).str()),
|
|
ContextDirectiveAsFortran());
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::RequiresConstantPositiveParameter(
|
|
const llvm::omp::Clause &clause, const parser::ScalarIntConstantExpr &i) {
|
|
if (const auto v{GetIntValue(i)}) {
|
|
if (*v <= 0) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"The parameter of the %s clause must be "
|
|
"a constant positive integer expression"_err_en_US,
|
|
parser::ToUpperCaseLetters(
|
|
llvm::omp::getOpenMPClauseName(clause).str()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::RequiresPositiveParameter(
|
|
const llvm::omp::Clause &clause, const parser::ScalarIntExpr &i) {
|
|
if (const auto v{GetIntValue(i)}) {
|
|
if (*v <= 0) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"The parameter of the %s clause must be "
|
|
"a positive integer expression"_err_en_US,
|
|
parser::ToUpperCaseLetters(
|
|
llvm::omp::getOpenMPClauseName(clause).str()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OpenMPConstruct &) {
|
|
// 2.8.1 TODO: Simd Construct with Ordered Construct Nesting check
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OpenMPLoopConstruct &x) {
|
|
const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
|
|
const auto &beginDir{std::get<parser::OmpLoopDirective>(beginLoopDir.t)};
|
|
|
|
// check matching, End directive is optional
|
|
if (const auto &endLoopDir{
|
|
std::get<std::optional<parser::OmpEndLoopDirective>>(x.t)}) {
|
|
CheckMatching<parser::OmpLoopDirective>(beginLoopDir, *endLoopDir);
|
|
}
|
|
|
|
if (beginDir.v != llvm::omp::Directive::OMPD_do)
|
|
PushContext(beginDir.source, beginDir.v);
|
|
|
|
switch (beginDir.v) {
|
|
// 2.7.1 do-clause -> private-clause |
|
|
// firstprivate-clause |
|
|
// lastprivate-clause |
|
|
// linear-clause |
|
|
// reduction-clause |
|
|
// schedule-clause |
|
|
// collapse-clause |
|
|
// ordered-clause
|
|
case llvm::omp::Directive::OMPD_do: {
|
|
// nesting check
|
|
HasInvalidWorksharingNesting(beginDir.source,
|
|
{llvm::omp::Directive::OMPD_do, llvm::omp::Directive::OMPD_sections,
|
|
llvm::omp::Directive::OMPD_single,
|
|
llvm::omp::Directive::OMPD_workshare,
|
|
llvm::omp::Directive::OMPD_task,
|
|
llvm::omp::Directive::OMPD_taskloop,
|
|
llvm::omp::Directive::OMPD_critical,
|
|
llvm::omp::Directive::OMPD_ordered,
|
|
llvm::omp::Directive::OMPD_atomic,
|
|
llvm::omp::Directive::OMPD_master});
|
|
PushContext(beginDir.source, llvm::omp::Directive::OMPD_do);
|
|
SetContextAllowed(doAllowedClauses);
|
|
SetContextAllowedOnce(doAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.11.1 parallel-do-clause -> parallel-clause |
|
|
// do-clause
|
|
case llvm::omp::Directive::OMPD_parallel_do: {
|
|
SetContextAllowed(parallelAllowedClauses | doAllowedClauses);
|
|
SetContextAllowedOnce(parallelAllowedOnceClauses | doAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.8.1 simd-clause -> safelen-clause |
|
|
// simdlen-clause |
|
|
// linear-clause |
|
|
// aligned-clause |
|
|
// private-clause |
|
|
// lastprivate-clause |
|
|
// reduction-clause |
|
|
// collapse-clause
|
|
case llvm::omp::Directive::OMPD_simd: {
|
|
SetContextAllowed(simdAllowedClauses);
|
|
SetContextAllowedOnce(simdAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.8.3 do-simd-clause -> do-clause |
|
|
// simd-clause
|
|
case llvm::omp::Directive::OMPD_do_simd: {
|
|
SetContextAllowed(doAllowedClauses | simdAllowedClauses);
|
|
SetContextAllowedOnce(doAllowedOnceClauses | simdAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.11.4 parallel-do-simd-clause -> parallel-clause |
|
|
// do-simd-clause
|
|
case llvm::omp::Directive::OMPD_parallel_do_simd: {
|
|
SetContextAllowed(
|
|
parallelAllowedClauses | doAllowedClauses | simdAllowedClauses);
|
|
SetContextAllowedOnce(parallelAllowedOnceClauses | doAllowedOnceClauses |
|
|
simdAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.9.2 taskloop-clause -> if-clause |
|
|
// shared-clause |
|
|
// private-clause |
|
|
// firstprivate-clause |
|
|
// lastprivate-clause |
|
|
// default-clause |
|
|
// grainsize-clause |
|
|
// num-tasks-clause |
|
|
// collapse-clause |
|
|
// final-clause |
|
|
// priority-clause |
|
|
// untied-clause |
|
|
// mergeable-clause |
|
|
// nogroup-clause
|
|
case llvm::omp::Directive::OMPD_taskloop: {
|
|
SetContextAllowed(taskloopAllowedClauses);
|
|
SetContextAllowedOnce(taskloopAllowedOnceClauses);
|
|
SetContextAllowedExclusive(taskloopAllowedExclusiveClauses);
|
|
} break;
|
|
|
|
// 2.9.3 taskloop-simd-clause -> taskloop-clause |
|
|
// simd-clause
|
|
case llvm::omp::Directive::OMPD_taskloop_simd: {
|
|
SetContextAllowed((taskloopAllowedClauses | simdAllowedClauses) -
|
|
llvm::omp::Clause::OMPC_reduction);
|
|
SetContextAllowedOnce(taskloopAllowedOnceClauses | simdAllowedOnceClauses);
|
|
SetContextAllowedExclusive(taskloopAllowedExclusiveClauses);
|
|
} break;
|
|
|
|
// 2.10.8 distribute-clause -> private-clause |
|
|
// firstprivate-clause |
|
|
// lastprivate-clause |
|
|
// collapse-clause |
|
|
// dist-schedule-clause
|
|
case llvm::omp::Directive::OMPD_distribute: {
|
|
SetContextAllowed(distributeAllowedClauses);
|
|
SetContextAllowedOnce(distributeAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.10.9 distribute-simd-clause -> distribute-clause |
|
|
// simd-clause
|
|
case llvm::omp::Directive::OMPD_distribute_simd: {
|
|
SetContextAllowed(distributeAllowedClauses | simdAllowedClauses);
|
|
SetContextAllowedOnce(
|
|
distributeAllowedOnceClauses | simdAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.10.10 distribute-parallel-do-clause -> distribute-clause |
|
|
// parallel-do-clause
|
|
case llvm::omp::Directive::OMPD_distribute_parallel_do: {
|
|
SetContextAllowed(
|
|
distributeAllowedClauses | parallelAllowedClauses | doAllowedClauses);
|
|
SetContextAllowedOnce(distributeAllowedOnceClauses |
|
|
parallelAllowedOnceClauses | doAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.10.11 distribute-parallel-do-simd-clause -> distribute-clause |
|
|
// parallel-do-simd-clause
|
|
case llvm::omp::Directive::OMPD_distribute_parallel_do_simd: {
|
|
SetContextAllowed(distributeAllowedClauses | parallelAllowedClauses |
|
|
doAllowedClauses | simdAllowedClauses);
|
|
SetContextAllowedOnce(distributeAllowedOnceClauses |
|
|
parallelAllowedOnceClauses | doAllowedOnceClauses | simdAllowedClauses);
|
|
} break;
|
|
|
|
// 2.11.6 target-parallel-do-clause -> target-clause |
|
|
// parallel-do-clause
|
|
case llvm::omp::Directive::OMPD_target_parallel_do: {
|
|
SetContextAllowed(
|
|
targetAllowedClauses | parallelAllowedClauses | doAllowedClauses);
|
|
SetContextAllowedOnce(
|
|
(targetAllowedOnceClauses | parallelAllowedOnceClauses |
|
|
doAllowedOnceClauses) -
|
|
llvm::omp::Clause::OMPC_nowait);
|
|
} break;
|
|
|
|
// 2.11.7 target-parallel-do-simd-clause -> target-clause |
|
|
// parallel-do-simd-clause
|
|
case llvm::omp::Directive::OMPD_target_parallel_do_simd: {
|
|
SetContextAllowed(targetAllowedClauses | parallelAllowedClauses |
|
|
doAllowedClauses | simdAllowedClauses);
|
|
SetContextAllowedOnce(
|
|
(targetAllowedOnceClauses | parallelAllowedOnceClauses |
|
|
doAllowedOnceClauses | simdAllowedOnceClauses) -
|
|
llvm::omp::Clause::OMPC_nowait);
|
|
} break;
|
|
|
|
// 2.11.8 target-simd-clause -> target-clause |
|
|
// simd-clause
|
|
case llvm::omp::Directive::OMPD_target_simd: {
|
|
SetContextAllowed(targetAllowedClauses | simdAllowedClauses);
|
|
SetContextAllowedOnce(targetAllowedOnceClauses | simdAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.11.10 teams-distribute-clause -> teams-clause |
|
|
// distribute-clause
|
|
case llvm::omp::Directive::OMPD_teams_distribute: {
|
|
SetContextAllowed(teamsAllowedClauses | distributeAllowedClauses);
|
|
SetContextAllowedOnce(
|
|
teamsAllowedOnceClauses | distributeAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.11.11 teams-distribute-simd-clause -> teams-clause |
|
|
// distribute-simd-clause
|
|
case llvm::omp::Directive::OMPD_teams_distribute_simd: {
|
|
SetContextAllowed(
|
|
teamsAllowedClauses | distributeAllowedClauses | simdAllowedClauses);
|
|
SetContextAllowedOnce(teamsAllowedOnceClauses |
|
|
distributeAllowedOnceClauses | simdAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.11.12 target-teams-distribute-clause -> target-clause |
|
|
// teams-distribute-clause
|
|
case llvm::omp::Directive::OMPD_target_teams_distribute: {
|
|
SetContextAllowed(
|
|
targetAllowedClauses | teamsAllowedClauses | distributeAllowedClauses);
|
|
SetContextAllowedOnce(targetAllowedOnceClauses | teamsAllowedOnceClauses |
|
|
distributeAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.11.13 target-teams-distribute-simd-clause -> target-clause |
|
|
// teams-distribute-simd-clause
|
|
case llvm::omp::Directive::OMPD_target_teams_distribute_simd: {
|
|
SetContextAllowed(targetAllowedClauses | teamsAllowedClauses |
|
|
distributeAllowedClauses | simdAllowedClauses);
|
|
SetContextAllowed(targetAllowedOnceClauses | teamsAllowedOnceClauses |
|
|
distributeAllowedOnceClauses | simdAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.11.14 teams-distribute-parallel-do-clause -> teams-clause |
|
|
// distribute-parallel-do-clause
|
|
case llvm::omp::Directive::OMPD_teams_distribute_parallel_do: {
|
|
SetContextAllowed(teamsAllowedClauses | distributeAllowedClauses |
|
|
parallelAllowedClauses | doAllowedClauses);
|
|
SetContextAllowedOnce(teamsAllowedOnceClauses |
|
|
distributeAllowedOnceClauses | parallelAllowedOnceClauses |
|
|
doAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.11.15 target-teams-distribute-parallel-do-clause -> target-clause |
|
|
// teams-distribute-parallel-do-clause
|
|
case llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do: {
|
|
SetContextAllowed(targetAllowedClauses | teamsAllowedClauses |
|
|
distributeAllowedClauses | parallelAllowedClauses | doAllowedClauses);
|
|
SetContextAllowedOnce(targetAllowedOnceClauses | teamsAllowedOnceClauses |
|
|
distributeAllowedOnceClauses | parallelAllowedOnceClauses |
|
|
doAllowedOnceClauses);
|
|
} break;
|
|
|
|
// 2.11.16 teams-distribute-parallel-do-clause -> teams-clause |
|
|
// distribute-parallel-do-simd-clause
|
|
case llvm::omp::Directive::OMPD_teams_distribute_parallel_do_simd: {
|
|
SetContextAllowed(teamsAllowedClauses | distributeAllowedClauses |
|
|
parallelAllowedClauses | doAllowedClauses | simdAllowedClauses);
|
|
SetContextAllowedOnce(teamsAllowedOnceClauses |
|
|
distributeAllowedOnceClauses | parallelAllowedOnceClauses |
|
|
doAllowedOnceClauses | simdAllowedOnceClauses);
|
|
} break;
|
|
|
|
case llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd: {
|
|
SetContextAllowed(targetAllowedClauses | teamsAllowedClauses |
|
|
distributeAllowedClauses | parallelAllowedClauses | doAllowedClauses |
|
|
simdAllowedClauses);
|
|
SetContextAllowedOnce(targetAllowedOnceClauses | teamsAllowedOnceClauses |
|
|
distributeAllowedOnceClauses | parallelAllowedOnceClauses |
|
|
doAllowedOnceClauses | simdAllowedOnceClauses);
|
|
} break;
|
|
|
|
default:
|
|
// TODO others
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &) {
|
|
ompContext_.pop_back();
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpEndLoopDirective &x) {
|
|
const auto &dir{std::get<parser::OmpLoopDirective>(x.t)};
|
|
ResetPartialContext(dir.source);
|
|
switch (dir.v) {
|
|
// 2.7.1 end-do -> END DO [nowait-clause]
|
|
// 2.8.3 end-do-simd -> END DO SIMD [nowait-clause]
|
|
case llvm::omp::Directive::OMPD_do:
|
|
SetContextDirectiveEnum(llvm::omp::Directive::OMPD_end_do);
|
|
SetContextAllowed(OmpClauseSet{llvm::omp::Clause::OMPC_nowait});
|
|
break;
|
|
case llvm::omp::Directive::OMPD_do_simd:
|
|
SetContextDirectiveEnum(llvm::omp::Directive::OMPD_end_do_simd);
|
|
SetContextAllowed(OmpClauseSet{llvm::omp::Clause::OMPC_nowait});
|
|
break;
|
|
default:
|
|
// no clauses are allowed
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OpenMPBlockConstruct &x) {
|
|
const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
|
|
const auto &endBlockDir{std::get<parser::OmpEndBlockDirective>(x.t)};
|
|
const auto &beginDir{
|
|
CheckMatching<parser::OmpBlockDirective>(beginBlockDir, endBlockDir)};
|
|
|
|
PushContext(beginDir.source, beginDir.v);
|
|
switch (beginDir.v) {
|
|
// 2.5 parallel-clause -> if-clause |
|
|
// num-threads-clause |
|
|
// default-clause |
|
|
// private-clause |
|
|
// firstprivate-clause |
|
|
// shared-clause |
|
|
// copyin-clause |
|
|
// reduction-clause |
|
|
// proc-bind-clause
|
|
case llvm::omp::Directive::OMPD_parallel: {
|
|
// reserve for nesting check
|
|
SetContextAllowed(parallelAllowedClauses);
|
|
SetContextAllowedOnce(parallelAllowedOnceClauses);
|
|
} break;
|
|
// 2.7.3 single-clause -> private-clause |
|
|
// firstprivate-clause
|
|
case llvm::omp::Directive::OMPD_single:
|
|
SetContextAllowed({llvm::omp::Clause::OMPC_private,
|
|
llvm::omp::Clause::OMPC_firstprivate});
|
|
break;
|
|
// 2.7.4 workshare (no clauses are allowed)
|
|
case llvm::omp::Directive::OMPD_workshare:
|
|
break;
|
|
// 2.11.3 parallel-workshare-clause -> parallel-clause
|
|
case llvm::omp::Directive::OMPD_parallel_workshare: {
|
|
SetContextAllowed(parallelAllowedClauses);
|
|
SetContextAllowedOnce(parallelAllowedOnceClauses);
|
|
} break;
|
|
// 2.9.1 task-clause -> if-clause |
|
|
// final-clause |
|
|
// untied-clause |
|
|
// default-clause |
|
|
// mergeable-clause |
|
|
// private-clause |
|
|
// firstprivate-clause |
|
|
// shared-clause |
|
|
// depend-clause |
|
|
// priority-clause
|
|
case llvm::omp::Directive::OMPD_task: {
|
|
OmpClauseSet allowed{llvm::omp::Clause::OMPC_untied,
|
|
llvm::omp::Clause::OMPC_default, llvm::omp::Clause::OMPC_mergeable,
|
|
llvm::omp::Clause::OMPC_private, llvm::omp::Clause::OMPC_firstprivate,
|
|
llvm::omp::Clause::OMPC_shared, llvm::omp::Clause::OMPC_depend};
|
|
SetContextAllowed(allowed);
|
|
OmpClauseSet allowedOnce{llvm::omp::Clause::OMPC_if,
|
|
llvm::omp::Clause::OMPC_final, llvm::omp::Clause::OMPC_priority};
|
|
SetContextAllowedOnce(allowedOnce);
|
|
} break;
|
|
// 2.10.4 target-clause -> if-clause |
|
|
// device-clause |
|
|
// private-clause |
|
|
// firstprivate-clause |
|
|
// map-clause |
|
|
// is-device-ptr-clause |
|
|
// defaultmap-clause |
|
|
// nowait-clause |
|
|
// depend-clause
|
|
case llvm::omp::Directive::OMPD_target: {
|
|
SetContextAllowed(targetAllowedClauses);
|
|
SetContextAllowedOnce(targetAllowedOnceClauses);
|
|
} break;
|
|
// 2.10.7 teams-clause -> num-teams-clause |
|
|
// thread-limit-clause |
|
|
// default-clause |
|
|
// private-clause |
|
|
// firstprivate-clause |
|
|
// shared-clause |
|
|
// reduction-clause
|
|
case llvm::omp::Directive::OMPD_teams: {
|
|
SetContextAllowed(teamsAllowedClauses);
|
|
SetContextAllowedOnce(teamsAllowedOnceClauses);
|
|
} break;
|
|
// 2.11.9 target-teams -> target-clause |
|
|
// teams-clause
|
|
case llvm::omp::Directive::OMPD_target_teams: {
|
|
SetContextAllowed(targetAllowedClauses | teamsAllowedClauses);
|
|
SetContextAllowedOnce(targetAllowedOnceClauses | teamsAllowedOnceClauses);
|
|
} break;
|
|
// 2.10.1 target-data-clause -> if-clause |
|
|
// device-clause |
|
|
// map-clause |
|
|
// use-device-ptr-clause
|
|
case llvm::omp::Directive::OMPD_target_data: {
|
|
OmpClauseSet allowed{llvm::omp::Clause::OMPC_if,
|
|
llvm::omp::Clause::OMPC_map, llvm::omp::Clause::OMPC_use_device_ptr};
|
|
SetContextAllowed(allowed);
|
|
SetContextAllowedOnce({llvm::omp::Clause::OMPC_device});
|
|
SetContextRequired({llvm::omp::Clause::OMPC_map});
|
|
} break;
|
|
// 2.13.1 master (no clauses are allowed)
|
|
case llvm::omp::Directive::OMPD_master:
|
|
break;
|
|
// 2.11.5 target-parallel-clause -> target-clause |
|
|
// parallel-clause
|
|
case llvm::omp::Directive::OMPD_target_parallel: {
|
|
SetContextAllowed((targetAllowedClauses | parallelAllowedClauses) -
|
|
llvm::omp::Clause::OMPC_copyin);
|
|
SetContextAllowedOnce(
|
|
targetAllowedOnceClauses | parallelAllowedOnceClauses);
|
|
} break;
|
|
default:
|
|
// TODO others
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(const parser::OpenMPBlockConstruct &) {
|
|
ompContext_.pop_back();
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OpenMPSectionsConstruct &x) {
|
|
const auto &beginSectionsDir{
|
|
std::get<parser::OmpBeginSectionsDirective>(x.t)};
|
|
const auto &endSectionsDir{std::get<parser::OmpEndSectionsDirective>(x.t)};
|
|
const auto &beginDir{CheckMatching<parser::OmpSectionsDirective>(
|
|
beginSectionsDir, endSectionsDir)};
|
|
|
|
PushContext(beginDir.source, beginDir.v);
|
|
switch (beginDir.v) {
|
|
// 2.7.2 sections-clause -> private-clause |
|
|
// firstprivate-clause |
|
|
// lastprivate-clause |
|
|
// reduction-clause
|
|
case llvm::omp::Directive::OMPD_sections: {
|
|
SetContextAllowed(sectionsAllowedClauses);
|
|
} break;
|
|
// 2.11.2 -> parallel-sections-clause -> parallel-clause |
|
|
// sections-clause
|
|
case llvm::omp::Directive::OMPD_parallel_sections: {
|
|
SetContextAllowed(parallelAllowedClauses | sectionsAllowedClauses);
|
|
SetContextAllowedOnce(parallelAllowedOnceClauses);
|
|
} break;
|
|
default:
|
|
// TODO others
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(const parser::OpenMPSectionsConstruct &) {
|
|
ompContext_.pop_back();
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpEndSectionsDirective &x) {
|
|
const auto &dir{std::get<parser::OmpSectionsDirective>(x.t)};
|
|
ResetPartialContext(dir.source);
|
|
switch (dir.v) {
|
|
// 2.7.2 end-sections -> END SECTIONS [nowait-clause]
|
|
case llvm::omp::Directive::OMPD_sections:
|
|
SetContextDirectiveEnum(llvm::omp::Directive::OMPD_end_sections);
|
|
SetContextAllowed(OmpClauseSet{llvm::omp::Clause::OMPC_nowait});
|
|
break;
|
|
default:
|
|
// no clauses are allowed
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OpenMPDeclareSimdConstruct &x) {
|
|
const auto &dir{std::get<parser::Verbatim>(x.t)};
|
|
PushContext(dir.source, llvm::omp::Directive::OMPD_declare_simd);
|
|
// 2.8.2 declare-simd-clause -> simdlen-clause |
|
|
// linear-clause |
|
|
// aligned-clause |
|
|
// uniform-clause |
|
|
// inbranch-clause |
|
|
// notinbranch-clause
|
|
OmpClauseSet allowed{llvm::omp::Clause::OMPC_linear,
|
|
llvm::omp::Clause::OMPC_aligned, llvm::omp::Clause::OMPC_uniform};
|
|
SetContextAllowed(allowed);
|
|
SetContextAllowedOnce({llvm::omp::Clause::OMPC_simdlen});
|
|
SetContextAllowedExclusive(
|
|
{llvm::omp::Clause::OMPC_inbranch, llvm::omp::Clause::OMPC_notinbranch});
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(const parser::OpenMPDeclareSimdConstruct &) {
|
|
ompContext_.pop_back();
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OpenMPDeclareTargetConstruct &x) {
|
|
const auto &dir{std::get<parser::Verbatim>(x.t)};
|
|
PushContext(dir.source, llvm::omp::Directive::OMPD_declare_target);
|
|
const auto &spec{std::get<parser::OmpDeclareTargetSpecifier>(x.t)};
|
|
if (std::holds_alternative<parser::OmpDeclareTargetWithClause>(spec.u)) {
|
|
SetContextAllowed(
|
|
OmpClauseSet{llvm::omp::Clause::OMPC_to, llvm::omp::Clause::OMPC_link});
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(const parser::OpenMPDeclareTargetConstruct &) {
|
|
ompContext_.pop_back();
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(
|
|
const parser::OpenMPSimpleStandaloneConstruct &x) {
|
|
const auto &dir{std::get<parser::OmpSimpleStandaloneDirective>(x.t)};
|
|
PushContext(dir.source, dir.v);
|
|
switch (dir.v) {
|
|
case llvm::omp::Directive::OMPD_barrier: {
|
|
// 2.13.3 barrier
|
|
} break;
|
|
case llvm::omp::Directive::OMPD_taskwait: {
|
|
// 2.13.4 taskwait
|
|
} break;
|
|
case llvm::omp::Directive::OMPD_taskyield: {
|
|
// 2.9.4 taskyield
|
|
} break;
|
|
case llvm::omp::Directive::OMPD_target_enter_data: {
|
|
// 2.10.2 target-enter-data-clause -> if-clause |
|
|
// device-clause |
|
|
// map-clause |
|
|
// depend-clause |
|
|
// nowait-clause
|
|
OmpClauseSet allowed{llvm::omp::Clause::OMPC_map,
|
|
llvm::omp::Clause::OMPC_depend, llvm::omp::Clause::OMPC_nowait};
|
|
SetContextAllowed(allowed);
|
|
OmpClauseSet allowedOnce{
|
|
llvm::omp::Clause::OMPC_device, llvm::omp::Clause::OMPC_if};
|
|
SetContextAllowedOnce(allowedOnce);
|
|
SetContextRequired({llvm::omp::Clause::OMPC_map});
|
|
} break;
|
|
case llvm::omp::Directive::OMPD_target_exit_data: {
|
|
// 2.10.3 target-enter-data-clause -> if-clause |
|
|
// device-clause |
|
|
// map-clause |
|
|
// depend-clause |
|
|
// nowait-clause
|
|
OmpClauseSet allowed{llvm::omp::Clause::OMPC_map,
|
|
llvm::omp::Clause::OMPC_depend, llvm::omp::Clause::OMPC_nowait};
|
|
SetContextAllowed(allowed);
|
|
OmpClauseSet allowedOnce{
|
|
llvm::omp::Clause::OMPC_device, llvm::omp::Clause::OMPC_if};
|
|
SetContextAllowedOnce(allowedOnce);
|
|
SetContextRequired({llvm::omp::Clause::OMPC_map});
|
|
} break;
|
|
case llvm::omp::Directive::OMPD_target_update: {
|
|
// 2.10.5 target-update
|
|
} break;
|
|
case llvm::omp::Directive::OMPD_ordered: {
|
|
// 2.13.8 ordered-construct-clause -> depend-clause
|
|
OmpClauseSet allowed{llvm::omp::Clause::OMPC_depend};
|
|
SetContextAllowed(allowed);
|
|
} break;
|
|
default:
|
|
// TODO others
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(
|
|
const parser::OpenMPSimpleStandaloneConstruct &) {
|
|
ompContext_.pop_back();
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OpenMPFlushConstruct &x) {
|
|
const auto &dir{std::get<parser::Verbatim>(x.t)};
|
|
PushContext(dir.source, llvm::omp::Directive::OMPD_flush);
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(const parser::OpenMPFlushConstruct &) {
|
|
ompContext_.pop_back();
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OpenMPCancelConstruct &x) {
|
|
const auto &dir{std::get<parser::Verbatim>(x.t)};
|
|
PushContext(dir.source, llvm::omp::Directive::OMPD_cancel);
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(const parser::OpenMPCancelConstruct &) {
|
|
ompContext_.pop_back();
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(
|
|
const parser::OpenMPCancellationPointConstruct &x) {
|
|
const auto &dir{std::get<parser::Verbatim>(x.t)};
|
|
PushContext(dir.source, llvm::omp::Directive::OMPD_cancellation_point);
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(
|
|
const parser::OpenMPCancellationPointConstruct &) {
|
|
ompContext_.pop_back();
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpEndBlockDirective &x) {
|
|
const auto &dir{std::get<parser::OmpBlockDirective>(x.t)};
|
|
ResetPartialContext(dir.source);
|
|
switch (dir.v) {
|
|
// 2.7.3 end-single-clause -> copyprivate-clause |
|
|
// nowait-clause
|
|
case llvm::omp::Directive::OMPD_single: {
|
|
SetContextDirectiveEnum(llvm::omp::Directive::OMPD_end_single);
|
|
OmpClauseSet allowed{llvm::omp::Clause::OMPC_copyprivate};
|
|
SetContextAllowed(allowed);
|
|
OmpClauseSet allowedOnce{llvm::omp::Clause::OMPC_nowait};
|
|
SetContextAllowedOnce(allowedOnce);
|
|
} break;
|
|
// 2.7.4 end-workshare -> END WORKSHARE [nowait-clause]
|
|
case llvm::omp::Directive::OMPD_workshare:
|
|
SetContextDirectiveEnum(llvm::omp::Directive::OMPD_end_workshare);
|
|
SetContextAllowed(OmpClauseSet{llvm::omp::Clause::OMPC_nowait});
|
|
break;
|
|
default:
|
|
// no clauses are allowed
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Leave(const parser::OmpClauseList &) {
|
|
// 2.7 Loop Construct Restriction
|
|
if (llvm::omp::doSet.test(GetContext().directive)) {
|
|
if (auto *clause{FindClause(llvm::omp::Clause::OMPC_schedule)}) {
|
|
// only one schedule clause is allowed
|
|
const auto &schedClause{std::get<parser::OmpScheduleClause>(clause->u)};
|
|
if (ScheduleModifierHasType(schedClause,
|
|
parser::OmpScheduleModifierType::ModType::Nonmonotonic)) {
|
|
if (FindClause(llvm::omp::Clause::OMPC_ordered)) {
|
|
context_.Say(clause->source,
|
|
"The NONMONOTONIC modifier cannot be specified "
|
|
"if an ORDERED clause is specified"_err_en_US);
|
|
}
|
|
if (ScheduleModifierHasType(schedClause,
|
|
parser::OmpScheduleModifierType::ModType::Monotonic)) {
|
|
context_.Say(clause->source,
|
|
"The MONOTONIC and NONMONOTONIC modifiers "
|
|
"cannot be both specified"_err_en_US);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (auto *clause{FindClause(llvm::omp::Clause::OMPC_ordered)}) {
|
|
// only one ordered clause is allowed
|
|
const auto &orderedClause{
|
|
std::get<parser::OmpClause::Ordered>(clause->u)};
|
|
|
|
if (orderedClause.v) {
|
|
if (FindClause(llvm::omp::Clause::OMPC_linear)) {
|
|
context_.Say(clause->source,
|
|
"A loop directive may not have both a LINEAR clause and "
|
|
"an ORDERED clause with a parameter"_err_en_US);
|
|
}
|
|
|
|
if (auto *clause2{FindClause(llvm::omp::Clause::OMPC_collapse)}) {
|
|
const auto &collapseClause{
|
|
std::get<parser::OmpClause::Collapse>(clause2->u)};
|
|
// ordered and collapse both have parameters
|
|
if (const auto orderedValue{GetIntValue(orderedClause.v)}) {
|
|
if (const auto collapseValue{GetIntValue(collapseClause.v)}) {
|
|
if (*orderedValue > 0 && *orderedValue < *collapseValue) {
|
|
context_.Say(clause->source,
|
|
"The parameter of the ORDERED clause must be "
|
|
"greater than or equal to "
|
|
"the parameter of the COLLAPSE clause"_err_en_US);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: ordered region binding check (requires nesting implementation)
|
|
}
|
|
} // doSet
|
|
|
|
// 2.8.1 Simd Construct Restriction
|
|
if (llvm::omp::simdSet.test(GetContext().directive)) {
|
|
if (auto *clause{FindClause(llvm::omp::Clause::OMPC_simdlen)}) {
|
|
if (auto *clause2{FindClause(llvm::omp::Clause::OMPC_safelen)}) {
|
|
const auto &simdlenClause{
|
|
std::get<parser::OmpClause::Simdlen>(clause->u)};
|
|
const auto &safelenClause{
|
|
std::get<parser::OmpClause::Safelen>(clause2->u)};
|
|
// simdlen and safelen both have parameters
|
|
if (const auto simdlenValue{GetIntValue(simdlenClause.v)}) {
|
|
if (const auto safelenValue{GetIntValue(safelenClause.v)}) {
|
|
if (*safelenValue > 0 && *simdlenValue > *safelenValue) {
|
|
context_.Say(clause->source,
|
|
"The parameter of the SIMDLEN clause must be less than or "
|
|
"equal to the parameter of the SAFELEN clause"_err_en_US);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: A list-item cannot appear in more than one aligned clause
|
|
} // SIMD
|
|
|
|
// 2.7.3 Single Construct Restriction
|
|
if (GetContext().directive == llvm::omp::Directive::OMPD_end_single) {
|
|
if (auto *clause{FindClause(llvm::omp::Clause::OMPC_copyprivate)}) {
|
|
if (FindClause(llvm::omp::Clause::OMPC_nowait)) {
|
|
context_.Say(clause->source,
|
|
"The COPYPRIVATE clause must not be used with "
|
|
"the NOWAIT clause"_err_en_US);
|
|
}
|
|
}
|
|
}
|
|
|
|
GetContext().requiredClauses.IterateOverMembers(
|
|
[this](llvm::omp::Clause c) { CheckRequired(c); });
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpClause &x) {
|
|
SetContextClause(x);
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpNowait &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_nowait);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Inbranch &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_inbranch);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Mergeable &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_mergeable);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Nogroup &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_nogroup);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Notinbranch &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_notinbranch);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Untied &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_untied);
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Collapse &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_collapse);
|
|
// collapse clause must have a parameter
|
|
RequiresConstantPositiveParameter(llvm::omp::Clause::OMPC_collapse, x.v);
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Copyin &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_copyin);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Copyprivate &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_copyprivate);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Device &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_device);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::DistSchedule &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_dist_schedule);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Final &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_final);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Firstprivate &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_firstprivate);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::From &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_from);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Grainsize &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_grainsize);
|
|
RequiresPositiveParameter(llvm::omp::Clause::OMPC_grainsize, x.v);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Lastprivate &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_lastprivate);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::NumTasks &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_num_tasks);
|
|
RequiresPositiveParameter(llvm::omp::Clause::OMPC_num_tasks, x.v);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::NumTeams &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_num_teams);
|
|
RequiresPositiveParameter(llvm::omp::Clause::OMPC_num_teams, x.v);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::NumThreads &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_num_threads);
|
|
RequiresPositiveParameter(llvm::omp::Clause::OMPC_num_threads, x.v);
|
|
// if parameter is variable, defer to Expression Analysis
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Ordered &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_ordered);
|
|
// the parameter of ordered clause is optional
|
|
if (const auto &expr{x.v}) {
|
|
RequiresConstantPositiveParameter(llvm::omp::Clause::OMPC_ordered, *expr);
|
|
|
|
// 2.8.3 Loop SIMD Construct Restriction
|
|
if (llvm::omp::doSimdSet.test(GetContext().directive)) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"No ORDERED clause with a parameter can be specified "
|
|
"on the %s directive"_err_en_US,
|
|
ContextDirectiveAsFortran());
|
|
}
|
|
}
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Priority &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_priority);
|
|
RequiresPositiveParameter(llvm::omp::Clause::OMPC_priority, x.v);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Private &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_private);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Safelen &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_safelen);
|
|
RequiresConstantPositiveParameter(llvm::omp::Clause::OMPC_safelen, x.v);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Shared &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_shared);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Simdlen &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_simdlen);
|
|
RequiresConstantPositiveParameter(llvm::omp::Clause::OMPC_simdlen, x.v);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::ThreadLimit &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_thread_limit);
|
|
RequiresPositiveParameter(llvm::omp::Clause::OMPC_thread_limit, x.v);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::To &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_to);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Link &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_link);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::Uniform &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_uniform);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::UseDevicePtr &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_use_device_ptr);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpClause::IsDevicePtr &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_is_device_ptr);
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpAlignedClause &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_aligned);
|
|
|
|
if (const auto &expr{
|
|
std::get<std::optional<parser::ScalarIntConstantExpr>>(x.t)}) {
|
|
if (const auto v{GetIntValue(*expr)}) {
|
|
if (*v <= 0) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"The ALIGNMENT parameter of the ALIGNED clause must be "
|
|
"a constant positive integer expression"_err_en_US);
|
|
}
|
|
}
|
|
}
|
|
// 2.8.1 TODO: list-item attribute check
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpDefaultClause &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_default);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpDefaultmapClause &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_defaultmap);
|
|
using VariableCategory = parser::OmpDefaultmapClause::VariableCategory;
|
|
if (!std::get<std::optional<VariableCategory>>(x.t)) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"The argument TOFROM:SCALAR must be specified on the DEFAULTMAP "
|
|
"clause"_err_en_US);
|
|
}
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpDependClause &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_depend);
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpIfClause &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_if);
|
|
|
|
using dirNameModifier = parser::OmpIfClause::DirectiveNameModifier;
|
|
static std::unordered_map<dirNameModifier, OmpDirectiveSet>
|
|
dirNameModifierMap{{dirNameModifier::Parallel, llvm::omp::parallelSet},
|
|
{dirNameModifier::Target, llvm::omp::targetSet},
|
|
{dirNameModifier::TargetEnterData,
|
|
{llvm::omp::Directive::OMPD_target_enter_data}},
|
|
{dirNameModifier::TargetExitData,
|
|
{llvm::omp::Directive::OMPD_target_exit_data}},
|
|
{dirNameModifier::TargetData,
|
|
{llvm::omp::Directive::OMPD_target_data}},
|
|
{dirNameModifier::TargetUpdate,
|
|
{llvm::omp::Directive::OMPD_target_update}},
|
|
{dirNameModifier::Task, {llvm::omp::Directive::OMPD_task}},
|
|
{dirNameModifier::Taskloop, llvm::omp::taskloopSet}};
|
|
if (const auto &directiveName{
|
|
std::get<std::optional<dirNameModifier>>(x.t)}) {
|
|
auto search{dirNameModifierMap.find(*directiveName)};
|
|
if (search == dirNameModifierMap.end() ||
|
|
!search->second.test(GetContext().directive)) {
|
|
context_
|
|
.Say(GetContext().clauseSource,
|
|
"Unmatched directive name modifier %s on the IF clause"_err_en_US,
|
|
parser::ToUpperCaseLetters(
|
|
parser::OmpIfClause::EnumToString(*directiveName)))
|
|
.Attach(
|
|
GetContext().directiveSource, "Cannot apply to directive"_en_US);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OmpStructureChecker::Enter(const parser::OmpLinearClause &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_linear);
|
|
|
|
// 2.7 Loop Construct Restriction
|
|
if ((llvm::omp::doSet | llvm::omp::simdSet).test(GetContext().directive)) {
|
|
if (std::holds_alternative<parser::OmpLinearClause::WithModifier>(x.u)) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"A modifier may not be specified in a LINEAR clause "
|
|
"on the %s directive"_err_en_US,
|
|
ContextDirectiveAsFortran());
|
|
}
|
|
}
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpMapClause &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_map);
|
|
if (const auto &maptype{std::get<std::optional<parser::OmpMapType>>(x.t)}) {
|
|
using Type = parser::OmpMapType::Type;
|
|
const Type &type{std::get<Type>(maptype->t)};
|
|
switch (GetContext().directive) {
|
|
case llvm::omp::Directive::OMPD_target:
|
|
case llvm::omp::Directive::OMPD_target_teams:
|
|
case llvm::omp::Directive::OMPD_target_teams_distribute:
|
|
case llvm::omp::Directive::OMPD_target_teams_distribute_simd:
|
|
case llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do:
|
|
case llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd:
|
|
case llvm::omp::Directive::OMPD_target_data: {
|
|
if (type != Type::To && type != Type::From && type != Type::Tofrom &&
|
|
type != Type::Alloc) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"Only the TO, FROM, TOFROM, or ALLOC map types are permitted "
|
|
"for MAP clauses on the %s directive"_err_en_US,
|
|
ContextDirectiveAsFortran());
|
|
}
|
|
} break;
|
|
case llvm::omp::Directive::OMPD_target_enter_data: {
|
|
if (type != Type::To && type != Type::Alloc) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"Only the TO or ALLOC map types are permitted "
|
|
"for MAP clauses on the %s directive"_err_en_US,
|
|
ContextDirectiveAsFortran());
|
|
}
|
|
} break;
|
|
case llvm::omp::Directive::OMPD_target_exit_data: {
|
|
if (type != Type::Delete && type != Type::Release && type != Type::From) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"Only the FROM, RELEASE, or DELETE map types are permitted "
|
|
"for MAP clauses on the %s directive"_err_en_US,
|
|
ContextDirectiveAsFortran());
|
|
}
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpProcBindClause &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_proc_bind);
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpReductionClause &) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_reduction);
|
|
}
|
|
|
|
bool OmpStructureChecker::ScheduleModifierHasType(
|
|
const parser::OmpScheduleClause &x,
|
|
const parser::OmpScheduleModifierType::ModType &type) {
|
|
const auto &modifier{
|
|
std::get<std::optional<parser::OmpScheduleModifier>>(x.t)};
|
|
if (modifier) {
|
|
const auto &modType1{
|
|
std::get<parser::OmpScheduleModifier::Modifier1>(modifier->t)};
|
|
const auto &modType2{
|
|
std::get<std::optional<parser::OmpScheduleModifier::Modifier2>>(
|
|
modifier->t)};
|
|
if (modType1.v.v == type || (modType2 && modType2->v.v == type)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
void OmpStructureChecker::Enter(const parser::OmpScheduleClause &x) {
|
|
CheckAllowed(llvm::omp::Clause::OMPC_schedule);
|
|
|
|
// 2.7 Loop Construct Restriction
|
|
if (llvm::omp::doSet.test(GetContext().directive)) {
|
|
const auto &kind{std::get<1>(x.t)};
|
|
const auto &chunk{std::get<2>(x.t)};
|
|
if (chunk) {
|
|
if (kind == parser::OmpScheduleClause::ScheduleType::Runtime ||
|
|
kind == parser::OmpScheduleClause::ScheduleType::Auto) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"When SCHEDULE clause has %s specified, "
|
|
"it must not have chunk size specified"_err_en_US,
|
|
parser::ToUpperCaseLetters(
|
|
parser::OmpScheduleClause::EnumToString(kind)));
|
|
}
|
|
}
|
|
|
|
if (ScheduleModifierHasType(
|
|
x, parser::OmpScheduleModifierType::ModType::Nonmonotonic)) {
|
|
if (kind != parser::OmpScheduleClause::ScheduleType::Dynamic &&
|
|
kind != parser::OmpScheduleClause::ScheduleType::Guided) {
|
|
context_.Say(GetContext().clauseSource,
|
|
"The NONMONOTONIC modifier can only be specified with "
|
|
"SCHEDULE(DYNAMIC) or SCHEDULE(GUIDED)"_err_en_US);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} // namespace Fortran::semantics
|