[flang-commits] [flang] [Flang][OpenMP][NFC] Track Objects for BlockArgs (PR #197442)
Jack Styles via flang-commits
flang-commits at lists.llvm.org
Fri May 15 02:58:40 PDT 2026
https://github.com/Stylie777 updated https://github.com/llvm/llvm-project/pull/197442
>From 98235a84df4e568dff3998ee912e5020b28f858c Mon Sep 17 00:00:00 2001
From: Jack Styles <jack.styles at arm.com>
Date: Tue, 12 May 2026 13:48:06 +0100
Subject: [PATCH 1/2] [Flang][OpenMP][NFC] Track Objects for BlockArgs
When lowering a BlockArg in OpenMP, currently the symbol is tracked.
This can however cause issues later on down the line as information
may be lost relating to an expression. For example, an ArrayElement
will be represented by its symbol, in this case the full array. This
is not ideal as its just he ArrayElement that is intended to be
represented.
Now, the object is tracked instead of the Symbol. For cases where the
symbol is required, appropriate API is available to retrieve this
information. This change opens the ability to better handle lowering
of expressions such as Array Elements.
Assisted-by: Codex
---
flang/include/flang/Support/OpenMP-utils.h | 36 +-
flang/lib/Lower/OpenMP/ClauseProcessor.cpp | 104 +++---
flang/lib/Lower/OpenMP/ClauseProcessor.h | 60 +--
flang/lib/Lower/OpenMP/OpenMP.cpp | 401 +++++++++++----------
flang/lib/Lower/OpenMP/Utils.cpp | 12 +-
flang/lib/Lower/OpenMP/Utils.h | 2 +-
6 files changed, 338 insertions(+), 277 deletions(-)
diff --git a/flang/include/flang/Support/OpenMP-utils.h b/flang/include/flang/Support/OpenMP-utils.h
index 6d9db2b682c50..47d5ab2c023c0 100644
--- a/flang/include/flang/Support/OpenMP-utils.h
+++ b/flang/include/flang/Support/OpenMP-utils.h
@@ -9,25 +9,35 @@
#ifndef FORTRAN_SUPPORT_OPENMP_UTILS_H_
#define FORTRAN_SUPPORT_OPENMP_UTILS_H_
+#include "flang/Lower/OpenMP/Clauses.h"
#include "flang/Semantics/symbol.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/Value.h"
#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
namespace Fortran::common::openmp {
/// Structure holding the information needed to create and bind entry block
/// arguments associated to a single clause.
struct EntryBlockArgsEntry {
- llvm::ArrayRef<const Fortran::semantics::Symbol *> syms;
+ llvm::SmallVector<Fortran::lower::omp::Object> objects;
llvm::ArrayRef<mlir::Value> vars;
bool isValid() const {
- // This check allows specifying a smaller number of symbols than values
+ // This check allows specifying a smaller number of objects than values
// because in some case cases a single symbol generates multiple block
// arguments.
- return syms.size() <= vars.size();
+ return objects.size() <= vars.size();
+ }
+
+ llvm::SmallVector<const Fortran::semantics::Symbol *> getSyms() const {
+ llvm::SmallVector<const Fortran::semantics::Symbol *> syms;
+ for (const Fortran::lower::omp::Object &object : objects) {
+ syms.push_back(object.sym());
+ }
+ return syms;
}
};
@@ -50,10 +60,22 @@ struct EntryBlockArgs {
useDeviceAddr.isValid() && useDevicePtr.isValid();
}
- auto getSyms() const {
- return llvm::concat<const semantics::Symbol *const>(hasDeviceAddr.syms,
- inReduction.syms, map.syms, priv.syms, reduction.syms,
- taskReduction.syms, useDeviceAddr.syms, useDevicePtr.syms);
+ llvm::SmallVector<const semantics::Symbol *> getSyms() const {
+ llvm::SmallVector<const semantics::Symbol *> syms;
+ auto appendSyms = [&syms](const EntryBlockArgsEntry &entry) {
+ for (const Fortran::lower::omp::Object &object : entry.objects) {
+ syms.push_back(object.sym());
+ }
+ };
+ appendSyms(hasDeviceAddr);
+ appendSyms(inReduction);
+ appendSyms(map);
+ appendSyms(priv);
+ appendSyms(reduction);
+ appendSyms(taskReduction);
+ appendSyms(useDeviceAddr);
+ appendSyms(useDevicePtr);
+ return syms;
}
auto getVars() const {
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
index 5f5b4fe77f701..6bbabf7e38cdb 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
@@ -1493,7 +1493,7 @@ bool ClauseProcessor::processGrainsize(
bool ClauseProcessor::processHasDeviceAddr(
lower::StatementContext &stmtCtx, mlir::omp::HasDeviceAddrClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &hasDeviceSyms) const {
+ llvm::SmallVectorImpl<Object> &hasDeviceObjects) const {
// For HAS_DEVICE_ADDR objects, implicitly map the top-level entities.
// Their address (or the whole descriptor, if the entity had one) will be
// passed to the target region.
@@ -1513,11 +1513,11 @@ bool ClauseProcessor::processHasDeviceAddr(
});
processMapObjects(stmtCtx, location, baseObjects, mapTypeBits,
parentMemberIndices, result.hasDeviceAddrVars,
- hasDeviceSyms);
+ hasDeviceObjects);
});
insertChildMapInfoIntoParent(converter, semaCtx, stmtCtx, parentMemberIndices,
- result.hasDeviceAddrVars, hasDeviceSyms);
+ result.hasDeviceAddrVars, hasDeviceObjects);
return clauseFound;
}
@@ -1541,26 +1541,32 @@ bool ClauseProcessor::processIf(
}
template <typename T>
-void collectReductionSyms(
- const T &reduction,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms) {
- const auto &objectList{std::get<omp::ObjectList>(reduction.t)};
- for (const Object &object : objectList) {
- const semantics::Symbol *symbol = object.sym();
- reductionSyms.push_back(symbol);
- }
+void collectReductionObjects(const T &reduction,
+ llvm::SmallVectorImpl<Object> &reductionObjects) {
+ const omp::ObjectList &objectList{std::get<omp::ObjectList>(reduction.t)};
+ llvm::copy(objectList, std::back_inserter(reductionObjects));
+}
+
+static llvm::SmallVector<const semantics::Symbol *>
+getObjectsSyms(llvm::ArrayRef<Object> objects) {
+ llvm::SmallVector<const semantics::Symbol *> syms;
+ for (const Object &object : objects)
+ syms.push_back(object.sym());
+ return syms;
}
bool ClauseProcessor::processInReduction(
mlir::Location currentLocation, mlir::omp::InReductionClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &outReductionSyms) const {
+ llvm::SmallVectorImpl<Object> &outReductionObjects) const {
return findRepeatableClause<omp::clause::InReduction>(
[&](const omp::clause::InReduction &clause, const parser::CharBlock &) {
llvm::SmallVector<mlir::Value> inReductionVars;
llvm::SmallVector<bool> inReduceVarByRef;
llvm::SmallVector<mlir::Attribute> inReductionDeclSymbols;
- llvm::SmallVector<const semantics::Symbol *> inReductionSyms;
- collectReductionSyms(clause, inReductionSyms);
+ llvm::SmallVector<Object> inReductionObjects;
+ collectReductionObjects(clause, inReductionObjects);
+ llvm::SmallVector<const semantics::Symbol *> inReductionSyms =
+ getObjectsSyms(inReductionObjects);
ReductionProcessor rp;
if (!rp.processReductionArguments<mlir::omp::DeclareReductionOp>(
@@ -1576,13 +1582,13 @@ bool ClauseProcessor::processInReduction(
std::back_inserter(result.inReductionByref));
llvm::copy(inReductionDeclSymbols,
std::back_inserter(result.inReductionSyms));
- llvm::copy(inReductionSyms, std::back_inserter(outReductionSyms));
+ llvm::copy(inReductionObjects, std::back_inserter(outReductionObjects));
});
}
bool ClauseProcessor::processIsDevicePtr(
lower::StatementContext &stmtCtx, mlir::omp::IsDevicePtrClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &isDeviceSyms) const {
+ llvm::SmallVectorImpl<Object> &isDeviceObjects) const {
std::map<Object, OmpMapParentAndMemberData> parentMemberIndices;
bool clauseFound = findRepeatableClause<omp::clause::IsDevicePtr>(
[&](const omp::clause::IsDevicePtr &clause,
@@ -1595,11 +1601,11 @@ bool ClauseProcessor::processIsDevicePtr(
mlir::omp::ClauseMapFlags::to;
processMapObjects(stmtCtx, location, clause.v, mapTypeBits,
parentMemberIndices, result.isDevicePtrVars,
- isDeviceSyms);
+ isDeviceObjects);
});
insertChildMapInfoIntoParent(converter, semaCtx, stmtCtx, parentMemberIndices,
- result.isDevicePtrVars, isDeviceSyms);
+ result.isDevicePtrVars, isDeviceObjects);
return clauseFound;
}
@@ -1709,9 +1715,8 @@ void ClauseProcessor::processMapObjects(
const omp::ObjectList &objects, mlir::omp::ClauseMapFlags mapTypeBits,
std::map<Object, OmpMapParentAndMemberData> &parentMemberIndices,
llvm::SmallVectorImpl<mlir::Value> &mapVars,
- llvm::SmallVectorImpl<const semantics::Symbol *> &mapSyms,
- llvm::StringRef mapperIdNameRef, bool isMotionModifier,
- llvm::omp::Directive directive) const {
+ llvm::SmallVectorImpl<Object> &mapObjects, llvm::StringRef mapperIdNameRef,
+ bool isMotionModifier, llvm::omp::Directive directive) const {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
auto getSymbolDerivedType = [](const semantics::Symbol &symbol)
@@ -1902,7 +1907,7 @@ void ClauseProcessor::processMapObjects(
object, mapOp, semaCtx);
} else {
mapVars.push_back(mapOp);
- mapSyms.push_back(object.sym());
+ mapObjects.push_back(object);
}
}
}
@@ -1936,13 +1941,13 @@ getMapperIdentifier(lower::AbstractConverter &converter,
bool ClauseProcessor::processMap(
mlir::Location currentLocation, lower::StatementContext &stmtCtx,
mlir::omp::MapClauseOps &result, llvm::omp::Directive directive,
- llvm::SmallVectorImpl<const semantics::Symbol *> *mapSyms) const {
- // We always require tracking of symbols, even if the caller does not,
- // so we create an optionally used local set of symbols when the mapSyms
+ llvm::SmallVectorImpl<Object> *mapObjects) const {
+ // We always require tracking of objects, even if the caller does not,
+ // so we create an optionally used local set of objects when the mapObjects
// argument is not present.
- llvm::SmallVector<const semantics::Symbol *> localMapSyms;
- llvm::SmallVectorImpl<const semantics::Symbol *> *ptrMapSyms =
- mapSyms ? mapSyms : &localMapSyms;
+ llvm::SmallVector<Object> localMapObjects;
+ llvm::SmallVectorImpl<Object> *ptrMapObjects =
+ mapObjects ? mapObjects : &localMapObjects;
std::map<Object, OmpMapParentAndMemberData> parentMemberIndices;
auto process = [&](const omp::clause::Map &clause,
@@ -2005,13 +2010,13 @@ bool ClauseProcessor::processMap(
}
processMapObjects(stmtCtx, clauseLocation,
std::get<omp::ObjectList>(clause.t), mapTypeBits,
- parentMemberIndices, result.mapVars, *ptrMapSyms,
+ parentMemberIndices, result.mapVars, *ptrMapObjects,
mapperIdName, /*isMotionModifier=*/false, directive);
};
bool clauseFound = findRepeatableClause<omp::clause::Map>(process);
insertChildMapInfoIntoParent(converter, semaCtx, stmtCtx, parentMemberIndices,
- result.mapVars, *ptrMapSyms);
+ result.mapVars, *ptrMapObjects);
return clauseFound;
}
@@ -2019,7 +2024,7 @@ bool ClauseProcessor::processMap(
bool ClauseProcessor::processMotionClauses(lower::StatementContext &stmtCtx,
mlir::omp::MapClauseOps &result) {
std::map<Object, OmpMapParentAndMemberData> parentMemberIndices;
- llvm::SmallVector<const semantics::Symbol *> mapSymbols;
+ llvm::SmallVector<Object> mapObjects;
auto callbackFn = [&](const auto &clause, const parser::CharBlock &source) {
mlir::Location clauseLocation = converter.genLocation(source);
@@ -2040,7 +2045,7 @@ bool ClauseProcessor::processMotionClauses(lower::StatementContext &stmtCtx,
}
processMapObjects(stmtCtx, clauseLocation, objects, mapTypeBits,
- parentMemberIndices, result.mapVars, mapSymbols,
+ parentMemberIndices, result.mapVars, mapObjects,
mapperIdName, /*isMotionModifier=*/true);
};
@@ -2049,7 +2054,7 @@ bool ClauseProcessor::processMotionClauses(lower::StatementContext &stmtCtx,
findRepeatableClause<omp::clause::From>(callbackFn) || clauseFound;
insertChildMapInfoIntoParent(converter, semaCtx, stmtCtx, parentMemberIndices,
- result.mapVars, mapSymbols);
+ result.mapVars, mapObjects);
return clauseFound;
}
@@ -2068,7 +2073,7 @@ bool ClauseProcessor::processNontemporal(
bool ClauseProcessor::processReduction(
mlir::Location currentLocation, mlir::omp::ReductionClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &outReductionSyms,
+ llvm::SmallVectorImpl<Object> &outReductionObjects,
llvm::DenseMap<const semantics::Symbol *, mlir::Value> *reductionVarCache)
const {
return findRepeatableClause<omp::clause::Reduction>(
@@ -2076,8 +2081,10 @@ bool ClauseProcessor::processReduction(
llvm::SmallVector<mlir::Value> reductionVars;
llvm::SmallVector<bool> reduceVarByRef;
llvm::SmallVector<mlir::Attribute> reductionDeclSymbols;
- llvm::SmallVector<const semantics::Symbol *> reductionSyms;
- collectReductionSyms(clause, reductionSyms);
+ llvm::SmallVector<Object> reductionObjects;
+ collectReductionObjects(clause, reductionObjects);
+ llvm::SmallVector<const semantics::Symbol *> reductionSyms =
+ getObjectsSyms(reductionObjects);
auto mod = std::get<std::optional<ReductionModifier>>(clause.t);
if (mod.has_value()) {
@@ -2101,20 +2108,22 @@ bool ClauseProcessor::processReduction(
llvm::copy(reduceVarByRef, std::back_inserter(result.reductionByref));
llvm::copy(reductionDeclSymbols,
std::back_inserter(result.reductionSyms));
- llvm::copy(reductionSyms, std::back_inserter(outReductionSyms));
+ llvm::copy(reductionObjects, std::back_inserter(outReductionObjects));
});
}
bool ClauseProcessor::processTaskReduction(
mlir::Location currentLocation, mlir::omp::TaskReductionClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &outReductionSyms) const {
+ llvm::SmallVectorImpl<Object> &outReductionObjects) const {
return findRepeatableClause<omp::clause::TaskReduction>(
[&](const omp::clause::TaskReduction &clause, const parser::CharBlock &) {
llvm::SmallVector<mlir::Value> taskReductionVars;
llvm::SmallVector<bool> taskReduceVarByRef;
llvm::SmallVector<mlir::Attribute> taskReductionDeclSymbols;
- llvm::SmallVector<const semantics::Symbol *> taskReductionSyms;
- collectReductionSyms(clause, taskReductionSyms);
+ llvm::SmallVector<Object> taskReductionObjects;
+ collectReductionObjects(clause, taskReductionObjects);
+ llvm::SmallVector<const semantics::Symbol *> taskReductionSyms =
+ getObjectsSyms(taskReductionObjects);
ReductionProcessor rp;
if (!rp.processReductionArguments<mlir::omp::DeclareReductionOp>(
@@ -2130,7 +2139,8 @@ bool ClauseProcessor::processTaskReduction(
std::back_inserter(result.taskReductionByref));
llvm::copy(taskReductionDeclSymbols,
std::back_inserter(result.taskReductionSyms));
- llvm::copy(taskReductionSyms, std::back_inserter(outReductionSyms));
+ llvm::copy(taskReductionObjects,
+ std::back_inserter(outReductionObjects));
});
}
@@ -2161,7 +2171,7 @@ bool ClauseProcessor::processEnter(
bool ClauseProcessor::processUseDeviceAddr(
lower::StatementContext &stmtCtx, mlir::omp::UseDeviceAddrClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &useDeviceSyms) const {
+ llvm::SmallVectorImpl<Object> &useDeviceObjects) const {
std::map<Object, OmpMapParentAndMemberData> parentMemberIndices;
bool clauseFound = findRepeatableClause<omp::clause::UseDeviceAddr>(
[&](const omp::clause::UseDeviceAddr &clause,
@@ -2171,17 +2181,17 @@ bool ClauseProcessor::processUseDeviceAddr(
mlir::omp::ClauseMapFlags::return_param;
processMapObjects(stmtCtx, location, clause.v, mapTypeBits,
parentMemberIndices, result.useDeviceAddrVars,
- useDeviceSyms);
+ useDeviceObjects);
});
insertChildMapInfoIntoParent(converter, semaCtx, stmtCtx, parentMemberIndices,
- result.useDeviceAddrVars, useDeviceSyms);
+ result.useDeviceAddrVars, useDeviceObjects);
return clauseFound;
}
bool ClauseProcessor::processUseDevicePtr(
lower::StatementContext &stmtCtx, mlir::omp::UseDevicePtrClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &useDeviceSyms) const {
+ llvm::SmallVectorImpl<Object> &useDeviceObjects) const {
std::map<Object, OmpMapParentAndMemberData> parentMemberIndices;
bool clauseFound = findRepeatableClause<omp::clause::UseDevicePtr>(
@@ -2192,11 +2202,11 @@ bool ClauseProcessor::processUseDevicePtr(
mlir::omp::ClauseMapFlags::return_param;
processMapObjects(stmtCtx, location, clause.v, mapTypeBits,
parentMemberIndices, result.useDevicePtrVars,
- useDeviceSyms);
+ useDeviceObjects);
});
insertChildMapInfoIntoParent(converter, semaCtx, stmtCtx, parentMemberIndices,
- result.useDevicePtrVars, useDeviceSyms);
+ result.useDevicePtrVars, useDeviceObjects);
return clauseFound;
}
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.h b/flang/lib/Lower/OpenMP/ClauseProcessor.h
index e138b4df30b71..1fc221b721ebf 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.h
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.h
@@ -87,10 +87,10 @@ class ClauseProcessor {
mlir::omp::FinalClauseOps &result) const;
bool processGrainsize(lower::StatementContext &stmtCtx,
mlir::omp::GrainsizeClauseOps &result) const;
- bool processHasDeviceAddr(
- lower::StatementContext &stmtCtx,
- mlir::omp::HasDeviceAddrClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &hasDeviceSyms) const;
+ bool
+ processHasDeviceAddr(lower::StatementContext &stmtCtx,
+ mlir::omp::HasDeviceAddrClauseOps &result,
+ llvm::SmallVectorImpl<Object> &hasDeviceObjects) const;
bool processHint(mlir::omp::HintClauseOps &result) const;
bool processInbranch(mlir::omp::InbranchClauseOps &result) const;
bool processInclusive(mlir::Location currentLocation,
@@ -141,47 +141,47 @@ class ClauseProcessor {
processEnter(llvm::SmallVectorImpl<DeclareTargetCaptureInfo> &result) const;
bool processIf(omp::clause::If::DirectiveNameModifier directiveName,
mlir::omp::IfClauseOps &result) const;
- bool processInReduction(
- mlir::Location currentLocation, mlir::omp::InReductionClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &outReductionSyms) const;
- bool processIsDevicePtr(
- lower::StatementContext &stmtCtx, mlir::omp::IsDevicePtrClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &isDeviceSyms) const;
+ bool
+ processInReduction(mlir::Location currentLocation,
+ mlir::omp::InReductionClauseOps &result,
+ llvm::SmallVectorImpl<Object> &outReductionObjects) const;
+ bool processIsDevicePtr(lower::StatementContext &stmtCtx,
+ mlir::omp::IsDevicePtrClauseOps &result,
+ llvm::SmallVectorImpl<Object> &isDeviceObjects) const;
bool processLinear(mlir::omp::LinearClauseOps &result,
bool isDeclareSimd = false) const;
bool
processLink(llvm::SmallVectorImpl<DeclareTargetCaptureInfo> &result) const;
// This method is used to process a map clause.
- // The optional parameter mapSyms is used to store the original Fortran symbol
- // for the map operands. It may be used later on to create the block_arguments
- // for some of the directives that require it.
+ // The optional parameter mapObjects is used to store the original Fortran
+ // objects for the map operands. It may be used later on to create the
+ // block_arguments for some of the directives that require it.
bool processMap(mlir::Location currentLocation,
lower::StatementContext &stmtCtx,
mlir::omp::MapClauseOps &result,
llvm::omp::Directive directive = llvm::omp::OMPD_unknown,
- llvm::SmallVectorImpl<const semantics::Symbol *> *mapSyms =
- nullptr) const;
+ llvm::SmallVectorImpl<Object> *mapObjects = nullptr) const;
bool processMotionClauses(lower::StatementContext &stmtCtx,
mlir::omp::MapClauseOps &result);
bool processNontemporal(mlir::omp::NontemporalClauseOps &result) const;
- bool processReduction(
- mlir::Location currentLocation, mlir::omp::ReductionClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms,
- llvm::DenseMap<const semantics::Symbol *, mlir::Value>
- *reductionVarCache = nullptr) const;
+ bool processReduction(mlir::Location currentLocation,
+ mlir::omp::ReductionClauseOps &result,
+ llvm::SmallVectorImpl<Object> &reductionObjects,
+ llvm::DenseMap<const semantics::Symbol *, mlir::Value>
+ *reductionVarCache = nullptr) const;
bool processTaskReduction(
mlir::Location currentLocation, mlir::omp::TaskReductionClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &outReductionSyms) const;
+ llvm::SmallVectorImpl<Object> &outReductionObjects) const;
bool processTo(llvm::SmallVectorImpl<DeclareTargetCaptureInfo> &result) const;
- bool processUseDeviceAddr(
- lower::StatementContext &stmtCtx,
- mlir::omp::UseDeviceAddrClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &useDeviceSyms) const;
- bool processUseDevicePtr(
- lower::StatementContext &stmtCtx,
- mlir::omp::UseDevicePtrClauseOps &result,
- llvm::SmallVectorImpl<const semantics::Symbol *> &useDeviceSyms) const;
+ bool
+ processUseDeviceAddr(lower::StatementContext &stmtCtx,
+ mlir::omp::UseDeviceAddrClauseOps &result,
+ llvm::SmallVectorImpl<Object> &useDeviceObjects) const;
+ bool
+ processUseDevicePtr(lower::StatementContext &stmtCtx,
+ mlir::omp::UseDevicePtrClauseOps &result,
+ llvm::SmallVectorImpl<Object> &useDeviceObjects) const;
bool processUniform(mlir::omp::UniformClauseOps &result) const;
// Call this method for these clauses that should be supported but are not
@@ -216,7 +216,7 @@ class ClauseProcessor {
const omp::ObjectList &objects, mlir::omp::ClauseMapFlags mapTypeBits,
std::map<Object, OmpMapParentAndMemberData> &parentMemberIndices,
llvm::SmallVectorImpl<mlir::Value> &mapVars,
- llvm::SmallVectorImpl<const semantics::Symbol *> &mapSyms,
+ llvm::SmallVectorImpl<Object> &mapObjects,
llvm::StringRef mapperIdNameRef = "", bool isMotionModifier = false,
llvm::omp::Directive directive = llvm::omp::OMPD_unknown) const;
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index fb5014f3394be..f849eb73ba1e6 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -74,6 +74,15 @@ static void processHostEvalClauses(lower::AbstractConverter &converter,
lower::pft::Evaluation &eval,
mlir::Location loc);
+static llvm::SmallVector<Object>
+makeObjects(llvm::ArrayRef<const semantics::Symbol *> syms) {
+ llvm::SmallVector<Object> objects;
+ for (const semantics::Symbol *sym : syms)
+ objects.push_back(
+ Object{const_cast<semantics::Symbol *>(sym), std::nullopt});
+ return objects;
+}
+
namespace {
/// Structure holding information that is needed to pass host-evaluated
/// information to later lowering stages.
@@ -247,7 +256,7 @@ getSectionsConstructStackTop(lower::AbstractConverter &converter) {
return frame ? &frame->sectionsConstruct : nullptr;
}
-/// Bind symbols to their corresponding entry block arguments.
+/// Bind objects to their corresponding entry block arguments.
///
/// The binding will be performed inside of the current block, which does not
/// necessarily have to be part of the operation for which the binding is done.
@@ -306,25 +315,29 @@ static void bindEntryBlockArgs(lower::AbstractConverter &converter,
};
auto bindMapLike =
- [&bindSingleMapLike](llvm::ArrayRef<const semantics::Symbol *> syms,
+ [&bindSingleMapLike](llvm::ArrayRef<Object> objects,
llvm::ArrayRef<mlir::BlockArgument> args) {
// Structure component symbols don't have bindings, and can only be
// explicitly mapped individually. If a member is captured implicitly
// we map the entirety of the derived type when we find its symbol.
llvm::SmallVector<const semantics::Symbol *> processedSyms;
- llvm::copy_if(syms, std::back_inserter(processedSyms),
- [](auto *sym) { return !sym->owner().IsDerivedType(); });
+ for (const Object &object : objects) {
+ const semantics::Symbol *sym = object.sym();
+ if (!sym->owner().IsDerivedType())
+ processedSyms.push_back(sym);
+ }
for (auto [sym, arg] : llvm::zip_equal(processedSyms, args))
bindSingleMapLike(*sym, arg);
};
auto bindPrivateLike = [&converter, &firOpBuilder](
- llvm::ArrayRef<const semantics::Symbol *> syms,
+ llvm::ArrayRef<Object> objects,
llvm::ArrayRef<mlir::Value> vars,
llvm::ArrayRef<mlir::BlockArgument> args) {
llvm::SmallVector<const semantics::Symbol *> processedSyms;
- for (auto *sym : syms) {
+ for (const Object &object : objects) {
+ const semantics::Symbol *sym = object.sym();
if (const auto *commonDet =
sym->detailsIf<semantics::CommonBlockDetails>()) {
llvm::transform(commonDet->objects(), std::back_inserter(processedSyms),
@@ -347,17 +360,17 @@ static void bindEntryBlockArgs(lower::AbstractConverter &converter,
// Process in clause name alphabetical order to match block arguments order.
// Do not bind host_eval variables because they cannot be used inside of the
// corresponding region, except for very specific cases handled separately.
- bindMapLike(args.hasDeviceAddr.syms, op.getHasDeviceAddrBlockArgs());
- bindPrivateLike(args.inReduction.syms, args.inReduction.vars,
+ bindMapLike(args.hasDeviceAddr.objects, op.getHasDeviceAddrBlockArgs());
+ bindPrivateLike(args.inReduction.objects, args.inReduction.vars,
op.getInReductionBlockArgs());
- bindMapLike(args.map.syms, op.getMapBlockArgs());
- bindPrivateLike(args.priv.syms, args.priv.vars, op.getPrivateBlockArgs());
- bindPrivateLike(args.reduction.syms, args.reduction.vars,
+ bindMapLike(args.map.objects, op.getMapBlockArgs());
+ bindPrivateLike(args.priv.objects, args.priv.vars, op.getPrivateBlockArgs());
+ bindPrivateLike(args.reduction.objects, args.reduction.vars,
op.getReductionBlockArgs());
- bindPrivateLike(args.taskReduction.syms, args.taskReduction.vars,
+ bindPrivateLike(args.taskReduction.objects, args.taskReduction.vars,
op.getTaskReductionBlockArgs());
- bindMapLike(args.useDeviceAddr.syms, op.getUseDeviceAddrBlockArgs());
- bindMapLike(args.useDevicePtr.syms, op.getUseDevicePtrBlockArgs());
+ bindMapLike(args.useDeviceAddr.objects, op.getUseDeviceAddrBlockArgs());
+ bindMapLike(args.useDevicePtr.objects, op.getUseDevicePtrBlockArgs());
}
/// Get the list of base values that the specified map-like variables point to.
@@ -738,25 +751,25 @@ createAndSetPrivatizedLoopVar(lower::AbstractConverter &converter,
// such list items in a use_device_ptr clause is deprecated."
static void promoteNonCPtrUseDevicePtrArgsToUseDeviceAddr(
llvm::SmallVectorImpl<mlir::Value> &useDeviceAddrVars,
- llvm::SmallVectorImpl<const semantics::Symbol *> &useDeviceAddrSyms,
+ llvm::SmallVectorImpl<Object> &useDeviceAddrObjects,
llvm::SmallVectorImpl<mlir::Value> &useDevicePtrVars,
- llvm::SmallVectorImpl<const semantics::Symbol *> &useDevicePtrSyms) {
+ llvm::SmallVectorImpl<Object> &useDevicePtrObjects) {
// Iterate over our use_device_ptr list and shift all non-cptr arguments into
// use_device_addr.
auto *varIt = useDevicePtrVars.begin();
- auto *symIt = useDevicePtrSyms.begin();
+ auto *objectIt = useDevicePtrObjects.begin();
while (varIt != useDevicePtrVars.end()) {
if (fir::isa_builtin_cptr_type(fir::unwrapRefType(varIt->getType()))) {
++varIt;
- ++symIt;
+ ++objectIt;
continue;
}
useDeviceAddrVars.push_back(*varIt);
- useDeviceAddrSyms.push_back(*symIt);
+ useDeviceAddrObjects.push_back(*objectIt);
varIt = useDevicePtrVars.erase(varIt);
- symIt = useDevicePtrSyms.erase(symIt);
+ objectIt = useDevicePtrObjects.erase(objectIt);
}
}
@@ -1439,8 +1452,9 @@ static void genBodyOfTargetOp(
// within the region, binding them to the member symbol for the scope of the
// region so that subsequent code generation within the region will utilise
// our new member accesses we have created.
- genIntermediateCommonBlockAccessors(
- converter, currentLocation, argIface.getMapBlockArgs(), args.map.syms);
+ genIntermediateCommonBlockAccessors(converter, currentLocation,
+ argIface.getMapBlockArgs(),
+ args.map.getSyms());
// Check if cloning the bounds introduced any dependency on the outer region.
// If so, then either clone them as well if they are MemoryEffectFree, or else
@@ -1595,15 +1609,15 @@ genLoopNestClauses(lower::AbstractConverter &converter,
cp.processTileSizes(eval, clauseOps);
}
-static void genLoopClauses(
- lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
- const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::LoopOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms) {
+static void genLoopClauses(lower::AbstractConverter &converter,
+ semantics::SemanticsContext &semaCtx,
+ const List<Clause> &clauses, mlir::Location loc,
+ mlir::omp::LoopOperands &clauseOps,
+ llvm::SmallVectorImpl<Object> &reductionObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processBind(clauseOps);
cp.processOrder(clauseOps);
- cp.processReduction(loc, clauseOps, reductionSyms);
+ cp.processReduction(loc, clauseOps, reductionObjects);
cp.processTODO<clause::Lastprivate>(loc, llvm::omp::Directive::OMPD_loop);
}
@@ -1629,7 +1643,7 @@ static void genParallelClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx, const List<Clause> &clauses,
mlir::Location loc, mlir::omp::ParallelOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms) {
+ llvm::SmallVectorImpl<Object> &reductionObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processIf(llvm::omp::Directive::OMPD_parallel, clauseOps);
@@ -1639,7 +1653,7 @@ static void genParallelClauses(
cp.processNumThreads(stmtCtx, clauseOps);
cp.processProcBind(clauseOps);
- cp.processReduction(loc, clauseOps, reductionSyms);
+ cp.processReduction(loc, clauseOps, reductionObjects);
}
static void genScanClauses(lower::AbstractConverter &converter,
@@ -1651,15 +1665,16 @@ static void genScanClauses(lower::AbstractConverter &converter,
cp.processExclusive(loc, clauseOps);
}
-static void genSectionsClauses(
- lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
- const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::SectionsOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms) {
+static void
+genSectionsClauses(lower::AbstractConverter &converter,
+ semantics::SemanticsContext &semaCtx,
+ const List<Clause> &clauses, mlir::Location loc,
+ mlir::omp::SectionsOperands &clauseOps,
+ llvm::SmallVectorImpl<Object> &reductionObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processNowait(clauseOps);
- cp.processReduction(loc, clauseOps, reductionSyms);
+ cp.processReduction(loc, clauseOps, reductionObjects);
// TODO Support delayed privatization.
}
@@ -1667,7 +1682,7 @@ static void genSimdClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
const List<Clause> &clauses, mlir::Location loc,
mlir::omp::SimdOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms,
+ llvm::SmallVectorImpl<Object> &reductionObjects,
llvm::DenseMap<const semantics::Symbol *, mlir::Value> *reductionVarCache =
nullptr) {
ClauseProcessor cp(converter, semaCtx, clauses);
@@ -1675,7 +1690,7 @@ static void genSimdClauses(
cp.processIf(llvm::omp::Directive::OMPD_simd, clauseOps);
cp.processNontemporal(clauseOps);
cp.processOrder(clauseOps);
- cp.processReduction(loc, clauseOps, reductionSyms, reductionVarCache);
+ cp.processReduction(loc, clauseOps, reductionObjects, reductionVarCache);
cp.processSafelen(clauseOps);
cp.processSimdlen(clauseOps);
cp.processLinear(clauseOps);
@@ -1751,15 +1766,15 @@ genSimdImplicitLinear(lower::AbstractConverter &converter,
}
}
-static void genScopeClauses(
- lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
- const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::ScopeOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms) {
+static void genScopeClauses(lower::AbstractConverter &converter,
+ semantics::SemanticsContext &semaCtx,
+ const List<Clause> &clauses, mlir::Location loc,
+ mlir::omp::ScopeOperands &clauseOps,
+ llvm::SmallVectorImpl<Object> &reductionObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processNowait(clauseOps);
- cp.processReduction(loc, clauseOps, reductionSyms);
+ cp.processReduction(loc, clauseOps, reductionObjects);
}
static void genSingleClauses(lower::AbstractConverter &converter,
@@ -1773,30 +1788,31 @@ static void genSingleClauses(lower::AbstractConverter &converter,
// TODO Support delayed privatization.
}
-static void genTargetClauses(
- lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
- lower::SymMap &symTable, lower::StatementContext &stmtCtx,
- lower::pft::Evaluation &eval, const List<Clause> &clauses,
- mlir::Location loc, mlir::omp::TargetOperands &clauseOps,
- DefaultMapsTy &defaultMaps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &hasDeviceAddrSyms,
- llvm::SmallVectorImpl<const semantics::Symbol *> &isDevicePtrSyms,
- llvm::SmallVectorImpl<const semantics::Symbol *> &mapSyms) {
+static void
+genTargetClauses(lower::AbstractConverter &converter,
+ semantics::SemanticsContext &semaCtx, lower::SymMap &symTable,
+ lower::StatementContext &stmtCtx, lower::pft::Evaluation &eval,
+ const List<Clause> &clauses, mlir::Location loc,
+ mlir::omp::TargetOperands &clauseOps,
+ DefaultMapsTy &defaultMaps,
+ llvm::SmallVectorImpl<Object> &hasDeviceAddrObjects,
+ llvm::SmallVectorImpl<Object> &isDevicePtrObjects,
+ llvm::SmallVectorImpl<Object> &mapObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processBare(clauseOps);
cp.processDefaultMap(stmtCtx, defaultMaps);
cp.processDepend(symTable, stmtCtx, clauseOps);
cp.processDevice(stmtCtx, clauseOps);
- cp.processHasDeviceAddr(stmtCtx, clauseOps, hasDeviceAddrSyms);
+ cp.processHasDeviceAddr(stmtCtx, clauseOps, hasDeviceAddrObjects);
if (HostEvalInfo *hostEvalInfo = getHostEvalInfoStackTop(converter)) {
// Only process host_eval if compiling for the host device.
processHostEvalClauses(converter, semaCtx, stmtCtx, eval, loc);
hostEvalInfo->collectValues(clauseOps.hostEvalVars);
}
cp.processIf(llvm::omp::Directive::OMPD_target, clauseOps);
- cp.processIsDevicePtr(stmtCtx, clauseOps, isDevicePtrSyms);
+ cp.processIsDevicePtr(stmtCtx, clauseOps, isDevicePtrObjects);
cp.processMap(loc, stmtCtx, clauseOps, llvm::omp::Directive::OMPD_unknown,
- &mapSyms);
+ &mapObjects);
cp.processNowait(clauseOps);
cp.processThreadLimit(stmtCtx, clauseOps);
@@ -1813,14 +1829,14 @@ static void genTargetDataClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx, const List<Clause> &clauses,
mlir::Location loc, mlir::omp::TargetDataOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &useDeviceAddrSyms,
- llvm::SmallVectorImpl<const semantics::Symbol *> &useDevicePtrSyms) {
+ llvm::SmallVectorImpl<Object> &useDeviceAddrObjects,
+ llvm::SmallVectorImpl<Object> &useDevicePtrObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processDevice(stmtCtx, clauseOps);
cp.processIf(llvm::omp::Directive::OMPD_target_data, clauseOps);
cp.processMap(loc, stmtCtx, clauseOps);
- cp.processUseDeviceAddr(stmtCtx, clauseOps, useDeviceAddrSyms);
- cp.processUseDevicePtr(stmtCtx, clauseOps, useDevicePtrSyms);
+ cp.processUseDeviceAddr(stmtCtx, clauseOps, useDeviceAddrObjects);
+ cp.processUseDevicePtr(stmtCtx, clauseOps, useDevicePtrObjects);
// This function implements the deprecated functionality of use_device_ptr
// that allows users to provide non-CPTR arguments to it with the caveat
@@ -1831,8 +1847,8 @@ static void genTargetDataClauses(
// TODO: Perhaps create a user provideable compiler option that will
// re-introduce a hard-error rather than a warning in these cases.
promoteNonCPtrUseDevicePtrArgsToUseDeviceAddr(
- clauseOps.useDeviceAddrVars, useDeviceAddrSyms,
- clauseOps.useDevicePtrVars, useDevicePtrSyms);
+ clauseOps.useDeviceAddrVars, useDeviceAddrObjects,
+ clauseOps.useDevicePtrVars, useDevicePtrObjects);
}
static void genTargetEnterExitUpdateDataClauses(
@@ -1854,53 +1870,55 @@ static void genTargetEnterExitUpdateDataClauses(
cp.processNowait(clauseOps);
}
-static void genTaskClauses(
- lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
- lower::SymMap &symTable, lower::StatementContext &stmtCtx,
- const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::TaskOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &inReductionSyms) {
+static void genTaskClauses(lower::AbstractConverter &converter,
+ semantics::SemanticsContext &semaCtx,
+ lower::SymMap &symTable,
+ lower::StatementContext &stmtCtx,
+ const List<Clause> &clauses, mlir::Location loc,
+ mlir::omp::TaskOperands &clauseOps,
+ llvm::SmallVectorImpl<Object> &inReductionObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAffinity(clauseOps);
cp.processAllocate(clauseOps);
cp.processDepend(symTable, stmtCtx, clauseOps);
cp.processFinal(stmtCtx, clauseOps);
cp.processIf(llvm::omp::Directive::OMPD_task, clauseOps);
- cp.processInReduction(loc, clauseOps, inReductionSyms);
+ cp.processInReduction(loc, clauseOps, inReductionObjects);
cp.processMergeable(clauseOps);
cp.processPriority(stmtCtx, clauseOps);
cp.processUntied(clauseOps);
cp.processDetach(clauseOps);
}
-static void genTaskgroupClauses(
- lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
- const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::TaskgroupOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &taskReductionSyms) {
+static void
+genTaskgroupClauses(lower::AbstractConverter &converter,
+ semantics::SemanticsContext &semaCtx,
+ const List<Clause> &clauses, mlir::Location loc,
+ mlir::omp::TaskgroupOperands &clauseOps,
+ llvm::SmallVectorImpl<Object> &taskReductionObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
- cp.processTaskReduction(loc, clauseOps, taskReductionSyms);
+ cp.processTaskReduction(loc, clauseOps, taskReductionObjects);
}
static void genTaskloopClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx, const List<Clause> &clauses,
mlir::Location loc, mlir::omp::TaskloopContextOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms,
- llvm::SmallVectorImpl<const semantics::Symbol *> &inReductionSyms) {
+ llvm::SmallVectorImpl<Object> &reductionObjects,
+ llvm::SmallVectorImpl<Object> &inReductionObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processFinal(stmtCtx, clauseOps);
cp.processGrainsize(stmtCtx, clauseOps);
cp.processIf(llvm::omp::Directive::OMPD_taskloop, clauseOps);
- cp.processInReduction(loc, clauseOps, inReductionSyms);
+ cp.processInReduction(loc, clauseOps, inReductionObjects);
cp.processMergeable(clauseOps);
cp.processNogroup(clauseOps);
cp.processNumTasks(stmtCtx, clauseOps);
cp.processPriority(stmtCtx, clauseOps);
- cp.processReduction(loc, clauseOps, reductionSyms);
+ cp.processReduction(loc, clauseOps, reductionObjects);
cp.processUntied(clauseOps);
}
@@ -1922,11 +1940,12 @@ static void genWorkshareClauses(lower::AbstractConverter &converter,
cp.processNowait(clauseOps);
}
-static void genTeamsClauses(
- lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
- lower::StatementContext &stmtCtx, const List<Clause> &clauses,
- mlir::Location loc, mlir::omp::TeamsOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms) {
+static void genTeamsClauses(lower::AbstractConverter &converter,
+ semantics::SemanticsContext &semaCtx,
+ lower::StatementContext &stmtCtx,
+ const List<Clause> &clauses, mlir::Location loc,
+ mlir::omp::TeamsOperands &clauseOps,
+ llvm::SmallVectorImpl<Object> &reductionObjects) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processIf(llvm::omp::Directive::OMPD_teams, clauseOps);
@@ -1937,7 +1956,7 @@ static void genTeamsClauses(
cp.processThreadLimit(stmtCtx, clauseOps);
}
- cp.processReduction(loc, clauseOps, reductionSyms);
+ cp.processReduction(loc, clauseOps, reductionObjects);
// TODO Support delayed privatization.
}
@@ -1945,7 +1964,7 @@ static void genWsloopClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx, const List<Clause> &clauses,
mlir::Location loc, mlir::omp::WsloopOperands &clauseOps,
- llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms,
+ llvm::SmallVectorImpl<Object> &reductionObjects,
llvm::DenseMap<const semantics::Symbol *, mlir::Value> *reductionVarCache =
nullptr) {
ClauseProcessor cp(converter, semaCtx, clauses);
@@ -1953,7 +1972,7 @@ static void genWsloopClauses(
cp.processNowait(clauseOps);
cp.processOrder(clauseOps);
cp.processOrdered(clauseOps);
- cp.processReduction(loc, clauseOps, reductionSyms, reductionVarCache);
+ cp.processReduction(loc, clauseOps, reductionObjects, reductionVarCache);
cp.processSchedule(stmtCtx, clauseOps);
cp.processLinear(clauseOps);
}
@@ -2097,9 +2116,9 @@ genLoopOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::const_iterator item) {
mlir::omp::LoopOperands loopClauseOps;
- llvm::SmallVector<const semantics::Symbol *> loopReductionSyms;
+ llvm::SmallVector<Object> loopReductionObjects;
genLoopClauses(converter, semaCtx, item->clauses, loc, loopClauseOps,
- loopReductionSyms);
+ loopReductionObjects);
DataSharingProcessor dsp(converter, semaCtx, item->clauses, eval,
/*shouldCollectPreDeterminedSymbols=*/true,
@@ -2112,9 +2131,9 @@ genLoopOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
loopNestClauseOps, iv);
EntryBlockArgs loopArgs;
- loopArgs.priv.syms = dsp.getDelayedPrivSymbols();
+ loopArgs.priv.objects = makeObjects(dsp.getDelayedPrivSymbols());
loopArgs.priv.vars = loopClauseOps.privateVars;
- loopArgs.reduction.syms = loopReductionSyms;
+ loopArgs.reduction.objects = loopReductionObjects;
loopArgs.reduction.vars = loopClauseOps.reductionVars;
auto loopOp =
@@ -2560,9 +2579,9 @@ genSectionsOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
const auto §ionBlocks =
std::get<std::list<parser::OpenMPConstruct>>(sectionsConstruct->t);
mlir::omp::SectionsOperands clauseOps;
- llvm::SmallVector<const semantics::Symbol *> reductionSyms;
+ llvm::SmallVector<Object> reductionObjects;
genSectionsClauses(converter, semaCtx, item->clauses, loc, clauseOps,
- reductionSyms);
+ reductionObjects);
auto &builder = converter.getFirOpBuilder();
@@ -2599,7 +2618,7 @@ genSectionsOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
// Create entry block with reduction variables as arguments.
EntryBlockArgs args;
// TODO: Add private syms and vars.
- args.reduction.syms = reductionSyms;
+ args.reduction.objects = reductionObjects;
args.reduction.vars = clauseOps.reductionVars;
genEntryBlock(builder, args, sectionsOp.getRegion());
@@ -2682,9 +2701,9 @@ genScopeOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
ConstructQueue::const_iterator item) {
lower::SymMapScope scope(symTable);
mlir::omp::ScopeOperands clauseOps;
- llvm::SmallVector<const semantics::Symbol *> reductionSyms;
+ llvm::SmallVector<Object> reductionObjects;
genScopeClauses(converter, semaCtx, item->clauses, loc, clauseOps,
- reductionSyms);
+ reductionObjects);
std::optional<DataSharingProcessor> dsp;
if (enableDelayedPrivatization) {
@@ -2696,9 +2715,9 @@ genScopeOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
EntryBlockArgs args;
if (dsp)
- args.priv.syms = dsp->getDelayedPrivSymbols();
+ args.priv.objects = makeObjects(dsp->getDelayedPrivSymbols());
args.priv.vars = clauseOps.privateVars;
- args.reduction.syms = reductionSyms;
+ args.reduction.objects = reductionObjects;
args.reduction.vars = clauseOps.reductionVars;
return genOpWithBody<mlir::omp::ScopeOp>(
@@ -2729,16 +2748,18 @@ genSingleOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
static bool isDuplicateMappedSymbol(
const semantics::Symbol &sym,
const llvm::SetVector<const semantics::Symbol *> &privatizedSyms,
- const llvm::SmallVectorImpl<const semantics::Symbol *> &hasDevSyms,
- const llvm::SmallVectorImpl<const semantics::Symbol *> &mappedSyms,
- const llvm::SmallVectorImpl<const semantics::Symbol *> &isDevicePtrSyms) {
+ llvm::ArrayRef<Object> hasDevObjects, llvm::ArrayRef<Object> mappedObjects,
+ llvm::ArrayRef<Object> isDevicePtrObjects) {
llvm::SmallVector<const semantics::Symbol *> concatSyms;
- concatSyms.reserve(privatizedSyms.size() + hasDevSyms.size() +
- mappedSyms.size() + isDevicePtrSyms.size());
+ concatSyms.reserve(privatizedSyms.size() + hasDevObjects.size() +
+ mappedObjects.size() + isDevicePtrObjects.size());
concatSyms.append(privatizedSyms.begin(), privatizedSyms.end());
- concatSyms.append(hasDevSyms.begin(), hasDevSyms.end());
- concatSyms.append(mappedSyms.begin(), mappedSyms.end());
- concatSyms.append(isDevicePtrSyms.begin(), isDevicePtrSyms.end());
+ llvm::transform(hasDevObjects, std::back_inserter(concatSyms),
+ [](const Object &object) { return object.sym(); });
+ llvm::transform(mappedObjects, std::back_inserter(concatSyms),
+ [](const Object &object) { return object.sym(); });
+ llvm::transform(isDevicePtrObjects, std::back_inserter(concatSyms),
+ [](const Object &object) { return object.sym(); });
auto checkSymbol = [&](const semantics::Symbol &checkSym) {
return std::any_of(concatSyms.begin(), concatSyms.end(),
@@ -2832,25 +2853,28 @@ genTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
mlir::omp::TargetOperands clauseOps;
DefaultMapsTy defaultMaps;
- llvm::SmallVector<const semantics::Symbol *> mapSyms, isDevicePtrSyms,
- hasDeviceAddrSyms;
+ llvm::SmallVector<Object> mapObjects, hasDeviceAddrObjects,
+ isDevicePtrObjects;
genTargetClauses(converter, semaCtx, symTable, stmtCtx, eval, item->clauses,
- loc, clauseOps, defaultMaps, hasDeviceAddrSyms,
- isDevicePtrSyms, mapSyms);
+ loc, clauseOps, defaultMaps, hasDeviceAddrObjects,
+ isDevicePtrObjects, mapObjects);
- if (!isDevicePtrSyms.empty()) {
+ if (!isDevicePtrObjects.empty()) {
// is_device_ptr maps get duplicated so the clause and synthesized
// has_device_addr entry each own a unique MapInfoOp user, keeping
// MapInfoFinalization happy while still wiring the symbol into
// has_device_addr when the user didn’t spell it explicitly.
auto insertionPt = firOpBuilder.saveInsertionPoint();
auto alreadyPresent = [&](const semantics::Symbol *sym) {
- return llvm::any_of(hasDeviceAddrSyms, [&](const semantics::Symbol *s) {
- return s && sym && s->GetUltimate() == sym->GetUltimate();
+ return llvm::any_of(hasDeviceAddrObjects, [&](const Object &object) {
+ const semantics::Symbol *objectSym = object.sym();
+ return objectSym && sym &&
+ objectSym->GetUltimate() == sym->GetUltimate();
});
};
- for (auto [idx, sym] : llvm::enumerate(isDevicePtrSyms)) {
+ for (auto [idx, object] : llvm::enumerate(isDevicePtrObjects)) {
+ const semantics::Symbol *sym = object.sym();
mlir::Value mapVal = clauseOps.isDevicePtrVars[idx];
assert(sym && "expected symbol for is_device_ptr");
assert(mapVal && "expected map value for is_device_ptr");
@@ -2859,7 +2883,7 @@ genTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
if (!alreadyPresent(sym)) {
clauseOps.hasDeviceAddrVars.push_back(mapVal);
- hasDeviceAddrSyms.push_back(sym);
+ hasDeviceAddrObjects.push_back(object);
}
firOpBuilder.setInsertionPointAfter(mapInfo);
@@ -2898,7 +2922,9 @@ genTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
// map for it.
if (const Fortran::semantics::Symbol *common =
Fortran::semantics::FindCommonBlockContaining(sym.GetUltimate()))
- if (llvm::is_contained(mapSyms, common))
+ if (llvm::any_of(mapObjects, [=](const Object &object) {
+ return object.sym() == common;
+ }))
return;
// If we come across a symbol without a symbol address, we
@@ -2919,7 +2945,8 @@ genTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
return;
if (!isDuplicateMappedSymbol(sym, dsp.getAllSymbolsToPrivatize(),
- hasDeviceAddrSyms, mapSyms, isDevicePtrSyms)) {
+ hasDeviceAddrObjects, mapObjects,
+ isDevicePtrObjects)) {
if (const auto *details =
sym.template detailsIf<semantics::HostAssocDetails>())
converter.copySymbolBinding(details->symbol(), sym);
@@ -2999,7 +3026,8 @@ genTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
/*partialMap=*/false, mapperId);
clauseOps.mapVars.push_back(mapOp);
- mapSyms.push_back(&sym);
+ mapObjects.push_back(
+ Object{const_cast<semantics::Symbol *>(&sym), std::nullopt});
}
};
lower::pft::visitAllSymbols(eval, captureImplicitMap);
@@ -3011,13 +3039,13 @@ genTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
extractMappedBaseValues(clauseOps.mapVars, mapBaseValues);
EntryBlockArgs args;
- args.hasDeviceAddr.syms = hasDeviceAddrSyms;
+ args.hasDeviceAddr.objects = hasDeviceAddrObjects;
args.hasDeviceAddr.vars = hasDeviceAddrBaseValues;
args.hostEvalVars = clauseOps.hostEvalVars;
// TODO: Add in_reduction syms and vars.
- args.map.syms = mapSyms;
+ args.map.objects = mapObjects;
args.map.vars = mapBaseValues;
- args.priv.syms = dsp.getDelayedPrivSymbols();
+ args.priv.objects = makeObjects(dsp.getDelayedPrivSymbols());
args.priv.vars = clauseOps.privateVars;
genBodyOfTargetOp(converter, symTable, semaCtx, eval, targetOp, args, loc,
@@ -3035,10 +3063,9 @@ static mlir::omp::TargetDataOp genTargetDataOp(
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue, ConstructQueue::const_iterator item) {
mlir::omp::TargetDataOperands clauseOps;
- llvm::SmallVector<const semantics::Symbol *> useDeviceAddrSyms,
- useDevicePtrSyms;
+ llvm::SmallVector<Object> useDeviceAddrObjects, useDevicePtrObjects;
genTargetDataClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
- clauseOps, useDeviceAddrSyms, useDevicePtrSyms);
+ clauseOps, useDeviceAddrObjects, useDevicePtrObjects);
auto targetDataOp = mlir::omp::TargetDataOp::create(
converter.getFirOpBuilder(), loc, clauseOps);
@@ -3049,9 +3076,9 @@ static mlir::omp::TargetDataOp genTargetDataOp(
extractMappedBaseValues(clauseOps.useDevicePtrVars, useDevicePtrBaseValues);
EntryBlockArgs args;
- args.useDeviceAddr.syms = useDeviceAddrSyms;
+ args.useDeviceAddr.objects = useDeviceAddrObjects;
args.useDeviceAddr.vars = useDeviceAddrBaseValues;
- args.useDevicePtr.syms = useDevicePtrSyms;
+ args.useDevicePtr.objects = useDevicePtrObjects;
args.useDevicePtr.vars = useDevicePtrBaseValues;
genBodyOfTargetDataOp(converter, symTable, semaCtx, eval, targetDataOp, args,
@@ -3093,9 +3120,9 @@ genTaskOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::const_iterator item) {
mlir::omp::TaskOperands clauseOps;
- llvm::SmallVector<const semantics::Symbol *> inReductionSyms;
+ llvm::SmallVector<Object> inReductionObjects;
genTaskClauses(converter, semaCtx, symTable, stmtCtx, item->clauses, loc,
- clauseOps, inReductionSyms);
+ clauseOps, inReductionObjects);
if (!enableDelayedPrivatization)
return genOpWithBody<mlir::omp::TaskOp>(
@@ -3110,9 +3137,9 @@ genTaskOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
dsp.processStep1(&clauseOps);
EntryBlockArgs taskArgs;
- taskArgs.priv.syms = dsp.getDelayedPrivSymbols();
+ taskArgs.priv.objects = makeObjects(dsp.getDelayedPrivSymbols());
taskArgs.priv.vars = clauseOps.privateVars;
- taskArgs.inReduction.syms = inReductionSyms;
+ taskArgs.inReduction.objects = inReductionObjects;
taskArgs.inReduction.vars = clauseOps.inReductionVars;
return genOpWithBody<mlir::omp::TaskOp>(
@@ -3131,12 +3158,12 @@ genTaskgroupOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
const ConstructQueue &queue,
ConstructQueue::const_iterator item) {
mlir::omp::TaskgroupOperands clauseOps;
- llvm::SmallVector<const semantics::Symbol *> taskReductionSyms;
+ llvm::SmallVector<Object> taskReductionObjects;
genTaskgroupClauses(converter, semaCtx, item->clauses, loc, clauseOps,
- taskReductionSyms);
+ taskReductionObjects);
EntryBlockArgs taskgroupArgs;
- taskgroupArgs.taskReduction.syms = taskReductionSyms;
+ taskgroupArgs.taskReduction.objects = taskReductionObjects;
taskgroupArgs.taskReduction.vars = clauseOps.taskReductionVars;
return genOpWithBody<mlir::omp::TaskgroupOp>(
@@ -3192,13 +3219,13 @@ genTeamsOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
ConstructQueue::const_iterator item) {
lower::SymMapScope scope(symTable);
mlir::omp::TeamsOperands clauseOps;
- llvm::SmallVector<const semantics::Symbol *> reductionSyms;
+ llvm::SmallVector<Object> reductionObjects;
genTeamsClauses(converter, semaCtx, stmtCtx, item->clauses, loc, clauseOps,
- reductionSyms);
+ reductionObjects);
EntryBlockArgs args;
// TODO: Add private syms and vars.
- args.reduction.syms = reductionSyms;
+ args.reduction.objects = reductionObjects;
args.reduction.vars = clauseOps.reductionVars;
return genOpWithBody<mlir::omp::TeamsOp>(
OpWithBodyGenInfo(converter, symTable, semaCtx, loc, eval,
@@ -3244,7 +3271,7 @@ static mlir::omp::DistributeOp genStandaloneDistribute(
loopNestClauseOps, iv);
EntryBlockArgs distributeArgs;
- distributeArgs.priv.syms = dsp.getDelayedPrivSymbols();
+ distributeArgs.priv.objects = makeObjects(dsp.getDelayedPrivSymbols());
distributeArgs.priv.vars = distributeClauseOps.privateVars;
auto distributeOp = genWrapperOp<mlir::omp::DistributeOp>(
converter, loc, distributeClauseOps, distributeArgs);
@@ -3261,9 +3288,9 @@ static mlir::omp::WsloopOp genStandaloneDo(
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue, ConstructQueue::const_iterator item) {
mlir::omp::WsloopOperands wsloopClauseOps;
- llvm::SmallVector<const semantics::Symbol *> wsloopReductionSyms;
+ llvm::SmallVector<Object> wsloopReductionObjects;
genWsloopClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
- wsloopClauseOps, wsloopReductionSyms);
+ wsloopClauseOps, wsloopReductionObjects);
DataSharingProcessor dsp(converter, semaCtx, item->clauses, eval,
/*shouldCollectPreDeterminedSymbols=*/true,
@@ -3276,9 +3303,9 @@ static mlir::omp::WsloopOp genStandaloneDo(
loopNestClauseOps, iv);
EntryBlockArgs wsloopArgs;
- wsloopArgs.priv.syms = dsp.getDelayedPrivSymbols();
+ wsloopArgs.priv.objects = makeObjects(dsp.getDelayedPrivSymbols());
wsloopArgs.priv.vars = wsloopClauseOps.privateVars;
- wsloopArgs.reduction.syms = wsloopReductionSyms;
+ wsloopArgs.reduction.objects = wsloopReductionObjects;
wsloopArgs.reduction.vars = wsloopClauseOps.reductionVars;
auto wsloopOp = genWrapperOp<mlir::omp::WsloopOp>(
converter, loc, wsloopClauseOps, wsloopArgs);
@@ -3296,9 +3323,9 @@ static mlir::omp::ParallelOp genStandaloneParallel(
const ConstructQueue &queue, ConstructQueue::const_iterator item) {
lower::SymMapScope scope(symTable);
mlir::omp::ParallelOperands parallelClauseOps;
- llvm::SmallVector<const semantics::Symbol *> parallelReductionSyms;
+ llvm::SmallVector<Object> parallelReductionObjects;
genParallelClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
- parallelClauseOps, parallelReductionSyms);
+ parallelClauseOps, parallelReductionObjects);
std::optional<DataSharingProcessor> dsp;
if (enableDelayedPrivatization) {
@@ -3310,9 +3337,9 @@ static mlir::omp::ParallelOp genStandaloneParallel(
EntryBlockArgs parallelArgs;
if (dsp)
- parallelArgs.priv.syms = dsp->getDelayedPrivSymbols();
+ parallelArgs.priv.objects = makeObjects(dsp->getDelayedPrivSymbols());
parallelArgs.priv.vars = parallelClauseOps.privateVars;
- parallelArgs.reduction.syms = parallelReductionSyms;
+ parallelArgs.reduction.objects = parallelReductionObjects;
parallelArgs.reduction.vars = parallelClauseOps.reductionVars;
return genParallelOp(converter, symTable, semaCtx, eval, loc, queue, item,
parallelClauseOps, parallelArgs,
@@ -3326,9 +3353,9 @@ genStandaloneSimd(lower::AbstractConverter &converter, lower::SymMap &symTable,
const ConstructQueue &queue,
ConstructQueue::const_iterator item) {
mlir::omp::SimdOperands simdClauseOps;
- llvm::SmallVector<const semantics::Symbol *> simdReductionSyms;
+ llvm::SmallVector<Object> simdReductionObjects;
genSimdClauses(converter, semaCtx, item->clauses, loc, simdClauseOps,
- simdReductionSyms);
+ simdReductionObjects);
DataSharingProcessor dsp(converter, semaCtx, item->clauses, eval,
/*shouldCollectPreDeterminedSymbols=*/true,
@@ -3343,9 +3370,9 @@ genStandaloneSimd(lower::AbstractConverter &converter, lower::SymMap &symTable,
iv);
EntryBlockArgs simdArgs;
- simdArgs.priv.syms = dsp.getDelayedPrivSymbols();
+ simdArgs.priv.objects = makeObjects(dsp.getDelayedPrivSymbols());
simdArgs.priv.vars = simdClauseOps.privateVars;
- simdArgs.reduction.syms = simdReductionSyms;
+ simdArgs.reduction.objects = simdReductionObjects;
simdArgs.reduction.vars = simdClauseOps.reductionVars;
auto simdOp =
genWrapperOp<mlir::omp::SimdOp>(converter, loc, simdClauseOps, simdArgs);
@@ -3361,11 +3388,11 @@ static mlir::omp::TaskloopContextOp genStandaloneTaskloop(
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue, ConstructQueue::const_iterator item) {
mlir::omp::TaskloopContextOperands taskloopClauseOps;
- llvm::SmallVector<const semantics::Symbol *> reductionSyms;
- llvm::SmallVector<const semantics::Symbol *> inReductionSyms;
+ llvm::SmallVector<Object> reductionObjects;
+ llvm::SmallVector<Object> inReductionObjects;
genTaskloopClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
- taskloopClauseOps, reductionSyms, inReductionSyms);
+ taskloopClauseOps, reductionObjects, inReductionObjects);
DataSharingProcessor dsp(converter, semaCtx, item->clauses, eval,
/*shouldCollectPreDeterminedSymbols=*/true,
enableDelayedPrivatization, symTable);
@@ -3377,11 +3404,11 @@ static mlir::omp::TaskloopContextOp genStandaloneTaskloop(
loopNestClauseOps, iv);
EntryBlockArgs taskloopArgs;
- taskloopArgs.priv.syms = dsp.getDelayedPrivSymbols();
+ taskloopArgs.priv.objects = makeObjects(dsp.getDelayedPrivSymbols());
taskloopArgs.priv.vars = taskloopClauseOps.privateVars;
- taskloopArgs.reduction.syms = reductionSyms;
+ taskloopArgs.reduction.objects = reductionObjects;
taskloopArgs.reduction.vars = taskloopClauseOps.reductionVars;
- taskloopArgs.inReduction.syms = inReductionSyms;
+ taskloopArgs.inReduction.objects = inReductionObjects;
taskloopArgs.inReduction.vars = taskloopClauseOps.inReductionVars;
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
@@ -3422,9 +3449,9 @@ static mlir::omp::DistributeOp genCompositeDistributeParallelDo(
// Create parent omp.parallel first.
mlir::omp::ParallelOperands parallelClauseOps;
- llvm::SmallVector<const semantics::Symbol *> parallelReductionSyms;
+ llvm::SmallVector<Object> parallelReductionObjects;
genParallelClauses(converter, semaCtx, stmtCtx, parallelItem->clauses, loc,
- parallelClauseOps, parallelReductionSyms);
+ parallelClauseOps, parallelReductionObjects);
DataSharingProcessor dsp(converter, semaCtx, doItem->clauses, eval,
/*shouldCollectPreDeterminedSymbols=*/true,
@@ -3432,9 +3459,9 @@ static mlir::omp::DistributeOp genCompositeDistributeParallelDo(
dsp.processStep1(¶llelClauseOps);
EntryBlockArgs parallelArgs;
- parallelArgs.priv.syms = dsp.getDelayedPrivSymbols();
+ parallelArgs.priv.objects = makeObjects(dsp.getDelayedPrivSymbols());
parallelArgs.priv.vars = parallelClauseOps.privateVars;
- parallelArgs.reduction.syms = parallelReductionSyms;
+ parallelArgs.reduction.objects = parallelReductionObjects;
parallelArgs.reduction.vars = parallelClauseOps.reductionVars;
genParallelOp(converter, symTable, semaCtx, eval, loc, queue, parallelItem,
parallelClauseOps, parallelArgs, &dsp, /*isComposite=*/true);
@@ -3445,9 +3472,9 @@ static mlir::omp::DistributeOp genCompositeDistributeParallelDo(
loc, distributeClauseOps);
mlir::omp::WsloopOperands wsloopClauseOps;
- llvm::SmallVector<const semantics::Symbol *> wsloopReductionSyms;
+ llvm::SmallVector<Object> wsloopReductionObjects;
genWsloopClauses(converter, semaCtx, stmtCtx, doItem->clauses, loc,
- wsloopClauseOps, wsloopReductionSyms);
+ wsloopClauseOps, wsloopReductionObjects);
mlir::omp::LoopNestOperands loopNestClauseOps;
llvm::SmallVector<const semantics::Symbol *> iv;
@@ -3463,7 +3490,7 @@ static mlir::omp::DistributeOp genCompositeDistributeParallelDo(
EntryBlockArgs wsloopArgs;
// TODO: Add private syms and vars.
- wsloopArgs.reduction.syms = wsloopReductionSyms;
+ wsloopArgs.reduction.objects = wsloopReductionObjects;
wsloopArgs.reduction.vars = wsloopClauseOps.reductionVars;
auto wsloopOp = genWrapperOp<mlir::omp::WsloopOp>(
converter, loc, wsloopClauseOps, wsloopArgs);
@@ -3489,9 +3516,9 @@ static mlir::omp::DistributeOp genCompositeDistributeParallelDoSimd(
// Create parent omp.parallel first.
mlir::omp::ParallelOperands parallelClauseOps;
- llvm::SmallVector<const semantics::Symbol *> parallelReductionSyms;
+ llvm::SmallVector<Object> parallelReductionObjects;
genParallelClauses(converter, semaCtx, stmtCtx, parallelItem->clauses, loc,
- parallelClauseOps, parallelReductionSyms);
+ parallelClauseOps, parallelReductionObjects);
DataSharingProcessor parallelItemDSP(
converter, semaCtx, parallelItem->clauses, eval,
@@ -3500,9 +3527,10 @@ static mlir::omp::DistributeOp genCompositeDistributeParallelDoSimd(
parallelItemDSP.processStep1(¶llelClauseOps);
EntryBlockArgs parallelArgs;
- parallelArgs.priv.syms = parallelItemDSP.getDelayedPrivSymbols();
+ parallelArgs.priv.objects =
+ makeObjects(parallelItemDSP.getDelayedPrivSymbols());
parallelArgs.priv.vars = parallelClauseOps.privateVars;
- parallelArgs.reduction.syms = parallelReductionSyms;
+ parallelArgs.reduction.objects = parallelReductionObjects;
parallelArgs.reduction.vars = parallelClauseOps.reductionVars;
genParallelOp(converter, symTable, semaCtx, eval, loc, queue, parallelItem,
parallelClauseOps, parallelArgs, ¶llelItemDSP,
@@ -3518,14 +3546,14 @@ static mlir::omp::DistributeOp genCompositeDistributeParallelDoSimd(
loc, distributeClauseOps);
mlir::omp::WsloopOperands wsloopClauseOps;
- llvm::SmallVector<const semantics::Symbol *> wsloopReductionSyms;
+ llvm::SmallVector<Object> wsloopReductionObjects;
genWsloopClauses(converter, semaCtx, stmtCtx, doItem->clauses, loc,
- wsloopClauseOps, wsloopReductionSyms, &reductionVarCache);
+ wsloopClauseOps, wsloopReductionObjects, &reductionVarCache);
mlir::omp::SimdOperands simdClauseOps;
- llvm::SmallVector<const semantics::Symbol *> simdReductionSyms;
+ llvm::SmallVector<Object> simdReductionObjects;
genSimdClauses(converter, semaCtx, simdItem->clauses, loc, simdClauseOps,
- simdReductionSyms, &reductionVarCache);
+ simdReductionObjects, &reductionVarCache);
DataSharingProcessor simdItemDSP(converter, semaCtx, simdItem->clauses, eval,
/*shouldCollectPreDeterminedSymbols=*/true,
@@ -3548,16 +3576,16 @@ static mlir::omp::DistributeOp genCompositeDistributeParallelDoSimd(
EntryBlockArgs wsloopArgs;
// TODO: Add private syms and vars.
- wsloopArgs.reduction.syms = wsloopReductionSyms;
+ wsloopArgs.reduction.objects = wsloopReductionObjects;
wsloopArgs.reduction.vars = wsloopClauseOps.reductionVars;
auto wsloopOp = genWrapperOp<mlir::omp::WsloopOp>(
converter, loc, wsloopClauseOps, wsloopArgs);
wsloopOp.setComposite(/*val=*/true);
EntryBlockArgs simdArgs;
- simdArgs.priv.syms = simdItemDSP.getDelayedPrivSymbols();
+ simdArgs.priv.objects = makeObjects(simdItemDSP.getDelayedPrivSymbols());
simdArgs.priv.vars = simdClauseOps.privateVars;
- simdArgs.reduction.syms = simdReductionSyms;
+ simdArgs.reduction.objects = simdReductionObjects;
simdArgs.reduction.vars = simdClauseOps.reductionVars;
auto simdOp =
genWrapperOp<mlir::omp::SimdOp>(converter, loc, simdClauseOps, simdArgs);
@@ -3588,9 +3616,9 @@ static mlir::omp::DistributeOp genCompositeDistributeSimd(
loc, distributeClauseOps);
mlir::omp::SimdOperands simdClauseOps;
- llvm::SmallVector<const semantics::Symbol *> simdReductionSyms;
+ llvm::SmallVector<Object> simdReductionObjects;
genSimdClauses(converter, semaCtx, simdItem->clauses, loc, simdClauseOps,
- simdReductionSyms);
+ simdReductionObjects);
DataSharingProcessor distributeItemDSP(
converter, semaCtx, distributeItem->clauses, eval,
@@ -3614,16 +3642,17 @@ static mlir::omp::DistributeOp genCompositeDistributeSimd(
// Operation creation.
EntryBlockArgs distributeArgs;
- distributeArgs.priv.syms = distributeItemDSP.getDelayedPrivSymbols();
+ distributeArgs.priv.objects =
+ makeObjects(distributeItemDSP.getDelayedPrivSymbols());
distributeArgs.priv.vars = distributeClauseOps.privateVars;
auto distributeOp = genWrapperOp<mlir::omp::DistributeOp>(
converter, loc, distributeClauseOps, distributeArgs);
distributeOp.setComposite(/*val=*/true);
EntryBlockArgs simdArgs;
- simdArgs.priv.syms = simdItemDSP.getDelayedPrivSymbols();
+ simdArgs.priv.objects = makeObjects(simdItemDSP.getDelayedPrivSymbols());
simdArgs.priv.vars = simdClauseOps.privateVars;
- simdArgs.reduction.syms = simdReductionSyms;
+ simdArgs.reduction.objects = simdReductionObjects;
simdArgs.reduction.vars = simdClauseOps.reductionVars;
auto simdOp =
genWrapperOp<mlir::omp::SimdOp>(converter, loc, simdClauseOps, simdArgs);
@@ -3653,14 +3682,14 @@ static mlir::omp::WsloopOp genCompositeDoSimd(
llvm::DenseMap<const semantics::Symbol *, mlir::Value> reductionVarCache;
mlir::omp::WsloopOperands wsloopClauseOps;
- llvm::SmallVector<const semantics::Symbol *> wsloopReductionSyms;
+ llvm::SmallVector<Object> wsloopReductionObjects;
genWsloopClauses(converter, semaCtx, stmtCtx, doItem->clauses, loc,
- wsloopClauseOps, wsloopReductionSyms, &reductionVarCache);
+ wsloopClauseOps, wsloopReductionObjects, &reductionVarCache);
mlir::omp::SimdOperands simdClauseOps;
- llvm::SmallVector<const semantics::Symbol *> simdReductionSyms;
+ llvm::SmallVector<Object> simdReductionObjects;
genSimdClauses(converter, semaCtx, simdItem->clauses, loc, simdClauseOps,
- simdReductionSyms, &reductionVarCache);
+ simdReductionObjects, &reductionVarCache);
DataSharingProcessor wsloopItemDSP(
converter, semaCtx, doItem->clauses, eval,
@@ -3684,18 +3713,18 @@ static mlir::omp::WsloopOp genCompositeDoSimd(
// Operation creation.
EntryBlockArgs wsloopArgs;
- wsloopArgs.priv.syms = wsloopItemDSP.getDelayedPrivSymbols();
+ wsloopArgs.priv.objects = makeObjects(wsloopItemDSP.getDelayedPrivSymbols());
wsloopArgs.priv.vars = wsloopClauseOps.privateVars;
- wsloopArgs.reduction.syms = wsloopReductionSyms;
+ wsloopArgs.reduction.objects = wsloopReductionObjects;
wsloopArgs.reduction.vars = wsloopClauseOps.reductionVars;
auto wsloopOp = genWrapperOp<mlir::omp::WsloopOp>(
converter, loc, wsloopClauseOps, wsloopArgs);
wsloopOp.setComposite(/*val=*/true);
EntryBlockArgs simdArgs;
- simdArgs.priv.syms = simdItemDSP.getDelayedPrivSymbols();
+ simdArgs.priv.objects = makeObjects(simdItemDSP.getDelayedPrivSymbols());
simdArgs.priv.vars = simdClauseOps.privateVars;
- simdArgs.reduction.syms = simdReductionSyms;
+ simdArgs.reduction.objects = simdReductionObjects;
simdArgs.reduction.vars = simdClauseOps.reductionVars;
auto simdOp =
genWrapperOp<mlir::omp::SimdOp>(converter, loc, simdClauseOps, simdArgs);
diff --git a/flang/lib/Lower/OpenMP/Utils.cpp b/flang/lib/Lower/OpenMP/Utils.cpp
index d65663dbebc53..460fa857150c1 100644
--- a/flang/lib/Lower/OpenMP/Utils.cpp
+++ b/flang/lib/Lower/OpenMP/Utils.cpp
@@ -562,16 +562,16 @@ void insertChildMapInfoIntoParent(
lower::StatementContext &stmtCtx,
std::map<Object, OmpMapParentAndMemberData> &parentMemberIndices,
llvm::SmallVectorImpl<mlir::Value> &mapOperands,
- llvm::SmallVectorImpl<const semantics::Symbol *> &mapSyms) {
+ llvm::SmallVectorImpl<Object> &mapObjects) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
for (auto indices : parentMemberIndices) {
auto *parentIter =
- llvm::find_if(mapSyms, [&indices](const semantics::Symbol *v) {
- return v == indices.first.sym();
+ llvm::find_if(mapObjects, [&indices](const Object &object) {
+ return object.sym() == indices.first.sym();
});
- if (parentIter != mapSyms.end()) {
+ if (parentIter != mapObjects.end()) {
auto mapOp = llvm::cast<mlir::omp::MapInfoOp>(
- mapOperands[std::distance(mapSyms.begin(), parentIter)]
+ mapOperands[std::distance(mapObjects.begin(), parentIter)]
.getDefiningOp());
// Once explicit members are attached to a parent map, do not also invoke
@@ -631,7 +631,7 @@ void insertChildMapInfoIntoParent(
/*partialMap=*/true);
mapOperands.push_back(mapOp);
- mapSyms.push_back(indices.first.sym());
+ mapObjects.push_back(indices.first);
}
}
}
diff --git a/flang/lib/Lower/OpenMP/Utils.h b/flang/lib/Lower/OpenMP/Utils.h
index 587a078c33ed8..7022597a233ca 100644
--- a/flang/lib/Lower/OpenMP/Utils.h
+++ b/flang/lib/Lower/OpenMP/Utils.h
@@ -123,7 +123,7 @@ void insertChildMapInfoIntoParent(
Fortran::lower::StatementContext &stmtCtx,
std::map<Object, OmpMapParentAndMemberData> &parentMemberIndices,
llvm::SmallVectorImpl<mlir::Value> &mapOperands,
- llvm::SmallVectorImpl<const semantics::Symbol *> &mapSyms);
+ llvm::SmallVectorImpl<Object> &mapObjects);
void generateMemberPlacementIndices(
const Object &object, llvm::SmallVectorImpl<int64_t> &indices,
>From bda78ec06f2d18a6853d734525719e2869f34ab8 Mon Sep 17 00:00:00 2001
From: Jack Styles <jack.styles at arm.com>
Date: Fri, 15 May 2026 10:55:39 +0100
Subject: [PATCH 2/2] Respond to review comments
This replaces for loops with llvm::copy or llvm::transform where
appropriate
---
flang/include/flang/Support/OpenMP-utils.h | 10 ++++------
flang/lib/Lower/OpenMP/ClauseProcessor.cpp | 5 +++--
flang/lib/Lower/OpenMP/OpenMP.cpp | 7 ++++---
3 files changed, 11 insertions(+), 11 deletions(-)
diff --git a/flang/include/flang/Support/OpenMP-utils.h b/flang/include/flang/Support/OpenMP-utils.h
index 47d5ab2c023c0..d10659c913381 100644
--- a/flang/include/flang/Support/OpenMP-utils.h
+++ b/flang/include/flang/Support/OpenMP-utils.h
@@ -34,9 +34,8 @@ struct EntryBlockArgsEntry {
llvm::SmallVector<const Fortran::semantics::Symbol *> getSyms() const {
llvm::SmallVector<const Fortran::semantics::Symbol *> syms;
- for (const Fortran::lower::omp::Object &object : objects) {
- syms.push_back(object.sym());
- }
+ syms.reserve(objects.size());
+ llvm::transform(objects, std::back_inserter(syms), [](const Fortran::lower::omp::Object &object) { return object.sym(); });
return syms;
}
};
@@ -63,9 +62,8 @@ struct EntryBlockArgs {
llvm::SmallVector<const semantics::Symbol *> getSyms() const {
llvm::SmallVector<const semantics::Symbol *> syms;
auto appendSyms = [&syms](const EntryBlockArgsEntry &entry) {
- for (const Fortran::lower::omp::Object &object : entry.objects) {
- syms.push_back(object.sym());
- }
+ syms.reserve(syms.size() + entry.objects.size());
+ llvm::transform(entry.objects, std::back_inserter(syms), [](const Fortran::lower::omp::Object &object) { return object.sym(); });
};
appendSyms(hasDeviceAddr);
appendSyms(inReduction);
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
index 6bbabf7e38cdb..e463cf9b54f51 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
@@ -1544,14 +1544,15 @@ template <typename T>
void collectReductionObjects(const T &reduction,
llvm::SmallVectorImpl<Object> &reductionObjects) {
const omp::ObjectList &objectList{std::get<omp::ObjectList>(reduction.t)};
+ reductionObjects.reserve(objectList.size());
llvm::copy(objectList, std::back_inserter(reductionObjects));
}
static llvm::SmallVector<const semantics::Symbol *>
getObjectsSyms(llvm::ArrayRef<Object> objects) {
llvm::SmallVector<const semantics::Symbol *> syms;
- for (const Object &object : objects)
- syms.push_back(object.sym());
+ syms.reserve(objects.size());
+ llvm::transform(objects, std::back_inserter(syms), [](const Fortran::lower::omp::Object &object) { return object.sym(); });
return syms;
}
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index f849eb73ba1e6..60095bff02986 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -77,9 +77,10 @@ static void processHostEvalClauses(lower::AbstractConverter &converter,
static llvm::SmallVector<Object>
makeObjects(llvm::ArrayRef<const semantics::Symbol *> syms) {
llvm::SmallVector<Object> objects;
- for (const semantics::Symbol *sym : syms)
- objects.push_back(
- Object{const_cast<semantics::Symbol *>(sym), std::nullopt});
+ objects.reserve(syms.size());
+ llvm::transform(syms, std::back_inserter(objects), [](const semantics::Symbol *sym) {
+ return Object{const_cast<semantics::Symbol *>(sym), std::nullopt};
+ });
return objects;
}
More information about the flang-commits
mailing list