[flang-commits] [flang] [mlir] [MLIR][OpenMP][Flang] Normalize clause arguments names (PR #99505)
Sergio Afonso via flang-commits
flang-commits at lists.llvm.org
Thu Jul 25 08:56:44 PDT 2024
https://github.com/skatrak updated https://github.com/llvm/llvm-project/pull/99505
>From fc0cb5ad333124a1edda2948536ac4050c698b6d Mon Sep 17 00:00:00 2001
From: Sergio Afonso <safonsof at amd.com>
Date: Tue, 16 Jul 2024 13:27:53 +0100
Subject: [PATCH] [MLIR][OpenMP][Flang] Normalize clause arguments names
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`
---
flang/lib/Lower/OpenMP/ClauseProcessor.cpp | 94 +-
.../lib/Lower/OpenMP/DataSharingProcessor.cpp | 4 +-
flang/lib/Lower/OpenMP/OpenMP.cpp | 112 ++-
.../Transforms/OMPMapInfoFinalization.cpp | 24 +-
.../Dialect/OpenMP/OpenMPClauseOperands.h | 145 ++--
.../mlir/Dialect/OpenMP/OpenMPClauses.td | 224 ++---
mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td | 132 ++-
.../Dialect/OpenMP/OpenMPOpsInterfaces.td | 8 +-
.../Conversion/SCFToOpenMP/SCFToOpenMP.cpp | 28 +-
mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp | 817 +++++++++---------
.../OpenMP/OpenMPToLLVMIRTranslation.cpp | 187 ++--
mlir/test/Dialect/OpenMP/invalid.mlir | 40 +-
mlir/test/Dialect/OpenMP/ops.mlir | 42 +-
mlir/test/Target/LLVMIR/openmp-llvm.mlir | 12 +-
14 files changed, 922 insertions(+), 947 deletions(-)
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
index b26c1679086b9..facf95e17707e 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
@@ -187,13 +187,14 @@ 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.collapseLowerBounds.size();
+ it++) {
+ result.collapseLowerBounds[it] = firOpBuilder.createConvert(
+ loc, loopVarType, result.collapseLowerBounds[it]);
+ result.collapseUpperBounds[it] = firOpBuilder.createConvert(
+ loc, loopVarType, result.collapseUpperBounds[it]);
+ result.collapseSteps[it] =
+ firOpBuilder.createConvert(loc, loopVarType, result.collapseSteps[it]);
}
}
@@ -232,15 +233,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.collapseLowerBounds.push_back(fir::getBase(
converter.genExprValue(*semantics::GetExpr(bounds->lower), stmtCtx)));
- result.loopUBVar.push_back(fir::getBase(
+ result.collapseUpperBounds.push_back(fir::getBase(
converter.genExprValue(*semantics::GetExpr(bounds->upper), stmtCtx)));
if (bounds->step) {
- result.loopStepVar.push_back(fir::getBase(
+ result.collapseSteps.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.collapseSteps.push_back(firOpBuilder.createIntegerConstant(
currentLocation, firOpBuilder.getIntegerType(32), 1));
}
iv.push_back(bounds->name.thing.symbol);
@@ -291,8 +292,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 +322,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 +335,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 +351,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 +362,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 +370,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 +385,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 +397,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 +408,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 +433,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 +443,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 +453,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 +464,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 +497,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 +522,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 +532,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 +540,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 +564,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 +593,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 +602,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 +797,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 +831,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 +1036,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 7e76a81e0df92..ae3acdc8ab78b 100644
--- a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
@@ -268,7 +268,7 @@ void DataSharingProcessor::insertLastPrivateCompare(mlir::Operation *op) {
llvm::SmallVector<mlir::Value> vs;
vs.reserve(loopOp.getIVs().size());
for (auto [iv, ub, step] : llvm::zip_equal(
- loopOp.getIVs(), loopOp.getUpperBound(), loopOp.getStep())) {
+ loopOp.getIVs(), loopOp.getCollapseUpperBounds(), loopOp.getCollapseSteps())) {
// v = iv + step
// cmp = step < 0 ? v < ub : v > ub
mlir::Value v = firOpBuilder.create<mlir::arith::AddIOp>(loc, iv, step);
@@ -587,7 +587,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 1f280a02a6550..2b1839b5270d4 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);
@@ -929,7 +929,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);
@@ -1022,15 +1022,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);
}
@@ -1039,7 +1037,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);
@@ -1063,18 +1061,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);
cp.processFilter(stmtCtx, clauseOps);
}
@@ -1083,7 +1081,7 @@ static void
genOrderedRegionClauses(lower::AbstractConverter &converter,
semantics::SemanticsContext &semaCtx,
const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::OrderedRegionClauseOps &clauseOps) {
+ mlir::omp::OrderedRegionOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processTODO<clause::Simd>(loc, llvm::omp::Directive::OMPD_ordered);
}
@@ -1091,7 +1089,7 @@ genOrderedRegionClauses(lower::AbstractConverter &converter,
static void genParallelClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx, const List<Clause> &clauses,
- mlir::Location loc, mlir::omp::ParallelClauseOps &clauseOps,
+ mlir::Location loc, mlir::omp::ParallelOperands &clauseOps,
llvm::SmallVectorImpl<mlir::Type> &reductionTypes,
llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms) {
ClauseProcessor cp(converter, semaCtx, clauses);
@@ -1106,7 +1104,7 @@ static void genParallelClauses(
static void genSectionsClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::SectionsClauseOps &clauseOps,
+ mlir::omp::SectionsOperands &clauseOps,
llvm::SmallVectorImpl<mlir::Type> &reductionTypes,
llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms) {
ClauseProcessor cp(converter, semaCtx, clauses);
@@ -1119,7 +1117,7 @@ static void genSectionsClauses(
static void genSimdClauses(lower::AbstractConverter &converter,
semantics::SemanticsContext &semaCtx,
const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::SimdClauseOps &clauseOps) {
+ mlir::omp::SimdOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAligned(clauseOps);
cp.processIf(llvm::omp::Directive::OMPD_simd, clauseOps);
@@ -1136,7 +1134,7 @@ static void genSimdClauses(lower::AbstractConverter &converter,
static void genSingleClauses(lower::AbstractConverter &converter,
semantics::SemanticsContext &semaCtx,
const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::SingleClauseOps &clauseOps) {
+ mlir::omp::SingleOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processCopyprivate(loc, clauseOps);
@@ -1148,7 +1146,7 @@ static void genTargetClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx, const List<Clause> &clauses,
mlir::Location loc, bool processHostOnlyClauses,
- mlir::omp::TargetClauseOps &clauseOps,
+ mlir::omp::TargetOperands &clauseOps,
llvm::SmallVectorImpl<const semantics::Symbol *> &mapSyms,
llvm::SmallVectorImpl<mlir::Location> &mapLocs,
llvm::SmallVectorImpl<mlir::Type> &mapTypes,
@@ -1185,7 +1183,7 @@ static void genTargetClauses(
static void genTargetDataClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx, const List<Clause> &clauses,
- mlir::Location loc, mlir::omp::TargetDataClauseOps &clauseOps,
+ mlir::Location loc, mlir::omp::TargetDataOperands &clauseOps,
llvm::SmallVectorImpl<mlir::Type> &useDeviceTypes,
llvm::SmallVectorImpl<mlir::Location> &useDeviceLocs,
llvm::SmallVectorImpl<const semantics::Symbol *> &useDeviceSyms) {
@@ -1218,7 +1216,7 @@ static void genTargetEnterExitUpdateDataClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx, const List<Clause> &clauses,
mlir::Location loc, llvm::omp::Directive directive,
- mlir::omp::TargetEnterExitUpdateDataClauseOps &clauseOps) {
+ mlir::omp::TargetEnterExitUpdateDataOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processDepend(clauseOps);
cp.processDevice(stmtCtx, clauseOps);
@@ -1237,7 +1235,7 @@ static void genTaskClauses(lower::AbstractConverter &converter,
semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx,
const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::TaskClauseOps &clauseOps) {
+ mlir::omp::TaskOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processDefault();
@@ -1256,7 +1254,7 @@ static void genTaskClauses(lower::AbstractConverter &converter,
static void genTaskgroupClauses(lower::AbstractConverter &converter,
semantics::SemanticsContext &semaCtx,
const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::TaskgroupClauseOps &clauseOps) {
+ mlir::omp::TaskgroupOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processTODO<clause::TaskReduction>(loc,
@@ -1266,7 +1264,7 @@ static void genTaskgroupClauses(lower::AbstractConverter &converter,
static void genTaskwaitClauses(lower::AbstractConverter &converter,
semantics::SemanticsContext &semaCtx,
const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::TaskwaitClauseOps &clauseOps) {
+ mlir::omp::TaskwaitOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processTODO<clause::Depend, clause::Nowait>(
loc, llvm::omp::Directive::OMPD_taskwait);
@@ -1276,7 +1274,7 @@ static void genTeamsClauses(lower::AbstractConverter &converter,
semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx,
const List<Clause> &clauses, mlir::Location loc,
- mlir::omp::TeamsClauseOps &clauseOps) {
+ mlir::omp::TeamsOperands &clauseOps) {
ClauseProcessor cp(converter, semaCtx, clauses);
cp.processAllocate(clauseOps);
cp.processDefault();
@@ -1291,7 +1289,7 @@ static void genTeamsClauses(lower::AbstractConverter &converter,
static void genWsloopClauses(
lower::AbstractConverter &converter, semantics::SemanticsContext &semaCtx,
lower::StatementContext &stmtCtx, const List<Clause> &clauses,
- mlir::Location loc, mlir::omp::WsloopClauseOps &clauseOps,
+ mlir::Location loc, mlir::omp::WsloopOperands &clauseOps,
llvm::SmallVectorImpl<mlir::Type> &reductionTypes,
llvm::SmallVectorImpl<const semantics::Symbol *> &reductionSyms) {
ClauseProcessor cp(converter, semaCtx, clauses);
@@ -1332,7 +1330,7 @@ genCriticalOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
mlir::ModuleOp mod = firOpBuilder.getModule();
auto global = mod.lookupSymbol<mlir::omp::CriticalDeclareOp>(nameStr);
if (!global) {
- mlir::omp::CriticalClauseOps clauseOps;
+ mlir::omp::CriticalDeclareOperands clauseOps;
genCriticalDeclareClauses(converter, semaCtx, item->clauses, loc,
clauseOps, nameStr);
@@ -1367,7 +1365,7 @@ genLoopNestOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
semantics::SemanticsContext &semaCtx,
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue, ConstructQueue::iterator item,
- mlir::omp::LoopNestClauseOps &clauseOps,
+ mlir::omp::LoopNestOperands &clauseOps,
llvm::ArrayRef<const semantics::Symbol *> iv,
llvm::ArrayRef<const semantics::Symbol *> wrapperSyms,
llvm::ArrayRef<mlir::BlockArgument> wrapperArgs,
@@ -1395,7 +1393,7 @@ genMaskedOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::iterator item) {
lower::StatementContext stmtCtx;
- mlir::omp::MaskedClauseOps clauseOps;
+ mlir::omp::MaskedOperands clauseOps;
genMaskedClauses(converter, semaCtx, stmtCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::MaskedOp>(
@@ -1429,7 +1427,7 @@ genOrderedRegionOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
semantics::SemanticsContext &semaCtx,
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue, ConstructQueue::iterator item) {
- mlir::omp::OrderedRegionClauseOps clauseOps;
+ mlir::omp::OrderedRegionOperands clauseOps;
genOrderedRegionClauses(converter, semaCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::OrderedRegionOp>(
@@ -1443,7 +1441,7 @@ genParallelOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
semantics::SemanticsContext &semaCtx,
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue, ConstructQueue::iterator item,
- mlir::omp::ParallelClauseOps &clauseOps,
+ mlir::omp::ParallelOperands &clauseOps,
llvm::ArrayRef<const semantics::Symbol *> reductionSyms,
llvm::ArrayRef<mlir::Type> reductionTypes) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
@@ -1534,7 +1532,7 @@ genSectionsOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
const parser::OmpSectionBlocks §ionBlocks) {
llvm::SmallVector<mlir::Type> reductionTypes;
llvm::SmallVector<const semantics::Symbol *> reductionSyms;
- mlir::omp::SectionsClauseOps clauseOps;
+ mlir::omp::SectionsOperands clauseOps;
genSectionsClauses(converter, semaCtx, item->clauses, loc, clauseOps,
reductionTypes, reductionSyms);
@@ -1635,7 +1633,7 @@ genSectionsOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
// Emit implicit barrier to synchronize threads and avoid data
// races on post-update of lastprivate variables when `nowait`
// clause is present.
- if (clauseOps.nowaitAttr && !lastprivates.empty())
+ if (clauseOps.nowait && !lastprivates.empty())
builder.create<mlir::omp::BarrierOp>(loc);
symTable.popScope();
@@ -1647,7 +1645,7 @@ genSingleOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
semantics::SemanticsContext &semaCtx, lower::pft::Evaluation &eval,
mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::iterator item) {
- mlir::omp::SingleClauseOps clauseOps;
+ mlir::omp::SingleOperands clauseOps;
genSingleClauses(converter, semaCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::SingleOp>(
@@ -1669,7 +1667,7 @@ genTargetOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
!llvm::cast<mlir::omp::OffloadModuleInterface>(*converter.getModuleOp())
.getIsTargetDevice();
- mlir::omp::TargetClauseOps clauseOps;
+ mlir::omp::TargetOperands clauseOps;
llvm::SmallVector<const semantics::Symbol *> mapSyms, devicePtrSyms,
deviceAddrSyms;
llvm::SmallVector<mlir::Location> mapLocs, devicePtrLocs, deviceAddrLocs;
@@ -1797,7 +1795,7 @@ genTargetDataOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue, ConstructQueue::iterator item) {
lower::StatementContext stmtCtx;
- mlir::omp::TargetDataClauseOps clauseOps;
+ mlir::omp::TargetDataOperands clauseOps;
llvm::SmallVector<mlir::Type> useDeviceTypes;
llvm::SmallVector<mlir::Location> useDeviceLocs;
llvm::SmallVector<const semantics::Symbol *> useDeviceSyms;
@@ -1835,7 +1833,7 @@ static OpTy genTargetEnterExitUpdateDataOp(lower::AbstractConverter &converter,
llvm_unreachable("Unexpected TARGET DATA construct");
}
- mlir::omp::TargetEnterExitUpdateDataClauseOps clauseOps;
+ mlir::omp::TargetEnterExitUpdateDataOperands clauseOps;
genTargetEnterExitUpdateDataClauses(converter, semaCtx, stmtCtx,
item->clauses, loc, directive, clauseOps);
@@ -1848,7 +1846,7 @@ genTaskOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::iterator item) {
lower::StatementContext stmtCtx;
- mlir::omp::TaskClauseOps clauseOps;
+ mlir::omp::TaskOperands clauseOps;
genTaskClauses(converter, semaCtx, stmtCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::TaskOp>(
@@ -1863,7 +1861,7 @@ genTaskgroupOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
semantics::SemanticsContext &semaCtx,
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue, ConstructQueue::iterator item) {
- mlir::omp::TaskgroupClauseOps clauseOps;
+ mlir::omp::TaskgroupOperands clauseOps;
genTaskgroupClauses(converter, semaCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::TaskgroupOp>(
@@ -1878,7 +1876,7 @@ genTaskwaitOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
semantics::SemanticsContext &semaCtx,
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue, ConstructQueue::iterator item) {
- mlir::omp::TaskwaitClauseOps clauseOps;
+ mlir::omp::TaskwaitOperands clauseOps;
genTaskwaitClauses(converter, semaCtx, item->clauses, loc, clauseOps);
return converter.getFirOpBuilder().create<mlir::omp::TaskwaitOp>(loc,
clauseOps);
@@ -1898,7 +1896,7 @@ genTeamsOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::iterator item) {
lower::StatementContext stmtCtx;
- mlir::omp::TeamsClauseOps clauseOps;
+ mlir::omp::TeamsOperands clauseOps;
genTeamsClauses(converter, semaCtx, stmtCtx, item->clauses, loc, clauseOps);
return genOpWithBody<mlir::omp::TeamsOp>(
@@ -1920,11 +1918,11 @@ static void genStandaloneDistribute(
ConstructQueue::iterator item, DataSharingProcessor &dsp) {
lower::StatementContext stmtCtx;
- mlir::omp::DistributeClauseOps distributeClauseOps;
+ mlir::omp::DistributeOperands distributeClauseOps;
genDistributeClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
distributeClauseOps);
- mlir::omp::LoopNestClauseOps loopNestClauseOps;
+ mlir::omp::LoopNestOperands loopNestClauseOps;
llvm::SmallVector<const semantics::Symbol *> iv;
genLoopNestClauses(converter, semaCtx, eval, item->clauses, loc,
loopNestClauseOps, iv);
@@ -1948,13 +1946,13 @@ static void genStandaloneDo(lower::AbstractConverter &converter,
DataSharingProcessor &dsp) {
lower::StatementContext stmtCtx;
- mlir::omp::WsloopClauseOps wsloopClauseOps;
+ mlir::omp::WsloopOperands wsloopClauseOps;
llvm::SmallVector<const semantics::Symbol *> reductionSyms;
llvm::SmallVector<mlir::Type> reductionTypes;
genWsloopClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
wsloopClauseOps, reductionTypes, reductionSyms);
- mlir::omp::LoopNestClauseOps loopNestClauseOps;
+ mlir::omp::LoopNestOperands loopNestClauseOps;
llvm::SmallVector<const semantics::Symbol *> iv;
genLoopNestClauses(converter, semaCtx, eval, item->clauses, loc,
loopNestClauseOps, iv);
@@ -1978,7 +1976,7 @@ static void genStandaloneParallel(lower::AbstractConverter &converter,
ConstructQueue::iterator item) {
lower::StatementContext stmtCtx;
- mlir::omp::ParallelClauseOps clauseOps;
+ mlir::omp::ParallelOperands clauseOps;
llvm::SmallVector<const semantics::Symbol *> reductionSyms;
llvm::SmallVector<mlir::Type> reductionTypes;
genParallelClauses(converter, semaCtx, stmtCtx, item->clauses, loc, clauseOps,
@@ -1995,10 +1993,10 @@ static void genStandaloneSimd(lower::AbstractConverter &converter,
const ConstructQueue &queue,
ConstructQueue::iterator item,
DataSharingProcessor &dsp) {
- mlir::omp::SimdClauseOps simdClauseOps;
+ mlir::omp::SimdOperands simdClauseOps;
genSimdClauses(converter, semaCtx, item->clauses, loc, simdClauseOps);
- mlir::omp::LoopNestClauseOps loopNestClauseOps;
+ mlir::omp::LoopNestOperands loopNestClauseOps;
llvm::SmallVector<const semantics::Symbol *> iv;
genLoopNestClauses(converter, semaCtx, eval, item->clauses, loc,
loopNestClauseOps, iv);
@@ -2049,14 +2047,14 @@ static void genCompositeDistributeSimd(
lower::StatementContext stmtCtx;
// Clause processing.
- mlir::omp::DistributeClauseOps distributeClauseOps;
+ mlir::omp::DistributeOperands distributeClauseOps;
genDistributeClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
distributeClauseOps);
- mlir::omp::SimdClauseOps simdClauseOps;
+ mlir::omp::SimdOperands simdClauseOps;
genSimdClauses(converter, semaCtx, item->clauses, loc, simdClauseOps);
- mlir::omp::LoopNestClauseOps loopNestClauseOps;
+ mlir::omp::LoopNestOperands loopNestClauseOps;
llvm::SmallVector<const semantics::Symbol *> iv;
genLoopNestClauses(converter, semaCtx, eval, item->clauses, loc,
loopNestClauseOps, iv);
@@ -2095,16 +2093,16 @@ static void genCompositeDoSimd(lower::AbstractConverter &converter,
lower::StatementContext stmtCtx;
// Clause processing.
- mlir::omp::WsloopClauseOps wsloopClauseOps;
+ mlir::omp::WsloopOperands wsloopClauseOps;
llvm::SmallVector<const semantics::Symbol *> wsloopReductionSyms;
llvm::SmallVector<mlir::Type> wsloopReductionTypes;
genWsloopClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
wsloopClauseOps, wsloopReductionTypes, wsloopReductionSyms);
- mlir::omp::SimdClauseOps simdClauseOps;
+ mlir::omp::SimdOperands simdClauseOps;
genSimdClauses(converter, semaCtx, item->clauses, loc, simdClauseOps);
- mlir::omp::LoopNestClauseOps loopNestClauseOps;
+ mlir::omp::LoopNestOperands loopNestClauseOps;
llvm::SmallVector<const semantics::Symbol *> iv;
genLoopNestClauses(converter, semaCtx, eval, item->clauses, loc,
loopNestClauseOps, iv);
@@ -2315,7 +2313,7 @@ static void
genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
semantics::SemanticsContext &semaCtx, lower::pft::Evaluation &eval,
const parser::OpenMPDeclareTargetConstruct &declareTargetConstruct) {
- mlir::omp::DeclareTargetClauseOps clauseOps;
+ mlir::omp::DeclareTargetOperands clauseOps;
llvm::SmallVector<DeclareTargetCapturePair> symbolAndClause;
mlir::ModuleOp mod = converter.getFirOpBuilder().getModule();
getDeclareTargetInfo(converter, semaCtx, eval, declareTargetConstruct,
diff --git a/flang/lib/Optimizer/Transforms/OMPMapInfoFinalization.cpp b/flang/lib/Optimizer/Transforms/OMPMapInfoFinalization.cpp
index 35203fe89f5bc..ddaa3c5f404f0 100644
--- a/flang/lib/Optimizer/Transforms/OMPMapInfoFinalization.cpp
+++ b/flang/lib/Optimizer/Transforms/OMPMapInfoFinalization.cpp
@@ -109,10 +109,10 @@ class OMPMapInfoFinalizationPass
if (auto mapClauseOwner =
llvm::dyn_cast<mlir::omp::MapClauseOwningOpInterface>(target)) {
llvm::SmallVector<mlir::Value> newMapOps;
- mlir::OperandRange mapOperandsArr = mapClauseOwner.getMapOperands();
+ mlir::OperandRange mapVarsArr = mapClauseOwner.getMapVars();
- for (size_t i = 0; i < mapOperandsArr.size(); ++i) {
- if (mapOperandsArr[i] == op) {
+ for (size_t i = 0; i < mapVarsArr.size(); ++i) {
+ if (mapVarsArr[i] == op) {
// Push new implicit maps generated for the descriptor.
newMapOps.push_back(baseAddr);
@@ -120,13 +120,13 @@ class OMPMapInfoFinalizationPass
// new additional map operand with an appropriate BlockArgument,
// as the printing and later processing currently requires a 1:1
// mapping of BlockArgs to MapInfoOp's at the same placement in
- // each array (BlockArgs and MapOperands).
+ // each array (BlockArgs and MapVars).
if (auto targetOp = llvm::dyn_cast<mlir::omp::TargetOp>(target))
targetOp.getRegion().insertArgument(i, baseAddr.getType(), loc);
}
- newMapOps.push_back(mapOperandsArr[i]);
+ newMapOps.push_back(mapVarsArr[i]);
}
- mapClauseOwner.getMapOperandsMutable().assign(newMapOps);
+ mapClauseOwner.getMapVarsMutable().assign(newMapOps);
}
mlir::Value newDescParentMapOp = builder.create<mlir::omp::MapInfoOp>(
@@ -196,27 +196,27 @@ class OMPMapInfoFinalizationPass
return;
llvm::SmallVector<mlir::Value> newMapOps;
- mlir::OperandRange mapOperandsArr = mapClauseOwner.getMapOperands();
+ mlir::OperandRange mapVarsArr = mapClauseOwner.getMapVars();
auto targetOp = llvm::dyn_cast<mlir::omp::TargetOp>(target);
- for (size_t i = 0; i < mapOperandsArr.size(); ++i) {
- if (mapOperandsArr[i] == op) {
+ for (size_t i = 0; i < mapVarsArr.size(); ++i) {
+ if (mapVarsArr[i] == op) {
for (auto [j, mapMember] : llvm::enumerate(op.getMembers())) {
newMapOps.push_back(mapMember);
// for TargetOp's which have IsolatedFromAbove we must align the
// new additional map operand with an appropriate BlockArgument,
// as the printing and later processing currently requires a 1:1
// mapping of BlockArgs to MapInfoOp's at the same placement in
- // each array (BlockArgs and MapOperands).
+ // each array (BlockArgs and MapVars).
if (targetOp) {
targetOp.getRegion().insertArgument(i + j, mapMember.getType(),
targetOp->getLoc());
}
}
}
- newMapOps.push_back(mapOperandsArr[i]);
+ newMapOps.push_back(mapVarsArr[i]);
}
- mapClauseOwner.getMapOperandsMutable().assign(newMapOps);
+ mapClauseOwner.getMapVarsMutable().assign(newMapOps);
}
// This pass executes on omp::MapInfoOp's containing descriptor based types
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauseOperands.h b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauseOperands.h
index 0eefe06055b7d..4730d544e8739 100644
--- a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauseOperands.h
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauseOperands.h
@@ -32,37 +32,42 @@ namespace omp {
struct AlignedClauseOps {
llvm::SmallVector<Value> alignedVars;
- llvm::SmallVector<Attribute> alignmentAttrs;
+ llvm::SmallVector<Attribute> alignments;
};
struct AllocateClauseOps {
- llvm::SmallVector<Value> allocatorVars, allocateVars;
+ llvm::SmallVector<Value> allocateVars, allocatorVars;
};
struct CancelDirectiveNameClauseOps {
- ClauseCancellationConstructTypeAttr cancelDirectiveNameAttr;
+ ClauseCancellationConstructTypeAttr cancelDirective;
};
struct CollapseClauseOps {
- llvm::SmallVector<Value> loopLBVar, loopUBVar, loopStepVar;
+ llvm::SmallVector<Value> collapseLowerBounds, collapseUpperBounds,
+ collapseSteps;
};
struct CopyprivateClauseOps {
llvm::SmallVector<Value> copyprivateVars;
- llvm::SmallVector<Attribute> copyprivateFuncs;
+ llvm::SmallVector<Attribute> copyprivateSyms;
};
struct CriticalNameClauseOps {
- StringAttr criticalNameAttr;
+ /// This field has a generic name because it's mirroring the `sym_name`
+ /// argument of the `OpenMP_CriticalNameClause` tablegen definition. That one
+ /// can't be renamed to anything more specific because the `sym_name` name is
+ /// a requirement of the `Symbol` MLIR trait associated with that clause.
+ StringAttr symName;
};
struct DependClauseOps {
- llvm::SmallVector<Attribute> dependTypeAttrs;
+ llvm::SmallVector<Attribute> dependKinds;
llvm::SmallVector<Value> dependVars;
};
struct DeviceClauseOps {
- Value deviceVar;
+ Value device;
};
struct DeviceTypeClauseOps {
@@ -71,26 +76,26 @@ struct DeviceTypeClauseOps {
};
struct DistScheduleClauseOps {
- UnitAttr distScheduleStaticAttr;
- Value distScheduleChunkSizeVar;
+ UnitAttr distScheduleStatic;
+ Value distScheduleChunkSize;
};
struct DoacrossClauseOps {
- llvm::SmallVector<Value> doacrossVectorVars;
- ClauseDependAttr doacrossDependTypeAttr;
- IntegerAttr doacrossNumLoopsAttr;
+ ClauseDependAttr doacrossDependType;
+ IntegerAttr doacrossNumLoops;
+ llvm::SmallVector<Value> doacrossDependVars;
};
struct FilterClauseOps {
- Value filteredThreadIdVar;
+ Value filteredThreadId;
};
struct FinalClauseOps {
- Value finalVar;
+ Value final;
};
struct GrainsizeClauseOps {
- Value grainsizeVar;
+ Value grainsize;
};
struct HasDeviceAddrClauseOps {
@@ -98,7 +103,7 @@ struct HasDeviceAddrClauseOps {
};
struct HintClauseOps {
- IntegerAttr hintAttr;
+ IntegerAttr hint;
};
struct IfClauseOps {
@@ -107,8 +112,8 @@ struct IfClauseOps {
struct InReductionClauseOps {
llvm::SmallVector<Value> inReductionVars;
- llvm::SmallVector<bool> inReductionVarsByRef;
- llvm::SmallVector<Attribute> inReductionDeclSymbols;
+ llvm::SmallVector<bool> inReductionByref;
+ llvm::SmallVector<Attribute> inReductionSyms;
};
struct IsDevicePtrClauseOps {
@@ -120,7 +125,7 @@ struct LinearClauseOps {
};
struct LoopRelatedOps {
- UnitAttr loopInclusiveAttr;
+ UnitAttr loopInclusive;
};
struct MapClauseOps {
@@ -128,11 +133,11 @@ struct MapClauseOps {
};
struct MergeableClauseOps {
- UnitAttr mergeableAttr;
+ UnitAttr mergeable;
};
struct NogroupClauseOps {
- UnitAttr nogroupAttr;
+ UnitAttr nogroup;
};
struct NontemporalClauseOps {
@@ -140,36 +145,36 @@ struct NontemporalClauseOps {
};
struct NowaitClauseOps {
- UnitAttr nowaitAttr;
+ UnitAttr nowait;
};
struct NumTasksClauseOps {
- Value numTasksVar;
+ Value numTasks;
};
struct NumTeamsClauseOps {
- Value numTeamsLowerVar, numTeamsUpperVar;
+ Value numTeamsLower, numTeamsUpper;
};
struct NumThreadsClauseOps {
- Value numThreadsVar;
+ Value numThreads;
};
struct OrderClauseOps {
- ClauseOrderKindAttr orderAttr;
- OrderModifierAttr orderModAttr;
+ ClauseOrderKindAttr order;
+ OrderModifierAttr orderMod;
};
struct OrderedClauseOps {
- IntegerAttr orderedAttr;
+ IntegerAttr ordered;
};
struct ParallelizationLevelClauseOps {
- UnitAttr parLevelSimdAttr;
+ UnitAttr parLevelSimd;
};
struct PriorityClauseOps {
- Value priorityVar;
+ Value priority;
};
struct PrivateClauseOps {
@@ -179,46 +184,46 @@ struct PrivateClauseOps {
llvm::SmallVector<Value> privateVars;
// The list of symbols referring to delayed privatizer ops (i.e. `omp.private`
// ops).
- llvm::SmallVector<Attribute> privatizers;
+ llvm::SmallVector<Attribute> privateSyms;
};
struct ProcBindClauseOps {
- ClauseProcBindKindAttr procBindKindAttr;
+ ClauseProcBindKindAttr procBindKind;
};
struct ReductionClauseOps {
llvm::SmallVector<Value> reductionVars;
- llvm::SmallVector<bool> reductionVarsByRef;
- llvm::SmallVector<Attribute> reductionDeclSymbols;
+ llvm::SmallVector<bool> reductionByref;
+ llvm::SmallVector<Attribute> reductionSyms;
};
struct SafelenClauseOps {
- IntegerAttr safelenAttr;
+ IntegerAttr safelen;
};
struct ScheduleClauseOps {
- ClauseScheduleKindAttr scheduleValAttr;
- ScheduleModifierAttr scheduleModAttr;
- Value scheduleChunkVar;
- UnitAttr scheduleSimdAttr;
+ ClauseScheduleKindAttr scheduleKind;
+ Value scheduleChunk;
+ ScheduleModifierAttr scheduleMod;
+ UnitAttr scheduleSimd;
};
struct SimdlenClauseOps {
- IntegerAttr simdlenAttr;
+ IntegerAttr simdlen;
};
struct TaskReductionClauseOps {
llvm::SmallVector<Value> taskReductionVars;
- llvm::SmallVector<bool> taskReductionVarsByRef;
- llvm::SmallVector<Attribute> taskReductionDeclSymbols;
+ llvm::SmallVector<bool> taskReductionByref;
+ llvm::SmallVector<Attribute> taskReductionSyms;
};
struct ThreadLimitClauseOps {
- Value threadLimitVar;
+ Value threadLimit;
};
struct UntiedClauseOps {
- UnitAttr untiedAttr;
+ UnitAttr untied;
};
struct UseDeviceAddrClauseOps {
@@ -241,82 +246,82 @@ template <typename... Mixins>
struct Clauses : public Mixins... {};
} // namespace detail
-using CancelClauseOps =
+using CancelOperands =
detail::Clauses<CancelDirectiveNameClauseOps, IfClauseOps>;
-using CancellationPointClauseOps =
- detail::Clauses<CancelDirectiveNameClauseOps>;
+using CancellationPointOperands = detail::Clauses<CancelDirectiveNameClauseOps>;
-using CriticalClauseOps = detail::Clauses<CriticalNameClauseOps, HintClauseOps>;
+using CriticalDeclareOperands =
+ detail::Clauses<CriticalNameClauseOps, HintClauseOps>;
// TODO `indirect` clause.
-using DeclareTargetClauseOps = detail::Clauses<DeviceTypeClauseOps>;
+using DeclareTargetOperands = detail::Clauses<DeviceTypeClauseOps>;
-using DistributeClauseOps =
+using DistributeOperands =
detail::Clauses<AllocateClauseOps, DistScheduleClauseOps, OrderClauseOps,
PrivateClauseOps>;
-using LoopNestClauseOps = detail::Clauses<CollapseClauseOps, LoopRelatedOps>;
+using LoopNestOperands = detail::Clauses<CollapseClauseOps, LoopRelatedOps>;
-using MaskedClauseOps = detail::Clauses<FilterClauseOps>;
+using MaskedOperands = detail::Clauses<FilterClauseOps>;
-using OrderedOpClauseOps = detail::Clauses<DoacrossClauseOps>;
+using OrderedOperands = detail::Clauses<DoacrossClauseOps>;
-using OrderedRegionClauseOps = detail::Clauses<ParallelizationLevelClauseOps>;
+using OrderedRegionOperands = detail::Clauses<ParallelizationLevelClauseOps>;
-using ParallelClauseOps =
+using ParallelOperands =
detail::Clauses<AllocateClauseOps, IfClauseOps, NumThreadsClauseOps,
PrivateClauseOps, ProcBindClauseOps, ReductionClauseOps>;
-using SectionsClauseOps = detail::Clauses<AllocateClauseOps, NowaitClauseOps,
- PrivateClauseOps, ReductionClauseOps>;
+using SectionsOperands = detail::Clauses<AllocateClauseOps, NowaitClauseOps,
+ PrivateClauseOps, ReductionClauseOps>;
// TODO `linear` clause.
-using SimdClauseOps =
+using SimdOperands =
detail::Clauses<AlignedClauseOps, IfClauseOps, NontemporalClauseOps,
OrderClauseOps, PrivateClauseOps, ReductionClauseOps,
SafelenClauseOps, SimdlenClauseOps>;
-using SingleClauseOps = detail::Clauses<AllocateClauseOps, CopyprivateClauseOps,
- NowaitClauseOps, PrivateClauseOps>;
+using SingleOperands = detail::Clauses<AllocateClauseOps, CopyprivateClauseOps,
+ NowaitClauseOps, PrivateClauseOps>;
// TODO `defaultmap`, `uses_allocators` clauses.
-using TargetClauseOps =
+using TargetOperands =
detail::Clauses<AllocateClauseOps, DependClauseOps, DeviceClauseOps,
HasDeviceAddrClauseOps, IfClauseOps, InReductionClauseOps,
IsDevicePtrClauseOps, MapClauseOps, NowaitClauseOps,
PrivateClauseOps, ThreadLimitClauseOps>;
-using TargetDataClauseOps =
+using TargetDataOperands =
detail::Clauses<DeviceClauseOps, IfClauseOps, MapClauseOps,
UseDeviceAddrClauseOps, UseDevicePtrClauseOps>;
-using TargetEnterExitUpdateDataClauseOps =
+using TargetEnterExitUpdateDataOperands =
detail::Clauses<DependClauseOps, DeviceClauseOps, IfClauseOps, MapClauseOps,
NowaitClauseOps>;
// TODO `affinity`, `detach` clauses.
-using TaskClauseOps =
+using TaskOperands =
detail::Clauses<AllocateClauseOps, DependClauseOps, FinalClauseOps,
IfClauseOps, InReductionClauseOps, MergeableClauseOps,
PriorityClauseOps, PrivateClauseOps, UntiedClauseOps>;
-using TaskgroupClauseOps =
+using TaskgroupOperands =
detail::Clauses<AllocateClauseOps, TaskReductionClauseOps>;
-using TaskloopClauseOps =
+using TaskloopOperands =
detail::Clauses<AllocateClauseOps, FinalClauseOps, GrainsizeClauseOps,
IfClauseOps, InReductionClauseOps, MergeableClauseOps,
NogroupClauseOps, NumTasksClauseOps, PriorityClauseOps,
PrivateClauseOps, ReductionClauseOps, UntiedClauseOps>;
-using TaskwaitClauseOps = detail::Clauses<DependClauseOps, NowaitClauseOps>;
+using TaskwaitOperands = detail::Clauses<DependClauseOps, NowaitClauseOps>;
-using TeamsClauseOps =
+using TeamsOperands =
detail::Clauses<AllocateClauseOps, IfClauseOps, NumTeamsClauseOps,
PrivateClauseOps, ReductionClauseOps, ThreadLimitClauseOps>;
-using WsloopClauseOps =
+using WsloopOperands =
detail::Clauses<AllocateClauseOps, LinearClauseOps, NowaitClauseOps,
OrderClauseOps, OrderedClauseOps, PrivateClauseOps,
ReductionClauseOps, ScheduleClauseOps>;
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
index 5b201687b4ea3..b6be8be63b328 100644
--- a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
@@ -20,6 +20,7 @@
#define OPENMP_CLAUSES
include "mlir/Dialect/OpenMP/OpenMPOpBase.td"
+include "mlir/IR/SymbolInterfaces.td"
//===----------------------------------------------------------------------===//
// V5.2: [5.11] `aligned` clause
@@ -32,18 +33,18 @@ class OpenMP_AlignedClauseSkip<
description, extraClassDeclaration> {
let arguments = (ins
Variadic<OpenMP_PointerLikeType>:$aligned_vars,
- OptionalAttr<I64ArrayAttr>:$alignment_values
+ OptionalAttr<I64ArrayAttr>:$alignments
);
let assemblyFormat = [{
`aligned` `(` custom<AlignedClause>($aligned_vars, type($aligned_vars),
- $alignment_values) `)`
+ $alignments) `)`
}];
let description = [{
- The `alignment_values` attribute additionally specifies alignment of each
- corresponding aligned operand. Note that `aligned_vars` and
- `alignment_values` should contain the same number of elements.
+ The `alignments` attribute additionally specifies alignment of each
+ corresponding aligned operand. Note that `aligned_vars` and `alignments`
+ must contain the same number of elements.
}];
}
@@ -60,22 +61,22 @@ class OpenMP_AllocateClauseSkip<
description, extraClassDeclaration> {
let arguments = (ins
Variadic<AnyType>:$allocate_vars,
- Variadic<AnyType>:$allocators_vars
+ Variadic<AnyType>:$allocator_vars
);
let extraClassDeclaration = [{
unsigned getNumAllocateVars() { return getAllocateVars().size(); }
- unsigned getNumAllocatorsVars() { return getAllocatorsVars().size(); }
+ unsigned getNumAllocatorsVars() { return getAllocatorVars().size(); }
}];
let assemblyFormat = [{
`allocate` `(`
custom<AllocateAndAllocator>($allocate_vars, type($allocate_vars),
- $allocators_vars, type($allocators_vars)) `)`
+ $allocator_vars, type($allocator_vars)) `)`
}];
let description = [{
- The `allocators_vars` and `allocate_vars` parameters are a variadic list of
+ The `allocator_vars` and `allocate_vars` parameters are a variadic list of
values that specify the memory allocator to be used to obtain storage for
private values.
}];
@@ -93,12 +94,12 @@ class OpenMP_CancelDirectiveNameClauseSkip<
> : OpenMP_Clause</*isRequired=*/true, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- CancellationConstructTypeAttr:$cancellation_construct_type_val
+ CancellationConstructTypeAttr:$cancel_directive
);
let assemblyFormat = [{
`cancellation_construct_type` `(`
- custom<ClauseAttr>($cancellation_construct_type_val) `)`
+ custom<ClauseAttr>($cancel_directive) `)`
}];
// TODO: Add description.
@@ -116,18 +117,19 @@ class OpenMP_CollapseClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let traits = [
- AllTypesMatch<["lowerBound", "upperBound", "step"]>
+ AllTypesMatch<
+ ["collapse_lower_bounds", "collapse_upper_bounds", "collapse_steps"]>
];
let arguments = (ins
- Variadic<IntLikeType>:$lowerBound,
- Variadic<IntLikeType>:$upperBound,
- Variadic<IntLikeType>:$step
+ Variadic<IntLikeType>:$collapse_lower_bounds,
+ Variadic<IntLikeType>:$collapse_upper_bounds,
+ Variadic<IntLikeType>:$collapse_steps
);
let extraClassDeclaration = [{
/// Returns the number of loops in the loop nest.
- unsigned getNumLoops() { return getLowerBound().size(); }
+ unsigned getNumLoops() { return getCollapseLowerBounds().size(); }
}];
// Description and formatting integrated in the `omp.loop_nest` operation,
@@ -147,13 +149,13 @@ class OpenMP_CopyprivateClauseSkip<
description, extraClassDeclaration> {
let arguments = (ins
Variadic<OpenMP_PointerLikeType>:$copyprivate_vars,
- OptionalAttr<SymbolRefArrayAttr>:$copyprivate_funcs
+ OptionalAttr<SymbolRefArrayAttr>:$copyprivate_syms
);
let assemblyFormat = [{
`copyprivate` `(`
- custom<CopyPrivateVarList>($copyprivate_vars, type($copyprivate_vars),
- $copyprivate_funcs) `)`
+ custom<Copyprivate>($copyprivate_vars, type($copyprivate_vars),
+ $copyprivate_syms) `)`
}];
let description = [{
@@ -174,6 +176,10 @@ class OpenMP_CriticalNameClauseSkip<
bit description = false, bit extraClassDeclaration = false
> : OpenMP_Clause</*isRequired=*/true, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
+ let traits = [
+ Symbol
+ ];
+
let arguments = (ins
SymbolNameAttr:$sym_name
);
@@ -197,18 +203,19 @@ class OpenMP_DependClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- OptionalAttr<TaskDependArrayAttr>:$depends,
+ OptionalAttr<TaskDependArrayAttr>:$depend_kinds,
Variadic<OpenMP_PointerLikeType>:$depend_vars
);
let assemblyFormat = [{
`depend` `(`
- custom<DependVarList>($depend_vars, type($depend_vars), $depends) `)`
+ custom<DependVarList>($depend_vars, type($depend_vars), $depend_kinds) `)`
}];
let description = [{
- The `depends` and `depend_vars` arguments are variadic lists of values that
- specify the dependencies of this particular task in relation to other tasks.
+ The `depend_kinds` and `depend_vars` arguments are variadic lists of values
+ that specify the dependencies of this particular task in relation to other
+ tasks.
}];
}
@@ -250,19 +257,20 @@ class OpenMP_DistScheduleClauseSkip<
description, extraClassDeclaration> {
let arguments = (ins
UnitAttr:$dist_schedule_static,
- Optional<IntLikeType>:$chunk_size
+ Optional<IntLikeType>:$dist_schedule_chunk_size
);
let assemblyFormat = [{
`dist_schedule_static` $dist_schedule_static
- | `chunk_size` `(` $chunk_size `:` type($chunk_size) `)`
+ | `dist_schedule_chunk_size` `(` $dist_schedule_chunk_size `:`
+ type($dist_schedule_chunk_size) `)`
}];
let description = [{
The `dist_schedule_static` attribute specifies the schedule for this loop,
determining how the loop is distributed across the various teams. The
- optional `chunk_size` associated with this determines further controls this
- distribution.
+ optional `dist_schedule_chunk_size` associated with this determines further
+ controls this distribution.
}];
}
@@ -278,24 +286,25 @@ class OpenMP_DoacrossClauseSkip<
> : OpenMP_Clause</*isRequired=*/true, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- OptionalAttr<ClauseDependAttr>:$depend_type_val,
- ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$num_loops_val,
- Variadic<AnyType>:$depend_vec_vars
+ OptionalAttr<ClauseDependAttr>:$doacross_depend_type,
+ ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$doacross_num_loops,
+ Variadic<AnyType>:$doacross_depend_vars
);
let assemblyFormat = [{
- ( `depend_type` `` $depend_type_val^ )?
- ( `depend_vec` `(` $depend_vec_vars^ `:` type($depend_vec_vars) `)` )?
+ ( `depend_type` `` $doacross_depend_type^ )?
+ ( `depend_vec` `(` $doacross_depend_vars^ `:` type($doacross_depend_vars)
+ `)` )?
}];
let description = [{
- The `depend_type_val` attribute refers to either the DEPEND(SOURCE) clause
- or the DEPEND(SINK: vec) clause.
+ The `doacross_depend_type` attribute refers to either the DEPEND(SOURCE)
+ clause or the DEPEND(SINK: vec) clause.
- The `num_loops_val` attribute specifies the number of loops in the doacross
- nest.
+ The `doacross_num_loops` attribute specifies the number of loops in the
+ doacross nest.
- The `depend_vec_vars` is a variadic list of operands that specifies the
+ The `doacross_depend_vars` is a variadic list of operands that specifies the
index of the loop iterator in the doacross nest for the DEPEND(SOURCE)
clause or the index of the element of "vec" for the DEPEND(SINK: vec)
clause. It contains the operands in multiple "vec" when multiple
@@ -343,11 +352,11 @@ class OpenMP_FinalClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- Optional<I1>:$final_expr
+ Optional<I1>:$final
);
let assemblyFormat = [{
- `final` `(` $final_expr `)`
+ `final` `(` $final `)`
}];
let description = [{
@@ -371,11 +380,11 @@ class OpenMP_GrainsizeClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- Optional<IntLikeType>:$grain_size
+ Optional<IntLikeType>:$grainsize
);
let assemblyFormat = [{
- `grain_size` `(` $grain_size `:` type($grain_size) `)`
+ `grainsize` `(` $grainsize `:` type($grainsize) `)`
}];
let description = [{
@@ -398,17 +407,18 @@ class OpenMP_HasDeviceAddrClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- Variadic<OpenMP_PointerLikeType>:$has_device_addr
+ Variadic<OpenMP_PointerLikeType>:$has_device_addr_vars
);
let assemblyFormat = [{
- `has_device_addr` `(` $has_device_addr `:` type($has_device_addr) `)`
+ `has_device_addr` `(` $has_device_addr_vars `:` type($has_device_addr_vars)
+ `)`
}];
let description = [{
- The optional `has_device_addr` indicates that list items already have device
- addresses, so they may be directly accessed from the target device. This
- includes array sections.
+ The optional `has_device_addr_vars` indicates that list items already have
+ device addresses, so they may be directly accessed from the target device.
+ This includes array sections.
}];
}
@@ -424,11 +434,11 @@ class OpenMP_HintClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- DefaultValuedOptionalAttr<I64Attr, "0">:$hint_val
+ DefaultValuedOptionalAttr<I64Attr, "0">:$hint
);
let assemblyFormat = [{
- `hint` `(` custom<SynchronizationHint>($hint_val) `)`
+ `hint` `(` custom<SynchronizationHint>($hint) `)`
}];
let description = [{
@@ -477,14 +487,14 @@ class OpenMP_InReductionClauseSkip<
let arguments = (ins
Variadic<OpenMP_PointerLikeType>:$in_reduction_vars,
- OptionalAttr<DenseBoolArrayAttr>:$in_reduction_vars_byref,
- OptionalAttr<SymbolRefArrayAttr>:$in_reductions
+ OptionalAttr<DenseBoolArrayAttr>:$in_reduction_byref,
+ OptionalAttr<SymbolRefArrayAttr>:$in_reduction_syms
);
let assemblyFormat = [{
`in_reduction` `(`
custom<ReductionVarList>($in_reduction_vars, type($in_reduction_vars),
- $in_reduction_vars_byref, $in_reductions) `)`
+ $in_reduction_byref, $in_reduction_syms) `)`
}];
let extraClassDeclaration = [{
@@ -510,15 +520,15 @@ class OpenMP_IsDevicePtrClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- Variadic<OpenMP_PointerLikeType>:$is_device_ptr
+ Variadic<OpenMP_PointerLikeType>:$is_device_ptr_vars
);
let assemblyFormat = [{
- `is_device_ptr` `(` $is_device_ptr `:` type($is_device_ptr) `)`
+ `is_device_ptr` `(` $is_device_ptr_vars `:` type($is_device_ptr_vars) `)`
}];
let description = [{
- The optional `is_device_ptr` indicates list items are device pointers.
+ The optional `is_device_ptr_vars` indicates list items are device pointers.
}];
}
@@ -568,16 +578,16 @@ class OpenMP_MapClauseSkip<
];
let arguments = (ins
- Variadic<OpenMP_PointerLikeType>:$map_operands
+ Variadic<OpenMP_PointerLikeType>:$map_vars
);
let assemblyFormat = [{
- `map_entries` `(` custom<MapEntries>($map_operands, type($map_operands)) `)`
+ `map_entries` `(` custom<MapEntries>($map_vars, type($map_vars)) `)`
}];
let description = [{
- The optional `map_operands` maps data from the current task's data
- environment to the device data environment.
+ The optional `map_vars` maps data from the current task's data environment
+ to the device data environment.
}];
}
@@ -593,11 +603,11 @@ class OpenMP_MemoryOrderClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- OptionalAttr<MemoryOrderKindAttr>:$memory_order_val
+ OptionalAttr<MemoryOrderKindAttr>:$memory_order
);
let assemblyFormat = [{
- `memory_order` `(` custom<ClauseAttr>($memory_order_val) `)`
+ `memory_order` `(` custom<ClauseAttr>($memory_order) `)`
}];
let description = [{
@@ -779,16 +789,16 @@ class OpenMP_NumThreadsClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- Optional<IntLikeType>:$num_threads_var
+ Optional<IntLikeType>:$num_threads
);
let assemblyFormat = [{
- `num_threads` `(` $num_threads_var `:` type($num_threads_var) `)`
+ `num_threads` `(` $num_threads `:` type($num_threads) `)`
}];
let description = [{
- The optional `num_threads_var` parameter specifies the number of threads
- which should be used to execute the parallel region.
+ The optional `num_threads` parameter specifies the number of threads which
+ should be used to execute the parallel region.
}];
}
@@ -804,12 +814,12 @@ class OpenMP_OrderClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- OptionalAttr<OrderKindAttr>:$order_val,
+ OptionalAttr<OrderKindAttr>:$order,
OptionalAttr<OrderModifierAttr>:$order_mod
);
let assemblyFormat = [{
- `order` `(` custom<OrderClause>($order_val, $order_mod) `)`
+ `order` `(` custom<OrderClause>($order, $order_mod) `)`
}];
let description = [{
@@ -831,15 +841,15 @@ class OpenMP_OrderedClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$ordered_val
+ ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$ordered
);
let assemblyFormat = [{
- `ordered` `(` $ordered_val `)`
+ `ordered` `(` $ordered `)`
}];
let description = [{
- The optional `ordered_val` attribute specifies how many loops are associated
+ The optional `ordered` attribute specifies how many loops are associated
with the worksharing-loop construct. The value of zero refers to the ordered
clause specified without parameter.
}];
@@ -857,17 +867,17 @@ class OpenMP_ParallelizationLevelClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- UnitAttr:$simd
+ UnitAttr:$par_level_simd
);
let assemblyFormat = [{
- `simd` $simd
+ `par_level_simd` $par_level_simd
}];
let description = [{
- The `simd` attribute corresponds to the simd clause specified. If it is not
- present, it behaves as if the threads clause is specified or no clause is
- specified.
+ The `par_level_simd` attribute corresponds to the simd clause specified. If
+ it is not present, it behaves as if the threads clause is specified or no
+ clause is specified.
}];
}
@@ -914,12 +924,12 @@ class OpenMP_PrivateClauseSkip<
description, extraClassDeclaration> {
let arguments = (ins
Variadic<AnyType>:$private_vars,
- OptionalAttr<SymbolRefArrayAttr>:$privatizers
+ OptionalAttr<SymbolRefArrayAttr>:$private_syms
);
let assemblyFormat = [{
`private` `(`
- custom<PrivateList>($private_vars, type($private_vars), $privatizers) `)`
+ custom<PrivateList>($private_vars, type($private_vars), $private_syms) `)`
}];
// TODO: Add description.
@@ -937,15 +947,15 @@ class OpenMP_ProcBindClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- OptionalAttr<ProcBindKindAttr>:$proc_bind_val
+ OptionalAttr<ProcBindKindAttr>:$proc_bind_kind
);
let assemblyFormat = [{
- `proc_bind` `(` custom<ClauseAttr>($proc_bind_val) `)`
+ `proc_bind` `(` custom<ClauseAttr>($proc_bind_kind) `)`
}];
let description = [{
- The optional `proc_bind_val` attribute controls the thread affinity for the
+ The optional `proc_bind_kind` attribute controls the thread affinity for the
execution of the parallel region.
}];
}
@@ -967,14 +977,14 @@ class OpenMP_ReductionClauseSkip<
let arguments = (ins
Variadic<OpenMP_PointerLikeType>:$reduction_vars,
- OptionalAttr<DenseBoolArrayAttr>:$reduction_vars_byref,
- OptionalAttr<SymbolRefArrayAttr>:$reductions
+ OptionalAttr<DenseBoolArrayAttr>:$reduction_byref,
+ OptionalAttr<SymbolRefArrayAttr>:$reduction_syms
);
let assemblyFormat = [{
`reduction` `(`
custom<ReductionVarList>($reduction_vars, type($reduction_vars),
- $reduction_vars_byref, $reductions) `)`
+ $reduction_byref, $reduction_syms) `)`
}];
let extraClassDeclaration = [{
@@ -986,10 +996,10 @@ class OpenMP_ReductionClauseSkip<
let description = [{
Reductions can be performed by specifying reduction accumulator variables in
`reduction_vars`, symbols referring to reduction declarations in the
- `reductions` attribute, and whether the reduction variable should be passed
- into the reduction region by value or by reference in
- `reduction_vars_byref`. Each reduction is identified by the accumulator it
- uses and accumulators must not be repeated in the same reduction. A private
+ `reduction_syms` attribute, and whether the reduction variable should be
+ passed into the reduction region by value or by reference in
+ `reduction_byref`. Each reduction is identified by the accumulator it uses
+ and accumulators must not be repeated in the same reduction. A private
variable corresponding to the accumulator is used in place of the
accumulator inside the body of the operation. The reduction declaration
specifies how to combine the values from each iteration, section, team,
@@ -1036,22 +1046,22 @@ class OpenMP_ScheduleClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- OptionalAttr<ScheduleKindAttr>:$schedule_val,
- Optional<AnyType>:$schedule_chunk_var,
- OptionalAttr<ScheduleModifierAttr>:$schedule_modifier,
- UnitAttr:$simd_modifier
+ OptionalAttr<ScheduleKindAttr>:$schedule_kind,
+ Optional<AnyType>:$schedule_chunk,
+ OptionalAttr<ScheduleModifierAttr>:$schedule_mod,
+ UnitAttr:$schedule_simd
);
let assemblyFormat = [{
`schedule` `(`
- custom<ScheduleClause>($schedule_val, $schedule_modifier, $simd_modifier,
- $schedule_chunk_var, type($schedule_chunk_var)) `)`
+ custom<ScheduleClause>($schedule_kind, $schedule_mod, $schedule_simd,
+ $schedule_chunk, type($schedule_chunk)) `)`
}];
let description = [{
- The optional `schedule_val` attribute specifies the loop schedule for this
+ The optional `schedule_kind` attribute specifies the loop schedule for this
loop, determining how the loop is distributed across the parallel threads.
- The optional `schedule_chunk_var` associated with this determines further
+ The optional `schedule_chunk` associated with this determines further
controls this distribution.
}];
}
@@ -1098,14 +1108,14 @@ class OpenMP_TaskReductionClauseSkip<
let arguments = (ins
Variadic<OpenMP_PointerLikeType>:$task_reduction_vars,
- OptionalAttr<DenseBoolArrayAttr>:$task_reduction_vars_byref,
- OptionalAttr<SymbolRefArrayAttr>:$task_reductions
+ OptionalAttr<DenseBoolArrayAttr>:$task_reduction_byref,
+ OptionalAttr<SymbolRefArrayAttr>:$task_reduction_syms
);
let assemblyFormat = [{
`task_reduction` `(`
custom<ReductionVarList>($task_reduction_vars, type($task_reduction_vars),
- $task_reduction_vars_byref, $task_reductions) `)`
+ $task_reduction_byref, $task_reduction_syms) `)`
}];
let description = [{
@@ -1115,9 +1125,9 @@ class OpenMP_TaskReductionClauseSkip<
participating in the reduction. After the end of the region, the original
list item contains the result of the reduction. Similarly to the `reduction`
clause, accumulator variables must be passed in `task_reduction_vars`,
- symbols referring to reduction declarations in the `task_reductions`
+ symbols referring to reduction declarations in the `task_reduction_syms`
attribute, and whether the reduction variable should be passed into the
- reduction region by value or by reference in `task_reduction_vars_byref`.
+ reduction region by value or by reference in `task_reduction_byref`.
}];
let extraClassDeclaration = [{
@@ -1176,7 +1186,7 @@ class OpenMP_UntiedClauseSkip<
If the `untied` clause is present on a task construct, any thread in the
team can resume the task region after a suspension. The `untied` clause is
ignored if a `final` clause is present on the same task construct and the
- `final_expr` evaluates to `true`, or if a task is an included task.
+ `final` expression evaluates to `true`, or if a task is an included task.
}];
}
@@ -1192,16 +1202,16 @@ class OpenMP_UseDeviceAddrClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- Variadic<OpenMP_PointerLikeType>:$use_device_addr
+ Variadic<OpenMP_PointerLikeType>:$use_device_addr_vars
);
let assemblyFormat = [{
- `use_device_addr` `(` $use_device_addr `:` type($use_device_addr) `)`
+ `use_device_addr` `(` $use_device_addr_vars `:` type($use_device_addr_vars) `)`
}];
let description = [{
- The optional `use_device_addr` specifies the address of the objects in the
- device data environment.
+ The optional `use_device_addr_vars` specifies the address of the objects in
+ the device data environment.
}];
}
@@ -1217,15 +1227,15 @@ class OpenMP_UseDevicePtrClauseSkip<
> : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
description, extraClassDeclaration> {
let arguments = (ins
- Variadic<OpenMP_PointerLikeType>:$use_device_ptr
+ Variadic<OpenMP_PointerLikeType>:$use_device_ptr_vars
);
let assemblyFormat = [{
- `use_device_ptr` `(` $use_device_ptr `:` type($use_device_ptr) `)`
+ `use_device_ptr` `(` $use_device_ptr_vars `:` type($use_device_ptr_vars) `)`
}];
let description = [{
- The optional `use_device_ptr` specifies the device pointers to the
+ The optional `use_device_ptr_vars` specifies the device pointers to the
corresponding list items in the device data environment.
}];
}
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td b/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
index 69fd1f1f0130f..a42e32587e570 100644
--- a/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
@@ -145,15 +145,14 @@ def ParallelOp : OpenMP_Op<"parallel", traits = [
The parallel construct includes a region of code which is to be executed
by a team of threads.
- The optional `if_expr` parameter specifies a boolean result of a
- conditional check. If this value is 1 or is not provided then the parallel
- region runs as normal, if it is 0 then the parallel region is executed with
- one thread.
+ The optional `if_expr` parameter specifies a boolean result of a conditional
+ check. If this value is 1 or is not provided then the parallel region runs
+ as normal, if it is 0 then the parallel region is executed with one thread.
}] # clausesDescription;
let builders = [
OpBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
- OpBuilder<(ins CArg<"const ParallelClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const ParallelOperands &">:$clauses)>
];
// TODO: Use default assembly format inherited from OpenMP_Op once printing
@@ -163,16 +162,16 @@ def ParallelOp : OpenMP_Op<"parallel", traits = [
let assemblyFormat = [{
oilist(
`if` `(` $if_expr `)`
- | `num_threads` `(` $num_threads_var `:` type($num_threads_var) `)`
+ | `num_threads` `(` $num_threads `:` type($num_threads) `)`
| `allocate` `(`
custom<AllocateAndAllocator>(
$allocate_vars, type($allocate_vars),
- $allocators_vars, type($allocators_vars)
+ $allocator_vars, type($allocator_vars)
) `)`
- | `proc_bind` `(` custom<ClauseAttr>($proc_bind_val) `)`
+ | `proc_bind` `(` custom<ClauseAttr>($proc_bind_kind) `)`
) custom<ParallelRegion>($region, $reduction_vars, type($reduction_vars),
- $reduction_vars_byref, $reductions, $private_vars,
- type($private_vars), $privatizers) attr-dict
+ $reduction_byref, $reduction_syms, $private_vars,
+ type($private_vars), $private_syms) attr-dict
}];
let hasVerifier = 1;
@@ -212,7 +211,7 @@ def TeamsOp : OpenMP_Op<"teams", traits = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const TeamsClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TeamsOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -258,7 +257,7 @@ def SectionsOp : OpenMP_Op<"sections", traits = [
let regions = (region SizedRegion<1>:$region);
let builders = [
- OpBuilder<(ins CArg<"const SectionsClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const SectionsOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -285,7 +284,7 @@ def SingleOp : OpenMP_Op<"single", traits = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const SingleClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const SingleOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -313,8 +312,8 @@ def LoopNestOp : OpenMP_Op<"loop_nest", traits = [
The body region can contain any number of blocks. The region is terminated
by an `omp.yield` instruction without operands. The induction variables,
represented as entry block arguments to the loop nest operation's single
- region, match the types of the `lowerBound`, `upperBound` and `step`
- arguments.
+ region, match the types of the `collapse_lower_bounds`,
+ `collapse_upper_bounds` and `collapse_steps` arguments.
```mlir
omp.loop_nest (%i1, %i2) : i32 = (%c0, %c0) to (%c10, %c10) step (%c1, %c1) {
@@ -339,7 +338,7 @@ def LoopNestOp : OpenMP_Op<"loop_nest", traits = [
let arguments = !con(clausesArgs, (ins UnitAttr:$inclusive));
let builders = [
- OpBuilder<(ins CArg<"const LoopNestClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const LoopNestOperands &">:$clauses)>
];
let extraClassDeclaration = [{
@@ -402,7 +401,7 @@ def WsloopOp : OpenMP_Op<"wsloop", traits = [
let builders = [
OpBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
- OpBuilder<(ins CArg<"const WsloopClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const WsloopOperands &">:$clauses)>
];
// TODO: Use default assembly format inherited from OpenMP_Op once printing
@@ -415,13 +414,13 @@ def WsloopOp : OpenMP_Op<"wsloop", traits = [
$linear_step_vars) `)`
|`schedule` `(`
custom<ScheduleClause>(
- $schedule_val, $schedule_modifier, $simd_modifier,
- $schedule_chunk_var, type($schedule_chunk_var)) `)`
+ $schedule_kind, $schedule_mod, $schedule_simd,
+ $schedule_chunk, type($schedule_chunk)) `)`
|`nowait` $nowait
- |`ordered` `(` $ordered_val `)`
- |`order` `(` custom<OrderClause>($order_val, $order_mod) `)`
+ |`ordered` `(` $ordered `)`
+ |`order` `(` custom<OrderClause>($order, $order_mod) `)`
) custom<Wsloop>($region, $reduction_vars, type($reduction_vars),
- $reduction_vars_byref, $reductions) attr-dict
+ $reduction_byref, $reduction_syms) attr-dict
}];
let hasVerifier = 1;
@@ -468,7 +467,7 @@ def SimdOp : OpenMP_Op<"simd", traits = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const SimdClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const SimdOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -541,7 +540,7 @@ def DistributeOp : OpenMP_Op<"distribute", traits = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const DistributeClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const DistributeOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -576,12 +575,12 @@ def TaskOp : OpenMP_Op<"task", traits = [
The `in_reduction` clause specifies that this particular task (among all the
tasks in current taskgroup, if any) participates in a reduction.
- `in_reduction_vars_byref` indicates whether each reduction variable should
+ `in_reduction_byref` indicates whether each reduction variable should
be passed by value or by reference.
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const TaskClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TaskOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -639,7 +638,7 @@ def TaskloopOp : OpenMP_Op<"taskloop", traits = [
items is present. Thus, the generated tasks are participants of a reduction
previously defined by a reduction scoping clause. In this case, accumulator
variables are specified in `in_reduction_vars`, symbols referring to
- reduction declarations in `in_reductions` and `in_reduction_vars_byref`
+ reduction declarations in `in_reduction_syms` and `in_reduction_byref`
indicate for each reduction variable whether it should be passed by value or
by reference.
@@ -654,7 +653,7 @@ def TaskloopOp : OpenMP_Op<"taskloop", traits = [
}];
let builders = [
- OpBuilder<(ins CArg<"const TaskloopClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TaskloopOperands &">:$clauses)>
];
let extraClassDeclaration = [{
@@ -688,7 +687,7 @@ def TaskgroupOp : OpenMP_Op<"taskgroup", traits = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const TaskgroupClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TaskgroupOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -965,14 +964,13 @@ def TargetDataOp: OpenMP_Op<"target_data", traits = [
to and from the offloading device when multiple target regions are using
the same data.
- The optional `if_expr` parameter specifies a boolean result of a
- conditional check. If this value is 1 or is not provided then the target
- region runs on a device, if it is 0 then the target region is executed
- on the host device.
+ The optional `if_expr` parameter specifies a boolean result of a conditional
+ check. If this value is 1 or is not provided then the target region runs on
+ a device, if it is 0 then the target region is executed on the host device.
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const TargetDataClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TargetDataOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -995,14 +993,13 @@ def TargetEnterDataOp: OpenMP_Op<"target_enter_data", traits = [
a device data environment. The target enter data directive is a
stand-alone directive.
- The optional `if_expr` parameter specifies a boolean result of a
- conditional check. If this value is 1 or is not provided then the target
- region runs on a device, if it is 0 then the target region is executed on
- the host device.
+ The optional `if_expr` parameter specifies a boolean result of a conditional
+ check. If this value is 1 or is not provided then the target region runs on
+ a device, if it is 0 then the target region is executed on the host device.
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const TargetEnterExitUpdateDataClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TargetEnterExitUpdateDataOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -1025,14 +1022,13 @@ def TargetExitDataOp: OpenMP_Op<"target_exit_data", traits = [
device data environment. The target exit data directive is
a stand-alone directive.
- The optional `if_expr` parameter specifies a boolean result of a
- conditional check. If this value is 1 or is not provided then the target
- region runs on a device, if it is 0 then the target region is executed
- on the host device.
+ The optional `if_expr` parameter specifies a boolean result of a conditional
+ check. If this value is 1 or is not provided then the target region runs on
+ a device, if it is 0 then the target region is executed on the host device.
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const TargetEnterExitUpdateDataClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TargetEnterExitUpdateDataOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -1056,10 +1052,9 @@ def TargetUpdateOp: OpenMP_Op<"target_update", traits = [
specified motion clauses. The target update construct is a stand-alone
directive.
- The optional `if_expr` parameter specifies a boolean result of a
- conditional check. If this value is 1 or is not provided then the target
- region runs on a device, if it is 0 then the target region is executed
- on the host device.
+ The optional `if_expr` parameter specifies a boolean result of a conditional
+ check. If this value is 1 or is not provided then the target region runs on
+ a device, if it is 0 then the target region is executed on the host device.
We use `MapInfoOp` to model the motion clauses and their modifiers. Even
though the spec differentiates between map-types & map-type-modifiers vs.
@@ -1070,7 +1065,7 @@ def TargetUpdateOp: OpenMP_Op<"target_update", traits = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const TargetEnterExitUpdateDataClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TargetEnterExitUpdateDataOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -1095,14 +1090,13 @@ def TargetOp : OpenMP_Op<"target", traits = [
The target construct includes a region of code which is to be executed
on a device.
- The optional `if_expr` parameter specifies a boolean result of a
- conditional check. If this value is 1 or is not provided then the target
- region runs on a device, if it is 0 then the target region is executed on the
- host device.
+ The optional `if_expr` parameter specifies a boolean result of a conditional
+ check. If this value is 1 or is not provided then the target region runs on
+ a device, if it is 0 then the target region is executed on the host device.
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const TargetClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TargetOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -1125,9 +1119,7 @@ def MasterOp : OpenMP_Op<"master", singleRegion = true> {
//===----------------------------------------------------------------------===//
// 2.17.1 critical Construct
//===----------------------------------------------------------------------===//
-def CriticalDeclareOp : OpenMP_Op<"critical.declare", traits = [
- Symbol
- ], clauses = [
+def CriticalDeclareOp : OpenMP_Op<"critical.declare", clauses = [
OpenMP_CriticalNameClause, OpenMP_HintClause
]> {
let summary = "declares a named critical section.";
@@ -1136,7 +1128,7 @@ def CriticalDeclareOp : OpenMP_Op<"critical.declare", traits = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const CriticalClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const CriticalDeclareOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -1189,7 +1181,7 @@ def OrderedOp : OpenMP_Op<"ordered", clauses = [OpenMP_DoacrossClause]> {
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const OrderedOpClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const OrderedOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -1206,7 +1198,7 @@ def OrderedRegionOp : OpenMP_Op<"ordered.region", clauses = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const OrderedRegionClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const OrderedRegionOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -1226,7 +1218,7 @@ def TaskwaitOp : OpenMP_Op<"taskwait", clauses = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const TaskwaitClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const TaskwaitOperands &">:$clauses)>
];
// TODO: Remove overriden `assemblyFormat` once a clause is added.
@@ -1264,8 +1256,8 @@ def AtomicReadOp : OpenMP_Op<"atomic.read", traits = [
// Override clause-based assemblyFormat.
let assemblyFormat = [{
$v `=` $x
- oilist( `memory_order` `(` custom<ClauseAttr>($memory_order_val) `)`
- | `hint` `(` custom<SynchronizationHint>($hint_val) `)`)
+ oilist( `memory_order` `(` custom<ClauseAttr>($memory_order) `)`
+ | `hint` `(` custom<SynchronizationHint>($hint) `)`)
`:` type($x) `,` $element_type attr-dict
}];
@@ -1308,8 +1300,8 @@ def AtomicWriteOp : OpenMP_Op<"atomic.write", traits = [
// Override clause-based assemblyFormat.
let assemblyFormat = [{
$x `=` $expr
- oilist( `hint` `(` custom<SynchronizationHint>($hint_val) `)`
- | `memory_order` `(` custom<ClauseAttr>($memory_order_val) `)`)
+ oilist( `hint` `(` custom<SynchronizationHint>($hint) `)`
+ | `memory_order` `(` custom<ClauseAttr>($memory_order) `)`)
`:` type($x) `,` type($expr)
attr-dict
}];
@@ -1371,8 +1363,8 @@ def AtomicUpdateOp : OpenMP_Op<"atomic.update", traits = [
// Override clause-based assemblyFormat.
let assemblyFormat = [{
- oilist( `memory_order` `(` custom<ClauseAttr>($memory_order_val) `)`
- | `hint` `(` custom<SynchronizationHint>($hint_val) `)`)
+ oilist( `memory_order` `(` custom<ClauseAttr>($memory_order) `)`
+ | `hint` `(` custom<SynchronizationHint>($hint) `)`)
$x `:` type($x) $region attr-dict
}];
@@ -1505,7 +1497,7 @@ def CancelOp : OpenMP_Op<"cancel", clauses = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const CancelClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const CancelOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -1525,7 +1517,7 @@ def CancellationPointOp : OpenMP_Op<"cancellation_point", clauses = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const CancellationPointClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const CancellationPointOperands &">:$clauses)>
];
let hasVerifier = 1;
@@ -1605,7 +1597,7 @@ def MaskedOp : OpenMP_Op<"masked", clauses = [
}] # clausesDescription;
let builders = [
- OpBuilder<(ins CArg<"const MaskedClauseOps &">:$clauses)>
+ OpBuilder<(ins CArg<"const MaskedOperands &">:$clauses)>
];
}
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td b/mlir/include/mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td
index 385aa8b1b016a..45d30a41bd29b 100644
--- a/mlir/include/mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td
@@ -41,14 +41,14 @@ def MapClauseOwningOpInterface : OpInterface<"MapClauseOwningOpInterface"> {
let cppNamespace = "::mlir::omp";
let methods = [
- InterfaceMethod<"Get map operands", "::mlir::OperandRange", "getMapOperands",
+ InterfaceMethod<"Get map operands", "::mlir::OperandRange", "getMapVars",
(ins), [{
- return $_op.getMapOperands();
+ return $_op.getMapVars();
}]>,
InterfaceMethod<"Get mutable map operands", "::mlir::MutableOperandRange",
- "getMapOperandsMutable",
+ "getMapVarsMutable",
(ins), [{
- return $_op.getMapOperandsMutable();
+ return $_op.getMapVarsMutable();
}]>,
];
}
diff --git a/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp b/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp
index fdc4c7be1ca5c..169171ab799b7 100644
--- a/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp
+++ b/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp
@@ -366,7 +366,7 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
// Declare reductions.
// TODO: consider checking it here is already a compatible reduction
// declaration and use it instead of redeclaring.
- SmallVector<Attribute> reductionDeclSymbols;
+ SmallVector<Attribute> reductionSyms;
SmallVector<omp::DeclareReductionOp> ompReductionDecls;
auto reduce = cast<scf::ReduceOp>(parallelOp.getBody()->getTerminator());
for (int64_t i = 0, e = parallelOp.getNumReductions(); i < e; ++i) {
@@ -374,7 +374,7 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
ompReductionDecls.push_back(decl);
if (!decl)
return failure();
- reductionDeclSymbols.push_back(
+ reductionSyms.push_back(
SymbolRefAttr::get(rewriter.getContext(), decl.getSymName()));
}
@@ -445,15 +445,15 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
auto ompParallel = rewriter.create<omp::ParallelOp>(
loc,
/* if_expr = */ Value{},
- /* num_threads_var = */ numThreadsVar,
+ /* num_threads = */ numThreadsVar,
/* allocate_vars = */ llvm::SmallVector<Value>{},
- /* allocators_vars = */ llvm::SmallVector<Value>{},
+ /* allocator_vars = */ llvm::SmallVector<Value>{},
/* reduction_vars = */ llvm::SmallVector<Value>{},
- /* reduction_vars_isbyref = */ DenseBoolArrayAttr{},
- /* reductions = */ ArrayAttr{},
- /* proc_bind_val = */ omp::ClauseProcBindKindAttr{},
+ /* reduction_byref = */ DenseBoolArrayAttr{},
+ /* reduction_syms = */ ArrayAttr{},
+ /* proc_bind_kind = */ omp::ClauseProcBindKindAttr{},
/* private_vars = */ ValueRange(),
- /* privatizers = */ nullptr);
+ /* private_syms = */ nullptr);
{
OpBuilder::InsertionGuard guard(rewriter);
@@ -465,15 +465,15 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
// Create worksharing loop wrapper.
auto wsloopOp = rewriter.create<omp::WsloopOp>(parallelOp.getLoc());
if (!reductionVariables.empty()) {
- wsloopOp.setReductionsAttr(
- ArrayAttr::get(rewriter.getContext(), reductionDeclSymbols));
+ wsloopOp.setReductionSymsAttr(
+ ArrayAttr::get(rewriter.getContext(), reductionSyms));
wsloopOp.getReductionVarsMutable().append(reductionVariables);
- llvm::SmallVector<bool> byRefVec;
+ llvm::SmallVector<bool> reductionByRef;
// false because these reductions always reduce scalars and so do
// not need to pass by reference
- byRefVec.resize(reductionVariables.size(), false);
- wsloopOp.setReductionVarsByref(
- DenseBoolArrayAttr::get(rewriter.getContext(), byRefVec));
+ reductionByRef.resize(reductionVariables.size(), false);
+ wsloopOp.setReductionByref(
+ DenseBoolArrayAttr::get(rewriter.getContext(), reductionByRef));
}
rewriter.create<omp::TerminatorOp>(loc); // omp.parallel terminator.
diff --git a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
index f5ec5a476ad8f..18a1c2a1bd587 100644
--- a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
+++ b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
@@ -117,39 +117,39 @@ void OpenMPDialect::initialize() {
/// ssa-id-and-type ::= ssa-id `:` type
static ParseResult parseAllocateAndAllocator(
OpAsmParser &parser,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operandsAllocate,
- SmallVectorImpl<Type> &typesAllocate,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operandsAllocator,
- SmallVectorImpl<Type> &typesAllocator) {
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &allocateVars,
+ SmallVectorImpl<Type> &allocateTypes,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &allocatorVars,
+ SmallVectorImpl<Type> &allocatorTypes) {
return parser.parseCommaSeparatedList([&]() {
OpAsmParser::UnresolvedOperand operand;
Type type;
if (parser.parseOperand(operand) || parser.parseColonType(type))
return failure();
- operandsAllocator.push_back(operand);
- typesAllocator.push_back(type);
+ allocatorVars.push_back(operand);
+ allocatorTypes.push_back(type);
if (parser.parseArrow())
return failure();
if (parser.parseOperand(operand) || parser.parseColonType(type))
return failure();
- operandsAllocate.push_back(operand);
- typesAllocate.push_back(type);
+ allocateVars.push_back(operand);
+ allocateTypes.push_back(type);
return success();
});
}
/// Print allocate clause
static void printAllocateAndAllocator(OpAsmPrinter &p, Operation *op,
- OperandRange varsAllocate,
- TypeRange typesAllocate,
- OperandRange varsAllocator,
- TypeRange typesAllocator) {
- for (unsigned i = 0; i < varsAllocate.size(); ++i) {
- std::string separator = i == varsAllocate.size() - 1 ? "" : ", ";
- p << varsAllocator[i] << " : " << typesAllocator[i] << " -> ";
- p << varsAllocate[i] << " : " << typesAllocate[i] << separator;
+ OperandRange allocateVars,
+ TypeRange allocateTypes,
+ OperandRange allocatorVars,
+ TypeRange allocatorTypes) {
+ for (unsigned i = 0; i < allocateVars.size(); ++i) {
+ std::string separator = i == allocateVars.size() - 1 ? "" : ", ";
+ p << allocatorVars[i] << " : " << allocatorTypes[i] << " -> ";
+ p << allocateVars[i] << " : " << allocateTypes[i] << separator;
}
}
@@ -183,11 +183,11 @@ void printClauseAttr(OpAsmPrinter &p, Operation *op, ClauseAttr attr) {
/// linear ::= `linear` `(` linear-list `)`
/// linear-list := linear-val | linear-val linear-list
/// linear-val := ssa-id-and-type `=` ssa-id-and-type
-static ParseResult
-parseLinearClause(OpAsmParser &parser,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &vars,
- SmallVectorImpl<Type> &types,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &stepVars) {
+static ParseResult parseLinearClause(
+ OpAsmParser &parser,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &linearVars,
+ SmallVectorImpl<Type> &linearTypes,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &linearStepVars) {
return parser.parseCommaSeparatedList([&]() {
OpAsmParser::UnresolvedOperand var;
Type type;
@@ -196,16 +196,16 @@ parseLinearClause(OpAsmParser &parser,
parser.parseOperand(stepVar) || parser.parseColonType(type))
return failure();
- vars.push_back(var);
- types.push_back(type);
- stepVars.push_back(stepVar);
+ linearVars.push_back(var);
+ linearTypes.push_back(type);
+ linearStepVars.push_back(stepVar);
return success();
});
}
/// Print Linear Clause
static void printLinearClause(OpAsmPrinter &p, Operation *op,
- ValueRange linearVars, TypeRange linearVarTypes,
+ ValueRange linearVars, TypeRange linearTypes,
ValueRange linearStepVars) {
size_t linearVarsSize = linearVars.size();
for (unsigned i = 0; i < linearVarsSize; ++i) {
@@ -221,12 +221,12 @@ static void printLinearClause(OpAsmPrinter &p, Operation *op,
// Verifier for Nontemporal Clause
//===----------------------------------------------------------------------===//
-static LogicalResult
-verifyNontemporalClause(Operation *op, OperandRange nontemporalVariables) {
+static LogicalResult verifyNontemporalClause(Operation *op,
+ OperandRange nontemporalVars) {
// Check if each var is unique - OpenMP 5.0 -> 2.9.3.1 section
DenseSet<Value> nontemporalItems;
- for (const auto &it : nontemporalVariables)
+ for (const auto &it : nontemporalVars)
if (!nontemporalItems.insert(it).second)
return op->emitOpError() << "nontemporal variable used more than once";
@@ -236,32 +236,32 @@ verifyNontemporalClause(Operation *op, OperandRange nontemporalVariables) {
//===----------------------------------------------------------------------===//
// Parser, verifier and printer for Aligned Clause
//===----------------------------------------------------------------------===//
-static LogicalResult
-verifyAlignedClause(Operation *op, std::optional<ArrayAttr> alignmentValues,
- OperandRange alignedVariables) {
+static LogicalResult verifyAlignedClause(Operation *op,
+ std::optional<ArrayAttr> alignments,
+ OperandRange alignedVars) {
// Check if number of alignment values equals to number of aligned variables
- if (!alignedVariables.empty()) {
- if (!alignmentValues || alignmentValues->size() != alignedVariables.size())
+ if (!alignedVars.empty()) {
+ if (!alignments || alignments->size() != alignedVars.size())
return op->emitOpError()
<< "expected as many alignment values as aligned variables";
} else {
- if (alignmentValues)
+ if (alignments)
return op->emitOpError() << "unexpected alignment values attribute";
return success();
}
// Check if each var is aligned only once - OpenMP 4.5 -> 2.8.1 section
DenseSet<Value> alignedItems;
- for (auto it : alignedVariables)
+ for (auto it : alignedVars)
if (!alignedItems.insert(it).second)
return op->emitOpError() << "aligned variable used more than once";
- if (!alignmentValues)
+ if (!alignments)
return success();
// Check if all alignment values are positive - OpenMP 4.5 -> 2.8.1 section
- for (unsigned i = 0; i < (*alignmentValues).size(); ++i) {
- if (auto intAttr = llvm::dyn_cast<IntegerAttr>((*alignmentValues)[i])) {
+ for (unsigned i = 0; i < (*alignments).size(); ++i) {
+ if (auto intAttr = llvm::dyn_cast<IntegerAttr>((*alignments)[i])) {
if (intAttr.getValue().sle(0))
return op->emitOpError() << "alignment should be greater than 0";
} else {
@@ -275,14 +275,15 @@ verifyAlignedClause(Operation *op, std::optional<ArrayAttr> alignmentValues,
/// aligned ::= `aligned` `(` aligned-list `)`
/// aligned-list := aligned-val | aligned-val aligned-list
/// aligned-val := ssa-id-and-type `->` alignment
-static ParseResult parseAlignedClause(
- OpAsmParser &parser,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &alignedItems,
- SmallVectorImpl<Type> &types, ArrayAttr &alignmentValues) {
+static ParseResult
+parseAlignedClause(OpAsmParser &parser,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &alignedVars,
+ SmallVectorImpl<Type> &alignedTypes,
+ ArrayAttr &alignmentsAttr) {
SmallVector<Attribute> alignmentVec;
if (failed(parser.parseCommaSeparatedList([&]() {
- if (parser.parseOperand(alignedItems.emplace_back()) ||
- parser.parseColonType(types.emplace_back()) ||
+ if (parser.parseOperand(alignedVars.emplace_back()) ||
+ parser.parseColonType(alignedTypes.emplace_back()) ||
parser.parseArrow() ||
parser.parseAttribute(alignmentVec.emplace_back())) {
return failure();
@@ -291,20 +292,19 @@ static ParseResult parseAlignedClause(
})))
return failure();
SmallVector<Attribute> alignments(alignmentVec.begin(), alignmentVec.end());
- alignmentValues = ArrayAttr::get(parser.getContext(), alignments);
+ alignmentsAttr = ArrayAttr::get(parser.getContext(), alignments);
return success();
}
/// Print Aligned Clause
static void printAlignedClause(OpAsmPrinter &p, Operation *op,
- ValueRange alignedVars,
- TypeRange alignedVarTypes,
- std::optional<ArrayAttr> alignmentValues) {
+ ValueRange alignedVars, TypeRange alignedTypes,
+ std::optional<ArrayAttr> alignments) {
for (unsigned i = 0; i < alignedVars.size(); ++i) {
if (i != 0)
p << ", ";
p << alignedVars[i] << " : " << alignedVars[i].getType();
- p << " -> " << (*alignmentValues)[i];
+ p << " -> " << (*alignments)[i];
}
}
@@ -353,10 +353,11 @@ verifyScheduleModifiers(OpAsmParser &parser,
/// sched-wo-chunk ::= `auto` | `runtime`
/// sched-modifier ::= sched-mod-val | sched-mod-val `,` sched-mod-val
/// sched-mod-val ::= `monotonic` | `nonmonotonic` | `simd` | `none`
-static ParseResult parseScheduleClause(
- OpAsmParser &parser, ClauseScheduleKindAttr &scheduleAttr,
- ScheduleModifierAttr &scheduleModifier, UnitAttr &simdModifier,
- std::optional<OpAsmParser::UnresolvedOperand> &chunkSize, Type &chunkType) {
+static ParseResult
+parseScheduleClause(OpAsmParser &parser, ClauseScheduleKindAttr &scheduleAttr,
+ ScheduleModifierAttr &scheduleMod, UnitAttr &scheduleSimd,
+ std::optional<OpAsmParser::UnresolvedOperand> &chunkSize,
+ Type &chunkType) {
StringRef keyword;
if (parser.parseKeyword(&keyword))
return failure();
@@ -399,14 +400,14 @@ static ParseResult parseScheduleClause(
SMLoc loc = parser.getCurrentLocation();
if (std::optional<ScheduleModifier> mod =
symbolizeScheduleModifier(modifiers[0])) {
- scheduleModifier = ScheduleModifierAttr::get(parser.getContext(), *mod);
+ scheduleMod = ScheduleModifierAttr::get(parser.getContext(), *mod);
} else {
return parser.emitError(loc, "invalid schedule modifier");
}
// Only SIMD attribute is allowed here!
if (modifiers.size() > 1) {
assert(symbolizeScheduleModifier(modifiers[1]) == ScheduleModifier::simd);
- simdModifier = UnitAttr::get(parser.getBuilder().getContext());
+ scheduleSimd = UnitAttr::get(parser.getBuilder().getContext());
}
}
@@ -415,16 +416,16 @@ static ParseResult parseScheduleClause(
/// Print schedule clause
static void printScheduleClause(OpAsmPrinter &p, Operation *op,
- ClauseScheduleKindAttr schedAttr,
- ScheduleModifierAttr modifier, UnitAttr simd,
- Value scheduleChunkVar,
+ ClauseScheduleKindAttr scheduleKind,
+ ScheduleModifierAttr scheduleMod,
+ UnitAttr scheduleSimd, Value scheduleChunk,
Type scheduleChunkType) {
- p << stringifyClauseScheduleKind(schedAttr.getValue());
- if (scheduleChunkVar)
- p << " = " << scheduleChunkVar << " : " << scheduleChunkVar.getType();
- if (modifier)
- p << ", " << stringifyScheduleModifier(modifier.getValue());
- if (simd)
+ p << stringifyClauseScheduleKind(scheduleKind.getValue());
+ if (scheduleChunk)
+ p << " = " << scheduleChunk << " : " << scheduleChunk.getType();
+ if (scheduleMod)
+ p << ", " << stringifyScheduleModifier(scheduleMod.getValue());
+ if (scheduleSimd)
p << ", simd";
}
@@ -435,15 +436,15 @@ static void printScheduleClause(OpAsmPrinter &p, Operation *op,
// order ::= `order` `(` [order-modifier ':'] concurrent `)`
// order-modifier ::= reproducible | unconstrained
static ParseResult parseOrderClause(OpAsmParser &parser,
- ClauseOrderKindAttr &kindAttr,
- OrderModifierAttr &modifierAttr) {
+ ClauseOrderKindAttr &order,
+ OrderModifierAttr &orderMod) {
StringRef enumStr;
SMLoc loc = parser.getCurrentLocation();
if (parser.parseKeyword(&enumStr))
return failure();
if (std::optional<OrderModifier> enumValue =
symbolizeOrderModifier(enumStr)) {
- modifierAttr = OrderModifierAttr::get(parser.getContext(), *enumValue);
+ orderMod = OrderModifierAttr::get(parser.getContext(), *enumValue);
if (parser.parseOptionalColon())
return failure();
loc = parser.getCurrentLocation();
@@ -452,19 +453,19 @@ static ParseResult parseOrderClause(OpAsmParser &parser,
}
if (std::optional<ClauseOrderKind> enumValue =
symbolizeClauseOrderKind(enumStr)) {
- kindAttr = ClauseOrderKindAttr::get(parser.getContext(), *enumValue);
+ order = ClauseOrderKindAttr::get(parser.getContext(), *enumValue);
return success();
}
return parser.emitError(loc, "invalid clause value: '") << enumStr << "'";
}
static void printOrderClause(OpAsmPrinter &p, Operation *op,
- ClauseOrderKindAttr kindAttr,
- OrderModifierAttr modifierAttr) {
- if (modifierAttr)
- p << stringifyOrderModifier(modifierAttr.getValue()) << ":";
- if (kindAttr)
- p << stringifyClauseOrderKind(kindAttr.getValue());
+ ClauseOrderKindAttr order,
+ OrderModifierAttr orderMod) {
+ if (orderMod)
+ p << stringifyOrderModifier(orderMod.getValue()) << ":";
+ if (order)
+ p << stringifyClauseOrderKind(order.getValue());
}
//===----------------------------------------------------------------------===//
@@ -474,8 +475,7 @@ static void printOrderClause(OpAsmPrinter &p, Operation *op,
static ParseResult parseClauseWithRegionArgs(
OpAsmParser &parser, Region ®ion,
SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
- SmallVectorImpl<Type> &types, DenseBoolArrayAttr &isByRef,
- ArrayAttr &symbols,
+ SmallVectorImpl<Type> &types, DenseBoolArrayAttr &byref, ArrayAttr &symbols,
SmallVectorImpl<OpAsmParser::Argument> ®ionPrivateArgs) {
SmallVector<SymbolRefAttr> reductionVec;
SmallVector<bool> isByRefVec;
@@ -494,7 +494,7 @@ static ParseResult parseClauseWithRegionArgs(
return success();
})))
return failure();
- isByRef = makeDenseBoolArrayAttr(parser.getContext(), isByRefVec);
+ byref = makeDenseBoolArrayAttr(parser.getContext(), isByRefVec);
auto *argsBegin = regionPrivateArgs.begin();
MutableArrayRef argsSubrange(argsBegin + regionArgOffset,
@@ -510,13 +510,13 @@ static ParseResult parseClauseWithRegionArgs(
static void printClauseWithRegionArgs(OpAsmPrinter &p, Operation *op,
ValueRange argsSubrange,
StringRef clauseName, ValueRange operands,
- TypeRange types, DenseBoolArrayAttr byRef,
+ TypeRange types, DenseBoolArrayAttr byref,
ArrayAttr symbols) {
if (!clauseName.empty())
p << clauseName << "(";
llvm::interleaveComma(llvm::zip_equal(symbols, operands, argsSubrange, types,
- byRef.asArrayRef()),
+ byref.asArrayRef()),
p, [&p](auto t) {
auto [sym, op, arg, type, isByRef] = t;
p << (isByRef ? "byref " : "") << sym << " " << op
@@ -529,28 +529,27 @@ static void printClauseWithRegionArgs(OpAsmPrinter &p, Operation *op,
static ParseResult parseParallelRegion(
OpAsmParser &parser, Region ®ion,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &reductionVarOperands,
- SmallVectorImpl<Type> &reductionVarTypes,
- DenseBoolArrayAttr &reductionByRef, ArrayAttr &reductionSymbols,
- llvm::SmallVectorImpl<OpAsmParser::UnresolvedOperand> &privateVarOperands,
- llvm::SmallVectorImpl<Type> &privateVarsTypes,
- ArrayAttr &privatizerSymbols) {
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &reductionVars,
+ SmallVectorImpl<Type> &reductionTypes, DenseBoolArrayAttr &reductionByref,
+ ArrayAttr &reductionSyms,
+ llvm::SmallVectorImpl<OpAsmParser::UnresolvedOperand> &privateVars,
+ llvm::SmallVectorImpl<Type> &privateTypes, ArrayAttr &privateSyms) {
llvm::SmallVector<OpAsmParser::Argument> regionPrivateArgs;
if (succeeded(parser.parseOptionalKeyword("reduction"))) {
- if (failed(parseClauseWithRegionArgs(parser, region, reductionVarOperands,
- reductionVarTypes, reductionByRef,
- reductionSymbols, regionPrivateArgs)))
+ if (failed(parseClauseWithRegionArgs(parser, region, reductionVars,
+ reductionTypes, reductionByref,
+ reductionSyms, regionPrivateArgs)))
return failure();
}
if (succeeded(parser.parseOptionalKeyword("private"))) {
- auto privateByRef = DenseBoolArrayAttr::get(parser.getContext(), {});
- if (failed(parseClauseWithRegionArgs(parser, region, privateVarOperands,
- privateVarsTypes, privateByRef,
- privatizerSymbols, regionPrivateArgs)))
+ auto privateByref = DenseBoolArrayAttr::get(parser.getContext(), {});
+ if (failed(parseClauseWithRegionArgs(parser, region, privateVars,
+ privateTypes, privateByref,
+ privateSyms, regionPrivateArgs)))
return failure();
- if (llvm::any_of(privateByRef.asArrayRef(),
+ if (llvm::any_of(privateByref.asArrayRef(),
[](bool byref) { return byref; })) {
parser.emitError(parser.getCurrentLocation(),
"private clause cannot have byref attributes");
@@ -562,35 +561,30 @@ static ParseResult parseParallelRegion(
}
static void printParallelRegion(OpAsmPrinter &p, Operation *op, Region ®ion,
- ValueRange reductionVarOperands,
- TypeRange reductionVarTypes,
- DenseBoolArrayAttr reductionVarIsByRef,
- ArrayAttr reductionSymbols,
- ValueRange privateVarOperands,
- TypeRange privateVarTypes,
- ArrayAttr privatizerSymbols) {
- if (reductionSymbols) {
+ ValueRange reductionVars,
+ TypeRange reductionTypes,
+ DenseBoolArrayAttr reductionByref,
+ ArrayAttr reductionSyms, ValueRange privateVars,
+ TypeRange privateTypes, ArrayAttr privateSyms) {
+ if (reductionSyms) {
auto *argsBegin = region.front().getArguments().begin();
- MutableArrayRef argsSubrange(argsBegin,
- argsBegin + reductionVarTypes.size());
- printClauseWithRegionArgs(p, op, argsSubrange, "reduction",
- reductionVarOperands, reductionVarTypes,
- reductionVarIsByRef, reductionSymbols);
+ MutableArrayRef argsSubrange(argsBegin, argsBegin + reductionTypes.size());
+ printClauseWithRegionArgs(p, op, argsSubrange, "reduction", reductionVars,
+ reductionTypes, reductionByref, reductionSyms);
}
- if (privatizerSymbols) {
+ if (privateSyms) {
auto *argsBegin = region.front().getArguments().begin();
- MutableArrayRef argsSubrange(argsBegin + reductionVarOperands.size(),
- argsBegin + reductionVarOperands.size() +
- privateVarTypes.size());
+ MutableArrayRef argsSubrange(argsBegin + reductionVars.size(),
+ argsBegin + reductionVars.size() +
+ privateTypes.size());
mlir::SmallVector<bool> isByRefVec;
- isByRefVec.resize(privateVarTypes.size(), false);
+ isByRefVec.resize(privateTypes.size(), false);
DenseBoolArrayAttr isByRef =
makeDenseBoolArrayAttr(op->getContext(), isByRefVec);
- printClauseWithRegionArgs(p, op, argsSubrange, "private",
- privateVarOperands, privateVarTypes, isByRef,
- privatizerSymbols);
+ printClauseWithRegionArgs(p, op, argsSubrange, "private", privateVars,
+ privateTypes, isByRef, privateSyms);
}
p.printRegion(region, /*printEntryBlockArgs=*/false);
@@ -599,41 +593,41 @@ static void printParallelRegion(OpAsmPrinter &p, Operation *op, Region ®ion,
/// reduction-entry-list ::= reduction-entry
/// | reduction-entry-list `,` reduction-entry
/// reduction-entry ::= (`byref`)? symbol-ref `->` ssa-id `:` type
-static ParseResult
-parseReductionVarList(OpAsmParser &parser,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
- SmallVectorImpl<Type> &types, DenseBoolArrayAttr &isByRef,
- ArrayAttr &reductionSymbols) {
+static ParseResult parseReductionVarList(
+ OpAsmParser &parser,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &reductionVars,
+ SmallVectorImpl<Type> &reductionTypes, DenseBoolArrayAttr &reductionByref,
+ ArrayAttr &reductionSyms) {
SmallVector<SymbolRefAttr> reductionVec;
SmallVector<bool> isByRefVec;
if (failed(parser.parseCommaSeparatedList([&]() {
ParseResult optionalByref = parser.parseOptionalKeyword("byref");
if (parser.parseAttribute(reductionVec.emplace_back()) ||
parser.parseArrow() ||
- parser.parseOperand(operands.emplace_back()) ||
- parser.parseColonType(types.emplace_back()))
+ parser.parseOperand(reductionVars.emplace_back()) ||
+ parser.parseColonType(reductionTypes.emplace_back()))
return failure();
isByRefVec.push_back(optionalByref.succeeded());
return success();
})))
return failure();
- isByRef = makeDenseBoolArrayAttr(parser.getContext(), isByRefVec);
+ reductionByref = makeDenseBoolArrayAttr(parser.getContext(), isByRefVec);
SmallVector<Attribute> reductions(reductionVec.begin(), reductionVec.end());
- reductionSymbols = ArrayAttr::get(parser.getContext(), reductions);
+ reductionSyms = ArrayAttr::get(parser.getContext(), reductions);
return success();
}
/// Print Reduction clause
-static void printReductionVarList(OpAsmPrinter &p, Operation *op,
- OperandRange reductionVars,
- TypeRange reductionTypes,
- std::optional<DenseBoolArrayAttr> isByRef,
- std::optional<ArrayAttr> reductions) {
+static void
+printReductionVarList(OpAsmPrinter &p, Operation *op,
+ OperandRange reductionVars, TypeRange reductionTypes,
+ std::optional<DenseBoolArrayAttr> reductionByref,
+ std::optional<ArrayAttr> reductionSyms) {
auto getByRef = [&](unsigned i) -> const char * {
- if (!isByRef || !*isByRef)
+ if (!reductionByref || !*reductionByref)
return "";
- assert(isByRef->empty() || i < isByRef->size());
- if (!isByRef->empty() && (*isByRef)[i])
+ assert(reductionByref->empty() || i < reductionByref->size());
+ if (!reductionByref->empty() && (*reductionByref)[i])
return "byref ";
return "";
};
@@ -641,26 +635,26 @@ static void printReductionVarList(OpAsmPrinter &p, Operation *op,
for (unsigned i = 0, e = reductionVars.size(); i < e; ++i) {
if (i != 0)
p << ", ";
- p << getByRef(i) << (*reductions)[i] << " -> " << reductionVars[i] << " : "
- << reductionVars[i].getType();
+ p << getByRef(i) << (*reductionSyms)[i] << " -> " << reductionVars[i]
+ << " : " << reductionVars[i].getType();
}
}
/// Verifies Reduction Clause
static LogicalResult
-verifyReductionVarList(Operation *op, std::optional<ArrayAttr> reductions,
+verifyReductionVarList(Operation *op, std::optional<ArrayAttr> reductionSyms,
OperandRange reductionVars,
- std::optional<ArrayRef<bool>> byRef) {
+ std::optional<ArrayRef<bool>> reductionByref) {
if (!reductionVars.empty()) {
- if (!reductions || reductions->size() != reductionVars.size())
+ if (!reductionSyms || reductionSyms->size() != reductionVars.size())
return op->emitOpError()
<< "expected as many reduction symbol references "
"as reduction variables";
- if (byRef && byRef->size() != reductionVars.size())
+ if (reductionByref && reductionByref->size() != reductionVars.size())
return op->emitError() << "expected as many reduction variable by "
"reference attributes as reduction variables";
} else {
- if (reductions)
+ if (reductionSyms)
return op->emitOpError() << "unexpected reduction symbol references";
return success();
}
@@ -668,7 +662,7 @@ verifyReductionVarList(Operation *op, std::optional<ArrayAttr> reductions,
// TODO: The followings should be done in
// SymbolUserOpInterface::verifySymbolUses.
DenseSet<Value> accumulators;
- for (auto args : llvm::zip(reductionVars, *reductions)) {
+ for (auto args : llvm::zip(reductionVars, *reductionSyms)) {
Value accum = std::get<0>(args);
if (!accumulators.insert(accum).second)
@@ -693,41 +687,40 @@ verifyReductionVarList(Operation *op, std::optional<ArrayAttr> reductions,
}
//===----------------------------------------------------------------------===//
-// Parser, printer and verifier for CopyPrivateVarList
+// Parser, printer and verifier for Copyprivate
//===----------------------------------------------------------------------===//
/// copyprivate-entry-list ::= copyprivate-entry
/// | copyprivate-entry-list `,` copyprivate-entry
/// copyprivate-entry ::= ssa-id `->` symbol-ref `:` type
-static ParseResult parseCopyPrivateVarList(
+static ParseResult parseCopyprivate(
OpAsmParser &parser,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
- SmallVectorImpl<Type> &types, ArrayAttr ©PrivateSymbols) {
- SmallVector<SymbolRefAttr> copyPrivateFuncsVec;
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> ©privateVars,
+ SmallVectorImpl<Type> ©privateTypes, ArrayAttr ©privateSyms) {
+ SmallVector<SymbolRefAttr> symsVec;
if (failed(parser.parseCommaSeparatedList([&]() {
- if (parser.parseOperand(operands.emplace_back()) ||
+ if (parser.parseOperand(copyprivateVars.emplace_back()) ||
parser.parseArrow() ||
- parser.parseAttribute(copyPrivateFuncsVec.emplace_back()) ||
- parser.parseColonType(types.emplace_back()))
+ parser.parseAttribute(symsVec.emplace_back()) ||
+ parser.parseColonType(copyprivateTypes.emplace_back()))
return failure();
return success();
})))
return failure();
- SmallVector<Attribute> copyPrivateFuncs(copyPrivateFuncsVec.begin(),
- copyPrivateFuncsVec.end());
- copyPrivateSymbols = ArrayAttr::get(parser.getContext(), copyPrivateFuncs);
+ SmallVector<Attribute> syms(symsVec.begin(), symsVec.end());
+ copyprivateSyms = ArrayAttr::get(parser.getContext(), syms);
return success();
}
-/// Print CopyPrivate clause
-static void printCopyPrivateVarList(OpAsmPrinter &p, Operation *op,
- OperandRange copyPrivateVars,
- TypeRange copyPrivateTypes,
- std::optional<ArrayAttr> copyPrivateFuncs) {
- if (!copyPrivateFuncs.has_value())
+/// Print Copyprivate clause
+static void printCopyprivate(OpAsmPrinter &p, Operation *op,
+ OperandRange copyprivateVars,
+ TypeRange copyprivateTypes,
+ std::optional<ArrayAttr> copyprivateSyms) {
+ if (!copyprivateSyms.has_value())
return;
llvm::interleaveComma(
- llvm::zip(copyPrivateVars, *copyPrivateFuncs, copyPrivateTypes), p,
+ llvm::zip(copyprivateVars, *copyprivateSyms, copyprivateTypes), p,
[&](const auto &args) {
p << std::get<0>(args) << " -> " << std::get<1>(args) << " : "
<< std::get<2>(args);
@@ -736,22 +729,22 @@ static void printCopyPrivateVarList(OpAsmPrinter &p, Operation *op,
/// Verifies CopyPrivate Clause
static LogicalResult
-verifyCopyPrivateVarList(Operation *op, OperandRange copyPrivateVars,
- std::optional<ArrayAttr> copyPrivateFuncs) {
- size_t copyPrivateFuncsSize =
- copyPrivateFuncs.has_value() ? copyPrivateFuncs->size() : 0;
- if (copyPrivateFuncsSize != copyPrivateVars.size())
- return op->emitOpError() << "inconsistent number of copyPrivate vars (= "
- << copyPrivateVars.size()
- << ") and functions (= " << copyPrivateFuncsSize
+verifyCopyprivateVarList(Operation *op, OperandRange copyprivateVars,
+ std::optional<ArrayAttr> copyprivateSyms) {
+ size_t copyprivateSymsSize =
+ copyprivateSyms.has_value() ? copyprivateSyms->size() : 0;
+ if (copyprivateSymsSize != copyprivateVars.size())
+ return op->emitOpError() << "inconsistent number of copyprivate vars (= "
+ << copyprivateVars.size()
+ << ") and functions (= " << copyprivateSymsSize
<< "), both must be equal";
- if (!copyPrivateFuncs.has_value())
+ if (!copyprivateSyms.has_value())
return success();
- for (auto copyPrivateVarAndFunc :
- llvm::zip(copyPrivateVars, *copyPrivateFuncs)) {
+ for (auto copyprivateVarAndSym :
+ llvm::zip(copyprivateVars, *copyprivateSyms)) {
auto symbolRef =
- llvm::cast<SymbolRefAttr>(std::get<1>(copyPrivateVarAndFunc));
+ llvm::cast<SymbolRefAttr>(std::get<1>(copyprivateVarAndSym));
std::optional<std::variant<mlir::func::FuncOp, mlir::LLVM::LLVMFuncOp>>
funcOp;
if (mlir::func::FuncOp mlirFuncOp =
@@ -785,7 +778,7 @@ verifyCopyPrivateVarList(Operation *op, OperandRange copyPrivateVars,
return op->emitOpError() << "expected copy function " << symbolRef
<< " arguments to have the same type";
- Type varType = std::get<0>(copyPrivateVarAndFunc).getType();
+ Type varType = std::get<0>(copyprivateVarAndSym).getType();
if (argTy != varType)
return op->emitOpError()
<< "expected copy function arguments' type (" << argTy
@@ -805,39 +798,39 @@ verifyCopyPrivateVarList(Operation *op, OperandRange copyPrivateVars,
/// depend-entry ::= depend-kind `->` ssa-id `:` type
static ParseResult
parseDependVarList(OpAsmParser &parser,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands,
- SmallVectorImpl<Type> &types, ArrayAttr &dependsArray) {
- SmallVector<ClauseTaskDependAttr> dependVec;
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &dependVars,
+ SmallVectorImpl<Type> &dependTypes, ArrayAttr &dependKinds) {
+ SmallVector<ClauseTaskDependAttr> kindsVec;
if (failed(parser.parseCommaSeparatedList([&]() {
StringRef keyword;
if (parser.parseKeyword(&keyword) || parser.parseArrow() ||
- parser.parseOperand(operands.emplace_back()) ||
- parser.parseColonType(types.emplace_back()))
+ parser.parseOperand(dependVars.emplace_back()) ||
+ parser.parseColonType(dependTypes.emplace_back()))
return failure();
if (std::optional<ClauseTaskDepend> keywordDepend =
(symbolizeClauseTaskDepend(keyword)))
- dependVec.emplace_back(
+ kindsVec.emplace_back(
ClauseTaskDependAttr::get(parser.getContext(), *keywordDepend));
else
return failure();
return success();
})))
return failure();
- SmallVector<Attribute> depends(dependVec.begin(), dependVec.end());
- dependsArray = ArrayAttr::get(parser.getContext(), depends);
+ SmallVector<Attribute> kinds(kindsVec.begin(), kindsVec.end());
+ dependKinds = ArrayAttr::get(parser.getContext(), kinds);
return success();
}
/// Print Depend clause
static void printDependVarList(OpAsmPrinter &p, Operation *op,
OperandRange dependVars, TypeRange dependTypes,
- std::optional<ArrayAttr> depends) {
+ std::optional<ArrayAttr> dependKinds) {
- for (unsigned i = 0, e = depends->size(); i < e; ++i) {
+ for (unsigned i = 0, e = dependKinds->size(); i < e; ++i) {
if (i != 0)
p << ", ";
p << stringifyClauseTaskDepend(
- llvm::cast<mlir::omp::ClauseTaskDependAttr>((*depends)[i])
+ llvm::cast<mlir::omp::ClauseTaskDependAttr>((*dependKinds)[i])
.getValue())
<< " -> " << dependVars[i] << " : " << dependTypes[i];
}
@@ -845,14 +838,14 @@ static void printDependVarList(OpAsmPrinter &p, Operation *op,
/// Verifies Depend clause
static LogicalResult verifyDependVarList(Operation *op,
- std::optional<ArrayAttr> depends,
+ std::optional<ArrayAttr> dependKinds,
OperandRange dependVars) {
if (!dependVars.empty()) {
- if (!depends || depends->size() != dependVars.size())
+ if (!dependKinds || dependKinds->size() != dependVars.size())
return op->emitOpError() << "expected as many depend values"
" as depend variables";
} else {
- if (depends && !depends->empty())
+ if (dependKinds && !dependKinds->empty())
return op->emitOpError() << "unexpected depend values";
return success();
}
@@ -1144,8 +1137,8 @@ static void printMembersIndex(OpAsmPrinter &p, MapInfoOp op,
static ParseResult
parseMapEntries(OpAsmParser &parser,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &mapOperands,
- SmallVectorImpl<Type> &mapOperandTypes) {
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &mapVars,
+ SmallVectorImpl<Type> &mapTypes) {
OpAsmParser::UnresolvedOperand arg;
OpAsmParser::UnresolvedOperand blockArg;
Type argType;
@@ -1154,14 +1147,14 @@ parseMapEntries(OpAsmParser &parser,
return failure();
if (succeeded(parser.parseOptionalArrow()) && parser.parseOperand(blockArg))
return failure();
- mapOperands.push_back(arg);
+ mapVars.push_back(arg);
return success();
};
auto parseTypes = [&]() -> ParseResult {
if (parser.parseType(argType))
return failure();
- mapOperandTypes.push_back(argType);
+ mapTypes.push_back(argType);
return success();
};
@@ -1178,48 +1171,47 @@ parseMapEntries(OpAsmParser &parser,
}
static void printMapEntries(OpAsmPrinter &p, Operation *op,
- OperandRange mapOperands,
- TypeRange mapOperandTypes) {
+ OperandRange mapVars, TypeRange mapTypes) {
// Get pointer to the region if this is an omp.target, because printing map
// clauses for that operation has to also show the correspondence of each
// variable to the corresponding block argument.
Block *entryBlock = isa<TargetOp>(op) ? &op->getRegion(0).front() : nullptr;
unsigned argIndex = 0;
- for (const auto &mapOp : mapOperands) {
+ for (const auto &mapOp : mapVars) {
p << mapOp;
if (entryBlock) {
const auto &blockArg = entryBlock->getArgument(argIndex);
p << " -> " << blockArg;
}
argIndex++;
- if (argIndex < mapOperands.size())
+ if (argIndex < mapVars.size())
p << ", ";
}
p << " : ";
argIndex = 0;
- for (const auto &mapType : mapOperandTypes) {
+ for (const auto &mapType : mapTypes) {
p << mapType;
argIndex++;
- if (argIndex < mapOperands.size())
+ if (argIndex < mapVars.size())
p << ", ";
}
}
-static ParseResult parsePrivateList(
- OpAsmParser &parser,
- SmallVectorImpl<OpAsmParser::UnresolvedOperand> &privateOperands,
- SmallVectorImpl<Type> &privateOperandTypes, ArrayAttr &privatizerSymbols) {
+static ParseResult
+parsePrivateList(OpAsmParser &parser,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &privateVars,
+ SmallVectorImpl<Type> &privateTypes, ArrayAttr &privateSyms) {
SmallVector<SymbolRefAttr> privateSymRefs;
SmallVector<OpAsmParser::Argument> regionPrivateArgs;
if (failed(parser.parseCommaSeparatedList([&]() {
if (parser.parseAttribute(privateSymRefs.emplace_back()) ||
- parser.parseOperand(privateOperands.emplace_back()) ||
+ parser.parseOperand(privateVars.emplace_back()) ||
parser.parseArrow() ||
parser.parseArgument(regionPrivateArgs.emplace_back()) ||
- parser.parseColonType(privateOperandTypes.emplace_back()))
+ parser.parseColonType(privateTypes.emplace_back()))
return failure();
return success();
})))
@@ -1227,32 +1219,31 @@ static ParseResult parsePrivateList(
SmallVector<Attribute> privateSymAttrs(privateSymRefs.begin(),
privateSymRefs.end());
- privatizerSymbols = ArrayAttr::get(parser.getContext(), privateSymAttrs);
+ privateSyms = ArrayAttr::get(parser.getContext(), privateSymAttrs);
return success();
}
static void printPrivateList(OpAsmPrinter &p, Operation *op,
- ValueRange privateVarOperands,
- TypeRange privateVarTypes,
- ArrayAttr privatizerSymbols) {
+ ValueRange privateVars, TypeRange privateTypes,
+ ArrayAttr privateSyms) {
// TODO: Remove target-specific logic from this function.
auto targetOp = mlir::dyn_cast<mlir::omp::TargetOp>(op);
assert(targetOp);
auto ®ion = op->getRegion(0);
auto *argsBegin = region.front().getArguments().begin();
- MutableArrayRef argsSubrange(argsBegin + targetOp.getMapOperands().size(),
- argsBegin + targetOp.getMapOperands().size() +
- privateVarTypes.size());
+ MutableArrayRef argsSubrange(argsBegin + targetOp.getMapVars().size(),
+ argsBegin + targetOp.getMapVars().size() +
+ privateTypes.size());
mlir::SmallVector<bool> isByRefVec;
- isByRefVec.resize(privateVarTypes.size(), false);
+ isByRefVec.resize(privateTypes.size(), false);
DenseBoolArrayAttr isByRef =
DenseBoolArrayAttr::get(op->getContext(), isByRefVec);
- printClauseWithRegionArgs(
- p, op, argsSubrange, /*clauseName=*/llvm::StringRef{}, privateVarOperands,
- privateVarTypes, isByRef, privatizerSymbols);
+ printClauseWithRegionArgs(p, op, argsSubrange,
+ /*clauseName=*/llvm::StringRef{}, privateVars,
+ privateTypes, isByRef, privateSyms);
}
static void printCaptureType(OpAsmPrinter &p, Operation *op,
@@ -1271,32 +1262,32 @@ static void printCaptureType(OpAsmPrinter &p, Operation *op,
}
static ParseResult parseCaptureType(OpAsmParser &parser,
- VariableCaptureKindAttr &mapCapture) {
+ VariableCaptureKindAttr &mapCaptureType) {
StringRef mapCaptureKey;
if (parser.parseKeyword(&mapCaptureKey))
return failure();
if (mapCaptureKey == "This")
- mapCapture = mlir::omp::VariableCaptureKindAttr::get(
+ mapCaptureType = mlir::omp::VariableCaptureKindAttr::get(
parser.getContext(), mlir::omp::VariableCaptureKind::This);
if (mapCaptureKey == "ByRef")
- mapCapture = mlir::omp::VariableCaptureKindAttr::get(
+ mapCaptureType = mlir::omp::VariableCaptureKindAttr::get(
parser.getContext(), mlir::omp::VariableCaptureKind::ByRef);
if (mapCaptureKey == "ByCopy")
- mapCapture = mlir::omp::VariableCaptureKindAttr::get(
+ mapCaptureType = mlir::omp::VariableCaptureKindAttr::get(
parser.getContext(), mlir::omp::VariableCaptureKind::ByCopy);
if (mapCaptureKey == "VLAType")
- mapCapture = mlir::omp::VariableCaptureKindAttr::get(
+ mapCaptureType = mlir::omp::VariableCaptureKindAttr::get(
parser.getContext(), mlir::omp::VariableCaptureKind::VLAType);
return success();
}
-static LogicalResult verifyMapClause(Operation *op, OperandRange mapOperands) {
+static LogicalResult verifyMapClause(Operation *op, OperandRange mapVars) {
llvm::DenseSet<mlir::TypedValue<mlir::omp::PointerLikeType>> updateToVars;
llvm::DenseSet<mlir::TypedValue<mlir::omp::PointerLikeType>> updateFromVars;
- for (auto mapOp : mapOperands) {
+ for (auto mapOp : mapVars) {
if (!mapOp.getDefiningOp())
emitError(op->getLoc(), "missing map operation");
@@ -1378,19 +1369,20 @@ static LogicalResult verifyMapClause(Operation *op, OperandRange mapOperands) {
//===----------------------------------------------------------------------===//
void TargetDataOp::build(OpBuilder &builder, OperationState &state,
- const TargetDataClauseOps &clauses) {
- TargetDataOp::build(builder, state, clauses.ifVar, clauses.deviceVar,
+ const TargetDataOperands &clauses) {
+ TargetDataOp::build(builder, state, clauses.ifVar, clauses.device,
clauses.useDevicePtrVars, clauses.useDeviceAddrVars,
clauses.mapVars);
}
LogicalResult TargetDataOp::verify() {
- if (getMapOperands().empty() && getUseDevicePtr().empty() &&
- getUseDeviceAddr().empty()) {
- return ::emitError(this->getLoc(), "At least one of map, useDevicePtr, or "
- "useDeviceAddr operand must be present");
+ if (getMapVars().empty() && getUseDevicePtrVars().empty() &&
+ getUseDeviceAddrVars().empty()) {
+ return ::emitError(this->getLoc(),
+ "At least one of map, use_device_ptr_vars, or "
+ "use_device_addr_vars operand must be present");
}
- return verifyMapClause(*this, getMapOperands());
+ return verifyMapClause(*this, getMapVars());
}
//===----------------------------------------------------------------------===//
@@ -1399,40 +1391,37 @@ LogicalResult TargetDataOp::verify() {
void TargetEnterDataOp::build(
OpBuilder &builder, OperationState &state,
- const TargetEnterExitUpdateDataClauseOps &clauses) {
+ const TargetEnterExitUpdateDataOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- TargetEnterDataOp::build(builder, state, clauses.ifVar, clauses.deviceVar,
- makeArrayAttr(ctx, clauses.dependTypeAttrs),
- clauses.dependVars, clauses.nowaitAttr,
- clauses.mapVars);
+ TargetEnterDataOp::build(builder, state, clauses.ifVar, clauses.device,
+ makeArrayAttr(ctx, clauses.dependKinds),
+ clauses.dependVars, clauses.nowait, clauses.mapVars);
}
LogicalResult TargetEnterDataOp::verify() {
LogicalResult verifyDependVars =
- verifyDependVarList(*this, getDepends(), getDependVars());
+ verifyDependVarList(*this, getDependKinds(), getDependVars());
return failed(verifyDependVars) ? verifyDependVars
- : verifyMapClause(*this, getMapOperands());
+ : verifyMapClause(*this, getMapVars());
}
//===----------------------------------------------------------------------===//
// TargetExitDataOp
//===----------------------------------------------------------------------===//
-void TargetExitDataOp::build(
- OpBuilder &builder, OperationState &state,
- const TargetEnterExitUpdateDataClauseOps &clauses) {
+void TargetExitDataOp::build(OpBuilder &builder, OperationState &state,
+ const TargetEnterExitUpdateDataOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- TargetExitDataOp::build(builder, state, clauses.ifVar, clauses.deviceVar,
- makeArrayAttr(ctx, clauses.dependTypeAttrs),
- clauses.dependVars, clauses.nowaitAttr,
- clauses.mapVars);
+ TargetExitDataOp::build(builder, state, clauses.ifVar, clauses.device,
+ makeArrayAttr(ctx, clauses.dependKinds),
+ clauses.dependVars, clauses.nowait, clauses.mapVars);
}
LogicalResult TargetExitDataOp::verify() {
LogicalResult verifyDependVars =
- verifyDependVarList(*this, getDepends(), getDependVars());
+ verifyDependVarList(*this, getDependKinds(), getDependVars());
return failed(verifyDependVars) ? verifyDependVars
- : verifyMapClause(*this, getMapOperands());
+ : verifyMapClause(*this, getMapVars());
}
//===----------------------------------------------------------------------===//
@@ -1440,19 +1429,18 @@ LogicalResult TargetExitDataOp::verify() {
//===----------------------------------------------------------------------===//
void TargetUpdateOp::build(OpBuilder &builder, OperationState &state,
- const TargetEnterExitUpdateDataClauseOps &clauses) {
+ const TargetEnterExitUpdateDataOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- TargetUpdateOp::build(builder, state, clauses.ifVar, clauses.deviceVar,
- makeArrayAttr(ctx, clauses.dependTypeAttrs),
- clauses.dependVars, clauses.nowaitAttr,
- clauses.mapVars);
+ TargetUpdateOp::build(builder, state, clauses.ifVar, clauses.device,
+ makeArrayAttr(ctx, clauses.dependKinds),
+ clauses.dependVars, clauses.nowait, clauses.mapVars);
}
LogicalResult TargetUpdateOp::verify() {
LogicalResult verifyDependVars =
- verifyDependVarList(*this, getDepends(), getDependVars());
+ verifyDependVarList(*this, getDependKinds(), getDependVars());
return failed(verifyDependVars) ? verifyDependVars
- : verifyMapClause(*this, getMapOperands());
+ : verifyMapClause(*this, getMapVars());
}
//===----------------------------------------------------------------------===//
@@ -1460,24 +1448,23 @@ LogicalResult TargetUpdateOp::verify() {
//===----------------------------------------------------------------------===//
void TargetOp::build(OpBuilder &builder, OperationState &state,
- const TargetClauseOps &clauses) {
+ const TargetOperands &clauses) {
MLIRContext *ctx = builder.getContext();
// TODO Store clauses in op: allocateVars, allocatorVars, inReductionVars,
// inReduceVarByRef, inReductionDeclSymbols, reductionVars, reduceVarByRef,
// reductionDeclSymbols.
- TargetOp::build(
- builder, state, clauses.ifVar, clauses.deviceVar, clauses.threadLimitVar,
- makeArrayAttr(ctx, clauses.dependTypeAttrs), clauses.dependVars,
- clauses.nowaitAttr, clauses.isDevicePtrVars, clauses.hasDeviceAddrVars,
- clauses.mapVars, clauses.privateVars,
- makeArrayAttr(ctx, clauses.privatizers));
+ TargetOp::build(builder, state, clauses.ifVar, clauses.device,
+ clauses.threadLimit, makeArrayAttr(ctx, clauses.dependKinds),
+ clauses.dependVars, clauses.nowait, clauses.isDevicePtrVars,
+ clauses.hasDeviceAddrVars, clauses.mapVars,
+ clauses.privateVars, makeArrayAttr(ctx, clauses.privateSyms));
}
LogicalResult TargetOp::verify() {
LogicalResult verifyDependVars =
- verifyDependVarList(*this, getDepends(), getDependVars());
+ verifyDependVarList(*this, getDependKinds(), getDependVars());
return failed(verifyDependVars) ? verifyDependVars
- : verifyMapClause(*this, getMapOperands());
+ : verifyMapClause(*this, getMapVars());
}
//===----------------------------------------------------------------------===//
@@ -1487,55 +1474,52 @@ LogicalResult TargetOp::verify() {
void ParallelOp::build(OpBuilder &builder, OperationState &state,
ArrayRef<NamedAttribute> attributes) {
ParallelOp::build(
- builder, state, /*if_expr=*/nullptr, /*num_threads_var=*/nullptr,
- /*allocate_vars=*/ValueRange(), /*allocators_vars=*/ValueRange(),
- /*reduction_vars=*/ValueRange(), /*reduction_vars_byref=*/nullptr,
- /*reductions=*/nullptr, /*proc_bind_val=*/nullptr,
- /*private_vars=*/ValueRange(), /*privatizers=*/nullptr);
+ builder, state, /*if_expr=*/nullptr, /*num_threads=*/nullptr,
+ /*allocate_vars=*/ValueRange(), /*allocator_vars=*/ValueRange(),
+ /*reduction_vars=*/ValueRange(), /*reduction_byref=*/nullptr,
+ /*reduction_syms=*/nullptr, /*proc_bind_kind=*/nullptr,
+ /*private_vars=*/ValueRange(), /*private_syms=*/nullptr);
state.addAttributes(attributes);
}
void ParallelOp::build(OpBuilder &builder, OperationState &state,
- const ParallelClauseOps &clauses) {
+ const ParallelOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- ParallelOp::build(builder, state, clauses.ifVar, clauses.numThreadsVar,
- clauses.allocateVars, clauses.allocatorVars,
- clauses.reductionVars,
- makeDenseBoolArrayAttr(ctx, clauses.reductionVarsByRef),
- makeArrayAttr(ctx, clauses.reductionDeclSymbols),
- clauses.procBindKindAttr, clauses.privateVars,
- makeArrayAttr(ctx, clauses.privatizers));
+ ParallelOp::build(
+ builder, state, clauses.ifVar, clauses.numThreads, clauses.allocateVars,
+ clauses.allocatorVars, clauses.reductionVars,
+ makeDenseBoolArrayAttr(ctx, clauses.reductionByref),
+ makeArrayAttr(ctx, clauses.reductionSyms), clauses.procBindKind,
+ clauses.privateVars, makeArrayAttr(ctx, clauses.privateSyms));
}
template <typename OpType>
static LogicalResult verifyPrivateVarList(OpType &op) {
auto privateVars = op.getPrivateVars();
- auto privatizers = op.getPrivatizersAttr();
+ auto privateSyms = op.getPrivateSymsAttr();
- if (privateVars.empty() && (privatizers == nullptr || privatizers.empty()))
+ if (privateVars.empty() && (privateSyms == nullptr || privateSyms.empty()))
return success();
auto numPrivateVars = privateVars.size();
- auto numPrivatizers = (privatizers == nullptr) ? 0 : privatizers.size();
+ auto numPrivateSyms = (privateSyms == nullptr) ? 0 : privateSyms.size();
- if (numPrivateVars != numPrivatizers)
+ if (numPrivateVars != numPrivateSyms)
return op.emitError() << "inconsistent number of private variables and "
"privatizer op symbols, private vars: "
<< numPrivateVars
- << " vs. privatizer op symbols: " << numPrivatizers;
+ << " vs. privatizer op symbols: " << numPrivateSyms;
- for (auto privateVarInfo : llvm::zip_equal(privateVars, privatizers)) {
+ for (auto privateVarInfo : llvm::zip_equal(privateVars, privateSyms)) {
Type varType = std::get<0>(privateVarInfo).getType();
- SymbolRefAttr privatizerSym =
- cast<SymbolRefAttr>(std::get<1>(privateVarInfo));
+ SymbolRefAttr privateSym = cast<SymbolRefAttr>(std::get<1>(privateVarInfo));
PrivateClauseOp privatizerOp =
- SymbolTable::lookupNearestSymbolFrom<PrivateClauseOp>(op,
- privatizerSym);
+ SymbolTable::lookupNearestSymbolFrom<PrivateClauseOp>(op, privateSym);
if (privatizerOp == nullptr)
return op.emitError() << "failed to lookup privatizer op with symbol: '"
- << privatizerSym << "'";
+ << privateSym << "'";
Type privatizerType = privatizerOp.getType();
@@ -1570,15 +1554,15 @@ LogicalResult ParallelOp::verify() {
}
}
- if (getAllocateVars().size() != getAllocatorsVars().size())
+ if (getAllocateVars().size() != getAllocatorVars().size())
return emitError(
"expected equal sizes for allocate and allocator variables");
if (failed(verifyPrivateVarList(*this)))
return failure();
- return verifyReductionVarList(*this, getReductions(), getReductionVars(),
- getReductionVarsByref());
+ return verifyReductionVarList(*this, getReductionSyms(), getReductionVars(),
+ getReductionByref());
}
//===----------------------------------------------------------------------===//
@@ -1593,15 +1577,14 @@ static bool opInGlobalImplicitParallelRegion(Operation *op) {
}
void TeamsOp::build(OpBuilder &builder, OperationState &state,
- const TeamsClauseOps &clauses) {
+ const TeamsOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- // TODO Store clauses in op: privateVars, privatizers.
- TeamsOp::build(builder, state, clauses.numTeamsLowerVar,
- clauses.numTeamsUpperVar, clauses.ifVar,
- clauses.threadLimitVar, clauses.allocateVars,
+ // TODO Store clauses in op: privateVars, privateSyms.
+ TeamsOp::build(builder, state, clauses.numTeamsLower, clauses.numTeamsUpper,
+ clauses.ifVar, clauses.threadLimit, clauses.allocateVars,
clauses.allocatorVars, clauses.reductionVars,
- makeDenseBoolArrayAttr(ctx, clauses.reductionVarsByRef),
- makeArrayAttr(ctx, clauses.reductionDeclSymbols));
+ makeDenseBoolArrayAttr(ctx, clauses.reductionByref),
+ makeArrayAttr(ctx, clauses.reductionSyms));
}
LogicalResult TeamsOp::verify() {
@@ -1628,12 +1611,12 @@ LogicalResult TeamsOp::verify() {
}
// Check for allocate clause restrictions
- if (getAllocateVars().size() != getAllocatorsVars().size())
+ if (getAllocateVars().size() != getAllocatorVars().size())
return emitError(
"expected equal sizes for allocate and allocator variables");
- return verifyReductionVarList(*this, getReductions(), getReductionVars(),
- getReductionVarsByref());
+ return verifyReductionVarList(*this, getReductionSyms(), getReductionVars(),
+ getReductionByref());
}
//===----------------------------------------------------------------------===//
@@ -1641,23 +1624,23 @@ LogicalResult TeamsOp::verify() {
//===----------------------------------------------------------------------===//
void SectionsOp::build(OpBuilder &builder, OperationState &state,
- const SectionsClauseOps &clauses) {
+ const SectionsOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- // TODO Store clauses in op: privateVars, privatizers.
+ // TODO Store clauses in op: privateVars, privateSyms.
SectionsOp::build(builder, state, clauses.reductionVars,
- makeDenseBoolArrayAttr(ctx, clauses.reductionVarsByRef),
- makeArrayAttr(ctx, clauses.reductionDeclSymbols),
+ makeDenseBoolArrayAttr(ctx, clauses.reductionByref),
+ makeArrayAttr(ctx, clauses.reductionSyms),
clauses.allocateVars, clauses.allocatorVars,
- clauses.nowaitAttr);
+ clauses.nowait);
}
LogicalResult SectionsOp::verify() {
- if (getAllocateVars().size() != getAllocatorsVars().size())
+ if (getAllocateVars().size() != getAllocatorVars().size())
return emitError(
"expected equal sizes for allocate and allocator variables");
- return verifyReductionVarList(*this, getReductions(), getReductionVars(),
- getReductionVarsByref());
+ return verifyReductionVarList(*this, getReductionSyms(), getReductionVars(),
+ getReductionByref());
}
LogicalResult SectionsOp::verifyRegions() {
@@ -1676,23 +1659,22 @@ LogicalResult SectionsOp::verifyRegions() {
//===----------------------------------------------------------------------===//
void SingleOp::build(OpBuilder &builder, OperationState &state,
- const SingleClauseOps &clauses) {
+ const SingleOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- // TODO Store clauses in op: privateVars, privatizers.
+ // TODO Store clauses in op: privateVars, privateSyms.
SingleOp::build(builder, state, clauses.allocateVars, clauses.allocatorVars,
clauses.copyprivateVars,
- makeArrayAttr(ctx, clauses.copyprivateFuncs),
- clauses.nowaitAttr);
+ makeArrayAttr(ctx, clauses.copyprivateSyms), clauses.nowait);
}
LogicalResult SingleOp::verify() {
// Check for allocate clause restrictions
- if (getAllocateVars().size() != getAllocatorsVars().size())
+ if (getAllocateVars().size() != getAllocatorVars().size())
return emitError(
"expected equal sizes for allocate and allocator variables");
- return verifyCopyPrivateVarList(*this, getCopyprivateVars(),
- getCopyprivateFuncs());
+ return verifyCopyprivateVarList(*this, getCopyprivateVars(),
+ getCopyprivateSyms());
}
//===----------------------------------------------------------------------===//
@@ -1731,28 +1713,25 @@ void WsloopOp::build(OpBuilder &builder, OperationState &state,
ArrayRef<NamedAttribute> attributes) {
build(builder, state, /*linear_vars=*/ValueRange(),
/*linear_step_vars=*/ValueRange(), /*reduction_vars=*/ValueRange(),
- /*reduction_vars_byref=*/nullptr,
- /*reductions=*/nullptr, /*schedule_val=*/nullptr,
- /*schedule_chunk_var=*/nullptr, /*schedule_modifier=*/nullptr,
- /*simd_modifier=*/false, /*nowait=*/false,
- /*ordered_val=*/nullptr, /*order_val=*/nullptr,
- /*order_modifier=*/nullptr);
+ /*reduction_byref=*/nullptr, /*reduction_syms=*/nullptr,
+ /*schedule_kind=*/nullptr, /*schedule_chunk=*/nullptr,
+ /*schedule_mod=*/nullptr, /*schedule_simd=*/false, /*nowait=*/false,
+ /*ordered=*/nullptr, /*order=*/nullptr, /*order_mod=*/nullptr);
state.addAttributes(attributes);
}
void WsloopOp::build(OpBuilder &builder, OperationState &state,
- const WsloopClauseOps &clauses) {
+ const WsloopOperands &clauses) {
MLIRContext *ctx = builder.getContext();
// TODO: Store clauses in op: allocateVars, allocatorVars, privateVars,
- // privatizers.
+ // privateSyms.
WsloopOp::build(builder, state, clauses.linearVars, clauses.linearStepVars,
clauses.reductionVars,
- makeDenseBoolArrayAttr(ctx, clauses.reductionVarsByRef),
- makeArrayAttr(ctx, clauses.reductionDeclSymbols),
- clauses.scheduleValAttr, clauses.scheduleChunkVar,
- clauses.scheduleModAttr, clauses.scheduleSimdAttr,
- clauses.nowaitAttr, clauses.orderedAttr, clauses.orderAttr,
- clauses.orderModAttr);
+ makeDenseBoolArrayAttr(ctx, clauses.reductionByref),
+ makeArrayAttr(ctx, clauses.reductionSyms),
+ clauses.scheduleKind, clauses.scheduleChunk,
+ clauses.scheduleMod, clauses.scheduleSimd, clauses.nowait,
+ clauses.ordered, clauses.order, clauses.orderMod);
}
LogicalResult WsloopOp::verify() {
@@ -1766,8 +1745,8 @@ LogicalResult WsloopOp::verify() {
return emitError() << "only supported nested wrapper is 'omp.simd'";
}
- return verifyReductionVarList(*this, getReductions(), getReductionVars(),
- getReductionVarsByref());
+ return verifyReductionVarList(*this, getReductionSyms(), getReductionVars(),
+ getReductionByref());
}
//===----------------------------------------------------------------------===//
@@ -1775,14 +1754,14 @@ LogicalResult WsloopOp::verify() {
//===----------------------------------------------------------------------===//
void SimdOp::build(OpBuilder &builder, OperationState &state,
- const SimdClauseOps &clauses) {
+ const SimdOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- // TODO Store clauses in op: privateVars, privatizers, reductionVars,
+ // TODO Store clauses in op: privateVars, privateSyms, reductionVars,
// reduceVarByRef, reductionDeclSymbols.
SimdOp::build(builder, state, clauses.alignedVars,
- makeArrayAttr(ctx, clauses.alignmentAttrs), clauses.ifVar,
- clauses.nontemporalVars, clauses.orderAttr,
- clauses.orderModAttr, clauses.safelenAttr, clauses.simdlenAttr);
+ makeArrayAttr(ctx, clauses.alignments), clauses.ifVar,
+ clauses.nontemporalVars, clauses.order, clauses.orderMod,
+ clauses.safelen, clauses.simdlen);
}
LogicalResult SimdOp::verify() {
@@ -1792,8 +1771,7 @@ LogicalResult SimdOp::verify() {
<< "simdlen clause and safelen clause are both present, but the "
"simdlen value is not less than or equal to safelen value";
- if (verifyAlignedClause(*this, getAlignmentValues(), getAlignedVars())
- .failed())
+ if (verifyAlignedClause(*this, getAlignments(), getAlignedVars()).failed())
return failure();
if (verifyNontemporalClause(*this, getNontemporalVars()).failed())
@@ -1813,20 +1791,19 @@ LogicalResult SimdOp::verify() {
//===----------------------------------------------------------------------===//
void DistributeOp::build(OpBuilder &builder, OperationState &state,
- const DistributeClauseOps &clauses) {
- // TODO Store clauses in op: privateVars, privatizers.
- DistributeOp::build(builder, state, clauses.distScheduleStaticAttr,
- clauses.distScheduleChunkSizeVar, clauses.allocateVars,
- clauses.allocatorVars, clauses.orderAttr,
- clauses.orderModAttr);
+ const DistributeOperands &clauses) {
+ // TODO Store clauses in op: privateVars, privateSyms.
+ DistributeOp::build(builder, state, clauses.distScheduleStatic,
+ clauses.distScheduleChunkSize, clauses.allocateVars,
+ clauses.allocatorVars, clauses.order, clauses.orderMod);
}
LogicalResult DistributeOp::verify() {
- if (this->getChunkSize() && !this->getDistScheduleStatic())
+ if (this->getDistScheduleChunkSize() && !this->getDistScheduleStatic())
return emitOpError() << "chunk size set without "
"dist_schedule_static being present";
- if (getAllocateVars().size() != getAllocatorsVars().size())
+ if (getAllocateVars().size() != getAllocatorVars().size())
return emitError(
"expected equal sizes for allocate and allocator variables");
@@ -1942,26 +1919,25 @@ LogicalResult DeclareReductionOp::verifyRegions() {
//===----------------------------------------------------------------------===//
void TaskOp::build(OpBuilder &builder, OperationState &state,
- const TaskClauseOps &clauses) {
+ const TaskOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- // TODO Store clauses in op: privateVars, privatizers.
- TaskOp::build(
- builder, state, clauses.ifVar, clauses.finalVar, clauses.untiedAttr,
- clauses.mergeableAttr, clauses.inReductionVars,
- makeDenseBoolArrayAttr(ctx, clauses.inReductionVarsByRef),
- makeArrayAttr(ctx, clauses.inReductionDeclSymbols), clauses.priorityVar,
- makeArrayAttr(ctx, clauses.dependTypeAttrs), clauses.dependVars,
- clauses.allocateVars, clauses.allocatorVars);
+ // TODO Store clauses in op: privateVars, privateSyms.
+ TaskOp::build(builder, state, clauses.ifVar, clauses.final, clauses.untied,
+ clauses.mergeable, clauses.inReductionVars,
+ makeDenseBoolArrayAttr(ctx, clauses.inReductionByref),
+ makeArrayAttr(ctx, clauses.inReductionSyms), clauses.priority,
+ makeArrayAttr(ctx, clauses.dependKinds), clauses.dependVars,
+ clauses.allocateVars, clauses.allocatorVars);
}
LogicalResult TaskOp::verify() {
LogicalResult verifyDependVars =
- verifyDependVarList(*this, getDepends(), getDependVars());
+ verifyDependVarList(*this, getDependKinds(), getDependVars());
return failed(verifyDependVars)
? verifyDependVars
- : verifyReductionVarList(*this, getInReductions(),
+ : verifyReductionVarList(*this, getInReductionSyms(),
getInReductionVars(),
- getInReductionVarsByref());
+ getInReductionByref());
}
//===----------------------------------------------------------------------===//
@@ -1969,19 +1945,18 @@ LogicalResult TaskOp::verify() {
//===----------------------------------------------------------------------===//
void TaskgroupOp::build(OpBuilder &builder, OperationState &state,
- const TaskgroupClauseOps &clauses) {
+ const TaskgroupOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- TaskgroupOp::build(
- builder, state, clauses.taskReductionVars,
- makeDenseBoolArrayAttr(ctx, clauses.taskReductionVarsByRef),
- makeArrayAttr(ctx, clauses.taskReductionDeclSymbols),
- clauses.allocateVars, clauses.allocatorVars);
+ TaskgroupOp::build(builder, state, clauses.taskReductionVars,
+ makeDenseBoolArrayAttr(ctx, clauses.taskReductionByref),
+ makeArrayAttr(ctx, clauses.taskReductionSyms),
+ clauses.allocateVars, clauses.allocatorVars);
}
LogicalResult TaskgroupOp::verify() {
- return verifyReductionVarList(*this, getTaskReductions(),
+ return verifyReductionVarList(*this, getTaskReductionSyms(),
getTaskReductionVars(),
- getTaskReductionVarsByref());
+ getTaskReductionByref());
}
//===----------------------------------------------------------------------===//
@@ -1989,18 +1964,18 @@ LogicalResult TaskgroupOp::verify() {
//===----------------------------------------------------------------------===//
void TaskloopOp::build(OpBuilder &builder, OperationState &state,
- const TaskloopClauseOps &clauses) {
+ const TaskloopOperands &clauses) {
MLIRContext *ctx = builder.getContext();
- // TODO Store clauses in op: privateVars, privatizers.
- TaskloopOp::build(
- builder, state, clauses.ifVar, clauses.finalVar, clauses.untiedAttr,
- clauses.mergeableAttr, clauses.inReductionVars,
- makeDenseBoolArrayAttr(ctx, clauses.inReductionVarsByRef),
- makeArrayAttr(ctx, clauses.inReductionDeclSymbols), clauses.reductionVars,
- makeDenseBoolArrayAttr(ctx, clauses.reductionVarsByRef),
- makeArrayAttr(ctx, clauses.reductionDeclSymbols), clauses.priorityVar,
- clauses.allocateVars, clauses.allocatorVars, clauses.grainsizeVar,
- clauses.numTasksVar, clauses.nogroupAttr);
+ // TODO Store clauses in op: privateVars, privateSyms.
+ TaskloopOp::build(builder, state, clauses.ifVar, clauses.final,
+ clauses.untied, clauses.mergeable, clauses.inReductionVars,
+ makeDenseBoolArrayAttr(ctx, clauses.inReductionByref),
+ makeArrayAttr(ctx, clauses.inReductionSyms),
+ clauses.reductionVars,
+ makeDenseBoolArrayAttr(ctx, clauses.reductionByref),
+ makeArrayAttr(ctx, clauses.reductionSyms), clauses.priority,
+ clauses.allocateVars, clauses.allocatorVars,
+ clauses.grainsize, clauses.numTasks, clauses.nogroup);
}
SmallVector<Value> TaskloopOp::getAllReductionVars() {
@@ -2012,14 +1987,14 @@ SmallVector<Value> TaskloopOp::getAllReductionVars() {
}
LogicalResult TaskloopOp::verify() {
- if (getAllocateVars().size() != getAllocatorsVars().size())
+ if (getAllocateVars().size() != getAllocatorVars().size())
return emitError(
"expected equal sizes for allocate and allocator variables");
- if (failed(verifyReductionVarList(*this, getReductions(), getReductionVars(),
- getReductionVarsByref())) ||
- failed(verifyReductionVarList(*this, getInReductions(),
+ if (failed(verifyReductionVarList(*this, getReductionSyms(),
+ getReductionVars(), getReductionByref())) ||
+ failed(verifyReductionVarList(*this, getInReductionSyms(),
getInReductionVars(),
- getInReductionVarsByref())))
+ getInReductionByref())))
return failure();
if (!getReductionVars().empty() && getNogroup())
@@ -2031,7 +2006,7 @@ LogicalResult TaskloopOp::verify() {
"and an in_reduction clause");
}
- if (getGrainSize() && getNumTasks()) {
+ if (getGrainsize() && getNumTasks()) {
return emitError(
"the grainsize clause and num_tasks clause are mutually exclusive and "
"may not appear on the same taskloop directive");
@@ -2099,28 +2074,29 @@ ParseResult LoopNestOp::parse(OpAsmParser &parser, OperationState &result) {
void LoopNestOp::print(OpAsmPrinter &p) {
Region ®ion = getRegion();
auto args = region.getArguments();
- p << " (" << args << ") : " << args[0].getType() << " = (" << getLowerBound()
- << ") to (" << getUpperBound() << ") ";
+ p << " (" << args << ") : " << args[0].getType() << " = ("
+ << getCollapseLowerBounds() << ") to (" << getCollapseUpperBounds() << ") ";
if (getInclusive())
p << "inclusive ";
- p << "step (" << getStep() << ") ";
+ p << "step (" << getCollapseSteps() << ") ";
p.printRegion(region, /*printEntryBlockArgs=*/false);
}
void LoopNestOp::build(OpBuilder &builder, OperationState &state,
- const LoopNestClauseOps &clauses) {
- LoopNestOp::build(builder, state, clauses.loopLBVar, clauses.loopUBVar,
- clauses.loopStepVar, clauses.loopInclusiveAttr);
+ const LoopNestOperands &clauses) {
+ LoopNestOp::build(builder, state, clauses.collapseLowerBounds,
+ clauses.collapseUpperBounds, clauses.collapseSteps,
+ clauses.loopInclusive);
}
LogicalResult LoopNestOp::verify() {
- if (getLowerBound().empty())
+ if (getCollapseLowerBounds().empty())
return emitOpError() << "must represent at least one loop";
- if (getLowerBound().size() != getIVs().size())
+ if (getCollapseLowerBounds().size() != getIVs().size())
return emitOpError() << "number of range arguments and IVs do not match";
- for (auto [lb, iv] : llvm::zip_equal(getLowerBound(), getIVs())) {
+ for (auto [lb, iv] : llvm::zip_equal(getCollapseLowerBounds(), getIVs())) {
if (lb.getType() != iv.getType())
return emitOpError()
<< "range argument type does not match corresponding IV type";
@@ -2152,13 +2128,12 @@ void LoopNestOp::gatherWrappers(
//===----------------------------------------------------------------------===//
void CriticalDeclareOp::build(OpBuilder &builder, OperationState &state,
- const CriticalClauseOps &clauses) {
- CriticalDeclareOp::build(builder, state, clauses.criticalNameAttr,
- clauses.hintAttr);
+ const CriticalDeclareOperands &clauses) {
+ CriticalDeclareOp::build(builder, state, clauses.symName, clauses.hint);
}
LogicalResult CriticalDeclareOp::verify() {
- return verifySynchronizationHint(*this, getHintVal());
+ return verifySynchronizationHint(*this, getHint());
}
LogicalResult CriticalOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
@@ -2193,7 +2168,7 @@ static LogicalResult verifyOrderedParent(Operation &op) {
Operation *wrapper = loopOp->getParentOp();
if (auto wsloopOp = dyn_cast<WsloopOp>(wrapper)) {
- IntegerAttr orderedAttr = wsloopOp.getOrderedValAttr();
+ IntegerAttr orderedAttr = wsloopOp.getOrderedAttr();
if (!orderedAttr)
return op.emitOpError() << "the enclosing worksharing-loop region must "
"have an ordered clause";
@@ -2213,9 +2188,9 @@ static LogicalResult verifyOrderedParent(Operation &op) {
}
void OrderedOp::build(OpBuilder &builder, OperationState &state,
- const OrderedOpClauseOps &clauses) {
- OrderedOp::build(builder, state, clauses.doacrossDependTypeAttr,
- clauses.doacrossNumLoopsAttr, clauses.doacrossVectorVars);
+ const OrderedOperands &clauses) {
+ OrderedOp::build(builder, state, clauses.doacrossDependType,
+ clauses.doacrossNumLoops, clauses.doacrossDependVars);
}
LogicalResult OrderedOp::verify() {
@@ -2223,7 +2198,7 @@ LogicalResult OrderedOp::verify() {
return failure();
auto wrapper = (*this)->getParentOfType<WsloopOp>();
- if (!wrapper || *wrapper.getOrderedVal() != *getNumLoopsVal())
+ if (!wrapper || *wrapper.getOrdered() != *getDoacrossNumLoops())
return emitOpError() << "number of variables in depend clause does not "
<< "match number of iteration variables in the "
<< "doacross loop";
@@ -2232,13 +2207,13 @@ LogicalResult OrderedOp::verify() {
}
void OrderedRegionOp::build(OpBuilder &builder, OperationState &state,
- const OrderedRegionClauseOps &clauses) {
- OrderedRegionOp::build(builder, state, clauses.parLevelSimdAttr);
+ const OrderedRegionOperands &clauses) {
+ OrderedRegionOp::build(builder, state, clauses.parLevelSimd);
}
LogicalResult OrderedRegionOp::verify() {
// TODO: The code generation for ordered simd directive is not supported yet.
- if (getSimd())
+ if (getParLevelSimd())
return failure();
return verifyOrderedParent(**this);
@@ -2249,7 +2224,7 @@ LogicalResult OrderedRegionOp::verify() {
//===----------------------------------------------------------------------===//
void TaskwaitOp::build(OpBuilder &builder, OperationState &state,
- const TaskwaitClauseOps &clauses) {
+ const TaskwaitOperands &clauses) {
// TODO Store clauses in op: dependTypeAttrs, dependVars, nowaitAttr.
TaskwaitOp::build(builder, state);
}
@@ -2262,14 +2237,14 @@ LogicalResult AtomicReadOp::verify() {
if (verifyCommon().failed())
return mlir::failure();
- if (auto mo = getMemoryOrderVal()) {
+ if (auto mo = getMemoryOrder()) {
if (*mo == ClauseMemoryOrderKind::Acq_rel ||
*mo == ClauseMemoryOrderKind::Release) {
return emitError(
"memory-order must not be acq_rel or release for atomic reads");
}
}
- return verifySynchronizationHint(*this, getHintVal());
+ return verifySynchronizationHint(*this, getHint());
}
//===----------------------------------------------------------------------===//
@@ -2280,14 +2255,14 @@ LogicalResult AtomicWriteOp::verify() {
if (verifyCommon().failed())
return mlir::failure();
- if (auto mo = getMemoryOrderVal()) {
+ if (auto mo = getMemoryOrder()) {
if (*mo == ClauseMemoryOrderKind::Acq_rel ||
*mo == ClauseMemoryOrderKind::Acquire) {
return emitError(
"memory-order must not be acq_rel or acquire for atomic writes");
}
}
- return verifySynchronizationHint(*this, getHintVal());
+ return verifySynchronizationHint(*this, getHint());
}
//===----------------------------------------------------------------------===//
@@ -2301,9 +2276,8 @@ LogicalResult AtomicUpdateOp::canonicalize(AtomicUpdateOp op,
return success();
}
if (Value writeVal = op.getWriteOpVal()) {
- rewriter.replaceOpWithNewOp<AtomicWriteOp>(op, op.getX(), writeVal,
- op.getHintValAttr(),
- op.getMemoryOrderValAttr());
+ rewriter.replaceOpWithNewOp<AtomicWriteOp>(
+ op, op.getX(), writeVal, op.getHintAttr(), op.getMemoryOrderAttr());
return success();
}
return failure();
@@ -2313,7 +2287,7 @@ LogicalResult AtomicUpdateOp::verify() {
if (verifyCommon().failed())
return mlir::failure();
- if (auto mo = getMemoryOrderVal()) {
+ if (auto mo = getMemoryOrder()) {
if (*mo == ClauseMemoryOrderKind::Acq_rel ||
*mo == ClauseMemoryOrderKind::Acquire) {
return emitError(
@@ -2321,7 +2295,7 @@ LogicalResult AtomicUpdateOp::verify() {
}
}
- return verifySynchronizationHint(*this, getHintVal());
+ return verifySynchronizationHint(*this, getHint());
}
LogicalResult AtomicUpdateOp::verifyRegions() { return verifyRegionsCommon(); }
@@ -2349,19 +2323,19 @@ AtomicUpdateOp AtomicCaptureOp::getAtomicUpdateOp() {
}
LogicalResult AtomicCaptureOp::verify() {
- return verifySynchronizationHint(*this, getHintVal());
+ return verifySynchronizationHint(*this, getHint());
}
LogicalResult AtomicCaptureOp::verifyRegions() {
if (verifyRegionsCommon().failed())
return mlir::failure();
- if (getFirstOp()->getAttr("hint_val") || getSecondOp()->getAttr("hint_val"))
+ if (getFirstOp()->getAttr("hint") || getSecondOp()->getAttr("hint"))
return emitOpError(
"operations inside capture region must not have hint clause");
- if (getFirstOp()->getAttr("memory_order_val") ||
- getSecondOp()->getAttr("memory_order_val"))
+ if (getFirstOp()->getAttr("memory_order") ||
+ getSecondOp()->getAttr("memory_order"))
return emitOpError(
"operations inside capture region must not have memory_order clause");
return success();
@@ -2372,13 +2346,12 @@ LogicalResult AtomicCaptureOp::verifyRegions() {
//===----------------------------------------------------------------------===//
void CancelOp::build(OpBuilder &builder, OperationState &state,
- const CancelClauseOps &clauses) {
- CancelOp::build(builder, state, clauses.cancelDirectiveNameAttr,
- clauses.ifVar);
+ const CancelOperands &clauses) {
+ CancelOp::build(builder, state, clauses.cancelDirective, clauses.ifVar);
}
LogicalResult CancelOp::verify() {
- ClauseCancellationConstructType cct = getCancellationConstructTypeVal();
+ ClauseCancellationConstructType cct = getCancelDirective();
Operation *parentOp = (*this)->getParentOp();
if (!parentOp) {
@@ -2404,7 +2377,7 @@ LogicalResult CancelOp::verify() {
return emitError() << "A worksharing construct that is canceled "
<< "must not have a nowait clause";
}
- if (wsloopOp.getOrderedValAttr()) {
+ if (wsloopOp.getOrderedAttr()) {
return emitError() << "A worksharing construct that is canceled "
<< "must not have an ordered clause";
}
@@ -2429,12 +2402,12 @@ LogicalResult CancelOp::verify() {
//===----------------------------------------------------------------------===//
void CancellationPointOp::build(OpBuilder &builder, OperationState &state,
- const CancellationPointClauseOps &clauses) {
- CancellationPointOp::build(builder, state, clauses.cancelDirectiveNameAttr);
+ const CancellationPointOperands &clauses) {
+ CancellationPointOp::build(builder, state, clauses.cancelDirective);
}
LogicalResult CancellationPointOp::verify() {
- ClauseCancellationConstructType cct = getCancellationConstructTypeVal();
+ ClauseCancellationConstructType cct = getCancelDirective();
Operation *parentOp = (*this)->getParentOp();
if (!parentOp) {
@@ -2574,8 +2547,8 @@ LogicalResult PrivateClauseOp::verify() {
//===----------------------------------------------------------------------===//
void MaskedOp::build(OpBuilder &builder, OperationState &state,
- const MaskedClauseOps &clauses) {
- MaskedOp::build(builder, state, clauses.filteredThreadIdVar);
+ const MaskedOperands &clauses) {
+ MaskedOp::build(builder, state, clauses.filteredThreadId);
}
#define GET_ATTRDEF_CLASSES
diff --git a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
index 8b031deca8931..b7d1792852b08 100644
--- a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
@@ -362,9 +362,9 @@ convertOmpCritical(Operation &opInst, llvm::IRBuilderBase &builder,
auto criticalDeclareOp =
SymbolTable::lookupNearestSymbolFrom<omp::CriticalDeclareOp>(criticalOp,
symbolRef);
- hint = llvm::ConstantInt::get(
- llvm::Type::getInt32Ty(llvmContext),
- static_cast<int>(criticalDeclareOp.getHintVal()));
+ hint =
+ llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvmContext),
+ static_cast<int>(criticalDeclareOp.getHint()));
}
builder.restoreIP(moduleTranslation.getOpenMPBuilder()->createCritical(
ompLoc, bodyGenCB, finiCB, criticalOp.getName().value_or(""), hint));
@@ -376,7 +376,7 @@ template <typename T>
static void
collectReductionDecls(T loop,
SmallVectorImpl<omp::DeclareReductionOp> &reductions) {
- std::optional<ArrayAttr> attr = loop.getReductions();
+ std::optional<ArrayAttr> attr = loop.getReductionSyms();
if (!attr)
return;
@@ -534,11 +534,11 @@ convertOmpOrdered(Operation &opInst, llvm::IRBuilderBase &builder,
LLVM::ModuleTranslation &moduleTranslation) {
auto orderedOp = cast<omp::OrderedOp>(opInst);
- omp::ClauseDepend dependType = *orderedOp.getDependTypeVal();
+ omp::ClauseDepend dependType = *orderedOp.getDoacrossDependType();
bool isDependSource = dependType == omp::ClauseDepend::dependsource;
- unsigned numLoops = *orderedOp.getNumLoopsVal();
+ unsigned numLoops = *orderedOp.getDoacrossNumLoops();
SmallVector<llvm::Value *> vecValues =
- moduleTranslation.lookupValues(orderedOp.getDependVecVars());
+ moduleTranslation.lookupValues(orderedOp.getDoacrossDependVars());
size_t indexVecValues = 0;
while (indexVecValues < vecValues.size()) {
@@ -566,7 +566,7 @@ convertOmpOrderedRegion(Operation &opInst, llvm::IRBuilderBase &builder,
auto orderedRegionOp = cast<omp::OrderedRegionOp>(opInst);
// TODO: The code generation for ordered simd directive is not supported yet.
- if (orderedRegionOp.getSimd())
+ if (orderedRegionOp.getParLevelSimd())
return failure();
// TODO: support error propagation in OpenMPIRBuilder and use it instead of
@@ -588,7 +588,7 @@ convertOmpOrderedRegion(Operation &opInst, llvm::IRBuilderBase &builder,
llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder);
builder.restoreIP(
moduleTranslation.getOpenMPBuilder()->createOrderedThreadsSimd(
- ompLoc, bodyGenCB, finiCB, !orderedRegionOp.getSimd()));
+ ompLoc, bodyGenCB, finiCB, !orderedRegionOp.getParLevelSimd()));
return bodyGenStatus;
}
@@ -837,11 +837,11 @@ convertOmpSections(Operation &opInst, llvm::IRBuilderBase &builder,
// TODO: Support the following clauses: private, firstprivate, lastprivate,
// allocate
if (!sectionsOp.getAllocateVars().empty() ||
- !sectionsOp.getAllocatorsVars().empty())
+ !sectionsOp.getAllocatorVars().empty())
return emitError(sectionsOp.getLoc())
<< "allocate clause is not supported for sections construct";
- llvm::ArrayRef<bool> isByRef = getIsByRef(sectionsOp.getReductionVarsByref());
+ llvm::ArrayRef<bool> isByRef = getIsByRef(sectionsOp.getReductionByref());
assert(isByRef.size() == sectionsOp.getNumReductionVars());
SmallVector<omp::DeclareReductionOp> reductionDecls;
@@ -954,7 +954,7 @@ convertOmpSingle(omp::SingleOp &singleOp, llvm::IRBuilderBase &builder,
// Handle copyprivate
Operation::operand_range cpVars = singleOp.getCopyprivateVars();
- std::optional<ArrayAttr> cpFuncs = singleOp.getCopyprivateFuncs();
+ std::optional<ArrayAttr> cpFuncs = singleOp.getCopyprivateSyms();
llvm::SmallVector<llvm::Value *> llvmCPVars;
llvm::SmallVector<llvm::Function *> llvmCPFuncs;
for (size_t i = 0, e = cpVars.size(); i < e; ++i) {
@@ -976,7 +976,7 @@ convertOmpTeams(omp::TeamsOp op, llvm::IRBuilderBase &builder,
LLVM::ModuleTranslation &moduleTranslation) {
using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
LogicalResult bodyGenStatus = success();
- if (!op.getAllocatorsVars().empty() || op.getReductions())
+ if (!op.getAllocatorVars().empty() || op.getReductionSyms())
return op.emitError("unhandled clauses for translation to LLVM IR");
auto bodyCB = [&](InsertPointTy allocaIP, InsertPointTy codegenIP) {
@@ -1000,8 +1000,8 @@ convertOmpTeams(omp::TeamsOp op, llvm::IRBuilderBase &builder,
threadLimit = moduleTranslation.lookupValue(threadLimitVar);
llvm::Value *ifExpr = nullptr;
- if (Value ifExprVar = op.getIfExpr())
- ifExpr = moduleTranslation.lookupValue(ifExprVar);
+ if (Value ifVar = op.getIfExpr())
+ ifExpr = moduleTranslation.lookupValue(ifVar);
llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder);
builder.restoreIP(moduleTranslation.getOpenMPBuilder()->createTeams(
@@ -1010,12 +1010,12 @@ convertOmpTeams(omp::TeamsOp op, llvm::IRBuilderBase &builder,
}
static void
-buildDependData(std::optional<ArrayAttr> depends, OperandRange dependVars,
+buildDependData(std::optional<ArrayAttr> dependKinds, OperandRange dependVars,
LLVM::ModuleTranslation &moduleTranslation,
SmallVectorImpl<llvm::OpenMPIRBuilder::DependData> &dds) {
if (dependVars.empty())
return;
- for (auto dep : llvm::zip(dependVars, depends->getValue())) {
+ for (auto dep : llvm::zip(dependVars, dependKinds->getValue())) {
llvm::omp::RTLDependenceKindTy type;
switch (
cast<mlir::omp::ClauseTaskDependAttr>(std::get<1>(dep)).getValue()) {
@@ -1042,7 +1042,7 @@ convertOmpTaskOp(omp::TaskOp taskOp, llvm::IRBuilderBase &builder,
using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
LogicalResult bodyGenStatus = success();
if (taskOp.getUntiedAttr() || taskOp.getMergeableAttr() ||
- taskOp.getInReductions() || taskOp.getPriority() ||
+ taskOp.getInReductionSyms() || taskOp.getPriority() ||
!taskOp.getAllocateVars().empty()) {
return taskOp.emitError("unhandled clauses for translation to LLVM IR");
}
@@ -1058,7 +1058,7 @@ convertOmpTaskOp(omp::TaskOp taskOp, llvm::IRBuilderBase &builder,
};
SmallVector<llvm::OpenMPIRBuilder::DependData> dds;
- buildDependData(taskOp.getDepends(), taskOp.getDependVars(),
+ buildDependData(taskOp.getDependKinds(), taskOp.getDependVars(),
moduleTranslation, dds);
llvm::OpenMPIRBuilder::InsertPointTy allocaIP =
@@ -1066,7 +1066,7 @@ convertOmpTaskOp(omp::TaskOp taskOp, llvm::IRBuilderBase &builder,
llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder);
builder.restoreIP(moduleTranslation.getOpenMPBuilder()->createTask(
ompLoc, allocaIP, bodyCB, !taskOp.getUntied(),
- moduleTranslation.lookupValue(taskOp.getFinalExpr()),
+ moduleTranslation.lookupValue(taskOp.getFinal()),
moduleTranslation.lookupValue(taskOp.getIfExpr()), dds));
return bodyGenStatus;
}
@@ -1101,20 +1101,21 @@ convertOmpWsloop(Operation &opInst, llvm::IRBuilderBase &builder,
// 'DO/FOR'.
auto loopOp = cast<omp::LoopNestOp>(wsloopOp.getWrappedLoop());
- llvm::ArrayRef<bool> isByRef = getIsByRef(wsloopOp.getReductionVarsByref());
+ llvm::ArrayRef<bool> isByRef = getIsByRef(wsloopOp.getReductionByref());
assert(isByRef.size() == wsloopOp.getNumReductionVars());
// Static is the default.
auto schedule =
- wsloopOp.getScheduleVal().value_or(omp::ClauseScheduleKind::Static);
+ wsloopOp.getScheduleKind().value_or(omp::ClauseScheduleKind::Static);
// Find the loop configuration.
- llvm::Value *step = moduleTranslation.lookupValue(loopOp.getStep()[0]);
+ llvm::Value *step =
+ moduleTranslation.lookupValue(loopOp.getCollapseSteps()[0]);
llvm::Type *ivType = step->getType();
llvm::Value *chunk = nullptr;
- if (wsloopOp.getScheduleChunkVar()) {
+ if (wsloopOp.getScheduleChunk()) {
llvm::Value *chunkVar =
- moduleTranslation.lookupValue(wsloopOp.getScheduleChunkVar());
+ moduleTranslation.lookupValue(wsloopOp.getScheduleChunk());
chunk = builder.CreateSExtOrTrunc(chunkVar, ivType);
}
@@ -1178,10 +1179,11 @@ convertOmpWsloop(Operation &opInst, llvm::IRBuilderBase &builder,
llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
for (unsigned i = 0, e = loopOp.getNumLoops(); i < e; ++i) {
llvm::Value *lowerBound =
- moduleTranslation.lookupValue(loopOp.getLowerBound()[i]);
+ moduleTranslation.lookupValue(loopOp.getCollapseLowerBounds()[i]);
llvm::Value *upperBound =
- moduleTranslation.lookupValue(loopOp.getUpperBound()[i]);
- llvm::Value *step = moduleTranslation.lookupValue(loopOp.getStep()[i]);
+ moduleTranslation.lookupValue(loopOp.getCollapseUpperBounds()[i]);
+ llvm::Value *step =
+ moduleTranslation.lookupValue(loopOp.getCollapseSteps()[i]);
// Make sure loop trip count are emitted in the preheader of the outermost
// loop at the latest so that they are all available for the new collapsed
@@ -1209,16 +1211,15 @@ convertOmpWsloop(Operation &opInst, llvm::IRBuilderBase &builder,
allocaIP = findAllocaInsertPoint(builder, moduleTranslation);
// TODO: Handle doacross loops when the ordered clause has a parameter.
- bool isOrdered = wsloopOp.getOrderedVal().has_value();
- std::optional<omp::ScheduleModifier> scheduleModifier =
- wsloopOp.getScheduleModifier();
- bool isSimd = wsloopOp.getSimdModifier();
+ bool isOrdered = wsloopOp.getOrdered().has_value();
+ std::optional<omp::ScheduleModifier> scheduleMod = wsloopOp.getScheduleMod();
+ bool isSimd = wsloopOp.getScheduleSimd();
ompBuilder->applyWorkshareLoop(
ompLoc.DL, loopInfo, allocaIP, !wsloopOp.getNowait(),
convertToScheduleKind(schedule), chunk, isSimd,
- scheduleModifier == omp::ScheduleModifier::monotonic,
- scheduleModifier == omp::ScheduleModifier::nonmonotonic, isOrdered);
+ scheduleMod == omp::ScheduleModifier::monotonic,
+ scheduleMod == omp::ScheduleModifier::nonmonotonic, isOrdered);
// Continue building IR after the loop. Note that the LoopInfo returned by
// `collapseLoops` points inside the outermost loop and is intended for
@@ -1275,7 +1276,7 @@ convertOmpParallel(omp::ParallelOp opInst, llvm::IRBuilderBase &builder,
LLVM::ModuleTranslation &moduleTranslation) {
using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
OmpParallelOpConversionManager raii(opInst);
- ArrayRef<bool> isByRef = getIsByRef(opInst.getReductionVarsByref());
+ ArrayRef<bool> isByRef = getIsByRef(opInst.getReductionByref());
assert(isByRef.size() == opInst.getNumReductionVars());
// TODO: support error propagation in OpenMPIRBuilder and use it instead of
@@ -1420,11 +1421,11 @@ convertOmpParallel(omp::ParallelOp opInst, llvm::IRBuilderBase &builder,
auto [privVar, privatizerClone] =
[&]() -> std::pair<mlir::Value, omp::PrivateClauseOp> {
if (!opInst.getPrivateVars().empty()) {
- auto privVars = opInst.getPrivateVars();
- auto privatizers = opInst.getPrivatizers();
+ auto privateVars = opInst.getPrivateVars();
+ auto privateSyms = opInst.getPrivateSyms();
for (auto [privVar, privatizerAttr] :
- llvm::zip_equal(privVars, *privatizers)) {
+ llvm::zip_equal(privateVars, *privateSyms)) {
// Find the MLIR private variable corresponding to the LLVM value
// being privatized.
llvm::Value *llvmPrivVar = moduleTranslation.lookupValue(privVar);
@@ -1564,13 +1565,13 @@ convertOmpParallel(omp::ParallelOp opInst, llvm::IRBuilderBase &builder,
};
llvm::Value *ifCond = nullptr;
- if (auto ifExprVar = opInst.getIfExpr())
- ifCond = moduleTranslation.lookupValue(ifExprVar);
+ if (auto ifVar = opInst.getIfExpr())
+ ifCond = moduleTranslation.lookupValue(ifVar);
llvm::Value *numThreads = nullptr;
- if (auto numThreadsVar = opInst.getNumThreadsVar())
+ if (auto numThreadsVar = opInst.getNumThreads())
numThreads = moduleTranslation.lookupValue(numThreadsVar);
auto pbKind = llvm::omp::OMP_PROC_BIND_default;
- if (auto bind = opInst.getProcBindVal())
+ if (auto bind = opInst.getProcBindKind())
pbKind = getProcBindKind(*bind);
// TODO: Is the Parallel construct cancellable?
bool isCancellable = false;
@@ -1643,10 +1644,11 @@ convertOmpSimd(Operation &opInst, llvm::IRBuilderBase &builder,
llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
for (unsigned i = 0, e = loopOp.getNumLoops(); i < e; ++i) {
llvm::Value *lowerBound =
- moduleTranslation.lookupValue(loopOp.getLowerBound()[i]);
+ moduleTranslation.lookupValue(loopOp.getCollapseLowerBounds()[i]);
llvm::Value *upperBound =
- moduleTranslation.lookupValue(loopOp.getUpperBound()[i]);
- llvm::Value *step = moduleTranslation.lookupValue(loopOp.getStep()[i]);
+ moduleTranslation.lookupValue(loopOp.getCollapseUpperBounds()[i]);
+ llvm::Value *step =
+ moduleTranslation.lookupValue(loopOp.getCollapseSteps()[i]);
// Make sure loop trip count are emitted in the preheader of the outermost
// loop at the latest so that they are all available for the new collapsed
@@ -1680,7 +1682,7 @@ convertOmpSimd(Operation &opInst, llvm::IRBuilderBase &builder,
safelen = builder.getInt64(safelenVar.value());
llvm::MapVector<llvm::Value *, llvm::Value *> alignedVars;
- llvm::omp::OrderKind order = convertOrderKind(simdOp.getOrderVal());
+ llvm::omp::OrderKind order = convertOrderKind(simdOp.getOrder());
ompBuilder->applySimd(loopInfo, alignedVars,
simdOp.getIfExpr()
? moduleTranslation.lookupValue(simdOp.getIfExpr())
@@ -1722,7 +1724,7 @@ convertOmpAtomicRead(Operation &opInst, llvm::IRBuilderBase &builder,
llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder);
- llvm::AtomicOrdering AO = convertAtomicOrdering(readOp.getMemoryOrderVal());
+ llvm::AtomicOrdering AO = convertAtomicOrdering(readOp.getMemoryOrder());
llvm::Value *x = moduleTranslation.lookupValue(readOp.getX());
llvm::Value *v = moduleTranslation.lookupValue(readOp.getV());
@@ -1743,7 +1745,7 @@ convertOmpAtomicWrite(Operation &opInst, llvm::IRBuilderBase &builder,
llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder);
- llvm::AtomicOrdering ao = convertAtomicOrdering(writeOp.getMemoryOrderVal());
+ llvm::AtomicOrdering ao = convertAtomicOrdering(writeOp.getMemoryOrder());
llvm::Value *expr = moduleTranslation.lookupValue(writeOp.getExpr());
llvm::Value *dest = moduleTranslation.lookupValue(writeOp.getX());
llvm::Type *ty = moduleTranslation.convertType(writeOp.getExpr().getType());
@@ -1811,7 +1813,7 @@ convertOmpAtomicUpdate(omp::AtomicUpdateOp &opInst,
/*isVolatile=*/false};
llvm::AtomicOrdering atomicOrdering =
- convertAtomicOrdering(opInst.getMemoryOrderVal());
+ convertAtomicOrdering(opInst.getMemoryOrder());
// Generate update code.
LogicalResult updateGenStatus = success();
@@ -1903,7 +1905,7 @@ convertOmpAtomicCapture(omp::AtomicCaptureOp atomicCaptureOp,
/*isVolatile=*/false};
llvm::AtomicOrdering atomicOrdering =
- convertAtomicOrdering(atomicCaptureOp.getMemoryOrderVal());
+ convertAtomicOrdering(atomicCaptureOp.getMemoryOrder());
LogicalResult updateGenStatus = success();
auto updateFn = [&](llvm::Value *atomicx,
@@ -2166,12 +2168,11 @@ llvm::Value *getSizeInBytes(DataLayout &dl, const mlir::Type &type,
return builder.getInt64(dl.getTypeSizeInBits(type) / 8);
}
-void collectMapDataFromMapOperands(MapInfoData &mapData,
- llvm::SmallVectorImpl<Value> &mapOperands,
- LLVM::ModuleTranslation &moduleTranslation,
- DataLayout &dl,
- llvm::IRBuilderBase &builder) {
- for (mlir::Value mapValue : mapOperands) {
+void collectMapDataFromMapVars(MapInfoData &mapData,
+ llvm::SmallVectorImpl<Value> &mapVars,
+ LLVM::ModuleTranslation &moduleTranslation,
+ DataLayout &dl, llvm::IRBuilderBase &builder) {
+ for (mlir::Value mapValue : mapVars) {
if (auto mapOp = mlir::dyn_cast_if_present<mlir::omp::MapInfoOp>(
mapValue.getDefiningOp())) {
mlir::Value offloadPtr =
@@ -2211,7 +2212,7 @@ void collectMapDataFromMapOperands(MapInfoData &mapData,
// TODO: May require some further additions to support nested record
// types, i.e. member maps that can have member maps.
mapData.IsAMember.push_back(false);
- for (mlir::Value mapValue : mapOperands) {
+ for (mlir::Value mapValue : mapVars) {
if (auto map = mlir::dyn_cast_if_present<mlir::omp::MapInfoOp>(
mapValue.getDefiningOp())) {
for (auto member : map.getMembers()) {
@@ -2689,8 +2690,8 @@ static void genMapInfos(llvm::IRBuilderBase &builder,
DataLayout &dl,
llvm::OpenMPIRBuilder::MapInfosTy &combinedInfo,
MapInfoData &mapData,
- const SmallVector<Value> &devPtrOperands = {},
- const SmallVector<Value> &devAddrOperands = {},
+ const SmallVector<Value> &useDevicePtrVars = {},
+ const SmallVector<Value> &useDeviceAddrVars = {},
bool isTargetParams = false) {
// We wish to modify some of the methods in which arguments are
// passed based on their capture type by the target region, this can
@@ -2748,13 +2749,13 @@ static void genMapInfos(llvm::IRBuilderBase &builder,
return false;
};
- auto addDevInfos = [&, fail](auto devOperands, auto devOpType) -> void {
- for (const auto &devOp : devOperands) {
+ auto addDevInfos = [&, fail](auto useDeviceVars, auto devOpType) -> void {
+ for (const auto &useDeviceVar : useDeviceVars) {
// TODO: Only LLVMPointerTypes are handled.
- if (!isa<LLVM::LLVMPointerType>(devOp.getType()))
+ if (!isa<LLVM::LLVMPointerType>(useDeviceVar.getType()))
return fail();
- llvm::Value *mapOpValue = moduleTranslation.lookupValue(devOp);
+ llvm::Value *mapOpValue = moduleTranslation.lookupValue(useDeviceVar);
// Check if map info is already present for this entry.
unsigned infoIndex;
@@ -2767,7 +2768,7 @@ static void genMapInfos(llvm::IRBuilderBase &builder,
combinedInfo.Pointers.emplace_back(mapOpValue);
combinedInfo.DevicePointers.emplace_back(devOpType);
combinedInfo.Names.emplace_back(
- LLVM::createMappingInformation(devOp.getLoc(), *ompBuilder));
+ LLVM::createMappingInformation(useDeviceVar.getLoc(), *ompBuilder));
combinedInfo.Types.emplace_back(
llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_RETURN_PARAM);
combinedInfo.Sizes.emplace_back(builder.getInt64(0));
@@ -2775,8 +2776,8 @@ static void genMapInfos(llvm::IRBuilderBase &builder,
}
};
- addDevInfos(devPtrOperands, llvm::OpenMPIRBuilder::DeviceInfoTy::Pointer);
- addDevInfos(devAddrOperands, llvm::OpenMPIRBuilder::DeviceInfoTy::Address);
+ addDevInfos(useDevicePtrVars, llvm::OpenMPIRBuilder::DeviceInfoTy::Pointer);
+ addDevInfos(useDeviceAddrVars, llvm::OpenMPIRBuilder::DeviceInfoTy::Address);
}
static LogicalResult
@@ -2784,9 +2785,9 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
LLVM::ModuleTranslation &moduleTranslation) {
llvm::Value *ifCond = nullptr;
int64_t deviceID = llvm::omp::OMP_DEVICEID_UNDEF;
- SmallVector<Value> mapOperands;
- SmallVector<Value> useDevPtrOperands;
- SmallVector<Value> useDevAddrOperands;
+ SmallVector<Value> mapVars;
+ SmallVector<Value> useDevicePtrVars;
+ SmallVector<Value> useDeviceAddrVars;
llvm::omp::RuntimeFunction RTLFn;
DataLayout DL = DataLayout(op->getParentOfType<ModuleOp>());
@@ -2795,8 +2796,8 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
LogicalResult result =
llvm::TypeSwitch<Operation *, LogicalResult>(op)
.Case([&](omp::TargetDataOp dataOp) {
- if (auto ifExprVar = dataOp.getIfExpr())
- ifCond = moduleTranslation.lookupValue(ifExprVar);
+ if (auto ifVar = dataOp.getIfExpr())
+ ifCond = moduleTranslation.lookupValue(ifVar);
if (auto devId = dataOp.getDevice())
if (auto constOp =
@@ -2804,9 +2805,9 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
if (auto intAttr = dyn_cast<IntegerAttr>(constOp.getValue()))
deviceID = intAttr.getInt();
- mapOperands = dataOp.getMapOperands();
- useDevPtrOperands = dataOp.getUseDevicePtr();
- useDevAddrOperands = dataOp.getUseDeviceAddr();
+ mapVars = dataOp.getMapVars();
+ useDevicePtrVars = dataOp.getUseDevicePtrVars();
+ useDeviceAddrVars = dataOp.getUseDeviceAddrVars();
return success();
})
.Case([&](omp::TargetEnterDataOp enterDataOp) {
@@ -2814,8 +2815,8 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
return (LogicalResult)(enterDataOp.emitError(
"`nowait` is not supported yet"));
- if (auto ifExprVar = enterDataOp.getIfExpr())
- ifCond = moduleTranslation.lookupValue(ifExprVar);
+ if (auto ifVar = enterDataOp.getIfExpr())
+ ifCond = moduleTranslation.lookupValue(ifVar);
if (auto devId = enterDataOp.getDevice())
if (auto constOp =
@@ -2823,7 +2824,7 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
if (auto intAttr = dyn_cast<IntegerAttr>(constOp.getValue()))
deviceID = intAttr.getInt();
RTLFn = llvm::omp::OMPRTL___tgt_target_data_begin_mapper;
- mapOperands = enterDataOp.getMapOperands();
+ mapVars = enterDataOp.getMapVars();
return success();
})
.Case([&](omp::TargetExitDataOp exitDataOp) {
@@ -2831,8 +2832,8 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
return (LogicalResult)(exitDataOp.emitError(
"`nowait` is not supported yet"));
- if (auto ifExprVar = exitDataOp.getIfExpr())
- ifCond = moduleTranslation.lookupValue(ifExprVar);
+ if (auto ifVar = exitDataOp.getIfExpr())
+ ifCond = moduleTranslation.lookupValue(ifVar);
if (auto devId = exitDataOp.getDevice())
if (auto constOp =
@@ -2841,7 +2842,7 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
deviceID = intAttr.getInt();
RTLFn = llvm::omp::OMPRTL___tgt_target_data_end_mapper;
- mapOperands = exitDataOp.getMapOperands();
+ mapVars = exitDataOp.getMapVars();
return success();
})
.Case([&](omp::TargetUpdateOp updateDataOp) {
@@ -2849,8 +2850,8 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
return (LogicalResult)(updateDataOp.emitError(
"`nowait` is not supported yet"));
- if (auto ifExprVar = updateDataOp.getIfExpr())
- ifCond = moduleTranslation.lookupValue(ifExprVar);
+ if (auto ifVar = updateDataOp.getIfExpr())
+ ifCond = moduleTranslation.lookupValue(ifVar);
if (auto devId = updateDataOp.getDevice())
if (auto constOp =
@@ -2859,7 +2860,7 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
deviceID = intAttr.getInt();
RTLFn = llvm::omp::OMPRTL___tgt_target_data_update_mapper;
- mapOperands = updateDataOp.getMapOperands();
+ mapVars = updateDataOp.getMapVars();
return success();
})
.Default([&](Operation *op) {
@@ -2873,8 +2874,7 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
MapInfoData mapData;
- collectMapDataFromMapOperands(mapData, mapOperands, moduleTranslation, DL,
- builder);
+ collectMapDataFromMapVars(mapData, mapVars, moduleTranslation, DL, builder);
// Fill up the arrays with all the mapped variables.
llvm::OpenMPIRBuilder::MapInfosTy combinedInfo;
@@ -2883,7 +2883,7 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
builder.restoreIP(codeGenIP);
if (auto dataOp = dyn_cast<omp::TargetDataOp>(op)) {
genMapInfos(builder, moduleTranslation, DL, combinedInfo, mapData,
- useDevPtrOperands, useDevAddrOperands);
+ useDevicePtrVars, useDeviceAddrVars);
} else {
genMapInfos(builder, moduleTranslation, DL, combinedInfo, mapData);
}
@@ -2905,7 +2905,7 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
if (!info.DevicePtrInfoMap.empty()) {
builder.restoreIP(codeGenIP);
unsigned argIndex = 0;
- for (auto &devPtrOp : useDevPtrOperands) {
+ for (auto &devPtrOp : useDevicePtrVars) {
llvm::Value *mapOpValue = moduleTranslation.lookupValue(devPtrOp);
const auto &arg = region.front().getArgument(argIndex);
moduleTranslation.mapValue(arg,
@@ -2913,7 +2913,7 @@ convertOmpTargetData(Operation *op, llvm::IRBuilderBase &builder,
argIndex++;
}
- for (auto &devAddrOp : useDevAddrOperands) {
+ for (auto &devAddrOp : useDeviceAddrVars) {
llvm::Value *mapOpValue = moduleTranslation.lookupValue(devAddrOp);
const auto &arg = region.front().getArgument(argIndex);
auto *LI = builder.CreateLoad(
@@ -3200,7 +3200,7 @@ convertOmpTarget(Operation &opInst, llvm::IRBuilderBase &builder,
auto targetOp = cast<omp::TargetOp>(opInst);
auto &targetRegion = targetOp.getRegion();
DataLayout dl = DataLayout(opInst.getParentOfType<ModuleOp>());
- SmallVector<Value> mapOperands = targetOp.getMapOperands();
+ SmallVector<Value> mapVars = targetOp.getMapVars();
llvm::Function *llvmOutlinedFn = nullptr;
LogicalResult bodyGenStatus = success();
@@ -3225,7 +3225,7 @@ convertOmpTarget(Operation &opInst, llvm::IRBuilderBase &builder,
builder.restoreIP(codeGenIP);
unsigned argIndex = 0;
- for (auto &mapOp : mapOperands) {
+ for (auto &mapOp : mapVars) {
auto mapInfoOp =
mlir::dyn_cast<mlir::omp::MapInfoOp>(mapOp.getDefiningOp());
llvm::Value *mapOpValue =
@@ -3255,8 +3255,7 @@ convertOmpTarget(Operation &opInst, llvm::IRBuilderBase &builder,
findAllocaInsertPoint(builder, moduleTranslation);
MapInfoData mapData;
- collectMapDataFromMapOperands(mapData, mapOperands, moduleTranslation, dl,
- builder);
+ collectMapDataFromMapVars(mapData, mapVars, moduleTranslation, dl, builder);
llvm::OpenMPIRBuilder::MapInfosTy combinedInfos;
auto genMapInfoCB = [&](llvm::OpenMPIRBuilder::InsertPointTy codeGenIP)
@@ -3288,7 +3287,7 @@ convertOmpTarget(Operation &opInst, llvm::IRBuilderBase &builder,
};
llvm::SmallVector<llvm::Value *, 4> kernelInput;
- for (size_t i = 0; i < mapOperands.size(); ++i) {
+ for (size_t i = 0; i < mapVars.size(); ++i) {
// declare target arguments are not passed to kernels as arguments
// TODO: We currently do not handle cases where a member is explicitly
// passed in as an argument, this will likley need to be handled in
@@ -3299,7 +3298,7 @@ convertOmpTarget(Operation &opInst, llvm::IRBuilderBase &builder,
kernelInput.push_back(mapData.OriginalValue[i]);
}
SmallVector<llvm::OpenMPIRBuilder::DependData> dds;
- buildDependData(targetOp.getDepends(), targetOp.getDependVars(),
+ buildDependData(targetOp.getDependKinds(), targetOp.getDependVars(),
moduleTranslation, dds);
builder.restoreIP(moduleTranslation.getOpenMPBuilder()->createTarget(
diff --git a/mlir/test/Dialect/OpenMP/invalid.mlir b/mlir/test/Dialect/OpenMP/invalid.mlir
index 9977dd57e3023..a29e34a9d5518 100644
--- a/mlir/test/Dialect/OpenMP/invalid.mlir
+++ b/mlir/test/Dialect/OpenMP/invalid.mlir
@@ -420,7 +420,7 @@ func.func @omp_simd_aligned_mismatch(%arg0 : index, %arg1 : index,
omp.loop_nest (%iv) : index = (%arg0) to (%arg1) step (%arg2) {
omp.yield
}
- }) {alignment_values = [128],
+ }) {alignments = [128],
operandSegmentSizes = array<i32: 2, 0, 0>} : (memref<i32>, memref<i32>) -> ()
return
}
@@ -435,7 +435,7 @@ func.func @omp_simd_aligned_negative(%arg0 : index, %arg1 : index,
omp.loop_nest (%iv) : index = (%arg0) to (%arg1) step (%arg2) {
omp.yield
}
- }) {alignment_values = [-1, 128], operandSegmentSizes = array<i32: 2, 0, 0>} : (memref<i32>, memref<i32>) -> ()
+ }) {alignments = [-1, 128], operandSegmentSizes = array<i32: 2, 0, 0>} : (memref<i32>, memref<i32>) -> ()
return
}
@@ -449,7 +449,7 @@ func.func @omp_simd_unexpected_alignment(%arg0 : index, %arg1 : index,
omp.loop_nest (%iv) : index = (%arg0) to (%arg1) step (%arg2) {
omp.yield
}
- }) {alignment_values = [1, 128]} : () -> ()
+ }) {alignments = [1, 128]} : () -> ()
return
}
@@ -463,7 +463,7 @@ func.func @omp_simd_aligned_float(%arg0 : index, %arg1 : index,
omp.loop_nest (%iv) : index = (%arg0) to (%arg1) step (%arg2) {
omp.yield
}
- }) {alignment_values = [1.5, 128], operandSegmentSizes = array<i32: 2, 0, 0>} : (memref<i32>, memref<i32>) -> ()
+ }) {alignments = [1.5, 128], operandSegmentSizes = array<i32: 2, 0, 0>} : (memref<i32>, memref<i32>) -> ()
return
}
@@ -477,7 +477,7 @@ func.func @omp_simd_aligned_the_same_var(%arg0 : index, %arg1 : index,
omp.loop_nest (%iv) : index = (%arg0) to (%arg1) step (%arg2) {
omp.yield
}
- }) {alignment_values = [1, 128], operandSegmentSizes = array<i32: 2, 0, 0>} : (memref<i32>, memref<i32>) -> ()
+ }) {alignments = [1, 128], operandSegmentSizes = array<i32: 2, 0, 0>} : (memref<i32>, memref<i32>) -> ()
return
}
@@ -839,7 +839,7 @@ func.func @omp_ordered_region3(%x : i32) -> () {
func.func @omp_ordered1(%vec0 : i64) -> () {
// expected-error @below {{op must be nested inside of a loop}}
- omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+ omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {doacross_num_loops = 1 : i64}
return
}
@@ -849,7 +849,7 @@ func.func @omp_ordered2(%arg1 : i32, %arg2 : i32, %arg3 : i32, %vec0 : i64) -> (
omp.distribute {
omp.loop_nest (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
// expected-error @below {{op must be nested inside of a worksharing, simd or worksharing simd loop}}
- omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+ omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {doacross_num_loops = 1 : i64}
omp.yield
}
omp.terminator
@@ -863,7 +863,7 @@ func.func @omp_ordered3(%arg1 : i32, %arg2 : i32, %arg3 : i32, %vec0 : i64) -> (
omp.wsloop {
omp.loop_nest (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
// expected-error @below {{the enclosing worksharing-loop region must have an ordered clause}}
- omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+ omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {doacross_num_loops = 1 : i64}
omp.yield
}
omp.terminator
@@ -877,7 +877,7 @@ func.func @omp_ordered4(%arg1 : i32, %arg2 : i32, %arg3 : i32, %vec0 : i64) -> (
omp.wsloop ordered(0) {
omp.loop_nest (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
// expected-error @below {{the enclosing loop's ordered clause must have a parameter present}}
- omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+ omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {doacross_num_loops = 1 : i64}
omp.yield
}
omp.terminator
@@ -891,7 +891,7 @@ func.func @omp_ordered5(%arg1 : i32, %arg2 : i32, %arg3 : i32, %vec0 : i64, %vec
omp.wsloop ordered(1) {
omp.loop_nest (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
// expected-error @below {{number of variables in depend clause does not match number of iteration variables in the doacross loop}}
- omp.ordered depend_type(dependsource) depend_vec(%vec0, %vec1 : i64, i64) {num_loops_val = 2 : i64}
+ omp.ordered depend_type(dependsource) depend_vec(%vec0, %vec1 : i64, i64) {doacross_num_loops = 2 : i64}
omp.yield
}
omp.terminator
@@ -1564,7 +1564,7 @@ func.func @omp_single(%data_var : memref<i32>) -> () {
// -----
func.func @omp_single_copyprivate(%data_var : memref<i32>) -> () {
- // expected-error @below {{inconsistent number of copyPrivate vars (= 1) and functions (= 0), both must be equal}}
+ // expected-error @below {{inconsistent number of copyprivate vars (= 1) and functions (= 0), both must be equal}}
"omp.single" (%data_var) ({
omp.barrier
}) {operandSegmentSizes = array<i32: 0,0,1>} : (memref<i32>) -> ()
@@ -1623,7 +1623,7 @@ func.func @omp_task_depend(%data_var: memref<i32>) {
// expected-error @below {{op expected as many depend values as depend variables}}
"omp.task"(%data_var) ({
"omp.terminator"() : () -> ()
- }) {depends = [], operandSegmentSizes = array<i32: 0, 0, 0, 0, 1, 0, 0>} : (memref<i32>) -> ()
+ }) {depend_kinds = [], operandSegmentSizes = array<i32: 0, 0, 0, 0, 1, 0, 0>} : (memref<i32>) -> ()
"func.return"() : () -> ()
}
@@ -1834,7 +1834,7 @@ func.func @taskloop(%lb: i32, %ub: i32, %step: i32) {
omp.loop_nest (%i, %j) : i32 = (%lb, %ub) to (%ub, %lb) step (%step, %step) {
omp.yield
}
- }) {operandSegmentSizes = array<i32: 0, 0, 0, 2, 0, 0, 0, 0, 0>, reductions = [@add_f32]} : (!llvm.ptr, !llvm.ptr) -> ()
+ }) {operandSegmentSizes = array<i32: 0, 0, 0, 2, 0, 0, 0, 0, 0>, reduction_syms = [@add_f32]} : (!llvm.ptr, !llvm.ptr) -> ()
return
}
@@ -1847,7 +1847,7 @@ func.func @taskloop(%lb: i32, %ub: i32, %step: i32) {
omp.loop_nest (%i, %j) : i32 = (%lb, %ub) to (%ub, %lb) step (%step, %step) {
omp.yield
}
- }) {operandSegmentSizes = array<i32: 0, 0, 0, 1, 0, 0, 0, 0, 0>, reductions = [@add_f32, @add_f32]} : (!llvm.ptr) -> ()
+ }) {operandSegmentSizes = array<i32: 0, 0, 0, 1, 0, 0, 0, 0, 0>, reduction_syms = [@add_f32, @add_f32]} : (!llvm.ptr) -> ()
return
}
@@ -1861,7 +1861,7 @@ func.func @taskloop(%lb: i32, %ub: i32, %step: i32) {
omp.loop_nest (%i, %j) : i32 = (%lb, %ub) to (%ub, %lb) step (%step, %step) {
omp.yield
}
- }) {in_reductions = [@add_f32], operandSegmentSizes = array<i32: 0, 0, 2, 0, 0, 0, 0, 0, 0>} : (!llvm.ptr, !llvm.ptr) -> ()
+ }) {in_reduction_syms = [@add_f32], operandSegmentSizes = array<i32: 0, 0, 2, 0, 0, 0, 0, 0, 0>} : (!llvm.ptr, !llvm.ptr) -> ()
return
}
@@ -1874,7 +1874,7 @@ func.func @taskloop(%lb: i32, %ub: i32, %step: i32) {
omp.loop_nest (%i, %j) : i32 = (%lb, %ub) to (%ub, %lb) step (%step, %step) {
omp.yield
}
- }) {in_reductions = [@add_f32, @add_f32], operandSegmentSizes = array<i32: 0, 0, 1, 0, 0, 0, 0, 0, 0>} : (!llvm.ptr) -> ()
+ }) {in_reduction_syms = [@add_f32, @add_f32], operandSegmentSizes = array<i32: 0, 0, 1, 0, 0, 0, 0, 0, 0>} : (!llvm.ptr) -> ()
return
}
@@ -1934,7 +1934,7 @@ func.func @taskloop(%lb: i32, %ub: i32, %step: i32) {
func.func @taskloop(%lb: i32, %ub: i32, %step: i32) {
%testi64 = "test.i64"() : () -> (i64)
// expected-error @below {{the grainsize clause and num_tasks clause are mutually exclusive and may not appear on the same taskloop directive}}
- omp.taskloop grain_size(%testi64: i64) num_tasks(%testi64: i64) {
+ omp.taskloop grainsize(%testi64: i64) num_tasks(%testi64: i64) {
omp.loop_nest (%i, %j) : i32 = (%lb, %ub) to (%ub, %lb) step (%step, %step) {
omp.yield
}
@@ -2001,7 +2001,7 @@ func.func @omp_target_data(%map1: memref<?xi32>) {
// -----
func.func @omp_target_data() {
- // expected-error @below {{At least one of map, useDevicePtr, or useDeviceAddr operand must be present}}
+ // expected-error @below {{At least one of map, use_device_ptr_vars, or use_device_addr_vars operand must be present}}
omp.target_data {}
return
}
@@ -2129,7 +2129,7 @@ func.func @omp_target_depend(%data_var: memref<i32>) {
// expected-error @below {{op expected as many depend values as depend variables}}
"omp.target"(%data_var) ({
"omp.terminator"() : () -> ()
- }) {depends = [], operandSegmentSizes = array<i32: 0, 0, 0, 1, 0, 0, 0, 0>} : (memref<i32>) -> ()
+ }) {depend_kinds = [], operandSegmentSizes = array<i32: 0, 0, 0, 1, 0, 0, 0, 0>} : (memref<i32>) -> ()
"func.return"() : () -> ()
}
@@ -2340,7 +2340,7 @@ func.func @undefined_privatizer(%arg0: index) {
// -----
func.func @undefined_privatizer(%arg0: !llvm.ptr) {
// expected-error @below {{inconsistent number of private variables and privatizer op symbols, private vars: 1 vs. privatizer op symbols: 2}}
- "omp.parallel"(%arg0) <{operandSegmentSizes = array<i32: 0, 0, 0, 0, 0, 1>, privatizers = [@x.privatizer, @y.privatizer]}> ({
+ "omp.parallel"(%arg0) <{operandSegmentSizes = array<i32: 0, 0, 0, 0, 0, 1>, private_syms = [@x.privatizer, @y.privatizer]}> ({
^bb0(%arg2: !llvm.ptr):
omp.terminator
}) : (!llvm.ptr) -> ()
diff --git a/mlir/test/Dialect/OpenMP/ops.mlir b/mlir/test/Dialect/OpenMP/ops.mlir
index d6f4a810c4a80..9db98883113b4 100644
--- a/mlir/test/Dialect/OpenMP/ops.mlir
+++ b/mlir/test/Dialect/OpenMP/ops.mlir
@@ -91,7 +91,7 @@ func.func @omp_parallel(%data_var : memref<i32>, %if_cond : i1, %num_threads : i
}) {operandSegmentSizes = array<i32: 1,1,0,0,0,0>} : (i1, i32) -> ()
omp.terminator
- }) {operandSegmentSizes = array<i32: 1,1,1,1,0,0>, proc_bind_val = #omp<procbindkind spread>} : (i1, i32, memref<i32>, memref<i32>) -> ()
+ }) {operandSegmentSizes = array<i32: 1,1,1,1,0,0>, proc_bind_kind = #omp<procbindkind spread>} : (i1, i32, memref<i32>, memref<i32>) -> ()
// test with multiple parameters for single variadic argument
// CHECK: omp.parallel allocate(%{{.*}} : memref<i32> -> %{{.*}} : memref<i32>)
@@ -382,7 +382,7 @@ func.func @omp_wsloop(%lb : index, %ub : index, %step : index, %data_var : memre
omp.yield
}
omp.terminator
- }) {operandSegmentSizes = array<i32: 0,0,0,0>, ordered_val = 1} :
+ }) {operandSegmentSizes = array<i32: 0,0,0,0>, ordered = 1} :
() -> ()
// CHECK: omp.wsloop linear(%{{.*}} = %{{.*}} : memref<i32>) schedule(static) {
@@ -392,7 +392,7 @@ func.func @omp_wsloop(%lb : index, %ub : index, %step : index, %data_var : memre
omp.yield
}
omp.terminator
- }) {operandSegmentSizes = array<i32: 1,1,0,0>, schedule_val = #omp<schedulekind static>} :
+ }) {operandSegmentSizes = array<i32: 1,1,0,0>, schedule_kind = #omp<schedulekind static>} :
(memref<i32>, i32) -> ()
// CHECK: omp.wsloop linear(%{{.*}} = %{{.*}} : memref<i32>, %{{.*}} = %{{.*}} : memref<i32>) schedule(static) {
@@ -402,7 +402,7 @@ func.func @omp_wsloop(%lb : index, %ub : index, %step : index, %data_var : memre
omp.yield
}
omp.terminator
- }) {operandSegmentSizes = array<i32: 2,2,0,0>, schedule_val = #omp<schedulekind static>} :
+ }) {operandSegmentSizes = array<i32: 2,2,0,0>, schedule_kind = #omp<schedulekind static>} :
(memref<i32>, memref<i32>, i32, i32) -> ()
// CHECK: omp.wsloop linear(%{{.*}} = %{{.*}} : memref<i32>) schedule(dynamic = %{{.*}}) ordered(2) {
@@ -412,7 +412,7 @@ func.func @omp_wsloop(%lb : index, %ub : index, %step : index, %data_var : memre
omp.yield
}
omp.terminator
- }) {operandSegmentSizes = array<i32: 1,1,0,1>, schedule_val = #omp<schedulekind dynamic>, ordered_val = 2} :
+ }) {operandSegmentSizes = array<i32: 1,1,0,1>, schedule_kind = #omp<schedulekind dynamic>, ordered = 2} :
(memref<i32>, i32, i32) -> ()
// CHECK: omp.wsloop schedule(auto) nowait {
@@ -422,7 +422,7 @@ func.func @omp_wsloop(%lb : index, %ub : index, %step : index, %data_var : memre
omp.yield
}
omp.terminator
- }) {operandSegmentSizes = array<i32: 0,0,0,0>, nowait, schedule_val = #omp<schedulekind auto>} :
+ }) {operandSegmentSizes = array<i32: 0,0,0,0>, nowait, schedule_kind = #omp<schedulekind auto>} :
() -> ()
// CHECK: omp.wsloop {
@@ -574,7 +574,7 @@ func.func @omp_simd_aligned_list(%arg0 : index, %arg1 : index, %arg2 : index,
"omp.yield"() : () -> ()
}) : (index, index, index) -> ()
"omp.terminator"() : () -> ()
- }) {alignment_values = [32, 128],
+ }) {alignments = [32, 128],
operandSegmentSizes = array<i32: 2, 0, 0>} : (memref<i32>, memref<i32>) -> ()
return
}
@@ -589,7 +589,7 @@ func.func @omp_simd_aligned_single(%arg0 : index, %arg1 : index, %arg2 : index,
"omp.yield"() : () -> ()
}) : (index, index, index) -> ()
"omp.terminator"() : () -> ()
- }) {alignment_values = [32],
+ }) {alignments = [32],
operandSegmentSizes = array<i32: 1, 0, 0>} : (memref<i32>) -> ()
return
}
@@ -752,8 +752,8 @@ func.func @omp_distribute(%chunk_size : i32, %data_var : memref<i32>, %arg0 : i3
}
omp.terminator
}
- // CHECK: omp.distribute dist_schedule_static chunk_size(%{{.+}} : i32)
- omp.distribute dist_schedule_static chunk_size(%chunk_size : i32) {
+ // CHECK: omp.distribute dist_schedule_static dist_schedule_chunk_size(%{{.+}} : i32)
+ omp.distribute dist_schedule_static dist_schedule_chunk_size(%chunk_size : i32) {
omp.loop_nest (%iv) : i32 = (%arg0) to (%arg0) step (%arg0) {
omp.yield
}
@@ -1294,11 +1294,11 @@ func.func @omp_ordered(%arg1 : i32, %arg2 : i32, %arg3 : i32,
omp.wsloop ordered(1) {
omp.loop_nest (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
// Only one DEPEND(SINK: vec) clause
- // CHECK: omp.ordered depend_type(dependsink) depend_vec(%{{.*}} : i64) {num_loops_val = 1 : i64}
- omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+ // CHECK: omp.ordered depend_type(dependsink) depend_vec(%{{.*}} : i64) {doacross_num_loops = 1 : i64}
+ omp.ordered depend_type(dependsink) depend_vec(%vec0 : i64) {doacross_num_loops = 1 : i64}
- // CHECK: omp.ordered depend_type(dependsource) depend_vec(%{{.*}} : i64) {num_loops_val = 1 : i64}
- omp.ordered depend_type(dependsource) depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+ // CHECK: omp.ordered depend_type(dependsource) depend_vec(%{{.*}} : i64) {doacross_num_loops = 1 : i64}
+ omp.ordered depend_type(dependsource) depend_vec(%vec0 : i64) {doacross_num_loops = 1 : i64}
omp.yield
}
@@ -1308,11 +1308,11 @@ func.func @omp_ordered(%arg1 : i32, %arg2 : i32, %arg3 : i32,
omp.wsloop ordered(2) {
omp.loop_nest (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
// Multiple DEPEND(SINK: vec) clauses
- // CHECK: omp.ordered depend_type(dependsink) depend_vec(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : i64, i64, i64, i64) {num_loops_val = 2 : i64}
- omp.ordered depend_type(dependsink) depend_vec(%vec0, %vec1, %vec2, %vec3 : i64, i64, i64, i64) {num_loops_val = 2 : i64}
+ // CHECK: omp.ordered depend_type(dependsink) depend_vec(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : i64, i64, i64, i64) {doacross_num_loops = 2 : i64}
+ omp.ordered depend_type(dependsink) depend_vec(%vec0, %vec1, %vec2, %vec3 : i64, i64, i64, i64) {doacross_num_loops = 2 : i64}
- // CHECK: omp.ordered depend_type(dependsource) depend_vec(%{{.*}}, %{{.*}} : i64, i64) {num_loops_val = 2 : i64}
- omp.ordered depend_type(dependsource) depend_vec(%vec0, %vec1 : i64, i64) {num_loops_val = 2 : i64}
+ // CHECK: omp.ordered depend_type(dependsource) depend_vec(%{{.*}}, %{{.*}} : i64, i64) {doacross_num_loops = 2 : i64}
+ omp.ordered depend_type(dependsource) depend_vec(%vec0, %vec1 : i64, i64) {doacross_num_loops = 2 : i64}
omp.yield
}
@@ -1880,7 +1880,7 @@ func.func @omp_sectionsop(%data_var1 : memref<i32>, %data_var2 : memref<i32>,
"omp.sections" (%redn_var) ({
// CHECK: omp.terminator
omp.terminator
- }) {operandSegmentSizes = array<i32: 1,0,0>, reduction_vars_byref = array<i1: false>, reductions=[@add_f32]} : (!llvm.ptr) -> ()
+ }) {operandSegmentSizes = array<i32: 1,0,0>, reduction_byref = array<i1: false>, reduction_syms=[@add_f32]} : (!llvm.ptr) -> ()
// CHECK: omp.sections nowait {
omp.sections nowait {
@@ -2421,8 +2421,8 @@ func.func @omp_taskloop(%lb: i32, %ub: i32, %step: i32) -> () {
}
%testi64 = "test.i64"() : () -> (i64)
- // CHECK: omp.taskloop grain_size(%{{[^:]+}}: i64) {
- omp.taskloop grain_size(%testi64: i64) {
+ // CHECK: omp.taskloop grainsize(%{{[^:]+}}: i64) {
+ omp.taskloop grainsize(%testi64: i64) {
omp.loop_nest (%i, %j) : i32 = (%lb, %ub) to (%ub, %lb) step (%step, %step) {
// CHECK: omp.yield
omp.yield
diff --git a/mlir/test/Target/LLVMIR/openmp-llvm.mlir b/mlir/test/Target/LLVMIR/openmp-llvm.mlir
index 04c2e9fa091bd..acebb20674406 100644
--- a/mlir/test/Target/LLVMIR/openmp-llvm.mlir
+++ b/mlir/test/Target/LLVMIR/openmp-llvm.mlir
@@ -148,12 +148,12 @@ llvm.func @test_omp_parallel_num_threads_3() -> () {
// CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_3_1]]
// CHECK: call void @__kmpc_barrier
-// CHECK: define void @test_omp_parallel_if_1(i32 %[[IF_VAR_1:.*]])
+// CHECK: define void @test_omp_parallel_if_1(i32 %[[IF_EXPR_1:.*]])
llvm.func @test_omp_parallel_if_1(%arg0: i32) -> () {
%0 = llvm.mlir.constant(0 : index) : i32
%1 = llvm.icmp "slt" %arg0, %0 : i32
-// CHECK: %[[IF_COND_VAR_1:.*]] = icmp slt i32 %[[IF_VAR_1]], 0
+// CHECK: %[[IF_COND_VAR_1:.*]] = icmp slt i32 %[[IF_EXPR_1]], 0
// CHECK: %[[GTN_IF_1:.*]] = call i32 @__kmpc_global_thread_num(ptr @[[SI_VAR_IF_1:.*]])
@@ -1330,14 +1330,14 @@ llvm.func @omp_ordered(%arg0 : i32, %arg1 : i32, %arg2 : i32, %arg3 : i64,
// CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x i64], ptr [[ADDR]], i64 0, i64 0
// CHECK: [[OMP_THREAD2:%.*]] = call i32 @__kmpc_global_thread_num(ptr @[[GLOB3:[0-9]+]])
// CHECK: call void @__kmpc_doacross_wait(ptr @[[GLOB3]], i32 [[OMP_THREAD2]], ptr [[TMP2]])
- omp.ordered depend_type(dependsink) depend_vec(%arg3 : i64) {num_loops_val = 1 : i64}
+ omp.ordered depend_type(dependsink) depend_vec(%arg3 : i64) {doacross_num_loops = 1 : i64}
// CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x i64], ptr [[ADDR3]], i64 0, i64 0
// CHECK: store i64 [[ARG0]], ptr [[TMP3]], align 8
// CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x i64], ptr [[ADDR3]], i64 0, i64 0
// CHECK: [[OMP_THREAD4:%.*]] = call i32 @__kmpc_global_thread_num(ptr @[[GLOB5:[0-9]+]])
// CHECK: call void @__kmpc_doacross_post(ptr @[[GLOB5]], i32 [[OMP_THREAD4]], ptr [[TMP4]])
- omp.ordered depend_type(dependsource) depend_vec(%arg3 : i64) {num_loops_val = 1 : i64}
+ omp.ordered depend_type(dependsource) depend_vec(%arg3 : i64) {doacross_num_loops = 1 : i64}
omp.yield
}
@@ -1360,7 +1360,7 @@ llvm.func @omp_ordered(%arg0 : i32, %arg1 : i32, %arg2 : i32, %arg3 : i64,
// CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x i64], ptr [[ADDR7]], i64 0, i64 0
// CHECK: [[OMP_THREAD8:%.*]] = call i32 @__kmpc_global_thread_num(ptr @[[GLOB7]])
// CHECK: call void @__kmpc_doacross_wait(ptr @[[GLOB7]], i32 [[OMP_THREAD8]], ptr [[TMP10]])
- omp.ordered depend_type(dependsink) depend_vec(%arg3, %arg4, %arg5, %arg6 : i64, i64, i64, i64) {num_loops_val = 2 : i64}
+ omp.ordered depend_type(dependsink) depend_vec(%arg3, %arg4, %arg5, %arg6 : i64, i64, i64, i64) {doacross_num_loops = 2 : i64}
// CHECK: [[TMP11:%.*]] = getelementptr inbounds [2 x i64], ptr [[ADDR9]], i64 0, i64 0
// CHECK: store i64 [[ARG0]], ptr [[TMP11]], align 8
@@ -1369,7 +1369,7 @@ llvm.func @omp_ordered(%arg0 : i32, %arg1 : i32, %arg2 : i32, %arg3 : i64,
// CHECK: [[TMP13:%.*]] = getelementptr inbounds [2 x i64], ptr [[ADDR9]], i64 0, i64 0
// CHECK: [[OMP_THREAD10:%.*]] = call i32 @__kmpc_global_thread_num(ptr @[[GLOB9:[0-9]+]])
// CHECK: call void @__kmpc_doacross_post(ptr @[[GLOB9]], i32 [[OMP_THREAD10]], ptr [[TMP13]])
- omp.ordered depend_type(dependsource) depend_vec(%arg3, %arg4 : i64, i64) {num_loops_val = 2 : i64}
+ omp.ordered depend_type(dependsource) depend_vec(%arg3, %arg4 : i64, i64) {doacross_num_loops = 2 : i64}
omp.yield
}
More information about the flang-commits
mailing list