[flang-commits] [flang] [flang][OpenMP] Remove unnecessary `Fortran::` qualification, NFC (PR #92298)
via flang-commits
flang-commits at lists.llvm.org
Wed May 15 10:39:30 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
Author: Krzysztof Parzyszek (kparzysz)
<details>
<summary>Changes</summary>
The `Fortran::` namespace is obvious for all parts of the code in this PR.
---
Patch is 179.63 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/92298.diff
11 Files Affected:
- (modified) flang/lib/Lower/OpenMP/ClauseProcessor.cpp (+90-111)
- (modified) flang/lib/Lower/OpenMP/ClauseProcessor.h (+53-60)
- (modified) flang/lib/Lower/OpenMP/Clauses.cpp (+3-4)
- (modified) flang/lib/Lower/OpenMP/Clauses.h (+3-4)
- (modified) flang/lib/Lower/OpenMP/DataSharingProcessor.cpp (+67-81)
- (modified) flang/lib/Lower/OpenMP/DataSharingProcessor.h (+31-35)
- (modified) flang/lib/Lower/OpenMP/OpenMP.cpp (+470-587)
- (modified) flang/lib/Lower/OpenMP/ReductionProcessor.cpp (+10-13)
- (modified) flang/lib/Lower/OpenMP/ReductionProcessor.h (+6-7)
- (modified) flang/lib/Lower/OpenMP/Utils.cpp (+46-54)
- (modified) flang/lib/Lower/OpenMP/Utils.h (+11-13)
``````````diff
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
index 0ea87314d571f..40d66460a6984 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
@@ -62,13 +62,13 @@ getSimdModifier(const omp::clause::Schedule &clause) {
}
static void
-genAllocateClause(Fortran::lower::AbstractConverter &converter,
+genAllocateClause(lower::AbstractConverter &converter,
const omp::clause::Allocate &clause,
llvm::SmallVectorImpl<mlir::Value> &allocatorOperands,
llvm::SmallVectorImpl<mlir::Value> &allocateOperands) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
mlir::Location currentLocation = converter.getCurrentLocation();
- Fortran::lower::StatementContext stmtCtx;
+ lower::StatementContext stmtCtx;
auto &objects = std::get<omp::ObjectList>(clause.t);
@@ -144,7 +144,7 @@ genDependKindAttr(fir::FirOpBuilder &firOpBuilder,
}
static mlir::Value
-getIfClauseOperand(Fortran::lower::AbstractConverter &converter,
+getIfClauseOperand(lower::AbstractConverter &converter,
const omp::clause::If &clause,
omp::clause::If::DirectiveNameModifier directiveName,
mlir::Location clauseLocation) {
@@ -154,7 +154,7 @@ getIfClauseOperand(Fortran::lower::AbstractConverter &converter,
if (directive && directive.value() != directiveName)
return nullptr;
- Fortran::lower::StatementContext stmtCtx;
+ lower::StatementContext stmtCtx;
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
mlir::Value ifVal = fir::getBase(
converter.genExprValue(std::get<omp::SomeExpr>(clause.t), stmtCtx));
@@ -163,12 +163,11 @@ getIfClauseOperand(Fortran::lower::AbstractConverter &converter,
}
static void addUseDeviceClause(
- Fortran::lower::AbstractConverter &converter,
- const omp::ObjectList &objects,
+ lower::AbstractConverter &converter, const omp::ObjectList &objects,
llvm::SmallVectorImpl<mlir::Value> &operands,
llvm::SmallVectorImpl<mlir::Type> &useDeviceTypes,
llvm::SmallVectorImpl<mlir::Location> &useDeviceLocs,
- llvm::SmallVectorImpl<const Fortran::semantics::Symbol *> &useDeviceSyms) {
+ llvm::SmallVectorImpl<const semantics::Symbol *> &useDeviceSyms) {
genObjectList(objects, converter, operands);
for (mlir::Value &operand : operands) {
checkMapType(operand.getLoc(), operand.getType());
@@ -179,7 +178,7 @@ static void addUseDeviceClause(
useDeviceSyms.push_back(object.id());
}
-static void convertLoopBounds(Fortran::lower::AbstractConverter &converter,
+static void convertLoopBounds(lower::AbstractConverter &converter,
mlir::Location loc,
mlir::omp::CollapseClauseOps &result,
std::size_t loopVarTypeSize) {
@@ -202,45 +201,43 @@ static void convertLoopBounds(Fortran::lower::AbstractConverter &converter,
//===----------------------------------------------------------------------===//
bool ClauseProcessor::processCollapse(
- mlir::Location currentLocation, Fortran::lower::pft::Evaluation &eval,
+ mlir::Location currentLocation, lower::pft::Evaluation &eval,
mlir::omp::CollapseClauseOps &result,
- llvm::SmallVectorImpl<const Fortran::semantics::Symbol *> &iv) const {
+ llvm::SmallVectorImpl<const semantics::Symbol *> &iv) const {
bool found = false;
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
// Collect the loops to collapse.
- Fortran::lower::pft::Evaluation *doConstructEval =
- &eval.getFirstNestedEvaluation();
- if (doConstructEval->getIf<Fortran::parser::DoConstruct>()
- ->IsDoConcurrent()) {
+ lower::pft::Evaluation *doConstructEval = &eval.getFirstNestedEvaluation();
+ if (doConstructEval->getIf<parser::DoConstruct>()->IsDoConcurrent()) {
TODO(currentLocation, "Do Concurrent in Worksharing loop construct");
}
std::int64_t collapseValue = 1l;
if (auto *clause = findUniqueClause<omp::clause::Collapse>()) {
- collapseValue = Fortran::evaluate::ToInt64(clause->v).value();
+ collapseValue = evaluate::ToInt64(clause->v).value();
found = true;
}
std::size_t loopVarTypeSize = 0;
do {
- Fortran::lower::pft::Evaluation *doLoop =
+ lower::pft::Evaluation *doLoop =
&doConstructEval->getFirstNestedEvaluation();
- auto *doStmt = doLoop->getIf<Fortran::parser::NonLabelDoStmt>();
+ auto *doStmt = doLoop->getIf<parser::NonLabelDoStmt>();
assert(doStmt && "Expected do loop to be in the nested evaluation");
const auto &loopControl =
- std::get<std::optional<Fortran::parser::LoopControl>>(doStmt->t);
- const Fortran::parser::LoopControl::Bounds *bounds =
- std::get_if<Fortran::parser::LoopControl::Bounds>(&loopControl->u);
+ std::get<std::optional<parser::LoopControl>>(doStmt->t);
+ const parser::LoopControl::Bounds *bounds =
+ std::get_if<parser::LoopControl::Bounds>(&loopControl->u);
assert(bounds && "Expected bounds for worksharing do loop");
- Fortran::lower::StatementContext stmtCtx;
- result.loopLBVar.push_back(fir::getBase(converter.genExprValue(
- *Fortran::semantics::GetExpr(bounds->lower), stmtCtx)));
- result.loopUBVar.push_back(fir::getBase(converter.genExprValue(
- *Fortran::semantics::GetExpr(bounds->upper), stmtCtx)));
+ lower::StatementContext stmtCtx;
+ result.loopLBVar.push_back(fir::getBase(
+ converter.genExprValue(*semantics::GetExpr(bounds->lower), stmtCtx)));
+ result.loopUBVar.push_back(fir::getBase(
+ converter.genExprValue(*semantics::GetExpr(bounds->upper), stmtCtx)));
if (bounds->step) {
- result.loopStepVar.push_back(fir::getBase(converter.genExprValue(
- *Fortran::semantics::GetExpr(bounds->step), stmtCtx)));
+ result.loopStepVar.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(
currentLocation, firOpBuilder.getIntegerType(32), 1));
@@ -280,9 +277,9 @@ bool ClauseProcessor::processDefault() const {
return false;
}
-bool ClauseProcessor::processDevice(Fortran::lower::StatementContext &stmtCtx,
+bool ClauseProcessor::processDevice(lower::StatementContext &stmtCtx,
mlir::omp::DeviceClauseOps &result) const {
- const Fortran::parser::CharBlock *source = nullptr;
+ const parser::CharBlock *source = nullptr;
if (auto *clause = findUniqueClause<omp::clause::Device>(&source)) {
mlir::Location clauseLocation = converter.genLocation(*source);
if (auto deviceModifier =
@@ -320,9 +317,9 @@ bool ClauseProcessor::processDeviceType(
return false;
}
-bool ClauseProcessor::processFinal(Fortran::lower::StatementContext &stmtCtx,
+bool ClauseProcessor::processFinal(lower::StatementContext &stmtCtx,
mlir::omp::FinalClauseOps &result) const {
- const Fortran::parser::CharBlock *source = nullptr;
+ const parser::CharBlock *source = nullptr;
if (auto *clause = findUniqueClause<omp::clause::Final>(&source)) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
mlir::Location clauseLocation = converter.genLocation(*source);
@@ -339,7 +336,7 @@ bool ClauseProcessor::processFinal(Fortran::lower::StatementContext &stmtCtx,
bool ClauseProcessor::processHint(mlir::omp::HintClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::Hint>()) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
- int64_t hintValue = *Fortran::evaluate::ToInt64(clause->v);
+ int64_t hintValue = *evaluate::ToInt64(clause->v);
result.hintAttr = firOpBuilder.getI64IntegerAttr(hintValue);
return true;
}
@@ -356,7 +353,7 @@ bool ClauseProcessor::processNowait(mlir::omp::NowaitClauseOps &result) const {
}
bool ClauseProcessor::processNumTeams(
- Fortran::lower::StatementContext &stmtCtx,
+ lower::StatementContext &stmtCtx,
mlir::omp::NumTeamsClauseOps &result) const {
// TODO Get lower and upper bounds for num_teams when parser is updated to
// accept both.
@@ -371,7 +368,7 @@ bool ClauseProcessor::processNumTeams(
}
bool ClauseProcessor::processNumThreads(
- Fortran::lower::StatementContext &stmtCtx,
+ lower::StatementContext &stmtCtx,
mlir::omp::NumThreadsClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::NumThreads>()) {
// OMPIRBuilder expects `NUM_THREADS` clause as a `Value`.
@@ -388,7 +385,7 @@ bool ClauseProcessor::processOrdered(
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
int64_t orderedClauseValue = 0l;
if (clause->v.has_value())
- orderedClauseValue = *Fortran::evaluate::ToInt64(*clause->v);
+ orderedClauseValue = *evaluate::ToInt64(*clause->v);
result.orderedAttr = firOpBuilder.getI64IntegerAttr(orderedClauseValue);
return true;
}
@@ -396,7 +393,7 @@ bool ClauseProcessor::processOrdered(
}
bool ClauseProcessor::processPriority(
- Fortran::lower::StatementContext &stmtCtx,
+ lower::StatementContext &stmtCtx,
mlir::omp::PriorityClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::Priority>()) {
result.priorityVar =
@@ -420,8 +417,7 @@ bool ClauseProcessor::processSafelen(
mlir::omp::SafelenClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::Safelen>()) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
- const std::optional<std::int64_t> safelenVal =
- Fortran::evaluate::ToInt64(clause->v);
+ const std::optional<std::int64_t> safelenVal = evaluate::ToInt64(clause->v);
result.safelenAttr = firOpBuilder.getI64IntegerAttr(*safelenVal);
return true;
}
@@ -429,7 +425,7 @@ bool ClauseProcessor::processSafelen(
}
bool ClauseProcessor::processSchedule(
- Fortran::lower::StatementContext &stmtCtx,
+ lower::StatementContext &stmtCtx,
mlir::omp::ScheduleClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::Schedule>()) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
@@ -479,8 +475,7 @@ bool ClauseProcessor::processSimdlen(
mlir::omp::SimdlenClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::Simdlen>()) {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
- const std::optional<std::int64_t> simdlenVal =
- Fortran::evaluate::ToInt64(clause->v);
+ const std::optional<std::int64_t> simdlenVal = evaluate::ToInt64(clause->v);
result.simdlenAttr = firOpBuilder.getI64IntegerAttr(*simdlenVal);
return true;
}
@@ -488,7 +483,7 @@ bool ClauseProcessor::processSimdlen(
}
bool ClauseProcessor::processThreadLimit(
- Fortran::lower::StatementContext &stmtCtx,
+ lower::StatementContext &stmtCtx,
mlir::omp::ThreadLimitClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::ThreadLimit>()) {
result.threadLimitVar =
@@ -509,8 +504,7 @@ bool ClauseProcessor::processUntied(mlir::omp::UntiedClauseOps &result) const {
bool ClauseProcessor::processAllocate(
mlir::omp::AllocateClauseOps &result) const {
return findRepeatableClause<omp::clause::Allocate>(
- [&](const omp::clause::Allocate &clause,
- const Fortran::parser::CharBlock &) {
+ [&](const omp::clause::Allocate &clause, const parser::CharBlock &) {
genAllocateClause(converter, clause, result.allocatorVars,
result.allocateVars);
});
@@ -521,30 +515,28 @@ bool ClauseProcessor::processCopyin() const {
mlir::OpBuilder::InsertPoint insPt = firOpBuilder.saveInsertionPoint();
firOpBuilder.setInsertionPointToStart(firOpBuilder.getAllocaBlock());
auto checkAndCopyHostAssociateVar =
- [&](Fortran::semantics::Symbol *sym,
+ [&](semantics::Symbol *sym,
mlir::OpBuilder::InsertPoint *copyAssignIP = nullptr) {
- assert(sym->has<Fortran::semantics::HostAssocDetails>() &&
+ assert(sym->has<semantics::HostAssocDetails>() &&
"No host-association found");
if (converter.isPresentShallowLookup(*sym))
converter.copyHostAssociateVar(*sym, copyAssignIP);
};
bool hasCopyin = findRepeatableClause<omp::clause::Copyin>(
- [&](const omp::clause::Copyin &clause,
- const Fortran::parser::CharBlock &) {
+ [&](const omp::clause::Copyin &clause, const parser::CharBlock &) {
for (const omp::Object &object : clause.v) {
- Fortran::semantics::Symbol *sym = object.id();
+ semantics::Symbol *sym = object.id();
assert(sym && "Expecting symbol");
if (const auto *commonDetails =
- sym->detailsIf<Fortran::semantics::CommonBlockDetails>()) {
+ sym->detailsIf<semantics::CommonBlockDetails>()) {
for (const auto &mem : commonDetails->objects())
checkAndCopyHostAssociateVar(&*mem, &insPt);
break;
}
- if (Fortran::semantics::IsAllocatableOrObjectPointer(
- &sym->GetUltimate()))
+ if (semantics::IsAllocatableOrObjectPointer(&sym->GetUltimate()))
TODO(converter.getCurrentLocation(),
"pointer or allocatable variables in Copyin clause");
- assert(sym->has<Fortran::semantics::HostAssocDetails>() &&
+ assert(sym->has<semantics::HostAssocDetails>() &&
"No host-association found");
checkAndCopyHostAssociateVar(sym);
}
@@ -616,7 +608,7 @@ void TypeInfo::typeScan(mlir::Type ty) {
// Create a function that performs a copy between two variables, compatible
// with their types and attributes.
static mlir::func::FuncOp
-createCopyFunc(mlir::Location loc, Fortran::lower::AbstractConverter &converter,
+createCopyFunc(mlir::Location loc, lower::AbstractConverter &converter,
mlir::Type varType, fir::FortranVariableFlagsEnum varAttrs) {
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::ModuleOp module = builder.getModule();
@@ -671,7 +663,7 @@ createCopyFunc(mlir::Location loc, Fortran::lower::AbstractConverter &converter,
bool ClauseProcessor::processCopyprivate(
mlir::Location currentLocation,
mlir::omp::CopyprivateClauseOps &result) const {
- auto addCopyPrivateVar = [&](Fortran::semantics::Symbol *sym) {
+ auto addCopyPrivateVar = [&](semantics::Symbol *sym) {
mlir::Value symVal = converter.getSymbolAddress(*sym);
auto declOp = symVal.getDefiningOp<hlfir::DeclareOp>();
if (!declOp)
@@ -704,12 +696,11 @@ bool ClauseProcessor::processCopyprivate(
};
bool hasCopyPrivate = findRepeatableClause<clause::Copyprivate>(
- [&](const clause::Copyprivate &clause,
- const Fortran::parser::CharBlock &) {
+ [&](const clause::Copyprivate &clause, const parser::CharBlock &) {
for (const Object &object : clause.v) {
- Fortran::semantics::Symbol *sym = object.id();
+ semantics::Symbol *sym = object.id();
if (const auto *commonDetails =
- sym->detailsIf<Fortran::semantics::CommonBlockDetails>()) {
+ sym->detailsIf<semantics::CommonBlockDetails>()) {
for (const auto &mem : commonDetails->objects())
addCopyPrivateVar(&*mem);
break;
@@ -725,8 +716,7 @@ bool ClauseProcessor::processDepend(mlir::omp::DependClauseOps &result) const {
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
return findRepeatableClause<omp::clause::Depend>(
- [&](const omp::clause::Depend &clause,
- const Fortran::parser::CharBlock &) {
+ [&](const omp::clause::Depend &clause, const parser::CharBlock &) {
using Depend = omp::clause::Depend;
assert(std::holds_alternative<Depend::WithLocators>(clause.u) &&
"Only the modern form is handled at the moment");
@@ -741,15 +731,15 @@ bool ClauseProcessor::processDepend(mlir::omp::DependClauseOps &result) const {
for (const omp::Object &object : objects) {
assert(object.ref() && "Expecting designator");
- if (Fortran::evaluate::ExtractSubstring(*object.ref())) {
+ if (evaluate::ExtractSubstring(*object.ref())) {
TODO(converter.getCurrentLocation(),
"substring not supported for task depend");
- } else if (Fortran::evaluate::IsArrayElement(*object.ref())) {
+ } else if (evaluate::IsArrayElement(*object.ref())) {
TODO(converter.getCurrentLocation(),
"array sections not supported for task depend");
}
- Fortran::semantics::Symbol *sym = object.id();
+ semantics::Symbol *sym = object.id();
const mlir::Value variable = converter.getSymbolAddress(*sym);
result.dependVars.push_back(variable);
}
@@ -760,11 +750,10 @@ bool ClauseProcessor::processHasDeviceAddr(
mlir::omp::HasDeviceAddrClauseOps &result,
llvm::SmallVectorImpl<mlir::Type> &isDeviceTypes,
llvm::SmallVectorImpl<mlir::Location> &isDeviceLocs,
- llvm::SmallVectorImpl<const Fortran::semantics::Symbol *> &isDeviceSymbols)
- const {
+ llvm::SmallVectorImpl<const semantics::Symbol *> &isDeviceSymbols) const {
return findRepeatableClause<omp::clause::HasDeviceAddr>(
[&](const omp::clause::HasDeviceAddr &devAddrClause,
- const Fortran::parser::CharBlock &) {
+ const parser::CharBlock &) {
addUseDeviceClause(converter, devAddrClause.v, result.hasDeviceAddrVars,
isDeviceTypes, isDeviceLocs, isDeviceSymbols);
});
@@ -774,19 +763,18 @@ bool ClauseProcessor::processIf(
omp::clause::If::DirectiveNameModifier directiveName,
mlir::omp::IfClauseOps &result) const {
bool found = false;
- findRepeatableClause<omp::clause::If>(
- [&](const omp::clause::If &clause,
- const Fortran::parser::CharBlock &source) {
- mlir::Location clauseLocation = converter.genLocation(source);
- mlir::Value operand = getIfClauseOperand(converter, clause,
- directiveName, clauseLocation);
- // Assume that, at most, a single 'if' clause will be applicable to the
- // given directive.
- if (operand) {
- result.ifVar = operand;
- found = true;
- }
- });
+ findRepeatableClause<omp::clause::If>([&](const omp::clause::If &clause,
+ const parser::CharBlock &source) {
+ mlir::Location clauseLocation = converter.genLocation(source);
+ mlir::Value operand =
+ getIfClauseOperand(converter, clause, directiveName, clauseLocation);
+ // Assume that, at most, a single 'if' clause will be applicable to the
+ // given directive.
+ if (operand) {
+ result.ifVar = operand;
+ found = true;
+ }
+ });
return found;
}
@@ -794,11 +782,10 @@ bool ClauseProcessor::processIsDevicePtr(
mlir::omp::IsDevicePtrClauseOps &result,
llvm::SmallVectorImpl<mlir::Type> &isDeviceTypes,
llvm::SmallVectorImpl<mlir::Location> &isDeviceLocs,
- llvm::SmallVectorImpl<const Fortran::semantics::Symbol *> &isDeviceSymbols)
- const {
+ llvm::SmallVectorImpl<const semantics::Symbol *> &isDeviceSymbols) const {
return findRepeatableClause<omp::clause::IsDevicePtr>(
[&](const omp::clause::IsDevicePtr &devPtrClause,
- const Fortran::parser::CharBlock &) {
+ const parser::CharBlock &) {
addUseDeviceClause(converter, devPtrClause.v, result.isDevicePtrVars,
isDeviceTypes, isDeviceLocs, isDeviceSymbols);
});
@@ -807,7 +794,7 @@ bool ClauseProcessor::processIsDevicePtr(
bool ClauseProcessor::processLink(
llvm::SmallVectorImpl<DeclareTargetCapturePair> &result) const {
return findRepeatableClause<omp::clause::Link>(
- [&](const omp::clause::Link &clause, const Fortran::parser::CharBlock &) {
+ [&](const omp::clause::Link &clause, const parser::CharBlock &) {
// Case: declare target...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/92298
More information about the flang-commits
mailing list