[flang][OpenMP] Concatenate begin and end clauses into single list #89090
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This patch introduces a set of composable structures grouping the MLIR operands associated to each OpenMP clause. This makes it easier to keep the MLIR representation for the same clause consistent throughout all operations that accept it. The relevant clause operand structures are grouped into per-operation structures using a mixin pattern and used to define new operation constructors. These constructors can be used to avoid having to get the order of a possibly large list of operands right. Missing clauses are documented as TODOs, as well as operands which are part of the relevant operation's operand structure but cannot be attached to the associated operation yet, due to missing op arguments to its MLIR definition. A follow-up patch will update Flang lowering to make use of these structures, simplifying the passing of information from clause processing to operation- generating functions and also simplifying the creation of operations through the use of the new operation constructors.
This patch updates Flang lowering to use the new set of OpenMP clause operand structures and their groupings into directive-specific sets of clause operands. It simplifies the passing of information from the clause processor and the creation of operations. The `DataSharingProcessor` is slightly modified to not hold delayed privatization state. Instead, optional arguments are added to `processStep1` which are only passed when delayed privatization is used. This enables using the clause operand structure for `private` and removes the need for the ad-hoc `DelayedPrivatizationInfo` structure. The processing of the `schedule` clause is updated to process the `chunk` modifier rather than requiring two separate calls to the `ClauseProcessor`. Lowering of a block-associated `ordered` construct is updated to emit a TODO error if the `simd` clause is specified, since it is not currently supported by the `ClauseProcessor` or later compilation stages. Removed processing of `schedule` from `omp.simdloop`, as it doesn't apply to `simd` constructs.
This patch performs several cleanups with the main purpose of normalizing the code patterns used to trigger codegen for MLIR OpenMP operations and making the processing of clauses and constructs independent. The following changes are made: - Clean up unused `directive` argument to `ClauseProcessor::processMap()`. - Move general helper functions in OpenMP.cpp to the appropriate section of the file. - Create `gen<OpName>Clauses()` functions containing the clause processing code specific for the associated OpenMP construct. - Update `gen<OpName>Op()` functions to call the corresponding `gen<OpName>Clauses()` function. - Sort calls to `ClauseProcessor::process<ClauseName>()` alphabetically, to avoid inadvertently relying on some arbitrary order. Update some tests that broke due to the order change. - Normalize `genOMP()` functions so they all delegate the generation of MLIR to `gen<OpName>Op()` functions following the same pattern. - Only process `nowait` clause on `TARGET` constructs if not compiling for the target device. A later patch can move the calls to `gen<OpName>Clauses()` out of `gen<OpName>Op()` functions and passing completed clause structures instead, in preparation to supporting composite constructs. That will make it possible to reuse clause processing for a given leaf construct when appearing alone or in a combined or composite construct, while controlling where the associated code is produced.
…katrak/spr/clause-operands-02-flang
…skatrak/spr/clause-operands-03-genopclauses
This patch simplifies the lowering from PFT to MLIR of OpenMP compound constructs (i.e. combined and composite). The new approach consists of iteratively processing the outermost leaf construct of the given combined construct until it cannot be split further. Both leaf constructs and composite ones have `gen...()` functions that are called when appropriate. This approach enables treating a leaf construct the same way regardless of if it appeared as part of a combined construct, and it also enables the lowering of composite constructs as a single unit. Previous corner cases are now handled in a more straightforward way and comments pointing to the relevant spec section are added. Directive sets are also completed with missing LOOP related constructs.
This removes the last use of genOmpObjectList2, which has now been removed.
llvmbot
added
flang
|
@llvm/pr-subscribers-flang-fir-hlfir Author: Krzysztof Parzyszek (kparzysz) ChangesThis will remove the distinction between begin clauses and end clauses, 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:
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]
|
|
✅ With the latest revision this PR passed the C/C++ code formatter. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This will remove the distinction between begin clauses and end clauses,
and process all of them together.