[llvm-branch-commits] [flang] [flang][OpenMP] Allow utility constructs in specification part (PR #121509)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Jan 2 10:15:44 PST 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-parser
@llvm/pr-subscribers-flang-fir-hlfir
Author: Krzysztof Parzyszek (kparzysz)
<details>
<summary>Changes</summary>
Allow utility constructs (error and nothing) to appear in the specification part as well as the execution part. The exception is "ERROR AT(EXECUTION)" which should only be in the execution part.
In case of ambiguity (the boundary between the specification and the execution part), utility constructs will be parsed as belonging to the specification part. In such cases move them to the execution part in the OpenMP canonicalization code.
---
Patch is 23.70 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/121509.diff
10 Files Affected:
- (modified) flang/include/flang/Parser/parse-tree.h (+1-1)
- (modified) flang/lib/Lower/OpenMP/OpenMP.cpp (+4)
- (modified) flang/lib/Parser/openmp-parsers.cpp (+3-1)
- (modified) flang/lib/Parser/unparse.cpp (+42-59)
- (modified) flang/lib/Semantics/canonicalize-omp.cpp (+162)
- (modified) flang/lib/Semantics/check-omp-structure.cpp (+18-1)
- (modified) flang/lib/Semantics/check-omp-structure.h (+6-2)
- (modified) flang/test/Parser/OpenMP/error-unparse.f90 (+11-7)
- (modified) flang/test/Parser/OpenMP/nothing.f90 (+100)
- (added) flang/test/Semantics/OpenMP/error.f90 (+8)
``````````diff
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index 9df7c6d5e39c31..b693e001e5e4b4 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -4342,7 +4342,7 @@ struct OpenMPDeclarativeConstruct {
std::variant<OpenMPDeclarativeAllocate, OpenMPDeclareMapperConstruct,
OpenMPDeclareReductionConstruct, OpenMPDeclareSimdConstruct,
OpenMPDeclareTargetConstruct, OpenMPThreadprivate,
- OpenMPRequiresConstruct>
+ OpenMPRequiresConstruct, OpenMPUtilityConstruct>
u;
};
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index fe6d82125a9e01..0a84162291573a 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -2586,6 +2586,10 @@ static void genOMPDispatch(lower::AbstractConverter &converter,
//===----------------------------------------------------------------------===//
// OpenMPDeclarativeConstruct visitors
//===----------------------------------------------------------------------===//
+static void genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
+ semantics::SemanticsContext &semaCtx,
+ lower::pft::Evaluation &eval,
+ const parser::OpenMPUtilityConstruct &);
static void
genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index 0a0a29002de27c..75bb64d06ed0fe 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -1090,7 +1090,9 @@ TYPE_PARSER(startOmpLine >>
construct<OpenMPDeclarativeConstruct>(
Parser<OpenMPRequiresConstruct>{}) ||
construct<OpenMPDeclarativeConstruct>(
- Parser<OpenMPThreadprivate>{})) /
+ Parser<OpenMPThreadprivate>{}) ||
+ construct<OpenMPDeclarativeConstruct>(
+ Parser<OpenMPUtilityConstruct>{})) /
endOmpLine))
// Block Construct
diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp
index 4fe57f3e348d35..58820476c51bc1 100644
--- a/flang/lib/Parser/unparse.cpp
+++ b/flang/lib/Parser/unparse.cpp
@@ -2631,81 +2631,64 @@ class UnparseVisitor {
}
}
void Unparse(const OpenMPDeclareReductionConstruct &x) {
+ BeginOpenMP();
+ Word("!$OMP DECLARE REDUCTION ");
Put("(");
Walk(std::get<OmpReductionIdentifier>(x.t)), Put(" : ");
Walk(std::get<std::list<DeclarationTypeSpec>>(x.t), ","), Put(" : ");
Walk(std::get<OmpReductionCombiner>(x.t));
Put(")");
Walk(std::get<std::optional<OmpReductionInitializerClause>>(x.t));
+ EndOpenMP();
}
- bool Pre(const OpenMPDeclarativeConstruct &x) {
+
+ void Unparse(const OpenMPDeclareMapperConstruct &z) {
BeginOpenMP();
- Word("!$OMP ");
- return common::visit(
- common::visitors{
- [&](const OpenMPDeclarativeAllocate &z) {
- Word("ALLOCATE (");
- Walk(std::get<OmpObjectList>(z.t));
- Put(")");
- Walk(std::get<OmpClauseList>(z.t));
- Put("\n");
- EndOpenMP();
- return false;
- },
- [&](const OpenMPDeclareMapperConstruct &z) {
- Word("DECLARE MAPPER (");
- const auto &spec{std::get<OmpDeclareMapperSpecifier>(z.t)};
- if (auto mapname{std::get<std::optional<Name>>(spec.t)}) {
- Walk(mapname);
- Put(":");
- }
- Walk(std::get<TypeSpec>(spec.t));
- Put("::");
- Walk(std::get<Name>(spec.t));
- Put(")");
+ Word("!$OMP DECLARE MAPPER (");
+ const auto &spec{std::get<OmpDeclareMapperSpecifier>(z.t)};
+ if (auto mapname{std::get<std::optional<Name>>(spec.t)}) {
+ Walk(mapname);
+ Put(":");
+ }
+ Walk(std::get<TypeSpec>(spec.t));
+ Put("::");
+ Walk(std::get<Name>(spec.t));
+ Put(")");
- Walk(std::get<OmpClauseList>(z.t));
- Put("\n");
- return false;
- },
- [&](const OpenMPDeclareReductionConstruct &) {
- Word("DECLARE REDUCTION ");
- return true;
- },
- [&](const OpenMPDeclareSimdConstruct &y) {
- Word("DECLARE SIMD ");
- Walk("(", std::get<std::optional<Name>>(y.t), ")");
- Walk(std::get<OmpClauseList>(y.t));
- Put("\n");
- EndOpenMP();
- return false;
- },
- [&](const OpenMPDeclareTargetConstruct &) {
- Word("DECLARE TARGET ");
- return true;
- },
- [&](const OpenMPRequiresConstruct &y) {
- Word("REQUIRES ");
- Walk(std::get<OmpClauseList>(y.t));
- Put("\n");
- EndOpenMP();
- return false;
- },
- [&](const OpenMPThreadprivate &) {
- Word("THREADPRIVATE (");
- return true;
- },
- },
- x.u);
+ Walk(std::get<OmpClauseList>(z.t));
+ Put("\n");
+ EndOpenMP();
+ }
+ void Unparse(const OpenMPDeclareSimdConstruct &y) {
+ BeginOpenMP();
+ Word("!$OMP DECLARE SIMD ");
+ Walk("(", std::get<std::optional<Name>>(y.t), ")");
+ Walk(std::get<OmpClauseList>(y.t));
+ Put("\n");
+ EndOpenMP();
}
- void Post(const OpenMPDeclarativeConstruct &) {
+ void Unparse(const OpenMPDeclareTargetConstruct &x) {
+ BeginOpenMP();
+ Word("!$OMP DECLARE TARGET ");
+ Walk(std::get<parser::OmpDeclareTargetSpecifier>(x.t));
Put("\n");
EndOpenMP();
}
- void Post(const OpenMPThreadprivate &) {
+ void Unparse(const OpenMPRequiresConstruct &y) {
+ BeginOpenMP();
+ Word("!$OMP REQUIRES ");
+ Walk(std::get<OmpClauseList>(y.t));
+ Put("\n");
+ EndOpenMP();
+ }
+ void Unparse(const OpenMPThreadprivate &x) {
+ BeginOpenMP();
+ Word("!$OMP THREADPRIVATE (");
+ Walk(std::get<parser::OmpObjectList>(x.t));
Put(")\n");
EndOpenMP();
}
+
bool Pre(const OmpMessageClause &x) {
Walk(x.v);
return false;
diff --git a/flang/lib/Semantics/canonicalize-omp.cpp b/flang/lib/Semantics/canonicalize-omp.cpp
index 0481b3d41f501d..5164f1dc6faab7 100644
--- a/flang/lib/Semantics/canonicalize-omp.cpp
+++ b/flang/lib/Semantics/canonicalize-omp.cpp
@@ -50,6 +50,43 @@ class CanonicalizationOfOmp {
void Post(parser::ExecutionPart &body) { RewriteOmpAllocations(body); }
+ // Pre-visit all constructs that have both a specification part and
+ // an execution part, and store the connection between the two.
+ bool Pre(parser::BlockConstruct &x) {
+ auto *spec = &std::get<parser::BlockSpecificationPart>(x.t).v;
+ auto *block = &std::get<parser::Block>(x.t);
+ blockForSpec_.insert(std::make_pair(spec, block));
+ return true;
+ }
+ bool Pre(parser::MainProgram &x) {
+ auto *spec = &std::get<parser::SpecificationPart>(x.t);
+ auto *block = &std::get<parser::ExecutionPart>(x.t).v;
+ blockForSpec_.insert(std::make_pair(spec, block));
+ return true;
+ }
+ bool Pre(parser::FunctionSubprogram &x) {
+ auto *spec = &std::get<parser::SpecificationPart>(x.t);
+ auto *block = &std::get<parser::ExecutionPart>(x.t).v;
+ blockForSpec_.insert(std::make_pair(spec, block));
+ return true;
+ }
+ bool Pre(parser::SubroutineSubprogram &x) {
+ auto *spec = &std::get<parser::SpecificationPart>(x.t);
+ auto *block = &std::get<parser::ExecutionPart>(x.t).v;
+ blockForSpec_.insert(std::make_pair(spec, block));
+ return true;
+ }
+ bool Pre(parser::SeparateModuleSubprogram &x) {
+ auto *spec = &std::get<parser::SpecificationPart>(x.t);
+ auto *block = &std::get<parser::ExecutionPart>(x.t).v;
+ blockForSpec_.insert(std::make_pair(spec, block));
+ return true;
+ }
+
+ void Post(parser::SpecificationPart &spec) {
+ CanonicalizeUtilityConstructs(spec);
+ }
+
private:
template <typename T> T *GetConstructIf(parser::ExecutionPartConstruct &x) {
if (auto *y{std::get_if<parser::ExecutableConstruct>(&x.u)}) {
@@ -155,6 +192,131 @@ class CanonicalizationOfOmp {
}
}
+ // Canonicalization of utility constructs.
+ //
+ // This addresses the issue of utility constructs that appear at the
+ // boundary between the specification and the execution parts, e.g.
+ // subroutine foo
+ // integer :: x ! Specification
+ // !$omp nothing
+ // x = 1 ! Execution
+ // ...
+ // end
+ //
+ // Utility constructs (error and nothing) can appear in both the
+ // specification part and the execution part, except "error at(execution)",
+ // which cannot be present in the specification part (whereas any utility
+ // construct can be in the execution part).
+ // When a utility construct is at the boundary, it should preferably be
+ // parsed as an element of the execution part, but since the specification
+ // part is parsed first, the utility construct ends up belonging to the
+ // specification part.
+ //
+ // To allow the likes of the following code to compile, move all utility
+ // construct that are at the end of the specification part to the beginning
+ // of the execution part.
+ //
+ // subroutine foo
+ // !$omp error at(execution) ! Initially parsed as declarative construct.
+ // ! Move it to the execution part.
+ // end
+
+ void CanonicalizeUtilityConstructs(parser::SpecificationPart &spec) {
+ auto found = blockForSpec_.find(&spec);
+ if (found == blockForSpec_.end()) {
+ // There is no corresponding execution part, so there is nothing to do.
+ return;
+ }
+ parser::Block &block = *found->second;
+
+ // There are two places where an OpenMP declarative construct can
+ // show up in the tuple in specification part:
+ // (1) in std::list<OpenMPDeclarativeConstruct>, or
+ // (2) in std::list<DeclarationConstruct>.
+ // The case (1) is only possible is the list (2) is empty.
+
+ auto &omps =
+ std::get<std::list<parser::OpenMPDeclarativeConstruct>>(spec.t);
+ auto &decls = std::get<std::list<parser::DeclarationConstruct>>(spec.t);
+
+ if (!decls.empty()) {
+ MoveUtilityConstructsFromDecls(decls, block);
+ } else {
+ MoveUtilityConstructsFromOmps(omps, block);
+ }
+ }
+
+ void MoveUtilityConstructsFromDecls(
+ std::list<parser::DeclarationConstruct> &decls, parser::Block &block) {
+ // Find the trailing range of DeclarationConstructs that are OpenMP
+ // utility construct, that are to be moved to the execution part.
+ std::list<parser::DeclarationConstruct>::reverse_iterator rlast = [&]() {
+ for (auto rit = decls.rbegin(), rend = decls.rend(); rit != rend; ++rit) {
+ parser::DeclarationConstruct &dc = *rit;
+ if (!std::holds_alternative<parser::SpecificationConstruct>(dc.u)) {
+ return rit;
+ }
+ auto &sc = std::get<parser::SpecificationConstruct>(dc.u);
+ using OpenMPDeclarativeConstruct =
+ common::Indirection<parser::OpenMPDeclarativeConstruct>;
+ if (!std::holds_alternative<OpenMPDeclarativeConstruct>(sc.u)) {
+ return rit;
+ }
+ // Got OpenMPDeclarativeConstruct. If it's not a utility construct
+ // then stop.
+ auto &odc = std::get<OpenMPDeclarativeConstruct>(sc.u).value();
+ if (!std::holds_alternative<parser::OpenMPUtilityConstruct>(odc.u)) {
+ return rit;
+ }
+ }
+ return decls.rend();
+ }();
+
+ std::transform(decls.rbegin(), rlast, std::front_inserter(block),
+ [](parser::DeclarationConstruct &dc) {
+ auto &sc = std::get<parser::SpecificationConstruct>(dc.u);
+ using OpenMPDeclarativeConstruct =
+ common::Indirection<parser::OpenMPDeclarativeConstruct>;
+ auto &oc = std::get<OpenMPDeclarativeConstruct>(sc.u).value();
+ auto &ut = std::get<parser::OpenMPUtilityConstruct>(oc.u);
+
+ return parser::ExecutionPartConstruct(parser::ExecutableConstruct(
+ common::Indirection(parser::OpenMPConstruct(std::move(ut)))));
+ });
+
+ decls.erase(rlast.base(), decls.end());
+ }
+
+ void MoveUtilityConstructsFromOmps(
+ std::list<parser::OpenMPDeclarativeConstruct> &omps,
+ parser::Block &block) {
+ using OpenMPDeclarativeConstruct = parser::OpenMPDeclarativeConstruct;
+ // Find the trailing range of OpenMPDeclarativeConstruct that are OpenMP
+ // utility construct, that are to be moved to the execution part.
+ std::list<OpenMPDeclarativeConstruct>::reverse_iterator rlast = [&]() {
+ for (auto rit = omps.rbegin(), rend = omps.rend(); rit != rend; ++rit) {
+ OpenMPDeclarativeConstruct &dc = *rit;
+ if (!std::holds_alternative<parser::OpenMPUtilityConstruct>(dc.u)) {
+ return rit;
+ }
+ }
+ return omps.rend();
+ }();
+
+ std::transform(omps.rbegin(), rlast, std::front_inserter(block),
+ [](parser::OpenMPDeclarativeConstruct &dc) {
+ auto &ut = std::get<parser::OpenMPUtilityConstruct>(dc.u);
+ return parser::ExecutionPartConstruct(parser::ExecutableConstruct(
+ common::Indirection(parser::OpenMPConstruct(std::move(ut)))));
+ });
+
+ omps.erase(rlast.base(), omps.end());
+ }
+
+ // Mapping from the specification parts to the blocks that follow in the
+ // same construct. This is for converting utility constructs to executable
+ // constructs.
+ std::map<parser::SpecificationPart *, parser::Block *> blockForSpec_;
parser::Messages &messages_;
};
diff --git a/flang/lib/Semantics/check-omp-structure.cpp b/flang/lib/Semantics/check-omp-structure.cpp
index 3a928c8a0289bf..4c6a408a9ef30d 100644
--- a/flang/lib/Semantics/check-omp-structure.cpp
+++ b/flang/lib/Semantics/check-omp-structure.cpp
@@ -614,6 +614,14 @@ void OmpStructureChecker::Leave(const parser::OpenMPConstruct &) {
deferredNonVariables_.clear();
}
+void OmpStructureChecker::Enter(const parser::OpenMPDeclarativeConstruct &x) {
+ EnterDirectiveNest(DeclarativeNest);
+}
+
+void OmpStructureChecker::Leave(const parser::OpenMPDeclarativeConstruct &x) {
+ ExitDirectiveNest(DeclarativeNest);
+}
+
void OmpStructureChecker::Enter(const parser::OpenMPLoopConstruct &x) {
loopStack_.push_back(&x);
const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
@@ -1697,6 +1705,16 @@ 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) {
+ if (x.v.v == parser::OmpAtClause::ActionTime::Execution) {
+ context_.Say(GetContext().clauseSource,
+ "The ERROR directive with AT(EXECUTION) cannot appear in the specification part"_err_en_US);
+ }
+ }
+}
+
void OmpStructureChecker::Enter(const parser::OpenMPExecutableAllocate &x) {
isPredefinedAllocator = true;
const auto &dir{std::get<parser::Verbatim>(x.t)};
@@ -2856,7 +2874,6 @@ CHECK_SIMPLE_CLAUSE(Init, OMPC_init)
CHECK_SIMPLE_CLAUSE(Use, OMPC_use)
CHECK_SIMPLE_CLAUSE(Novariants, OMPC_novariants)
CHECK_SIMPLE_CLAUSE(Nocontext, OMPC_nocontext)
-CHECK_SIMPLE_CLAUSE(At, OMPC_at)
CHECK_SIMPLE_CLAUSE(Severity, OMPC_severity)
CHECK_SIMPLE_CLAUSE(Message, OMPC_message)
CHECK_SIMPLE_CLAUSE(Filter, OMPC_filter)
diff --git a/flang/lib/Semantics/check-omp-structure.h b/flang/lib/Semantics/check-omp-structure.h
index 2a4f6fbd618c39..f47c01c00499a1 100644
--- a/flang/lib/Semantics/check-omp-structure.h
+++ b/flang/lib/Semantics/check-omp-structure.h
@@ -73,6 +73,9 @@ class OmpStructureChecker
void Enter(const parser::OpenMPConstruct &);
void Leave(const parser::OpenMPConstruct &);
+ void Enter(const parser::OpenMPDeclarativeConstruct &);
+ void Leave(const parser::OpenMPDeclarativeConstruct &);
+
void Enter(const parser::OpenMPLoopConstruct &);
void Leave(const parser::OpenMPLoopConstruct &);
void Enter(const parser::OmpEndLoopDirective &);
@@ -270,11 +273,12 @@ class OmpStructureChecker
const parser::Variable &, const parser::Expr &);
inline void ErrIfNonScalarAssignmentStmt(
const parser::Variable &, const parser::Expr &);
- enum directiveNestType {
+ enum directiveNestType : int {
SIMDNest,
TargetBlockOnlyTeams,
TargetNest,
- LastType
+ DeclarativeNest,
+ LastType = DeclarativeNest,
};
int directiveNest_[LastType + 1] = {0};
diff --git a/flang/test/Parser/OpenMP/error-unparse.f90 b/flang/test/Parser/OpenMP/error-unparse.f90
index 4dd06b736da80d..2cb4e1a083a6cf 100644
--- a/flang/test/Parser/OpenMP/error-unparse.f90
+++ b/flang/test/Parser/OpenMP/error-unparse.f90
@@ -1,23 +1,27 @@
-! RUN: %flang_fc1 -fopenmp-version=51 -fopenmp -fdebug-unparse-no-sema %s 2>&1 | FileCheck %s
-! RUN: %flang_fc1 -fopenmp-version=51 -fopenmp -fdebug-dump-parse-tree-no-sema %s 2>&1 | FileCheck %s --check-prefix="PARSE-TREE"
+! RUN: %flang_fc1 -fopenmp-version=51 -fopenmp -fdebug-unparse %s 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -fopenmp-version=51 -fopenmp -fdebug-dump-parse-tree %s 2>&1 | FileCheck %s --check-prefix="PARSE-TREE"
program main
character(*), parameter :: message = "This is an error"
!CHECK: !$OMP ERROR AT(COMPILATION) SEVERITY(WARNING) MESSAGE("some message here")
!PARSE-TREE: ExecutionPartConstruct -> ExecutableConstruct -> OpenMPConstruct -> OpenMPUtilityConstruct -> OmpErrorDirective
!PARSE-TREE: OmpClauseList -> OmpClause -> At -> OmpAtClause -> ActionTime = Compilation
!PARSE-TREE: OmpClause -> Severity -> OmpSeverityClause -> Severity = Warning
- !PARSE-TREE: OmpClause -> Message -> OmpMessageClause -> Expr -> LiteralConstant -> CharLiteralConstant
+ !PARSE-TREE: OmpClause -> Message -> OmpMessageClause -> Expr = '"some message here"'
+ !PARSE-TREE: LiteralConstant -> CharLiteralConstant
+ !PARSE-TREE: string = 'some message here'
!$omp error at(compilation) severity(warning) message("some message here")
- !CHECK: !$OMP ERROR AT(COMPILATION) SEVERITY(FATAL) MESSAGE(message)
+ !CHECK: !$OMP ERROR AT(COMPILATION) SEVERITY(FATAL) MESSAGE("This is an error")
!PARSE-TREE: ExecutionPartConstruct -> ExecutableConstruct -> OpenMPConstruct -> OpenMPUtilityConstruct -> OmpErrorDirective
!PARSE-TREE: OmpClauseList -> OmpClause -> At -> OmpAtClause -> ActionTime = Compilation
!PARSE-TREE: OmpClause -> Severity -> OmpSeverityClause -> Severity = Fatal
- !PARSE-TREE: OmpClause -> Message -> OmpMessageClause -> Expr -> Designator -> DataRef -> Name = 'message'
+ !PARSE-TREE: OmpClause -> Message -> OmpMessageClause -> Expr = '"This is an error"'
+ !PARSE-TREE: Designator -> DataRef -> Name = 'message'
!$omp error at(compilation) severity(fatal) message(message)
- !CHECK: !$OMP ERROR AT(EXECUTION) SEVERITY(FATAL) MESSAGE(message)
+ !CHECK: !$OMP ERROR AT(EXECUTION) SEVERITY(FATAL) MESSAGE("This is an error")
!PARSE-TREE: ExecutionPartConstruct -> ExecutableConstruct -> OpenMPConstruct -> OpenMPUtilityConstruct -> OmpErrorDirective
!PARSE-TREE: OmpClauseList -> OmpClause -> At -> OmpAtClause -> ActionTime = Execution
!PARSE-TREE: OmpClause -> Severity -> OmpSeverityClause -> Severity = Fatal
- !PARSE-TREE: OmpClause -> Message -> OmpMessageClause -> Expr -> Designator -> DataRef -> Name = 'message'
+ !PARSE-TREE: OmpClause -> Message -> OmpMessageClause -> Expr = '"This is an error"'
+ !PARSE-TREE: Designator -> DataRef -> Name = 'message'
!$omp error at(EXECUTION) severity(fatal) message(message)
end program main
diff --git a/flang/test/Parser/OpenMP/nothing.f90 b/flang/test/Parser/OpenMP/nothing.f90
index 80c0932087610b..eab73a15098841 100644
--- a/flang/test/Parser/OpenMP/nothing.f90
+++ b/flang/test/Parser/OpenMP/nothing.f90
@@ -11,3 +11,103 @@ subroutine f00
!PARSE-TREE: ExecutionPart -> Block
!PARSE-TREE: | | ExecutionPartConstruct -> ExecutableConstruct -> OpenMPConstruct -> OpenMPUtilityConstruct -> OmpNothingDirective
+
+subroutine f01
+ block
+ import, none
+ integer :: x
+ !$omp nothing ! "nothing" in the execution part
+ x = x+1
+ end block
+end
+
+!UNPARSE: SUBROUTINE f01
+!...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/121509
More information about the llvm-branch-commits
mailing list