[flang-commits] [flang] 94a1106 - [flang] Lower min|max intrinsics
Valentin Clement via flang-commits
flang-commits at lists.llvm.org
Tue Mar 15 14:24:39 PDT 2022
Author: Valentin Clement
Date: 2022-03-15T22:24:10+01:00
New Revision: 94a11063573b4e1a3405d4a73d9928083115a6c1
URL: https://github.com/llvm/llvm-project/commit/94a11063573b4e1a3405d4a73d9928083115a6c1
DIFF: https://github.com/llvm/llvm-project/commit/94a11063573b4e1a3405d4a73d9928083115a6c1.diff
LOG: [flang] Lower min|max intrinsics
This patch adds lowering for the following intrinsics:
- `max`
- `maxloc`
- `maxval`
- `minloc`
- `minval`
This patch is part of the upstreaming effort from fir-dev branch.
Reviewed By: PeteSteinfeld
Differential Revision: https://reviews.llvm.org/D121701
Co-authored-by: Jean Perier <jperier at nvidia.com>
Co-authored-by: Eric Schweitz <eschweitz at nvidia.com>
Co-authored-by: mleair <leairmark at gmail.com>
Added:
flang/test/Lower/Intrinsics/max.f90
flang/test/Lower/Intrinsics/maxloc.f90
flang/test/Lower/Intrinsics/maxval.f90
flang/test/Lower/Intrinsics/minloc.f90
flang/test/Lower/Intrinsics/minval.f90
Modified:
flang/lib/Lower/Bridge.cpp
flang/lib/Lower/ConvertExpr.cpp
flang/lib/Lower/IntrinsicCall.cpp
flang/lib/Optimizer/Builder/MutableBox.cpp
Removed:
################################################################################
diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp
index e1f719742b2dc..65e45d5f310cb 100644
--- a/flang/lib/Lower/Bridge.cpp
+++ b/flang/lib/Lower/Bridge.cpp
@@ -249,12 +249,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
fir::ExtendedValue genExprBox(const Fortran::lower::SomeExpr &expr,
Fortran::lower::StatementContext &context,
mlir::Location loc) override final {
- if (expr.Rank() > 0 && Fortran::evaluate::IsVariable(expr) &&
- !Fortran::evaluate::HasVectorSubscript(expr))
- return Fortran::lower::createSomeArrayBox(*this, expr, localSymbols,
- context);
- return fir::BoxValue(
- builder->createBox(loc, genExprAddr(expr, context, &loc)));
+ return Fortran::lower::createBoxValue(loc, *this, expr, localSymbols,
+ context);
}
Fortran::evaluate::FoldingContext &getFoldingContext() override final {
diff --git a/flang/lib/Lower/ConvertExpr.cpp b/flang/lib/Lower/ConvertExpr.cpp
index 5a8ba4d1cd799..7ccb68677c6f2 100644
--- a/flang/lib/Lower/ConvertExpr.cpp
+++ b/flang/lib/Lower/ConvertExpr.cpp
@@ -2681,6 +2681,36 @@ class ScalarExprLowering {
llvm::StringRef name = intrinsic.name;
mlir::Location loc = getLoc();
+ if (Fortran::lower::intrinsicRequiresCustomOptionalHandling(
+ procRef, intrinsic, converter)) {
+ using ExvAndPresence = std::pair<ExtValue, llvm::Optional<mlir::Value>>;
+ llvm::SmallVector<ExvAndPresence, 4> operands;
+ auto prepareOptionalArg = [&](const Fortran::lower::SomeExpr &expr) {
+ ExtValue optionalArg = lowerIntrinsicArgumentAsInquired(expr);
+ mlir::Value isPresent =
+ genActualIsPresentTest(builder, loc, optionalArg);
+ operands.emplace_back(optionalArg, isPresent);
+ };
+ auto prepareOtherArg = [&](const Fortran::lower::SomeExpr &expr) {
+ operands.emplace_back(genval(expr), llvm::None);
+ };
+ Fortran::lower::prepareCustomIntrinsicArgument(
+ procRef, intrinsic, resultType, prepareOptionalArg, prepareOtherArg,
+ converter);
+
+ auto getArgument = [&](std::size_t i) -> ExtValue {
+ if (fir::conformsWithPassByRef(
+ fir::getBase(operands[i].first).getType()))
+ return genLoad(operands[i].first);
+ return operands[i].first;
+ };
+ auto isPresent = [&](std::size_t i) -> llvm::Optional<mlir::Value> {
+ return operands[i].second;
+ };
+ return Fortran::lower::lowerCustomIntrinsic(
+ builder, loc, name, resultType, isPresent, getArgument,
+ operands.size(), stmtCtx);
+ }
const Fortran::lower::IntrinsicArgumentLoweringRules *argLowering =
Fortran::lower::getIntrinsicArgumentLowering(name);
diff --git a/flang/lib/Lower/IntrinsicCall.cpp b/flang/lib/Lower/IntrinsicCall.cpp
index 531cab96675a1..adb4a324e8248 100644
--- a/flang/lib/Lower/IntrinsicCall.cpp
+++ b/flang/lib/Lower/IntrinsicCall.cpp
@@ -228,6 +228,168 @@ genDotProd(FN func, mlir::Type resultType, fir::FirOpBuilder &builder,
return func(builder, loc, vectorA, vectorB, resultBox);
}
+/// Process calls to Maxval, Minval, Product, Sum intrinsic functions
+template <typename FN, typename FD, typename FC>
+static fir::ExtendedValue
+genExtremumVal(FN func, FD funcDim, FC funcChar, mlir::Type resultType,
+ fir::FirOpBuilder &builder, mlir::Location loc,
+ Fortran::lower::StatementContext *stmtCtx,
+ llvm::StringRef errMsg,
+ llvm::ArrayRef<fir::ExtendedValue> args) {
+
+ assert(args.size() == 3);
+
+ // Handle required array argument
+ fir::BoxValue arryTmp = builder.createBox(loc, args[0]);
+ mlir::Value array = fir::getBase(arryTmp);
+ int rank = arryTmp.rank();
+ assert(rank >= 1);
+ bool hasCharacterResult = arryTmp.isCharacter();
+
+ // Handle optional mask argument
+ auto mask = isAbsent(args[2])
+ ? builder.create<fir::AbsentOp>(
+ loc, fir::BoxType::get(builder.getI1Type()))
+ : builder.createBox(loc, args[2]);
+
+ bool absentDim = isAbsent(args[1]);
+
+ // For Maxval/MinVal, we call the type specific versions of
+ // Maxval/Minval because the result is scalar in the case below.
+ if (!hasCharacterResult && (absentDim || rank == 1))
+ return func(builder, loc, array, mask);
+
+ if (hasCharacterResult && (absentDim || rank == 1)) {
+ // Create mutable fir.box to be passed to the runtime for the result.
+ fir::MutableBoxValue resultMutableBox =
+ fir::factory::createTempMutableBox(builder, loc, resultType);
+ mlir::Value resultIrBox =
+ fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
+
+ funcChar(builder, loc, resultIrBox, array, mask);
+
+ // Handle cleanup of allocatable result descriptor and return
+ fir::ExtendedValue res =
+ fir::factory::genMutableBoxRead(builder, loc, resultMutableBox);
+ return res.match(
+ [&](const fir::CharBoxValue &box) -> fir::ExtendedValue {
+ // Add cleanup code
+ assert(stmtCtx);
+ fir::FirOpBuilder *bldr = &builder;
+ mlir::Value temp = box.getAddr();
+ stmtCtx->attachCleanup(
+ [=]() { bldr->create<fir::FreeMemOp>(loc, temp); });
+ return box;
+ },
+ [&](const auto &) -> fir::ExtendedValue {
+ fir::emitFatalError(loc, errMsg);
+ });
+ }
+
+ // Handle Min/Maxval cases that have an array result.
+ return genFuncDim(funcDim, resultType, builder, loc, stmtCtx, errMsg, array,
+ args[1], mask, rank);
+}
+
+/// Process calls to Minloc, Maxloc intrinsic functions
+template <typename FN, typename FD>
+static fir::ExtendedValue genExtremumloc(
+ FN func, FD funcDim, mlir::Type resultType, fir::FirOpBuilder &builder,
+ mlir::Location loc, Fortran::lower::StatementContext *stmtCtx,
+ llvm::StringRef errMsg, llvm::ArrayRef<fir::ExtendedValue> args) {
+
+ assert(args.size() == 5);
+
+ // Handle required array argument
+ mlir::Value array = builder.createBox(loc, args[0]);
+ unsigned rank = fir::BoxValue(array).rank();
+ assert(rank >= 1);
+
+ // Handle optional mask argument
+ auto mask = isAbsent(args[2])
+ ? builder.create<fir::AbsentOp>(
+ loc, fir::BoxType::get(builder.getI1Type()))
+ : builder.createBox(loc, args[2]);
+
+ // Handle optional kind argument
+ auto kind = isAbsent(args[3]) ? builder.createIntegerConstant(
+ loc, builder.getIndexType(),
+ builder.getKindMap().defaultIntegerKind())
+ : fir::getBase(args[3]);
+
+ // Handle optional back argument
+ auto back = isAbsent(args[4]) ? builder.createBool(loc, false)
+ : fir::getBase(args[4]);
+
+ bool absentDim = isAbsent(args[1]);
+
+ if (!absentDim && rank == 1) {
+ // If dim argument is present and the array is rank 1, then the result is
+ // a scalar (since the the result is rank-1 or 0).
+ // Therefore, we use a scalar result descriptor with Min/MaxlocDim().
+ mlir::Value dim = fir::getBase(args[1]);
+ // Create mutable fir.box to be passed to the runtime for the result.
+ fir::MutableBoxValue resultMutableBox =
+ fir::factory::createTempMutableBox(builder, loc, resultType);
+ mlir::Value resultIrBox =
+ fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
+
+ funcDim(builder, loc, resultIrBox, array, dim, mask, kind, back);
+
+ // Handle cleanup of allocatable result descriptor and return
+ fir::ExtendedValue res =
+ fir::factory::genMutableBoxRead(builder, loc, resultMutableBox);
+ return res.match(
+ [&](const mlir::Value &tempAddr) -> fir::ExtendedValue {
+ // Add cleanup code
+ assert(stmtCtx);
+ fir::FirOpBuilder *bldr = &builder;
+ stmtCtx->attachCleanup(
+ [=]() { bldr->create<fir::FreeMemOp>(loc, tempAddr); });
+ return builder.create<fir::LoadOp>(loc, resultType, tempAddr);
+ },
+ [&](const auto &) -> fir::ExtendedValue {
+ fir::emitFatalError(loc, errMsg);
+ });
+ }
+
+ // Note: The Min/Maxloc/val cases below have an array result.
+
+ // Create mutable fir.box to be passed to the runtime for the result.
+ mlir::Type resultArrayType =
+ builder.getVarLenSeqTy(resultType, absentDim ? 1 : rank - 1);
+ fir::MutableBoxValue resultMutableBox =
+ fir::factory::createTempMutableBox(builder, loc, resultArrayType);
+ mlir::Value resultIrBox =
+ fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
+
+ if (absentDim) {
+ // Handle min/maxloc/val case where there is no dim argument
+ // (calls Min/Maxloc()/MinMaxval() runtime routine)
+ func(builder, loc, resultIrBox, array, mask, kind, back);
+ } else {
+ // else handle min/maxloc case with dim argument (calls
+ // Min/Max/loc/val/Dim() runtime routine).
+ mlir::Value dim = fir::getBase(args[1]);
+ funcDim(builder, loc, resultIrBox, array, dim, mask, kind, back);
+ }
+
+ return fir::factory::genMutableBoxRead(builder, loc, resultMutableBox)
+ .match(
+ [&](const fir::ArrayBoxValue &box) -> fir::ExtendedValue {
+ // Add cleanup code
+ assert(stmtCtx);
+ fir::FirOpBuilder *bldr = &builder;
+ mlir::Value temp = box.getAddr();
+ stmtCtx->attachCleanup(
+ [=]() { bldr->create<fir::FreeMemOp>(loc, temp); });
+ return box;
+ },
+ [&](const auto &) -> fir::ExtendedValue {
+ fir::emitFatalError(loc, errMsg);
+ });
+}
+
// TODO error handling -> return a code or directly emit messages ?
struct IntrinsicLibrary {
@@ -289,6 +451,10 @@ struct IntrinsicLibrary {
fir::ExtendedValue genNull(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genLen(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genLenTrim(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+ fir::ExtendedValue genMaxloc(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+ fir::ExtendedValue genMaxval(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+ fir::ExtendedValue genMinloc(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+ fir::ExtendedValue genMinval(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genSize(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genSum(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genUbound(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
@@ -419,6 +585,36 @@ static constexpr IntrinsicHandler handlers[]{
{"llt", &I::genCharacterCompare<mlir::arith::CmpIPredicate::slt>},
{"min", &I::genExtremum<Extremum::Min, ExtremumBehavior::MinMaxss>},
{"null", &I::genNull, {{{"mold", asInquired}}}, /*isElemental=*/false},
+ {"max", &I::genExtremum<Extremum::Max, ExtremumBehavior::MinMaxss>},
+ {"maxloc",
+ &I::genMaxloc,
+ {{{"array", asBox},
+ {"dim", asValue},
+ {"mask", asBox, handleDynamicOptional},
+ {"kind", asValue},
+ {"back", asValue, handleDynamicOptional}}},
+ /*isElemental=*/false},
+ {"maxval",
+ &I::genMaxval,
+ {{{"array", asBox},
+ {"dim", asValue},
+ {"mask", asBox, handleDynamicOptional}}},
+ /*isElemental=*/false},
+ {"min", &I::genExtremum<Extremum::Min, ExtremumBehavior::MinMaxss>},
+ {"minloc",
+ &I::genMinloc,
+ {{{"array", asBox},
+ {"dim", asValue},
+ {"mask", asBox, handleDynamicOptional},
+ {"kind", asValue},
+ {"back", asValue, handleDynamicOptional}}},
+ /*isElemental=*/false},
+ {"minval",
+ &I::genMinval,
+ {{{"array", asBox},
+ {"dim", asValue},
+ {"mask", asBox, handleDynamicOptional}}},
+ /*isElemental=*/false},
{"sum",
&I::genSum,
{{{"array", asBox},
@@ -1474,6 +1670,42 @@ static mlir::Value createExtremumCompare(mlir::Location loc,
return result;
}
+// MAXLOC
+fir::ExtendedValue
+IntrinsicLibrary::genMaxloc(mlir::Type resultType,
+ llvm::ArrayRef<fir::ExtendedValue> args) {
+ return genExtremumloc(fir::runtime::genMaxloc, fir::runtime::genMaxlocDim,
+ resultType, builder, loc, stmtCtx,
+ "unexpected result for Maxloc", args);
+}
+
+// MAXVAL
+fir::ExtendedValue
+IntrinsicLibrary::genMaxval(mlir::Type resultType,
+ llvm::ArrayRef<fir::ExtendedValue> args) {
+ return genExtremumVal(fir::runtime::genMaxval, fir::runtime::genMaxvalDim,
+ fir::runtime::genMaxvalChar, resultType, builder, loc,
+ stmtCtx, "unexpected result for Maxval", args);
+}
+
+// MINLOC
+fir::ExtendedValue
+IntrinsicLibrary::genMinloc(mlir::Type resultType,
+ llvm::ArrayRef<fir::ExtendedValue> args) {
+ return genExtremumloc(fir::runtime::genMinloc, fir::runtime::genMinlocDim,
+ resultType, builder, loc, stmtCtx,
+ "unexpected result for Minloc", args);
+}
+
+// MINVAL
+fir::ExtendedValue
+IntrinsicLibrary::genMinval(mlir::Type resultType,
+ llvm::ArrayRef<fir::ExtendedValue> args) {
+ return genExtremumVal(fir::runtime::genMinval, fir::runtime::genMinvalDim,
+ fir::runtime::genMinvalChar, resultType, builder, loc,
+ stmtCtx, "unexpected result for Minval", args);
+}
+
// MIN and MAX
template <Extremum extremum, ExtremumBehavior behavior>
mlir::Value IntrinsicLibrary::genExtremum(mlir::Type,
diff --git a/flang/lib/Optimizer/Builder/MutableBox.cpp b/flang/lib/Optimizer/Builder/MutableBox.cpp
index 66bdb99cf9cc6..0d9fe18089ef9 100644
--- a/flang/lib/Optimizer/Builder/MutableBox.cpp
+++ b/flang/lib/Optimizer/Builder/MutableBox.cpp
@@ -364,16 +364,16 @@ mlir::Value
fir::factory::createUnallocatedBox(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Type boxType,
mlir::ValueRange nonDeferredParams) {
- auto heapType = boxType.dyn_cast<fir::BoxType>().getEleTy();
- auto type = fir::dyn_cast_ptrEleTy(heapType);
- auto eleTy = type;
- if (auto seqType = eleTy.dyn_cast<fir::SequenceType>())
- eleTy = seqType.getEleTy();
+ auto baseAddrType = boxType.dyn_cast<fir::BoxType>().getEleTy();
+ if (!fir::isa_ref_type(baseAddrType))
+ baseAddrType = builder.getRefType(baseAddrType);
+ auto type = fir::unwrapRefType(baseAddrType);
+ auto eleTy = fir::unwrapSequenceType(type);
if (auto recTy = eleTy.dyn_cast<fir::RecordType>())
if (recTy.getNumLenParams() > 0)
TODO(loc, "creating unallocated fir.box of derived type with length "
"parameters");
- auto nullAddr = builder.createNullConstant(loc, heapType);
+ auto nullAddr = builder.createNullConstant(loc, baseAddrType);
mlir::Value shape;
if (auto seqTy = type.dyn_cast<fir::SequenceType>()) {
auto zero = builder.createIntegerConstant(loc, builder.getIndexType(), 0);
diff --git a/flang/test/Lower/Intrinsics/max.f90 b/flang/test/Lower/Intrinsics/max.f90
new file mode 100644
index 0000000000000..3cfea3d3e70a2
--- /dev/null
+++ b/flang/test/Lower/Intrinsics/max.f90
@@ -0,0 +1,139 @@
+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+module max_test
+ contains
+ ! CHECK-LABEL: func @_QMmax_testPdynamic_optional(
+ ! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"},
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"},
+ ! CHECK-SAME: %[[VAL_2:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c", fir.optional}) {
+ subroutine dynamic_optional(a, b, c)
+ integer :: a(:), b(:)
+ integer, optional :: c(:)
+ ! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
+ ! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_1]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
+ ! CHECK: %[[VAL_12:.*]] = fir.is_present %[[VAL_2]] : (!fir.box<!fir.array<?xi32>>) -> i1
+ ! CHECK: %[[VAL_17:.*]] = arith.select %[[VAL_12]], %[[VAL_2]], %{{.*}} : !fir.box<!fir.array<?xi32>>
+ ! CHECK: %[[VAL_18:.*]] = fir.array_load %[[VAL_17]] {fir.optional} : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
+ ! CHECK: fir.do_loop %[[VAL_26:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_27:.*]] = %{{.*}}) -> (!fir.array<?xi32>) {
+ ! CHECK: %[[VAL_28:.*]] = fir.array_fetch %[[VAL_10]], %[[VAL_26]] : (!fir.array<?xi32>, index) -> i32
+ ! CHECK: %[[VAL_29:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_26]] : (!fir.array<?xi32>, index) -> i32
+ ! CHECK: %[[VAL_30:.*]] = arith.cmpi sgt, %[[VAL_28]], %[[VAL_29]] : i32
+ ! CHECK: %[[VAL_31:.*]] = arith.select %[[VAL_30]], %[[VAL_28]], %[[VAL_29]] : i32
+ ! CHECK: %[[VAL_32:.*]] = fir.if %[[VAL_12]] -> (i32) {
+ ! CHECK: %[[VAL_33:.*]] = fir.array_fetch %[[VAL_18]], %[[VAL_26]] : (!fir.array<?xi32>, index) -> i32
+ ! CHECK: %[[VAL_34:.*]] = arith.cmpi sgt, %[[VAL_31]], %[[VAL_33]] : i32
+ ! CHECK: %[[VAL_35:.*]] = arith.select %[[VAL_34]], %[[VAL_31]], %[[VAL_33]] : i32
+ ! CHECK: fir.result %[[VAL_35]] : i32
+ ! CHECK: } else {
+ ! CHECK: fir.result %[[VAL_31]] : i32
+ ! CHECK: }
+ ! CHECK: %[[VAL_36:.*]] = fir.array_update %[[VAL_27]], %[[VAL_32]], %[[VAL_26]] : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
+ ! CHECK: fir.result %[[VAL_36]] : !fir.array<?xi32>
+ ! CHECK: }
+ print *, max(a, b, c)
+ end subroutine
+
+ ! CHECK-LABEL: func @_QMmax_testPdynamic_optional_array_expr_scalar_optional(
+ ! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"},
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"},
+ ! CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<i32> {fir.bindc_name = "c", fir.optional}) {
+ subroutine dynamic_optional_array_expr_scalar_optional(a, b, c)
+ integer :: a(:), b(:)
+ integer, optional :: c
+ print *, max(a, b, c)
+ ! CHECK: %[[VAL_10:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
+ ! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_1]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
+ ! CHECK: %[[VAL_12:.*]] = fir.is_present %[[VAL_2]] : (!fir.ref<i32>) -> i1
+ ! CHECK: fir.do_loop %[[VAL_20:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%[[VAL_21:.*]] = %{{.*}}) -> (!fir.array<?xi32>) {
+ ! CHECK: %[[VAL_22:.*]] = fir.array_fetch %[[VAL_10]], %[[VAL_20]] : (!fir.array<?xi32>, index) -> i32
+ ! CHECK: %[[VAL_23:.*]] = fir.array_fetch %[[VAL_11]], %[[VAL_20]] : (!fir.array<?xi32>, index) -> i32
+ ! CHECK: %[[VAL_24:.*]] = arith.cmpi sgt, %[[VAL_22]], %[[VAL_23]] : i32
+ ! CHECK: %[[VAL_25:.*]] = arith.select %[[VAL_24]], %[[VAL_22]], %[[VAL_23]] : i32
+ ! CHECK: %[[VAL_26:.*]] = fir.if %[[VAL_12]] -> (i32) {
+ ! CHECK: %[[VAL_27:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
+ ! CHECK: %[[VAL_28:.*]] = arith.cmpi sgt, %[[VAL_25]], %[[VAL_27]] : i32
+ ! CHECK: %[[VAL_29:.*]] = arith.select %[[VAL_28]], %[[VAL_25]], %[[VAL_27]] : i32
+ ! CHECK: fir.result %[[VAL_29]] : i32
+ ! CHECK: } else {
+ ! CHECK: fir.result %[[VAL_25]] : i32
+ ! CHECK: }
+ ! CHECK: %[[VAL_30:.*]] = fir.array_update %[[VAL_21]], %[[VAL_26]], %[[VAL_20]] : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
+ ! CHECK: fir.result %[[VAL_30]] : !fir.array<?xi32>
+ ! CHECK: }
+ end subroutine
+
+ ! CHECK-LABEL: func @_QMmax_testPdynamic_optional_scalar(
+ ! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32> {fir.bindc_name = "a"},
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "b"},
+ ! CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<i32> {fir.bindc_name = "c", fir.optional}) {
+ subroutine dynamic_optional_scalar(a, b, c)
+ integer :: a, b
+ integer, optional :: c
+ print *, max(a, b, c)
+ ! CHECK: %[[VAL_8:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
+ ! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
+ ! CHECK: %[[VAL_10:.*]] = fir.is_present %[[VAL_2]] : (!fir.ref<i32>) -> i1
+ ! CHECK: %[[VAL_11:.*]] = arith.cmpi sgt, %[[VAL_8]], %[[VAL_9]] : i32
+ ! CHECK: %[[VAL_12:.*]] = arith.select %[[VAL_11]], %[[VAL_8]], %[[VAL_9]] : i32
+ ! CHECK: %[[VAL_13:.*]] = fir.if %[[VAL_10]] -> (i32) {
+ ! CHECK: %[[VAL_14:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
+ ! CHECK: %[[VAL_15:.*]] = arith.cmpi sgt, %[[VAL_12]], %[[VAL_14]] : i32
+ ! CHECK: %[[VAL_16:.*]] = arith.select %[[VAL_15]], %[[VAL_12]], %[[VAL_14]] : i32
+ ! CHECK: fir.result %[[VAL_16]] : i32
+ ! CHECK: } else {
+ ! CHECK: fir.result %[[VAL_12]] : i32
+ ! CHECK: }
+ ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[VAL_13]]) : (!fir.ref<i8>, i32) -> i1
+ end subroutine
+
+ ! CHECK-LABEL: func @_QMmax_testPdynamic_optional_weird(
+ ! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i32> {fir.bindc_name = "a"},
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "b"},
+ ! CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<i32> {fir.bindc_name = "c", fir.optional},
+ ! CHECK-SAME: %[[VAL_3:.*]]: !fir.ref<i32> {fir.bindc_name = "d"},
+ ! CHECK-SAME: %[[VAL_4:.*]]: !fir.ref<i32> {fir.bindc_name = "e", fir.optional}) {
+ subroutine dynamic_optional_weird(a, b, c, d, e)
+ integer :: a, b, d
+ integer, optional :: c, e
+ ! a3, a4, a6, a8 statically missing. a5, a9 dynamically optional.
+ print *, max(a1=a, a2=b, a5=c, a7=d, a9 = e)
+ ! CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
+ ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
+ ! CHECK: %[[VAL_12:.*]] = fir.is_present %[[VAL_2]] : (!fir.ref<i32>) -> i1
+ ! CHECK: %[[VAL_13:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
+ ! CHECK: %[[VAL_14:.*]] = fir.is_present %[[VAL_4]] : (!fir.ref<i32>) -> i1
+ ! CHECK: %[[VAL_15:.*]] = arith.cmpi sgt, %[[VAL_10]], %[[VAL_11]] : i32
+ ! CHECK: %[[VAL_16:.*]] = arith.select %[[VAL_15]], %[[VAL_10]], %[[VAL_11]] : i32
+ ! CHECK: %[[VAL_17:.*]] = fir.if %[[VAL_12]] -> (i32) {
+ ! CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
+ ! CHECK: %[[VAL_19:.*]] = arith.cmpi sgt, %[[VAL_16]], %[[VAL_18]] : i32
+ ! CHECK: %[[VAL_20:.*]] = arith.select %[[VAL_19]], %[[VAL_16]], %[[VAL_18]] : i32
+ ! CHECK: fir.result %[[VAL_20]] : i32
+ ! CHECK: } else {
+ ! CHECK: fir.result %[[VAL_16]] : i32
+ ! CHECK: }
+ ! CHECK: %[[VAL_21:.*]] = arith.cmpi sgt, %[[VAL_17]], %[[VAL_13]] : i32
+ ! CHECK: %[[VAL_23:.*]] = arith.select %[[VAL_21]], %[[VAL_17]], %[[VAL_13]] : i32
+ ! CHECK: %[[VAL_24:.*]] = fir.if %[[VAL_14]] -> (i32) {
+ ! CHECK: %[[VAL_25:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
+ ! CHECK: %[[VAL_26:.*]] = arith.cmpi sgt, %[[VAL_23]], %[[VAL_25]] : i32
+ ! CHECK: %[[VAL_27:.*]] = arith.select %[[VAL_26]], %[[VAL_23]], %[[VAL_25]] : i32
+ ! CHECK: fir.result %[[VAL_27]] : i32
+ ! CHECK: } else {
+ ! CHECK: fir.result %[[VAL_23]] : i32
+ ! CHECK: }
+ ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[VAL_24]]) : (!fir.ref<i8>, i32) -> i1
+ end subroutine
+ end module
+
+ use :: max_test
+ integer :: a(4) = [1,12,23, 34]
+ integer :: b(4) = [31,22,13, 4]
+ integer :: c(4) = [21,32,3, 14]
+ call dynamic_optional(a, b)
+ call dynamic_optional(a, b, c)
+ call dynamic_optional_array_expr_scalar_optional(a, b)
+ call dynamic_optional_array_expr_scalar_optional(a, b, c(2))
+ call dynamic_optional_scalar(a(2), b(2))
+ call dynamic_optional_scalar(a(2), b(2), c(2))
+ end
diff --git a/flang/test/Lower/Intrinsics/maxloc.f90 b/flang/test/Lower/Intrinsics/maxloc.f90
new file mode 100644
index 0000000000000..9fe28f2d86b34
--- /dev/null
+++ b/flang/test/Lower/Intrinsics/maxloc.f90
@@ -0,0 +1,89 @@
+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+! CHECK-LABEL: func @_QPmaxloc_test(
+! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) {
+subroutine maxloc_test(arr,res)
+ integer :: arr(:)
+ integer :: res(:)
+ ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
+ ! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+ ! CHECK-DAG: %[[a1:.*]] = fir.absent !fir.box<i1>
+ ! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK-DAG: %[[a7:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
+ ! CHECK-DAG: %[[a8:.*]] = fir.convert %[[c4]] : (index) -> i32
+ ! CHECK-DAG: %[[a10:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+ res = maxloc(arr)
+ ! CHECK: %{{.*}} = fir.call @_FortranAMaxloc(%[[a6]], %[[a7]], %[[a8]], %{{.*}}, %{{.*}}, %[[a10]], %false) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> none
+ ! CHECK-DAG: %[[a12:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+ ! CHECK-DAG: %[[a14:.*]] = fir.box_addr %[[a12]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+ ! CHECK-DAG: fir.freemem %[[a14]]
+ end subroutine
+
+ ! CHECK-LABEL: func @_QPmaxloc_test2(
+ ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg2:.*]]: !fir.ref<i32>{{.*}}) {
+ subroutine maxloc_test2(arr,res,d)
+ integer :: arr(:)
+ integer :: res(:)
+ integer :: d
+ ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
+ ! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<i32>>
+ ! CHECK-DAG: %[[a1:.*]] = fir.load %arg2 : !fir.ref<i32>
+ ! CHECK-DAG: %[[a2:.*]] = fir.absent !fir.box<i1>
+ ! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK-DAG: %[[a7:.*]] = fir.convert %arg0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
+ ! CHECK-DAG: %[[a8:.*]] = fir.convert %[[c4]] : (index) -> i32
+ ! CHECK-DAG: %[[a10:.*]] = fir.convert %[[a2]] : (!fir.box<i1>) -> !fir.box<none>
+ res = maxloc(arr, dim=d)
+ ! CHECK: %{{.*}} = fir.call @_FortranAMaxlocDim(%[[a6]], %[[a7]], %[[a8]], %[[a1]], %{{.*}}, %{{.*}}, %[[a10]], %false) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> none
+ ! CHECK: %[[a12:.*]] = fir.load %0 : !fir.ref<!fir.box<!fir.heap<i32>>>
+ ! CHECK: %[[a13:.*]] = fir.box_addr %[[a12]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
+ ! CHECK: fir.freemem %[[a13]]
+ end subroutine
+
+ ! CHECK-LABEL: func @_QPtest_maxloc_optional_scalar_mask(
+ ! CHECK-SAME: %[[VAL_0:[^:]+]]: !fir.ref<!fir.logical<4>>
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+ subroutine test_maxloc_optional_scalar_mask(mask, back, array)
+ integer :: array(:)
+ logical, optional :: mask
+ logical, optional :: back
+ print *, maxloc(array, mask=mask, back=back)
+ ! CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[VAL_10:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
+ ! CHECK: %[[VAL_11:.*]] = fir.absent !fir.box<!fir.logical<4>>
+ ! CHECK: %[[VAL_12:.*]] = arith.select %[[VAL_9]], %[[VAL_10]], %[[VAL_11]] : !fir.box<!fir.logical<4>>
+ ! CHECK: %[[VAL_13:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[VAL_14:.*]] = fir.if %[[VAL_13]] -> (!fir.logical<4>) {
+ ! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
+ ! CHECK: fir.result %[[VAL_15]] : !fir.logical<4>
+ ! CHECK: } else {
+ ! CHECK: %[[VAL_16:.*]] = arith.constant false
+ ! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i1) -> !fir.logical<4>
+ ! CHECK: fir.result %[[VAL_17]] : !fir.logical<4>
+ ! CHECK: }
+ ! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_12]] : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
+ ! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_14]] : (!fir.logical<4>) -> i1
+ ! CHECK: fir.call @_FortranAMaxloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_29]], %[[VAL_30]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> none
+ end subroutine
+
+ ! CHECK-LABEL: func @_QPtest_maxloc_optional_array_mask(
+ ! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+ subroutine test_maxloc_optional_array_mask(mask, back, array)
+ integer :: array(:)
+ logical, optional :: mask(:)
+ logical, optional :: back
+ print *, maxloc(array, mask=mask, back=back)
+ ! CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.logical<4>) {
+ ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
+ ! CHECK: fir.result %[[VAL_11]] : !fir.logical<4>
+ ! CHECK: } else {
+ ! CHECK: %[[VAL_12:.*]] = arith.constant false
+ ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i1) -> !fir.logical<4>
+ ! CHECK: fir.result %[[VAL_13]] : !fir.logical<4>
+ ! CHECK: }
+ ! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>
+ ! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_10]] : (!fir.logical<4>) -> i1
+ ! CHECK: fir.call @_FortranAMaxloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_25]], %[[VAL_26]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> none
+ end subroutine
diff --git a/flang/test/Lower/Intrinsics/maxval.f90 b/flang/test/Lower/Intrinsics/maxval.f90
new file mode 100644
index 0000000000000..55ac7aa8ee930
--- /dev/null
+++ b/flang/test/Lower/Intrinsics/maxval.f90
@@ -0,0 +1,69 @@
+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+! CHECK-LABEL: func @_QPmaxval_test(
+! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) -> i32
+integer function maxval_test(a)
+integer :: a(:)
+! CHECK-DAG: %[[c0:.*]] = arith.constant 0 : index
+! CHECK-DAG: %[[a2:.*]] = fir.absent !fir.box<i1>
+! CHECK-DAG: %[[a4:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
+! CHECK: %[[a6:.*]] = fir.convert %[[c0]] : (index) -> i32
+! CHECK: %[[a7:.*]] = fir.convert %[[a2]] : (!fir.box<i1>) -> !fir.box<none>
+maxval_test = maxval(a)
+! CHECK: %{{.*}} = fir.call @_FortranAMaxvalInteger4(%[[a4]], %{{.*}}, %{{.*}}, %[[a6]], %[[a7]]) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+end function
+
+! CHECK-LABEL: func @_QPmaxval_test2(
+! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.char<1>>, %[[arg1:.*]]: index, %[[arg2:.*]]: !fir.box<!fir.array<?x!fir.char<1>>> {fir.bindc_name = "a"}) -> !fir.boxchar<1> {
+character function maxval_test2(a)
+character :: a(:)
+! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.char<1,?>>>
+! CHECK: %[[a1:.*]] = fir.absent !fir.box<i1>
+! CHECK-DAG: %[[a5:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>) -> !fir.ref<!fir.box<none>>
+! CHECK: %[[a6:.*]] = fir.convert %[[arg2]] : (!fir.box<!fir.array<?x!fir.char<1>>>) -> !fir.box<none>
+! CHECK-DAG: %[[a8:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+maxval_test2 = maxval(a)
+! CHECK: %{{.*}} = fir.call @_FortranAMaxvalCharacter(%[[a5]], %[[a6]], %{{.*}}, %{{.*}}, %[[a8]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32, !fir.box<none>) -> none
+end function
+
+! CHECK-LABEL: func @_QPmaxval_test3(
+! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>
+subroutine maxval_test3(a,r)
+integer :: a(:,:)
+integer :: r(:)
+! CHECK-DAG: %[[c2_i32:.*]] = arith.constant 2 : i32
+! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+! CHECK: %[[a1:.*]] = fir.absent !fir.box<i1>
+! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+! CHECK: %[[a7:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+! CHECK-DAG: %[[a9:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+r = maxval(a,dim=2)
+! CHECK: %{{.*}} = fir.call @_FortranAMaxvalDim(%[[a6]], %[[a7]], %[[c2_i32]], %{{.*}}, %{{.*}}, %[[a9]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>) -> none
+! CHECK: %[[a11:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+! CHECK-DAG: %[[a13:.*]] = fir.box_addr %[[a11]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+! CHECK-DAG: fir.freemem %[[a13]]
+end subroutine
+
+! CHECK-LABEL: func @_QPtest_maxval_optional_scalar_mask(
+! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+subroutine test_maxval_optional_scalar_mask(mask, array)
+integer :: array(:)
+logical, optional :: mask
+print *, maxval(array, mask)
+! CHECK: %[[VAL_7:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
+! CHECK: %[[VAL_8:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
+! CHECK: %[[VAL_9:.*]] = fir.absent !fir.box<!fir.logical<4>>
+! CHECK: %[[VAL_10:.*]] = arith.select %[[VAL_7]], %[[VAL_8]], %[[VAL_9]] : !fir.box<!fir.logical<4>>
+! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_10]] : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
+! CHECK: fir.call @_FortranAMaxvalInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_17]]) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+end subroutine
+
+! CHECK-LABEL: func @_QPtest_maxval_optional_array_mask(
+! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>
+subroutine test_maxval_optional_array_mask(mask, array)
+integer :: array(:)
+logical, optional :: mask(:)
+print *, maxval(array, mask)
+! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>
+! CHECK: fir.call @_FortranAMaxvalInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_13]]) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+end subroutine
diff --git a/flang/test/Lower/Intrinsics/minloc.f90 b/flang/test/Lower/Intrinsics/minloc.f90
new file mode 100644
index 0000000000000..b16edcea4762c
--- /dev/null
+++ b/flang/test/Lower/Intrinsics/minloc.f90
@@ -0,0 +1,89 @@
+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+! CHECK-LABEL: func @_QPminloc_test(
+! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>
+subroutine minloc_test(arr,res)
+ integer :: arr(:)
+ integer :: res(:)
+ ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
+ ! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+ ! CHECK-DAG: %[[a1:.*]] = fir.absent !fir.box<i1>
+ ! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK-DAG: %[[a7:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
+ ! CHECK-DAG: %[[a8:.*]] = fir.convert %[[c4]] : (index) -> i32
+ ! CHECK-DAG: %[[a10:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+ res = minloc(arr)
+ ! CHECK: %{{.*}} = fir.call @_FortranAMinloc(%[[a6]], %[[a7]], %[[a8]], %{{.*}}, %{{.*}}, %[[a10]], %false) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> none
+ ! CHECK-DAG: %[[a12:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+ ! CHECK-DAG: %[[a14:.*]] = fir.box_addr %[[a12]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+ ! CHECK-DAG: fir.freemem %[[a14]]
+ end subroutine
+
+ ! CHECK-LABEL: func @_QPminloc_test2(
+ ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}, %[[arg2:.*]]: !fir.ref<i32>
+ subroutine minloc_test2(arr,res,d)
+ integer :: arr(:)
+ integer :: res(:)
+ integer :: d
+ ! CHECK-DAG: %[[c4:.*]] = arith.constant 4 : index
+ ! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<i32>>
+ ! CHECK-DAG: %[[a1:.*]] = fir.load %arg2 : !fir.ref<i32>
+ ! CHECK-DAG: %[[a2:.*]] = fir.absent !fir.box<i1>
+ ! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK-DAG: %[[a7:.*]] = fir.convert %arg0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
+ ! CHECK-DAG: %[[a8:.*]] = fir.convert %[[c4]] : (index) -> i32
+ ! CHECK-DAG: %[[a10:.*]] = fir.convert %[[a2]] : (!fir.box<i1>) -> !fir.box<none>
+ res = minloc(arr, dim=d)
+ ! CHECK: %{{.*}} = fir.call @_FortranAMinlocDim(%[[a6]], %[[a7]], %[[a8]], %[[a1]], %{{.*}}, %{{.*}}, %[[a10]], %false) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> none
+ ! CHECK: %[[a12:.*]] = fir.load %0 : !fir.ref<!fir.box<!fir.heap<i32>>>
+ ! CHECK: %[[a13:.*]] = fir.box_addr %[[a12]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
+ ! CHECK: fir.freemem %[[a13]]
+ end subroutine
+
+ ! CHECK-LABEL: func @_QPtest_minloc_optional_scalar_mask(
+ ! CHECK-SAME: %[[VAL_0:[^:]+]]: !fir.ref<!fir.logical<4>>
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+ subroutine test_minloc_optional_scalar_mask(mask, back, array)
+ integer :: array(:)
+ logical, optional :: mask
+ logical, optional :: back
+ print *, minloc(array, mask=mask, back=back)
+ ! CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_0]] : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[VAL_10:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
+ ! CHECK: %[[VAL_11:.*]] = fir.absent !fir.box<!fir.logical<4>>
+ ! CHECK: %[[VAL_12:.*]] = arith.select %[[VAL_9]], %[[VAL_10]], %[[VAL_11]] : !fir.box<!fir.logical<4>>
+ ! CHECK: %[[VAL_13:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[VAL_14:.*]] = fir.if %[[VAL_13]] -> (!fir.logical<4>) {
+ ! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
+ ! CHECK: fir.result %[[VAL_15]] : !fir.logical<4>
+ ! CHECK: } else {
+ ! CHECK: %[[VAL_16:.*]] = arith.constant false
+ ! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i1) -> !fir.logical<4>
+ ! CHECK: fir.result %[[VAL_17]] : !fir.logical<4>
+ ! CHECK: }
+ ! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_12]] : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
+ ! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_14]] : (!fir.logical<4>) -> i1
+ ! CHECK: fir.call @_FortranAMinloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_29]], %[[VAL_30]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> none
+ end subroutine
+
+ ! CHECK-LABEL: func @_QPtest_minloc_optional_array_mask(
+ ! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>
+ ! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+ subroutine test_minloc_optional_array_mask(mask, back, array)
+ integer :: array(:)
+ logical, optional :: mask(:)
+ logical, optional :: back
+ print *, minloc(array, mask=mask, back=back)
+ ! CHECK: %[[VAL_9:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
+ ! CHECK: %[[VAL_10:.*]] = fir.if %[[VAL_9]] -> (!fir.logical<4>) {
+ ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
+ ! CHECK: fir.result %[[VAL_11]] : !fir.logical<4>
+ ! CHECK: } else {
+ ! CHECK: %[[VAL_12:.*]] = arith.constant false
+ ! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i1) -> !fir.logical<4>
+ ! CHECK: fir.result %[[VAL_13]] : !fir.logical<4>
+ ! CHECK: }
+ ! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>
+ ! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_10]] : (!fir.logical<4>) -> i1
+ ! CHECK: fir.call @_FortranAMinloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_25]], %[[VAL_26]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>, i1) -> none
+ end subroutine
diff --git a/flang/test/Lower/Intrinsics/minval.f90 b/flang/test/Lower/Intrinsics/minval.f90
new file mode 100644
index 0000000000000..ecc11900d052a
--- /dev/null
+++ b/flang/test/Lower/Intrinsics/minval.f90
@@ -0,0 +1,69 @@
+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+! CHECK-LABEL: func @_QPminval_test(
+! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) -> i32
+integer function minval_test(a)
+integer :: a(:)
+! CHECK-DAG: %[[c0:.*]] = arith.constant 0 : index
+! CHECK-DAG: %[[a2:.*]] = fir.absent !fir.box<i1>
+! CHECK-DAG: %[[a4:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>
+! CHECK: %[[a6:.*]] = fir.convert %[[c0]] : (index) -> i32
+! CHECK: %[[a7:.*]] = fir.convert %[[a2]] : (!fir.box<i1>) -> !fir.box<none>
+minval_test = minval(a)
+! CHECK: %{{.*}} = fir.call @_FortranAMinvalInteger4(%[[a4]], %{{.*}}, %{{.*}}, %[[a6]], %[[a7]]) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+end function
+
+! CHECK-LABEL: func @_QPminval_test2(
+! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.char<1>>{{.*}}, %[[arg1:.*]]: index{{.*}}, %[[arg2:.*]]: !fir.box<!fir.array<?x!fir.char<1>>>{{.*}}) -> !fir.boxchar<1>
+character function minval_test2(a)
+character :: a(:)
+! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.char<1,?>>>
+! CHECK: %[[a1:.*]] = fir.absent !fir.box<i1>
+! CHECK-DAG: %[[a5:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>) -> !fir.ref<!fir.box<none>>
+! CHECK: %[[a6:.*]] = fir.convert %[[arg2]] : (!fir.box<!fir.array<?x!fir.char<1>>>) -> !fir.box<none>
+! CHECK-DAG: %[[a8:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+minval_test2 = minval(a)
+! CHECK: %{{.*}} = fir.call @_FortranAMinvalCharacter(%[[a5]], %[[a6]], %{{.*}}, %{{.*}}, %[[a8]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32, !fir.box<none>) -> none
+end function
+
+! CHECK-LABEL: func @_QPminval_test3(
+! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?xi32>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?xi32>>{{.*}})
+subroutine minval_test3(a,r)
+integer :: a(:,:)
+integer :: r(:)
+! CHECK-DAG: %[[c2_i32:.*]] = arith.constant 2 : i32
+! CHECK-DAG: %[[a0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
+! CHECK: %[[a1:.*]] = fir.absent !fir.box<i1>
+! CHECK-DAG: %[[a6:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+! CHECK: %[[a7:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?xi32>>) -> !fir.box<none>
+! CHECK-DAG: %[[a9:.*]] = fir.convert %[[a1]] : (!fir.box<i1>) -> !fir.box<none>
+r = minval(a,dim=2)
+! CHECK: %{{.*}} = fir.call @_FortranAMinvalDim(%[[a6]], %[[a7]], %[[c2_i32]], %{{.*}}, %{{.*}}, %[[a9]]) : (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32, !fir.box<none>) -> none
+! CHECK: %[[a11:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+! CHECK-DAG: %[[a13:.*]] = fir.box_addr %[[a11]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+! CHECK-DAG: fir.freemem %[[a13]]
+end subroutine
+
+! CHECK-LABEL: func @_QPtest_minval_optional_scalar_mask(
+! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>
+subroutine test_minval_optional_scalar_mask(mask, array)
+integer :: array(:)
+logical, optional :: mask
+print *, minval(array, mask)
+! CHECK: %[[VAL_7:.*]] = fir.is_present %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> i1
+! CHECK: %[[VAL_8:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>
+! CHECK: %[[VAL_9:.*]] = fir.absent !fir.box<!fir.logical<4>>
+! CHECK: %[[VAL_10:.*]] = arith.select %[[VAL_7]], %[[VAL_8]], %[[VAL_9]] : !fir.box<!fir.logical<4>>
+! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_10]] : (!fir.box<!fir.logical<4>>) -> !fir.box<none>
+! CHECK: fir.call @_FortranAMinvalInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_17]]) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+end subroutine
+
+! CHECK-LABEL: func @_QPtest_minval_optional_array_mask(
+! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>
+subroutine test_minval_optional_array_mask(mask, array)
+integer :: array(:)
+logical, optional :: mask(:)
+print *, minval(array, mask)
+! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> !fir.box<none>
+! CHECK: fir.call @_FortranAMinvalInteger4(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[VAL_13]]) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+end subroutine
More information about the flang-commits
mailing list