[llvm-branch-commits] [flang] [mlir] [MLIR][OpenMP][Flang] Normalize clause arguments names (PR #99505)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Jul 18 07:55:27 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir-openmp
Author: Sergio Afonso (skatrak)
<details>
<summary>Changes</summary>
Currently, there are some inconsistencies to how clause arguments are named in the OpenMP dialect. Additionally, the clause operand structures associated to them also diverge in certain cases. The purpose of this patch is to normalize argument names across all `OpenMP_Clause` tablegen definitions and clause operand structures.
This has the benefit of providing more consistent representations for clauses in the dialect, but the main short-term advantage is that it enables the development of an OpenMP-specific tablegen backend to automatically generate the clause operand structures without breaking dependent code.
The main re-naming decisions made in this patch are the following:
- Variadic arguments (i.e. multiple values) have the "_vars" suffix. This and other similar suffixes are removed from array attribute arguments.
- Individual required or optional value arguments do not have any suffix added to them (e.g. "val", "var", "expr", ...), except for `if` which would otherwise result in an invalid C++ variable name.
- The associated clause's name is prepended to argument names that don't already contain it as part of its name. This avoids future collisions between arguments named the same way on different clauses and adding both clauses to the same operation.
- Privatization and reduction related arguments that contain lists of symbols pointing to privatizer/reducer operations use the "_syms" suffix. This removes the inconsistencies between the names for "copyprivate_funcs", "[in]reductions", "privatizers", etc.
- General improvements to names, replacement of camel case for snake case everywhere, etc.
- Renaming of operation-associated operand structures to use the "Operands" suffix in place of "ClauseOps", to better differentiate between clause operand structures and operation operand structures.
- Fields on clause operand structures are sorted according to the tablegen definition of the same clause.
The assembly format for a few arguments is updated to better reflect the clause they are associated with:
- `chunk_size` -> `dist_schedule_chunk_size`
- `grain_size` -> `grainsize`
- `simd` -> `par_level_simd`
---
Patch is 226.78 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/99505.diff
14 Files Affected:
- (modified) flang/lib/Lower/OpenMP/ClauseProcessor.cpp (+45-48)
- (modified) flang/lib/Lower/OpenMP/DataSharingProcessor.cpp (+3-3)
- (modified) flang/lib/Lower/OpenMP/OpenMP.cpp (+55-57)
- (modified) flang/lib/Optimizer/Transforms/OMPMapInfoFinalization.cpp (+12-12)
- (modified) mlir/include/mlir/Dialect/OpenMP/OpenMPClauseOperands.h (+70-70)
- (modified) mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td (+114-109)
- (modified) mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td (+64-70)
- (modified) mlir/include/mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td (+4-4)
- (modified) mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp (+15-15)
- (modified) mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp (+395-422)
- (modified) mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp (+96-97)
- (modified) mlir/test/Dialect/OpenMP/invalid.mlir (+20-20)
- (modified) mlir/test/Dialect/OpenMP/ops.mlir (+23-23)
- (modified) mlir/test/Target/LLVMIR/openmp-llvm.mlir (+4-4)
``````````diff
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
index b26c1679086b9..76402f0b2aeb3 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
@@ -187,13 +187,13 @@ static void convertLoopBounds(lower::AbstractConverter &converter,
// The types of lower bound, upper bound, and step are converted into the
// type of the loop variable if necessary.
mlir::Type loopVarType = getLoopVarType(converter, loopVarTypeSize);
- for (unsigned it = 0; it < (unsigned)result.loopLBVar.size(); it++) {
- result.loopLBVar[it] =
- firOpBuilder.createConvert(loc, loopVarType, result.loopLBVar[it]);
- result.loopUBVar[it] =
- firOpBuilder.createConvert(loc, loopVarType, result.loopUBVar[it]);
- result.loopStepVar[it] =
- firOpBuilder.createConvert(loc, loopVarType, result.loopStepVar[it]);
+ for (unsigned it = 0; it < (unsigned)result.collapseLowerBound.size(); it++) {
+ result.collapseLowerBound[it] = firOpBuilder.createConvert(
+ loc, loopVarType, result.collapseLowerBound[it]);
+ result.collapseUpperBound[it] = firOpBuilder.createConvert(
+ loc, loopVarType, result.collapseUpperBound[it]);
+ result.collapseStep[it] =
+ firOpBuilder.createConvert(loc, loopVarType, result.collapseStep[it]);
}
}
@@ -232,15 +232,15 @@ bool ClauseProcessor::processCollapse(
std::get_if<parser::LoopControl::Bounds>(&loopControl->u);
assert(bounds && "Expected bounds for worksharing do loop");
lower::StatementContext stmtCtx;
- result.loopLBVar.push_back(fir::getBase(
+ result.collapseLowerBound.push_back(fir::getBase(
converter.genExprValue(*semantics::GetExpr(bounds->lower), stmtCtx)));
- result.loopUBVar.push_back(fir::getBase(
+ result.collapseUpperBound.push_back(fir::getBase(
converter.genExprValue(*semantics::GetExpr(bounds->upper), stmtCtx)));
if (bounds->step) {
- result.loopStepVar.push_back(fir::getBase(
+ result.collapseStep.push_back(fir::getBase(
converter.genExprValue(*semantics::GetExpr(bounds->step), stmtCtx)));
} else { // If `step` is not present, assume it as `1`.
- result.loopStepVar.push_back(firOpBuilder.createIntegerConstant(
+ result.collapseStep.push_back(firOpBuilder.createIntegerConstant(
currentLocation, firOpBuilder.getIntegerType(32), 1));
}
iv.push_back(bounds->name.thing.symbol);
@@ -291,8 +291,7 @@ bool ClauseProcessor::processDevice(lower::StatementContext &stmtCtx,
}
}
const auto &deviceExpr = std::get<omp::SomeExpr>(clause->t);
- result.deviceVar =
- fir::getBase(converter.genExprValue(deviceExpr, stmtCtx));
+ result.device = fir::getBase(converter.genExprValue(deviceExpr, stmtCtx));
return true;
}
return false;
@@ -322,10 +321,10 @@ bool ClauseProcessor::processDistSchedule(
lower::StatementContext &stmtCtx,
mlir::omp::DistScheduleClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::DistSchedule>()) {
- result.distScheduleStaticAttr = converter.getFirOpBuilder().getUnitAttr();
+ result.distScheduleStatic = converter.getFirOpBuilder().getUnitAttr();
const auto &chunkSize = std::get<std::optional<ExprTy>>(clause->t);
if (chunkSize)
- result.distScheduleChunkSizeVar =
+ result.distScheduleChunkSize =
fir::getBase(converter.genExprValue(*chunkSize, stmtCtx));
return true;
}
@@ -335,7 +334,7 @@ bool ClauseProcessor::processDistSchedule(
bool ClauseProcessor::processFilter(lower::StatementContext &stmtCtx,
mlir::omp::FilterClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::Filter>()) {
- result.filteredThreadIdVar =
+ result.filteredThreadId =
fir::getBase(converter.genExprValue(clause->v, stmtCtx));
return true;
}
@@ -351,7 +350,7 @@ bool ClauseProcessor::processFinal(lower::StatementContext &stmtCtx,
mlir::Value finalVal =
fir::getBase(converter.genExprValue(clause->v, stmtCtx));
- result.finalVar = firOpBuilder.createConvert(
+ result.final = firOpBuilder.createConvert(
clauseLocation, firOpBuilder.getI1Type(), finalVal);
return true;
}
@@ -362,7 +361,7 @@ bool ClauseProcessor::processHint(mlir::omp::HintClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::Hint>()) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
int64_t hintValue = *evaluate::ToInt64(clause->v);
- result.hintAttr = firOpBuilder.getI64IntegerAttr(hintValue);
+ result.hint = firOpBuilder.getI64IntegerAttr(hintValue);
return true;
}
return false;
@@ -370,11 +369,11 @@ bool ClauseProcessor::processHint(mlir::omp::HintClauseOps &result) const {
bool ClauseProcessor::processMergeable(
mlir::omp::MergeableClauseOps &result) const {
- return markClauseOccurrence<omp::clause::Mergeable>(result.mergeableAttr);
+ return markClauseOccurrence<omp::clause::Mergeable>(result.mergeable);
}
bool ClauseProcessor::processNowait(mlir::omp::NowaitClauseOps &result) const {
- return markClauseOccurrence<omp::clause::Nowait>(result.nowaitAttr);
+ return markClauseOccurrence<omp::clause::Nowait>(result.nowait);
}
bool ClauseProcessor::processNumTeams(
@@ -385,7 +384,7 @@ bool ClauseProcessor::processNumTeams(
if (auto *clause = findUniqueClause<omp::clause::NumTeams>()) {
// auto lowerBound = std::get<std::optional<ExprTy>>(clause->t);
auto &upperBound = std::get<ExprTy>(clause->t);
- result.numTeamsUpperVar =
+ result.numTeamsUpper =
fir::getBase(converter.genExprValue(upperBound, stmtCtx));
return true;
}
@@ -397,7 +396,7 @@ bool ClauseProcessor::processNumThreads(
mlir::omp::NumThreadsClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::NumThreads>()) {
// OMPIRBuilder expects `NUM_THREADS` clause as a `Value`.
- result.numThreadsVar =
+ result.numThreads =
fir::getBase(converter.genExprValue(clause->v, stmtCtx));
return true;
}
@@ -408,17 +407,17 @@ bool ClauseProcessor::processOrder(mlir::omp::OrderClauseOps &result) const {
using Order = omp::clause::Order;
if (auto *clause = findUniqueClause<Order>()) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
- result.orderAttr = mlir::omp::ClauseOrderKindAttr::get(
+ result.order = mlir::omp::ClauseOrderKindAttr::get(
firOpBuilder.getContext(), mlir::omp::ClauseOrderKind::Concurrent);
const auto &modifier =
std::get<std::optional<Order::OrderModifier>>(clause->t);
if (modifier && *modifier == Order::OrderModifier::Unconstrained) {
- result.orderModAttr = mlir::omp::OrderModifierAttr::get(
+ result.orderMod = mlir::omp::OrderModifierAttr::get(
firOpBuilder.getContext(), mlir::omp::OrderModifier::unconstrained);
} else {
// "If order-modifier is not unconstrained, the behavior is as if the
// reproducible modifier is present."
- result.orderModAttr = mlir::omp::OrderModifierAttr::get(
+ result.orderMod = mlir::omp::OrderModifierAttr::get(
firOpBuilder.getContext(), mlir::omp::OrderModifier::reproducible);
}
return true;
@@ -433,7 +432,7 @@ bool ClauseProcessor::processOrdered(
int64_t orderedClauseValue = 0l;
if (clause->v.has_value())
orderedClauseValue = *evaluate::ToInt64(*clause->v);
- result.orderedAttr = firOpBuilder.getI64IntegerAttr(orderedClauseValue);
+ result.ordered = firOpBuilder.getI64IntegerAttr(orderedClauseValue);
return true;
}
return false;
@@ -443,8 +442,7 @@ bool ClauseProcessor::processPriority(
lower::StatementContext &stmtCtx,
mlir::omp::PriorityClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::Priority>()) {
- result.priorityVar =
- fir::getBase(converter.genExprValue(clause->v, stmtCtx));
+ result.priority = fir::getBase(converter.genExprValue(clause->v, stmtCtx));
return true;
}
return false;
@@ -454,7 +452,7 @@ bool ClauseProcessor::processProcBind(
mlir::omp::ProcBindClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::ProcBind>()) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
- result.procBindKindAttr = genProcBindKindAttr(firOpBuilder, *clause);
+ result.procBindKind = genProcBindKindAttr(firOpBuilder, *clause);
return true;
}
return false;
@@ -465,7 +463,7 @@ bool ClauseProcessor::processSafelen(
if (auto *clause = findUniqueClause<omp::clause::Safelen>()) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
const std::optional<std::int64_t> safelenVal = evaluate::ToInt64(clause->v);
- result.safelenAttr = firOpBuilder.getI64IntegerAttr(*safelenVal);
+ result.safelen = firOpBuilder.getI64IntegerAttr(*safelenVal);
return true;
}
return false;
@@ -498,19 +496,19 @@ bool ClauseProcessor::processSchedule(
break;
}
- result.scheduleValAttr =
+ result.scheduleKind =
mlir::omp::ClauseScheduleKindAttr::get(context, scheduleKind);
- mlir::omp::ScheduleModifier scheduleModifier = getScheduleModifier(*clause);
- if (scheduleModifier != mlir::omp::ScheduleModifier::none)
- result.scheduleModAttr =
- mlir::omp::ScheduleModifierAttr::get(context, scheduleModifier);
+ mlir::omp::ScheduleModifier scheduleMod = getScheduleModifier(*clause);
+ if (scheduleMod != mlir::omp::ScheduleModifier::none)
+ result.scheduleMod =
+ mlir::omp::ScheduleModifierAttr::get(context, scheduleMod);
if (getSimdModifier(*clause) != mlir::omp::ScheduleModifier::none)
- result.scheduleSimdAttr = firOpBuilder.getUnitAttr();
+ result.scheduleSimd = firOpBuilder.getUnitAttr();
if (const auto &chunkExpr = std::get<omp::MaybeExpr>(clause->t))
- result.scheduleChunkVar =
+ result.scheduleChunk =
fir::getBase(converter.genExprValue(*chunkExpr, stmtCtx));
return true;
@@ -523,7 +521,7 @@ bool ClauseProcessor::processSimdlen(
if (auto *clause = findUniqueClause<omp::clause::Simdlen>()) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
const std::optional<std::int64_t> simdlenVal = evaluate::ToInt64(clause->v);
- result.simdlenAttr = firOpBuilder.getI64IntegerAttr(*simdlenVal);
+ result.simdlen = firOpBuilder.getI64IntegerAttr(*simdlenVal);
return true;
}
return false;
@@ -533,7 +531,7 @@ bool ClauseProcessor::processThreadLimit(
lower::StatementContext &stmtCtx,
mlir::omp::ThreadLimitClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::ThreadLimit>()) {
- result.threadLimitVar =
+ result.threadLimit =
fir::getBase(converter.genExprValue(clause->v, stmtCtx));
return true;
}
@@ -541,7 +539,7 @@ bool ClauseProcessor::processThreadLimit(
}
bool ClauseProcessor::processUntied(mlir::omp::UntiedClauseOps &result) const {
- return markClauseOccurrence<omp::clause::Untied>(result.untiedAttr);
+ return markClauseOccurrence<omp::clause::Untied>(result.untied);
}
//===----------------------------------------------------------------------===//
@@ -565,7 +563,7 @@ static void
addAlignedClause(lower::AbstractConverter &converter,
const omp::clause::Aligned &clause,
llvm::SmallVectorImpl<mlir::Value> &alignedVars,
- llvm::SmallVectorImpl<mlir::Attribute> &alignmentAttrs) {
+ llvm::SmallVectorImpl<mlir::Attribute> &alignments) {
using Aligned = omp::clause::Aligned;
lower::StatementContext stmtCtx;
mlir::IntegerAttr alignmentValueAttr;
@@ -594,7 +592,7 @@ addAlignedClause(lower::AbstractConverter &converter,
alignmentValueAttr = builder.getI64IntegerAttr(alignment);
// All the list items in a aligned clause will have same alignment
for (std::size_t i = 0; i < objects.size(); i++)
- alignmentAttrs.push_back(alignmentValueAttr);
+ alignments.push_back(alignmentValueAttr);
}
}
@@ -603,7 +601,7 @@ bool ClauseProcessor::processAligned(
return findRepeatableClause<omp::clause::Aligned>(
[&](const omp::clause::Aligned &clause, const parser::CharBlock &) {
addAlignedClause(converter, clause, result.alignedVars,
- result.alignmentAttrs);
+ result.alignments);
});
}
@@ -798,7 +796,7 @@ bool ClauseProcessor::processCopyprivate(
result.copyprivateVars.push_back(cpVar);
mlir::func::FuncOp funcOp =
createCopyFunc(currentLocation, converter, cpVar.getType(), attrs);
- result.copyprivateFuncs.push_back(mlir::SymbolRefAttr::get(funcOp));
+ result.copyprivateSyms.push_back(mlir::SymbolRefAttr::get(funcOp));
};
bool hasCopyPrivate = findRepeatableClause<clause::Copyprivate>(
@@ -832,7 +830,7 @@ bool ClauseProcessor::processDepend(mlir::omp::DependClauseOps &result) const {
mlir::omp::ClauseTaskDependAttr dependTypeOperand =
genDependKindAttr(firOpBuilder, kind);
- result.dependTypeAttrs.append(objects.size(), dependTypeOperand);
+ result.dependKinds.append(objects.size(), dependTypeOperand);
for (const omp::Object &object : objects) {
assert(object.ref() && "Expecting designator");
@@ -1037,10 +1035,9 @@ bool ClauseProcessor::processReduction(
// Copy local lists into the output.
llvm::copy(reductionVars, std::back_inserter(result.reductionVars));
- llvm::copy(reduceVarByRef,
- std::back_inserter(result.reductionVarsByRef));
+ llvm::copy(reduceVarByRef, std::back_inserter(result.reductionByref));
llvm::copy(reductionDeclSymbols,
- std::back_inserter(result.reductionDeclSymbols));
+ std::back_inserter(result.reductionSyms));
if (outReductionTypes) {
outReductionTypes->reserve(outReductionTypes->size() +
diff --git a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
index 7df3905c29990..4f1f54475d929 100644
--- a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
@@ -226,8 +226,8 @@ void DataSharingProcessor::insertLastPrivateCompare(mlir::Operation *op) {
firOpBuilder.setInsertionPoint(lastOper);
mlir::Value iv = loopOp.getIVs()[0];
- mlir::Value ub = loopOp.getUpperBound()[0];
- mlir::Value step = loopOp.getStep()[0];
+ mlir::Value ub = loopOp.getCollapseUpperBound()[0];
+ mlir::Value step = loopOp.getCollapseStep()[0];
// v = iv + step
// cmp = step < 0 ? v < ub : v > ub
@@ -537,7 +537,7 @@ void DataSharingProcessor::doPrivatize(const semantics::Symbol *sym,
}();
if (clauseOps) {
- clauseOps->privatizers.push_back(mlir::SymbolRefAttr::get(privatizerOp));
+ clauseOps->privateSyms.push_back(mlir::SymbolRefAttr::get(privatizerOp));
clauseOps->privateVars.push_back(hsb.getAddr());
}
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index 47ce2d8c8db87..7e16dc4910cb9 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -284,7 +284,7 @@ static void getDeclareTargetInfo(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::pft::Evaluation &eval,
const parser::OpenMPDeclareTargetConstruct &declareTargetConstruct,
- mlir::omp::DeclareTargetClauseOps &clauseOps,
+ mlir::omp::DeclareTargetOperands &clauseOps,
llvm::SmallVectorImpl<DeclareTargetCapturePair> &symbolAndClause) {
const auto &spec =
std::get<parser::OmpDeclareTargetSpecifier>(declareTargetConstruct.t);
@@ -322,7 +322,7 @@ static void collectDeferredDeclareTargets(
const parser::OpenMPDeclareTargetConstruct &declareTargetConstruct,
llvm::SmallVectorImpl<lower::OMPDeferredDeclareTargetInfo>
&deferredDeclareTarget) {
- mlir::omp::DeclareTargetClauseOps clauseOps;
+ mlir::omp::DeclareTargetOperands clauseOps;
llvm::SmallVector<DeclareTargetCapturePair> symbolAndClause;
getDeclareTargetInfo(converter, semaCtx, eval, declareTargetConstruct,
clauseOps, symbolAndClause);
@@ -347,7 +347,7 @@ getDeclareTargetFunctionDevice(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::pft::Evaluation &eval,
const parser::OpenMPDeclareTargetConstruct &declareTargetConstruct) {
- mlir::omp::DeclareTargetClauseOps clauseOps;
+ mlir::omp::DeclareTargetOperands clauseOps;
llvm::SmallVector<DeclareTargetCapturePair> symbolAndClause;
getDeclareTargetInfo(converter, semaCtx, eval, declareTargetConstruct,
clauseOps, symbolAndClause);
@@ -926,7 +926,7 @@ genBodyOfTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
std::underlying_type_t<llvm::omp::OpenMPOffloadMappingFlags>>(
llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_IMPLICIT),
mlir::omp::VariableCaptureKind::ByCopy, copyVal.getType());
- targetOp.getMapOperandsMutable().append(mapOp);
+ targetOp.getMapVarsMutable().append(mapOp);
mlir::Value clonedValArg =
region.addArgument(copyVal.getType(), copyVal.getLoc());
firOpBuilder.setInsertionPointToStart(regionBlock);
@@ -1019,15 +1019,13 @@ static OpTy genWrapperOp(lower::AbstractConverter &converter,
// Code generation functions for clauses
//===----------------------------------------------------------------------===//
-static void genCriticalDeclareClauses(lower::AbstractConverter &converter,
- semantics::SemanticsContext &semaCtx,
- const List<Clause> &clauses,
- mlir::Location loc,
- mlir::omp::CriticalClauseOps &clauseOps,
- llvm::StringRef name) {
+static void genCriticalDeclareClauses(
+ lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
+ const List<Clause> &clauses, mlir::Location loc,
+ mlir::omp::CriticalDeclareOperands &clauseOps, llvm::StringRef name) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processHint(clauseOps);
- clauseOps.criticalNameAttr =
+ clauseOps.symName =
mlir::StringAttr::get(converter.getFirOpBuilder().getContext(), name);
}
@@ -1036,7 +1034,7 @@ static void genDistributeClauses(lower::AbstractConverter &converter,
lower::StatementContext &stmtCtx,
const List<Clause> &clauses,
mlir::Location loc,
- mlir::omp::DistributeClauseOps &clauseOps) {
+ mlir::omp::DistributeOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processDistSchedule(stmtCtx, clauseOps);
@@ -1060,18 +1058,18 @@ static void
genLoopNestClauses(lower::AbstractConverter &converter,
semantics::SemanticsContext &semaCtx,
lower::pft::Evaluation &eval, const List<Clause> &clauses,
- mlir::Location loc, mlir::omp::LoopNestClauseOps &clauseOps,
+ mlir::Location loc, mlir::omp::LoopNestOperands &clauseOps,
llvm::SmallVectorImpl<const semantics::Symbol *> &iv) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processCollapse(loc, eval, clauseOps, iv);
- clauseOps.loopInclusiveAttr = converter.getFirOpBuilder().getUnitAttr();
+ clauseOps.loopInclusive = converter.getFirOpBuilder().getUnitAttr();
}
static void genMaskedClauses(lower::AbstractConverter &converter,
semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx,
const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::MaskedClauseOps &clauseOps) {
+ mlir::omp::MaskedOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/99505
More information about the llvm-branch-commits
mailing list