[flang-commits] [flang] 4525f44 - [flang][OpenMP] Don't pass clauses to op-generating functions anymore (#90108)
via flang-commits
flang-commits at lists.llvm.org
Wed May 15 10:01:20 PDT 2024
Author: Krzysztof Parzyszek
Date: 2024-05-15T12:01:16-05:00
New Revision: 4525f442fadb7cc44cc2eaede2c8ac6ba15bdf78
URL: https://github.com/llvm/llvm-project/commit/4525f442fadb7cc44cc2eaede2c8ac6ba15bdf78
DIFF: https://github.com/llvm/llvm-project/commit/4525f442fadb7cc44cc2eaede2c8ac6ba15bdf78.diff
LOG: [flang][OpenMP] Don't pass clauses to op-generating functions anymore (#90108)
Remove parameter `const List<Clause> &clauses` from functions that take
construct queue. The clauses should now be accessed from the construct
queue.
Added:
Modified:
flang/lib/Lower/OpenMP/OpenMP.cpp
Removed:
################################################################################
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index f21acdd64d7c3..f05cf1f5120f8 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -1233,8 +1233,7 @@ genCriticalOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item,
+ const ConstructQueue &queue, ConstructQueue::iterator item,
const std::optional<Fortran::parser::Name> &name) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
mlir::FlatSymbolRefAttr nameAttr;
@@ -1245,8 +1244,8 @@ genCriticalOp(Fortran::lower::AbstractConverter &converter,
auto global = mod.lookupSymbol<mlir::omp::CriticalDeclareOp>(nameStr);
if (!global) {
mlir::omp::CriticalClauseOps clauseOps;
- genCriticalDeclareClauses(converter, semaCtx, clauses, loc, clauseOps,
- nameStr);
+ genCriticalDeclareClauses(converter, semaCtx, item->clauses, loc,
+ clauseOps, nameStr);
mlir::OpBuilder modBuilder(mod.getBodyRegion());
global = modBuilder.create<mlir::omp::CriticalDeclareOp>(loc, clauseOps);
@@ -1266,8 +1265,7 @@ genDistributeOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
TODO(loc, "Distribute construct");
return nullptr;
}
@@ -1277,10 +1275,11 @@ genFlushOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const ObjectList &objects, const List<Clause> &clauses,
- const ConstructQueue &queue, ConstructQueue::iterator item) {
+ const ObjectList &objects, const ConstructQueue &queue,
+ ConstructQueue::iterator item) {
llvm::SmallVector<mlir::Value> operandRange;
- genFlushClauses(converter, semaCtx, objects, clauses, loc, operandRange);
+ genFlushClauses(converter, semaCtx, objects, item->clauses, loc,
+ operandRange);
return converter.getFirOpBuilder().create<mlir::omp::FlushOp>(
converter.getCurrentLocation(), operandRange);
@@ -1291,8 +1290,7 @@ genMasterOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
return genOpWithBody<mlir::omp::MasterOp>(
OpWithBodyGenInfo(converter, symTable, semaCtx, loc, eval,
llvm::omp::Directive::OMPD_master),
@@ -1304,8 +1302,7 @@ genOrderedOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
TODO(loc, "OMPD_ordered");
return nullptr;
}
@@ -1315,10 +1312,9 @@ genOrderedRegionOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
mlir::omp::OrderedRegionClauseOps clauseOps;
- genOrderedRegionClauses(converter, semaCtx, clauses, loc, clauseOps);
+ genOrderedRegionClauses(converter, semaCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::OrderedRegionOp>(
OpWithBodyGenInfo(converter, symTable, semaCtx, loc, eval,
@@ -1331,15 +1327,15 @@ genParallelOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item, bool outerCombined = false) {
+ const ConstructQueue &queue, ConstructQueue::iterator item,
+ bool outerCombined = false) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
Fortran::lower::StatementContext stmtCtx;
mlir::omp::ParallelClauseOps clauseOps;
llvm::SmallVector<const Fortran::semantics::Symbol *> privateSyms;
llvm::SmallVector<mlir::Type> reductionTypes;
llvm::SmallVector<const Fortran::semantics::Symbol *> reductionSyms;
- genParallelClauses(converter, semaCtx, stmtCtx, clauses, loc,
+ genParallelClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
/*processReduction=*/!outerCombined, clauseOps,
reductionTypes, reductionSyms);
@@ -1352,7 +1348,7 @@ genParallelOp(Fortran::lower::AbstractConverter &converter,
OpWithBodyGenInfo(converter, symTable, semaCtx, loc, eval,
llvm::omp::Directive::OMPD_parallel)
.setOuterCombined(outerCombined)
- .setClauses(&clauses)
+ .setClauses(&item->clauses)
.setReductions(&reductionSyms, &reductionTypes)
.setGenRegionEntryCb(reductionCallback);
@@ -1361,7 +1357,7 @@ genParallelOp(Fortran::lower::AbstractConverter &converter,
clauseOps);
bool privatize = !outerCombined;
- DataSharingProcessor dsp(converter, semaCtx, clauses, eval,
+ DataSharingProcessor dsp(converter, semaCtx, item->clauses, eval,
/*useDelayedPrivatization=*/true, &symTable);
if (privatize)
@@ -1414,14 +1410,13 @@ genSectionOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
// Currently only private/firstprivate clause is handled, and
// all privatization is done within `omp.section` operations.
return genOpWithBody<mlir::omp::SectionOp>(
OpWithBodyGenInfo(converter, symTable, semaCtx, loc, eval,
llvm::omp::Directive::OMPD_section)
- .setClauses(&clauses),
+ .setClauses(&item->clauses),
queue, item);
}
@@ -1430,22 +1425,21 @@ genSectionsOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
mlir::omp::SectionsClauseOps clauseOps;
- genSectionsClauses(converter, semaCtx, clauses, loc, clauseOps);
+ genSectionsClauses(converter, semaCtx, item->clauses, loc, clauseOps);
auto &builder = converter.getFirOpBuilder();
// Insert privatizations before SECTIONS
symTable.pushScope();
- DataSharingProcessor dsp(converter, semaCtx, clauses, eval);
+ DataSharingProcessor dsp(converter, semaCtx, item->clauses, eval);
dsp.processStep1();
List<Clause> nonDsaClauses;
List<const clause::Lastprivate *> lastprivates;
- for (const Clause &clause : clauses) {
+ for (const Clause &clause : item->clauses) {
if (clause.id == llvm::omp::Clause::OMPC_lastprivate) {
lastprivates.push_back(&std::get<clause::Lastprivate>(clause.u));
} else {
@@ -1508,18 +1502,18 @@ genSimdOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
- DataSharingProcessor dsp(converter, semaCtx, clauses, eval);
+ DataSharingProcessor dsp(converter, semaCtx, item->clauses, eval);
dsp.processStep1();
Fortran::lower::StatementContext stmtCtx;
mlir::omp::LoopNestClauseOps loopClauseOps;
mlir::omp::SimdClauseOps simdClauseOps;
llvm::SmallVector<const Fortran::semantics::Symbol *> iv;
- genLoopNestClauses(converter, semaCtx, eval, clauses, loc, loopClauseOps, iv);
- genSimdClauses(converter, semaCtx, clauses, loc, simdClauseOps);
+ genLoopNestClauses(converter, semaCtx, eval, item->clauses, loc,
+ loopClauseOps, iv);
+ genSimdClauses(converter, semaCtx, item->clauses, loc, simdClauseOps);
// Create omp.simd wrapper.
auto simdOp = firOpBuilder.create<mlir::omp::SimdOp>(loc, simdClauseOps);
@@ -1532,7 +1526,8 @@ genSimdOp(Fortran::lower::AbstractConverter &converter,
// Create nested omp.loop_nest and fill body with loop contents.
auto loopOp = firOpBuilder.create<mlir::omp::LoopNestOp>(loc, loopClauseOps);
- auto *nestedEval = getCollapsedLoopEval(eval, getCollapseValue(clauses));
+ auto *nestedEval =
+ getCollapsedLoopEval(eval, getCollapseValue(item->clauses));
auto ivCallback = [&](mlir::Operation *op) {
genLoopVars(op, converter, loc, iv);
@@ -1542,7 +1537,7 @@ genSimdOp(Fortran::lower::AbstractConverter &converter,
createBodyOfOp(*loopOp,
OpWithBodyGenInfo(converter, symTable, semaCtx, loc,
*nestedEval, llvm::omp::Directive::OMPD_simd)
- .setClauses(&clauses)
+ .setClauses(&item->clauses)
.setDataSharingProcessor(&dsp)
.setGenRegionEntryCb(ivCallback),
queue, item);
@@ -1555,15 +1550,14 @@ genSingleOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
mlir::omp::SingleClauseOps clauseOps;
- genSingleClauses(converter, semaCtx, clauses, loc, clauseOps);
+ genSingleClauses(converter, semaCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::SingleOp>(
OpWithBodyGenInfo(converter, symTable, semaCtx, loc, eval,
llvm::omp::Directive::OMPD_single)
- .setClauses(&clauses),
+ .setClauses(&item->clauses),
queue, item, clauseOps);
}
@@ -1572,8 +1566,8 @@ genTargetOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item, bool outerCombined = false) {
+ const ConstructQueue &queue, ConstructQueue::iterator item,
+ bool outerCombined = false) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
Fortran::lower::StatementContext stmtCtx;
@@ -1586,7 +1580,7 @@ genTargetOp(Fortran::lower::AbstractConverter &converter,
deviceAddrSyms;
llvm::SmallVector<mlir::Location> mapLocs, devicePtrLocs, deviceAddrLocs;
llvm::SmallVector<mlir::Type> mapTypes, devicePtrTypes, deviceAddrTypes;
- genTargetClauses(converter, semaCtx, stmtCtx, clauses, loc,
+ genTargetClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
processHostOnlyClauses, /*processReduction=*/outerCombined,
clauseOps, mapSyms, mapLocs, mapTypes, deviceAddrSyms,
deviceAddrLocs, deviceAddrTypes, devicePtrSyms,
@@ -1690,15 +1684,14 @@ genTargetDataOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
Fortran::lower::StatementContext stmtCtx;
mlir::omp::TargetDataClauseOps clauseOps;
llvm::SmallVector<mlir::Type> useDeviceTypes;
llvm::SmallVector<mlir::Location> useDeviceLocs;
llvm::SmallVector<const Fortran::semantics::Symbol *> useDeviceSyms;
- genTargetDataClauses(converter, semaCtx, stmtCtx, clauses, loc, clauseOps,
- useDeviceTypes, useDeviceLocs, useDeviceSyms);
+ genTargetDataClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
+ clauseOps, useDeviceTypes, useDeviceLocs, useDeviceSyms);
auto targetDataOp =
converter.getFirOpBuilder().create<mlir::omp::TargetDataOp>(loc,
@@ -1714,8 +1707,7 @@ static OpTy
genTargetEnterExitUpdateDataOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
- mlir::Location loc, const List<Clause> &clauses,
- const ConstructQueue &queue,
+ mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::iterator item) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
Fortran::lower::StatementContext stmtCtx;
@@ -1733,8 +1725,8 @@ genTargetEnterExitUpdateDataOp(Fortran::lower::AbstractConverter &converter,
}
mlir::omp::TargetEnterExitUpdateDataClauseOps clauseOps;
- genTargetEnterExitUpdateDataClauses(converter, semaCtx, stmtCtx, clauses, loc,
- directive, clauseOps);
+ genTargetEnterExitUpdateDataClauses(converter, semaCtx, stmtCtx,
+ item->clauses, loc, directive, clauseOps);
return firOpBuilder.create<OpTy>(loc, clauseOps);
}
@@ -1744,16 +1736,15 @@ genTaskOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
Fortran::lower::StatementContext stmtCtx;
mlir::omp::TaskClauseOps clauseOps;
- genTaskClauses(converter, semaCtx, stmtCtx, clauses, loc, clauseOps);
+ genTaskClauses(converter, semaCtx, stmtCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::TaskOp>(
OpWithBodyGenInfo(converter, symTable, semaCtx, loc, eval,
llvm::omp::Directive::OMPD_task)
- .setClauses(&clauses),
+ .setClauses(&item->clauses),
queue, item, clauseOps);
}
@@ -1762,15 +1753,14 @@ genTaskgroupOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
mlir::omp::TaskgroupClauseOps clauseOps;
- genTaskgroupClauses(converter, semaCtx, clauses, loc, clauseOps);
+ genTaskgroupClauses(converter, semaCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::TaskgroupOp>(
OpWithBodyGenInfo(converter, symTable, semaCtx, loc, eval,
llvm::omp::Directive::OMPD_taskgroup)
- .setClauses(&clauses),
+ .setClauses(&item->clauses),
queue, item, clauseOps);
}
@@ -1779,8 +1769,7 @@ genTaskloopOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
TODO(loc, "Taskloop construct");
}
@@ -1789,10 +1778,9 @@ genTaskwaitOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
mlir::omp::TaskwaitClauseOps clauseOps;
- genTaskwaitClauses(converter, semaCtx, clauses, loc, clauseOps);
+ genTaskwaitClauses(converter, semaCtx, item->clauses, loc, clauseOps);
return converter.getFirOpBuilder().create<mlir::omp::TaskwaitOp>(loc,
clauseOps);
}
@@ -1811,17 +1799,17 @@ genTeamsOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item, bool outerCombined = false) {
+ const ConstructQueue &queue, ConstructQueue::iterator item,
+ bool outerCombined = false) {
Fortran::lower::StatementContext stmtCtx;
mlir::omp::TeamsClauseOps clauseOps;
- genTeamsClauses(converter, semaCtx, stmtCtx, clauses, loc, clauseOps);
+ genTeamsClauses(converter, semaCtx, stmtCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::TeamsOp>(
OpWithBodyGenInfo(converter, symTable, semaCtx, loc, eval,
llvm::omp::Directive::OMPD_teams)
.setOuterCombined(outerCombined)
- .setClauses(&clauses),
+ .setClauses(&item->clauses),
queue, item, clauseOps);
}
@@ -1830,10 +1818,9 @@ genWsloopOp(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
- DataSharingProcessor dsp(converter, semaCtx, clauses, eval);
+ DataSharingProcessor dsp(converter, semaCtx, item->clauses, eval);
dsp.processStep1();
Fortran::lower::StatementContext stmtCtx;
@@ -1842,8 +1829,9 @@ genWsloopOp(Fortran::lower::AbstractConverter &converter,
llvm::SmallVector<const Fortran::semantics::Symbol *> iv;
llvm::SmallVector<mlir::Type> reductionTypes;
llvm::SmallVector<const Fortran::semantics::Symbol *> reductionSyms;
- genLoopNestClauses(converter, semaCtx, eval, clauses, loc, loopClauseOps, iv);
- genWsloopClauses(converter, semaCtx, stmtCtx, clauses, loc, wsClauseOps,
+ genLoopNestClauses(converter, semaCtx, eval, item->clauses, loc,
+ loopClauseOps, iv);
+ genWsloopClauses(converter, semaCtx, stmtCtx, item->clauses, loc, wsClauseOps,
reductionTypes, reductionSyms);
// Create omp.wsloop wrapper and populate entry block arguments with reduction
@@ -1858,7 +1846,8 @@ genWsloopOp(Fortran::lower::AbstractConverter &converter,
// Create nested omp.loop_nest and fill body with loop contents.
auto loopOp = firOpBuilder.create<mlir::omp::LoopNestOp>(loc, loopClauseOps);
- auto *nestedEval = getCollapsedLoopEval(eval, getCollapseValue(clauses));
+ auto *nestedEval =
+ getCollapsedLoopEval(eval, getCollapseValue(item->clauses));
auto ivCallback = [&](mlir::Operation *op) {
genLoopVars(op, converter, loc, iv, reductionSyms,
@@ -1869,7 +1858,7 @@ genWsloopOp(Fortran::lower::AbstractConverter &converter,
createBodyOfOp(*loopOp,
OpWithBodyGenInfo(converter, symTable, semaCtx, loc,
*nestedEval, llvm::omp::Directive::OMPD_do)
- .setClauses(&clauses)
+ .setClauses(&item->clauses)
.setDataSharingProcessor(&dsp)
.setReductions(&reductionSyms, &reductionTypes)
.setGenRegionEntryCb(ivCallback),
@@ -1886,8 +1875,7 @@ static void genCompositeDistributeParallelDo(
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
TODO(loc, "Composite DISTRIBUTE PARALLEL DO");
}
@@ -1896,8 +1884,7 @@ static void genCompositeDistributeParallelDoSimd(
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval, mlir::Location loc,
- const List<Clause> &clauses, const ConstructQueue &queue,
- ConstructQueue::iterator item) {
+ const ConstructQueue &queue, ConstructQueue::iterator item) {
TODO(loc, "Composite DISTRIBUTE PARALLEL DO SIMD");
}
@@ -1906,8 +1893,7 @@ genCompositeDistributeSimd(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval,
- mlir::Location loc, const List<Clause> &clauses,
- const ConstructQueue &queue,
+ mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::iterator item) {
TODO(loc, "Composite DISTRIBUTE SIMD");
}
@@ -1916,10 +1902,9 @@ static void genCompositeDoSimd(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval,
- mlir::Location loc, const List<Clause> &clauses,
- const ConstructQueue &queue,
+ mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::iterator item) {
- ClauseProcessor cp(converter, semaCtx, clauses);
+ ClauseProcessor cp(converter, semaCtx, item->clauses);
cp.processTODO<clause::Aligned, clause::Allocate, clause::Linear,
clause::Order, clause::Safelen, clause::Simdlen>(
loc, llvm::omp::OMPD_do_simd);
@@ -1931,7 +1916,7 @@ static void genCompositeDoSimd(Fortran::lower::AbstractConverter &converter,
// When support for vectorization is enabled, then we need to add handling of
// if clause. Currently if clause can be skipped because we always assume
// SIMD length = 1.
- genWsloopOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item);
+ genWsloopOp(converter, symTable, semaCtx, eval, loc, queue, item);
}
static void
@@ -1939,8 +1924,7 @@ genCompositeTaskloopSimd(Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symTable,
Fortran::semantics::SemanticsContext &semaCtx,
Fortran::lower::pft::Evaluation &eval,
- mlir::Location loc, const List<Clause> &clauses,
- const ConstructQueue &queue,
+ mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::iterator item) {
TODO(loc, "Composite TASKLOOP SIMD");
}
@@ -1956,18 +1940,16 @@ static void genOMPDispatch(Fortran::lower::AbstractConverter &converter,
mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::iterator item) {
assert(item != queue.end());
- const List<Clause> &clauses = item->clauses;
switch (llvm::omp::Directive dir = item->id) {
case llvm::omp::Directive::OMPD_barrier:
genBarrierOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_distribute:
- genDistributeOp(converter, symTable, semaCtx, eval, loc, clauses, queue,
- item);
+ genDistributeOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_do:
- genWsloopOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item);
+ genWsloopOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_loop:
case llvm::omp::Directive::OMPD_masked:
@@ -1975,71 +1957,64 @@ static void genOMPDispatch(Fortran::lower::AbstractConverter &converter,
llvm::omp::getOpenMPDirectiveName(dir) + ")");
break;
case llvm::omp::Directive::OMPD_master:
- genMasterOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item);
+ genMasterOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_ordered:
// Block-associated "ordered" construct.
- genOrderedRegionOp(converter, symTable, semaCtx, eval, loc, clauses, queue,
- item);
+ genOrderedRegionOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_parallel:
- genParallelOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item,
+ genParallelOp(converter, symTable, semaCtx, eval, loc, queue, item,
/*outerCombined=*/false);
break;
case llvm::omp::Directive::OMPD_section:
- genSectionOp(converter, symTable, semaCtx, eval, loc, /*clauses=*/{}, queue,
- item);
+ genSectionOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_sections:
- genSectionsOp(converter, symTable, semaCtx, eval, loc, clauses, queue,
- item);
+ genSectionsOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_simd:
- genSimdOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item);
+ genSimdOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_single:
- genSingleOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item);
+ genSingleOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_target:
- genTargetOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item,
+ genTargetOp(converter, symTable, semaCtx, eval, loc, queue, item,
/*outerCombined=*/false);
break;
case llvm::omp::Directive::OMPD_target_data:
- genTargetDataOp(converter, symTable, semaCtx, eval, loc, clauses, queue,
- item);
+ genTargetDataOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_target_enter_data:
genTargetEnterExitUpdateDataOp<mlir::omp::TargetEnterDataOp>(
- converter, symTable, semaCtx, loc, clauses, queue, item);
+ converter, symTable, semaCtx, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_target_exit_data:
genTargetEnterExitUpdateDataOp<mlir::omp::TargetExitDataOp>(
- converter, symTable, semaCtx, loc, clauses, queue, item);
+ converter, symTable, semaCtx, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_target_update:
genTargetEnterExitUpdateDataOp<mlir::omp::TargetUpdateOp>(
- converter, symTable, semaCtx, loc, clauses, queue, item);
+ converter, symTable, semaCtx, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_task:
- genTaskOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item);
+ genTaskOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_taskgroup:
- genTaskgroupOp(converter, symTable, semaCtx, eval, loc, clauses, queue,
- item);
+ genTaskgroupOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_taskloop:
- genTaskloopOp(converter, symTable, semaCtx, eval, loc, clauses, queue,
- item);
+ genTaskloopOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_taskwait:
- genTaskwaitOp(converter, symTable, semaCtx, eval, loc, clauses, queue,
- item);
+ genTaskwaitOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_taskyield:
genTaskyieldOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_teams:
- genTeamsOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item);
+ genTeamsOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_tile:
case llvm::omp::Directive::OMPD_unroll:
@@ -2050,29 +2025,28 @@ static void genOMPDispatch(Fortran::lower::AbstractConverter &converter,
// FIXME: Workshare is not a commonly used OpenMP construct, an
// implementation for this feature will come later. For the codes
// that use this construct, add a single construct for now.
- genSingleOp(converter, symTable, semaCtx, eval, loc, clauses, queue, item);
+ genSingleOp(converter, symTable, semaCtx, eval, loc, queue, item);
break;
// Composite constructs
case llvm::omp::Directive::OMPD_distribute_parallel_do:
genCompositeDistributeParallelDo(converter, symTable, semaCtx, eval, loc,
- clauses, queue, item);
+ queue, item);
break;
case llvm::omp::Directive::OMPD_distribute_parallel_do_simd:
genCompositeDistributeParallelDoSimd(converter, symTable, semaCtx, eval,
- loc, clauses, queue, item);
+ loc, queue, item);
break;
case llvm::omp::Directive::OMPD_distribute_simd:
- genCompositeDistributeSimd(converter, symTable, semaCtx, eval, loc, clauses,
- queue, item);
+ genCompositeDistributeSimd(converter, symTable, semaCtx, eval, loc, queue,
+ item);
break;
case llvm::omp::Directive::OMPD_do_simd:
- genCompositeDoSimd(converter, symTable, semaCtx, eval, loc, clauses, queue,
- item);
+ genCompositeDoSimd(converter, symTable, semaCtx, eval, loc, queue, item);
break;
case llvm::omp::Directive::OMPD_taskloop_simd:
- genCompositeTaskloopSimd(converter, symTable, semaCtx, eval, loc, clauses,
- queue, item);
+ genCompositeTaskloopSimd(converter, symTable, semaCtx, eval, loc, queue,
+ item);
break;
default:
break;
@@ -2194,8 +2168,8 @@ static void genOMP(Fortran::lower::AbstractConverter &converter,
eval, directive.source, directive.v, clauses)};
if (directive.v == llvm::omp::Directive::OMPD_ordered) {
// Standalone "ordered" directive.
- genOrderedOp(converter, symTable, semaCtx, eval, currentLocation, clauses,
- queue, queue.begin());
+ genOrderedOp(converter, symTable, semaCtx, eval, currentLocation, queue,
+ queue.begin());
} else {
// Dispatch handles the "block-associated" variant of "ordered".
genOMPDispatch(converter, symTable, semaCtx, eval, currentLocation, queue,
@@ -2227,7 +2201,7 @@ genOMP(Fortran::lower::AbstractConverter &converter,
converter.getFirOpBuilder().getModule(), semaCtx, eval, verbatim.source,
llvm::omp::Directive::OMPD_flush, clauses)};
genFlushOp(converter, symTable, semaCtx, eval, currentLocation, objects,
- clauses, queue, queue.begin());
+ queue, queue.begin());
}
static void
@@ -2399,8 +2373,8 @@ genOMP(Fortran::lower::AbstractConverter &converter,
const auto &name = std::get<std::optional<Fortran::parser::Name>>(cd.t);
mlir::Location currentLocation = converter.getCurrentLocation();
- genCriticalOp(converter, symTable, semaCtx, eval, currentLocation, clauses,
- queue, queue.begin(), name);
+ genCriticalOp(converter, symTable, semaCtx, eval, currentLocation, queue,
+ queue.begin(), name);
}
static void
More information about the flang-commits
mailing list