[flang][OpenMP] Use new modifiers in ALLOCATE clause #117627
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Again, this simplifies the semantic checks and lowering quite a bit. Update the check for positive alignment to use a more informative message, and to highlight the modifier itsef, not the whole clause. Remove the checks for the allocator expression itself being positive: there is nothing in the spec that says that it should be positive. Remove the "simple" modifier from the AllocateT template, since both simple and complex modifiers are the same thing, only differing in syntax.
llvmbot
added
flang
|
@llvm/pr-subscribers-flang-parser @llvm/pr-subscribers-flang-openmp Author: Krzysztof Parzyszek (kparzysz) ChangesAgain, this simplifies the semantic checks and lowering quite a bit. Update the check for positive alignment to use a more informative message, and to highlight the modifier itsef, not the whole clause. Remove the checks for the allocator expression itself being positive: there is nothing in the spec that says that it should be positive. Remove the "simple" modifier from the AllocateT template, since both simple and complex modifiers are the same thing, only differing in syntax. Patch is 29.90 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/117627.diff 19 Files Affected:
diff --git a/flang/include/flang/Parser/dump-parse-tree.h b/flang/include/flang/Parser/dump-parse-tree.h
index 68f9406dc28309..d499b414827d50 100644
--- a/flang/include/flang/Parser/dump-parse-tree.h
+++ b/flang/include/flang/Parser/dump-parse-tree.h
@@ -586,10 +586,10 @@ class ParseTreeDumper {
NODE(parser, OmpReductionInitializerClause)
NODE(parser, OmpReductionIdentifier)
NODE(parser, OmpAllocateClause)
- NODE(OmpAllocateClause, AllocateModifier)
- NODE(OmpAllocateClause::AllocateModifier, Allocator)
- NODE(OmpAllocateClause::AllocateModifier, ComplexModifier)
- NODE(OmpAllocateClause::AllocateModifier, Align)
+ NODE(OmpAllocateClause, Modifier)
+ NODE(parser, OmpAlignModifier)
+ NODE(parser, OmpAllocatorComplexModifier)
+ NODE(parser, OmpAllocatorSimpleModifier)
NODE(parser, OmpScheduleClause)
NODE(OmpScheduleClause, Modifier)
NODE_ENUM(OmpScheduleClause, Kind)
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index 8d7119a56b7f8e..e9a02a87812452 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -3457,6 +3457,30 @@ inline namespace modifier {
// ENUM_CLASS(Value, Keyword1, Keyword2);
// };
+// Ref: [5.1:184-185], [5.2:178-179]
+//
+// align-modifier ->
+// ALIGN(alignment) // since 5.1
+struct OmpAlignModifier {
+ WRAPPER_CLASS_BOILERPLATE(OmpAlignModifier, ScalarIntExpr);
+};
+
+// Ref: [5.0:158-159], [5.1:184-185], [5.2:178-179]
+//
+// allocator-simple-modifier ->
+// allocator // since 5.0
+struct OmpAllocatorSimpleModifier {
+ WRAPPER_CLASS_BOILERPLATE(OmpAllocatorSimpleModifier, ScalarIntExpr);
+};
+
+// Ref: [5.1:184-185], [5.2:178-179]
+//
+// allocator-complex-modifier ->
+// ALLOCATOR(allocator) // since 5.1
+struct OmpAllocatorComplexModifier {
+ WRAPPER_CLASS_BOILERPLATE(OmpAllocatorComplexModifier, ScalarIntExpr);
+};
+
// Ref: [5.2:252-254]
//
// chunk-modifier ->
@@ -3646,24 +3670,20 @@ struct OmpAlignedClause {
std::tuple<OmpObjectList, std::optional<ScalarIntConstantExpr>> t;
};
-// OMP 5.0 2.11.4 allocate-clause -> ALLOCATE ([allocator:] variable-name-list)
-// OMP 5.2 2.13.4 allocate-clause -> ALLOCATE ([allocate-modifier [,
-// allocate-modifier] :]
-// variable-name-list)
-// allocate-modifier -> allocator | align
+// Ref: [5.0:158-159], [5.1:184-185], [5.2:178-179]
+//
+// allocate-clause ->
+// ALLOCATE(
+// [allocator-simple-modifier:] list) | // since 5.0
+// ALLOCATE([modifier...:] list) // since 5.1
+// modifier ->
+// allocator-simple-modifier |
+// allocator-complex-modifier | align-modifier // since 5.1
struct OmpAllocateClause {
- struct AllocateModifier {
- WRAPPER_CLASS(Allocator, ScalarIntExpr);
- WRAPPER_CLASS(Align, ScalarIntExpr);
- struct ComplexModifier {
- TUPLE_CLASS_BOILERPLATE(ComplexModifier);
- std::tuple<Allocator, Align> t;
- };
- UNION_CLASS_BOILERPLATE(AllocateModifier);
- std::variant<Allocator, ComplexModifier, Align> u;
- };
+ MODIFIER_BOILERPLATE(OmpAlignModifier, OmpAllocatorSimpleModifier,
+ OmpAllocatorComplexModifier);
TUPLE_CLASS_BOILERPLATE(OmpAllocateClause);
- std::tuple<std::optional<AllocateModifier>, OmpObjectList> t;
+ std::tuple<MODIFIERS(), OmpObjectList> t;
};
// OMP 5.0 2.4 atomic-default-mem-order-clause ->
diff --git a/flang/include/flang/Semantics/openmp-modifiers.h b/flang/include/flang/Semantics/openmp-modifiers.h
index 60f116e6f00339..a6316cf7aba564 100644
--- a/flang/include/flang/Semantics/openmp-modifiers.h
+++ b/flang/include/flang/Semantics/openmp-modifiers.h
@@ -67,6 +67,9 @@ template <typename SpecificTy> const OmpModifierDescriptor &OmpGetDescriptor();
#define DECLARE_DESCRIPTOR(name) \
template <> const OmpModifierDescriptor &OmpGetDescriptor<name>()
+DECLARE_DESCRIPTOR(parser::OmpAlignModifier);
+DECLARE_DESCRIPTOR(parser::OmpAllocatorComplexModifier);
+DECLARE_DESCRIPTOR(parser::OmpAllocatorSimpleModifier);
DECLARE_DESCRIPTOR(parser::OmpChunkModifier);
DECLARE_DESCRIPTOR(parser::OmpDependenceType);
DECLARE_DESCRIPTOR(parser::OmpExpectation);
@@ -216,10 +219,26 @@ OmpGetRepeatableModifier(const std::optional<std::list<UnionTy>> &modifiers) {
OmpSpecificModifierIterator(items, items->end()));
}
+// Attempt to prevent creating a range based on an expiring modifier list.
template <typename SpecificTy, typename UnionTy>
llvm::iterator_range<OmpSpecificModifierIterator<SpecificTy>>
OmpGetRepeatableModifier(std::optional<std::list<UnionTy>> &&) = delete;
+template <typename SpecificTy, typename UnionTy>
+Fortran::parser::CharBlock OmpGetModifierSource(
+ const std::optional<std::list<UnionTy>> &modifiers,
+ const SpecificTy *specific) {
+ if (!modifiers || !specific) {
+ return Fortran::parser::CharBlock{};
+ }
+ for (auto &m : *modifiers) {
+ if (std::get_if<SpecificTy>(&m.u) == specific) {
+ return m.source;
+ }
+ }
+ llvm_unreachable("`specific` must be a member of `modifiers`");
+}
+
namespace detail {
template <typename T> constexpr const T *make_nullptr() {
return static_cast<const T *>(nullptr);
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
index 6baa22a44eafb1..8670a5470cdc67 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
@@ -81,12 +81,8 @@ genAllocateClause(lower::AbstractConverter &converter,
// Check if allocate clause has allocator specified. If so, add it
// to list of allocators, otherwise, add default allocator to
// list of allocators.
- using SimpleModifier = Allocate::AllocatorSimpleModifier;
using ComplexModifier = Allocate::AllocatorComplexModifier;
- if (auto &mod = std::get<std::optional<SimpleModifier>>(clause.t)) {
- mlir::Value operand = fir::getBase(converter.genExprValue(*mod, stmtCtx));
- allocatorOperands.append(objects.size(), operand);
- } else if (auto &mod = std::get<std::optional<ComplexModifier>>(clause.t)) {
+ if (auto &mod = std::get<std::optional<ComplexModifier>>(clause.t)) {
mlir::Value operand = fir::getBase(converter.genExprValue(mod->v, stmtCtx));
allocatorOperands.append(objects.size(), operand);
} else {
diff --git a/flang/lib/Lower/OpenMP/Clauses.cpp b/flang/lib/Lower/OpenMP/Clauses.cpp
index bf20f42bdecaf1..ddc91ef2030bd7 100644
--- a/flang/lib/Lower/OpenMP/Clauses.cpp
+++ b/flang/lib/Lower/OpenMP/Clauses.cpp
@@ -415,47 +415,29 @@ Aligned make(const parser::OmpClause::Aligned &inp,
Allocate make(const parser::OmpClause::Allocate &inp,
semantics::SemanticsContext &semaCtx) {
// inp.v -> parser::OmpAllocateClause
- using wrapped = parser::OmpAllocateClause;
- auto &t0 = std::get<std::optional<wrapped::AllocateModifier>>(inp.v.t);
+ auto &mods = semantics::OmpGetModifiers(inp.v);
+ auto *m0 = semantics::OmpGetUniqueModifier<parser::OmpAlignModifier>(mods);
+ auto *m1 =
+ semantics::OmpGetUniqueModifier<parser::OmpAllocatorComplexModifier>(
+ mods);
+ auto *m2 =
+ semantics::OmpGetUniqueModifier<parser::OmpAllocatorSimpleModifier>(mods);
auto &t1 = std::get<parser::OmpObjectList>(inp.v.t);
- if (!t0) {
- return Allocate{{/*AllocatorSimpleModifier=*/std::nullopt,
- /*AllocatorComplexModifier=*/std::nullopt,
- /*AlignModifier=*/std::nullopt,
- /*List=*/makeObjects(t1, semaCtx)}};
- }
+ auto makeAllocator = [&](auto *mod) -> std::optional<Allocator> {
+ if (mod)
+ return Allocator{makeExpr(mod->v, semaCtx)};
+ return std::nullopt;
+ };
- using Tuple = decltype(Allocate::t);
+ auto makeAlign = [&](const parser::ScalarIntExpr &expr) {
+ return Align{makeExpr(expr, semaCtx)};
+ };
- return Allocate{Fortran::common::visit(
- common::visitors{
- // simple-modifier
- [&](const wrapped::AllocateModifier::Allocator &v) -> Tuple {
- return {/*AllocatorSimpleModifier=*/makeExpr(v.v, semaCtx),
- /*AllocatorComplexModifier=*/std::nullopt,
- /*AlignModifier=*/std::nullopt,
- /*List=*/makeObjects(t1, semaCtx)};
- },
- // complex-modifier + align-modifier
- [&](const wrapped::AllocateModifier::ComplexModifier &v) -> Tuple {
- auto &s0 = std::get<wrapped::AllocateModifier::Allocator>(v.t);
- auto &s1 = std::get<wrapped::AllocateModifier::Align>(v.t);
- return {
- /*AllocatorSimpleModifier=*/std::nullopt,
- /*AllocatorComplexModifier=*/Allocator{makeExpr(s0.v, semaCtx)},
- /*AlignModifier=*/Align{makeExpr(s1.v, semaCtx)},
- /*List=*/makeObjects(t1, semaCtx)};
- },
- // align-modifier
- [&](const wrapped::AllocateModifier::Align &v) -> Tuple {
- return {/*AllocatorSimpleModifier=*/std::nullopt,
- /*AllocatorComplexModifier=*/std::nullopt,
- /*AlignModifier=*/Align{makeExpr(v.v, semaCtx)},
- /*List=*/makeObjects(t1, semaCtx)};
- },
- },
- t0->u)};
+ auto maybeAllocator = m1 ? makeAllocator(m1) : makeAllocator(m2);
+ return Allocate{{/*AllocatorComplexModifier=*/std::move(maybeAllocator),
+ /*AlignModifier=*/maybeApplyToV(makeAlign, m0),
+ /*List=*/makeObjects(t1, semaCtx)}};
}
Allocator make(const parser::OmpClause::Allocator &inp,
diff --git a/flang/lib/Lower/OpenMP/Clauses.h b/flang/lib/Lower/OpenMP/Clauses.h
index 5fac5c2271c3bf..562685e43c13bf 100644
--- a/flang/lib/Lower/OpenMP/Clauses.h
+++ b/flang/lib/Lower/OpenMP/Clauses.h
@@ -153,10 +153,11 @@ std::optional<ResultTy> maybeApply(FuncTy &&func,
return func(*arg);
}
-template <
+template < //
typename FuncTy, //
typename ArgTy, //
- typename ResultTy = std::invoke_result_t<FuncTy, typename ArgTy::Value>>
+ typename ResultTy =
+ std::invoke_result_t<FuncTy, decltype(std::declval<ArgTy>().v)>>
std::optional<ResultTy> maybeApplyToV(FuncTy &&func, const ArgTy *arg) {
if (!arg)
return std::nullopt;
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index 2040a3e7ed5aeb..f231290932c122 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -91,6 +91,14 @@ static TypeDeclarationStmt makeIterSpecDecl(std::list<ObjectName> &&names) {
// --- Parsers for clause modifiers -----------------------------------
+TYPE_PARSER(construct<OmpAlignModifier>( //
+ "ALIGN" >> parenthesized(scalarIntExpr)))
+
+TYPE_PARSER(construct<OmpAllocatorComplexModifier>(
+ "ALLOCATOR" >> parenthesized(scalarIntExpr)))
+
+TYPE_PARSER(construct<OmpAllocatorSimpleModifier>(scalarIntExpr))
+
TYPE_PARSER(construct<OmpChunkModifier>( //
"SIMD" >> pure(OmpChunkModifier::Value::Simd)))
@@ -183,6 +191,16 @@ TYPE_PARSER(construct<OmpVariableCategory>(
"SCALAR" >> pure(OmpVariableCategory::Value::Scalar)))
// This could be auto-generated.
+TYPE_PARSER(sourced(construct<OmpAllocateClause::Modifier>(sourced(
+ construct<OmpAllocateClause::Modifier>(Parser<OmpAlignModifier>{}) ||
+ construct<OmpAllocateClause::Modifier>(
+ Parser<OmpAllocatorComplexModifier>{}) ||
+ construct<OmpAllocateClause::Modifier>(
+ Parser<OmpAllocatorSimpleModifier>{})))))
+
+TYPE_PARSER(sourced(
+ construct<OmpDefaultmapClause::Modifier>(Parser<OmpVariableCategory>{})))
+
TYPE_PARSER(sourced(construct<OmpFromClause::Modifier>(
sourced(construct<OmpFromClause::Modifier>(Parser<OmpExpectation>{}) ||
construct<OmpFromClause::Modifier>(Parser<OmpMapper>{}) ||
@@ -211,9 +229,6 @@ TYPE_PARSER(sourced(construct<OmpToClause::Modifier>(
construct<OmpToClause::Modifier>(Parser<OmpMapper>{}) ||
construct<OmpToClause::Modifier>(Parser<OmpIterator>{})))))
-TYPE_PARSER(sourced(
- construct<OmpDefaultmapClause::Modifier>(Parser<OmpVariableCategory>{})))
-
// --- Parsers for clauses --------------------------------------------
/// `MOBClause` is a clause that has a
@@ -334,29 +349,7 @@ TYPE_PARSER(construct<OmpInReductionClause>(
// variable-name-list)
// allocate-modifier -> allocator | align
TYPE_PARSER(construct<OmpAllocateClause>(
- maybe(
- first(
- construct<OmpAllocateClause::AllocateModifier>("ALLOCATOR" >>
- construct<OmpAllocateClause::AllocateModifier::ComplexModifier>(
- parenthesized(construct<
- OmpAllocateClause::AllocateModifier::Allocator>(
- scalarIntExpr)) /
- ",",
- "ALIGN" >> parenthesized(construct<
- OmpAllocateClause::AllocateModifier::Align>(
- scalarIntExpr)))),
- construct<OmpAllocateClause::AllocateModifier>("ALLOCATOR" >>
- parenthesized(
- construct<OmpAllocateClause::AllocateModifier::Allocator>(
- scalarIntExpr))),
- construct<OmpAllocateClause::AllocateModifier>("ALIGN" >>
- parenthesized(
- construct<OmpAllocateClause::AllocateModifier::Align>(
- scalarIntExpr))),
- construct<OmpAllocateClause::AllocateModifier>(
- construct<OmpAllocateClause::AllocateModifier::Allocator>(
- scalarIntExpr))) /
- ":"),
+ maybe(nonemptyList(Parser<OmpAllocateClause::Modifier>{}) / ":"),
Parser<OmpObjectList>{}))
// iteration-offset -> +/- non-negative-constant-expr
diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp
index fe3f6ce7aa6291..192917512c17a2 100644
--- a/flang/lib/Parser/unparse.cpp
+++ b/flang/lib/Parser/unparse.cpp
@@ -2148,35 +2148,21 @@ class UnparseVisitor {
Walk(std::get<OmpObjectList>(x.t));
}
void Unparse(const OmpAllocateClause &x) {
- Walk(
- std::get<std::optional<OmpAllocateClause::AllocateModifier>>(x.t), ":");
+ using Modifier = OmpAllocateClause::Modifier;
+ Walk(std::get<std::optional<std::list<Modifier>>>(x.t), ": ");
Walk(std::get<OmpObjectList>(x.t));
}
- void Unparse(const OmpAllocateClause::AllocateModifier &x) {
- common::visit(
- common::visitors{
- [&](const OmpAllocateClause::AllocateModifier::Allocator &y) {
- Walk(y);
- },
- [&](const OmpAllocateClause::AllocateModifier::ComplexModifier &y) {
- Word("ALLOCATOR(");
- Walk(std::get<OmpAllocateClause::AllocateModifier::Allocator>(
- y.t));
- Put(")");
- Put(",");
- Walk(std::get<OmpAllocateClause::AllocateModifier::Align>(y.t));
- },
- [&](const OmpAllocateClause::AllocateModifier::Align &y) {
- Walk(y);
- },
- },
- x.u);
- }
- void Unparse(const OmpAllocateClause::AllocateModifier::Align &x) {
+ void Unparse(const OmpAlignModifier &x) {
Word("ALIGN(");
Walk(x.v);
Put(")");
}
+ void Unparse(const OmpAllocatorSimpleModifier &x) { Walk(x.v); }
+ void Unparse(const OmpAllocatorComplexModifier &x) {
+ Word("ALLOCATOR(");
+ Walk(x.v);
+ Put(")");
+ }
void Unparse(const OmpOrderClause &x) {
using Modifier = OmpOrderClause::Modifier;
Walk(std::get<std::optional<std::list<Modifier>>>(x.t), ":");
diff --git a/flang/lib/Semantics/check-omp-structure.cpp b/flang/lib/Semantics/check-omp-structure.cpp
index 3733ebfaf94925..b49258da506ce6 100644
--- a/flang/lib/Semantics/check-omp-structure.cpp
+++ b/flang/lib/Semantics/check-omp-structure.cpp
@@ -1481,34 +1481,26 @@ void OmpStructureChecker::Enter(const parser::OmpClause::Allocator &x) {
void OmpStructureChecker::Enter(const parser::OmpClause::Allocate &x) {
CheckAllowedClause(llvm::omp::Clause::OMPC_allocate);
- if (const auto &modifier{
- std::get<std::optional<parser::OmpAllocateClause::AllocateModifier>>(
- x.v.t)}) {
- common::visit(
- common::visitors{
- [&](const parser::OmpAllocateClause::AllocateModifier::Allocator
- &y) {
- RequiresPositiveParameter(llvm::omp::Clause::OMPC_allocate, y.v);
- isPredefinedAllocator = GetIntValue(y.v).has_value();
- },
- [&](const parser::OmpAllocateClause::AllocateModifier::
- ComplexModifier &y) {
- const auto &alloc = std::get<
- parser::OmpAllocateClause::AllocateModifier::Allocator>(y.t);
- const auto &align =
- std::get<parser::OmpAllocateClause::AllocateModifier::Align>(
- y.t);
- RequiresPositiveParameter(
- llvm::omp::Clause::OMPC_allocate, alloc.v);
- RequiresPositiveParameter(
- llvm::omp::Clause::OMPC_allocate, align.v);
- isPredefinedAllocator = GetIntValue(alloc.v).has_value();
- },
- [&](const parser::OmpAllocateClause::AllocateModifier::Align &y) {
- RequiresPositiveParameter(llvm::omp::Clause::OMPC_allocate, y.v);
- },
- },
- modifier->u);
+ if (OmpVerifyModifiers(
+ x.v, llvm::omp::OMPC_allocate, GetContext().clauseSource, context_)) {
+ auto &modifiers{OmpGetModifiers(x.v)};
+ if (auto *align{
+ OmpGetUniqueModifier<parser::OmpAlignModifier>(modifiers)}) {
+ if (const auto &v{GetIntValue(align->v)}; !v || *v <= 0) {
+ context_.Say(OmpGetModifierSource(modifiers, align),
+ "The alignment value should be a constant positive integer"_err_en_US);
+ }
+ }
+ // The simple and complex modifiers have the same structure. They only
+ // differ in their syntax.
+ if (auto *alloc{OmpGetUniqueModifier<parser::OmpAllocatorComplexModifier>(
+ modifiers)}) {
+ isPredefinedAllocator = GetIntValue(alloc->v).has_value();
+ }
+ if (auto *alloc{OmpGetUniqueModifier<parser::OmpAllocatorSimpleModifier>(
+ modifiers)}) {
+ isPredefinedAllocator = GetIntValue(alloc->v).has_value();
+ }
}
}
diff --git a/flang/lib/Semantics/openmp-modifiers.cpp b/flang/lib/Semantics/openmp-modifiers.cpp
index 1fd2358aa594ea..18863b7b904a4a 100644
--- a/flang/lib/Semantics/openmp-modifiers.cpp
+++ b/flang/lib/Semantics/openmp-modifiers.cpp
@@ -74,6 +74,56 @@ unsigned OmpModifierDescriptor::since(llvm::omp::Clause id) const {
// Note: The intent for these functions is to have them be automatically-
// generated in the future.
+template <>
+const OmpModifierDescriptor &OmpGetDescriptor<parser::OmpAlignModifier>() {
+ static const OmpModifierDescriptor desc{
+ /*name=*/"align-modifier",
+ /*props=*/
+ {
+ {51, {OmpProperty::Unique}},
+ },
+ /*clauses=*/
+ {
+ {51, {Clause::OMPC_allocate}},
+ },
+ };
+ return desc;
+}
+
+template <>
+const OmpModifierDescriptor &
+OmpGetDescriptor<parser::OmpAllocatorComplexModifier>() {
+ static const OmpModifierDescriptor desc{
+ /*name=*/"allocator-complex-modifier",
+ /*props=*/
+ {
+ {51, {OmpProperty::Unique}},
+ },
+ /*clauses=*/
+ {
+ {51, {Clause::OMPC_allocate}},
+ },
+ };
+ return desc;
+}
+
+template <>
+const OmpModifierDescriptor &
+OmpGetDescriptor<parser::OmpAllocatorSimpleModifier>() {
+ static const OmpModifierDescriptor desc{
+ /*name=*/"allocator-simple-modifier",
+ /*props=*/
+ {
+ {50, {OmpProperty::Exclusive, OmpProperty::Unique}},
+ },
+ /*clauses=*/
+ {
+ {50, {Clause::OMPC_allocate}},
+ },
+ };
+ return desc;
+}
+
template <>
const OmpModifierDescriptor &OmpGetDescriptor<parser::OmpChunkModifier>() {
static const OmpModifierDescriptor desc{
diff --git a/flang/lib/Semantics/resolve-directives.cpp b/flang/lib/Semantics/resolve-directives.cpp
index 0c3708b3fd29b4..4f56356d879a40 100644
--- a/flang/lib/Semantics/resolve-direc...
[truncated]
|
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/195/builds/1783 Here is the relevant piece of the build log for the reference |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Again, this simplifies the semantic checks and lowering quite a bit. Update the check for positive alignment to use a more informative message, and to highlight the modifier itsef, not the whole clause. Remove the checks for the allocator expression itself being positive: there is nothing in the spec that says that it should be positive.
Remove the "simple" modifier from the AllocateT template, since both simple and complex modifiers are the same thing, only differing in syntax.