[flang-commits] [flang] [Flang][MIF] Adding support of intrinsics with coarray argument (PR #192944)
Jean-Didier PAILLEUX via flang-commits
flang-commits at lists.llvm.org
Mon Apr 20 04:25:37 PDT 2026
https://github.com/JDPailleux updated https://github.com/llvm/llvm-project/pull/192944
>From a5a05b8239e834e60bc925747a2c40dd1c50a9a7 Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Thu, 5 Feb 2026 20:54:24 +0100
Subject: [PATCH 1/2] [Flang][MIF] Adding support of intrinsics with coarray
argument
- Adding lowering and operation in MIF Dialect for UCOBOUND, LCOBOUND,
COSHAPE and IMAGE_INDEX
- Adding support of coarray argument for THIS_IMAGE in MIF Dialect (and the lowering)
---
.../flang/Optimizer/Builder/IntrinsicCall.h | 7 +
.../flang/Optimizer/Dialect/FIROpsSupport.h | 3 +
.../flang/Optimizer/Dialect/MIF/MIFOps.td | 128 ++++++++-
flang/lib/Lower/ConvertCall.cpp | 57 +++-
flang/lib/Optimizer/Builder/IntrinsicCall.cpp | 98 ++++++-
flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp | 120 +++++++-
.../Optimizer/Transforms/MIFOpConversion.cpp | 271 ++++++++++++++++--
flang/test/Fir/MIF/cobound.mlir | 93 ++++++
flang/test/Fir/MIF/coshape.mlir | 78 +++++
flang/test/Fir/MIF/image_index.mlir | 67 +++++
flang/test/Fir/MIF/this_image.mlir | 63 +++-
flang/test/Lower/MIF/cobound.f90 | 21 ++
flang/test/Lower/MIF/coshape.f90 | 14 +
flang/test/Lower/MIF/image_index.f90 | 20 ++
flang/test/Lower/MIF/this_image.f90 | 10 +-
15 files changed, 1004 insertions(+), 46 deletions(-)
create mode 100644 flang/test/Fir/MIF/cobound.mlir
create mode 100644 flang/test/Fir/MIF/coshape.mlir
create mode 100644 flang/test/Fir/MIF/image_index.mlir
create mode 100644 flang/test/Lower/MIF/cobound.f90
create mode 100644 flang/test/Lower/MIF/coshape.f90
create mode 100644 flang/test/Lower/MIF/image_index.f90
diff --git a/flang/include/flang/Optimizer/Builder/IntrinsicCall.h b/flang/include/flang/Optimizer/Builder/IntrinsicCall.h
index ca9677a8cb2b1..adf05affecc41 100644
--- a/flang/include/flang/Optimizer/Builder/IntrinsicCall.h
+++ b/flang/include/flang/Optimizer/Builder/IntrinsicCall.h
@@ -176,6 +176,7 @@ struct IntrinsicLibrary {
llvm::ArrayRef<fir::ExtendedValue>);
mlir::Value genCmplx(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genConjg(mlir::Type, llvm::ArrayRef<mlir::Value>);
+ fir::ExtendedValue genCoshape(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genCount(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
void genCpuTime(llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genCshift(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
@@ -295,6 +296,8 @@ struct IntrinsicLibrary {
mlir::Value genIeeeUnordered(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genIeeeValue(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genIeor(mlir::Type, llvm::ArrayRef<mlir::Value>);
+ fir::ExtendedValue genImageIndex(mlir::Type,
+ llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genIndex(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
mlir::Value genIor(mlir::Type, llvm::ArrayRef<mlir::Value>);
fir::ExtendedValue genIparity(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
@@ -309,6 +312,8 @@ struct IntrinsicLibrary {
mlir::Value genIshft(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genIshftc(mlir::Type, llvm::ArrayRef<mlir::Value>);
fir::ExtendedValue genLbound(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+ fir::ExtendedValue genLcobound(mlir::Type,
+ llvm::ArrayRef<fir::ExtendedValue>);
mlir::Value genLeadz(mlir::Type, llvm::ArrayRef<mlir::Value>);
fir::ExtendedValue genLen(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genLenTrim(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
@@ -415,6 +420,8 @@ struct IntrinsicLibrary {
llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genTrim(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genUbound(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+ fir::ExtendedValue genUcobound(mlir::Type,
+ llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genUnlink(std::optional<mlir::Type> resultType,
llvm::ArrayRef<fir::ExtendedValue> args);
fir::ExtendedValue genUnpack(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
diff --git a/flang/include/flang/Optimizer/Dialect/FIROpsSupport.h b/flang/include/flang/Optimizer/Dialect/FIROpsSupport.h
index b014d925592cb..9e168ffe90d0d 100644
--- a/flang/include/flang/Optimizer/Dialect/FIROpsSupport.h
+++ b/flang/include/flang/Optimizer/Dialect/FIROpsSupport.h
@@ -136,6 +136,9 @@ static constexpr llvm::StringRef getAccessGroupsAttrName() {
return "access_groups";
}
+/// Attribute to mark coarray Fortran entities with the CORANK attribute.
+constexpr llvm::StringRef getCorankAttrName() { return "fir.corank"; }
+
/// Does the function, \p func, have a host-associations tuple argument?
/// Some internal procedures may have access to host procedure variables.
bool hasHostAssociationArgument(mlir::func::FuncOp func);
diff --git a/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td b/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td
index 7df274b5697f3..f39ea71e93ffd 100644
--- a/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td
+++ b/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td
@@ -102,11 +102,13 @@ def mif_ThisImageOp : mif_Op<"this_image", [AttrSizedOperandSegments]> {
value 5, `this_image(A)` has the value [5, 0, 0].
}];
- let arguments = (ins Optional<fir_BoxType>:$coarray,
- Optional<AnyInteger>:$dim, Optional<AnyRefOrBoxType>:$team);
- let results = (outs I32:$res);
+ let arguments = (ins Optional<AnyType>:$coarray, Optional<AnyInteger>:$dim,
+ Optional<AnyRefOrBoxType>:$team);
+ let results = (outs AnyType:$res);
- let builders = [OpBuilder<(ins "mlir::Value":$coarray, "mlir::Value":$team)>,
+ let builders = [OpBuilder<(ins "mlir::Value":$coarray, "mlir::Value":$dim,
+ "mlir::Value":$team)>,
+ OpBuilder<(ins "mlir::Value":$coarray, "mlir::Value":$team)>,
OpBuilder<(ins "mlir::Value":$team)>];
let hasVerifier = 1;
@@ -118,6 +120,124 @@ def mif_ThisImageOp : mif_Op<"this_image", [AttrSizedOperandSegments]> {
}];
}
+//===----------------------------------------------------------------------===//
+// Coarray Queries
+//===----------------------------------------------------------------------===//
+
+def mif_ImageIndexOp : mif_Op<"image_index", [AttrSizedOperandSegments]> {
+ let summary = "Image index from cosubscripts.";
+ let description = [{
+ Arguments:
+ - `coarray`: Shall be a coarray of any type.
+ - `sub`: rank-one integer array of size equal to the corank of `coarray`.
+ - `team`: Shall be a scalar of type `team_type` from ISO_FORTRAN_ENV.
+ - `team_number`: It shall identify the initial team or a sibling team
+ of the current team.
+
+ Usage:
+ - Case(1) : `call image_index(coarray, sub)`
+ - Case(2) : `call image_index(coarray, sub, team)`
+ - Case(3) : `call image_index(coarray, sub, team_number)`
+
+ Result: If the value of `sub` is a valid sequence of cosubscripts for `coarray` in the
+ team specified by `team` or `team_number`, or the current team if neither `team` nor
+ `team_number` appears, the result is the index of the corresponding image in that team.
+ Otherwise, the result is zero.
+ }];
+
+ let arguments = (ins AnyType:$coarray, fir_BoxType:$sub,
+ Optional<AnyRefOrBoxType>:$team, Optional<AnyInteger>:$team_number);
+ let builders = [OpBuilder<(ins "mlir::Value":$coarray, "mlir::Value":$sub,
+ "mlir::Value":$team)>];
+
+ let results = (outs I32);
+
+ let hasVerifier = 1;
+ let assemblyFormat = [{
+ `coarray` $coarray `sub` $sub
+ ( `team` $team^ )?
+ ( `team_number` $team_number^ )?
+ attr-dict `:` functional-type(operands, results)
+ }];
+}
+
+def mif_LcoboundOp : mif_Op<"lcobound", [NoMemoryEffect]> {
+ let summary = "Returns the lower cobound(s) associated with a coarray.";
+ let description = [{
+ This operation returns the lower cobound(s) associated with a coarray.
+ Arguments:
+ - `coarray`: Shall be a coarray of any type.
+ - `dim`(optional) : Shall be an integer scalar. Its value shall be in the range of
+ `1 <= DIM <= N`, where `N` is the corank of the coarray.
+ Results:
+ - Case(1): If `dim` is present, the result is an integer scalar equal to
+ the lower cobound for codimension `dim`.
+ - Case(2): `dim` is absent, so the result is an array whose size matches
+ the corank of the indicated coarray.
+ }];
+
+ let arguments = (ins AnyType:$coarray, Optional<AnyInteger>:$dim);
+ let results = (outs AnyType);
+
+ let builders = [OpBuilder<(ins "mlir::Value":$coarray, "mlir::Value":$dim)>,
+ OpBuilder<(ins "mlir::Value":$coarray)>];
+
+ let hasVerifier = 1;
+ let assemblyFormat = [{
+ `coarray` $coarray
+ ( `dim` $dim^ )?
+ attr-dict `:` functional-type(operands, results)
+ }];
+}
+
+def mif_UcoboundOp : mif_Op<"ucobound", [NoMemoryEffect]> {
+ let summary = "Returns the upper cobound(s) associated with a coarray.";
+ let description = [{
+ This operation returns the upper cobound(s) associated with a coarray.
+ Arguments:
+ - `coarray`: Shall be a coarray of any type.
+ - `dim`(optional) : Shall be an integer scalar. Its value shall be in the range of
+ `1 <= DIM <= N`, where `N` is the corank of the coarray.
+ Results:
+ - Case(1): If `dim` is present, the result is an integer scalar equal to
+ the upper cobound for codimension `dim`.
+ - Case(2): `dim` is absent, so the result is an array whose size matches
+ the corank of the indicated coarray.
+ }];
+
+ let arguments = (ins AnyType:$coarray, Optional<AnyInteger>:$dim);
+ let results = (outs AnyType);
+
+ let builders = [OpBuilder<(ins "mlir::Value":$coarray, "mlir::Value":$dim)>,
+ OpBuilder<(ins "mlir::Value":$coarray)>];
+
+ let hasVerifier = 1;
+ let assemblyFormat = [{
+ `coarray` $coarray
+ ( `dim` $dim^ )?
+ attr-dict `:` functional-type(operands, results)
+ }];
+}
+
+def mif_CoshapeOp : mif_Op<"coshape", [NoMemoryEffect]> {
+ let summary = "Return the sizes of codimensions of a coarray.";
+ let description = [{
+ Argument: `coarray`: Shall be a coarray of any type.
+ Result : Is an array whose size matches the corank of the indicated coarray and
+ returns `UCOBOUND - LCOBOUND + 1`.
+ }];
+
+ let arguments = (ins AnyType:$coarray);
+ let builders = [OpBuilder<(ins "mlir::Value":$coarray)>];
+ let results = (outs AnyBoxedArray);
+
+ let hasVerifier = 1;
+ let assemblyFormat = [{
+ `coarray` $coarray
+ attr-dict `:` functional-type(operands, results)
+ }];
+}
+
//===----------------------------------------------------------------------===//
// Synchronization
//===----------------------------------------------------------------------===//
diff --git a/flang/lib/Lower/ConvertCall.cpp b/flang/lib/Lower/ConvertCall.cpp
index ea65a49355330..ada0708931b4e 100644
--- a/flang/lib/Lower/ConvertCall.cpp
+++ b/flang/lib/Lower/ConvertCall.cpp
@@ -2149,6 +2149,22 @@ static std::optional<hlfir::EntityWithAttributes> genCustomIntrinsicRefCore(
loc, builder, result, ".tmp.custom_intrinsic_result")}};
}
+static mlir::IntegerAttr
+getCorankFromExpr(fir::FirOpBuilder &builder,
+ const Fortran::lower::SomeExpr &expr) {
+ mlir::IntegerAttr corankAttr;
+ if (auto dataRef{Fortran::evaluate::ExtractDataRef(expr)}) {
+ const Fortran::semantics::Symbol sym = dataRef->GetLastSymbol();
+ if (const auto *object =
+ sym.GetUltimate()
+ .detailsIf<Fortran::semantics::ObjectEntityDetails>())
+ if (object->coshape().size())
+ corankAttr = builder.getIntegerAttr(builder.getI32Type(),
+ object->coshape().size());
+ }
+ return corankAttr;
+}
+
/// Lower calls to intrinsic procedures with actual arguments that have been
/// pre-lowered but have not yet been prepared according to the interface.
static std::optional<hlfir::EntityWithAttributes>
@@ -2172,6 +2188,11 @@ genIntrinsicRefCore(Fortran::lower::PreparedActualArguments &loweredActuals,
const fir::IntrinsicArgumentLoweringRules *argLowering =
intrinsicEntry.getArgumentLoweringRules();
for (auto arg : llvm::enumerate(loweredActuals)) {
+ // Trying to retrieve the corank of a variable if this is a coarray
+ mlir::IntegerAttr corankAttr;
+ if (const Fortran::lower::SomeExpr *expr =
+ callContext.procRef.UnwrapArgExpr(arg.index()))
+ corankAttr = getCorankFromExpr(builder, *expr);
if (!arg.value()) {
operands.emplace_back(fir::getAbsentIntrinsicArgument());
continue;
@@ -2221,6 +2242,9 @@ genIntrinsicRefCore(Fortran::lower::PreparedActualArguments &loweredActuals,
genOptionalValue(builder, loc, getActualFortranElementType(),
getActualCb, isPresent);
addToCleanups(std::move(cleanup));
+ if (corankAttr)
+ fir::getBase(exv).getDefiningOp()->setAttr(fir::getCorankAttrName(),
+ corankAttr);
operands.emplace_back(exv);
continue;
}
@@ -2228,6 +2252,9 @@ genIntrinsicRefCore(Fortran::lower::PreparedActualArguments &loweredActuals,
hlfir::Entity actual = arg.value()->getActual(loc, builder);
auto [exv, cleanup] = genOptionalAddr(builder, loc, actual, isPresent);
addToCleanups(std::move(cleanup));
+ if (corankAttr)
+ fir::getBase(exv).getDefiningOp()->setAttr(fir::getCorankAttrName(),
+ corankAttr);
operands.emplace_back(exv);
continue;
}
@@ -2235,6 +2262,9 @@ genIntrinsicRefCore(Fortran::lower::PreparedActualArguments &loweredActuals,
hlfir::Entity actual = arg.value()->getActual(loc, builder);
auto [exv, cleanup] = genOptionalBox(builder, loc, actual, isPresent);
addToCleanups(std::move(cleanup));
+ if (corankAttr)
+ fir::getBase(exv).getDefiningOp()->setAttr(fir::getCorankAttrName(),
+ corankAttr);
operands.emplace_back(exv);
continue;
}
@@ -2250,19 +2280,31 @@ genIntrinsicRefCore(Fortran::lower::PreparedActualArguments &loweredActuals,
llvm_unreachable("bad switch");
}
+ fir::ExtendedValue exv;
hlfir::Entity actual = arg.value()->getActual(loc, builder);
switch (argRules.lowerAs) {
case fir::LowerIntrinsicArgAs::Value:
- operands.emplace_back(
- Fortran::lower::convertToValue(loc, converter, actual, stmtCtx));
+ exv = Fortran::lower::convertToValue(loc, converter, actual, stmtCtx);
+ if (corankAttr)
+ fir::getBase(exv).getDefiningOp()->setAttr(fir::getCorankAttrName(),
+ corankAttr);
+ operands.emplace_back(exv);
continue;
case fir::LowerIntrinsicArgAs::Addr:
- operands.emplace_back(Fortran::lower::convertToAddress(
- loc, converter, actual, stmtCtx, getActualFortranElementType()));
+ exv = Fortran::lower::convertToAddress(loc, converter, actual, stmtCtx,
+ getActualFortranElementType());
+ if (corankAttr)
+ fir::getBase(exv).getDefiningOp()->setAttr(fir::getCorankAttrName(),
+ corankAttr);
+ operands.emplace_back(exv);
continue;
case fir::LowerIntrinsicArgAs::Box:
- operands.emplace_back(Fortran::lower::convertToBox(
- loc, converter, actual, stmtCtx, getActualFortranElementType()));
+ exv = Fortran::lower::convertToBox(loc, converter, actual, stmtCtx,
+ getActualFortranElementType());
+ if (corankAttr)
+ fir::getBase(exv).getDefiningOp()->setAttr(fir::getCorankAttrName(),
+ corankAttr);
+ operands.emplace_back(exv);
continue;
case fir::LowerIntrinsicArgAs::Inquired:
if (const Fortran::lower::SomeExpr *expr =
@@ -2977,6 +3019,9 @@ genCustomIntrinsicRef(const Fortran::evaluate::SpecificIntrinsic *intrinsic,
}
if (!exv)
llvm_unreachable("bad switch");
+ if (mlir::IntegerAttr corankAttr = getCorankFromExpr(builder, expr))
+ fir::getBase(*exv).getDefiningOp()->setAttr(fir::getCorankAttrName(),
+ corankAttr);
actual = extendedValueToHlfirEntity(loc, builder, exv.value(),
"tmp.custom_intrinsic_arg");
loweredActuals.emplace_back(Fortran::lower::PreparedActualArgument{
diff --git a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
index 8f75b94d2f7e7..dd1c0dcd6d069 100644
--- a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
+++ b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
@@ -243,6 +243,10 @@ static constexpr IntrinsicHandler handlers[]{
{"command_argument_count", &I::genCommandArgumentCount},
{"conjg", &I::genConjg},
{"cosd", &I::genCosd},
+ {"coshape",
+ &I::genCoshape,
+ {{{"coarray", asAddr}, {"kind", asValue}}},
+ false},
{"cospi", &I::genCospi},
{"count",
&I::genCount,
@@ -499,6 +503,13 @@ static constexpr IntrinsicHandler handlers[]{
{"ieee_unordered", &I::genIeeeUnordered},
{"ieee_value", &I::genIeeeValue},
{"ieor", &I::genIeor},
+ {"image_index",
+ &I::genImageIndex,
+ {{{"coarray", asAddr},
+ {"sub", asBox},
+ {"team", asAddr},
+ {"team_number", asAddr}}},
+ /*isElemental*/ false},
{"index",
&I::genIndex,
{{{"string", asAddr},
@@ -529,6 +540,10 @@ static constexpr IntrinsicHandler handlers[]{
&I::genLbound,
{{{"array", asInquired}, {"dim", asValue}, {"kind", asValue}}},
/*isElemental=*/false},
+ {"lcobound",
+ &I::genLcobound,
+ {{{"coarray", asAddr}, {"dim", asValue}, {"kind", asValue}}},
+ /*isElemental=*/false},
{"leadz", &I::genLeadz},
{"len",
&I::genLen,
@@ -801,8 +816,8 @@ static constexpr IntrinsicHandler handlers[]{
/*isElemental=*/false},
{"this_image",
&I::genThisImage,
- {{{"coarray", asBox},
- {"dim", asAddr},
+ {{{"coarray", asAddr},
+ {"dim", asValue},
{"team", asBox, handleDynamicOptional}}},
/*isElemental=*/false},
{"time", &I::genTime, {}, /*isElemental=*/false},
@@ -827,6 +842,10 @@ static constexpr IntrinsicHandler handlers[]{
&I::genUbound,
{{{"array", asBox}, {"dim", asValue}, {"kind", asValue}}},
/*isElemental=*/false},
+ {"ucobound",
+ &I::genUcobound,
+ {{{"coarray", asAddr}, {"dim", asValue}, {"kind", asValue}}},
+ /*isElemental=*/false},
{"umaskl", &I::genMask<mlir::arith::ShLIOp>},
{"umaskr", &I::genMask<mlir::arith::ShRUIOp>},
{"unlink",
@@ -3568,6 +3587,17 @@ mlir::Value IntrinsicLibrary::genCospi(mlir::Type resultType,
return getRuntimeCallGenerator("cos", ftype)(builder, loc, {arg});
}
+// COSHAPE
+fir::ExtendedValue
+IntrinsicLibrary::genCoshape(mlir::Type,
+ llvm::ArrayRef<fir::ExtendedValue> args) {
+ converter->checkCoarrayEnabled();
+ assert(args.size() == 2);
+
+ return mif::CoshapeOp::create(builder, loc,
+ /*coarray*/ fir::getBase(args[0]));
+}
+
// COUNT
fir::ExtendedValue
IntrinsicLibrary::genCount(mlir::Type resultType,
@@ -6243,6 +6273,22 @@ mlir::Value IntrinsicLibrary::genIeor(mlir::Type resultType,
args[1]);
}
+// IMAGE_INDEX
+fir::ExtendedValue
+IntrinsicLibrary::genImageIndex(mlir::Type resultType,
+ llvm::ArrayRef<fir::ExtendedValue> args) {
+ converter->checkCoarrayEnabled();
+ assert(args.size() == 2 || args.size() == 3);
+
+ mlir::Value team;
+ if (args.size() > 2) {
+ team = fir::getBase(args[2]);
+ }
+ return mif::ImageIndexOp::create(builder, loc,
+ /*coarray*/ fir::getBase(args[0]),
+ /*sub*/ fir::getBase(args[1]), team);
+}
+
// INDEX
fir::ExtendedValue
IntrinsicLibrary::genIndex(mlir::Type resultType,
@@ -8257,11 +8303,21 @@ IntrinsicLibrary::genThisImage(mlir::Type resultType,
converter->checkCoarrayEnabled();
assert(args.size() >= 1 && args.size() <= 3);
const bool coarrayIsAbsent = args.size() == 1;
+ const bool dimIsAbsent = args.size() < 3;
mlir::Value team = fir::getBase(args[args.size() - 1]);
- if (!coarrayIsAbsent)
- TODO(loc, "this_image with coarray argument.");
- mlir::Value res = mif::ThisImageOp::create(builder, loc, team);
+ if (!coarrayIsAbsent && dimIsAbsent) {
+ mlir::Value res =
+ mif::ThisImageOp::create(builder, loc, fir::getBase(args[0]), team);
+ return res;
+ }
+ mlir::Value res;
+ if (!dimIsAbsent) {
+ mlir::Value coarray = fir::getBase(args[0]);
+ mlir::Value dim = fir::getBase(args[1]);
+ res = mif::ThisImageOp::create(builder, loc, coarray, dim, team);
+ } else
+ res = mif::ThisImageOp::create(builder, loc, team);
return builder.createConvert(loc, resultType, res);
}
@@ -8366,6 +8422,22 @@ IntrinsicLibrary::genLbound(mlir::Type resultType,
fir::runtime::genLboundDim(builder, loc, fir::getBase(box), dim));
}
+// LCOBOUND
+fir::ExtendedValue
+IntrinsicLibrary::genLcobound(mlir::Type resultType,
+ llvm::ArrayRef<fir::ExtendedValue> args) {
+ converter->checkCoarrayEnabled();
+ assert(args.size() == 2 || args.size() == 3);
+
+ mlir::Value coarray = fir::getBase(args[0]);
+ const bool dimIsAbsent = args.size() == 2 || isStaticallyAbsent(args, 1);
+ if (!dimIsAbsent) {
+ mlir::Value dim = fir::getBase(args[1]);
+ return mif::LcoboundOp::create(builder, loc, resultType, coarray, dim);
+ }
+ return mif::LcoboundOp::create(builder, loc, coarray);
+}
+
// UBOUND
fir::ExtendedValue
IntrinsicLibrary::genUbound(mlir::Type resultType,
@@ -8388,6 +8460,22 @@ IntrinsicLibrary::genUbound(mlir::Type resultType,
/*needAccurateLowerBound=*/true);
}
+// UCOBOUND
+fir::ExtendedValue
+IntrinsicLibrary::genUcobound(mlir::Type resultType,
+ llvm::ArrayRef<fir::ExtendedValue> args) {
+ converter->checkCoarrayEnabled();
+ assert(args.size() == 2 || args.size() == 3);
+
+ mlir::Value coarray = fir::getBase(args[0]);
+ const bool dimIsAbsent = args.size() == 2 || isStaticallyAbsent(args, 1);
+ if (!dimIsAbsent) {
+ mlir::Value dim = fir::getBase(args[1]);
+ return mif::UcoboundOp::create(builder, loc, resultType, coarray, dim);
+ }
+ return mif::UcoboundOp::create(builder, loc, coarray);
+}
+
// SPACING
mlir::Value IntrinsicLibrary::genSpacing(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
diff --git a/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
index ebeba9aa51494..5620353a58f3d 100644
--- a/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
+++ b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
@@ -10,6 +10,7 @@
#include "flang/Optimizer/Builder/Todo.h"
#include "flang/Optimizer/Dialect/FIRAttr.h"
#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "flang/Optimizer/Dialect/MIF/MIFDialect.h"
#include "flang/Optimizer/HLFIR/HLFIROps.h"
@@ -18,6 +19,14 @@
#include "llvm/ADT/SmallVector.h"
#include <tuple>
+template <class T>
+static llvm::LogicalResult checkCorankAttr(T op) {
+ mlir::Value coarray = op.getCoarray();
+ if (!coarray.getDefiningOp()->hasAttr(fir::getCorankAttrName()))
+ return op.emitOpError("`coarray` must have a corank integer attribute.");
+ return mlir::success();
+}
+
// Function used to check if a type has POINTER or ALLOCATABLE component.
// Currently an allocation of coarray with this kind of component are not yet
// supported.
@@ -64,22 +73,35 @@ llvm::LogicalResult mif::NumImagesOp::verify() {
// ThisImageOp
//===----------------------------------------------------------------------===//
+void mif::ThisImageOp::build(mlir::OpBuilder &builder,
+ mlir::OperationState &result, mlir::Value coarray,
+ mlir::Value dim, mlir::Value team) {
+ mlir::Type resultTy = builder.getI32Type();
+ build(builder, result, resultTy, coarray, dim, team);
+}
+
void mif::ThisImageOp::build(mlir::OpBuilder &builder,
mlir::OperationState &result, mlir::Value coarray,
mlir::Value team) {
- build(builder, result, coarray, /*dim*/ mlir::Value{}, team);
+ mlir::Type i64Ty = builder.getI64Type();
+ mlir::Type resultTy = fir::BoxType::get(
+ fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, i64Ty));
+ build(builder, result, resultTy, 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);
+ mlir::Type resultTy = builder.getI32Type();
+ build(builder, result, resultTy, /*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.");
+ if (getCoarray())
+ return checkCorankAttr(*this);
return mlir::success();
}
@@ -269,5 +291,97 @@ llvm::LogicalResult mif::AllocCoarrayOp::verify() {
return mlir::success();
}
+//===----------------------------------------------------------------------===//
+// LcoboundOp
+//===----------------------------------------------------------------------===//
+
+void mif::LcoboundOp::build(mlir::OpBuilder &builder,
+ mlir::OperationState &result, mlir::Value coarray,
+ mlir::Value dim) {
+ // By default the result type is an I64
+ mlir::Type resultTy = builder.getI64Type();
+ build(builder, result, resultTy, coarray, dim);
+}
+
+void mif::LcoboundOp::build(mlir::OpBuilder &builder,
+ mlir::OperationState &result, mlir::Value coarray) {
+ mlir::Type i64Ty = builder.getI64Type();
+ mlir::Type resultTy = fir::BoxType::get(
+ fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, i64Ty));
+ build(builder, result, resultTy, coarray, /*dim*/ mlir::Value{});
+}
+
+llvm::LogicalResult mif::LcoboundOp::verify() {
+ if (getCoarray())
+ return checkCorankAttr(*this);
+ return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
+// UcoboundOp
+//===----------------------------------------------------------------------===//
+
+void mif::UcoboundOp::build(mlir::OpBuilder &builder,
+ mlir::OperationState &result, mlir::Value coarray,
+ mlir::Value dim) {
+ // By default the result type is an I64
+ mlir::Type resultTy = builder.getI64Type();
+ build(builder, result, resultTy, coarray, dim);
+}
+
+void mif::UcoboundOp::build(mlir::OpBuilder &builder,
+ mlir::OperationState &result, mlir::Value coarray) {
+ mlir::Type i64Ty = builder.getI64Type();
+ mlir::Type resultTy = fir::BoxType::get(
+ fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, i64Ty));
+ build(builder, result, resultTy, coarray, /*dim*/ mlir::Value{});
+}
+
+llvm::LogicalResult mif::UcoboundOp::verify() {
+ if (getCoarray())
+ return checkCorankAttr(*this);
+ return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
+// CoshapeOp
+//===----------------------------------------------------------------------===//
+
+void mif::CoshapeOp::build(mlir::OpBuilder &builder,
+ mlir::OperationState &result, mlir::Value coarray) {
+ mlir::Type i64Ty = builder.getI64Type();
+ mlir::Type resultTy = fir::BoxType::get(
+ fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, i64Ty));
+ build(builder, result, resultTy, coarray);
+}
+
+llvm::LogicalResult mif::CoshapeOp::verify() {
+ if (getCoarray())
+ return checkCorankAttr(*this);
+ return mlir::success();
+}
+
+//===----------------------------------------------------------------------===//
+// ImageIndexOp
+//===----------------------------------------------------------------------===//
+
+void mif::ImageIndexOp::build(mlir::OpBuilder &builder,
+ mlir::OperationState &result, mlir::Value coarray,
+ mlir::Value sub, mlir::Value teamArg) {
+ bool isTeamNumber =
+ teamArg && fir::unwrapPassByRefType(teamArg.getType()).isInteger();
+ if (!isTeamNumber)
+ build(builder, result, coarray, sub, teamArg, /*team*/ mlir::Value{});
+ else
+ build(builder, result, coarray, sub, /*team_number*/ mlir::Value{},
+ teamArg);
+}
+
+llvm::LogicalResult mif::ImageIndexOp::verify() {
+ if (getCoarray())
+ return checkCorankAttr(*this);
+ return mlir::success();
+}
+
#define GET_OP_CLASSES
#include "flang/Optimizer/Dialect/MIF/MIFOps.cpp.inc"
diff --git a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
index 28e6dda7721e8..ba6a0a91d3d9b 100644
--- a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
+++ b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
@@ -139,6 +139,15 @@ void storeCoarrayHandle(fir::FirOpBuilder &builder, mlir::Location loc,
fir::StoreOp::create(builder, loc, coarrayHandle, addrOf);
}
+std::int64_t getCorankFromAttr(fir::FirOpBuilder &builder, mlir::Location loc,
+ mlir::Value coarray) {
+ std::int64_t corank = 0;
+ if (auto intAttr = coarray.getDefiningOp()->getAttrOfType<mlir::IntegerAttr>(
+ fir::getCorankAttrName()))
+ corank = intAttr.getInt();
+ return corank;
+}
+
static int computeElementByteSize(mlir::Location loc, mlir::Type type,
fir::KindMapping &kindMap,
bool emitErrorOnFailure = true) {
@@ -430,27 +439,74 @@ struct MIFThisImageOpConversion
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::Type i64Ty = builder.getI64Type();
+ mlir::Type i32Ty = builder.getI32Type();
+ mlir::Type boxTy = fir::BoxType::get(rewriter.getNoneType());
+
+ mlir::Value teamArg = op.getTeam();
+ if (!op.getTeam())
+ teamArg = fir::AbsentOp::create(builder, loc, boxTy);
+ else
+ teamArg = builder.createBox(loc, teamArg);
+
+ if (op.getCoarray()) {
+ llvm::SmallVector<mlir::Value> args;
+ mlir::FunctionType ftype;
+ mlir::func::FuncOp funcOp;
+ mlir::Value result;
+ mlir::Value coarrayHandle =
+ getCoarrayHandle(builder, loc, op.getCoarray());
+ if (mlir::Value d = op.getDim()) {
+ mlir::Value dim = builder.createTemporary(loc, i32Ty);
+ if (d.getType() != i32Ty)
+ d = fir::ConvertOp::create(builder, loc, i32Ty, d);
+ fir::StoreOp::create(builder, loc, d, dim);
+ result = builder.createTemporary(loc, i64Ty);
+ ftype = mlir::FunctionType::get(builder.getContext(),
+ /*inputs*/
+ {boxTy, builder.getRefType(i32Ty),
+ boxTy, builder.getRefType(i64Ty)},
+ /*results*/ {});
+ funcOp = builder.createFunction(
+ loc, getPRIFProcName("this_image_with_dim"), ftype);
+ args = fir::runtime::createArguments(builder, loc, ftype, coarrayHandle,
+ dim, teamArg, result);
+ fir::CallOp::create(builder, loc, funcOp, args);
+ result = fir::LoadOp::create(builder, loc, result).getResult();
+ if (result.getType() != op.getType())
+ result = builder.createConvert(loc, op.getType(), result);
+ } else {
+ std::int64_t corank = getCorankFromAttr(builder, loc, op.getCoarray());
+ mlir::Type resTy = fir::SequenceType::get({corank}, i64Ty);
+ // Need to embox the array
+ result = builder.createBox(loc, builder.createTemporary(loc, resTy));
+ ftype = mlir::FunctionType::get(
+ builder.getContext(),
+ /*inputs*/ {boxTy, boxTy, fir::BoxType::get(resTy)},
+ /*results*/ {});
+ funcOp = builder.createFunction(
+ loc, getPRIFProcName("this_image_with_coarray"), ftype);
+ args = fir::runtime::createArguments(builder, loc, ftype, coarrayHandle,
+ teamArg, result);
+ fir::CallOp::create(builder, loc, funcOp, args);
+ result = fir::ConvertOp::create(builder, loc,
+ genBoxedSequenceType(i64Ty), result);
+ }
+ rewriter.replaceOp(op, result);
+ } else {
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();
}
+ return mlir::success();
}
};
@@ -1114,6 +1170,182 @@ struct MIFDeallocCoarrayOpConversion
}
};
+/// Convert mif.coshape operation to runtime call of 'prif_coshape'
+struct MIFCoshapeOpConversion : public mlir::OpRewritePattern<mif::CoshapeOp> {
+ using OpRewritePattern::OpRewritePattern;
+
+ mlir::LogicalResult
+ matchAndRewrite(mif::CoshapeOp 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 i64Ty = builder.getI64Type();
+ mlir::Type boxTy = fir::BoxType::get(builder.getNoneType());
+
+ mlir::FunctionType ftype =
+ mlir::FunctionType::get(builder.getContext(),
+ /*inputs*/ {boxTy, genBoxedSequenceType(i64Ty)},
+ /*results*/ {});
+ mlir::func::FuncOp funcOp =
+ builder.createFunction(loc, getPRIFProcName("coshape"), ftype);
+
+ mlir::Value coarrayHandle = getCoarrayHandle(builder, loc, op.getCoarray());
+ std::int64_t corank = getCorankFromAttr(builder, loc, op.getCoarray());
+ mlir::Type resultType = fir::SequenceType::get(
+ static_cast<fir::SequenceType::Extent>(corank), i64Ty);
+ mlir::Value result =
+ builder.createBox(loc, builder.createTemporary(loc, resultType));
+
+ llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+ builder, loc, ftype, coarrayHandle, result);
+ fir::CallOp::create(builder, loc, funcOp, args);
+ result = fir::ConvertOp::create(builder, loc, genBoxedSequenceType(i64Ty),
+ result);
+ rewriter.replaceOp(op, result);
+ return mlir::success();
+ }
+};
+
+template <class T>
+mlir::LogicalResult CoboundOpConversion(T op, mlir::PatternRewriter &rewriter,
+ const std::string &prefix) {
+ auto mod = op->template getParentOfType<mlir::ModuleOp>();
+ fir::FirOpBuilder builder(rewriter, mod);
+ mlir::Location loc = op.getLoc();
+ mlir::Type i64Ty = builder.getI64Type();
+ mlir::Type boxTy = fir::BoxType::get(builder.getNoneType());
+
+ mlir::Value coarrayHandle = getCoarrayHandle(builder, loc, op.getCoarray());
+ if (mlir::Value d = op.getDim()) {
+ mlir::Type i32Ty = builder.getI32Type();
+ mlir::FunctionType ftype = mlir::FunctionType::get(
+ builder.getContext(),
+ /*inputs*/
+ {boxTy, builder.getRefType(i32Ty), builder.getRefType(i64Ty)},
+ /*results*/ {});
+ mlir::func::FuncOp funcOp = builder.createFunction(
+ loc, getPRIFProcName(prefix + "_with_dim"), ftype);
+
+ mlir::Value result = builder.createTemporary(loc, i64Ty);
+ mlir::Value dim = builder.createTemporary(loc, i32Ty);
+ if (d.getType() != i32Ty)
+ d = fir::ConvertOp::create(builder, loc, i32Ty, d);
+ fir::StoreOp::create(builder, loc, d, dim);
+
+ llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+ builder, loc, ftype, coarrayHandle, dim, result);
+ fir::CallOp::create(builder, loc, funcOp, args);
+ result = fir::LoadOp::create(builder, loc, result).getResult();
+ if (result.getType() != op.getType())
+ result = builder.createConvert(loc, op.getType(), result);
+ rewriter.replaceOp(op, result);
+ } else {
+ mlir::FunctionType ftype =
+ mlir::FunctionType::get(builder.getContext(),
+ /*inputs*/ {boxTy, genBoxedSequenceType(i64Ty)},
+ /*results*/ {});
+ mlir::func::FuncOp funcOp =
+ builder.createFunction(loc, getPRIFProcName(prefix + "_no_dim"), ftype);
+
+ std::int64_t corank = getCorankFromAttr(builder, loc, op.getCoarray());
+ mlir::Type resultType = fir::SequenceType::get(
+ static_cast<fir::SequenceType::Extent>(corank), i64Ty);
+ mlir::Value result =
+ builder.createBox(loc, builder.createTemporary(loc, resultType));
+ llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+ builder, loc, ftype, coarrayHandle, result);
+ fir::CallOp::create(builder, loc, funcOp, args);
+ result = fir::ConvertOp::create(builder, loc, genBoxedSequenceType(i64Ty),
+ result);
+ rewriter.replaceOp(op, result);
+ }
+ return mlir::success();
+}
+
+/// Convert mif.lcobound operation to runtime call of
+/// 'prif_lcobound_{with|no}_dim'
+struct MIFLcoboundOpConversion
+ : public mlir::OpRewritePattern<mif::LcoboundOp> {
+ using OpRewritePattern::OpRewritePattern;
+
+ mlir::LogicalResult
+ matchAndRewrite(mif::LcoboundOp op,
+ mlir::PatternRewriter &rewriter) const override {
+ return CoboundOpConversion(op, rewriter, "lcobound");
+ }
+};
+
+/// Convert mif.ucobound operation to runtime call of
+/// 'prif_ucobound_{with|no}_dim'
+struct MIFUcoboundOpConversion
+ : public mlir::OpRewritePattern<mif::UcoboundOp> {
+ using OpRewritePattern::OpRewritePattern;
+
+ mlir::LogicalResult
+ matchAndRewrite(mif::UcoboundOp op,
+ mlir::PatternRewriter &rewriter) const override {
+ return CoboundOpConversion(op, rewriter, "ucobound");
+ }
+};
+
+/// Convert mif.image_index operation to runtime call of
+/// 'prif_image_index[_with_team[_number]]'
+struct MIFImageIndexOpConversion
+ : public mlir::OpRewritePattern<mif::ImageIndexOp> {
+ using OpRewritePattern::OpRewritePattern;
+
+ mlir::LogicalResult
+ matchAndRewrite(mif::ImageIndexOp 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 i64Ty = builder.getI64Type();
+ mlir::Type i32Ty = builder.getI32Type();
+ mlir::Type resTy = builder.getRefType(i32Ty);
+ mlir::Type boxTy = fir::BoxType::get(builder.getNoneType());
+ mlir::Value result = builder.createTemporary(loc, i32Ty);
+
+ mlir::func::FuncOp funcOp;
+ mlir::FunctionType ftype;
+ llvm::SmallVector<mlir::Value> args;
+ mlir::Value coarrayHandle = getCoarrayHandle(builder, loc, op.getCoarray());
+ if (!op.getTeam()) {
+ mlir::FunctionType ftype = mlir::FunctionType::get(
+ builder.getContext(),
+ /*inputs*/ {boxTy, genBoxedSequenceType(i64Ty), resTy},
+ /*results*/ {});
+ funcOp =
+ builder.createFunction(loc, getPRIFProcName("image_index"), ftype);
+ args = fir::runtime::createArguments(builder, loc, ftype, coarrayHandle,
+ op.getSub(), result);
+ } else {
+ mlir::Value team = op.getTeam();
+ std::string imageIndexName =
+ fir::unwrapPassByRefType(team.getType()).isInteger()
+ ? getPRIFProcName("image_index_with_team")
+ : getPRIFProcName("image_index_with_team_number");
+ mlir::Type teamTy = fir::unwrapPassByRefType(team.getType()).isInteger()
+ ? builder.getRefType(i64Ty)
+ : boxTy;
+ mlir::FunctionType ftype = mlir::FunctionType::get(
+ builder.getContext(),
+ /*inputs*/ {boxTy, genBoxedSequenceType(i64Ty), teamTy, resTy},
+ /*results*/ {});
+ funcOp = builder.createFunction(loc, imageIndexName, ftype);
+
+ if (fir::isa_ref_type(team.getType()))
+ team = builder.createBox(loc, team);
+ args = fir::runtime::createArguments(builder, loc, ftype, coarrayHandle,
+ op.getSub(), team, result);
+ }
+ fir::CallOp::create(builder, loc, funcOp, args);
+ rewriter.replaceOpWithNewOp<fir::LoadOp>(op, result);
+ return mlir::success();
+ }
+};
+
class MIFOpConversion : public fir::impl::MIFOpConversionBase<MIFOpConversion> {
public:
void runOnOperation() override {
@@ -1158,13 +1390,14 @@ void mif::populateMIFOpConversionPatterns(
mlir::RewritePatternSet &patterns) {
patterns.insert<MIFAllocCoarrayOpConversion>(patterns.getContext(), &dl,
&converter);
- patterns.insert<MIFInitOpConversion, MIFThisImageOpConversion,
- MIFNumImagesOpConversion, MIFSyncAllOpConversion,
- MIFSyncImagesOpConversion, MIFSyncMemoryOpConversion,
- MIFSyncTeamOpConversion, MIFCoBroadcastOpConversion,
- MIFCoMaxOpConversion, MIFCoMinOpConversion,
- MIFCoSumOpConversion, MIFFormTeamOpConversion,
- MIFChangeTeamOpConversion, MIFGetTeamOpConversion,
- MIFTeamNumberOpConversion, MIFDeallocCoarrayOpConversion>(
- patterns.getContext());
+ patterns.insert<
+ MIFInitOpConversion, MIFThisImageOpConversion, MIFNumImagesOpConversion,
+ MIFSyncAllOpConversion, MIFSyncImagesOpConversion,
+ MIFSyncMemoryOpConversion, MIFSyncTeamOpConversion,
+ MIFCoBroadcastOpConversion, MIFCoMaxOpConversion, MIFCoMinOpConversion,
+ MIFCoSumOpConversion, MIFFormTeamOpConversion, MIFChangeTeamOpConversion,
+ MIFGetTeamOpConversion, MIFTeamNumberOpConversion,
+ MIFDeallocCoarrayOpConversion, MIFCoshapeOpConversion,
+ MIFLcoboundOpConversion, MIFUcoboundOpConversion,
+ MIFImageIndexOpConversion>(patterns.getContext());
}
diff --git a/flang/test/Fir/MIF/cobound.mlir b/flang/test/Fir/MIF/cobound.mlir
new file mode 100644
index 0000000000000..e5072632e6b49
--- /dev/null
+++ b/flang/test/Fir/MIF/cobound.mlir
@@ -0,0 +1,93 @@
+// RUN: fir-opt --mif-convert %s | FileCheck %s
+
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 23.0.0 (git at github.com:SiPearl/llvm-project.git d31a4730513391710d91c5ad33bb8ea3d68db3cb)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
+// CHECK-LABEL: func.func @_QQmain
+ func.func @_QQmain() attributes {fir.bindc_name = "TEST"} {
+ %0 = fir.alloca !fir.array<2xi64>
+ %1 = fir.alloca !fir.array<3xi64>
+ %2 = fir.dummy_scope : !fir.dscope
+ %3 = fir.address_of(@_QFEa) : !fir.ref<!fir.box<!fir.heap<i32>>>
+ %4:2 = hlfir.declare %3 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEa"} : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
+ %c3 = arith.constant 3 : index
+ %5 = fir.alloca !fir.array<3xi32> {bindc_name = "res1", uniq_name = "_QFEres1"}
+ %6 = fir.shape %c3 : (index) -> !fir.shape<1>
+ %7:2 = hlfir.declare %5(%6) {uniq_name = "_QFEres1"} : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<3xi32>>, !fir.ref<!fir.array<3xi32>>)
+ %8 = fir.alloca i32 {bindc_name = "res2", uniq_name = "_QFEres2"}
+ %9:2 = hlfir.declare %8 {uniq_name = "_QFEres2"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+ %10 = fir.absent !fir.box<none>
+ %c1_i64 = arith.constant 1 : i64
+ %c2_i32 = arith.constant 2 : i32
+ %11 = fir.convert %c2_i32 : (i32) -> i64
+ %c0 = arith.constant 0 : index
+ %12 = fir.coordinate_of %1, %c0 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64 to %12 : !fir.ref<i64>
+ %13 = fir.coordinate_of %0, %c0 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+ fir.store %11 to %13 : !fir.ref<i64>
+ %c3_i32 = arith.constant 3 : i32
+ %14 = fir.convert %c3_i32 : (i32) -> i64
+ %c5_i32 = arith.constant 5 : i32
+ %15 = fir.convert %c5_i32 : (i32) -> i64
+ %c1 = arith.constant 1 : index
+ %16 = fir.coordinate_of %1, %c1 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+ fir.store %14 to %16 : !fir.ref<i64>
+ %17 = fir.coordinate_of %0, %c1 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+ fir.store %15 to %17 : !fir.ref<i64>
+ %c2 = arith.constant 2 : index
+ %18 = fir.coordinate_of %1, %c2 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64 to %18 : !fir.ref<i64>
+ %19 = fir.embox %1 : (!fir.ref<!fir.array<3xi64>>) -> !fir.box<!fir.array<3xi64>>
+ %20 = fir.embox %0 : (!fir.ref<!fir.array<2xi64>>) -> !fir.box<!fir.array<2xi64>>
+ mif.alloc_coarray %4#0 lcobounds %19 ucobounds %20 errmsg %10 {uniq_name = "_QFEa"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<2xi64>>, !fir.box<none>) -> ()
+ %21 = fir.load %4#0 : !fir.ref<!fir.box<!fir.heap<i32>>>
+ %22 = fir.box_addr %21 {fir.corank = 3 : i32} : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
+// CHECK: fir.call @_QMprifPprif_lcobound_no_dim
+ %23 = mif.lcobound coarray %22 : (!fir.heap<i32>) -> !fir.box<!fir.array<?xi64>>
+ %24:2 = hlfir.declare %23 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.array<?xi64>>) -> (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>)
+ %false = arith.constant false
+ %25 = hlfir.as_expr %24#0 move %false : (!fir.box<!fir.array<?xi64>>, i1) -> !hlfir.expr<?xi64>
+ %c0_0 = arith.constant 0 : index
+ %26:3 = fir.box_dims %24#0, %c0_0 : (!fir.box<!fir.array<?xi64>>, index) -> (index, index, index)
+ %27 = fir.shape %26#1 : (index) -> !fir.shape<1>
+ %28 = hlfir.elemental %27 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
+ ^bb0(%arg0: index):
+ %43 = hlfir.apply %25, %arg0 : (!hlfir.expr<?xi64>, index) -> i64
+ %44 = fir.convert %43 : (i64) -> i32
+ hlfir.yield_element %44 : i32
+ }
+ hlfir.assign %28 to %7#0 : !hlfir.expr<?xi32>, !fir.ref<!fir.array<3xi32>>
+ hlfir.destroy %28 : !hlfir.expr<?xi32>
+ hlfir.destroy %25 : !hlfir.expr<?xi64>
+ %c2_i32_1 = arith.constant 2 : i32
+ %29 = fir.load %4#0 : !fir.ref<!fir.box<!fir.heap<i32>>>
+ %30 = fir.box_addr %29 {fir.corank = 3 : i32} : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
+// CHECK: fir.call @_QMprifPprif_lcobound_with_dim
+ %31 = mif.lcobound coarray %30 dim %c2_i32_1 : (!fir.heap<i32>, i32) -> i32
+ hlfir.assign %31 to %9#0 : i32, !fir.ref<i32>
+ %32 = fir.load %4#0 : !fir.ref<!fir.box<!fir.heap<i32>>>
+ %33 = fir.box_addr %32 {fir.corank = 3 : i32} : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
+ %34 = mif.ucobound coarray %33 : (!fir.heap<i32>) -> !fir.box<!fir.array<?xi64>>
+// CHECK: fir.call @_QMprifPprif_ucobound_no_dim
+ %35:2 = hlfir.declare %34 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.array<?xi64>>) -> (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>)
+ %false_2 = arith.constant false
+ %36 = hlfir.as_expr %35#0 move %false_2 : (!fir.box<!fir.array<?xi64>>, i1) -> !hlfir.expr<?xi64>
+ %c0_3 = arith.constant 0 : index
+ %37:3 = fir.box_dims %35#0, %c0_3 : (!fir.box<!fir.array<?xi64>>, index) -> (index, index, index)
+ %38 = fir.shape %37#1 : (index) -> !fir.shape<1>
+ %39 = hlfir.elemental %38 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
+ ^bb0(%arg0: index):
+ %43 = hlfir.apply %36, %arg0 : (!hlfir.expr<?xi64>, index) -> i64
+ %44 = fir.convert %43 : (i64) -> i32
+ hlfir.yield_element %44 : i32
+ }
+ hlfir.assign %39 to %7#0 : !hlfir.expr<?xi32>, !fir.ref<!fir.array<3xi32>>
+ hlfir.destroy %39 : !hlfir.expr<?xi32>
+ hlfir.destroy %36 : !hlfir.expr<?xi64>
+ %c2_i32_4 = arith.constant 2 : i32
+ %40 = fir.load %4#0 : !fir.ref<!fir.box<!fir.heap<i32>>>
+ %41 = fir.box_addr %40 {fir.corank = 3 : i32} : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
+// CHECK: fir.call @_QMprifPprif_ucobound_with_dim
+ %42 = mif.ucobound coarray %41 dim %c2_i32_4 : (!fir.heap<i32>, i32) -> i32
+ hlfir.assign %42 to %9#0 : i32, !fir.ref<i32>
+ return
+ }
+}
diff --git a/flang/test/Fir/MIF/coshape.mlir b/flang/test/Fir/MIF/coshape.mlir
new file mode 100644
index 0000000000000..1a019117cf8f1
--- /dev/null
+++ b/flang/test/Fir/MIF/coshape.mlir
@@ -0,0 +1,78 @@
+// RUN: fir-opt --mif-convert %s | FileCheck %s
+
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 23.0.0 (git at github.com:SiPearl/llvm-project.git d31a4730513391710d91c5ad33bb8ea3d68db3cb)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
+ func.func @_QQmain() attributes {fir.bindc_name = "TEST"} {
+ %0 = fir.alloca !fir.array<2xi64>
+ %1 = fir.alloca !fir.array<3xi64>
+ %2 = fir.dummy_scope : !fir.dscope
+ %3 = fir.address_of(@_QFEa) : !fir.ref<i32>
+ %c1_i64 = arith.constant 1 : i64
+ %c0 = arith.constant 0 : index
+ %4 = fir.coordinate_of %1, %c0 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64 to %4 : !fir.ref<i64>
+ %c3_i64 = arith.constant 3 : i64
+ %c1 = arith.constant 1 : index
+ %5 = fir.coordinate_of %1, %c1 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+ fir.store %c3_i64 to %5 : !fir.ref<i64>
+ %c1_i64_0 = arith.constant 1 : i64
+ %c2 = arith.constant 2 : index
+ %6 = fir.coordinate_of %1, %c2 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64_0 to %6 : !fir.ref<i64>
+ %7 = fir.embox %1 : (!fir.ref<!fir.array<3xi64>>) -> !fir.box<!fir.array<3xi64>>
+ %c1_i64_1 = arith.constant 1 : i64
+ %c0_2 = arith.constant 0 : index
+ %8 = fir.coordinate_of %0, %c0_2 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64_1 to %8 : !fir.ref<i64>
+ %c3_i64_3 = arith.constant 3 : i64
+ %c1_4 = arith.constant 1 : index
+ %9 = fir.coordinate_of %0, %c1_4 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+ fir.store %c3_i64_3 to %9 : !fir.ref<i64>
+ %10 = fir.embox %0 : (!fir.ref<!fir.array<2xi64>>) -> !fir.box<!fir.array<2xi64>>
+ mif.alloc_coarray %3 lcobounds %7 ucobounds %10 {uniq_name = "_QFEa"} : (!fir.ref<i32>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<2xi64>>) -> ()
+ %11:2 = hlfir.declare %3 {fir.corank = 3 : i32, uniq_name = "_QFEa"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+ %c3 = arith.constant 3 : index
+ %12 = fir.alloca !fir.array<3xi32> {bindc_name = "res", uniq_name = "_QFEres"}
+ %13 = fir.shape %c3 : (index) -> !fir.shape<1>
+ %14:2 = hlfir.declare %12(%13) {uniq_name = "_QFEres"} : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<3xi32>>, !fir.ref<!fir.array<3xi32>>)
+ %c3_5 = arith.constant 3 : index
+ %15 = fir.alloca !fir.array<3xi64> {bindc_name = "res2", uniq_name = "_QFEres2"}
+ %16 = fir.shape %c3_5 : (index) -> !fir.shape<1>
+ %17:2 = hlfir.declare %15(%16) {uniq_name = "_QFEres2"} : (!fir.ref<!fir.array<3xi64>>, !fir.shape<1>) -> (!fir.ref<!fir.array<3xi64>>, !fir.ref<!fir.array<3xi64>>)
+ %18 = mif.coshape coarray %11#0 : (!fir.ref<i32>) -> !fir.box<!fir.array<?xi64>>
+ %19:2 = hlfir.declare %18 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.array<?xi64>>) -> (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>)
+ %false = arith.constant false
+ %20 = hlfir.as_expr %19#0 move %false : (!fir.box<!fir.array<?xi64>>, i1) -> !hlfir.expr<?xi64>
+ %c0_6 = arith.constant 0 : index
+ %21:3 = fir.box_dims %19#0, %c0_6 : (!fir.box<!fir.array<?xi64>>, index) -> (index, index, index)
+ %22 = fir.shape %21#1 : (index) -> !fir.shape<1>
+ %23 = hlfir.elemental %22 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
+ ^bb0(%arg0: index):
+ %30 = hlfir.apply %20, %arg0 : (!hlfir.expr<?xi64>, index) -> i64
+ %31 = fir.convert %30 : (i64) -> i32
+ hlfir.yield_element %31 : i32
+ }
+ hlfir.assign %23 to %14#0 : !hlfir.expr<?xi32>, !fir.ref<!fir.array<3xi32>>
+ hlfir.destroy %23 : !hlfir.expr<?xi32>
+ hlfir.destroy %20 : !hlfir.expr<?xi64>
+ %24 = mif.coshape coarray %11#0 : (!fir.ref<i32>) -> !fir.box<!fir.array<?xi64>>
+ %25:2 = hlfir.declare %24 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.array<?xi64>>) -> (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>)
+ %false_7 = arith.constant false
+ %26 = hlfir.as_expr %25#0 move %false_7 : (!fir.box<!fir.array<?xi64>>, i1) -> !hlfir.expr<?xi64>
+ %c0_8 = arith.constant 0 : index
+ %27:3 = fir.box_dims %25#0, %c0_8 : (!fir.box<!fir.array<?xi64>>, index) -> (index, index, index)
+ %28 = fir.shape %27#1 : (index) -> !fir.shape<1>
+ %29 = hlfir.elemental %28 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi64> {
+ ^bb0(%arg0: index):
+ %30 = hlfir.apply %26, %arg0 : (!hlfir.expr<?xi64>, index) -> i64
+ hlfir.yield_element %30 : i64
+ }
+ hlfir.assign %29 to %17#0 : !hlfir.expr<?xi64>, !fir.ref<!fir.array<3xi64>>
+ hlfir.destroy %29 : !hlfir.expr<?xi64>
+ hlfir.destroy %26 : !hlfir.expr<?xi64>
+ return
+ }
+}
+
+// CHECK-LABEL: func.func @_QQmain
+// CHECK: fir.call @_QMprifPprif_coshape
+// CHECK: fir.call @_QMprifPprif_coshape
diff --git a/flang/test/Fir/MIF/image_index.mlir b/flang/test/Fir/MIF/image_index.mlir
new file mode 100644
index 0000000000000..608dca26e8a6f
--- /dev/null
+++ b/flang/test/Fir/MIF/image_index.mlir
@@ -0,0 +1,67 @@
+// RUN: fir-opt --mif-convert %s | FileCheck %s
+
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 23.0.0 (git at github.com:SiPearl/llvm-project.git d31a4730513391710d91c5ad33bb8ea3d68db3cb)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
+// CHECK-LABEL: func.func @_QQmain
+ func.func @_QQmain() attributes {fir.bindc_name = "TEST"} {
+ %0 = fir.alloca !fir.array<2xi64>
+ %1 = fir.alloca !fir.array<3xi64>
+ %2 = fir.dummy_scope : !fir.dscope
+ %3 = fir.address_of(@_QFEa) : !fir.ref<i32>
+ %c1_i64 = arith.constant 1 : i64
+ %c0 = arith.constant 0 : index
+ %4 = fir.coordinate_of %1, %c0 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64 to %4 : !fir.ref<i64>
+ %c3_i64 = arith.constant 3 : i64
+ %c1 = arith.constant 1 : index
+ %5 = fir.coordinate_of %1, %c1 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+ fir.store %c3_i64 to %5 : !fir.ref<i64>
+ %c1_i64_0 = arith.constant 1 : i64
+ %c2 = arith.constant 2 : index
+ %6 = fir.coordinate_of %1, %c2 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64_0 to %6 : !fir.ref<i64>
+ %7 = fir.embox %1 : (!fir.ref<!fir.array<3xi64>>) -> !fir.box<!fir.array<3xi64>>
+ %c1_i64_1 = arith.constant 1 : i64
+ %c0_2 = arith.constant 0 : index
+ %8 = fir.coordinate_of %0, %c0_2 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64_1 to %8 : !fir.ref<i64>
+ %c3_i64_3 = arith.constant 3 : i64
+ %c1_4 = arith.constant 1 : index
+ %9 = fir.coordinate_of %0, %c1_4 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+ fir.store %c3_i64_3 to %9 : !fir.ref<i64>
+ %10 = fir.embox %0 : (!fir.ref<!fir.array<2xi64>>) -> !fir.box<!fir.array<2xi64>>
+ mif.alloc_coarray %3 lcobounds %7 ucobounds %10 {uniq_name = "_QFEa"} : (!fir.ref<i32>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<2xi64>>) -> ()
+ %11:2 = hlfir.declare %3 {fir.corank = 3 : i32, uniq_name = "_QFEa"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+ %12 = fir.alloca i32 {bindc_name = "idx", uniq_name = "_QFEidx"}
+ %13:2 = hlfir.declare %12 {uniq_name = "_QFEidx"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+ %14 = fir.address_of(@_QFEsub) : !fir.ref<!fir.array<3xi32>>
+ %c3 = arith.constant 3 : index
+ %15 = fir.shape %c3 : (index) -> !fir.shape<1>
+ %16:2 = hlfir.declare %14(%15) {uniq_name = "_QFEsub"} : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<3xi32>>, !fir.ref<!fir.array<3xi32>>)
+ %17 = fir.address_of(@_QFEsub2) : !fir.ref<!fir.array<3xi64>>
+ %c3_5 = arith.constant 3 : index
+ %18 = fir.shape %c3_5 : (index) -> !fir.shape<1>
+ %19:2 = hlfir.declare %17(%18) {uniq_name = "_QFEsub2"} : (!fir.ref<!fir.array<3xi64>>, !fir.shape<1>) -> (!fir.ref<!fir.array<3xi64>>, !fir.ref<!fir.array<3xi64>>)
+ %20 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
+ %21:2 = hlfir.declare %20 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+ %22 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+ fir.copy %22 to %21#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+ %23 = fir.alloca i32 {bindc_name = "team_number", uniq_name = "_QFEteam_number"}
+ %24:2 = hlfir.declare %23 {uniq_name = "_QFEteam_number"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+ %25 = fir.shape %c3 : (index) -> !fir.shape<1>
+ %26 = fir.embox %16#0(%25) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
+// CHECK: fir.call @_QMprifPprif_image_index
+ %27 = mif.image_index coarray %11#0 sub %26 : (!fir.ref<i32>, !fir.box<!fir.array<3xi32>>) -> i32
+ hlfir.assign %27 to %13#0 : i32, !fir.ref<i32>
+ %28 = fir.shape %c3_5 : (index) -> !fir.shape<1>
+ %29 = fir.embox %19#0(%28) : (!fir.ref<!fir.array<3xi64>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi64>>
+// CHECK: fir.call @_QMprifPprif_image_index
+ %30 = mif.image_index coarray %11#0 sub %29 : (!fir.ref<i32>, !fir.box<!fir.array<3xi64>>) -> i32
+ hlfir.assign %30 to %13#0 : i32, !fir.ref<i32>
+ %31 = fir.shape %c3 : (index) -> !fir.shape<1>
+ %32 = fir.embox %16#0(%31) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
+// CHECK: fir.call @_QMprifPprif_image_index_with_team
+ %33 = mif.image_index coarray %11#0 sub %32 team %21#0 : (!fir.ref<i32>, !fir.box<!fir.array<3xi32>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> i32
+ hlfir.assign %33 to %13#0 : i32, !fir.ref<i32>
+ return
+ }
+}
diff --git a/flang/test/Fir/MIF/this_image.mlir b/flang/test/Fir/MIF/this_image.mlir
index 25eafc09ef58c..d68827c7cf9ba 100644
--- a/flang/test/Fir/MIF/this_image.mlir
+++ b/flang/test/Fir/MIF/this_image.mlir
@@ -2,15 +2,64 @@
module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 22.0.0 (git at github.com:SiPearl/llvm-project.git 666e4313ebc03587f27774139ad8f780bac15c3e)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
func.func @_QQmain() attributes {fir.bindc_name = "TEST"} {
- %0 = fir.dummy_scope : !fir.dscope
- %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
- %2:2 = hlfir.declare %1 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
- %3 = mif.this_image : () -> i32
- hlfir.assign %3 to %2#0 : i32, !fir.ref<i32>
+ %0 = fir.alloca !fir.array<1xi64>
+ %1 = fir.alloca !fir.array<2xi64>
+ %2 = fir.dummy_scope : !fir.dscope
+ %3 = fir.address_of(@_QFEa) : !fir.ref<i32>
+ %c1_i64 = arith.constant 1 : i64
+ %c0 = arith.constant 0 : index
+ %4 = fir.coordinate_of %1, %c0 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64 to %4 : !fir.ref<i64>
+ %c1_i64_0 = arith.constant 1 : i64
+ %c1 = arith.constant 1 : index
+ %5 = fir.coordinate_of %1, %c1 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64_0 to %5 : !fir.ref<i64>
+ %6 = fir.embox %1 : (!fir.ref<!fir.array<2xi64>>) -> !fir.box<!fir.array<2xi64>>
+ %c1_i64_1 = arith.constant 1 : i64
+ %c0_2 = arith.constant 0 : index
+ %7 = fir.coordinate_of %0, %c0_2 : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+ fir.store %c1_i64_1 to %7 : !fir.ref<i64>
+ %8 = fir.embox %0 : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
+ mif.alloc_coarray %3 lcobounds %6 ucobounds %8 {uniq_name = "_QFEa"} : (!fir.ref<i32>, !fir.box<!fir.array<2xi64>>, !fir.box<!fir.array<1xi64>>) -> ()
+ %9:2 = hlfir.declare %3 {fir.corank = 2 : i32, uniq_name = "_QFEa"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+ %10 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
+ %11:2 = hlfir.declare %10 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+ %c2 = arith.constant 2 : index
+ %12 = fir.alloca !fir.array<2xi32> {bindc_name = "j", uniq_name = "_QFEj"}
+ %13 = fir.shape %c2 : (index) -> !fir.shape<1>
+ %14:2 = hlfir.declare %12(%13) {uniq_name = "_QFEj"} : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<2xi32>>, !fir.ref<!fir.array<2xi32>>)
+ %15 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
+ %16:2 = hlfir.declare %15 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+ %17 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+ fir.copy %17 to %16#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+ %18 = mif.this_image : () -> i32
+ hlfir.assign %18 to %11#0 : i32, !fir.ref<i32>
+ %19 = mif.this_image team %16#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> i32
+ hlfir.assign %19 to %11#0 : i32, !fir.ref<i32>
+ %20 = mif.this_image coarray %9#0 : (!fir.ref<i32>) -> !fir.box<!fir.array<?xi64>>
+ %21:2 = hlfir.declare %20 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.array<?xi64>>) -> (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>)
+ %false = arith.constant false
+ %22 = hlfir.as_expr %21#0 move %false : (!fir.box<!fir.array<?xi64>>, i1) -> !hlfir.expr<?xi64>
+ %c0_3 = arith.constant 0 : index
+ %23:3 = fir.box_dims %21#0, %c0_3 : (!fir.box<!fir.array<?xi64>>, index) -> (index, index, index)
+ %24 = fir.shape %23#1 : (index) -> !fir.shape<1>
+ %25 = hlfir.elemental %24 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
+ ^bb0(%arg0: index):
+ %27 = hlfir.apply %22, %arg0 : (!hlfir.expr<?xi64>, index) -> i64
+ %28 = fir.convert %27 : (i64) -> i32
+ hlfir.yield_element %28 : i32
+ }
+ hlfir.assign %25 to %14#0 : !hlfir.expr<?xi32>, !fir.ref<!fir.array<2xi32>>
+ hlfir.destroy %25 : !hlfir.expr<?xi32>
+ hlfir.destroy %22 : !hlfir.expr<?xi64>
+ %c1_i32 = arith.constant 1 : i32
+ %26 = mif.this_image coarray %9#0 dim %c1_i32 : (!fir.ref<i32>, i32) -> i32
+ hlfir.assign %26 to %14#0 : i32, !fir.ref<!fir.array<2xi32>>
return
}
}
-
// CHECK-LABEL: func.func @_QQmain
-// CHECK: fir.call @_QMprifPprif_this_image_no_coarray(
+// CHECK: fir.call @_QMprifPprif_this_image_no_coarray
+// CHECK: fir.call @_QMprifPprif_this_image_with_coarray
+// CHECK: fir.call @_QMprifPprif_this_image_with_dim
diff --git a/flang/test/Lower/MIF/cobound.f90 b/flang/test/Lower/MIF/cobound.f90
new file mode 100644
index 0000000000000..e5ad3f94d4beb
--- /dev/null
+++ b/flang/test/Lower/MIF/cobound.f90
@@ -0,0 +1,21 @@
+! RUN: %flang_fc1 -emit-hlfir -fcoarray %s -o - | FileCheck %s
+
+program test
+ integer :: res1(3), res2
+ integer, allocatable :: a[:,:,:]
+
+ allocate(a[2,3:5,*])
+
+ ! CHECK: mif.lcobound coarray %[[COARRAY:.*]] : (!fir.heap<i32>) -> !fir.box<!fir.array<?xi64>>
+ res1 = lcobound(a)
+
+ ! CHECK: mif.lcobound coarray %[[COARRAY:.*]] dim %[[C2:.*]] : (!fir.heap<i32>, i32) -> i32
+ res2 = lcobound(a, DIM=2)
+
+ ! CHECK: mif.ucobound coarray %[[COARRAY:.*]] : (!fir.heap<i32>) -> !fir.box<!fir.array<?xi64>>
+ res1 = ucobound(a)
+
+ ! CHECK: mif.ucobound coarray %[[COARRAY:.*]] dim %[[C2:.*]] : (!fir.heap<i32>, i32) -> i32
+ res2 = ucobound(a, DIM=2)
+
+end program
diff --git a/flang/test/Lower/MIF/coshape.f90 b/flang/test/Lower/MIF/coshape.f90
new file mode 100644
index 0000000000000..da1360d26b3a6
--- /dev/null
+++ b/flang/test/Lower/MIF/coshape.f90
@@ -0,0 +1,14 @@
+! RUN: %flang_fc1 -emit-hlfir -fcoarray %s -o - | FileCheck %s
+
+program test
+ integer :: res(3)
+ integer(kind=8) :: res2(3)
+ integer :: a[2,3:5,*]
+
+ ! CHECK: mif.coshape coarray %[[COARRAY:.*]]#0 : (!fir.ref<i32>) -> !fir.box<!fir.array<?xi64>>
+ res = coshape(a)
+
+ ! CHECK: mif.coshape coarray %[[COARRAY:.*]]#0 : (!fir.ref<i32>) -> !fir.box<!fir.array<?xi64>>
+ res2 = coshape(a)
+
+end program
diff --git a/flang/test/Lower/MIF/image_index.f90 b/flang/test/Lower/MIF/image_index.f90
new file mode 100644
index 0000000000000..88eb711679e6d
--- /dev/null
+++ b/flang/test/Lower/MIF/image_index.f90
@@ -0,0 +1,20 @@
+! RUN: %flang_fc1 -emit-hlfir -fcoarray %s -o - | FileCheck %s
+
+program test
+ use iso_fortran_env, only: team_type
+ integer(kind=4) :: sub(3) = (/1, 4, 2/)
+ integer(kind=8) :: sub2(3) = (/1, 4, 2/)
+ integer(kind=4) :: a[2,3:5,*], idx
+ type(team_type) :: team
+ integer :: team_number
+
+ ! CHECK: mif.image_index coarray %[[COARRAY:.*]]#0 sub %[[SUB:.*]] : (!fir.ref<i32>, !fir.box<!fir.array<3xi32>>) -> i32
+ idx = image_index(a, SUB=sub)
+
+ ! CHECK: mif.image_index coarray %[[COARRAY:.*]]#0 sub %[[SUB2:.*]] : (!fir.ref<i32>, !fir.box<!fir.array<3xi64>>) -> i32
+ idx = image_index(a, SUB=sub2)
+
+ ! CHECK: mif.image_index coarray %[[COARRAY:.*]]#0 sub %[[SUB2:.*]] team %[[TEAM:.*]]#0 : (!fir.ref<i32>, !fir.box<!fir.array<3xi32>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+ idx = image_index(a, SUB=sub, TEAM=team)
+
+end program
diff --git a/flang/test/Lower/MIF/this_image.f90 b/flang/test/Lower/MIF/this_image.f90
index c6674c309f3f4..1d33646155d18 100644
--- a/flang/test/Lower/MIF/this_image.f90
+++ b/flang/test/Lower/MIF/this_image.f90
@@ -1,9 +1,10 @@
! RUN: %flang_fc1 -emit-hlfir -fcoarray %s -o - | FileCheck %s
program test
- use iso_fortran_env
- integer :: i
+ use iso_fortran_env, only: team_type
+ integer :: i, j(2)
type(team_type) :: team
+ integer :: a[2,*]
! CHECK: mif.this_image : () -> i32
i = this_image()
@@ -11,4 +12,9 @@ program test
! CHECK: mif.this_image team %[[TEAM:.*]] : ({{.*}}) -> i32
i = this_image(TEAM=team)
+ ! CHECK: mif.this_image coarray %[[A:.*]] : ({{.*}}) -> !fir.box<!fir.array<?xi64>>
+ j = this_image(COARRAY=a)
+
+ ! CHECK: mif.this_image coarray %[[A:.*]]#0 dim %[[DIM:.*]] : ({{.*}}) -> i32
+ j = this_image(COARRAY=a, DIM=1)
end program
>From 50b73eb49c2828becc9d7a078543119c2cac904f Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Mon, 20 Apr 2026 13:25:19 +0200
Subject: [PATCH 2/2] Fix formating issue
---
.../Optimizer/Transforms/MIFOpConversion.cpp | 21 ++++++++++---------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
index ba6a0a91d3d9b..db25941a269a0 100644
--- a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
+++ b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
@@ -1390,14 +1390,15 @@ void mif::populateMIFOpConversionPatterns(
mlir::RewritePatternSet &patterns) {
patterns.insert<MIFAllocCoarrayOpConversion>(patterns.getContext(), &dl,
&converter);
- patterns.insert<
- MIFInitOpConversion, MIFThisImageOpConversion, MIFNumImagesOpConversion,
- MIFSyncAllOpConversion, MIFSyncImagesOpConversion,
- MIFSyncMemoryOpConversion, MIFSyncTeamOpConversion,
- MIFCoBroadcastOpConversion, MIFCoMaxOpConversion, MIFCoMinOpConversion,
- MIFCoSumOpConversion, MIFFormTeamOpConversion, MIFChangeTeamOpConversion,
- MIFGetTeamOpConversion, MIFTeamNumberOpConversion,
- MIFDeallocCoarrayOpConversion, MIFCoshapeOpConversion,
- MIFLcoboundOpConversion, MIFUcoboundOpConversion,
- MIFImageIndexOpConversion>(patterns.getContext());
+ patterns.insert<MIFInitOpConversion, MIFThisImageOpConversion,
+ MIFNumImagesOpConversion, MIFSyncAllOpConversion,
+ MIFSyncImagesOpConversion, MIFSyncMemoryOpConversion,
+ MIFSyncTeamOpConversion, MIFCoBroadcastOpConversion,
+ MIFCoMaxOpConversion, MIFCoMinOpConversion,
+ MIFCoSumOpConversion, MIFFormTeamOpConversion,
+ MIFChangeTeamOpConversion, MIFGetTeamOpConversion,
+ MIFTeamNumberOpConversion, MIFDeallocCoarrayOpConversion,
+ MIFCoshapeOpConversion, MIFLcoboundOpConversion,
+ MIFUcoboundOpConversion, MIFImageIndexOpConversion>(
+ patterns.getContext());
}
More information about the flang-commits
mailing list