[flang] [llvm] [flang][OpenMP] Overhaul implementation of ATOMIC construct (PR #137852)
via llvm-commits
llvm-commits at lists.llvm.org
Fri May 30 22:53:17 PDT 2025
================
@@ -2666,422 +2673,1391 @@ void OmpStructureChecker::Leave(const parser::OmpEndBlockDirective &x) {
}
}
-inline void OmpStructureChecker::ErrIfAllocatableVariable(
- const parser::Variable &var) {
- // Err out if the given symbol has
- // ALLOCATABLE attribute
- if (const auto *e{GetExpr(context_, var)})
- for (const Symbol &symbol : evaluate::CollectSymbols(*e))
- if (IsAllocatable(symbol)) {
- const auto &designator =
- std::get<common::Indirection<parser::Designator>>(var.u);
- const auto *dataRef =
- std::get_if<parser::DataRef>(&designator.value().u);
- const parser::Name *name =
- dataRef ? std::get_if<parser::Name>(&dataRef->u) : nullptr;
- if (name)
- context_.Say(name->source,
- "%s must not have ALLOCATABLE "
- "attribute"_err_en_US,
- name->ToString());
+/// parser::Block is a list of executable constructs, parser::BlockConstruct
+/// is Fortran's BLOCK/ENDBLOCK construct.
+/// Strip the outermost BlockConstructs, return the reference to the Block
+/// in the executable part of the innermost of the stripped constructs.
+/// Specifically, if the given `block` has a single entry (it's a list), and
+/// the entry is a BlockConstruct, get the Block contained within. Repeat
+/// this step as many times as possible.
+static const parser::Block &GetInnermostExecPart(const parser::Block &block) {
+ const parser::Block *iter{&block};
+ while (iter->size() == 1) {
+ const parser::ExecutionPartConstruct &ep{iter->front()};
+ if (auto *exec{std::get_if<parser::ExecutableConstruct>(&ep.u)}) {
+ using BlockConstruct = common::Indirection<parser::BlockConstruct>;
+ if (auto *bc{std::get_if<BlockConstruct>(&exec->u)}) {
+ iter = &std::get<parser::Block>(bc->value().t);
+ continue;
}
+ }
+ break;
+ }
+ return *iter;
}
-inline void OmpStructureChecker::ErrIfLHSAndRHSSymbolsMatch(
- const parser::Variable &var, const parser::Expr &expr) {
- // Err out if the symbol on the LHS is also used on the RHS of the assignment
- // statement
- const auto *e{GetExpr(context_, expr)};
- const auto *v{GetExpr(context_, var)};
- if (e && v) {
- auto vSyms{evaluate::GetSymbolVector(*v)};
- const Symbol &varSymbol = vSyms.front();
- for (const Symbol &symbol : evaluate::GetSymbolVector(*e)) {
- if (varSymbol == symbol) {
- const common::Indirection<parser::Designator> *designator =
- std::get_if<common::Indirection<parser::Designator>>(&expr.u);
- if (designator) {
- auto *z{var.typedExpr.get()};
- auto *c{expr.typedExpr.get()};
- if (z->v == c->v) {
- context_.Say(expr.source,
- "RHS expression on atomic assignment statement cannot access '%s'"_err_en_US,
- var.GetSource());
- }
+// There is no consistent way to get the source of a given ActionStmt, so
+// extract the source information from Statement<ActionStmt> when we can,
+// and keep it around for error reporting in further analyses.
+struct SourcedActionStmt {
+ const parser::ActionStmt *stmt{nullptr};
+ parser::CharBlock source;
+
+ operator bool() const { return stmt != nullptr; }
+};
+
+struct AnalyzedCondStmt {
+ SomeExpr cond{evaluate::NullPointer{}}; // Default ctor is deleted
+ parser::CharBlock source;
+ SourcedActionStmt ift, iff;
+};
+
+static SourcedActionStmt GetActionStmt(
+ const parser::ExecutionPartConstruct *x) {
+ if (x == nullptr) {
+ return SourcedActionStmt{};
+ }
+ if (auto *exec{std::get_if<parser::ExecutableConstruct>(&x->u)}) {
+ using ActionStmt = parser::Statement<parser::ActionStmt>;
+ if (auto *stmt{std::get_if<ActionStmt>(&exec->u)}) {
+ return SourcedActionStmt{&stmt->statement, stmt->source};
+ }
+ }
+ return SourcedActionStmt{};
+}
+
+static SourcedActionStmt GetActionStmt(const parser::Block &block) {
+ if (block.size() == 1) {
+ return GetActionStmt(&block.front());
+ }
+ return SourcedActionStmt{};
+}
+
+// Compute the `evaluate::Assignment` from parser::ActionStmt. The assumption
+// is that the ActionStmt will be either an assignment or a pointer-assignment,
+// otherwise return std::nullopt.
+// Note: This function can return std::nullopt on [Pointer]AssignmentStmt where
+// the "typedAssignment" is unset. This can happen is there are semantic errors
+// in the purported assignment.
+static std::optional<evaluate::Assignment> GetEvaluateAssignment(
+ const parser::ActionStmt *x) {
+ if (x == nullptr) {
+ return std::nullopt;
+ }
+
+ using AssignmentStmt = common::Indirection<parser::AssignmentStmt>;
+ using PointerAssignmentStmt =
+ common::Indirection<parser::PointerAssignmentStmt>;
+ using TypedAssignment = parser::AssignmentStmt::TypedAssignment;
+
+ return common::visit(
+ [](auto &&s) -> std::optional<evaluate::Assignment> {
+ using BareS = llvm::remove_cvref_t<decltype(s)>;
+ if constexpr (std::is_same_v<BareS, AssignmentStmt> ||
+ std::is_same_v<BareS, PointerAssignmentStmt>) {
+ const TypedAssignment &typed{s.value().typedAssignment};
+ // ForwardOwningPointer typedAssignment
+ // `- GenericAssignmentWrapper ^.get()
+ // `- std::optional<Assignment> ^->v
+ return typed.get()->v;
} else {
- context_.Say(expr.source,
- "RHS expression on atomic assignment statement cannot access '%s'"_err_en_US,
- var.GetSource());
+ return std::nullopt;
}
+ },
+ x->u);
+}
+
+// Check if the ActionStmt is actually a [Pointer]AssignmentStmt. This is
+// to separate cases where the source has something that looks like an
+// assignment, but is semantically wrong (diagnosed by general semantic
+// checks), and where the source has some other statement (which we want
+// to report as "should be an assignment").
+static bool IsAssignment(const parser::ActionStmt *x) {
+ if (x == nullptr) {
+ return false;
+ }
+
+ using AssignmentStmt = common::Indirection<parser::AssignmentStmt>;
+ using PointerAssignmentStmt =
+ common::Indirection<parser::PointerAssignmentStmt>;
+
+ return common::visit(
+ [](auto &&s) -> bool {
+ using BareS = llvm::remove_cvref_t<decltype(s)>;
+ return std::is_same_v<BareS, AssignmentStmt> ||
+ std::is_same_v<BareS, PointerAssignmentStmt>;
+ },
+ x->u);
+}
+
+static std::optional<AnalyzedCondStmt> AnalyzeConditionalStmt(
+ const parser::ExecutionPartConstruct *x) {
+ if (x == nullptr) {
+ return std::nullopt;
+ }
+
+ // Extract the evaluate::Expr from ScalarLogicalExpr.
+ auto getFromLogical{[](const parser::ScalarLogicalExpr &logical) {
+ // ScalarLogicalExpr is Scalar<Logical<common::Indirection<Expr>>>
+ const parser::Expr &expr{logical.thing.thing.value()};
+ return GetEvaluateExpr(expr);
+ }};
+
+ // Recognize either
+ // ExecutionPartConstruct -> ExecutableConstruct -> ActionStmt -> IfStmt, or
+ // ExecutionPartConstruct -> ExecutableConstruct -> IfConstruct.
+
+ if (auto &&action{GetActionStmt(x)}) {
+ if (auto *ifs{std::get_if<common::Indirection<parser::IfStmt>>(
+ &action.stmt->u)}) {
+ const parser::IfStmt &s{ifs->value()};
+ auto &&maybeCond{
+ getFromLogical(std::get<parser::ScalarLogicalExpr>(s.t))};
+ auto &thenStmt{
+ std::get<parser::UnlabeledStatement<parser::ActionStmt>>(s.t)};
+ if (maybeCond) {
+ return AnalyzedCondStmt{std::move(*maybeCond), action.source,
+ SourcedActionStmt{&thenStmt.statement, thenStmt.source},
+ SourcedActionStmt{}};
}
}
+ return std::nullopt;
}
+
+ if (auto *exec{std::get_if<parser::ExecutableConstruct>(&x->u)}) {
+ if (auto *ifc{
+ std::get_if<common::Indirection<parser::IfConstruct>>(&exec->u)}) {
+ using ElseBlock = parser::IfConstruct::ElseBlock;
+ using ElseIfBlock = parser::IfConstruct::ElseIfBlock;
+ const parser::IfConstruct &s{ifc->value()};
+
+ if (!std::get<std::list<ElseIfBlock>>(s.t).empty()) {
+ // Not expecting any else-if statements.
+ return std::nullopt;
+ }
+ auto &stmt{std::get<parser::Statement<parser::IfThenStmt>>(s.t)};
+ auto &&maybeCond{getFromLogical(
+ std::get<parser::ScalarLogicalExpr>(stmt.statement.t))};
+ if (!maybeCond) {
+ return std::nullopt;
+ }
+
+ if (auto &maybeElse{std::get<std::optional<ElseBlock>>(s.t)}) {
+ AnalyzedCondStmt result{std::move(*maybeCond), stmt.source,
+ GetActionStmt(std::get<parser::Block>(s.t)),
+ GetActionStmt(std::get<parser::Block>(maybeElse->t))};
+ if (result.ift.stmt && result.iff.stmt) {
+ return result;
+ }
+ } else {
+ AnalyzedCondStmt result{std::move(*maybeCond), stmt.source,
+ GetActionStmt(std::get<parser::Block>(s.t)), SourcedActionStmt{}};
+ if (result.ift.stmt) {
+ return result;
+ }
+ }
+ }
+ return std::nullopt;
+ }
+
+ return std::nullopt;
}
-inline void OmpStructureChecker::ErrIfNonScalarAssignmentStmt(
- const parser::Variable &var, const parser::Expr &expr) {
- // Err out if either the variable on the LHS or the expression on the RHS of
- // the assignment statement are non-scalar (i.e. have rank > 0 or is of
- // CHARACTER type)
- const auto *e{GetExpr(context_, expr)};
- const auto *v{GetExpr(context_, var)};
- if (e && v) {
- if (e->Rank() != 0 ||
- (e->GetType().has_value() &&
- e->GetType().value().category() == common::TypeCategory::Character))
- context_.Say(expr.source,
- "Expected scalar expression "
- "on the RHS of atomic assignment "
- "statement"_err_en_US);
- if (v->Rank() != 0 ||
- (v->GetType().has_value() &&
- v->GetType()->category() == common::TypeCategory::Character))
- context_.Say(var.GetSource(),
- "Expected scalar variable "
- "on the LHS of atomic assignment "
- "statement"_err_en_US);
- }
-}
-
-template <typename T, typename D>
-bool OmpStructureChecker::IsOperatorValid(const T &node, const D &variable) {
- using AllowedBinaryOperators =
- std::variant<parser::Expr::Add, parser::Expr::Multiply,
- parser::Expr::Subtract, parser::Expr::Divide, parser::Expr::AND,
- parser::Expr::OR, parser::Expr::EQV, parser::Expr::NEQV>;
- using BinaryOperators = std::variant<parser::Expr::Add,
- parser::Expr::Multiply, parser::Expr::Subtract, parser::Expr::Divide,
- parser::Expr::AND, parser::Expr::OR, parser::Expr::EQV,
- parser::Expr::NEQV, parser::Expr::Power, parser::Expr::Concat,
- parser::Expr::LT, parser::Expr::LE, parser::Expr::EQ, parser::Expr::NE,
- parser::Expr::GE, parser::Expr::GT>;
-
- if constexpr (common::HasMember<T, BinaryOperators>) {
- const auto &variableName{variable.GetSource().ToString()};
- const auto &exprLeft{std::get<0>(node.t)};
- const auto &exprRight{std::get<1>(node.t)};
- if ((exprLeft.value().source.ToString() != variableName) &&
- (exprRight.value().source.ToString() != variableName)) {
- context_.Say(variable.GetSource(),
- "Atomic update statement should be of form "
- "`%s = %s operator expr` OR `%s = expr operator %s`"_err_en_US,
- variableName, variableName, variableName, variableName);
- }
- return common::HasMember<T, AllowedBinaryOperators>;
+static std::pair<parser::CharBlock, parser::CharBlock> SplitAssignmentSource(
+ parser::CharBlock source) {
+ // Find => in the range, if not found, find = that is not a part of
+ // <=, >=, ==, or /=.
+ auto trim{[](std::string_view v) {
+ const char *begin{v.data()};
+ const char *end{begin + v.size()};
+ while (*begin == ' ' && begin != end) {
+ ++begin;
+ }
+ while (begin != end && end[-1] == ' ') {
+ --end;
+ }
+ assert(begin != end && "Source should not be empty");
+ return parser::CharBlock(begin, end - begin);
+ }};
+
+ std::string_view sv(source.begin(), source.size());
+
+ if (auto where{sv.find("=>")}; where != sv.npos) {
+ std::string_view lhs(sv.data(), where);
+ std::string_view rhs(sv.data() + where + 2, sv.size() - where - 2);
+ return std::make_pair(trim(lhs), trim(rhs));
}
- return false;
+
+ // Go backwards, since all the exclusions above end with a '='.
+ for (size_t next{source.size()}; next > 1; --next) {
+ if (sv[next - 1] == '=' && !llvm::is_contained("<>=/", sv[next - 2])) {
+ std::string_view lhs(sv.data(), next - 1);
+ std::string_view rhs(sv.data() + next, sv.size() - next);
+ return std::make_pair(trim(lhs), trim(rhs));
+ }
+ }
+ llvm_unreachable("Could not find assignment operator");
}
-void OmpStructureChecker::CheckAtomicCaptureStmt(
- const parser::AssignmentStmt &assignmentStmt) {
- const auto &var{std::get<parser::Variable>(assignmentStmt.t)};
- const auto &expr{std::get<parser::Expr>(assignmentStmt.t)};
- common::visit(
- common::visitors{
- [&](const common::Indirection<parser::Designator> &designator) {
- const auto *dataRef =
- std::get_if<parser::DataRef>(&designator.value().u);
- const auto *name =
- dataRef ? std::get_if<parser::Name>(&dataRef->u) : nullptr;
- if (name && IsAllocatable(*name->symbol))
- context_.Say(name->source,
- "%s must not have ALLOCATABLE "
- "attribute"_err_en_US,
- name->ToString());
- },
- [&](const auto &) {
- // Anything other than a `parser::Designator` is not allowed
- context_.Say(expr.source,
- "Expected scalar variable "
- "of intrinsic type on RHS of atomic "
- "assignment statement"_err_en_US);
- }},
- expr.u);
- ErrIfLHSAndRHSSymbolsMatch(var, expr);
- ErrIfNonScalarAssignmentStmt(var, expr);
-}
-
-void OmpStructureChecker::CheckAtomicWriteStmt(
- const parser::AssignmentStmt &assignmentStmt) {
- const auto &var{std::get<parser::Variable>(assignmentStmt.t)};
- const auto &expr{std::get<parser::Expr>(assignmentStmt.t)};
- ErrIfAllocatableVariable(var);
- ErrIfLHSAndRHSSymbolsMatch(var, expr);
- ErrIfNonScalarAssignmentStmt(var, expr);
-}
-
-void OmpStructureChecker::CheckAtomicUpdateStmt(
- const parser::AssignmentStmt &assignment) {
- const auto &expr{std::get<parser::Expr>(assignment.t)};
- const auto &var{std::get<parser::Variable>(assignment.t)};
- bool isIntrinsicProcedure{false};
- bool isValidOperator{false};
- common::visit(
- common::visitors{
- [&](const common::Indirection<parser::FunctionReference> &x) {
- isIntrinsicProcedure = true;
- const auto &procedureDesignator{
- std::get<parser::ProcedureDesignator>(x.value().v.t)};
- const parser::Name *name{
- std::get_if<parser::Name>(&procedureDesignator.u)};
- if (name &&
- !(name->source == "max" || name->source == "min" ||
- name->source == "iand" || name->source == "ior" ||
- name->source == "ieor")) {
- context_.Say(expr.source,
- "Invalid intrinsic procedure name in "
- "OpenMP ATOMIC (UPDATE) statement"_err_en_US);
- }
- },
- [&](const auto &x) {
- if (!IsOperatorValid(x, var)) {
- context_.Say(expr.source,
- "Invalid or missing operator in atomic update "
- "statement"_err_en_US);
- } else
- isValidOperator = true;
- },
- },
- expr.u);
- if (const auto *e{GetExpr(context_, expr)}) {
- const auto *v{GetExpr(context_, var)};
- if (e->Rank() != 0 ||
- (e->GetType().has_value() &&
- e->GetType().value().category() == common::TypeCategory::Character))
- context_.Say(expr.source,
- "Expected scalar expression "
- "on the RHS of atomic update assignment "
- "statement"_err_en_US);
- if (v->Rank() != 0 ||
- (v->GetType().has_value() &&
- v->GetType()->category() == common::TypeCategory::Character))
- context_.Say(var.GetSource(),
- "Expected scalar variable "
- "on the LHS of atomic update assignment "
- "statement"_err_en_US);
- auto vSyms{evaluate::GetSymbolVector(*v)};
- const Symbol &varSymbol = vSyms.front();
- int numOfSymbolMatches{0};
- SymbolVector exprSymbols{evaluate::GetSymbolVector(*e)};
- for (const Symbol &symbol : exprSymbols) {
- if (varSymbol == symbol) {
- numOfSymbolMatches++;
+namespace atomic {
+
+struct DesignatorCollector : public evaluate::Traverse<DesignatorCollector,
+ std::vector<SomeExpr>, false> {
+ using Result = std::vector<SomeExpr>;
+ using Base = evaluate::Traverse<DesignatorCollector, Result, false>;
+ DesignatorCollector() : Base(*this) {}
+
+ Result Default() const { return {}; }
+
+ using Base::operator();
+
+ template <typename T> //
+ Result operator()(const evaluate::Designator<T> &x) const {
+ // Once in a designator, don't traverse it any further (i.e. only
+ // collect top-level designators).
+ auto copy{x};
+ return Result{AsGenericExpr(std::move(copy))};
+ }
+
+ template <typename... Rs> //
+ Result Combine(Result &&result, Rs &&...results) const {
+ Result v(std::move(result));
+ auto moveAppend{[](auto &accum, auto &&other) {
+ for (auto &&s : other) {
+ accum.push_back(std::move(s));
}
+ }};
+ (moveAppend(v, std::move(results)), ...);
+ return v;
+ }
+};
+
+struct VariableFinder : public evaluate::AnyTraverse<VariableFinder> {
+ using Base = evaluate::AnyTraverse<VariableFinder>;
+ VariableFinder(const SomeExpr &v) : Base(*this), var(v) {}
+
+ using Base::operator();
+
+ template <typename T>
+ bool operator()(const evaluate::Designator<T> &x) const {
+ auto copy{x};
+ return evaluate::AsGenericExpr(std::move(copy)) == var;
+ }
+
+ template <typename T>
+ bool operator()(const evaluate::FunctionRef<T> &x) const {
+ auto copy{x};
+ return evaluate::AsGenericExpr(std::move(copy)) == var;
+ }
+
+private:
+ const SomeExpr &var;
+};
+} // namespace atomic
+
+static bool IsAllocatable(const SomeExpr &expr) {
+ std::vector<SomeExpr> dsgs{atomic::DesignatorCollector{}(expr)};
+ assert(dsgs.size() == 1 && "Should have a single top-level designator");
+ evaluate::SymbolVector syms{evaluate::GetSymbolVector(dsgs.front())};
+ return !syms.empty() && IsAllocatable(syms.back());
+}
+
+static bool IsPointerAssignment(const evaluate::Assignment &x) {
+ return std::holds_alternative<evaluate::Assignment::BoundsSpec>(x.u) ||
+ std::holds_alternative<evaluate::Assignment::BoundsRemapping>(x.u);
+}
+
+static bool IsCheckForAssociated(const SomeExpr &cond) {
+ return GetTopLevelOperation(cond).first == operation::Operator::Associated;
+}
+
+static bool HasCommonDesignatorSymbols(
+ const evaluate::SymbolVector &baseSyms, const SomeExpr &other) {
+ // Compare the designators used in "other" with the designators whose
+ // symbols are given in baseSyms.
+ // This is a part of the check if these two expressions can access the same
+ // storage: if the designators used in them are different enough, then they
+ // will be assumed not to access the same memory.
+ //
+ // Consider an (array element) expression x%y(w%z), the corresponding symbol
+ // vector will be {x, y, w, z} (i.e. the symbols for these names).
+ // Check whether this exact sequence appears anywhere in any the symbol
+ // vector for "other". This will be true for x(y) and x(y+1), so this is
+ // not a sufficient condition, but can be used to eliminate candidates
+ // before doing more exhaustive checks.
+ //
+ // If any of the symbols in this sequence are function names, assume that
+ // there is no storage overlap, mostly because it would be impossible in
+ // general to determine what storage the function will access.
+ // Note: if f is pure, then two calls to f will access the same storage
+ // when called with the same arguments. This check is not done yet.
+
+ if (llvm::any_of(
+ baseSyms, [](const SymbolRef &s) { return s->IsSubprogram(); })) {
+ // If there is a function symbol in the chain then we can't infer much
+ // about the accessed storage.
+ return false;
+ }
+
+ auto isSubsequence{// Is u a subsequence of v.
+ [](const evaluate::SymbolVector &u, const evaluate::SymbolVector &v) {
+ size_t us{u.size()}, vs{v.size()};
+ if (us > vs) {
+ return false;
+ }
+ for (size_t off{0}; off != vs - us + 1; ++off) {
+ bool same{true};
+ for (size_t i{0}; i != us; ++i) {
+ if (u[i] != v[off + i]) {
+ same = false;
+ break;
+ }
+ }
+ if (same) {
+ return true;
+ }
+ }
+ return false;
+ }};
+
+ evaluate::SymbolVector otherSyms{evaluate::GetSymbolVector(other)};
+ return isSubsequence(baseSyms, otherSyms);
+}
+
+static bool HasCommonTopLevelDesignators(
+ const std::vector<SomeExpr> &baseDsgs, const SomeExpr &other) {
+ // Compare designators directly as expressions. This will ensure
+ // that x(y) and x(y+1) are not flagged as overlapping, whereas
+ // the symbol vectors for both of these would be identical.
+ std::vector<SomeExpr> otherDsgs{atomic::DesignatorCollector{}(other)};
+
+ for (auto &s : baseDsgs) {
+ if (llvm::any_of(otherDsgs, [&](auto &&t) { return s == t; })) {
+ return true;
}
- if (isIntrinsicProcedure) {
- std::string varName = var.GetSource().ToString();
- if (numOfSymbolMatches != 1)
- context_.Say(expr.source,
- "Intrinsic procedure"
- " arguments in atomic update statement"
- " must have exactly one occurence of '%s'"_err_en_US,
- varName);
- else if (varSymbol != exprSymbols.front() &&
- varSymbol != exprSymbols.back())
- context_.Say(expr.source,
- "Atomic update statement "
- "should be of the form `%s = intrinsic_procedure(%s, expr_list)` "
- "OR `%s = intrinsic_procedure(expr_list, %s)`"_err_en_US,
- varName, varName, varName, varName);
- } else if (isValidOperator) {
- if (numOfSymbolMatches != 1)
- context_.Say(expr.source,
- "Exactly one occurence of '%s' "
- "expected on the RHS of atomic update assignment statement"_err_en_US,
- var.GetSource().ToString());
+ }
+ return false;
+}
+
+static const SomeExpr *HasStorageOverlap(
+ const SomeExpr &base, llvm::ArrayRef<SomeExpr> exprs) {
+ evaluate::SymbolVector baseSyms{evaluate::GetSymbolVector(base)};
+ std::vector<SomeExpr> baseDsgs{atomic::DesignatorCollector{}(base)};
+
+ for (const SomeExpr &expr : exprs) {
+ if (!HasCommonDesignatorSymbols(baseSyms, expr)) {
+ continue;
+ }
+ if (HasCommonTopLevelDesignators(baseDsgs, expr)) {
+ return &expr;
}
}
+ return nullptr;
+}
- ErrIfAllocatableVariable(var);
+static bool IsMaybeAtomicWrite(const evaluate::Assignment &assign) {
+ // This ignores function calls, so it will accept "f(x) = f(x) + 1"
+ // for example.
+ return HasStorageOverlap(assign.lhs, assign.rhs) == nullptr;
}
-void OmpStructureChecker::CheckAtomicCompareConstruct(
- const parser::OmpAtomicCompare &atomicCompareConstruct) {
+static bool IsSubexpressionOf(const SomeExpr &sub, const SomeExpr &super) {
+ return atomic::VariableFinder{sub}(super);
+}
- // TODO: Check that the if-stmt is `if (var == expr) var = new`
- // [with or without then/end-do]
+static void SetExpr(parser::TypedExpr &expr, MaybeExpr value) {
+ if (value) {
+ expr.Reset(new evaluate::GenericExprWrapper(std::move(value)),
+ evaluate::GenericExprWrapper::Deleter);
+ }
+}
- unsigned version{context_.langOptions().OpenMPVersion};
- if (version < 51) {
- context_.Say(atomicCompareConstruct.source,
- "%s construct not allowed in %s, %s"_err_en_US,
- atomicCompareConstruct.source, ThisVersion(version), TryVersion(51));
- }
-
- // TODO: More work needed here. Some of the Update restrictions need to
- // be added, but Update isn't the same either.
-}
-
-// TODO: Allow cond-update-stmt once compare clause is supported.
-void OmpStructureChecker::CheckAtomicCaptureConstruct(
- const parser::OmpAtomicCapture &atomicCaptureConstruct) {
- const parser::AssignmentStmt &stmt1 =
- std::get<parser::OmpAtomicCapture::Stmt1>(atomicCaptureConstruct.t)
- .v.statement;
- const auto &stmt1Var{std::get<parser::Variable>(stmt1.t)};
- const auto &stmt1Expr{std::get<parser::Expr>(stmt1.t)};
- const auto *v1 = GetExpr(context_, stmt1Var);
- const auto *e1 = GetExpr(context_, stmt1Expr);
-
- const parser::AssignmentStmt &stmt2 =
- std::get<parser::OmpAtomicCapture::Stmt2>(atomicCaptureConstruct.t)
- .v.statement;
- const auto &stmt2Var{std::get<parser::Variable>(stmt2.t)};
- const auto &stmt2Expr{std::get<parser::Expr>(stmt2.t)};
- const auto *v2 = GetExpr(context_, stmt2Var);
- const auto *e2 = GetExpr(context_, stmt2Expr);
-
- if (e1 && v1 && e2 && v2) {
- if (semantics::checkForSingleVariableOnRHS(stmt1)) {
- CheckAtomicCaptureStmt(stmt1);
- if (semantics::checkForSymbolMatch(v2, e2)) {
- // ATOMIC CAPTURE construct is of the form [capture-stmt, update-stmt]
- CheckAtomicUpdateStmt(stmt2);
+static void SetAssignment(parser::AssignmentStmt::TypedAssignment &assign,
+ std::optional<evaluate::Assignment> value) {
+ if (value) {
+ assign.Reset(new evaluate::GenericAssignmentWrapper(std::move(value)),
+ evaluate::GenericAssignmentWrapper::Deleter);
+ }
+}
+
+static parser::OpenMPAtomicConstruct::Analysis::Op MakeAtomicAnalysisOp(
+ int what,
+ const std::optional<evaluate::Assignment> &maybeAssign = std::nullopt) {
+ parser::OpenMPAtomicConstruct::Analysis::Op operation;
+ operation.what = what;
+ SetAssignment(operation.assign, maybeAssign);
+ return operation;
+}
+
+static parser::OpenMPAtomicConstruct::Analysis MakeAtomicAnalysis(
+ const SomeExpr &atom, const MaybeExpr &cond,
+ parser::OpenMPAtomicConstruct::Analysis::Op &&op0,
+ parser::OpenMPAtomicConstruct::Analysis::Op &&op1) {
+ // Defined in flang/include/flang/Parser/parse-tree.h
+ //
+ // struct Analysis {
+ // struct Kind {
+ // static constexpr int None = 0;
+ // static constexpr int Read = 1;
+ // static constexpr int Write = 2;
+ // static constexpr int Update = Read | Write;
+ // static constexpr int Action = 3; // Bits containing N, R, W, U
+ // static constexpr int IfTrue = 4;
+ // static constexpr int IfFalse = 8;
+ // static constexpr int Condition = 12; // Bits containing IfTrue, IfFalse
+ // };
+ // struct Op {
+ // int what;
+ // TypedAssignment assign;
+ // };
+ // TypedExpr atom, cond;
+ // Op op0, op1;
+ // };
+
+ parser::OpenMPAtomicConstruct::Analysis an;
+ SetExpr(an.atom, atom);
+ SetExpr(an.cond, cond);
+ an.op0 = std::move(op0);
+ an.op1 = std::move(op1);
+ return an;
+}
+
+void OmpStructureChecker::CheckStorageOverlap(const SomeExpr &base,
+ llvm::ArrayRef<evaluate::Expr<evaluate::SomeType>> exprs,
+ parser::CharBlock source) {
+ if (auto *expr{HasStorageOverlap(base, exprs)}) {
+ context_.Say(source,
+ "Within atomic operation %s and %s access the same storage"_warn_en_US,
+ base.AsFortran(), expr->AsFortran());
+ }
+}
+
+void OmpStructureChecker::ErrorShouldBeVariable(
+ const MaybeExpr &expr, parser::CharBlock source) {
+ if (expr) {
+ context_.Say(source, "Atomic expression %s should be a variable"_err_en_US,
+ expr->AsFortran());
+ } else {
+ context_.Say(source, "Atomic expression should be a variable"_err_en_US);
+ }
+}
+
+/// Check if `expr` satisfies the following conditions for x and v:
+///
+/// [6.0:189:10-12]
+/// - x and v (as applicable) are either scalar variables or
+/// function references with scalar data pointer result of non-character
+/// intrinsic type or variables that are non-polymorphic scalar pointers
+/// and any length type parameter must be constant.
+void OmpStructureChecker::CheckAtomicVariable(
+ const SomeExpr &atom, parser::CharBlock source) {
+ if (atom.Rank() != 0) {
+ context_.Say(source, "Atomic variable %s should be a scalar"_err_en_US,
+ atom.AsFortran());
+ }
+
+ if (std::optional<evaluate::DynamicType> dtype{atom.GetType()}) {
+ if (dtype->category() == TypeCategory::Character) {
+ context_.Say(source,
+ "Atomic variable %s cannot have CHARACTER type"_err_en_US,
+ atom.AsFortran());
+ } else if (dtype->IsPolymorphic()) {
+ context_.Say(source,
+ "Atomic variable %s cannot have a polymorphic type"_err_en_US,
+ atom.AsFortran());
+ }
+ // TODO: Check non-constant type parameters for non-character types.
+ // At the moment there don't seem to be any.
+ }
+
+ if (IsAllocatable(atom)) {
+ context_.Say(source, "Atomic variable %s cannot be ALLOCATABLE"_err_en_US,
+ atom.AsFortran());
+ }
+}
+
+std::pair<const parser::ExecutionPartConstruct *,
+ const parser::ExecutionPartConstruct *>
+OmpStructureChecker::CheckUpdateCapture(
+ const parser::ExecutionPartConstruct *ec1,
+ const parser::ExecutionPartConstruct *ec2, parser::CharBlock source) {
+ // Decide which statement is the atomic update and which is the capture.
+ //
+ // The two allowed cases are:
+ // x = ... atomic-var = ...
+ // ... = x capture-var = atomic-var (with optional converts)
+ // or
+ // ... = x capture-var = atomic-var (with optional converts)
+ // x = ... atomic-var = ...
+ //
+ // The case of 'a = b; b = a' is ambiguous, so pick the first one as capture
+ // (which makes more sense, as it captures the original value of the atomic
+ // variable).
+ //
+ // If the two statements don't fit these criteria, return a pair of default-
+ // constructed values.
+ using ReturnTy = std::pair<const parser::ExecutionPartConstruct *,
+ const parser::ExecutionPartConstruct *>;
+
+ SourcedActionStmt act1{GetActionStmt(ec1)};
+ SourcedActionStmt act2{GetActionStmt(ec2)};
+ auto maybeAssign1{GetEvaluateAssignment(act1.stmt)};
+ auto maybeAssign2{GetEvaluateAssignment(act2.stmt)};
+ if (!maybeAssign1 || !maybeAssign2) {
+ if (!IsAssignment(act1.stmt) || !IsAssignment(act2.stmt)) {
+ context_.Say(source,
+ "ATOMIC UPDATE operation with CAPTURE should contain two assignments"_err_en_US);
+ }
+ return std::make_pair(nullptr, nullptr);
+ }
+
+ auto as1{*maybeAssign1}, as2{*maybeAssign2};
+
+ auto isUpdateCapture{
+ [](const evaluate::Assignment &u, const evaluate::Assignment &c) {
+ return IsSameOrConvertOf(c.rhs, u.lhs);
+ }};
+
+ // Do some checks that narrow down the possible choices for the update
+ // and the capture statements. This will help to emit better diagnostics.
+ // 1. An assignment could be an update (cbu) if the left-hand side is a
+ // subexpression of the right-hand side.
+ // 2. An assignment could be a capture (cbc) if the right-hand side is
+ // a variable (or a function ref), with potential type conversions.
+ bool cbu1{IsSubexpressionOf(as1.lhs, as1.rhs)}; // Can as1 be an update?
+ bool cbu2{IsSubexpressionOf(as2.lhs, as2.rhs)}; // Can as2 be an update?
+ bool cbc1{IsVarOrFunctionRef(GetConvertInput(as1.rhs))}; // Can 1 be capture?
+ bool cbc2{IsVarOrFunctionRef(GetConvertInput(as2.rhs))}; // Can 2 be capture?
+
+ // We want to diagnose cases where both assignments cannot be an update,
+ // or both cannot be a capture, as well as cases where either assignment
+ // cannot be any of these two.
+ //
+ // If we organize these boolean values into a matrix
+ // |cbu1 cbu2|
+ // |cbc1 cbc2|
+ // then we want to diagnose cases where the matrix has a zero (i.e. "false")
+ // row or column, including the case where everything is zero. All these
+ // cases correspond to the determinant of the matrix being 0, which suggests
+ // that checking the det may be a convenient diagnostic check. There is only
+ // one additional case where the det is 0, which is when the matrx is all 1
----------------
NimishMishra wrote:
Nit: "matrx" -> "matrix"
https://github.com/llvm/llvm-project/pull/137852
More information about the llvm-commits
mailing list