diff options
Diffstat (limited to 'flang/lib')
27 files changed, 810 insertions, 359 deletions
diff --git a/flang/lib/Frontend/CMakeLists.txt b/flang/lib/Frontend/CMakeLists.txt index fa0d5ec..2b3bc0e 100644 --- a/flang/lib/Frontend/CMakeLists.txt +++ b/flang/lib/Frontend/CMakeLists.txt @@ -19,6 +19,7 @@ add_flang_library(flangFrontend FIROptCodeGenPassIncGen FIROptTransformsPassIncGen HLFIRDialect + MIFDialect LINK_LIBS CUFDialect @@ -41,6 +42,7 @@ add_flang_library(flangFrontend FIROpenACCSupport FIROpenMPSupport FlangOpenMPTransforms + MIFDialect LINK_COMPONENTS Passes diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp index 0595ca0..3b711cc 100644 --- a/flang/lib/Lower/Bridge.cpp +++ b/flang/lib/Lower/Bridge.cpp @@ -58,6 +58,7 @@ #include "flang/Optimizer/Support/InternalNames.h" #include "flang/Optimizer/Transforms/Passes.h" #include "flang/Parser/parse-tree.h" +#include "flang/Parser/tools.h" #include "flang/Runtime/iostat-consts.h" #include "flang/Semantics/openmp-dsa.h" #include "flang/Semantics/runtime-type-info.h" @@ -3352,7 +3353,7 @@ private: &var.u)) { const Fortran::parser::Designator &designator = iDesignator->value(); if (const auto *name = - Fortran::semantics::getDesignatorNameIfDataRef(designator)) { + Fortran::parser::GetDesignatorNameIfDataRef(designator)) { auto val = getSymbolAddress(*name->symbol); reduceOperands.push_back(val); } diff --git a/flang/lib/Lower/CMakeLists.txt b/flang/lib/Lower/CMakeLists.txt index eb4d57d..3d0b4e4 100644 --- a/flang/lib/Lower/CMakeLists.txt +++ b/flang/lib/Lower/CMakeLists.txt @@ -45,6 +45,7 @@ add_flang_library(FortranLower FIRDialect FIRTransforms HLFIRDialect + MIFDialect LINK_LIBS CUFAttrs @@ -61,6 +62,7 @@ add_flang_library(FortranLower FortranEvaluate FortranSemantics FortranUtils + MIFDialect LINK_COMPONENTS Support diff --git a/flang/lib/Lower/OpenACC.cpp b/flang/lib/Lower/OpenACC.cpp index cfb1891..b3e8b69 100644 --- a/flang/lib/Lower/OpenACC.cpp +++ b/flang/lib/Lower/OpenACC.cpp @@ -30,10 +30,12 @@ #include "flang/Optimizer/Dialect/FIRType.h" #include "flang/Parser/parse-tree-visitor.h" #include "flang/Parser/parse-tree.h" +#include "flang/Parser/tools.h" #include "flang/Semantics/expression.h" #include "flang/Semantics/scope.h" #include "flang/Semantics/tools.h" #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" +#include "mlir/Dialect/OpenACC/OpenACCUtils.h" #include "mlir/IR/IRMapping.h" #include "mlir/IR/MLIRContext.h" #include "mlir/Support/LLVM.h" @@ -296,7 +298,7 @@ getSymbolFromAccObject(const Fortran::parser::AccObject &accObject) { if (const auto *designator = std::get_if<Fortran::parser::Designator>(&accObject.u)) { if (const auto *name = - Fortran::semantics::getDesignatorNameIfDataRef(*designator)) + Fortran::parser::GetDesignatorNameIfDataRef(*designator)) return *name->symbol; if (const auto *arrayElement = Fortran::parser::Unwrap<Fortran::parser::ArrayElement>( @@ -327,7 +329,8 @@ genAtomicCaptureStatement(Fortran::lower::AbstractConverter &converter, fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder(); mlir::acc::AtomicReadOp::create(firOpBuilder, loc, fromAddress, toAddress, - mlir::TypeAttr::get(elementType)); + mlir::TypeAttr::get(elementType), + /*ifCond=*/mlir::Value{}); } /// Used to generate atomic.write operation which is created in existing @@ -347,7 +350,8 @@ genAtomicWriteStatement(Fortran::lower::AbstractConverter &converter, rhsExpr = firOpBuilder.createConvert(loc, varType, rhsExpr); firOpBuilder.restoreInsertionPoint(insertionPoint); - mlir::acc::AtomicWriteOp::create(firOpBuilder, loc, lhsAddr, rhsExpr); + mlir::acc::AtomicWriteOp::create(firOpBuilder, loc, lhsAddr, rhsExpr, + /*ifCond=*/mlir::Value{}); } /// Used to generate atomic.update operation which is created in existing @@ -463,7 +467,8 @@ static inline void genAtomicUpdateStatement( mlir::Operation *atomicUpdateOp = nullptr; atomicUpdateOp = - mlir::acc::AtomicUpdateOp::create(firOpBuilder, currentLocation, lhsAddr); + mlir::acc::AtomicUpdateOp::create(firOpBuilder, currentLocation, lhsAddr, + /*ifCond=*/mlir::Value{}); llvm::SmallVector<mlir::Type> varTys = {varType}; llvm::SmallVector<mlir::Location> locs = {currentLocation}; @@ -588,7 +593,9 @@ void genAtomicCapture(Fortran::lower::AbstractConverter &converter, fir::getBase(converter.genExprValue(assign2.lhs, stmtCtx)).getType(); mlir::Operation *atomicCaptureOp = nullptr; - atomicCaptureOp = mlir::acc::AtomicCaptureOp::create(firOpBuilder, loc); + atomicCaptureOp = + mlir::acc::AtomicCaptureOp::create(firOpBuilder, loc, + /*ifCond=*/mlir::Value{}); firOpBuilder.createBlock(&(atomicCaptureOp->getRegion(0))); mlir::Block &block = atomicCaptureOp->getRegion(0).back(); @@ -2712,12 +2719,19 @@ genACC(Fortran::lower::AbstractConverter &converter, const auto &loopDirective = std::get<Fortran::parser::AccLoopDirective>(beginLoopDirective.t); + mlir::Location currentLocation = + converter.genLocation(beginLoopDirective.source); bool needEarlyExitHandling = false; - if (eval.lowerAsUnstructured()) + if (eval.lowerAsUnstructured()) { needEarlyExitHandling = hasEarlyReturn(eval); + // If the loop is lowered in an unstructured fashion, lowering generates + // explicit control flow that duplicates the looping semantics of the + // loops. + if (!needEarlyExitHandling) + TODO(currentLocation, + "loop with early exit inside OpenACC loop construct"); + } - mlir::Location currentLocation = - converter.genLocation(beginLoopDirective.source); Fortran::lower::StatementContext stmtCtx; assert(loopDirective.v == llvm::acc::ACCD_loop && @@ -2900,7 +2914,7 @@ static Op createComputeOp( if (const auto *designator = std::get_if<Fortran::parser::Designator>(&accObject.u)) { if (const auto *name = - Fortran::semantics::getDesignatorNameIfDataRef( + Fortran::parser::GetDesignatorNameIfDataRef( *designator)) { auto cond = converter.getSymbolAddress(*name->symbol); selfCond = builder.createConvert(clauseLocation, @@ -3516,6 +3530,10 @@ genACC(Fortran::lower::AbstractConverter &converter, converter.genLocation(beginCombinedDirective.source); Fortran::lower::StatementContext stmtCtx; + if (eval.lowerAsUnstructured()) + TODO(currentLocation, + "loop with early exit inside OpenACC combined construct"); + if (combinedDirective.v == llvm::acc::ACCD_kernels_loop) { createComputeOp<mlir::acc::KernelsOp>( converter, currentLocation, eval, semanticsContext, stmtCtx, @@ -4261,8 +4279,7 @@ static void genGlobalCtors(Fortran::lower::AbstractConverter &converter, Fortran::common::visitors{ [&](const Fortran::parser::Designator &designator) { if (const auto *name = - Fortran::semantics::getDesignatorNameIfDataRef( - designator)) { + Fortran::parser::GetDesignatorNameIfDataRef(designator)) { genCtors(operandLocation, *name->symbol); } }, diff --git a/flang/lib/Lower/OpenMP/Clauses.cpp b/flang/lib/Lower/OpenMP/Clauses.cpp index ba34212..2a4ebf1 100644 --- a/flang/lib/Lower/OpenMP/Clauses.cpp +++ b/flang/lib/Lower/OpenMP/Clauses.cpp @@ -740,6 +740,18 @@ Device make(const parser::OmpClause::Device &inp, /*DeviceDescription=*/makeExpr(t1, semaCtx)}}; } +DeviceSafesync make(const parser::OmpClause::DeviceSafesync &inp, + semantics::SemanticsContext &semaCtx) { + // inp.v -> std::optional<parser::OmpDeviceSafesyncClause> + auto &&maybeRequired = maybeApply( + [&](const parser::OmpDeviceSafesyncClause &c) { + return makeExpr(c.v, semaCtx); + }, + inp.v); + + return DeviceSafesync{/*Required=*/std::move(maybeRequired)}; +} + DeviceType make(const parser::OmpClause::DeviceType &inp, semantics::SemanticsContext &semaCtx) { // inp.v -> parser::OmpDeviceTypeClause diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp index f86ee01..9495ea6 100644 --- a/flang/lib/Lower/OpenMP/OpenMP.cpp +++ b/flang/lib/Lower/OpenMP/OpenMP.cpp @@ -33,6 +33,7 @@ #include "flang/Parser/characters.h" #include "flang/Parser/openmp-utils.h" #include "flang/Parser/parse-tree.h" +#include "flang/Parser/tools.h" #include "flang/Semantics/openmp-directive-sets.h" #include "flang/Semantics/openmp-utils.h" #include "flang/Semantics/tools.h" @@ -3884,7 +3885,7 @@ static void genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable, assert(object && "Expecting object as argument"); auto *designator = semantics::omp::GetDesignatorFromObj(*object); assert(designator && "Expecting desginator in argument"); - auto *name = semantics::getDesignatorNameIfDataRef(*designator); + auto *name = parser::GetDesignatorNameIfDataRef(*designator); assert(name && "Expecting dataref in designator"); critName = *name; } diff --git a/flang/lib/Lower/Runtime.cpp b/flang/lib/Lower/Runtime.cpp index b19ca01..cb55524 100644 --- a/flang/lib/Lower/Runtime.cpp +++ b/flang/lib/Lower/Runtime.cpp @@ -12,10 +12,10 @@ #include "flang/Lower/OpenMP.h" #include "flang/Lower/StatementContext.h" #include "flang/Optimizer/Builder/FIRBuilder.h" -#include "flang/Optimizer/Builder/Runtime/Coarray.h" #include "flang/Optimizer/Builder/Runtime/RTBuilder.h" #include "flang/Optimizer/Builder/Todo.h" #include "flang/Optimizer/Dialect/FIROpsSupport.h" +#include "flang/Optimizer/Dialect/MIF/MIFOps.h" #include "flang/Parser/parse-tree.h" #include "flang/Runtime/misc-intrinsic.h" #include "flang/Runtime/pointer.h" @@ -52,7 +52,6 @@ static void genUnreachable(fir::FirOpBuilder &builder, mlir::Location loc) { static std::pair<mlir::Value, mlir::Value> getStatAndErrmsg( Fortran::lower::AbstractConverter &converter, mlir::Location loc, const std::list<Fortran::parser::StatOrErrmsg> &statOrErrList) { - fir::FirOpBuilder &builder = converter.getFirOpBuilder(); Fortran::lower::StatementContext stmtCtx; mlir::Value errMsgExpr, statExpr; @@ -71,16 +70,6 @@ static std::pair<mlir::Value, mlir::Value> getStatAndErrmsg( statOrErr.u); } - if (!statExpr) { - statExpr = fir::AbsentOp::create(builder, loc, - builder.getRefType(builder.getI32Type())); - } - if (!errMsgExpr) { - errMsgExpr = fir::AbsentOp::create( - builder, loc, - fir::BoxType::get(fir::CharacterType::get( - builder.getContext(), 1, fir::CharacterType::unknownLen()))); - } return {statExpr, errMsgExpr}; } @@ -215,7 +204,7 @@ void Fortran::lower::genSyncAllStatement( auto [statAddr, errMsgAddr] = getStatAndErrmsg(converter, loc, statOrErrList); fir::FirOpBuilder &builder = converter.getFirOpBuilder(); - fir::runtime::genSyncAllStatement(builder, loc, statAddr, errMsgAddr); + mif::SyncAllOp::create(builder, loc, statAddr, errMsgAddr); } void Fortran::lower::genSyncImagesStatement( @@ -244,16 +233,12 @@ void Fortran::lower::genSyncImagesStatement( fir::getBase(converter.genExprBox(loc, *expr, stmtCtx)); }, [&](const Fortran::parser::Star &) { - imageSet = fir::AbsentOp::create( - builder, loc, - fir::BoxType::get(fir::SequenceType::get( - {fir::SequenceType::getUnknownExtent()}, - builder.getI32Type()))); + // Image set is not set. + imageSet = mlir::Value{}; }}, imgSet.u); - fir::runtime::genSyncImagesStatement(builder, loc, imageSet, statAddr, - errMsgAddr); + mif::SyncImagesOp::create(builder, loc, imageSet, statAddr, errMsgAddr); } void Fortran::lower::genSyncMemoryStatement( @@ -267,7 +252,7 @@ void Fortran::lower::genSyncMemoryStatement( auto [statAddr, errMsgAddr] = getStatAndErrmsg(converter, loc, statOrErrList); fir::FirOpBuilder &builder = converter.getFirOpBuilder(); - fir::runtime::genSyncMemoryStatement(builder, loc, statAddr, errMsgAddr); + mif::SyncMemoryOp::create(builder, loc, statAddr, errMsgAddr); } void Fortran::lower::genSyncTeamStatement( diff --git a/flang/lib/Optimizer/Builder/CMakeLists.txt b/flang/lib/Optimizer/Builder/CMakeLists.txt index 404afd1..1f95259 100644 --- a/flang/lib/Optimizer/Builder/CMakeLists.txt +++ b/flang/lib/Optimizer/Builder/CMakeLists.txt @@ -16,7 +16,6 @@ add_flang_library(FIRBuilder Runtime/Allocatable.cpp Runtime/ArrayConstructor.cpp Runtime/Assign.cpp - Runtime/Coarray.cpp Runtime/Character.cpp Runtime/Command.cpp Runtime/CUDA/Descriptor.cpp @@ -42,6 +41,7 @@ add_flang_library(FIRBuilder CUFDialect FIRDialect HLFIRDialect + MIFDialect LINK_LIBS CUFAttrs @@ -52,6 +52,7 @@ add_flang_library(FIRBuilder FortranEvaluate FortranSupport HLFIRDialect + MIFDialect MLIR_DEPS ${dialect_libs} diff --git a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp index 0195178..29eedfb 100644 --- a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp +++ b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp @@ -25,7 +25,6 @@ #include "flang/Optimizer/Builder/Runtime/Allocatable.h" #include "flang/Optimizer/Builder/Runtime/CUDA/Descriptor.h" #include "flang/Optimizer/Builder/Runtime/Character.h" -#include "flang/Optimizer/Builder/Runtime/Coarray.h" #include "flang/Optimizer/Builder/Runtime/Command.h" #include "flang/Optimizer/Builder/Runtime/Derived.h" #include "flang/Optimizer/Builder/Runtime/Exceptions.h" @@ -40,6 +39,7 @@ #include "flang/Optimizer/Builder/Todo.h" #include "flang/Optimizer/Dialect/FIROps.h" #include "flang/Optimizer/Dialect/FIROpsSupport.h" +#include "flang/Optimizer/Dialect/MIF/MIFOps.h" #include "flang/Optimizer/Dialect/Support/FIRContext.h" #include "flang/Optimizer/HLFIR/HLFIROps.h" #include "flang/Optimizer/Support/FatalError.h" @@ -412,28 +412,28 @@ static constexpr IntrinsicHandler handlers[]{ {"co_broadcast", &I::genCoBroadcast, {{{"a", asBox}, - {"source_image", asAddr}, + {"source_image", asValue}, {"stat", asAddr, handleDynamicOptional}, {"errmsg", asBox, handleDynamicOptional}}}, /*isElemental*/ false}, {"co_max", &I::genCoMax, {{{"a", asBox}, - {"result_image", asAddr, handleDynamicOptional}, + {"result_image", asValue, handleDynamicOptional}, {"stat", asAddr, handleDynamicOptional}, {"errmsg", asBox, handleDynamicOptional}}}, /*isElemental*/ false}, {"co_min", &I::genCoMin, {{{"a", asBox}, - {"result_image", asAddr, handleDynamicOptional}, + {"result_image", asValue, handleDynamicOptional}, {"stat", asAddr, handleDynamicOptional}, {"errmsg", asBox, handleDynamicOptional}}}, /*isElemental*/ false}, {"co_sum", &I::genCoSum, {{{"a", asBox}, - {"result_image", asAddr, handleDynamicOptional}, + {"result_image", asValue, handleDynamicOptional}, {"stat", asAddr, handleDynamicOptional}, {"errmsg", asBox, handleDynamicOptional}}}, /*isElemental*/ false}, @@ -829,7 +829,7 @@ static constexpr IntrinsicHandler handlers[]{ {"null", &I::genNull, {{{"mold", asInquired}}}, /*isElemental=*/false}, {"num_images", &I::genNumImages, - {{{"team", asAddr}, {"team_number", asAddr}}}, + {{{"team_number", asValue}, {"team", asBox}}}, /*isElemental*/ false}, {"pack", &I::genPack, @@ -3516,11 +3516,23 @@ static mlir::Value getAddrFromBox(fir::FirOpBuilder &builder, return addr; } +static void clocDeviceArgRewrite(fir::ExtendedValue arg) { + // Special case for device address in c_loc. + if (auto emboxOp = mlir::dyn_cast_or_null<fir::EmboxOp>( + fir::getBase(arg).getDefiningOp())) + if (auto declareOp = mlir::dyn_cast_or_null<hlfir::DeclareOp>( + emboxOp.getMemref().getDefiningOp())) + if (declareOp.getDataAttr() && + declareOp.getDataAttr() == cuf::DataAttribute::Device) + emboxOp.getMemrefMutable().assign(declareOp.getMemref()); +} + static fir::ExtendedValue genCLocOrCFunLoc(fir::FirOpBuilder &builder, mlir::Location loc, mlir::Type resultType, llvm::ArrayRef<fir::ExtendedValue> args, bool isFunc = false, bool isDevLoc = false) { assert(args.size() == 1); + clocDeviceArgRewrite(args[0]); mlir::Value res = fir::AllocaOp::create(builder, loc, resultType); mlir::Value resAddr; if (isDevLoc) @@ -3795,79 +3807,40 @@ mlir::Value IntrinsicLibrary::genCmplx(mlir::Type resultType, void IntrinsicLibrary::genCoBroadcast(llvm::ArrayRef<fir::ExtendedValue> args) { converter->checkCoarrayEnabled(); assert(args.size() == 4); - mlir::Value sourceImage = fir::getBase(args[1]); - mlir::Value status = - isStaticallyAbsent(args[2]) - ? fir::AbsentOp::create(builder, loc, - builder.getRefType(builder.getI32Type())) - .getResult() - : fir::getBase(args[2]); - mlir::Value errmsg = - isStaticallyAbsent(args[3]) - ? fir::AbsentOp::create(builder, loc, PRIF_ERRMSG_TYPE).getResult() - : fir::getBase(args[3]); - fir::runtime::genCoBroadcast(builder, loc, fir::getBase(args[0]), sourceImage, - status, errmsg); + mif::CoBroadcastOp::create(builder, loc, fir::getBase(args[0]), + /*sourceImage*/ fir::getBase(args[1]), + /*status*/ fir::getBase(args[2]), + /*errmsg*/ fir::getBase(args[3])); } // CO_MAX void IntrinsicLibrary::genCoMax(llvm::ArrayRef<fir::ExtendedValue> args) { converter->checkCoarrayEnabled(); assert(args.size() == 4); - mlir::Value refNone = - fir::AbsentOp::create(builder, loc, - builder.getRefType(builder.getI32Type())) - .getResult(); - mlir::Value resultImage = - isStaticallyAbsent(args[1]) ? refNone : fir::getBase(args[1]); - mlir::Value status = - isStaticallyAbsent(args[2]) ? refNone : fir::getBase(args[2]); - mlir::Value errmsg = - isStaticallyAbsent(args[3]) - ? fir::AbsentOp::create(builder, loc, PRIF_ERRMSG_TYPE).getResult() - : fir::getBase(args[3]); - fir::runtime::genCoMax(builder, loc, fir::getBase(args[0]), resultImage, - status, errmsg); + mif::CoMaxOp::create(builder, loc, fir::getBase(args[0]), + /*resultImage*/ fir::getBase(args[1]), + /*status*/ fir::getBase(args[2]), + /*errmsg*/ fir::getBase(args[3])); } // CO_MIN void IntrinsicLibrary::genCoMin(llvm::ArrayRef<fir::ExtendedValue> args) { converter->checkCoarrayEnabled(); assert(args.size() == 4); - mlir::Value refNone = - fir::AbsentOp::create(builder, loc, - builder.getRefType(builder.getI32Type())) - .getResult(); - mlir::Value resultImage = - isStaticallyAbsent(args[1]) ? refNone : fir::getBase(args[1]); - mlir::Value status = - isStaticallyAbsent(args[2]) ? refNone : fir::getBase(args[2]); - mlir::Value errmsg = - isStaticallyAbsent(args[3]) - ? fir::AbsentOp::create(builder, loc, PRIF_ERRMSG_TYPE).getResult() - : fir::getBase(args[3]); - fir::runtime::genCoMin(builder, loc, fir::getBase(args[0]), resultImage, - status, errmsg); + mif::CoMinOp::create(builder, loc, fir::getBase(args[0]), + /*resultImage*/ fir::getBase(args[1]), + /*status*/ fir::getBase(args[2]), + /*errmsg*/ fir::getBase(args[3])); } // CO_SUM void IntrinsicLibrary::genCoSum(llvm::ArrayRef<fir::ExtendedValue> args) { converter->checkCoarrayEnabled(); assert(args.size() == 4); - mlir::Value absentInt = - fir::AbsentOp::create(builder, loc, - builder.getRefType(builder.getI32Type())) - .getResult(); - mlir::Value resultImage = - isStaticallyAbsent(args[1]) ? absentInt : fir::getBase(args[1]); - mlir::Value status = - isStaticallyAbsent(args[2]) ? absentInt : fir::getBase(args[2]); - mlir::Value errmsg = - isStaticallyAbsent(args[3]) - ? fir::AbsentOp::create(builder, loc, PRIF_ERRMSG_TYPE).getResult() - : fir::getBase(args[3]); - fir::runtime::genCoSum(builder, loc, fir::getBase(args[0]), resultImage, - status, errmsg); + mif::CoSumOp::create(builder, loc, fir::getBase(args[0]), + /*resultImage*/ fir::getBase(args[1]), + /*status*/ fir::getBase(args[2]), + /*errmsg*/ fir::getBase(args[3])); } // COMMAND_ARGUMENT_COUNT @@ -7579,9 +7552,9 @@ IntrinsicLibrary::genNumImages(mlir::Type resultType, assert(args.size() == 0 || args.size() == 1); if (args.size()) - return fir::runtime::getNumImagesWithTeam(builder, loc, - fir::getBase(args[0])); - return fir::runtime::getNumImages(builder, loc); + return mif::NumImagesOp::create(builder, loc, fir::getBase(args[0])) + .getResult(); + return mif::NumImagesOp::create(builder, loc).getResult(); } // CLOCK, CLOCK64, GLOBALTIMER @@ -8659,17 +8632,11 @@ IntrinsicLibrary::genThisImage(mlir::Type resultType, converter->checkCoarrayEnabled(); assert(args.size() >= 1 && args.size() <= 3); const bool coarrayIsAbsent = args.size() == 1; - mlir::Value team = - !isStaticallyAbsent(args, args.size() - 1) - ? fir::getBase(args[args.size() - 1]) - : builder - .create<fir::AbsentOp>(loc, - fir::BoxType::get(builder.getNoneType())) - .getResult(); + mlir::Value team = fir::getBase(args[args.size() - 1]); if (!coarrayIsAbsent) TODO(loc, "this_image with coarray argument."); - mlir::Value res = fir::runtime::getThisImage(builder, loc, team); + mlir::Value res = mif::ThisImageOp::create(builder, loc, team); return builder.createConvert(loc, resultType, res); } diff --git a/flang/lib/Optimizer/Builder/Runtime/Coarray.cpp b/flang/lib/Optimizer/Builder/Runtime/Coarray.cpp deleted file mode 100644 index 364e7b7..0000000 --- a/flang/lib/Optimizer/Builder/Runtime/Coarray.cpp +++ /dev/null @@ -1,228 +0,0 @@ -//===-- Coarray.cpp -- runtime API for coarray intrinsics -----------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#include "flang/Optimizer/Builder/Runtime/Coarray.h" -#include "flang/Optimizer/Builder/FIRBuilder.h" -#include "flang/Optimizer/Builder/Runtime/RTBuilder.h" -#include "mlir/Dialect/Func/IR/FuncOps.h" - -using namespace Fortran::runtime; -using namespace Fortran::semantics; - -// Most PRIF functions take `errmsg` and `errmsg_alloc` as two optional -// arguments of intent (out). One is allocatable, the other is not. -// It is the responsibility of the compiler to ensure that the appropriate -// optional argument is passed, and at most one must be provided in a given -// call. -// Depending on the type of `errmsg`, this function will return the pair -// corresponding to (`errmsg`, `errmsg_alloc`). -static std::pair<mlir::Value, mlir::Value> -genErrmsgPRIF(fir::FirOpBuilder &builder, mlir::Location loc, - mlir::Value errmsg) { - bool isAllocatableErrmsg = fir::isAllocatableType(errmsg.getType()); - - mlir::Value absent = fir::AbsentOp::create(builder, loc, PRIF_ERRMSG_TYPE); - mlir::Value errMsg = isAllocatableErrmsg ? absent : errmsg; - mlir::Value errMsgAlloc = isAllocatableErrmsg ? errmsg : absent; - return {errMsg, errMsgAlloc}; -} - -/// Generate Call to runtime prif_init -mlir::Value fir::runtime::genInitCoarray(fir::FirOpBuilder &builder, - mlir::Location loc) { - mlir::Type i32Ty = builder.getI32Type(); - mlir::Value result = builder.createTemporary(loc, i32Ty); - mlir::FunctionType ftype = PRIF_FUNCTYPE(builder.getRefType(i32Ty)); - mlir::func::FuncOp funcOp = - builder.createFunction(loc, PRIFNAME_SUB("init"), ftype); - llvm::SmallVector<mlir::Value> args = - fir::runtime::createArguments(builder, loc, ftype, result); - fir::CallOp::create(builder, loc, funcOp, args); - return fir::LoadOp::create(builder, loc, result); -} - -/// Generate Call to runtime prif_num_images -mlir::Value fir::runtime::getNumImages(fir::FirOpBuilder &builder, - mlir::Location loc) { - mlir::Value result = builder.createTemporary(loc, builder.getI32Type()); - mlir::FunctionType ftype = - PRIF_FUNCTYPE(builder.getRefType(builder.getI32Type())); - mlir::func::FuncOp funcOp = - builder.createFunction(loc, PRIFNAME_SUB("num_images"), ftype); - llvm::SmallVector<mlir::Value> args = - fir::runtime::createArguments(builder, loc, ftype, result); - fir::CallOp::create(builder, loc, funcOp, args); - return fir::LoadOp::create(builder, loc, result); -} - -/// Generate Call to runtime prif_num_images_with_{team|team_number} -mlir::Value fir::runtime::getNumImagesWithTeam(fir::FirOpBuilder &builder, - mlir::Location loc, - mlir::Value team) { - bool isTeamNumber = fir::unwrapPassByRefType(team.getType()).isInteger(); - std::string numImagesName = isTeamNumber - ? PRIFNAME_SUB("num_images_with_team_number") - : PRIFNAME_SUB("num_images_with_team"); - - mlir::Value result = builder.createTemporary(loc, builder.getI32Type()); - mlir::Type refTy = builder.getRefType(builder.getI32Type()); - mlir::FunctionType ftype = - isTeamNumber - ? PRIF_FUNCTYPE(builder.getRefType(builder.getI64Type()), refTy) - : PRIF_FUNCTYPE(fir::BoxType::get(builder.getNoneType()), refTy); - mlir::func::FuncOp funcOp = builder.createFunction(loc, numImagesName, ftype); - - if (!isTeamNumber) - team = builder.createBox(loc, team); - llvm::SmallVector<mlir::Value> args = - fir::runtime::createArguments(builder, loc, ftype, team, result); - fir::CallOp::create(builder, loc, funcOp, args); - return fir::LoadOp::create(builder, loc, result); -} - -/// Generate Call to runtime prif_this_image_no_coarray -mlir::Value fir::runtime::getThisImage(fir::FirOpBuilder &builder, - mlir::Location loc, mlir::Value team) { - mlir::Type refTy = builder.getRefType(builder.getI32Type()); - mlir::Type boxTy = fir::BoxType::get(builder.getNoneType()); - mlir::FunctionType ftype = PRIF_FUNCTYPE(boxTy, refTy); - mlir::func::FuncOp funcOp = - builder.createFunction(loc, PRIFNAME_SUB("this_image_no_coarray"), ftype); - - mlir::Value result = builder.createTemporary(loc, builder.getI32Type()); - mlir::Value teamArg = - !team ? fir::AbsentOp::create(builder, loc, boxTy) : team; - llvm::SmallVector<mlir::Value> args = - fir::runtime::createArguments(builder, loc, ftype, teamArg, result); - fir::CallOp::create(builder, loc, funcOp, args); - return fir::LoadOp::create(builder, loc, result); -} - -/// Generate call to collective subroutines except co_reduce -/// A must be lowered as a box -void genCollectiveSubroutine(fir::FirOpBuilder &builder, mlir::Location loc, - mlir::Value A, mlir::Value rootImage, - mlir::Value stat, mlir::Value errmsg, - std::string coName) { - mlir::Type boxTy = fir::BoxType::get(builder.getNoneType()); - mlir::FunctionType ftype = - PRIF_FUNCTYPE(boxTy, builder.getRefType(builder.getI32Type()), - PRIF_STAT_TYPE, PRIF_ERRMSG_TYPE, PRIF_ERRMSG_TYPE); - mlir::func::FuncOp funcOp = builder.createFunction(loc, coName, ftype); - - auto [errmsgArg, errmsgAllocArg] = genErrmsgPRIF(builder, loc, errmsg); - llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( - builder, loc, ftype, A, rootImage, stat, errmsgArg, errmsgAllocArg); - fir::CallOp::create(builder, loc, funcOp, args); -} - -/// Generate call to runtime subroutine prif_co_broadcast -void fir::runtime::genCoBroadcast(fir::FirOpBuilder &builder, - mlir::Location loc, mlir::Value A, - mlir::Value sourceImage, mlir::Value stat, - mlir::Value errmsg) { - genCollectiveSubroutine(builder, loc, A, sourceImage, stat, errmsg, - PRIFNAME_SUB("co_broadcast")); -} - -/// Generate call to runtime subroutine prif_co_max or prif_co_max_character -void fir::runtime::genCoMax(fir::FirOpBuilder &builder, mlir::Location loc, - mlir::Value A, mlir::Value resultImage, - mlir::Value stat, mlir::Value errmsg) { - mlir::Type argTy = - fir::unwrapSequenceType(fir::unwrapPassByRefType(A.getType())); - if (mlir::isa<fir::CharacterType>(argTy)) - genCollectiveSubroutine(builder, loc, A, resultImage, stat, errmsg, - PRIFNAME_SUB("co_max_character")); - else - genCollectiveSubroutine(builder, loc, A, resultImage, stat, errmsg, - PRIFNAME_SUB("co_max")); -} - -/// Generate call to runtime subroutine prif_co_min or prif_co_min_character -void fir::runtime::genCoMin(fir::FirOpBuilder &builder, mlir::Location loc, - mlir::Value A, mlir::Value resultImage, - mlir::Value stat, mlir::Value errmsg) { - mlir::Type argTy = - fir::unwrapSequenceType(fir::unwrapPassByRefType(A.getType())); - if (mlir::isa<fir::CharacterType>(argTy)) - genCollectiveSubroutine(builder, loc, A, resultImage, stat, errmsg, - PRIFNAME_SUB("co_min_character")); - else - genCollectiveSubroutine(builder, loc, A, resultImage, stat, errmsg, - PRIFNAME_SUB("co_min")); -} - -/// Generate call to runtime subroutine prif_co_sum -void fir::runtime::genCoSum(fir::FirOpBuilder &builder, mlir::Location loc, - mlir::Value A, mlir::Value resultImage, - mlir::Value stat, mlir::Value errmsg) { - genCollectiveSubroutine(builder, loc, A, resultImage, stat, errmsg, - PRIFNAME_SUB("co_sum")); -} - -/// Generate call to runtime subroutine prif_sync_all -void fir::runtime::genSyncAllStatement(fir::FirOpBuilder &builder, - mlir::Location loc, mlir::Value stat, - mlir::Value errmsg) { - mlir::FunctionType ftype = - PRIF_FUNCTYPE(PRIF_STAT_TYPE, PRIF_ERRMSG_TYPE, PRIF_ERRMSG_TYPE); - mlir::func::FuncOp funcOp = - builder.createFunction(loc, PRIFNAME_SUB("sync_all"), ftype); - - auto [errmsgArg, errmsgAllocArg] = genErrmsgPRIF(builder, loc, errmsg); - llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( - builder, loc, ftype, stat, errmsgArg, errmsgAllocArg); - fir::CallOp::create(builder, loc, funcOp, args); -} - -/// Generate call to runtime subroutine prif_sync_memory -void fir::runtime::genSyncMemoryStatement(fir::FirOpBuilder &builder, - mlir::Location loc, mlir::Value stat, - mlir::Value errmsg) { - mlir::FunctionType ftype = - PRIF_FUNCTYPE(PRIF_STAT_TYPE, PRIF_ERRMSG_TYPE, PRIF_ERRMSG_TYPE); - mlir::func::FuncOp funcOp = - builder.createFunction(loc, PRIFNAME_SUB("sync_memory"), ftype); - - auto [errmsgArg, errmsgAllocArg] = genErrmsgPRIF(builder, loc, errmsg); - llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( - builder, loc, ftype, stat, errmsgArg, errmsgAllocArg); - fir::CallOp::create(builder, loc, funcOp, args); -} - -/// Generate call to runtime subroutine prif_sync_images -void fir::runtime::genSyncImagesStatement(fir::FirOpBuilder &builder, - mlir::Location loc, - mlir::Value imageSet, - mlir::Value stat, - mlir::Value errmsg) { - mlir::Type imgSetTy = fir::BoxType::get(fir::SequenceType::get( - {fir::SequenceType::getUnknownExtent()}, builder.getI32Type())); - mlir::FunctionType ftype = PRIF_FUNCTYPE(imgSetTy, PRIF_STAT_TYPE, - PRIF_ERRMSG_TYPE, PRIF_ERRMSG_TYPE); - mlir::func::FuncOp funcOp = - builder.createFunction(loc, PRIFNAME_SUB("sync_images"), ftype); - - // If imageSet is scalar, PRIF require to pass an array of size 1. - if (auto boxTy = mlir::dyn_cast<fir::BoxType>(imageSet.getType())) { - if (!mlir::isa<fir::SequenceType>(boxTy.getEleTy())) { - mlir::Value one = - builder.createIntegerConstant(loc, builder.getI32Type(), 1); - mlir::Value shape = fir::ShapeOp::create(builder, loc, one); - imageSet = fir::ReboxOp::create( - builder, loc, - fir::BoxType::get(fir::SequenceType::get({1}, builder.getI32Type())), - imageSet, shape, mlir::Value{}); - } - } - auto [errmsgArg, errmsgAllocArg] = genErrmsgPRIF(builder, loc, errmsg); - llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( - builder, loc, ftype, imageSet, stat, errmsgArg, errmsgAllocArg); - fir::CallOp::create(builder, loc, funcOp, args); -} diff --git a/flang/lib/Optimizer/Builder/Runtime/Main.cpp b/flang/lib/Optimizer/Builder/Runtime/Main.cpp index d303e0a..9ce5e17 100644 --- a/flang/lib/Optimizer/Builder/Runtime/Main.cpp +++ b/flang/lib/Optimizer/Builder/Runtime/Main.cpp @@ -10,11 +10,11 @@ #include "flang/Lower/EnvironmentDefault.h" #include "flang/Optimizer/Builder/BoxValue.h" #include "flang/Optimizer/Builder/FIRBuilder.h" -#include "flang/Optimizer/Builder/Runtime/Coarray.h" #include "flang/Optimizer/Builder/Runtime/EnvironmentDefaults.h" #include "flang/Optimizer/Builder/Runtime/RTBuilder.h" #include "flang/Optimizer/Dialect/FIROps.h" #include "flang/Optimizer/Dialect/FIRType.h" +#include "flang/Optimizer/Dialect/MIF/MIFOps.h" #include "flang/Runtime/CUDA/init.h" #include "flang/Runtime/main.h" #include "flang/Runtime/stop.h" @@ -71,7 +71,7 @@ void fir::runtime::genMain( fir::CallOp::create(builder, loc, initFn); } if (initCoarrayEnv) - fir::runtime::genInitCoarray(builder, loc); + mif::InitOp::create(builder, loc); fir::CallOp::create(builder, loc, qqMainFn); fir::CallOp::create(builder, loc, stopFn); diff --git a/flang/lib/Optimizer/Dialect/CMakeLists.txt b/flang/lib/Optimizer/Dialect/CMakeLists.txt index 4fd4d28..65d1f2c 100644 --- a/flang/lib/Optimizer/Dialect/CMakeLists.txt +++ b/flang/lib/Optimizer/Dialect/CMakeLists.txt @@ -1,6 +1,7 @@ add_subdirectory(Support) add_subdirectory(CUF) add_subdirectory(FIRCG) +add_subdirectory(MIF) add_flang_library(FIRDialect FIRAttr.cpp diff --git a/flang/lib/Optimizer/Dialect/FIRType.cpp b/flang/lib/Optimizer/Dialect/FIRType.cpp index 48e1622..fe35b08 100644 --- a/flang/lib/Optimizer/Dialect/FIRType.cpp +++ b/flang/lib/Optimizer/Dialect/FIRType.cpp @@ -1427,6 +1427,13 @@ mlir::Type BaseBoxType::unwrapInnerType() const { return fir::unwrapInnerType(getEleTy()); } +mlir::Type BaseBoxType::getElementOrSequenceType() const { + mlir::Type eleTy = getEleTy(); + if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(eleTy)) + return seqTy; + return fir::unwrapRefType(eleTy); +} + static mlir::Type changeTypeShape(mlir::Type type, std::optional<fir::SequenceType::ShapeRef> newShape) { diff --git a/flang/lib/Optimizer/Dialect/MIF/CMakeLists.txt b/flang/lib/Optimizer/Dialect/MIF/CMakeLists.txt new file mode 100644 index 0000000..d52ab09 --- /dev/null +++ b/flang/lib/Optimizer/Dialect/MIF/CMakeLists.txt @@ -0,0 +1,20 @@ +add_flang_library(MIFDialect + MIFDialect.cpp + MIFOps.cpp + + DEPENDS + MLIRIR + MIFOpsIncGen + + LINK_LIBS + FIRDialect + FIRDialectSupport + FIRSupport + MLIRIR + MLIRTargetLLVMIRExport + + LINK_COMPONENTS + AsmParser + AsmPrinter + Remarks +) diff --git a/flang/lib/Optimizer/Dialect/MIF/MIFDialect.cpp b/flang/lib/Optimizer/Dialect/MIF/MIFDialect.cpp new file mode 100644 index 0000000..edc723d --- /dev/null +++ b/flang/lib/Optimizer/Dialect/MIF/MIFDialect.cpp @@ -0,0 +1,24 @@ +//===- MIFDialect.cpp - MIF dialect implementation ------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// C +//===----------------------------------------------------------------------===// + +#include "flang/Optimizer/Dialect/MIF/MIFDialect.h" +#include "flang/Optimizer/Dialect/FIRDialect.h" +#include "flang/Optimizer/Dialect/MIF/MIFOps.h" + +//===----------------------------------------------------------------------===// +/// Tablegen Definitions +//===----------------------------------------------------------------------===// + +#include "flang/Optimizer/Dialect/MIF/MIFDialect.cpp.inc" + +void mif::MIFDialect::initialize() { + addOperations< +#define GET_OP_LIST +#include "flang/Optimizer/Dialect/MIF/MIFOps.cpp.inc" + >(); +} diff --git a/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp new file mode 100644 index 0000000..c6cc2e8 --- /dev/null +++ b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp @@ -0,0 +1,153 @@ +//===-- MIFOps.cpp - MIF dialect ops implementation -----------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "flang/Optimizer/Dialect/MIF/MIFOps.h" +#include "flang/Optimizer/Builder/Todo.h" +#include "flang/Optimizer/Dialect/FIRAttr.h" +#include "flang/Optimizer/Dialect/FIRType.h" +#include "flang/Optimizer/Dialect/MIF/MIFDialect.h" +#include "mlir/IR/Matchers.h" +#include "mlir/IR/PatternMatch.h" +#include "llvm/ADT/SmallVector.h" + +#define GET_OP_CLASSES +#include "flang/Optimizer/Dialect/MIF/MIFOps.cpp.inc" + +//===----------------------------------------------------------------------===// +// NumImagesOp +//===----------------------------------------------------------------------===// + +void mif::NumImagesOp::build(mlir::OpBuilder &builder, + mlir::OperationState &result, + mlir::Value teamArg) { + bool isTeamNumber = + teamArg && fir::unwrapPassByRefType(teamArg.getType()).isInteger(); + if (isTeamNumber) + build(builder, result, teamArg, /*team*/ mlir::Value{}); + else + build(builder, result, /*team_number*/ mlir::Value{}, teamArg); +} + +llvm::LogicalResult mif::NumImagesOp::verify() { + if (getTeam() && getTeamNumber()) + return emitOpError( + "team and team_number must not be provided at the same time"); + return mlir::success(); +} + +//===----------------------------------------------------------------------===// +// ThisImageOp +//===----------------------------------------------------------------------===// + +void mif::ThisImageOp::build(mlir::OpBuilder &builder, + mlir::OperationState &result, mlir::Value coarray, + mlir::Value team) { + build(builder, result, coarray, /*dim*/ mlir::Value{}, team); +} + +void mif::ThisImageOp::build(mlir::OpBuilder &builder, + mlir::OperationState &result, mlir::Value team) { + build(builder, result, /*coarray*/ mlir::Value{}, /*dim*/ mlir::Value{}, + team); +} + +llvm::LogicalResult mif::ThisImageOp::verify() { + if (getDim() && !getCoarray()) + return emitOpError( + "`dim` must be provied at the same time as the `coarray` argument."); + return mlir::success(); +} + +//===----------------------------------------------------------------------===// +// SyncImagesOp +//===----------------------------------------------------------------------===// + +llvm::LogicalResult mif::SyncImagesOp::verify() { + if (getImageSet()) { + mlir::Type t = getImageSet().getType(); + fir::BoxType boxTy = mlir::dyn_cast<fir::BoxType>(t); + if (auto seqTy = mlir::dyn_cast<fir::SequenceType>( + boxTy.getElementOrSequenceType())) { + if (seqTy.getDimension() != 0 && seqTy.getDimension() != 1) + return emitOpError( + "`image_set` must be a boxed integer expression of rank 1."); + if (!fir::isa_integer(seqTy.getElementType())) + return emitOpError("`image_set` must be a boxed array of integer."); + } else if (!fir::isa_integer(boxTy.getElementType())) + return emitOpError( + "`image_set` must be a boxed scalar integer expression."); + } + return mlir::success(); +} + +//===----------------------------------------------------------------------===// +// CoBroadcastOp +//===----------------------------------------------------------------------===// + +llvm::LogicalResult mif::CoBroadcastOp::verify() { + fir::BoxType boxTy = mlir::dyn_cast<fir::BoxType>(getA().getType()); + + if (fir::isPolymorphicType(boxTy)) + return emitOpError("`A` cannot be polymorphic."); + else if (auto recTy = + mlir::dyn_cast<fir::RecordType>(boxTy.getElementType())) { + for (auto component : recTy.getTypeList()) { + if (fir::isPolymorphicType(component.second)) + TODO(getLoc(), "`A` with polymorphic subobject component."); + } + } + return mlir::success(); +} + +//===----------------------------------------------------------------------===// +// CoMaxOp +//===----------------------------------------------------------------------===// + +llvm::LogicalResult mif::CoMaxOp::verify() { + fir::BoxType boxTy = mlir::dyn_cast<fir::BoxType>(getA().getType()); + mlir::Type elemTy = boxTy.getElementOrSequenceType(); + if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(elemTy)) + elemTy = seqTy.getElementType(); + + if (!fir::isa_real(elemTy) && !fir::isa_integer(elemTy) && + !fir::isa_char(elemTy)) + return emitOpError("`A` shall be of type integer, real or character."); + return mlir::success(); +} + +//===----------------------------------------------------------------------===// +// CoMinOp +//===----------------------------------------------------------------------===// + +llvm::LogicalResult mif::CoMinOp::verify() { + fir::BoxType boxTy = mlir::dyn_cast<fir::BoxType>(getA().getType()); + mlir::Type elemTy = boxTy.getElementOrSequenceType(); + if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(elemTy)) + elemTy = seqTy.getElementType(); + + if (!fir::isa_real(elemTy) && !fir::isa_integer(elemTy) && + !fir::isa_char(elemTy)) + return emitOpError("`A` shall be of type integer, real or character."); + return mlir::success(); +} + +//===----------------------------------------------------------------------===// +// CoSumOp +//===----------------------------------------------------------------------===// + +llvm::LogicalResult mif::CoSumOp::verify() { + fir::BoxType boxTy = mlir::dyn_cast<fir::BoxType>(getA().getType()); + mlir::Type elemTy = boxTy.getElementOrSequenceType(); + if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(elemTy)) + elemTy = seqTy.getElementType(); + + if (!fir::isa_real(elemTy) && !fir::isa_integer(elemTy) && + !fir::isa_complex(elemTy)) + return emitOpError("`A` shall be of numeric type."); + return mlir::success(); +} diff --git a/flang/lib/Optimizer/OpenACC/Transforms/CMakeLists.txt b/flang/lib/Optimizer/OpenACC/Transforms/CMakeLists.txt index 2427da0..ed177ba 100644 --- a/flang/lib/Optimizer/OpenACC/Transforms/CMakeLists.txt +++ b/flang/lib/Optimizer/OpenACC/Transforms/CMakeLists.txt @@ -5,8 +5,10 @@ add_flang_library(FIROpenACCTransforms FIROpenACCPassesIncGen LINK_LIBS + FIRDialect + + MLIR_LIBS MLIRIR MLIRPass - FIRDialect MLIROpenACCDialect ) diff --git a/flang/lib/Optimizer/Passes/Pipelines.cpp b/flang/lib/Optimizer/Passes/Pipelines.cpp index 1ecb6d3..6dae39b 100644 --- a/flang/lib/Optimizer/Passes/Pipelines.cpp +++ b/flang/lib/Optimizer/Passes/Pipelines.cpp @@ -354,6 +354,7 @@ void createDebugPasses(mlir::PassManager &pm, void createDefaultFIRCodeGenPassPipeline(mlir::PassManager &pm, MLIRToLLVMPassPipelineConfig config, llvm::StringRef inputFilename) { + pm.addPass(fir::createMIFOpConversion()); fir::addBoxedProcedurePass(pm); if (config.OptLevel.isOptimizingForSpeed() && config.AliasAnalysis && !disableFirAliasTags && !useOldAliasTags) diff --git a/flang/lib/Optimizer/Transforms/CMakeLists.txt b/flang/lib/Optimizer/Transforms/CMakeLists.txt index 4ec1627..0388439 100644 --- a/flang/lib/Optimizer/Transforms/CMakeLists.txt +++ b/flang/lib/Optimizer/Transforms/CMakeLists.txt @@ -36,6 +36,7 @@ add_flang_library(FIRTransforms SimplifyFIROperations.cpp OptimizeArrayRepacking.cpp ConvertComplexPow.cpp + MIFOpConversion.cpp DEPENDS CUFAttrs @@ -43,6 +44,7 @@ add_flang_library(FIRTransforms FIRDialect FIROptTransformsPassIncGen HLFIROpsIncGen + MIFDialect LINK_LIBS CUFAttrs @@ -56,6 +58,7 @@ add_flang_library(FIRTransforms FIRSupport FortranSupport HLFIRDialect + MIFDialect MLIR_LIBS MLIRAffineUtils diff --git a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp new file mode 100644 index 0000000..206cb9b --- /dev/null +++ b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp @@ -0,0 +1,464 @@ +//===-- MIFOpConversion.cpp -----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "flang/Optimizer/Transforms/MIFOpConversion.h" +#include "flang/Optimizer/Builder/Runtime/RTBuilder.h" +#include "flang/Optimizer/Builder/Todo.h" +#include "flang/Optimizer/CodeGen/TypeConverter.h" +#include "flang/Optimizer/Dialect/FIRDialect.h" +#include "flang/Optimizer/Dialect/FIROps.h" +#include "flang/Optimizer/Dialect/MIF/MIFOps.h" +#include "flang/Optimizer/HLFIR/HLFIROps.h" +#include "flang/Optimizer/Support/DataLayout.h" +#include "flang/Optimizer/Support/InternalNames.h" +#include "mlir/IR/Matchers.h" +#include "mlir/Transforms/DialectConversion.h" +#include "mlir/Transforms/GreedyPatternRewriteDriver.h" + +namespace fir { +#define GEN_PASS_DEF_MIFOPCONVERSION +#include "flang/Optimizer/Transforms/Passes.h.inc" +} // namespace fir + +using namespace mlir; +using namespace Fortran::runtime; + +namespace { + +// Default prefix for subroutines of PRIF compiled with LLVM +static std::string getPRIFProcName(std::string fmt) { + std::ostringstream oss; + oss << "prif_" << fmt; + return fir::NameUniquer::doProcedure({"prif"}, {}, oss.str()); +} + +static mlir::Type getPRIFStatType(fir::FirOpBuilder &builder) { + return builder.getRefType(builder.getI32Type()); +} + +static mlir::Type getPRIFErrmsgType(fir::FirOpBuilder &builder) { + return fir::BoxType::get(fir::CharacterType::get( + builder.getContext(), 1, fir::CharacterType::unknownLen())); +} + +// Most PRIF functions take `errmsg` and `errmsg_alloc` as two optional +// arguments of intent (out). One is allocatable, the other is not. +// It is the responsibility of the compiler to ensure that the appropriate +// optional argument is passed, and at most one must be provided in a given +// call. +// Depending on the type of `errmsg`, this function will return the pair +// corresponding to (`errmsg`, `errmsg_alloc`). +static std::pair<mlir::Value, mlir::Value> +genErrmsgPRIF(fir::FirOpBuilder &builder, mlir::Location loc, + mlir::Value errmsg) { + mlir::Value absent = + fir::AbsentOp::create(builder, loc, getPRIFErrmsgType(builder)); + if (!errmsg) + return {absent, absent}; + + bool isAllocatableErrmsg = fir::isAllocatableType(errmsg.getType()); + mlir::Value errMsg = isAllocatableErrmsg ? absent : errmsg; + mlir::Value errMsgAlloc = isAllocatableErrmsg ? errmsg : absent; + return {errMsg, errMsgAlloc}; +} + +/// Convert mif.init operation to runtime call of 'prif_init' +struct MIFInitOpConversion : public mlir::OpRewritePattern<mif::InitOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::InitOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + mlir::Type i32Ty = builder.getI32Type(); + mlir::Value result = builder.createTemporary(loc, i32Ty); + mlir::FunctionType ftype = mlir::FunctionType::get( + builder.getContext(), + /*inputs*/ {builder.getRefType(i32Ty)}, /*results*/ {}); + mlir::func::FuncOp funcOp = + builder.createFunction(loc, getPRIFProcName("init"), ftype); + llvm::SmallVector<mlir::Value> args = + fir::runtime::createArguments(builder, loc, ftype, result); + fir::CallOp::create(builder, loc, funcOp, args); + rewriter.replaceOpWithNewOp<fir::LoadOp>(op, result); + return mlir::success(); + } +}; + +/// Convert mif.this_image operation to PRIF runtime call +struct MIFThisImageOpConversion + : public mlir::OpRewritePattern<mif::ThisImageOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::ThisImageOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + if (op.getCoarray()) + TODO(loc, "mif.this_image op with coarray argument."); + else { + mlir::Type i32Ty = builder.getI32Type(); + mlir::Type boxTy = fir::BoxType::get(rewriter.getNoneType()); + mlir::Value result = builder.createTemporary(loc, i32Ty); + mlir::FunctionType ftype = mlir::FunctionType::get( + builder.getContext(), + /*inputs*/ {boxTy, builder.getRefType(i32Ty)}, /*results*/ {}); + mlir::Value teamArg = op.getTeam(); + if (!op.getTeam()) + teamArg = fir::AbsentOp::create(builder, loc, boxTy); + + mlir::func::FuncOp funcOp = builder.createFunction( + loc, getPRIFProcName("this_image_no_coarray"), ftype); + llvm::SmallVector<mlir::Value> args = + fir::runtime::createArguments(builder, loc, ftype, teamArg, result); + fir::CallOp::create(builder, loc, funcOp, args); + rewriter.replaceOpWithNewOp<fir::LoadOp>(op, result); + return mlir::success(); + } + } +}; + +/// Convert mif.num_images operation to runtime call of +/// prif_num_images_with_{team|team_number} +struct MIFNumImagesOpConversion + : public mlir::OpRewritePattern<mif::NumImagesOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::NumImagesOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + mlir::Type i32Ty = builder.getI32Type(); + mlir::Type i64Ty = builder.getI64Type(); + mlir::Type boxTy = fir::BoxType::get(rewriter.getNoneType()); + mlir::Value result = builder.createTemporary(loc, i32Ty); + + mlir::func::FuncOp funcOp; + llvm::SmallVector<mlir::Value> args; + if (!op.getTeam() && !op.getTeamNumber()) { + mlir::FunctionType ftype = mlir::FunctionType::get( + builder.getContext(), + /*inputs*/ {builder.getRefType(i32Ty)}, /*results*/ {}); + funcOp = + builder.createFunction(loc, getPRIFProcName("num_images"), ftype); + args = fir::runtime::createArguments(builder, loc, ftype, result); + } else { + if (op.getTeam()) { + mlir::FunctionType ftype = + mlir::FunctionType::get(builder.getContext(), + /*inputs*/ + {boxTy, builder.getRefType(i32Ty)}, + /*results*/ {}); + funcOp = builder.createFunction( + loc, getPRIFProcName("num_images_with_team"), ftype); + args = fir::runtime::createArguments(builder, loc, ftype, op.getTeam(), + result); + } else { + mlir::Value teamNumber = builder.createTemporary(loc, i64Ty); + mlir::Value cst = op.getTeamNumber(); + if (op.getTeamNumber().getType() != i64Ty) + cst = fir::ConvertOp::create(builder, loc, i64Ty, op.getTeamNumber()); + fir::StoreOp::create(builder, loc, cst, teamNumber); + mlir::FunctionType ftype = mlir::FunctionType::get( + builder.getContext(), + /*inputs*/ {builder.getRefType(i64Ty), builder.getRefType(i32Ty)}, + /*results*/ {}); + funcOp = builder.createFunction( + loc, getPRIFProcName("num_images_with_team_number"), ftype); + args = fir::runtime::createArguments(builder, loc, ftype, teamNumber, + result); + } + } + fir::CallOp::create(builder, loc, funcOp, args); + rewriter.replaceOpWithNewOp<fir::LoadOp>(op, result); + return mlir::success(); + } +}; + +/// Convert mif.sync_all operation to runtime call of 'prif_sync_all' +struct MIFSyncAllOpConversion : public mlir::OpRewritePattern<mif::SyncAllOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::SyncAllOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + mlir::Type errmsgTy = getPRIFErrmsgType(builder); + mlir::FunctionType ftype = mlir::FunctionType::get( + builder.getContext(), + /*inputs*/ {getPRIFStatType(builder), errmsgTy, errmsgTy}, + /*results*/ {}); + mlir::func::FuncOp funcOp = + builder.createFunction(loc, getPRIFProcName("sync_all"), ftype); + + auto [errmsgArg, errmsgAllocArg] = + genErrmsgPRIF(builder, loc, op.getErrmsg()); + mlir::Value stat = op.getStat(); + if (!stat) + stat = fir::AbsentOp::create(builder, loc, getPRIFStatType(builder)); + llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( + builder, loc, ftype, stat, errmsgArg, errmsgAllocArg); + rewriter.replaceOpWithNewOp<fir::CallOp>(op, funcOp, args); + return mlir::success(); + } +}; + +/// Convert mif.sync_images operation to runtime call of 'prif_sync_images' +struct MIFSyncImagesOpConversion + : public mlir::OpRewritePattern<mif::SyncImagesOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::SyncImagesOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + mlir::Type errmsgTy = getPRIFErrmsgType(builder); + mlir::Type imgSetTy = fir::BoxType::get(fir::SequenceType::get( + {fir::SequenceType::getUnknownExtent()}, builder.getI32Type())); + mlir::FunctionType ftype = mlir::FunctionType::get( + builder.getContext(), + /*inputs*/ + {imgSetTy, getPRIFStatType(builder), errmsgTy, errmsgTy}, + /*results*/ {}); + mlir::func::FuncOp funcOp = + builder.createFunction(loc, getPRIFProcName("sync_images"), ftype); + + // If imageSet is scalar, PRIF require to pass an array of size 1. + mlir::Value imageSet = op.getImageSet(); + if (!imageSet) + imageSet = fir::AbsentOp::create(builder, loc, imgSetTy); + else if (auto boxTy = mlir::dyn_cast<fir::BoxType>(imageSet.getType())) { + if (!mlir::isa<fir::SequenceType>(boxTy.getEleTy())) { + mlir::Value one = + builder.createIntegerConstant(loc, builder.getI32Type(), 1); + mlir::Value shape = fir::ShapeOp::create(builder, loc, one); + imageSet = + fir::ReboxOp::create(builder, loc, + fir::BoxType::get(fir::SequenceType::get( + {1}, builder.getI32Type())), + imageSet, shape, mlir::Value{}); + } + } + auto [errmsgArg, errmsgAllocArg] = + genErrmsgPRIF(builder, loc, op.getErrmsg()); + mlir::Value stat = op.getStat(); + if (!stat) + stat = fir::AbsentOp::create(builder, loc, getPRIFStatType(builder)); + llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( + builder, loc, ftype, imageSet, stat, errmsgArg, errmsgAllocArg); + rewriter.replaceOpWithNewOp<fir::CallOp>(op, funcOp, args); + return mlir::success(); + } +}; + +/// Convert mif.sync_memory operation to runtime call of 'prif_sync_memory' +struct MIFSyncMemoryOpConversion + : public mlir::OpRewritePattern<mif::SyncMemoryOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::SyncMemoryOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + mlir::Type errmsgTy = getPRIFErrmsgType(builder); + mlir::FunctionType ftype = mlir::FunctionType::get( + builder.getContext(), + /*inputs*/ {getPRIFStatType(builder), errmsgTy, errmsgTy}, + /*results*/ {}); + mlir::func::FuncOp funcOp = + builder.createFunction(loc, getPRIFProcName("sync_memory"), ftype); + + auto [errmsgArg, errmsgAllocArg] = + genErrmsgPRIF(builder, loc, op.getErrmsg()); + mlir::Value stat = op.getStat(); + if (!stat) + stat = fir::AbsentOp::create(builder, loc, getPRIFStatType(builder)); + llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( + builder, loc, ftype, stat, errmsgArg, errmsgAllocArg); + rewriter.replaceOpWithNewOp<fir::CallOp>(op, funcOp, args); + return mlir::success(); + } +}; + +/// Generate call to collective subroutines except co_reduce +/// A must be lowered as a box +static fir::CallOp genCollectiveSubroutine(fir::FirOpBuilder &builder, + mlir::Location loc, mlir::Value A, + mlir::Value image, mlir::Value stat, + mlir::Value errmsg, + std::string coName) { + mlir::Value rootImage; + mlir::Type i32Ty = builder.getI32Type(); + if (!image) + rootImage = fir::AbsentOp::create(builder, loc, builder.getRefType(i32Ty)); + else { + rootImage = builder.createTemporary(loc, i32Ty); + if (image.getType() != i32Ty) + image = fir::ConvertOp::create(builder, loc, i32Ty, image); + fir::StoreOp::create(builder, loc, image, rootImage); + } + + mlir::Type errmsgTy = getPRIFErrmsgType(builder); + mlir::Type boxTy = fir::BoxType::get(builder.getNoneType()); + mlir::FunctionType ftype = + mlir::FunctionType::get(builder.getContext(), + /*inputs*/ + {boxTy, builder.getRefType(builder.getI32Type()), + getPRIFStatType(builder), errmsgTy, errmsgTy}, + /*results*/ {}); + mlir::func::FuncOp funcOp = builder.createFunction(loc, coName, ftype); + + auto [errmsgArg, errmsgAllocArg] = genErrmsgPRIF(builder, loc, errmsg); + if (!stat) + stat = fir::AbsentOp::create(builder, loc, getPRIFStatType(builder)); + llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( + builder, loc, ftype, A, rootImage, stat, errmsgArg, errmsgAllocArg); + return fir::CallOp::create(builder, loc, funcOp, args); +} + +/// Convert mif.co_broadcast operation to runtime call of 'prif_co_broadcast' +struct MIFCoBroadcastOpConversion + : public mlir::OpRewritePattern<mif::CoBroadcastOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::CoBroadcastOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + fir::CallOp callOp = genCollectiveSubroutine( + builder, loc, op.getA(), op.getSourceImage(), op.getStat(), + op.getErrmsg(), getPRIFProcName("co_broadcast")); + rewriter.replaceOp(op, callOp); + return mlir::success(); + } +}; + +/// Convert mif.co_max operation to runtime call of 'prif_co_max' +struct MIFCoMaxOpConversion : public mlir::OpRewritePattern<mif::CoMaxOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::CoMaxOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + fir::CallOp callOp; + mlir::Type argTy = + fir::unwrapSequenceType(fir::unwrapPassByRefType(op.getA().getType())); + if (mlir::isa<fir::CharacterType>(argTy)) + callOp = genCollectiveSubroutine( + builder, loc, op.getA(), op.getResultImage(), op.getStat(), + op.getErrmsg(), getPRIFProcName("co_max_character")); + else + callOp = genCollectiveSubroutine( + builder, loc, op.getA(), op.getResultImage(), op.getStat(), + op.getErrmsg(), getPRIFProcName("co_max")); + rewriter.replaceOp(op, callOp); + return mlir::success(); + } +}; + +/// Convert mif.co_min operation to runtime call of 'prif_co_min' +struct MIFCoMinOpConversion : public mlir::OpRewritePattern<mif::CoMinOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::CoMinOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + fir::CallOp callOp; + mlir::Type argTy = + fir::unwrapSequenceType(fir::unwrapPassByRefType(op.getA().getType())); + if (mlir::isa<fir::CharacterType>(argTy)) + callOp = genCollectiveSubroutine( + builder, loc, op.getA(), op.getResultImage(), op.getStat(), + op.getErrmsg(), getPRIFProcName("co_min_character")); + else + callOp = genCollectiveSubroutine( + builder, loc, op.getA(), op.getResultImage(), op.getStat(), + op.getErrmsg(), getPRIFProcName("co_min")); + rewriter.replaceOp(op, callOp); + return mlir::success(); + } +}; + +/// Convert mif.co_sum operation to runtime call of 'prif_co_sum' +struct MIFCoSumOpConversion : public mlir::OpRewritePattern<mif::CoSumOp> { + using OpRewritePattern::OpRewritePattern; + + mlir::LogicalResult + matchAndRewrite(mif::CoSumOp op, + mlir::PatternRewriter &rewriter) const override { + auto mod = op->template getParentOfType<mlir::ModuleOp>(); + fir::FirOpBuilder builder(rewriter, mod); + mlir::Location loc = op.getLoc(); + + fir::CallOp callOp = genCollectiveSubroutine( + builder, loc, op.getA(), op.getResultImage(), op.getStat(), + op.getErrmsg(), getPRIFProcName("co_sum")); + rewriter.replaceOp(op, callOp); + return mlir::success(); + } +}; + +class MIFOpConversion : public fir::impl::MIFOpConversionBase<MIFOpConversion> { +public: + void runOnOperation() override { + auto *ctx = &getContext(); + mlir::RewritePatternSet patterns(ctx); + mlir::ConversionTarget target(*ctx); + + mif::populateMIFOpConversionPatterns(patterns); + + target.addLegalDialect<fir::FIROpsDialect>(); + target.addLegalOp<mlir::ModuleOp>(); + + if (mlir::failed(mlir::applyPartialConversion(getOperation(), target, + std::move(patterns)))) { + mlir::emitError(mlir::UnknownLoc::get(ctx), + "error in MIF op conversion\n"); + return signalPassFailure(); + } + } +}; +} // namespace + +void mif::populateMIFOpConversionPatterns(mlir::RewritePatternSet &patterns) { + patterns.insert<MIFInitOpConversion, MIFThisImageOpConversion, + MIFNumImagesOpConversion, MIFSyncAllOpConversion, + MIFSyncImagesOpConversion, MIFSyncMemoryOpConversion, + MIFCoBroadcastOpConversion, MIFCoMaxOpConversion, + MIFCoMinOpConversion, MIFCoSumOpConversion>( + patterns.getContext()); +} diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp index d677e14..56fcac3 100644 --- a/flang/lib/Parser/openmp-parsers.cpp +++ b/flang/lib/Parser/openmp-parsers.cpp @@ -1159,6 +1159,9 @@ TYPE_PARSER( // construct<OmpDestroyClause>(Parser<OmpObject>{}))))) || "DEVICE" >> construct<OmpClause>(construct<OmpClause::Device>( parenthesized(Parser<OmpDeviceClause>{}))) || + "DEVICE_SAFESYNC" >> + construct<OmpClause>(construct<OmpClause::DeviceSafesync>( + maybe(parenthesized(scalarLogicalConstantExpr)))) || "DEVICE_TYPE" >> construct<OmpClause>(construct<OmpClause::DeviceType>( parenthesized(Parser<OmpDeviceTypeClause>{}))) || "DIST_SCHEDULE" >> diff --git a/flang/lib/Parser/tools.cpp b/flang/lib/Parser/tools.cpp index 264ca52..ed6d194 100644 --- a/flang/lib/Parser/tools.cpp +++ b/flang/lib/Parser/tools.cpp @@ -179,4 +179,9 @@ bool CheckForSingleVariableOnRHS(const AssignmentStmt &assignmentStmt) { return Unwrap<Designator>(std::get<Expr>(assignmentStmt.t)) != nullptr; } +const Name *GetDesignatorNameIfDataRef(const Designator &designator) { + const auto *dataRef{std::get_if<DataRef>(&designator.u)}; + return dataRef ? std::get_if<Name>(&dataRef->u) : nullptr; +} + } // namespace Fortran::parser diff --git a/flang/lib/Semantics/check-acc-structure.cpp b/flang/lib/Semantics/check-acc-structure.cpp index 3cd6d6b..5e87b83 100644 --- a/flang/lib/Semantics/check-acc-structure.cpp +++ b/flang/lib/Semantics/check-acc-structure.cpp @@ -10,6 +10,7 @@ #include "flang/Common/enum-set.h" #include "flang/Evaluate/tools.h" #include "flang/Parser/parse-tree.h" +#include "flang/Parser/tools.h" #include "flang/Semantics/symbol.h" #include "flang/Semantics/tools.h" #include "flang/Semantics/type.h" @@ -709,7 +710,8 @@ void AccStructureChecker::CheckMultipleOccurrenceInDeclare( common::visit( common::visitors{ [&](const parser::Designator &designator) { - if (const auto *name = getDesignatorNameIfDataRef(designator)) { + if (const auto *name = + parser::GetDesignatorNameIfDataRef(designator)) { if (declareSymbols.contains(&name->symbol->GetUltimate())) { if (declareSymbols[&name->symbol->GetUltimate()] == clause) { context_.Warn(common::UsageWarning::OpenAccUsage, @@ -982,7 +984,8 @@ void AccStructureChecker::Enter(const parser::AccClause::Reduction &reduction) { common::visit( common::visitors{ [&](const parser::Designator &designator) { - if (const auto *name = getDesignatorNameIfDataRef(designator)) { + if (const auto *name = + parser::GetDesignatorNameIfDataRef(designator)) { if (name->symbol) { if (const auto *type{name->symbol->GetType()}) { if (type->IsNumeric(TypeCategory::Integer) && diff --git a/flang/lib/Semantics/check-omp-loop.cpp b/flang/lib/Semantics/check-omp-loop.cpp index c9d0495..aaaa2d6 100644 --- a/flang/lib/Semantics/check-omp-loop.cpp +++ b/flang/lib/Semantics/check-omp-loop.cpp @@ -127,24 +127,23 @@ using namespace Fortran::semantics::omp; void OmpStructureChecker::HasInvalidDistributeNesting( const parser::OpenMPLoopConstruct &x) { - bool violation{false}; const parser::OmpDirectiveName &beginName{x.BeginDir().DirName()}; if (llvm::omp::topDistributeSet.test(beginName.v)) { // `distribute` region has to be nested - if (!CurrentDirectiveIsNested()) { - violation = true; - } else { + if (CurrentDirectiveIsNested()) { // `distribute` region has to be strictly nested inside `teams` if (!llvm::omp::bottomTeamsSet.test(GetContextParent().directive)) { - violation = true; + context_.Say(beginName.source, + "`DISTRIBUTE` region has to be strictly nested inside `TEAMS` " + "region."_err_en_US); } + } else { + // If not lexically nested (orphaned), issue a warning. + context_.Say(beginName.source, + "`DISTRIBUTE` must be dynamically enclosed in a `TEAMS` " + "region."_warn_en_US); } } - if (violation) { - context_.Say(beginName.source, - "`DISTRIBUTE` region has to be strictly nested inside `TEAMS` " - "region."_err_en_US); - } } void OmpStructureChecker::HasInvalidLoopBinding( const parser::OpenMPLoopConstruct &x) { @@ -486,8 +485,8 @@ void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &x) { common::visit( common::visitors{ [&](const parser::Designator &designator) { - if (const auto *name{semantics::getDesignatorNameIfDataRef( - designator)}) { + if (const auto *name{ + parser::GetDesignatorNameIfDataRef(designator)}) { checkReductionSymbolInScan(name); } }, diff --git a/flang/lib/Semantics/check-omp-structure.cpp b/flang/lib/Semantics/check-omp-structure.cpp index ea6fe43..e2f8796 100644 --- a/flang/lib/Semantics/check-omp-structure.cpp +++ b/flang/lib/Semantics/check-omp-structure.cpp @@ -1535,6 +1535,7 @@ void OmpStructureChecker::Enter(const parser::OpenMPRequiresConstruct &x) { [&](auto &&s) { using TypeS = llvm::remove_cvref_t<decltype(s)>; if constexpr ( // + std::is_same_v<TypeS, parser::OmpClause::DeviceSafesync> || std::is_same_v<TypeS, parser::OmpClause::DynamicAllocators> || std::is_same_v<TypeS, parser::OmpClause::ReverseOffload> || std::is_same_v<TypeS, parser::OmpClause::SelfMaps> || @@ -2616,7 +2617,7 @@ void OmpStructureChecker::Enter(const parser::OpenMPCriticalConstruct &x) { auto getNameFromArg{[](const parser::OmpArgument &arg) { if (auto *object{parser::Unwrap<parser::OmpObject>(arg.u)}) { if (auto *designator{omp::GetDesignatorFromObj(*object)}) { - return getDesignatorNameIfDataRef(*designator); + return parser::GetDesignatorNameIfDataRef(*designator); } } return static_cast<const parser::Name *>(nullptr); @@ -5194,6 +5195,10 @@ void OmpStructureChecker::Enter( CheckAllowedRequiresClause(llvm::omp::Clause::OMPC_atomic_default_mem_order); } +void OmpStructureChecker::Enter(const parser::OmpClause::DeviceSafesync &x) { + CheckAllowedRequiresClause(llvm::omp::Clause::OMPC_device_safesync); +} + void OmpStructureChecker::Enter(const parser::OmpClause::DynamicAllocators &x) { CheckAllowedRequiresClause(llvm::omp::Clause::OMPC_dynamic_allocators); } diff --git a/flang/lib/Semantics/resolve-directives.cpp b/flang/lib/Semantics/resolve-directives.cpp index 7067ed3..3bb586c 100644 --- a/flang/lib/Semantics/resolve-directives.cpp +++ b/flang/lib/Semantics/resolve-directives.cpp @@ -586,6 +586,7 @@ public: [&](auto &&s) { using TypeS = llvm::remove_cvref_t<decltype(s)>; if constexpr ( // + std::is_same_v<TypeS, OmpClause::DeviceSafesync> || std::is_same_v<TypeS, OmpClause::DynamicAllocators> || std::is_same_v<TypeS, OmpClause::ReverseOffload> || std::is_same_v<TypeS, OmpClause::SelfMaps> || @@ -892,7 +893,7 @@ public: common::visitors{ [&](const parser::Designator &designator) { if (const auto *name{ - semantics::getDesignatorNameIfDataRef(designator)}) { + parser::GetDesignatorNameIfDataRef(designator)}) { if (name->symbol) { name->symbol->set( ompFlag.value_or(Symbol::Flag::OmpMapStorage)); @@ -1758,7 +1759,7 @@ void AccAttributeVisitor::ResolveAccObject( common::visitors{ [&](const parser::Designator &designator) { if (const auto *name{ - semantics::getDesignatorNameIfDataRef(designator)}) { + parser::GetDesignatorNameIfDataRef(designator)}) { if (auto *symbol{ResolveAcc(*name, accFlag, currScope())}) { AddToContextObjectWithDSA(*symbol, accFlag); if (dataSharingAttributeFlags.test(accFlag)) { @@ -3064,7 +3065,7 @@ void OmpAttributeVisitor::ResolveOmpDesignator( unsigned version{context_.langOptions().OpenMPVersion}; llvm::omp::Directive directive{GetContext().directive}; - const auto *name{semantics::getDesignatorNameIfDataRef(designator)}; + const auto *name{parser::GetDesignatorNameIfDataRef(designator)}; if (!name) { // Array sections to be changed to substrings as needed if (AnalyzeExpr(context_, designator)) { diff --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp index 699de41..0af1c94 100644 --- a/flang/lib/Semantics/resolve-names.cpp +++ b/flang/lib/Semantics/resolve-names.cpp @@ -1494,7 +1494,7 @@ bool AccVisitor::Pre(const parser::AccClause::UseDevice &x) { common::visitors{ [&](const parser::Designator &designator) { if (const auto *name{ - semantics::getDesignatorNameIfDataRef(designator)}) { + parser::GetDesignatorNameIfDataRef(designator)}) { Symbol *prev{currScope().FindSymbol(name->source)}; if (prev != name->symbol) { name->symbol = prev; @@ -1648,7 +1648,7 @@ public: common::visitors{ [&](const parser::Designator &designator) { if (const auto *name{ - semantics::getDesignatorNameIfDataRef(designator)}) { + parser::GetDesignatorNameIfDataRef(designator)}) { specPartState_.declareTargetNames.insert(name->source); } }, @@ -2016,7 +2016,7 @@ void OmpVisitor::ResolveCriticalName(const parser::OmpArgument &arg) { if (auto *object{parser::Unwrap<parser::OmpObject>(arg.u)}) { if (auto *desg{omp::GetDesignatorFromObj(*object)}) { - if (auto *name{getDesignatorNameIfDataRef(*desg)}) { + if (auto *name{parser::GetDesignatorNameIfDataRef(*desg)}) { if (auto *symbol{FindInScope(globalScope, *name)}) { if (!symbol->test(Symbol::Flag::OmpCriticalLock)) { SayWithDecl(*name, *symbol, |