llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-flang-fir-hlfir Author: Krzysztof Parzyszek (kparzysz) <details> <summary>Changes</summary> This will remove the distinction between begin clauses and end clauses, and process all of them together. --- Patch is 23.92 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/89090.diff 1 Files Affected: - (modified) flang/lib/Lower/OpenMP/OpenMP.cpp (+99-123) ``````````diff diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp index 4424788e0132e2..304bef72534805 100644 --- a/flang/lib/Lower/OpenMP/OpenMP.cpp +++ b/flang/lib/Lower/OpenMP/OpenMP.cpp @@ -1121,16 +1121,14 @@ static void genSimdClauses(Fortran::lower::AbstractConverter &converter, static void genSingleClauses(Fortran::lower::AbstractConverter &converter, Fortran::semantics::SemanticsContext &semaCtx, - const List<Clause> &beginClauses, - const List<Clause> &endClauses, mlir::Location loc, + const List<Clause> &clauses, mlir::Location loc, mlir::omp::SingleClauseOps &clauseOps) { - ClauseProcessor bcp(converter, semaCtx, beginClauses); - bcp.processAllocate(clauseOps); + ClauseProcessor cp(converter, semaCtx, clauses); + cp.processAllocate(clauseOps); // TODO Support delayed privatization. - ClauseProcessor ecp(converter, semaCtx, endClauses); - ecp.processCopyprivate(loc, clauseOps); - ecp.processNowait(clauseOps); + cp.processCopyprivate(loc, clauseOps); + cp.processNowait(clauseOps); } static void genTargetClauses( @@ -1280,30 +1278,26 @@ static void genWsloopClauses( Fortran::lower::AbstractConverter &converter, Fortran::semantics::SemanticsContext &semaCtx, Fortran::lower::StatementContext &stmtCtx, - Fortran::lower::pft::Evaluation &eval, const List<Clause> &beginClauses, - const List<Clause> &endClauses, mlir::Location loc, - mlir::omp::WsloopClauseOps &clauseOps, + Fortran::lower::pft::Evaluation &eval, const List<Clause> &clauses, + mlir::Location loc, mlir::omp::WsloopClauseOps &clauseOps, llvm::SmallVectorImpl<const Fortran::semantics::Symbol *> &iv, llvm::SmallVectorImpl<mlir::Type> &reductionTypes, llvm::SmallVectorImpl<const Fortran::semantics::Symbol *> &reductionSyms) { fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder(); - ClauseProcessor bcp(converter, semaCtx, beginClauses); - bcp.processCollapse(loc, eval, clauseOps, iv); - bcp.processOrdered(clauseOps); - bcp.processReduction(loc, clauseOps, &reductionTypes, &reductionSyms); - bcp.processSchedule(stmtCtx, clauseOps); + ClauseProcessor cp(converter, semaCtx, clauses); + cp.processCollapse(loc, eval, clauseOps, iv); + cp.processOrdered(clauseOps); + cp.processReduction(loc, clauseOps, &reductionTypes, &reductionSyms); + cp.processSchedule(stmtCtx, clauseOps); clauseOps.loopInclusiveAttr = firOpBuilder.getUnitAttr(); // TODO Support delayed privatization. if (ReductionProcessor::doReductionByRef(clauseOps.reductionVars)) clauseOps.reductionByRefAttr = firOpBuilder.getUnitAttr(); - if (!endClauses.empty()) { - ClauseProcessor ecp(converter, semaCtx, endClauses); - ecp.processNowait(clauseOps); - } + cp.processNowait(clauseOps); - bcp.processTODO<clause::Allocate, clause::Linear, clause::Order>( + cp.processTODO<clause::Allocate, clause::Linear, clause::Order>( loc, llvm::omp::Directive::OMPD_do); } @@ -1557,17 +1551,15 @@ static mlir::omp::SingleOp genSingleOp(Fortran::lower::AbstractConverter &converter, Fortran::semantics::SemanticsContext &semaCtx, Fortran::lower::pft::Evaluation &eval, bool genNested, - mlir::Location loc, const List<Clause> &beginClauses, - const List<Clause> &endClauses) { + mlir::Location loc, const List<Clause> &clauses) { mlir::omp::SingleClauseOps clauseOps; - genSingleClauses(converter, semaCtx, beginClauses, endClauses, loc, - clauseOps); + genSingleClauses(converter, semaCtx, clauses, loc, clauseOps); return genOpWithBody<mlir::omp::SingleOp>( OpWithBodyGenInfo(converter, semaCtx, loc, eval, llvm::omp::Directive::OMPD_single) .setGenNested(genNested) - .setClauses(&beginClauses), + .setClauses(&clauses), clauseOps); } @@ -1816,8 +1808,8 @@ static mlir::omp::WsloopOp genWsloopOp(Fortran::lower::AbstractConverter &converter, Fortran::semantics::SemanticsContext &semaCtx, Fortran::lower::pft::Evaluation &eval, mlir::Location loc, - const List<Clause> &beginClauses, const List<Clause> &endClauses) { - DataSharingProcessor dsp(converter, semaCtx, beginClauses, eval); + const List<Clause> &clauses) { + DataSharingProcessor dsp(converter, semaCtx, clauses, eval); dsp.processStep1(); Fortran::lower::StatementContext stmtCtx; @@ -1825,10 +1817,10 @@ genWsloopOp(Fortran::lower::AbstractConverter &converter, llvm::SmallVector<const Fortran::semantics::Symbol *> iv; llvm::SmallVector<mlir::Type> reductionTypes; llvm::SmallVector<const Fortran::semantics::Symbol *> reductionSyms; - genWsloopClauses(converter, semaCtx, stmtCtx, eval, beginClauses, endClauses, - loc, clauseOps, iv, reductionTypes, reductionSyms); + genWsloopClauses(converter, semaCtx, stmtCtx, eval, clauses, loc, clauseOps, + iv, reductionTypes, reductionSyms); - auto *nestedEval = getCollapsedLoopEval(eval, getCollapseValue(beginClauses)); + auto *nestedEval = getCollapsedLoopEval(eval, getCollapseValue(clauses)); auto ivCallback = [&](mlir::Operation *op) { return genLoopAndReductionVars(op, converter, loc, iv, reductionSyms, @@ -1838,7 +1830,7 @@ genWsloopOp(Fortran::lower::AbstractConverter &converter, return genOpWithBody<mlir::omp::WsloopOp>( OpWithBodyGenInfo(converter, semaCtx, loc, *nestedEval, llvm::omp::Directive::OMPD_do) - .setClauses(&beginClauses) + .setClauses(&clauses) .setDataSharingProcessor(&dsp) .setReductions(&reductionSyms, &reductionTypes) .setGenRegionEntryCb(ivCallback), @@ -1852,16 +1844,16 @@ genWsloopOp(Fortran::lower::AbstractConverter &converter, static void genCompositeDistributeParallelDo( Fortran::lower::AbstractConverter &converter, Fortran::semantics::SemanticsContext &semaCtx, - Fortran::lower::pft::Evaluation &eval, const List<Clause> &beginClauses, - const List<Clause> &endClauses, mlir::Location loc) { + Fortran::lower::pft::Evaluation &eval, const List<Clause> &clauses, + mlir::Location loc) { TODO(loc, "Composite DISTRIBUTE PARALLEL DO"); } static void genCompositeDistributeParallelDoSimd( Fortran::lower::AbstractConverter &converter, Fortran::semantics::SemanticsContext &semaCtx, - Fortran::lower::pft::Evaluation &eval, const List<Clause> &beginClauses, - const List<Clause> &endClauses, mlir::Location loc) { + Fortran::lower::pft::Evaluation &eval, const List<Clause> &clauses, + mlir::Location loc) { TODO(loc, "Composite DISTRIBUTE PARALLEL DO SIMD"); } @@ -1869,18 +1861,16 @@ static void genCompositeDistributeSimd(Fortran::lower::AbstractConverter &converter, Fortran::semantics::SemanticsContext &semaCtx, Fortran::lower::pft::Evaluation &eval, - const List<Clause> &beginClauses, - const List<Clause> &endClauses, mlir::Location loc) { + const List<Clause> &clauses, mlir::Location loc) { TODO(loc, "Composite DISTRIBUTE SIMD"); } static void genCompositeDoSimd(Fortran::lower::AbstractConverter &converter, Fortran::semantics::SemanticsContext &semaCtx, Fortran::lower::pft::Evaluation &eval, - const List<Clause> &beginClauses, - const List<Clause> &endClauses, + const List<Clause> &clauses, mlir::Location loc) { - ClauseProcessor cp(converter, semaCtx, beginClauses); + ClauseProcessor cp(converter, semaCtx, clauses); cp.processTODO<clause::Aligned, clause::Allocate, clause::Linear, clause::Order, clause::Safelen, clause::Simdlen>( loc, llvm::omp::OMPD_do_simd); @@ -1892,15 +1882,14 @@ 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, semaCtx, eval, loc, beginClauses, endClauses); + genWsloopOp(converter, semaCtx, eval, loc, clauses); } static void genCompositeTaskloopSimd(Fortran::lower::AbstractConverter &converter, Fortran::semantics::SemanticsContext &semaCtx, Fortran::lower::pft::Evaluation &eval, - const List<Clause> &beginClauses, - const List<Clause> &endClauses, mlir::Location loc) { + const List<Clause> &clauses, mlir::Location loc) { TODO(loc, "Composite TASKLOOP SIMD"); } @@ -2172,49 +2161,44 @@ genOMP(Fortran::lower::AbstractConverter &converter, converter.genLocation(beginBlockDirective.source); const auto origDirective = std::get<Fortran::parser::OmpBlockDirective>(beginBlockDirective.t).v; - List<Clause> beginClauses = makeClauses( + List<Clause> clauses = makeClauses( std::get<Fortran::parser::OmpClauseList>(beginBlockDirective.t), semaCtx); - List<Clause> endClauses = makeClauses( - std::get<Fortran::parser::OmpClauseList>(endBlockDirective.t), semaCtx); + clauses.append(makeClauses( + std::get<Fortran::parser::OmpClauseList>(endBlockDirective.t), semaCtx)); assert(llvm::omp::blockConstructSet.test(origDirective) && "Expected block construct"); - for (const Clause &clause : beginClauses) { + for (const Clause &clause : clauses) { mlir::Location clauseLocation = converter.genLocation(clause.source); - if (!std::get_if<clause::If>(&clause.u) && - !std::get_if<clause::NumThreads>(&clause.u) && - !std::get_if<clause::ProcBind>(&clause.u) && - !std::get_if<clause::Allocate>(&clause.u) && - !std::get_if<clause::Default>(&clause.u) && - !std::get_if<clause::Final>(&clause.u) && - !std::get_if<clause::Priority>(&clause.u) && - !std::get_if<clause::Reduction>(&clause.u) && - !std::get_if<clause::Depend>(&clause.u) && - !std::get_if<clause::Private>(&clause.u) && - !std::get_if<clause::Firstprivate>(&clause.u) && - !std::get_if<clause::Copyin>(&clause.u) && - !std::get_if<clause::Shared>(&clause.u) && - !std::get_if<clause::Threads>(&clause.u) && - !std::get_if<clause::Map>(&clause.u) && - !std::get_if<clause::UseDevicePtr>(&clause.u) && - !std::get_if<clause::UseDeviceAddr>(&clause.u) && - !std::get_if<clause::IsDevicePtr>(&clause.u) && - !std::get_if<clause::HasDeviceAddr>(&clause.u) && - !std::get_if<clause::ThreadLimit>(&clause.u) && - !std::get_if<clause::NumTeams>(&clause.u) && - !std::get_if<clause::Simd>(&clause.u)) { + if (!std::holds_alternative<clause::Allocate>(clause.u) && + !std::holds_alternative<clause::Copyin>(clause.u) && + !std::holds_alternative<clause::Copyprivate>(clause.u) && + !std::holds_alternative<clause::Default>(clause.u) && + !std::holds_alternative<clause::Depend>(clause.u) && + !std::holds_alternative<clause::Final>(clause.u) && + !std::holds_alternative<clause::Firstprivate>(clause.u) && + !std::holds_alternative<clause::HasDeviceAddr>(clause.u) && + !std::holds_alternative<clause::If>(clause.u) && + !std::holds_alternative<clause::IsDevicePtr>(clause.u) && + !std::holds_alternative<clause::Map>(clause.u) && + !std::holds_alternative<clause::Nowait>(clause.u) && + !std::holds_alternative<clause::NumTeams>(clause.u) && + !std::holds_alternative<clause::NumThreads>(clause.u) && + !std::holds_alternative<clause::Priority>(clause.u) && + !std::holds_alternative<clause::Private>(clause.u) && + !std::holds_alternative<clause::ProcBind>(clause.u) && + !std::holds_alternative<clause::Reduction>(clause.u) && + !std::holds_alternative<clause::Shared>(clause.u) && + !std::holds_alternative<clause::Simd>(clause.u) && + !std::holds_alternative<clause::ThreadLimit>(clause.u) && + !std::holds_alternative<clause::Threads>(clause.u) && + !std::holds_alternative<clause::UseDeviceAddr>(clause.u) && + !std::holds_alternative<clause::UseDevicePtr>(clause.u)) { TODO(clauseLocation, "OpenMP Block construct clause"); } } - for (const Clause &clause : endClauses) { - mlir::Location clauseLocation = converter.genLocation(clause.source); - if (!std::get_if<clause::Nowait>(&clause.u) && - !std::get_if<clause::Copyprivate>(&clause.u)) - TODO(clauseLocation, "OpenMP Block construct clause"); - } - std::optional<llvm::omp::Directive> nextDir = origDirective; bool outermostLeafConstruct = true; while (nextDir) { @@ -2230,44 +2214,42 @@ genOMP(Fortran::lower::AbstractConverter &converter, case llvm::omp::Directive::OMPD_ordered: // 2.17.9 ORDERED construct. genOrderedRegionOp(converter, semaCtx, eval, genNested, currentLocation, - beginClauses); + clauses); break; case llvm::omp::Directive::OMPD_parallel: // 2.6 PARALLEL construct. genParallelOp(converter, symTable, semaCtx, eval, genNested, - currentLocation, beginClauses, outerCombined); + currentLocation, clauses, outerCombined); break; case llvm::omp::Directive::OMPD_single: // 2.8.2 SINGLE construct. genSingleOp(converter, semaCtx, eval, genNested, currentLocation, - beginClauses, endClauses); + clauses); break; case llvm::omp::Directive::OMPD_target: // 2.12.5 TARGET construct. - genTargetOp(converter, semaCtx, eval, genNested, currentLocation, - beginClauses, outerCombined); + genTargetOp(converter, semaCtx, eval, genNested, currentLocation, clauses, + outerCombined); break; case llvm::omp::Directive::OMPD_target_data: // 2.12.2 TARGET DATA construct. genTargetDataOp(converter, semaCtx, eval, genNested, currentLocation, - beginClauses); + clauses); break; case llvm::omp::Directive::OMPD_task: // 2.10.1 TASK construct. - genTaskOp(converter, semaCtx, eval, genNested, currentLocation, - beginClauses); + genTaskOp(converter, semaCtx, eval, genNested, currentLocation, clauses); break; case llvm::omp::Directive::OMPD_taskgroup: // 2.17.6 TASKGROUP construct. genTaskgroupOp(converter, semaCtx, eval, genNested, currentLocation, - beginClauses); + clauses); break; case llvm::omp::Directive::OMPD_teams: // 2.7 TEAMS construct. // FIXME Pass the outerCombined argument or rename it to better describe // what it represents if it must always be `false` in this context. - genTeamsOp(converter, semaCtx, eval, genNested, currentLocation, - beginClauses); + genTeamsOp(converter, semaCtx, eval, genNested, currentLocation, clauses); break; case llvm::omp::Directive::OMPD_workshare: // 2.8.3 WORKSHARE construct. @@ -2275,7 +2257,7 @@ genOMP(Fortran::lower::AbstractConverter &converter, // implementation for this feature will come later. For the codes // that use this construct, add a single construct for now. genSingleOp(converter, semaCtx, eval, genNested, currentLocation, - beginClauses, endClauses); + clauses); break; default: llvm_unreachable("Unexpected block construct"); @@ -2317,7 +2299,7 @@ static void genOMP(Fortran::lower::AbstractConverter &converter, const Fortran::parser::OpenMPLoopConstruct &loopConstruct) { const auto &beginLoopDirective = std::get<Fortran::parser::OmpBeginLoopDirective>(loopConstruct.t); - List<Clause> beginClauses = makeClauses( + List<Clause> clauses = makeClauses( std::get<Fortran::parser::OmpClauseList>(beginLoopDirective.t), semaCtx); mlir::Location currentLocation = converter.genLocation(beginLoopDirective.source); @@ -2327,16 +2309,13 @@ static void genOMP(Fortran::lower::AbstractConverter &converter, assert(llvm::omp::loopConstructSet.test(origDirective) && "Expected loop construct"); - List<Clause> endClauses = [&]() { - if (auto &endLoopDirective = - std::get<std::optional<Fortran::parser::OmpEndLoopDirective>>( - loopConstruct.t)) { - return makeClauses( - std::get<Fortran::parser::OmpClauseList>(endLoopDirective->t), - semaCtx); - } - return List<Clause>{}; - }(); + if (auto &endLoopDirective = + std::get<std::optional<Fortran::parser::OmpEndLoopDirective>>( + loopConstruct.t)) { + clauses.append(makeClauses( + std::get<Fortran::parser::OmpClauseList>(endLoopDirective->t), + semaCtx)); + } std::optional<llvm::omp::Directive> nextDir = origDirective; while (nextDir) { @@ -2347,29 +2326,27 @@ static void genOMP(Fortran::lower::AbstractConverter &converter, switch (leafDir) { case llvm::omp::Directive::OMPD_distribute_parallel_do: // 2.9.4.3 DISTRIBUTE PARALLEL Worksharing-Loop construct. - genCompositeDistributeParallelDo(converter, semaCtx, eval, beginClauses, - endClauses, currentLocation); + genCompositeDistributeParallelDo(converter, semaCtx, eval, clauses, + currentLocation); break; case llvm::omp::Directive::OMPD_distribute_parallel_do_simd: // 2.9.4.4 DISTRIBUTE PARALLEL Worksharing-Loop SIMD construct. - genCompositeDistributeParallelDoSimd(converter, semaCtx, eval, - beginClauses, endClauses, + genCompositeDistributeParallelDoSimd(converter, semaCtx, eval, clauses, currentLocation); break; case llvm::omp::Directive::OMPD_distribute_simd: // 2.9.4.2 DISTRIBUTE SIMD construct. - genCompositeDistributeSimd(converter, semaCtx, eval, beginClauses, - endClauses, currentLocation); + genCompositeDistributeSimd(converter, semaCtx, eval, clauses, + currentLocation); break; case llvm::omp::Directive::OMPD_do_simd: // 2.9.3.2 Worksharing-Loop SIMD construct. - genCompositeDoSimd(converter, semaCtx, eval, beginClauses, endClauses, - currentLocation); + genCompositeDoSimd(converter, semaCtx, eval, clauses, currentLocation); break; case llvm::omp::Directive::OMPD_taskloop_simd: // 2.10.3 TASKLOOP SIMD construct. - genCompositeTaskloopSimd(converter, semaCtx, eval, beginClauses, - endClauses, currentLocation); + genCompositeTaskloopSimd(converter, semaCtx, eval, clauses, + currentLocation); break; default: llvm_unreachable("Unexpected composite construct"); @@ -2380,12 +2357,11 @@ static void genOMP(Fortran::lower::AbstractConverter &converter, case llvm::omp::Directive::OMPD_distribute: // 2.9.4.1 DISTRIBUTE construct. genDistributeOp(converter, semaCtx, eval, genNested, currentLocation, - beginClauses); + clauses); break; case llvm::omp::Directive::OMPD_do: // 2.9.2 Worksharing-Loop construct. - genWsloopOp(converter, semaCtx, eval, currentLocation, beginClauses, - endClauses); + genWsloopOp(converter, semaCtx, eval, currentLocation, clauses); break; case llvm::omp::Directive::OMPD_parallel: // 2.6 PARALLEL construct. @@ -2394,21 +2370,21 @@ static void ge... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/89090 _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
