[flang] [llvm] [flang][OpenMP] Parse cancel-directive-name as clause (PR #130146)
Krzysztof Parzyszek via llvm-commits
llvm-commits at lists.llvm.org
Mon Mar 10 06:20:49 PDT 2025
https://github.com/kparzysz updated https://github.com/llvm/llvm-project/pull/130146
>From 2ea14e0dae3f1ef8d7c1e3f8a78f51dbc3d97ee3 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Tue, 4 Mar 2025 13:36:59 -0600
Subject: [PATCH 01/10] [flang][OpenMP] Implement OmpDirectiveName, use in
OmpDirectiveSpecification
The `OmpDirectiveName` class has a source in addition to wrapping the
llvm::omp::Directive.
---
flang/include/flang/Parser/dump-parse-tree.h | 1 +
flang/include/flang/Parser/parse-tree.h | 17 ++++++++-
flang/lib/Parser/openmp-parsers.cpp | 38 +++++++++++++++----
flang/lib/Parser/parse-tree.cpp | 15 ++++++++
flang/lib/Parser/unparse.cpp | 2 +-
flang/lib/Semantics/check-omp-structure.cpp | 2 +-
flang/lib/Semantics/resolve-directives.cpp | 2 +-
flang/lib/Semantics/resolve-names.cpp | 3 +-
.../Parser/OpenMP/metadirective-dirspec.f90 | 16 ++++----
.../test/Parser/OpenMP/metadirective-v50.f90 | 4 +-
flang/test/Parser/OpenMP/metadirective.f90 | 24 ++++++------
11 files changed, 89 insertions(+), 35 deletions(-)
diff --git a/flang/include/flang/Parser/dump-parse-tree.h b/flang/include/flang/Parser/dump-parse-tree.h
index 3b3c6bdc448d7..a154794e41e9d 100644
--- a/flang/include/flang/Parser/dump-parse-tree.h
+++ b/flang/include/flang/Parser/dump-parse-tree.h
@@ -489,6 +489,7 @@ class ParseTreeDumper {
NODE(parser, OmpOtherwiseClause)
NODE(parser, OmpWhenClause)
NODE(OmpWhenClause, Modifier)
+ NODE(parser, OmpDirectiveName)
NODE(parser, OmpDirectiveSpecification)
NODE(parser, OmpTraitPropertyName)
NODE(parser, OmpTraitScore)
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index f11859bb09ddb..346299b8e5215 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -3464,6 +3464,18 @@ WRAPPER_CLASS(PauseStmt, std::optional<StopCode>);
struct OmpClause;
struct OmpDirectiveSpecification;
+struct OmpDirectiveName {
+ // No boilerplates: this class should be copyable, movable, etc.
+ constexpr OmpDirectiveName() = default;
+ constexpr OmpDirectiveName(const OmpDirectiveName &) = default;
+ // Construct from an already parsed text. Use Verbatim for this because
+ // Verbatim's source corresponds to an actual source location.
+ OmpDirectiveName(const Verbatim &name);
+ using WrapperTrait = std::true_type;
+ CharBlock source;
+ llvm::omp::Directive v{llvm::omp::Directive::OMPD_unknown};
+};
+
// 2.1 Directives or clauses may accept a list or extended-list.
// A list item is a variable, array section or common block name (enclosed
// in slashes). An extended list item is a list item or a procedure Name.
@@ -4493,7 +4505,10 @@ struct OmpClauseList {
struct OmpDirectiveSpecification {
CharBlock source;
TUPLE_CLASS_BOILERPLATE(OmpDirectiveSpecification);
- std::tuple<llvm::omp::Directive, std::optional<std::list<OmpArgument>>,
+ llvm::omp::Directive DirId() const { //
+ return std::get<OmpDirectiveName>(t).v;
+ }
+ std::tuple<OmpDirectiveName, std::optional<std::list<OmpArgument>>,
std::optional<OmpClauseList>>
t;
};
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index 43cd2ea1eb0e6..b3e76d70c8064 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -27,15 +27,38 @@ namespace Fortran::parser {
constexpr auto startOmpLine = skipStuffBeforeStatement >> "!$OMP "_sptok;
constexpr auto endOmpLine = space >> endOfLine;
+template <typename Parser> struct UnwrapParser {
+ static_assert(
+ Parser::resultType::WrapperTrait::value && "Wrapper class required");
+ using resultType = decltype(Parser::resultType::v);
+ constexpr UnwrapParser(Parser p) : parser_(p) {}
+
+ std::optional<resultType> Parse(ParseState &state) const {
+ if (auto result{parser_.Parse(state)}) {
+ return result->v;
+ }
+ return std::nullopt;
+ }
+
+private:
+ const Parser parser_;
+};
+
+template <typename Parser> constexpr auto unwrap(const Parser &p) {
+ return UnwrapParser<Parser>(p);
+}
+
/// Parse OpenMP directive name (this includes compound directives).
struct OmpDirectiveNameParser {
- using resultType = llvm::omp::Directive;
+ using resultType = OmpDirectiveName;
using Token = TokenStringMatch<false, false>;
std::optional<resultType> Parse(ParseState &state) const {
for (const NameWithId &nid : directives()) {
if (attempt(Token(nid.first.data())).Parse(state)) {
- return nid.second;
+ OmpDirectiveName n;
+ n.v = nid.second;
+ return n;
}
}
return std::nullopt;
@@ -218,7 +241,7 @@ TYPE_PARSER(construct<OmpTraitSelectorName::Value>(
TYPE_PARSER(sourced(construct<OmpTraitSelectorName>(
// Parse predefined names first (because of SIMD).
construct<OmpTraitSelectorName>(Parser<OmpTraitSelectorName::Value>{}) ||
- construct<OmpTraitSelectorName>(OmpDirectiveNameParser{}) ||
+ construct<OmpTraitSelectorName>(unwrap(OmpDirectiveNameParser{})) ||
// identifier-or-string for extensions
construct<OmpTraitSelectorName>(
applyFunction(nameToString, Parser<Name>{})) ||
@@ -480,7 +503,8 @@ TYPE_PARSER(sourced(construct<OmpFromClause::Modifier>(
TYPE_PARSER(sourced(
construct<OmpGrainsizeClause::Modifier>(Parser<OmpPrescriptiveness>{})))
-TYPE_PARSER(sourced(construct<OmpIfClause::Modifier>(OmpDirectiveNameParser{})))
+TYPE_PARSER(
+ sourced(construct<OmpIfClause::Modifier>(unwrap(OmpDirectiveNameParser{}))))
TYPE_PARSER(sourced(construct<OmpInReductionClause::Modifier>(
Parser<OmpReductionIdentifier>{})))
@@ -775,9 +799,9 @@ TYPE_PARSER(construct<OmpMessageClause>(expr))
TYPE_PARSER(construct<OmpHoldsClause>(indirect(expr)))
TYPE_PARSER(construct<OmpAbsentClause>(many(maybe(","_tok) >>
- construct<llvm::omp::Directive>(OmpDirectiveNameParser{}))))
+ construct<llvm::omp::Directive>(unwrap(OmpDirectiveNameParser{})))))
TYPE_PARSER(construct<OmpContainsClause>(many(maybe(","_tok) >>
- construct<llvm::omp::Directive>(OmpDirectiveNameParser{}))))
+ construct<llvm::omp::Directive>(unwrap(OmpDirectiveNameParser{})))))
TYPE_PARSER("ABSENT" >> construct<OmpClause>(construct<OmpClause::Absent>(
parenthesized(Parser<OmpAbsentClause>{}))) ||
@@ -972,7 +996,7 @@ TYPE_PARSER(sourced(construct<OmpErrorDirective>(
// --- Parsers for directives and constructs --------------------------
TYPE_PARSER(sourced(construct<OmpDirectiveSpecification>( //
- OmpDirectiveNameParser{},
+ sourced(OmpDirectiveNameParser{}),
maybe(parenthesized(nonemptyList(Parser<OmpArgument>{}))),
maybe(Parser<OmpClauseList>{}))))
diff --git a/flang/lib/Parser/parse-tree.cpp b/flang/lib/Parser/parse-tree.cpp
index 251b6919cf52f..e42022ceffa28 100644
--- a/flang/lib/Parser/parse-tree.cpp
+++ b/flang/lib/Parser/parse-tree.cpp
@@ -253,6 +253,21 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Name &x) {
return os << x.ToString();
}
+OmpDirectiveName::OmpDirectiveName(const Verbatim &name) {
+ std::string_view nameView{name.source.begin(), name.source.size()};
+ std::string nameLower{ToLowerCaseLetters(nameView)};
+ // If the name was actually "unknown" then accept it, otherwise flag
+ // OMPD_unknown (the default return value from getOpenMPDirectiveKind)
+ // as an error.
+ if (nameLower != "unknown") {
+ v = llvm::omp::getOpenMPDirectiveKind(nameLower);
+ assert(v != llvm::omp::Directive::OMPD_unknown && "Unrecognized directive");
+ } else {
+ v = llvm::omp::Directive::OMPD_unknown;
+ }
+ source = name.source;
+}
+
OmpDependenceType::Value OmpDoacross::GetDepType() const {
return common::visit( //
common::visitors{
diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp
index 1df17b6d7382b..4f5c05dc2aa25 100644
--- a/flang/lib/Parser/unparse.cpp
+++ b/flang/lib/Parser/unparse.cpp
@@ -2095,7 +2095,7 @@ class UnparseVisitor {
}
void Unparse(const OmpDirectiveSpecification &x) {
using ArgList = std::list<parser::OmpArgument>;
- Walk(std::get<llvm::omp::Directive>(x.t));
+ Walk(std::get<OmpDirectiveName>(x.t));
if (auto &args{std::get<std::optional<ArgList>>(x.t)}) {
Put("(");
Walk(*args);
diff --git a/flang/lib/Semantics/check-omp-structure.cpp b/flang/lib/Semantics/check-omp-structure.cpp
index c6ed211549401..64a0be703744d 100644
--- a/flang/lib/Semantics/check-omp-structure.cpp
+++ b/flang/lib/Semantics/check-omp-structure.cpp
@@ -625,7 +625,7 @@ void OmpStructureChecker::CheckHintClause(
}
void OmpStructureChecker::Enter(const parser::OmpDirectiveSpecification &x) {
- PushContextAndClauseSets(x.source, std::get<llvm::omp::Directive>(x.t));
+ PushContextAndClauseSets(x.source, x.DirId());
}
void OmpStructureChecker::Leave(const parser::OmpDirectiveSpecification &) {
diff --git a/flang/lib/Semantics/resolve-directives.cpp b/flang/lib/Semantics/resolve-directives.cpp
index 38888a4dc1461..977c2fef34091 100644
--- a/flang/lib/Semantics/resolve-directives.cpp
+++ b/flang/lib/Semantics/resolve-directives.cpp
@@ -352,7 +352,7 @@ class OmpAttributeVisitor : DirectiveAttributeVisitor<llvm::omp::Directive> {
}
bool Pre(const parser::OmpDirectiveSpecification &x) {
- PushContext(x.source, std::get<llvm::omp::Directive>(x.t));
+ PushContext(x.source, x.DirId());
return true;
}
void Post(const parser::OmpDirectiveSpecification &) { PopContext(); }
diff --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp
index 4f80cdca0f4bb..e57abf8ac0912 100644
--- a/flang/lib/Semantics/resolve-names.cpp
+++ b/flang/lib/Semantics/resolve-names.cpp
@@ -1775,11 +1775,10 @@ bool OmpVisitor::Pre(const parser::OmpDirectiveSpecification &x) {
// Disable the semantic analysis for it for now to allow the compiler to
// parse METADIRECTIVE without flagging errors.
AddOmpSourceRange(x.source);
- auto dirId{std::get<llvm::omp::Directive>(x.t)};
auto &maybeArgs{std::get<std::optional<std::list<parser::OmpArgument>>>(x.t)};
auto &maybeClauses{std::get<std::optional<parser::OmpClauseList>>(x.t)};
- switch (dirId) {
+ switch (x.DirId()) {
case llvm::omp::Directive::OMPD_declare_mapper:
if (maybeArgs && maybeClauses) {
const parser::OmpArgument &first{maybeArgs->front()};
diff --git a/flang/test/Parser/OpenMP/metadirective-dirspec.f90 b/flang/test/Parser/OpenMP/metadirective-dirspec.f90
index 73520c41fe77d..bf749d1f48c10 100644
--- a/flang/test/Parser/OpenMP/metadirective-dirspec.f90
+++ b/flang/test/Parser/OpenMP/metadirective-dirspec.f90
@@ -25,7 +25,7 @@ subroutine f00(x)
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = allocate
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = allocate
!PARSE-TREE: | | | OmpArgument -> OmpLocator -> OmpObject -> Designator -> DataRef -> Name = 'x'
!PARSE-TREE: | | | OmpClauseList ->
@@ -51,7 +51,7 @@ subroutine f01(x)
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = critical
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = critical
!PARSE-TREE: | | | OmpArgument -> OmpLocator -> OmpObject -> Designator -> DataRef -> Name = 'x'
!PARSE-TREE: | | | OmpClauseList ->
@@ -76,7 +76,7 @@ subroutine f02
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = declare mapper
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = declare mapper
!PARSE-TREE: | | | OmpArgument -> OmpMapperSpecifier
!PARSE-TREE: | | | | Name = 'mymapper'
!PARSE-TREE: | | | | TypeSpec -> IntrinsicTypeSpec -> IntegerTypeSpec ->
@@ -120,7 +120,7 @@ subroutine f03
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = declare reduction
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = declare reduction
!PARSE-TREE: | | | OmpArgument -> OmpReductionSpecifier
!PARSE-TREE: | | | | OmpReductionIdentifier -> DefinedOperator -> IntrinsicOperator = Add
!PARSE-TREE: | | | | OmpTypeNameList -> OmpTypeSpecifier -> TypeSpec -> DerivedTypeSpec
@@ -158,7 +158,7 @@ subroutine f04
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = declare simd
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = declare simd
!PARSE-TREE: | | | OmpArgument -> OmpLocator -> OmpObject -> Designator -> DataRef -> Name = 'f04'
!PARSE-TREE: | | | OmpClauseList ->
!PARSE-TREE: ImplicitPart ->
@@ -183,7 +183,7 @@ subroutine f05
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = declare target
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = declare target
!PARSE-TREE: | | | OmpArgument -> OmpLocator -> OmpObject -> Designator -> DataRef -> Name = 'f05'
!PARSE-TREE: | | | OmpClauseList ->
!PARSE-TREE: ImplicitPart ->
@@ -210,7 +210,7 @@ subroutine f06(x, y)
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = flush
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = flush
!PARSE-TREE: | | | OmpArgument -> OmpLocator -> OmpObject -> Designator -> DataRef -> Name = 'x'
!PARSE-TREE: | | | OmpArgument -> OmpLocator -> OmpObject -> Designator -> DataRef -> Name = 'y'
!PARSE-TREE: | | | OmpClauseList ->
@@ -237,6 +237,6 @@ subroutine f07
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = threadprivate
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = threadprivate
!PARSE-TREE: | | | OmpArgument -> OmpLocator -> OmpObject -> Designator -> DataRef -> Name = 't'
!PARSE-TREE: | | | OmpClauseList ->
diff --git a/flang/test/Parser/OpenMP/metadirective-v50.f90 b/flang/test/Parser/OpenMP/metadirective-v50.f90
index d7c3121b8f1b8..6fef3376470a6 100644
--- a/flang/test/Parser/OpenMP/metadirective-v50.f90
+++ b/flang/test/Parser/OpenMP/metadirective-v50.f90
@@ -24,8 +24,8 @@ subroutine f01
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = nothing
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = nothing
!PARSE-TREE: | | | OmpClauseList ->
!PARSE-TREE: | OmpClause -> Default -> OmpDefaultClause -> OmpDirectiveSpecification
-!PARSE-TREE: | | llvm::omp::Directive = nothing
+!PARSE-TREE: | | OmpDirectiveName -> llvm::omp::Directive = nothing
!PARSE-TREE: | | OmpClauseList ->
diff --git a/flang/test/Parser/OpenMP/metadirective.f90 b/flang/test/Parser/OpenMP/metadirective.f90
index dce31c2e7db26..1185ac897ecf6 100644
--- a/flang/test/Parser/OpenMP/metadirective.f90
+++ b/flang/test/Parser/OpenMP/metadirective.f90
@@ -20,7 +20,7 @@ subroutine f00
!PARSE-TREE: | | | OmpTraitSelector
!PARSE-TREE: | | | | OmpTraitSelectorName -> llvm::omp::Directive = parallel
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = nothing
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = nothing
!PARSE-TREE: | | | OmpClauseList ->
subroutine f01
@@ -47,7 +47,7 @@ subroutine f01
!PARSE-TREE: | | | | | OmpTraitProperty -> Scalar -> Expr = '1_4'
!PARSE-TREE: | | | | | | LiteralConstant -> IntLiteralConstant = '1'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = nothing
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = nothing
!PARSE-TREE: | | | OmpClauseList ->
subroutine f02
@@ -74,7 +74,7 @@ subroutine f02
!PARSE-TREE: | | | | | OmpTraitProperty -> Scalar -> Expr = '7_4'
!PARSE-TREE: | | | | | | LiteralConstant -> IntLiteralConstant = '7'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = nothing
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = nothing
!PARSE-TREE: | | | OmpClauseList ->
subroutine f03
@@ -98,7 +98,7 @@ subroutine f03
!PARSE-TREE: | | | | Properties
!PARSE-TREE: | | | | | OmpTraitProperty -> OmpClause -> AcqRel
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = nothing
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = nothing
!PARSE-TREE: | | | OmpClauseList ->
subroutine f04
@@ -132,7 +132,7 @@ subroutine f04
!PARSE-TREE: | | | | | | | OmpTraitPropertyExtension -> Scalar -> Expr = '1_4'
!PARSE-TREE: | | | | | | | | LiteralConstant -> IntLiteralConstant = '1'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = nothing
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = nothing
!PARSE-TREE: | | | OmpClauseList ->
subroutine f05(x)
@@ -168,12 +168,12 @@ subroutine f05(x)
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = parallel do
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = parallel do
!PARSE-TREE: | | | OmpClauseList -> OmpClause -> Reduction -> OmpReductionClause
!PARSE-TREE: | | | | Modifier -> OmpReductionIdentifier -> DefinedOperator -> IntrinsicOperator = Add
!PARSE-TREE: | | | | OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'x'
!PARSE-TREE: | OmpClause -> Otherwise -> OmpOtherwiseClause -> OmpDirectiveSpecification
-!PARSE-TREE: | | llvm::omp::Directive = nothing
+!PARSE-TREE: | | OmpDirectiveName -> llvm::omp::Directive = nothing
!PARSE-TREE: | | OmpClauseList ->
subroutine f06
@@ -207,7 +207,7 @@ subroutine f06
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = nothing
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = nothing
!PARSE-TREE: | | | OmpClauseList ->
subroutine f07
@@ -232,7 +232,7 @@ subroutine f07
!PARSE-TREE: | | | | Properties
!PARSE-TREE: | | | | | OmpTraitProperty -> OmpTraitPropertyName -> string = 'amd'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = declare simd
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = declare simd
!PARSE-TREE: | | | OmpClauseList ->
!PARSE-TREE: | OmpClause -> When -> OmpWhenClause
!PARSE-TREE: | | Modifier -> OmpContextSelectorSpecification -> OmpTraitSetSelector
@@ -244,8 +244,8 @@ subroutine f07
!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
!PARSE-TREE: | | | | | | | bool = 'true'
!PARSE-TREE: | | OmpDirectiveSpecification
-!PARSE-TREE: | | | llvm::omp::Directive = declare target
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = declare target
!PARSE-TREE: | | | OmpClauseList ->
!PARSE-TREE: | OmpClause -> Otherwise -> OmpOtherwiseClause -> OmpDirectiveSpecification
-!PARSE-TREE: | | llvm::omp::Directive = nothing
-!PARSE-TREE: | | OmpClauseList ->
\ No newline at end of file
+!PARSE-TREE: | | OmpDirectiveName -> llvm::omp::Directive = nothing
+!PARSE-TREE: | | OmpClauseList ->
>From bf56b8c80a0f1a7e06dcd3e898172c27e5afabf5 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Wed, 5 Mar 2025 08:24:30 -0600
Subject: [PATCH 02/10] [flang][OpenMP] Accept old FLUSH syntax in
METADIRECTIVE
Accommodate it in OmpDirectiveSpecification, which may become the
primary component of the actual FLUSH construct in the future.
---
flang/include/flang/Parser/dump-parse-tree.h | 1 +
flang/include/flang/Parser/parse-tree.h | 6 ++-
flang/lib/Parser/openmp-parsers.cpp | 32 +++++++++--
flang/lib/Parser/unparse.cpp | 28 +++++++---
.../Parser/OpenMP/metadirective-flush.f90 | 54 +++++++++++++++++++
5 files changed, 109 insertions(+), 12 deletions(-)
create mode 100644 flang/test/Parser/OpenMP/metadirective-flush.f90
diff --git a/flang/include/flang/Parser/dump-parse-tree.h b/flang/include/flang/Parser/dump-parse-tree.h
index a154794e41e9d..fcd902d25fa40 100644
--- a/flang/include/flang/Parser/dump-parse-tree.h
+++ b/flang/include/flang/Parser/dump-parse-tree.h
@@ -491,6 +491,7 @@ class ParseTreeDumper {
NODE(OmpWhenClause, Modifier)
NODE(parser, OmpDirectiveName)
NODE(parser, OmpDirectiveSpecification)
+ NODE_ENUM(OmpDirectiveSpecification, Flags)
NODE(parser, OmpTraitPropertyName)
NODE(parser, OmpTraitScore)
NODE(parser, OmpTraitPropertyExtension)
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index 346299b8e5215..a197249ebae91 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -4503,13 +4503,15 @@ struct OmpClauseList {
// --- Directives and constructs
struct OmpDirectiveSpecification {
- CharBlock source;
+ ENUM_CLASS(Flags, None, DeprecatedSyntax);
TUPLE_CLASS_BOILERPLATE(OmpDirectiveSpecification);
llvm::omp::Directive DirId() const { //
return std::get<OmpDirectiveName>(t).v;
}
+
+ CharBlock source;
std::tuple<OmpDirectiveName, std::optional<std::list<OmpArgument>>,
- std::optional<OmpClauseList>>
+ std::optional<OmpClauseList>, Flags>
t;
};
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index b3e76d70c8064..0de7690b90262 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -995,10 +995,34 @@ TYPE_PARSER(sourced(construct<OmpErrorDirective>(
// --- Parsers for directives and constructs --------------------------
-TYPE_PARSER(sourced(construct<OmpDirectiveSpecification>( //
- sourced(OmpDirectiveNameParser{}),
- maybe(parenthesized(nonemptyList(Parser<OmpArgument>{}))),
- maybe(Parser<OmpClauseList>{}))))
+OmpDirectiveSpecification static makeFlushFromOldSyntax1(
+ Verbatim &&text, std::optional<OmpClauseList> &&clauses,
+ std::optional<std::list<OmpArgument>> &&args,
+ OmpDirectiveSpecification::Flags &&flags) {
+ return OmpDirectiveSpecification{OmpDirectiveName(text), std::move(args),
+ std::move(clauses), std::move(flags)};
+}
+
+TYPE_PARSER(sourced(
+ // Parse the old syntax: FLUSH [clauses] [(objects)]
+ construct<OmpDirectiveSpecification>( //
+ // Force this old-syntax parser to fail for FLUSH followed by '('.
+ // Otherwise it could succeed on the new syntax but have one of
+ // lists absent in the parsed result.
+ // E.g. for FLUSH(x) SEQ_CST it would find no clauses following
+ // the directive name, parse the argument list "(x)" and stop.
+ applyFunction(makeFlushFromOldSyntax1,
+ verbatim("FLUSH"_tok) / !lookAhead("("_tok),
+ maybe(Parser<OmpClauseList>{}),
+ maybe(parenthesized(nonemptyList(Parser<OmpArgument>{}))),
+ pure(OmpDirectiveSpecification::Flags::DeprecatedSyntax))) ||
+ // Parse the standard syntax: directive [(arguments)] [clauses]
+ construct<OmpDirectiveSpecification>( //
+ sourced(OmpDirectiveNameParser{}),
+ maybe(parenthesized(nonemptyList(Parser<OmpArgument>{}))),
+ maybe(Parser<OmpClauseList>{}),
+ pure(OmpDirectiveSpecification::Flags::None))
+))
TYPE_PARSER(sourced(construct<OmpNothingDirective>("NOTHING" >> ok)))
diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp
index 4f5c05dc2aa25..262077e62441b 100644
--- a/flang/lib/Parser/unparse.cpp
+++ b/flang/lib/Parser/unparse.cpp
@@ -2094,14 +2094,30 @@ class UnparseVisitor {
Word(llvm::omp::getOpenMPDirectiveName(x).str());
}
void Unparse(const OmpDirectiveSpecification &x) {
- using ArgList = std::list<parser::OmpArgument>;
+ auto unparseArgs{[&]() {
+ using ArgList = std::list<parser::OmpArgument>;
+ if (auto &args{std::get<std::optional<ArgList>>(x.t)}) {
+ Put("(");
+ Walk(*args);
+ Put(")");
+ }
+ }};
+ auto unparseClauses{[&]() {
+ Walk(std::get<std::optional<OmpClauseList>>(x.t));
+ }};
+
Walk(std::get<OmpDirectiveName>(x.t));
- if (auto &args{std::get<std::optional<ArgList>>(x.t)}) {
- Put("(");
- Walk(*args);
- Put(")");
+ auto flags{std::get<OmpDirectiveSpecification::Flags>(x.t)};
+ if (flags == OmpDirectiveSpecification::Flags::DeprecatedSyntax) {
+ if (x.DirId() == llvm::omp::Directive::OMPD_flush) {
+ // FLUSH clause arglist
+ unparseClauses();
+ unparseArgs();
+ }
+ } else {
+ unparseArgs();
+ unparseClauses();
}
- Walk(std::get<std::optional<OmpClauseList>>(x.t));
}
void Unparse(const OmpTraitScore &x) {
Word("SCORE(");
diff --git a/flang/test/Parser/OpenMP/metadirective-flush.f90 b/flang/test/Parser/OpenMP/metadirective-flush.f90
new file mode 100644
index 0000000000000..8403663200f93
--- /dev/null
+++ b/flang/test/Parser/OpenMP/metadirective-flush.f90
@@ -0,0 +1,54 @@
+!RUN: %flang_fc1 -fdebug-unparse -fopenmp -fopenmp-version=52 %s | FileCheck --ignore-case --check-prefix="UNPARSE" %s
+!RUN: %flang_fc1 -fdebug-dump-parse-tree -fopenmp -fopenmp-version=52 %s | FileCheck --check-prefix="PARSE-TREE" %s
+
+subroutine f00()
+ integer :: x
+ !$omp metadirective when(user={condition(.true.)}: flush seq_cst (x))
+end
+
+!UNPARSE: SUBROUTINE f00
+!UNPARSE: INTEGER x
+!UNPARSE: !$OMP METADIRECTIVE WHEN(USER={CONDITION(.true._4)}: FLUSH SEQ_CST(x))
+!UNPARSE: END SUBROUTINE
+
+!PARSE-TREE: OmpMetadirectiveDirective
+!PARSE-TREE: | OmpClauseList -> OmpClause -> When -> OmpWhenClause
+!PARSE-TREE: | | Modifier -> OmpContextSelectorSpecification -> OmpTraitSetSelector
+!PARSE-TREE: | | | OmpTraitSetSelectorName -> Value = User
+!PARSE-TREE: | | | OmpTraitSelector
+!PARSE-TREE: | | | | OmpTraitSelectorName -> Value = Condition
+!PARSE-TREE: | | | | Properties
+!PARSE-TREE: | | | | | OmpTraitProperty -> Scalar -> Expr = '.true._4'
+!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
+!PARSE-TREE: | | | | | | | bool = 'true'
+!PARSE-TREE: | | OmpDirectiveSpecification
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = flush
+!PARSE-TREE: | | | OmpArgument -> OmpLocator -> OmpObject -> Designator -> DataRef -> Name = 'x'
+!PARSE-TREE: | | | OmpClauseList -> OmpClause -> SeqCst
+!PARSE-TREE: | | | Flags = DeprecatedSyntax
+
+subroutine f01()
+ integer :: x
+ !$omp metadirective when(user={condition(.true.)}: flush(x) seq_cst)
+end
+
+!UNPARSE: SUBROUTINE f01
+!UNPARSE: INTEGER x
+!UNPARSE: !$OMP METADIRECTIVE WHEN(USER={CONDITION(.true._4)}: FLUSH(x) SEQ_CST)
+!UNPARSE: END SUBROUTINE
+
+!PARSE-TREE: OmpMetadirectiveDirective
+!PARSE-TREE: | OmpClauseList -> OmpClause -> When -> OmpWhenClause
+!PARSE-TREE: | | Modifier -> OmpContextSelectorSpecification -> OmpTraitSetSelector
+!PARSE-TREE: | | | OmpTraitSetSelectorName -> Value = User
+!PARSE-TREE: | | | OmpTraitSelector
+!PARSE-TREE: | | | | OmpTraitSelectorName -> Value = Condition
+!PARSE-TREE: | | | | Properties
+!PARSE-TREE: | | | | | OmpTraitProperty -> Scalar -> Expr = '.true._4'
+!PARSE-TREE: | | | | | | LiteralConstant -> LogicalLiteralConstant
+!PARSE-TREE: | | | | | | | bool = 'true'
+!PARSE-TREE: | | OmpDirectiveSpecification
+!PARSE-TREE: | | | OmpDirectiveName -> llvm::omp::Directive = flush
+!PARSE-TREE: | | | OmpArgument -> OmpLocator -> OmpObject -> Designator -> DataRef -> Name = 'x'
+!PARSE-TREE: | | | OmpClauseList -> OmpClause -> SeqCst
+!PARSE-TREE: | | | Flags = None
>From 00e6f062b3420d1edd0776262905c874e3267d53 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Thu, 6 Mar 2025 09:50:57 -0600
Subject: [PATCH 03/10] format
---
flang/lib/Parser/openmp-parsers.cpp | 11 +++++------
flang/lib/Parser/unparse.cpp | 2 +-
2 files changed, 6 insertions(+), 7 deletions(-)
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index 0de7690b90262..80831db0e7d50 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -995,17 +995,17 @@ TYPE_PARSER(sourced(construct<OmpErrorDirective>(
// --- Parsers for directives and constructs --------------------------
-OmpDirectiveSpecification static makeFlushFromOldSyntax1(
- Verbatim &&text, std::optional<OmpClauseList> &&clauses,
+OmpDirectiveSpecification static makeFlushFromOldSyntax1(Verbatim &&text,
+ std::optional<OmpClauseList> &&clauses,
std::optional<std::list<OmpArgument>> &&args,
OmpDirectiveSpecification::Flags &&flags) {
return OmpDirectiveSpecification{OmpDirectiveName(text), std::move(args),
- std::move(clauses), std::move(flags)};
+ std::move(clauses), std::move(flags)};
}
TYPE_PARSER(sourced(
// Parse the old syntax: FLUSH [clauses] [(objects)]
- construct<OmpDirectiveSpecification>( //
+ construct<OmpDirectiveSpecification>(
// Force this old-syntax parser to fail for FLUSH followed by '('.
// Otherwise it could succeed on the new syntax but have one of
// lists absent in the parsed result.
@@ -1021,8 +1021,7 @@ TYPE_PARSER(sourced(
sourced(OmpDirectiveNameParser{}),
maybe(parenthesized(nonemptyList(Parser<OmpArgument>{}))),
maybe(Parser<OmpClauseList>{}),
- pure(OmpDirectiveSpecification::Flags::None))
-))
+ pure(OmpDirectiveSpecification::Flags::None))))
TYPE_PARSER(sourced(construct<OmpNothingDirective>("NOTHING" >> ok)))
diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp
index 262077e62441b..12d86653a2b95 100644
--- a/flang/lib/Parser/unparse.cpp
+++ b/flang/lib/Parser/unparse.cpp
@@ -2102,7 +2102,7 @@ class UnparseVisitor {
Put(")");
}
}};
- auto unparseClauses{[&]() {
+ auto unparseClauses{[&]() { //
Walk(std::get<std::optional<OmpClauseList>>(x.t));
}};
>From 25b1b4bef48d57d12fbd8a98e6f549b81ce8cc73 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Thu, 6 Mar 2025 11:02:59 -0600
Subject: [PATCH 04/10] Address review comments
---
flang/include/flang/Parser/parse-tree.h | 1 +
flang/lib/Parser/openmp-parsers.cpp | 2 ++
flang/lib/Parser/parse-tree.cpp | 20 +++++++++++---------
3 files changed, 14 insertions(+), 9 deletions(-)
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index 346299b8e5215..5b737cf497584 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -3470,6 +3470,7 @@ struct OmpDirectiveName {
constexpr OmpDirectiveName(const OmpDirectiveName &) = default;
// Construct from an already parsed text. Use Verbatim for this because
// Verbatim's source corresponds to an actual source location.
+ // This allows "construct<OmpDirectiveName>(Verbatim("<name>"))".
OmpDirectiveName(const Verbatim &name);
using WrapperTrait = std::true_type;
CharBlock source;
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index b3e76d70c8064..80a8765b3e87a 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -27,6 +27,8 @@ namespace Fortran::parser {
constexpr auto startOmpLine = skipStuffBeforeStatement >> "!$OMP "_sptok;
constexpr auto endOmpLine = space >> endOfLine;
+// Given a parser P for a wrapper class, invoke P, and if it succeeds return
+// the wrapped object.
template <typename Parser> struct UnwrapParser {
static_assert(
Parser::resultType::WrapperTrait::value && "Wrapper class required");
diff --git a/flang/lib/Parser/parse-tree.cpp b/flang/lib/Parser/parse-tree.cpp
index e42022ceffa28..2e37710832059 100644
--- a/flang/lib/Parser/parse-tree.cpp
+++ b/flang/lib/Parser/parse-tree.cpp
@@ -256,15 +256,17 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Name &x) {
OmpDirectiveName::OmpDirectiveName(const Verbatim &name) {
std::string_view nameView{name.source.begin(), name.source.size()};
std::string nameLower{ToLowerCaseLetters(nameView)};
- // If the name was actually "unknown" then accept it, otherwise flag
- // OMPD_unknown (the default return value from getOpenMPDirectiveKind)
- // as an error.
- if (nameLower != "unknown") {
- v = llvm::omp::getOpenMPDirectiveKind(nameLower);
- assert(v != llvm::omp::Directive::OMPD_unknown && "Unrecognized directive");
- } else {
- v = llvm::omp::Directive::OMPD_unknown;
- }
+ // The function getOpenMPDirectiveKind will return OMPD_unknown in two cases:
+ // (1) if the given string doesn't match any actual directive, or
+ // (2) if the given string was "unknown".
+ // The Verbatim(<token>) parser will succeed as long as the given token
+ // matches the source.
+ // Since using "construct<OmpDirectiveName>(verbatim(...))" will succeed
+ // if the verbatim parser succeeds, in order to get OMPD_unknown the
+ // token given to Verbatim must be invalid. Because it's an internal issue
+ // asserting is ok.
+ v = llvm::omp::getOpenMPDirectiveKind(nameLower);
+ assert(v != llvm::omp::Directive::OMPD_unknown && "Invalid directive name");
source = name.source;
}
>From 98df18461bb06afa06b8968b157a3c5a5cf50324 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Thu, 6 Mar 2025 08:51:34 -0600
Subject: [PATCH 05/10] [flang][OpenMP] Parse cancel-directive-name as clause
The cancellable construct names on CANCEL or CANCELLATION POINT directives
are actually clauses (with the same names as the corresponding constructs).
Instead of parsing them into a custom structure, parse them as a clause,
which will make CANCEL/CANCELLATION POINT follow the same uniform scheme
as other constructs (<directive> [(<arguments>)] [clauses]).
---
flang/include/flang/Parser/dump-parse-tree.h | 2 +-
flang/include/flang/Parser/parse-tree.h | 11 +-
flang/lib/Parser/openmp-parsers.cpp | 31 ++++-
flang/lib/Parser/unparse.cpp | 5 +-
flang/lib/Semantics/check-omp-structure.cpp | 133 +++++++++++++------
flang/lib/Semantics/check-omp-structure.h | 5 +-
flang/test/Semantics/OpenMP/cancel.f90 | 29 ++++
llvm/include/llvm/Frontend/OpenMP/OMP.td | 5 +
8 files changed, 169 insertions(+), 52 deletions(-)
create mode 100644 flang/test/Semantics/OpenMP/cancel.f90
diff --git a/flang/include/flang/Parser/dump-parse-tree.h b/flang/include/flang/Parser/dump-parse-tree.h
index fcd902d25fa40..004e22a21ecfa 100644
--- a/flang/include/flang/Parser/dump-parse-tree.h
+++ b/flang/include/flang/Parser/dump-parse-tree.h
@@ -546,6 +546,7 @@ class ParseTreeDumper {
#define GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
#include "llvm/Frontend/OpenMP/OMP.inc"
NODE(parser, OmpClauseList)
+ NODE(parser, OmpCancellationConstructTypeClause)
NODE(parser, OmpContainsClause)
NODE(parser, OmpCriticalDirective)
NODE(parser, OmpErrorDirective)
@@ -689,7 +690,6 @@ class ParseTreeDumper {
NODE(parser, OpenMPAtomicConstruct)
NODE(parser, OpenMPBlockConstruct)
NODE(parser, OpenMPCancelConstruct)
- NODE(OpenMPCancelConstruct, If)
NODE(parser, OpenMPCancellationPointConstruct)
NODE(parser, OpenMPConstruct)
NODE(parser, OpenMPCriticalConstruct)
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index a197249ebae91..cb0eb884e1193 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -4048,6 +4048,12 @@ struct OmpBindClause {
WRAPPER_CLASS_BOILERPLATE(OmpBindClause, Binding);
};
+// Artificial clause to represent a cancellable construct.
+struct OmpCancellationConstructTypeClause {
+ TUPLE_CLASS_BOILERPLATE(OmpCancellationConstructTypeClause);
+ std::tuple<OmpDirectiveName, std::optional<ScalarLogicalExpr>> t;
+};
+
// Ref: [5.2:214]
//
// contains-clause ->
@@ -4870,15 +4876,14 @@ struct OmpCancelType {
struct OpenMPCancellationPointConstruct {
TUPLE_CLASS_BOILERPLATE(OpenMPCancellationPointConstruct);
CharBlock source;
- std::tuple<Verbatim, OmpCancelType> t;
+ std::tuple<Verbatim, OmpClauseList> t;
};
// 2.14.1 cancel -> CANCEL construct-type-clause [ [,] if-clause]
struct OpenMPCancelConstruct {
TUPLE_CLASS_BOILERPLATE(OpenMPCancelConstruct);
- WRAPPER_CLASS(If, ScalarLogicalExpr);
CharBlock source;
- std::tuple<Verbatim, OmpCancelType, std::optional<If>> t;
+ std::tuple<Verbatim, OmpClauseList> t;
};
// Ref: [5.0:254-255], [5.1:287-288], [5.2:322-323]
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index 80831db0e7d50..51b2567a3894d 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -803,8 +803,9 @@ TYPE_PARSER(construct<OmpAbsentClause>(many(maybe(","_tok) >>
TYPE_PARSER(construct<OmpContainsClause>(many(maybe(","_tok) >>
construct<llvm::omp::Directive>(unwrap(OmpDirectiveNameParser{})))))
-TYPE_PARSER("ABSENT" >> construct<OmpClause>(construct<OmpClause::Absent>(
- parenthesized(Parser<OmpAbsentClause>{}))) ||
+TYPE_PARSER( //
+ "ABSENT" >> construct<OmpClause>(construct<OmpClause::Absent>(
+ parenthesized(Parser<OmpAbsentClause>{}))) ||
"ACQUIRE" >> construct<OmpClause>(construct<OmpClause::Acquire>()) ||
"ACQ_REL" >> construct<OmpClause>(construct<OmpClause::AcqRel>()) ||
"AFFINITY" >> construct<OmpClause>(construct<OmpClause::Affinity>(
@@ -981,7 +982,24 @@ TYPE_PARSER("ABSENT" >> construct<OmpClause>(construct<OmpClause::Absent>(
"UPDATE" >> construct<OmpClause>(construct<OmpClause::Update>(
parenthesized(Parser<OmpUpdateClause>{}))) ||
"WHEN" >> construct<OmpClause>(construct<OmpClause::When>(
- parenthesized(Parser<OmpWhenClause>{}))))
+ parenthesized(Parser<OmpWhenClause>{}))) ||
+ // Cancellable constructs
+ construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
+ construct<OmpCancellationConstructTypeClause>( //
+ construct<OmpDirectiveName>(verbatim("DO"_id)),
+ maybe(parenthesized(scalarLogicalExpr))))) ||
+ construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
+ construct<OmpCancellationConstructTypeClause>( //
+ construct<OmpDirectiveName>(verbatim("PARALLEL"_id)),
+ maybe(parenthesized(scalarLogicalExpr))))) ||
+ construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
+ construct<OmpCancellationConstructTypeClause>( //
+ construct<OmpDirectiveName>(verbatim("SECTIONS"_id)),
+ maybe(parenthesized(scalarLogicalExpr))))) ||
+ construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
+ construct<OmpCancellationConstructTypeClause>( //
+ construct<OmpDirectiveName>(verbatim("TASKGROUP"_id)),
+ maybe(parenthesized(scalarLogicalExpr))))))
// [Clause, [Clause], ...]
TYPE_PARSER(sourced(construct<OmpClauseList>(
@@ -1104,11 +1122,11 @@ TYPE_PARSER(sourced(construct<OmpCancelType>(
// 2.14.2 Cancellation Point construct
TYPE_PARSER(sourced(construct<OpenMPCancellationPointConstruct>(
- verbatim("CANCELLATION POINT"_tok), Parser<OmpCancelType>{})))
+ verbatim("CANCELLATION POINT"_tok), Parser<OmpClauseList>{})))
// 2.14.1 Cancel construct
TYPE_PARSER(sourced(construct<OpenMPCancelConstruct>(verbatim("CANCEL"_tok),
- Parser<OmpCancelType>{}, maybe("IF" >> parenthesized(scalarLogicalExpr)))))
+ Parser<OmpClauseList>{})))
TYPE_PARSER(sourced(construct<OmpFailClause>(
parenthesized(indirect(Parser<OmpMemoryOrderClause>{})))))
@@ -1192,9 +1210,10 @@ TYPE_PARSER(
sourced(construct<OpenMPStandaloneConstruct>(
Parser<OpenMPSimpleStandaloneConstruct>{}) ||
construct<OpenMPStandaloneConstruct>(Parser<OpenMPFlushConstruct>{}) ||
- construct<OpenMPStandaloneConstruct>(Parser<OpenMPCancelConstruct>{}) ||
+ // Try CANCELLATION POINT before CANCEL.
construct<OpenMPStandaloneConstruct>(
Parser<OpenMPCancellationPointConstruct>{}) ||
+ construct<OpenMPStandaloneConstruct>(Parser<OpenMPCancelConstruct>{}) ||
construct<OpenMPStandaloneConstruct>(
Parser<OmpMetadirectiveDirective>{}) ||
construct<OpenMPStandaloneConstruct>(Parser<OpenMPDepobjConstruct>{})) /
diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp
index 12d86653a2b95..11ce214450d96 100644
--- a/flang/lib/Parser/unparse.cpp
+++ b/flang/lib/Parser/unparse.cpp
@@ -2851,15 +2851,14 @@ class UnparseVisitor {
void Unparse(const OpenMPCancellationPointConstruct &x) {
BeginOpenMP();
Word("!$OMP CANCELLATION POINT ");
- Walk(std::get<OmpCancelType>(x.t));
+ Walk(std::get<OmpClauseList>(x.t));
Put("\n");
EndOpenMP();
}
void Unparse(const OpenMPCancelConstruct &x) {
BeginOpenMP();
Word("!$OMP CANCEL ");
- Walk(std::get<OmpCancelType>(x.t));
- Walk(std::get<std::optional<OpenMPCancelConstruct::If>>(x.t));
+ Walk(std::get<OmpClauseList>(x.t));
Put("\n");
EndOpenMP();
}
diff --git a/flang/lib/Semantics/check-omp-structure.cpp b/flang/lib/Semantics/check-omp-structure.cpp
index 64a0be703744d..8d819defb4a0c 100644
--- a/flang/lib/Semantics/check-omp-structure.cpp
+++ b/flang/lib/Semantics/check-omp-structure.cpp
@@ -2176,9 +2176,13 @@ void OmpStructureChecker::Leave(const parser::OpenMPFlushConstruct &x) {
void OmpStructureChecker::Enter(const parser::OpenMPCancelConstruct &x) {
const auto &dir{std::get<parser::Verbatim>(x.t)};
- const auto &type{std::get<parser::OmpCancelType>(x.t)};
+ const auto &clauses{std::get<parser::OmpClauseList>(x.t)};
PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_cancel);
- CheckCancellationNest(dir.source, type.v);
+
+ if (auto maybeConstruct{GetCancelType(
+ llvm::omp::Directive::OMPD_cancel, x.source, clauses)}) {
+ CheckCancellationNest(dir.source, *maybeConstruct);
+ }
}
void OmpStructureChecker::Leave(const parser::OpenMPCancelConstruct &) {
@@ -2228,13 +2232,38 @@ void OmpStructureChecker::Leave(const parser::OpenMPCriticalConstruct &) {
dirContext_.pop_back();
}
+void OmpStructureChecker::Enter(
+ const parser::OmpClause::CancellationConstructType &x) {
+ // Do not call CheckAllowed/CheckAllowedClause, because in case of an error
+ // it will print "CANCELLATION_CONSTRUCT_TYPE" as the clause name instead of
+ // the contained construct name.
+ auto &dirName{std::get<parser::OmpDirectiveName>(x.v.t)};
+ switch (dirName.v) {
+ case llvm::omp::Directive::OMPD_do:
+ case llvm::omp::Directive::OMPD_parallel:
+ case llvm::omp::Directive::OMPD_sections:
+ case llvm::omp::Directive::OMPD_taskgroup:
+ break;
+ default:
+ context_.Say(dirName.source,
+ "%s is not a cancellable construct"_err_en_US,
+ parser::ToUpperCaseLetters(
+ llvm::omp::getOpenMPDirectiveName(dirName.v).str()));
+ break;
+ }
+}
+
void OmpStructureChecker::Enter(
const parser::OpenMPCancellationPointConstruct &x) {
const auto &dir{std::get<parser::Verbatim>(x.t)};
- const auto &type{std::get<parser::OmpCancelType>(x.t)};
+ const auto &clauses{std::get<parser::OmpClauseList>(x.t)};
PushContextAndClauseSets(
dir.source, llvm::omp::Directive::OMPD_cancellation_point);
- CheckCancellationNest(dir.source, type.v);
+
+ if (auto maybeConstruct{GetCancelType(
+ llvm::omp::Directive::OMPD_cancellation_point, x.source, clauses)}) {
+ CheckCancellationNest(dir.source, *maybeConstruct);
+ }
}
void OmpStructureChecker::Leave(
@@ -2242,8 +2271,42 @@ void OmpStructureChecker::Leave(
dirContext_.pop_back();
}
+std::optional<llvm::omp::Directive> OmpStructureChecker::GetCancelType(
+ llvm::omp::Directive cancelDir, const parser::CharBlock &cancelSource,
+ const parser::OmpClauseList &clauses) {
+ // Given clauses from CANCEL or CANCELLATION_POINT, identify the construct
+ // to which the cancellation applies.
+ std::optional<llvm::omp::Directive> cancelee;
+ llvm::StringRef cancelName{llvm::omp::getOpenMPDirectiveName(cancelDir)};
+
+ for (const parser::OmpClause &clause : clauses.v) {
+ using CancellationConstructType =
+ parser::OmpClause::CancellationConstructType;
+ if (auto *cctype{std::get_if<CancellationConstructType>(&clause.u)}) {
+ if (cancelee) {
+ context_.Say(cancelSource,
+ "Multiple cancel-directive-name clauses are not allowed on the %s construct"_err_en_US,
+ parser::ToUpperCaseLetters(cancelName.str()));
+ return std::nullopt;
+ }
+ cancelee = std::get<parser::OmpDirectiveName>(cctype->v.t).v;
+ }
+ }
+
+ if (!cancelee) {
+ context_.Say(cancelSource,
+ "Missing cancel-directive-name clause on the %s construct"_err_en_US,
+ parser::ToUpperCaseLetters(cancelName.str()));
+ return std::nullopt;
+ }
+
+ return cancelee;
+}
+
void OmpStructureChecker::CheckCancellationNest(
- const parser::CharBlock &source, const parser::OmpCancelType::Type &type) {
+ const parser::CharBlock &source, llvm::omp::Directive type) {
+ llvm::StringRef typeName{llvm::omp::getOpenMPDirectiveName(type)};
+
if (CurrentDirectiveIsNested()) {
// If construct-type-clause is taskgroup, the cancellation construct must be
// closely nested inside a task or a taskloop construct and the cancellation
@@ -2254,8 +2317,9 @@ void OmpStructureChecker::CheckCancellationNest(
// that matches the type specified in construct-type-clause of the
// cancellation construct.
bool eligibleCancellation{false};
+
switch (type) {
- case parser::OmpCancelType::Type::Taskgroup:
+ case llvm::omp::Directive::OMPD_taskgroup:
if (llvm::omp::nestedCancelTaskgroupAllowedSet.test(
GetContextParent().directive)) {
eligibleCancellation = true;
@@ -2281,38 +2345,37 @@ void OmpStructureChecker::CheckCancellationNest(
}
if (!eligibleCancellation) {
context_.Say(source,
- "With %s clause, %s construct must be closely nested inside TASK "
- "or TASKLOOP construct and %s region must be closely nested inside "
- "TASKGROUP region"_err_en_US,
- parser::ToUpperCaseLetters(
- parser::OmpCancelType::EnumToString(type)),
+ "With %s clause, %s construct must be closely nested inside TASK or TASKLOOP construct and %s region must be closely nested inside TASKGROUP region"_err_en_US,
+ parser::ToUpperCaseLetters(typeName.str()),
ContextDirectiveAsFortran(), ContextDirectiveAsFortran());
}
return;
- case parser::OmpCancelType::Type::Sections:
+ case llvm::omp::Directive::OMPD_sections:
if (llvm::omp::nestedCancelSectionsAllowedSet.test(
GetContextParent().directive)) {
eligibleCancellation = true;
}
break;
- case parser::OmpCancelType::Type::Do:
+ case llvm::omp::Directive::OMPD_do:
if (llvm::omp::nestedCancelDoAllowedSet.test(
GetContextParent().directive)) {
eligibleCancellation = true;
}
break;
- case parser::OmpCancelType::Type::Parallel:
+ case llvm::omp::Directive::OMPD_parallel:
if (llvm::omp::nestedCancelParallelAllowedSet.test(
GetContextParent().directive)) {
eligibleCancellation = true;
}
break;
+ default:
+ // This should have been diagnosed by this point.
+ llvm_unreachable("Unexpected directive");
}
if (!eligibleCancellation) {
context_.Say(source,
- "With %s clause, %s construct cannot be closely nested inside %s "
- "construct"_err_en_US,
- parser::ToUpperCaseLetters(parser::OmpCancelType::EnumToString(type)),
+ "With %s clause, %s construct cannot be closely nested inside %s construct"_err_en_US,
+ parser::ToUpperCaseLetters(typeName.str()),
ContextDirectiveAsFortran(),
parser::ToUpperCaseLetters(
getDirectiveName(GetContextParent().directive).str()));
@@ -2320,38 +2383,33 @@ void OmpStructureChecker::CheckCancellationNest(
} else {
// The cancellation directive cannot be orphaned.
switch (type) {
- case parser::OmpCancelType::Type::Taskgroup:
+ case llvm::omp::Directive::OMPD_taskgroup:
context_.Say(source,
- "%s %s directive is not closely nested inside "
- "TASK or TASKLOOP"_err_en_US,
+ "%s %s directive is not closely nested inside TASK or TASKLOOP"_err_en_US,
ContextDirectiveAsFortran(),
- parser::ToUpperCaseLetters(
- parser::OmpCancelType::EnumToString(type)));
+ parser::ToUpperCaseLetters(typeName.str()));
break;
- case parser::OmpCancelType::Type::Sections:
+ case llvm::omp::Directive::OMPD_sections:
context_.Say(source,
- "%s %s directive is not closely nested inside "
- "SECTION or SECTIONS"_err_en_US,
+ "%s %s directive is not closely nested inside SECTION or SECTIONS"_err_en_US,
ContextDirectiveAsFortran(),
- parser::ToUpperCaseLetters(
- parser::OmpCancelType::EnumToString(type)));
+ parser::ToUpperCaseLetters(typeName.str()));
break;
- case parser::OmpCancelType::Type::Do:
+ case llvm::omp::Directive::OMPD_do:
context_.Say(source,
- "%s %s directive is not closely nested inside "
- "the construct that matches the DO clause type"_err_en_US,
+ "%s %s directive is not closely nested inside the construct that matches the DO clause type"_err_en_US,
ContextDirectiveAsFortran(),
- parser::ToUpperCaseLetters(
- parser::OmpCancelType::EnumToString(type)));
+ parser::ToUpperCaseLetters(typeName.str()));
break;
- case parser::OmpCancelType::Type::Parallel:
+ case llvm::omp::Directive::OMPD_parallel:
context_.Say(source,
- "%s %s directive is not closely nested inside "
- "the construct that matches the PARALLEL clause type"_err_en_US,
+ "%s %s directive is not closely nested inside the construct that matches the PARALLEL clause type"_err_en_US,
ContextDirectiveAsFortran(),
- parser::ToUpperCaseLetters(
- parser::OmpCancelType::EnumToString(type)));
+ parser::ToUpperCaseLetters(typeName.str()));
break;
+ default:
+ // This should have been diagnosed by this point.
+ llvm_unreachable("Unexpected directive");
}
}
}
@@ -3044,7 +3102,6 @@ CHECK_SIMPLE_CLAUSE(MemoryOrder, OMPC_memory_order)
CHECK_SIMPLE_CLAUSE(Bind, OMPC_bind)
CHECK_SIMPLE_CLAUSE(Align, OMPC_align)
CHECK_SIMPLE_CLAUSE(Compare, OMPC_compare)
-CHECK_SIMPLE_CLAUSE(CancellationConstructType, OMPC_cancellation_construct_type)
CHECK_SIMPLE_CLAUSE(OmpxAttribute, OMPC_ompx_attribute)
CHECK_SIMPLE_CLAUSE(Weak, OMPC_weak)
diff --git a/flang/lib/Semantics/check-omp-structure.h b/flang/lib/Semantics/check-omp-structure.h
index b70ea58cf5578..48795995fdf50 100644
--- a/flang/lib/Semantics/check-omp-structure.h
+++ b/flang/lib/Semantics/check-omp-structure.h
@@ -275,8 +275,11 @@ class OmpStructureChecker
void CheckTargetUpdate();
void CheckDependenceType(const parser::OmpDependenceType::Value &x);
void CheckTaskDependenceType(const parser::OmpTaskDependenceType::Value &x);
+ std::optional<llvm::omp::Directive> GetCancelType(
+ llvm::omp::Directive cancelDir, const parser::CharBlock &cancelSource,
+ const parser::OmpClauseList &clauses);
void CheckCancellationNest(
- const parser::CharBlock &source, const parser::OmpCancelType::Type &type);
+ const parser::CharBlock &source, llvm::omp::Directive type);
std::int64_t GetOrdCollapseLevel(const parser::OpenMPLoopConstruct &x);
void CheckReductionObjects(
const parser::OmpObjectList &objects, llvm::omp::Clause clauseId);
diff --git a/flang/test/Semantics/OpenMP/cancel.f90 b/flang/test/Semantics/OpenMP/cancel.f90
new file mode 100644
index 0000000000000..581c4bdb97646
--- /dev/null
+++ b/flang/test/Semantics/OpenMP/cancel.f90
@@ -0,0 +1,29 @@
+!RUN: %python %S/../test_errors.py %s %flang -fopenmp
+
+subroutine f00
+!$omp parallel
+!ERROR: Missing cancel-directive-name clause on the CANCEL construct
+!$omp cancel
+!$omp end parallel
+end
+
+subroutine f01
+!$omp parallel
+!ERROR: Multiple cancel-directive-name clauses are not allowed on the CANCEL construct
+!$omp cancel parallel parallel
+!$omp end parallel
+end
+
+subroutine f02
+!$omp parallel
+!ERROR: Missing cancel-directive-name clause on the CANCELLATION POINT construct
+!$omp cancellation point
+!$omp end parallel
+end
+
+subroutine f03
+!$omp parallel
+!ERROR: Multiple cancel-directive-name clauses are not allowed on the CANCELLATION POINT construct
+!$omp cancellation point parallel parallel
+!$omp end parallel
+end
diff --git a/llvm/include/llvm/Frontend/OpenMP/OMP.td b/llvm/include/llvm/Frontend/OpenMP/OMP.td
index 8a2f30a7995dc..cbad02a70609f 100644
--- a/llvm/include/llvm/Frontend/OpenMP/OMP.td
+++ b/llvm/include/llvm/Frontend/OpenMP/OMP.td
@@ -105,6 +105,7 @@ def OMPC_CancellationConstructType : Clause<"cancellation_construct_type"> {
OMP_CANCELLATION_CONSTRUCT_Taskgroup,
OMP_CANCELLATION_CONSTRUCT_None
];
+ let flangClass = "OmpCancellationConstructTypeClause";
}
def OMPC_Contains : Clause<"contains"> {
let clangClass = "OMPContainsClause";
@@ -647,12 +648,16 @@ def OMP_BeginDeclareVariant : Directive<"begin declare variant"> {
}
def OMP_Cancel : Directive<"cancel"> {
let allowedOnceClauses = [
+ VersionedClause<OMPC_CancellationConstructType>,
VersionedClause<OMPC_If>,
];
let association = AS_None;
let category = CA_Executable;
}
def OMP_CancellationPoint : Directive<"cancellation point"> {
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_CancellationConstructType>,
+ ];
let association = AS_None;
let category = CA_Executable;
}
>From eedbc24196c0872e9466f3936599e5dd9d49630b Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Thu, 6 Mar 2025 11:30:24 -0600
Subject: [PATCH 06/10] format
---
flang/lib/Parser/openmp-parsers.cpp | 4 ++--
flang/lib/Semantics/check-omp-structure.cpp | 3 +--
2 files changed, 3 insertions(+), 4 deletions(-)
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index 51b2567a3894d..2f094b0ce320d 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -1125,8 +1125,8 @@ TYPE_PARSER(sourced(construct<OpenMPCancellationPointConstruct>(
verbatim("CANCELLATION POINT"_tok), Parser<OmpClauseList>{})))
// 2.14.1 Cancel construct
-TYPE_PARSER(sourced(construct<OpenMPCancelConstruct>(verbatim("CANCEL"_tok),
- Parser<OmpClauseList>{})))
+TYPE_PARSER(sourced(construct<OpenMPCancelConstruct>(
+ verbatim("CANCEL"_tok), Parser<OmpClauseList>{})))
TYPE_PARSER(sourced(construct<OmpFailClause>(
parenthesized(indirect(Parser<OmpMemoryOrderClause>{})))))
diff --git a/flang/lib/Semantics/check-omp-structure.cpp b/flang/lib/Semantics/check-omp-structure.cpp
index 8d819defb4a0c..cc9fc1e531063 100644
--- a/flang/lib/Semantics/check-omp-structure.cpp
+++ b/flang/lib/Semantics/check-omp-structure.cpp
@@ -2245,8 +2245,7 @@ void OmpStructureChecker::Enter(
case llvm::omp::Directive::OMPD_taskgroup:
break;
default:
- context_.Say(dirName.source,
- "%s is not a cancellable construct"_err_en_US,
+ context_.Say(dirName.source, "%s is not a cancellable construct"_err_en_US,
parser::ToUpperCaseLetters(
llvm::omp::getOpenMPDirectiveName(dirName.v).str()));
break;
>From d7ce7a5e4083760842cbdf17ec4a5453800db213 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Thu, 6 Mar 2025 11:39:42 -0600
Subject: [PATCH 07/10] Fix MSVC build error
---
flang/lib/Parser/openmp-parsers.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index 1115a3897f082..3175a234aab7a 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -1013,7 +1013,7 @@ TYPE_PARSER(sourced(
// lists absent in the parsed result.
// E.g. for FLUSH(x) SEQ_CST it would find no clauses following
// the directive name, parse the argument list "(x)" and stop.
- applyFunction(makeFlushFromOldSyntax1,
+ applyFunction<OmpDirectiveSpecification>(makeFlushFromOldSyntax1,
verbatim("FLUSH"_tok) / !lookAhead("("_tok),
maybe(Parser<OmpClauseList>{}),
maybe(parenthesized(nonemptyList(Parser<OmpArgument>{}))),
>From 86ab87002174c5999542763dc8d731b995f8ad8f Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Thu, 27 Feb 2025 08:08:49 -0600
Subject: [PATCH 08/10] Use OmpDirectiveName as OmpDirectiveNameModifier
---
flang/include/flang/Parser/dump-parse-tree.h | 1 -
flang/include/flang/Parser/parse-tree.h | 6 +++---
flang/lib/Parser/openmp-parsers.cpp | 3 +--
flang/lib/Parser/parse-tree.cpp | 8 ++++++++
flang/lib/Semantics/check-omp-structure.cpp | 14 ++++++++++++--
flang/lib/Semantics/check-omp-structure.h | 3 ++-
flang/test/Parser/OpenMP/if-clause.f90 | 20 ++++++++++----------
7 files changed, 36 insertions(+), 19 deletions(-)
diff --git a/flang/include/flang/Parser/dump-parse-tree.h b/flang/include/flang/Parser/dump-parse-tree.h
index a154794e41e9d..ded97c3fb02f9 100644
--- a/flang/include/flang/Parser/dump-parse-tree.h
+++ b/flang/include/flang/Parser/dump-parse-tree.h
@@ -587,7 +587,6 @@ class ParseTreeDumper {
NODE(OmpFromClause, Modifier)
NODE(parser, OmpExpectation)
NODE_ENUM(OmpExpectation, Value)
- NODE(parser, OmpDirectiveNameModifier)
NODE(parser, OmpHoldsClause)
NODE(parser, OmpIfClause)
NODE(OmpIfClause, Modifier)
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index 5b737cf497584..cd0be4453ac33 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -3807,9 +3807,7 @@ struct OmpDeviceModifier {
// [*] The IF clause is allowed on CANCEL in OpenMP 4.5, but only without
// the directive-name-modifier. For the sake of uniformity CANCEL can be
// considered a valid value in 4.5 as well.
-struct OmpDirectiveNameModifier {
- WRAPPER_CLASS_BOILERPLATE(OmpDirectiveNameModifier, llvm::omp::Directive);
-};
+using OmpDirectiveNameModifier = OmpDirectiveName;
// Ref: [5.1:205-209], [5.2:166-168]
//
@@ -4509,6 +4507,8 @@ struct OmpDirectiveSpecification {
llvm::omp::Directive DirId() const { //
return std::get<OmpDirectiveName>(t).v;
}
+ const OmpClauseList &Clauses() const;
+
std::tuple<OmpDirectiveName, std::optional<std::list<OmpArgument>>,
std::optional<OmpClauseList>>
t;
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index 80a8765b3e87a..dd43ede796b98 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -505,8 +505,7 @@ TYPE_PARSER(sourced(construct<OmpFromClause::Modifier>(
TYPE_PARSER(sourced(
construct<OmpGrainsizeClause::Modifier>(Parser<OmpPrescriptiveness>{})))
-TYPE_PARSER(
- sourced(construct<OmpIfClause::Modifier>(unwrap(OmpDirectiveNameParser{}))))
+TYPE_PARSER(sourced(construct<OmpIfClause::Modifier>(OmpDirectiveNameParser{})))
TYPE_PARSER(sourced(construct<OmpInReductionClause::Modifier>(
Parser<OmpReductionIdentifier>{})))
diff --git a/flang/lib/Parser/parse-tree.cpp b/flang/lib/Parser/parse-tree.cpp
index 2e37710832059..95575e76c1149 100644
--- a/flang/lib/Parser/parse-tree.cpp
+++ b/flang/lib/Parser/parse-tree.cpp
@@ -336,4 +336,12 @@ namespace Fortran::parser {
llvm::omp::Clause OmpClause::Id() const {
return std::visit([](auto &&s) { return getClauseIdForClass(s); }, u);
}
+
+const OmpClauseList &OmpDirectiveSpecification::Clauses() const {
+ static OmpClauseList empty{std::move(decltype(OmpClauseList::v){})};
+ if (auto &clauses = std::get<std::optional<OmpClauseList>>(t)) {
+ return *clauses;
+ }
+ return empty;
+}
} // namespace Fortran::parser
diff --git a/flang/lib/Semantics/check-omp-structure.cpp b/flang/lib/Semantics/check-omp-structure.cpp
index 64a0be703744d..f24d9f54f5fed 100644
--- a/flang/lib/Semantics/check-omp-structure.cpp
+++ b/flang/lib/Semantics/check-omp-structure.cpp
@@ -625,18 +625,28 @@ void OmpStructureChecker::CheckHintClause(
}
void OmpStructureChecker::Enter(const parser::OmpDirectiveSpecification &x) {
- PushContextAndClauseSets(x.source, x.DirId());
+ // OmpDirectiveSpecification exists on its own only in METADIRECTIVE.
+ // In other cases it's a part of other constructs that handle directive
+ // context stack by themselves.
+ if (GetDirectiveNest(MetadirectiveNest)) {
+ PushContextAndClauseSets(
+ std::get<parser::OmpDirectiveName>(x.t).source, x.DirId());
+ }
}
void OmpStructureChecker::Leave(const parser::OmpDirectiveSpecification &) {
- dirContext_.pop_back();
+ if (GetDirectiveNest(MetadirectiveNest)) {
+ dirContext_.pop_back();
+ }
}
void OmpStructureChecker::Enter(const parser::OmpMetadirectiveDirective &x) {
+ EnterDirectiveNest(MetadirectiveNest);
PushContextAndClauseSets(x.source, llvm::omp::Directive::OMPD_metadirective);
}
void OmpStructureChecker::Leave(const parser::OmpMetadirectiveDirective &) {
+ ExitDirectiveNest(MetadirectiveNest);
dirContext_.pop_back();
}
diff --git a/flang/lib/Semantics/check-omp-structure.h b/flang/lib/Semantics/check-omp-structure.h
index b70ea58cf5578..496915aa44496 100644
--- a/flang/lib/Semantics/check-omp-structure.h
+++ b/flang/lib/Semantics/check-omp-structure.h
@@ -326,7 +326,8 @@ class OmpStructureChecker
TargetNest,
DeclarativeNest,
ContextSelectorNest,
- LastType = ContextSelectorNest,
+ MetadirectiveNest,
+ LastType = MetadirectiveNest,
};
int directiveNest_[LastType + 1] = {0};
diff --git a/flang/test/Parser/OpenMP/if-clause.f90 b/flang/test/Parser/OpenMP/if-clause.f90
index b3e3913f8bd1c..d7ab86ca6d2cf 100644
--- a/flang/test/Parser/OpenMP/if-clause.f90
+++ b/flang/test/Parser/OpenMP/if-clause.f90
@@ -11,34 +11,34 @@ program openmp_parse_if
! CHECK: OmpSimpleStandaloneDirective -> llvm::omp::Directive = target update
! CHECK-NEXT: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: OmpDirectiveNameModifier -> llvm::omp::Directive = target update
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = target update
!$omp target update if(target update: cond) to(i)
! CHECK: OmpSimpleStandaloneDirective -> llvm::omp::Directive = target enter data
! CHECK: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: OmpDirectiveNameModifier -> llvm::omp::Directive = target enter data
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = target enter data
!$omp target enter data map(to: i) if(target enter data: cond)
! CHECK: OmpSimpleStandaloneDirective -> llvm::omp::Directive = target exit data
! CHECK: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: OmpDirectiveNameModifier -> llvm::omp::Directive = target exit data
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = target exit data
!$omp target exit data map(from: i) if(target exit data: cond)
! CHECK: OmpBlockDirective -> llvm::omp::Directive = target data
! CHECK: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: OmpDirectiveNameModifier -> llvm::omp::Directive = target data
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = target data
!$omp target data map(tofrom: i) if(target data: cond)
!$omp end target data
! CHECK: OmpLoopDirective -> llvm::omp::Directive = target teams distribute parallel do simd
! CHECK: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: OmpDirectiveNameModifier -> llvm::omp::Directive = target
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = target
! CHECK: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: OmpDirectiveNameModifier -> llvm::omp::Directive = teams
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = teams
! CHECK: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: OmpDirectiveNameModifier -> llvm::omp::Directive = parallel
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = parallel
! CHECK: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: OmpDirectiveNameModifier -> llvm::omp::Directive = simd
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = simd
!$omp target teams distribute parallel do simd if(target: cond) &
!$omp& if(teams: cond) if(parallel: cond) if(simd: cond)
do i = 1, 10
@@ -47,13 +47,13 @@ program openmp_parse_if
! CHECK: OmpBlockDirective -> llvm::omp::Directive = task
! CHECK-NEXT: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: OmpDirectiveNameModifier -> llvm::omp::Directive = task
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = task
!$omp task if(task: cond)
!$omp end task
! CHECK: OmpLoopDirective -> llvm::omp::Directive = taskloop
! CHECK-NEXT: OmpClause -> If -> OmpIfClause
- ! CHECK-NEXT: DirectiveNameModifier -> llvm::omp::Directive = taskloop
+ ! CHECK-NEXT: OmpDirectiveName -> llvm::omp::Directive = taskloop
!$omp taskloop if(taskloop: cond)
do i = 1, 10
end do
>From 2243137c115425bfd5949c1fea7d6cb4d06869a6 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Fri, 7 Mar 2025 09:13:08 -0600
Subject: [PATCH 09/10] Fix example
---
flang/examples/FeatureList/FeatureList.cpp | 1 -
1 file changed, 1 deletion(-)
diff --git a/flang/examples/FeatureList/FeatureList.cpp b/flang/examples/FeatureList/FeatureList.cpp
index ddb9dee5b8a8e..79dd3af3a3ff5 100644
--- a/flang/examples/FeatureList/FeatureList.cpp
+++ b/flang/examples/FeatureList/FeatureList.cpp
@@ -551,7 +551,6 @@ struct NodeVisitor {
READ_FEATURE(OpenMPAtomicConstruct)
READ_FEATURE(OpenMPBlockConstruct)
READ_FEATURE(OpenMPCancelConstruct)
- READ_FEATURE(OpenMPCancelConstruct::If)
READ_FEATURE(OpenMPCancellationPointConstruct)
READ_FEATURE(OpenMPConstruct)
READ_FEATURE(OpenMPCriticalConstruct)
>From 0cc1699486834cc2ae63c0cd2a5c74c3db4c2ad5 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Fri, 7 Mar 2025 12:12:40 -0600
Subject: [PATCH 10/10] Simplify parsing of OmpCancellationConstructTypeClause
---
flang/lib/Parser/openmp-parsers.cpp | 45 +++++++++++++++++++----------
1 file changed, 29 insertions(+), 16 deletions(-)
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index f4d8832b9af09..1514e09535fb8 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -50,6 +50,20 @@ template <typename Parser> constexpr auto unwrap(const Parser &p) {
return UnwrapParser<Parser>(p);
}
+// Check (without advancing the parsing location) if the next thing in the
+// input would be accepted by the "checked" parser, and if so, run the "parser"
+// parser.
+// The intended use is with the "checker" parser being some token, followed
+// by a more complex parser that consumes the token plus more things, e.g.
+// "PARALLEL"_id >= Parser<OmpDirectiveSpecification>{}.
+//
+// The >= has a higher precedence than ||, so it can be used just like >>
+// in an alternatives parser without parentheses.
+template <typename PA, typename PB>
+constexpr auto operator>=(PA checker, PB parser) {
+ return lookAhead(checker) >> parser;
+}
+
/// Parse OpenMP directive name (this includes compound directives).
struct OmpDirectiveNameParser {
using resultType = OmpDirectiveName;
@@ -575,6 +589,9 @@ TYPE_PARSER(construct<OmpAffinityClause>(
maybe(nonemptyList(Parser<OmpAffinityClause::Modifier>{}) / ":"),
Parser<OmpObjectList>{}))
+TYPE_PARSER(construct<OmpCancellationConstructTypeClause>(
+ OmpDirectiveNameParser{}, maybe(parenthesized(scalarLogicalExpr))))
+
// 2.15.3.1 DEFAULT (PRIVATE | FIRSTPRIVATE | SHARED | NONE)
TYPE_PARSER(construct<OmpDefaultClause::DataSharingAttribute>(
"PRIVATE" >> pure(OmpDefaultClause::DataSharingAttribute::Private) ||
@@ -985,22 +1002,18 @@ TYPE_PARSER( //
"WHEN" >> construct<OmpClause>(construct<OmpClause::When>(
parenthesized(Parser<OmpWhenClause>{}))) ||
// Cancellable constructs
- construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
- construct<OmpCancellationConstructTypeClause>( //
- construct<OmpDirectiveName>(verbatim("DO"_id)),
- maybe(parenthesized(scalarLogicalExpr))))) ||
- construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
- construct<OmpCancellationConstructTypeClause>( //
- construct<OmpDirectiveName>(verbatim("PARALLEL"_id)),
- maybe(parenthesized(scalarLogicalExpr))))) ||
- construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
- construct<OmpCancellationConstructTypeClause>( //
- construct<OmpDirectiveName>(verbatim("SECTIONS"_id)),
- maybe(parenthesized(scalarLogicalExpr))))) ||
- construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
- construct<OmpCancellationConstructTypeClause>( //
- construct<OmpDirectiveName>(verbatim("TASKGROUP"_id)),
- maybe(parenthesized(scalarLogicalExpr))))))
+ "DO"_id >=
+ construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
+ Parser<OmpCancellationConstructTypeClause>{})) ||
+ "PARALLEL"_id >=
+ construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
+ Parser<OmpCancellationConstructTypeClause>{})) ||
+ "SECTIONS"_id >=
+ construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
+ Parser<OmpCancellationConstructTypeClause>{})) ||
+ "TASKGROUP"_id >=
+ construct<OmpClause>(construct<OmpClause::CancellationConstructType>(
+ Parser<OmpCancellationConstructTypeClause>{})))
// [Clause, [Clause], ...]
TYPE_PARSER(sourced(construct<OmpClauseList>(
More information about the llvm-commits
mailing list