[flang-commits] [flang] c79333e - [flang][OpenMP] Centralize pushing/popping directive context (#204924)
via flang-commits
flang-commits at lists.llvm.org
Mon Jun 22 07:25:30 PDT 2026
Author: Krzysztof Parzyszek
Date: 2026-06-22T09:25:25-05:00
New Revision: c79333e16d4c567c4ebeccb878ac2fc40fed687d
URL: https://github.com/llvm/llvm-project/commit/c79333e16d4c567c4ebeccb878ac2fc40fed687d
DIFF: https://github.com/llvm/llvm-project/commit/c79333e16d4c567c4ebeccb878ac2fc40fed687d.diff
LOG: [flang][OpenMP] Centralize pushing/popping directive context (#204924)
Put calls to PushContextAndClauseSets to the Enter function for
OpenMPConstruct and OpenMPDeclarativeConstruct, and popping the context
to the corresponding Leave functions. This moves most of the context
handling to the top-level AST entries. This will allow more centralized
verification of common clause properties in the future.
Added:
Modified:
flang/lib/Semantics/check-omp-atomic.cpp
flang/lib/Semantics/check-omp-loop.cpp
flang/lib/Semantics/check-omp-structure.cpp
flang/lib/Semantics/check-omp-structure.h
flang/lib/Semantics/check-omp-variant.cpp
Removed:
################################################################################
diff --git a/flang/lib/Semantics/check-omp-atomic.cpp b/flang/lib/Semantics/check-omp-atomic.cpp
index a61a868c9baa4..ec307be469982 100644
--- a/flang/lib/Semantics/check-omp-atomic.cpp
+++ b/flang/lib/Semantics/check-omp-atomic.cpp
@@ -1641,8 +1641,6 @@ void OmpStructureChecker::Enter(const parser::OpenMPAtomicConstruct &x) {
}};
const parser::OmpDirectiveSpecification &dirSpec{x.BeginDir()};
- auto &dir{std::get<parser::OmpDirectiveName>(dirSpec.t)};
- PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_atomic);
llvm::omp::Clause kind{x.GetKind()};
checkExclusive(atomic, "atomic", dirSpec.Clauses());
@@ -1665,10 +1663,6 @@ void OmpStructureChecker::Enter(const parser::OpenMPAtomicConstruct &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OpenMPAtomicConstruct &) {
- dirContext_.pop_back();
-}
-
// Rewrite min/max:
// Min and max intrinsics in Fortran take an arbitrary number of arguments
// (two or more). The first two are mandatory, the rest is optional. That
diff --git a/flang/lib/Semantics/check-omp-loop.cpp b/flang/lib/Semantics/check-omp-loop.cpp
index 689e3a0da89ca..3e1f2e6cdf5d0 100644
--- a/flang/lib/Semantics/check-omp-loop.cpp
+++ b/flang/lib/Semantics/check-omp-loop.cpp
@@ -381,7 +381,6 @@ void OmpStructureChecker::CheckNestedConstruct(
void OmpStructureChecker::Enter(const parser::OpenMPLoopConstruct &x) {
const parser::OmpDirectiveName &beginName{x.BeginDir().DirName()};
- PushContextAndClauseSets(beginName.source, beginName.v);
// Check matching, end directive is optional
if (auto &endSpec{x.EndDir()}) {
@@ -688,7 +687,6 @@ void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &x) {
if (llvm::omp::allSimdSet.test(beginSpec.DirName().v)) {
ExitDirectiveNest(SIMDNest);
}
- dirContext_.pop_back();
}
void OmpStructureChecker::Enter(const parser::OmpClause::Depth &x) {
diff --git a/flang/lib/Semantics/check-omp-structure.cpp b/flang/lib/Semantics/check-omp-structure.cpp
index e2220156d13cd..022c774cd2adc 100644
--- a/flang/lib/Semantics/check-omp-structure.cpp
+++ b/flang/lib/Semantics/check-omp-structure.cpp
@@ -1041,22 +1041,17 @@ void OmpStructureChecker::Enter(const parser::OpenMPConstruct &x) {
return CheckDirectiveSpelling(source, id);
});
parser::Walk(x, visitor);
- if (GetOmpDirectiveName(x).v != llvm::omp::Directive::OMPD_section) {
- dirStack_.push_back(&GetOmpDirectiveSpecification(x));
- }
-
- CheckDirectiveDeprecation(x);
- if (GetOmpDirectiveName(x).v != llvm::omp::Directive::OMPD_section) {
- dirStack_.push_back(&GetOmpDirectiveSpecification(x));
+ parser::OmpDirectiveName dirName{GetOmpDirectiveName(x)};
+ if (dirName.v == llvm::omp::Directive::OMPD_section) {
+ return;
}
+ PushContextAndClauseSets(dirName.source, dirName.v);
+ dirStack_.push_back(&GetOmpDirectiveSpecification(x));
+ CheckDirectiveDeprecation(x);
- // Simd Construct with Ordered Construct Nesting check
- // We cannot use CurrentDirectiveIsNested() here because
- // PushContextAndClauseSets() has not been called yet, it is
- // called individually for each construct. Therefore a
- // dirContext_ size `1` means the current construct is nested
- if (dirContext_.size() >= 1) {
+ // Simd Construct with Ordered Construct Nesting check.
+ if (CurrentDirectiveIsNested()) {
if (GetDirectiveNest(SIMDNest) > 0) {
CheckSIMDNest(x);
}
@@ -1067,8 +1062,11 @@ void OmpStructureChecker::Enter(const parser::OpenMPConstruct &x) {
}
void OmpStructureChecker::Leave(const parser::OpenMPConstruct &x) {
- if (GetOmpDirectiveName(x).v != llvm::omp::Directive::OMPD_section) {
+ parser::OmpDirectiveName dirName{GetOmpDirectiveName(x)};
+ if (dirName.v != llvm::omp::Directive::OMPD_section) {
dirStack_.pop_back();
+ assert(dirName.v == GetContext().directive && "Context mismatch");
+ dirContext_.pop_back();
}
constructStack_.pop_back();
}
@@ -1080,6 +1078,8 @@ void OmpStructureChecker::Enter(const parser::OpenMPDeclarativeConstruct &x) {
});
parser::Walk(x, visitor);
+ parser::OmpDirectiveName dirName{GetOmpDirectiveName(x)};
+ PushContextAndClauseSets(dirName.source, dirName.v);
dirStack_.push_back(&GetOmpDirectiveSpecification(x));
EnterDirectiveNest(DeclarativeNest);
}
@@ -1087,6 +1087,9 @@ void OmpStructureChecker::Enter(const parser::OpenMPDeclarativeConstruct &x) {
void OmpStructureChecker::Leave(const parser::OpenMPDeclarativeConstruct &x) {
ExitDirectiveNest(DeclarativeNest);
dirStack_.pop_back();
+ [[maybe_unused]] parser::OmpDirectiveName dirName{GetOmpDirectiveName(x)};
+ assert(dirName.v == GetContext().directive && "Context mismatch");
+ dirContext_.pop_back();
}
void OmpStructureChecker::AddEndDirectiveClauses(
@@ -1215,8 +1218,6 @@ void OmpStructureChecker::Enter(const parser::OmpBlockConstruct &x) {
const parser::Block &block{std::get<parser::Block>(x.t)};
unsigned version{context_.langOptions().OpenMPVersion};
- PushContextAndClauseSets(beginSpec.DirName().source, beginSpec.DirId());
-
// Missing mandatory end block: this is checked in semantics because that
// makes it easier to control the error messages.
// The end block is mandatory when the construct is not applied to a strictly
@@ -1400,22 +1401,6 @@ void OmpStructureChecker::CheckMasterNesting(
}
}
-void OmpStructureChecker::Enter(const parser::OmpAssumeDirective &x) {
- PushContextAndClauseSets(x.source, llvm::omp::Directive::OMPD_assume);
-}
-
-void OmpStructureChecker::Leave(const parser::OmpAssumeDirective &) {
- dirContext_.pop_back();
-}
-
-void OmpStructureChecker::Enter(const parser::OmpAssumesDirective &x) {
- PushContextAndClauseSets(x.source, llvm::omp::Directive::OMPD_assumes);
-}
-
-void OmpStructureChecker::Leave(const parser::OmpAssumesDirective &) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::Leave(const parser::OmpBlockConstruct &x) {
if (GetContext().directive == llvm::omp::Directive::OMPD_taskgraph) {
CheckTaskgraph(x);
@@ -1426,7 +1411,6 @@ void OmpStructureChecker::Leave(const parser::OmpBlockConstruct &x) {
if (llvm::omp::allTargetSet.test(GetContext().directive)) {
ExitDirectiveNest(TargetNest);
}
- dirContext_.pop_back();
}
void OmpStructureChecker::ChecksOnOrderedAsBlock() {
@@ -1526,7 +1510,6 @@ void OmpStructureChecker::Enter(const parser::OpenMPSectionsConstruct &x) {
const parser::OmpDirectiveSpecification &beginSpec{x.BeginDir()};
const parser::OmpDirectiveName &beginName{beginSpec.DirName()};
const auto &endSpec{x.EndDir()};
- PushContextAndClauseSets(beginName.source, beginName.v);
if (!endSpec) {
context_.Say(
@@ -1549,10 +1532,6 @@ void OmpStructureChecker::Enter(const parser::OpenMPSectionsConstruct &x) {
llvm::omp::nestedWorkshareErrSet);
}
-void OmpStructureChecker::Leave(const parser::OpenMPSectionsConstruct &) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::Enter(const parser::OmpEndSectionsDirective &x) {
const parser::OmpDirectiveName &dirName{x.DirName()};
ResetPartialContext(dirName.source);
@@ -1689,9 +1668,6 @@ void OmpStructureChecker::CheckThreadprivateOrDeclareTargetVar(
}
void OmpStructureChecker::Enter(const parser::OmpGroupprivateDirective &x) {
- PushContextAndClauseSets(
- x.v.DirName().source, llvm::omp::Directive::OMPD_groupprivate);
-
for (const parser::OmpArgument &arg : x.v.Arguments().v) {
auto *locator{std::get_if<parser::OmpLocator>(&arg.u)};
const Symbol *sym{GetArgumentSymbol(arg, /*ultimate=*/true)};
@@ -1740,15 +1716,6 @@ void OmpStructureChecker::Enter(const parser::OmpGroupprivateDirective &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OmpGroupprivateDirective &x) {
- dirContext_.pop_back();
-}
-
-void OmpStructureChecker::Enter(const parser::OmpThreadprivateDirective &x) {
- const parser::OmpDirectiveName &dirName{x.v.DirName()};
- PushContextAndClauseSets(dirName.source, dirName.v);
-}
-
void OmpStructureChecker::Leave(const parser::OmpThreadprivateDirective &x) {
const parser::OmpDirectiveSpecification &dirSpec{x.v};
for (const parser::OmpArgument &arg : x.v.Arguments().v) {
@@ -1759,12 +1726,10 @@ void OmpStructureChecker::Leave(const parser::OmpThreadprivateDirective &x) {
CheckThreadprivateOrDeclareTargetVar(*object);
}
}
- dirContext_.pop_back();
}
void OmpStructureChecker::Enter(const parser::OmpDeclareSimdDirective &x) {
const parser::OmpDirectiveName &dirName{x.v.DirName()};
- PushContextAndClauseSets(dirName.source, dirName.v);
const Scope &containingScope = context_.FindScope(dirName.source);
const Scope &progUnitScope = GetProgramUnitContaining(containingScope);
@@ -1836,10 +1801,6 @@ void OmpStructureChecker::Enter(const parser::OmpDeclareSimdDirective &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OmpDeclareSimdDirective &) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::CheckInitOnDepobj(
const parser::OpenMPDepobjConstruct &depobj,
const parser::OmpClause &initClause) {
@@ -1887,7 +1848,6 @@ void OmpStructureChecker::CheckInitOnDepobj(
void OmpStructureChecker::Enter(const parser::OpenMPDepobjConstruct &x) {
const auto &dirName{std::get<parser::OmpDirectiveName>(x.v.t)};
- PushContextAndClauseSets(dirName.source, llvm::omp::Directive::OMPD_depobj);
unsigned version{context_.langOptions().OpenMPVersion};
const parser::OmpArgumentList &arguments{x.v.Arguments()};
@@ -1942,13 +1902,7 @@ void OmpStructureChecker::Enter(const parser::OpenMPDepobjConstruct &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OpenMPDepobjConstruct &x) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::Enter(const parser::OmpRequiresDirective &x) {
- const auto &dirName{x.v.DirName()};
- PushContextAndClauseSets(dirName.source, dirName.v);
unsigned version{context_.langOptions().OpenMPVersion};
for (const parser::OmpClause &clause : x.v.Clauses().v) {
@@ -1989,10 +1943,6 @@ void OmpStructureChecker::Enter(const parser::OmpRequiresDirective &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OmpRequiresDirective &) {
- dirContext_.pop_back();
-}
-
static std::pair<const parser::AllocateStmt *, parser::CharBlock>
getAllocateStmtAndSource(const parser::ExecutionPartConstruct *epc) {
if (SourcedActionStmt as{GetActionStmt(epc)}) {
@@ -2182,7 +2132,6 @@ void OmpStructureChecker::CheckExecutableAllocateDirective(
void OmpStructureChecker::Enter(const parser::OmpAllocateDirective &x) {
const parser::OmpDirectiveSpecification &beginSpec{x.BeginDir()};
const parser::OmpDirectiveName &dirName{beginSpec.DirName()};
- PushContextAndClauseSets(dirName.source, dirName.v);
++allocateDirectiveLevel_;
bool isExecutable{partStack_.back() == PartKind::ExecutionPart};
@@ -2234,7 +2183,6 @@ void OmpStructureChecker::Leave(const parser::OmpAllocateDirective &x) {
}
--allocateDirectiveLevel_;
- dirContext_.pop_back();
}
void OmpStructureChecker::Enter(const parser::OmpClause::Allocator &x) {
@@ -2302,9 +2250,6 @@ void OmpStructureChecker::Enter(const parser::OmpClause::Allocate &x) {
}
void OmpStructureChecker::Enter(const parser::OmpDeclareMapperDirective &x) {
- const parser::OmpDirectiveName &dirName{x.v.DirName()};
- PushContextAndClauseSets(dirName.source, dirName.v);
-
const parser::OmpArgumentList &args{x.v.Arguments()};
if (args.v.size() != 1) {
context_.Say(args.source,
@@ -2324,14 +2269,7 @@ void OmpStructureChecker::Enter(const parser::OmpDeclareMapperDirective &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OmpDeclareMapperDirective &) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::Enter(const parser::OmpDeclareReductionDirective &x) {
- const parser::OmpDirectiveName &dirName{x.v.DirName()};
- PushContextAndClauseSets(dirName.source, dirName.v);
-
const parser::OmpArgumentList &args{x.v.Arguments()};
if (args.v.size() != 1) {
context_.Say(args.source,
@@ -2346,13 +2284,8 @@ void OmpStructureChecker::Enter(const parser::OmpDeclareReductionDirective &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OmpDeclareReductionDirective &) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::Enter(const parser::OmpDeclareTargetDirective &x) {
const parser::OmpDirectiveName &dirName{x.v.DirName()};
- PushContext(dirName.source, dirName.v);
// Check if arguments are extended-list-items.
for (const parser::OmpArgument &arg : x.v.Arguments().v) {
@@ -2491,29 +2424,10 @@ void OmpStructureChecker::Leave(const parser::OmpDeclareTargetDirective &x) {
deviceConstructFound_ = true;
}
}
-
- dirContext_.pop_back();
-}
-
-void OmpStructureChecker::Enter(const parser::OmpErrorDirective &x) {
- const parser::OmpDirectiveName &dirName{x.v.DirName()};
- PushContextAndClauseSets(dirName.source, dirName.v);
-}
-
-void OmpStructureChecker::Enter(const parser::OmpNothingDirective &x) {
- const parser::OmpDirectiveName &dirName{x.v.DirName()};
- PushContextAndClauseSets(dirName.source, dirName.v);
-}
-
-void OmpStructureChecker::Leave(const parser::OmpNothingDirective &x) {
- dirContext_.pop_back();
}
void OmpStructureChecker::Enter(const parser::OpenMPDispatchConstruct &x) {
- const parser::OmpDirectiveSpecification &dirSpec{x.BeginDir()};
const auto &block{std::get<parser::Block>(x.t)};
- PushContextAndClauseSets(
- dirSpec.DirName().source, llvm::omp::Directive::OMPD_dispatch);
if (block.empty()) {
context_.Say(x.source,
@@ -2538,14 +2452,6 @@ void OmpStructureChecker::Enter(const parser::OpenMPDispatchConstruct &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OpenMPDispatchConstruct &x) {
- dirContext_.pop_back();
-}
-
-void OmpStructureChecker::Leave(const parser::OmpErrorDirective &x) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::Enter(const parser::OmpClause::At &x) {
CheckAllowedClause(llvm::omp::Clause::OMPC_at);
if (GetDirectiveNest(DeclarativeNest) > 0) {
@@ -2559,8 +2465,6 @@ void OmpStructureChecker::Enter(const parser::OmpClause::At &x) {
void OmpStructureChecker::Enter(const parser::OpenMPAllocatorsConstruct &x) {
const parser::OmpDirectiveSpecification &beginSpec{x.BeginDir()};
const parser::OmpDirectiveName &dirName{beginSpec.DirName()};
- PushContextAndClauseSets(
- dirName.source, llvm::omp::Directive::OMPD_allocators);
for (const auto &clause : beginSpec.Clauses().v) {
auto *alloc{std::get_if<parser::OmpClause::Allocate>(&clause.u)};
@@ -2637,10 +2541,6 @@ void OmpStructureChecker::Enter(const parser::OpenMPAllocatorsConstruct &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OpenMPAllocatorsConstruct &x) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::CheckScan(
const parser::OpenMPSimpleStandaloneConstruct &x) {
if (x.v.Clauses().v.size() != 1) {
@@ -3031,7 +2931,6 @@ void OmpStructureChecker::CheckDependenceType(
void OmpStructureChecker::Enter(
const parser::OpenMPSimpleStandaloneConstruct &x) {
const auto &dir{std::get<parser::OmpDirectiveName>(x.v.t)};
- PushContextAndClauseSets(dir.source, dir.v);
switch (dir.v) {
case llvm::omp::Directive::OMPD_barrier:
CheckBarrierNesting(x);
@@ -3057,12 +2956,6 @@ void OmpStructureChecker::Leave(
default:
break;
}
- dirContext_.pop_back();
-}
-
-void OmpStructureChecker::Enter(const parser::OpenMPFlushConstruct &x) {
- const auto &dirName{std::get<parser::OmpDirectiveName>(x.v.t)};
- PushContextAndClauseSets(dirName.source, llvm::omp::Directive::OMPD_flush);
}
void OmpStructureChecker::Leave(const parser::OpenMPFlushConstruct &x) {
@@ -3098,14 +2991,11 @@ void OmpStructureChecker::Leave(const parser::OpenMPFlushConstruct &x) {
"The syntax \"FLUSH clause (object, ...)\" has been deprecated, use \"FLUSH(object, ...) clause\" instead"_warn_en_US);
}
}
-
- dirContext_.pop_back();
}
void OmpStructureChecker::Enter(const parser::OpenMPCancelConstruct &x) {
auto &dirName{std::get<parser::OmpDirectiveName>(x.v.t)};
auto &maybeClauses{std::get<std::optional<parser::OmpClauseList>>(x.v.t)};
- PushContextAndClauseSets(dirName.source, llvm::omp::Directive::OMPD_cancel);
if (auto maybeConstruct{GetCancelType(
llvm::omp::Directive::OMPD_cancel, x.source, maybeClauses)}) {
@@ -3144,14 +3034,9 @@ void OmpStructureChecker::Enter(const parser::OpenMPCancelConstruct &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OpenMPCancelConstruct &) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::Enter(const parser::OpenMPCriticalConstruct &x) {
const parser::OmpBeginDirective &beginSpec{x.BeginDir()};
const std::optional<parser::OmpEndDirective> &endSpec{x.EndDir()};
- PushContextAndClauseSets(beginSpec.DirName().source, beginSpec.DirId());
const auto &block{std::get<parser::Block>(x.t)};
CheckNoBranching(
@@ -3233,10 +3118,6 @@ void OmpStructureChecker::Enter(const parser::OpenMPCriticalConstruct &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OpenMPCriticalConstruct &) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::Enter(
const parser::OmpClause::CancellationConstructType &x) {
llvm::omp::Directive dir{GetContext().directive};
@@ -3271,8 +3152,6 @@ void OmpStructureChecker::Enter(
const parser::OpenMPCancellationPointConstruct &x) {
auto &dirName{std::get<parser::OmpDirectiveName>(x.v.t)};
auto &maybeClauses{std::get<std::optional<parser::OmpClauseList>>(x.v.t)};
- PushContextAndClauseSets(
- dirName.source, llvm::omp::Directive::OMPD_cancellation_point);
if (auto maybeConstruct{
GetCancelType(llvm::omp::Directive::OMPD_cancellation_point, x.source,
@@ -3281,11 +3160,6 @@ void OmpStructureChecker::Enter(
}
}
-void OmpStructureChecker::Leave(
- const parser::OpenMPCancellationPointConstruct &) {
- dirContext_.pop_back();
-}
-
std::optional<llvm::omp::Directive> OmpStructureChecker::GetCancelType(
llvm::omp::Directive cancelDir, const parser::CharBlock &cancelSource,
const std::optional<parser::OmpClauseList> &maybeClauses) {
@@ -5794,9 +5668,7 @@ void OmpStructureChecker::Enter(const parser::OmpClause::ThreadLimit &x) {
void OmpStructureChecker::Enter(const parser::OpenMPInteropConstruct &x) {
bool isDependClauseOccurred{false};
int targetCount{0}, targetSyncCount{0};
- const auto &dir{std::get<parser::OmpDirectiveName>(x.v.t)};
std::set<const Symbol *> objectSymbolList;
- PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_interop);
const auto &clauseList{std::get<std::optional<parser::OmpClauseList>>(x.v.t)};
for (const auto &clause : clauseList->v) {
common::visit(
@@ -5884,10 +5756,6 @@ void OmpStructureChecker::Enter(const parser::OpenMPInteropConstruct &x) {
}
}
-void OmpStructureChecker::Leave(const parser::OpenMPInteropConstruct &) {
- dirContext_.pop_back();
-}
-
void OmpStructureChecker::CheckAllowedRequiresClause(llvm::omp::Clause clause) {
CheckAllowedClause(clause);
unsigned version{context_.langOptions().OpenMPVersion};
@@ -5909,6 +5777,8 @@ void OmpStructureChecker::Enter(const parser::OpenMPMisplacedEndDirective &x) {
}
void OmpStructureChecker::Leave(const parser::OpenMPMisplacedEndDirective &x) {
+ assert(GetContext().directive == llvm::omp::Directive::OMPD_unknown &&
+ "Context mismatch");
dirContext_.pop_back();
}
@@ -5918,6 +5788,8 @@ void OmpStructureChecker::Enter(const parser::OpenMPInvalidDirective &x) {
}
void OmpStructureChecker::Leave(const parser::OpenMPInvalidDirective &x) {
+ assert(GetContext().directive == llvm::omp::Directive::OMPD_unknown &&
+ "Context mismatch");
dirContext_.pop_back();
}
diff --git a/flang/lib/Semantics/check-omp-structure.h b/flang/lib/Semantics/check-omp-structure.h
index 9fca5ff0f5fca..1154fce5e00a7 100644
--- a/flang/lib/Semantics/check-omp-structure.h
+++ b/flang/lib/Semantics/check-omp-structure.h
@@ -96,12 +96,7 @@ class OmpStructureChecker : public OmpStructureCheckerBase {
void Enter(const parser::OpenMPLoopConstruct &);
void Leave(const parser::OpenMPLoopConstruct &);
- void Enter(const parser::OmpAssumeDirective &);
- void Leave(const parser::OmpAssumeDirective &);
- void Enter(const parser::OmpAssumesDirective &);
- void Leave(const parser::OmpAssumesDirective &);
void Enter(const parser::OpenMPInteropConstruct &);
- void Leave(const parser::OpenMPInteropConstruct &);
void Enter(const parser::OmpBlockConstruct &);
void Leave(const parser::OmpBlockConstruct &);
void Enter(const parser::OmpBeginDirective &);
@@ -110,51 +105,31 @@ class OmpStructureChecker : public OmpStructureCheckerBase {
void Leave(const parser::OmpEndDirective &);
void Enter(const parser::OpenMPSectionsConstruct &);
- void Leave(const parser::OpenMPSectionsConstruct &);
void Enter(const parser::OmpEndSectionsDirective &);
void Leave(const parser::OmpEndSectionsDirective &);
void Enter(const parser::OmpDeclareVariantDirective &);
- void Leave(const parser::OmpDeclareVariantDirective &);
void Enter(const parser::OmpDeclareSimdDirective &);
- void Leave(const parser::OmpDeclareSimdDirective &);
void Enter(const parser::OmpAllocateDirective &);
void Leave(const parser::OmpAllocateDirective &);
void Enter(const parser::OmpDeclareMapperDirective &);
- void Leave(const parser::OmpDeclareMapperDirective &);
void Enter(const parser::OmpDeclareReductionDirective &);
- void Leave(const parser::OmpDeclareReductionDirective &);
void Enter(const parser::OmpDeclareTargetDirective &);
void Leave(const parser::OmpDeclareTargetDirective &);
void Enter(const parser::OpenMPDepobjConstruct &);
- void Leave(const parser::OpenMPDepobjConstruct &);
void Enter(const parser::OpenMPDispatchConstruct &);
- void Leave(const parser::OpenMPDispatchConstruct &);
- void Enter(const parser::OmpErrorDirective &);
- void Leave(const parser::OmpErrorDirective &);
- void Enter(const parser::OmpNothingDirective &);
- void Leave(const parser::OmpNothingDirective &);
void Enter(const parser::OpenMPAllocatorsConstruct &);
- void Leave(const parser::OpenMPAllocatorsConstruct &);
void Enter(const parser::OmpRequiresDirective &);
- void Leave(const parser::OmpRequiresDirective &);
void Enter(const parser::OmpGroupprivateDirective &);
- void Leave(const parser::OmpGroupprivateDirective &);
- void Enter(const parser::OmpThreadprivateDirective &);
void Leave(const parser::OmpThreadprivateDirective &);
void Enter(const parser::OpenMPSimpleStandaloneConstruct &);
void Leave(const parser::OpenMPSimpleStandaloneConstruct &);
- void Enter(const parser::OpenMPFlushConstruct &);
void Leave(const parser::OpenMPFlushConstruct &);
void Enter(const parser::OpenMPCancelConstruct &);
- void Leave(const parser::OpenMPCancelConstruct &);
void Enter(const parser::OpenMPCancellationPointConstruct &);
- void Leave(const parser::OpenMPCancellationPointConstruct &);
void Enter(const parser::OpenMPCriticalConstruct &);
- void Leave(const parser::OpenMPCriticalConstruct &);
void Enter(const parser::OpenMPAtomicConstruct &);
- void Leave(const parser::OpenMPAtomicConstruct &);
void Leave(const parser::OmpClauseList &);
void Enter(const parser::OmpClause &);
@@ -167,8 +142,6 @@ class OmpStructureChecker : public OmpStructureCheckerBase {
void Enter(const parser::OmpMetadirectiveDirective &);
void Leave(const parser::OmpMetadirectiveDirective &);
- void Enter(const parser::OmpDelimitedMetadirectiveDirective &);
- void Leave(const parser::OmpDelimitedMetadirectiveDirective &);
void Enter(const parser::OmpContextSelector &);
void Leave(const parser::OmpContextSelector &);
diff --git a/flang/lib/Semantics/check-omp-variant.cpp b/flang/lib/Semantics/check-omp-variant.cpp
index 8ab160496b64a..c681cd601b856 100644
--- a/flang/lib/Semantics/check-omp-variant.cpp
+++ b/flang/lib/Semantics/check-omp-variant.cpp
@@ -585,23 +585,10 @@ void OmpStructureChecker::Leave(const parser::OmpDirectiveSpecification &x) {
void OmpStructureChecker::Enter(const parser::OmpMetadirectiveDirective &x) {
EnterDirectiveNest(MetadirectiveNest);
- PushContextAndClauseSets(
- x.v.source, llvm::omp::Directive::OMPD_metadirective);
}
void OmpStructureChecker::Leave(const parser::OmpMetadirectiveDirective &) {
ExitDirectiveNest(MetadirectiveNest);
- dirContext_.pop_back();
-}
-
-void OmpStructureChecker::Enter(
- const parser::OmpDelimitedMetadirectiveDirective &x) {
- PushContextAndClauseSets(x.source, llvm::omp::Directive::OMPD_metadirective);
-}
-
-void OmpStructureChecker::Leave(
- const parser::OmpDelimitedMetadirectiveDirective &) {
- dirContext_.pop_back();
}
static const parser::traits::OmpContextSelectorSpecification *
@@ -742,13 +729,7 @@ void OmpStructureChecker::CheckOmpDeclareVariantDirective(
}
void OmpStructureChecker::Enter(const parser::OmpDeclareVariantDirective &x) {
- const parser::OmpDirectiveName &dirName{x.v.DirName()};
- PushContextAndClauseSets(dirName.source, dirName.v);
CheckOmpDeclareVariantDirective(x);
}
-void OmpStructureChecker::Leave(const parser::OmpDeclareVariantDirective &) {
- dirContext_.pop_back();
-}
-
} // namespace Fortran::semantics
More information about the flang-commits
mailing list