[flang-commits] [flang] 4ffdc3a - [flang][hlfir] `hlfir.char_extremum` op definition and codegen
via flang-commits
flang-commits at lists.llvm.org
Mon Jun 26 12:42:37 PDT 2023
Author: Anthony Cabrera
Date: 2023-06-26T15:41:30-04:00
New Revision: 4ffdc3ac36717031126f65f5e8b4e738d6348016
URL: https://github.com/llvm/llvm-project/commit/4ffdc3ac36717031126f65f5e8b4e738d6348016
DIFF: https://github.com/llvm/llvm-project/commit/4ffdc3ac36717031126f65f5e8b4e738d6348016.diff
LOG: [flang][hlfir] `hlfir.char_extremum` op definition and codegen
This patch adds an hlfir operation called `char_extremum`, which takes the
lexicographic comparison between a variadic number (minimum of 2 arguments) of
characters.
Discussion for this work can be found in the draft revision found
[here](https://reviews.llvm.org/D143326). The reason I'm not promoting that draft to
a true patch for review was because I needed to separate out the op
definition/codegen and lowering as two separate patches, as preferred by
@jeanPerier.
Differential Revision: https://reviews.llvm.org/D152474
Added:
flang/test/HLFIR/char_extremum-bufferization.fir
flang/test/HLFIR/char_extremum.fir
Modified:
flang/include/flang/Optimizer/Builder/Character.h
flang/include/flang/Optimizer/HLFIR/CMakeLists.txt
flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h
flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td
flang/include/flang/Optimizer/HLFIR/HLFIROps.td
flang/lib/Optimizer/Builder/Character.cpp
flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp
Removed:
################################################################################
diff --git a/flang/include/flang/Optimizer/Builder/Character.h b/flang/include/flang/Optimizer/Builder/Character.h
index 3d8d9c6086461..c83076ee81987 100644
--- a/flang/include/flang/Optimizer/Builder/Character.h
+++ b/flang/include/flang/Optimizer/Builder/Character.h
@@ -15,6 +15,7 @@
#include "flang/Optimizer/Builder/BoxValue.h"
#include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
+#include "flang/Optimizer/Builder/Runtime/Character.h"
namespace fir {
class FirOpBuilder;
@@ -66,6 +67,10 @@ class CharacterExprHelper {
fir::CharBoxValue createConcatenate(const fir::CharBoxValue &lhs,
const fir::CharBoxValue &rhs);
+ /// Create {max,min}(lhs,rhs) in temp obtained with fir.alloca
+ fir::CharBoxValue
+ createCharExtremum(bool predIsMin, llvm::ArrayRef<fir::CharBoxValue> opCBVs);
+
/// LEN_TRIM intrinsic.
mlir::Value createLenTrim(const fir::CharBoxValue &str);
diff --git a/flang/include/flang/Optimizer/HLFIR/CMakeLists.txt b/flang/include/flang/Optimizer/HLFIR/CMakeLists.txt
index 823918bf8e9f9..9b4b6f5589559 100644
--- a/flang/include/flang/Optimizer/HLFIR/CMakeLists.txt
+++ b/flang/include/flang/Optimizer/HLFIR/CMakeLists.txt
@@ -5,6 +5,8 @@ mlir_tablegen(HLFIRDialect.h.inc -gen-dialect-decls -dialect=hlfir)
mlir_tablegen(HLFIRDialect.cpp.inc -gen-dialect-defs -dialect=hlfir)
mlir_tablegen(HLFIRAttributes.h.inc -gen-attrdef-decls -attrdefs-dialect=hlfir)
mlir_tablegen(HLFIRAttributes.cpp.inc -gen-attrdef-defs -attrdefs-dialect=hlfir)
+mlir_tablegen(HLFIREnums.h.inc -gen-enum-decls)
+mlir_tablegen(HLFIREnums.cpp.inc -gen-enum-defs)
set(LLVM_TARGET_DEFINITIONS HLFIROps.td)
mlir_tablegen(HLFIROpInterfaces.h.inc -gen-op-interface-decls)
diff --git a/flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h b/flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h
index 8e3a5dd9c24b3..8a0ce462ce748 100644
--- a/flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h
+++ b/flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h
@@ -26,6 +26,8 @@ bool isFortranScalarCharacterExprType(mlir::Type);
#include "flang/Optimizer/HLFIR/HLFIRDialect.h.inc"
+#include "flang/Optimizer/HLFIR/HLFIREnums.h.inc"
+
#define GET_TYPEDEF_CLASSES
#include "flang/Optimizer/HLFIR/HLFIRTypes.h.inc"
diff --git a/flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td b/flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td
index 5d37bd50c4b56..d44c636a59ea4 100644
--- a/flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td
+++ b/flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td
@@ -15,6 +15,7 @@
#define FORTRAN_DIALECT_HLFIR_OP_BASE
include "mlir/IR/AttrTypeBase.td"
+include "mlir/IR/EnumAttr.td"
include "mlir/IR/OpBase.td"
include "flang/Optimizer/Dialect/FIRTypes.td"
@@ -138,4 +139,12 @@ def IsFortranLogicalArrayPred
def AnyFortranLogicalArrayObject : Type<IsFortranLogicalArrayPred,
"any array-like object containing logicals">;
+def hlfir_CharExtremumPredicateAttr : I32EnumAttr<
+ "CharExtremumPredicate", "",
+ [
+ I32EnumAttrCase<"min", 0>,
+ I32EnumAttrCase<"max", 1>
+ ]> {
+ let cppNamespace = "hlfir";
+}
#endif // FORTRAN_DIALECT_HLFIR_OP_BASE
diff --git a/flang/include/flang/Optimizer/HLFIR/HLFIROps.td b/flang/include/flang/Optimizer/HLFIR/HLFIROps.td
index 541ad7a1588b0..cfc020e6b0d29 100644
--- a/flang/include/flang/Optimizer/HLFIR/HLFIROps.td
+++ b/flang/include/flang/Optimizer/HLFIR/HLFIROps.td
@@ -1425,4 +1425,29 @@ def hlfir_ForallIndexOp : hlfir_Op<"forall_index", [fir_FortranVariableOpInterfa
let hasCanonicalizeMethod = 1;
}
+def hlfir_CharExtremumOp : hlfir_Op<"char_extremum", []> {
+ let summary = "Find max/min from given character strings";
+ let description = [{
+ Find the lexicographical minimum or maximum of two or more character
+ strings of the same character kind and return the string with the lexicographical
+ minimum or maximum number of characters. Example:
+
+ %0 = hlfir.char_extremum min, %arg0, %arg1 : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,10>>
+ }];
+
+ let arguments = (ins hlfir_CharExtremumPredicateAttr:$predicate,
+ Variadic<AnyScalarCharacterEntity>:$strings
+ );
+
+ let results = (outs AnyScalarCharacterExpr);
+
+ let assemblyFormat = [{
+ $predicate `,` $strings attr-dict `:` functional-type(operands, results)
+ }];
+
+ let builders = [OpBuilder<(ins "hlfir::CharExtremumPredicate":$predicate, "mlir::ValueRange":$strings)>];
+
+ let hasVerifier = 1;
+}
+
#endif // FORTRAN_DIALECT_HLFIR_OPS
diff --git a/flang/lib/Optimizer/Builder/Character.cpp b/flang/lib/Optimizer/Builder/Character.cpp
index eb3825c1d4d60..b164282df2dc5 100644
--- a/flang/lib/Optimizer/Builder/Character.cpp
+++ b/flang/lib/Optimizer/Builder/Character.cpp
@@ -784,3 +784,68 @@ fir::factory::getCharacterProcedureTupleType(mlir::Type funcPointerType) {
mlir::Type lenType = mlir::IntegerType::get(context, 64);
return mlir::TupleType::get(context, {funcPointerType, lenType});
}
+
+fir::CharBoxValue fir::factory::CharacterExprHelper::createCharExtremum(
+ bool predIsMin, llvm::ArrayRef<fir::CharBoxValue> opCBVs) {
+ // inputs: we are given a vector of all of the charboxes of the arguments
+ // passed to hlfir.char_extremum, as well as the predicate for whether we
+ // want llt or lgt
+ //
+ // note: we know that, regardless of whether we're looking at smallest or
+ // largest char, the size of the output buffer will be the same size as the
+ // largest character out of all of the operands. so, we find the biggest
+ // length first. It's okay if these char lengths are not known at compile
+ // time.
+
+ fir::CharBoxValue firstCBV = opCBVs[0];
+ mlir::Value firstBuf = getCharBoxBuffer(firstCBV);
+ auto firstLen = builder.createConvert(loc, builder.getCharacterLengthType(),
+ firstCBV.getLen());
+
+ mlir::Value resultBuf = firstBuf;
+ mlir::Value resultLen = firstLen;
+ mlir::Value biggestLen = firstLen;
+
+ // values for casting buf type and len type
+ auto typeLen = fir::CharacterType::unknownLen();
+ auto kind = recoverCharacterType(firstBuf.getType()).getFKind();
+ auto charTy = fir::CharacterType::get(builder.getContext(), kind, typeLen);
+ auto type = fir::ReferenceType::get(charTy);
+
+ size_t numOperands = opCBVs.size();
+ for (size_t cbv_idx = 1; cbv_idx < numOperands; ++cbv_idx) {
+ auto currChar = opCBVs[cbv_idx];
+ auto currBuf = getCharBoxBuffer(currChar);
+ auto currLen = builder.createConvert(loc, builder.getCharacterLengthType(),
+ currChar.getLen());
+ // biggest len result
+ mlir::Value lhsBigger = builder.create<mlir::arith::CmpIOp>(
+ loc, mlir::arith::CmpIPredicate::uge, biggestLen, currLen);
+ biggestLen = builder.create<mlir::arith::SelectOp>(loc, lhsBigger,
+ biggestLen, currLen);
+
+ auto cmp = predIsMin ? mlir::arith::CmpIPredicate::slt
+ : mlir::arith::CmpIPredicate::sgt;
+
+ // lexical compare result
+ mlir::Value resultCmp = fir::runtime::genCharCompare(
+ builder, loc, cmp, currBuf, currLen, resultBuf, resultLen);
+
+ // it's casting (to unknown size) time!
+ resultBuf = builder.createConvert(loc, type, resultBuf);
+ currBuf = builder.createConvert(loc, type, currBuf);
+
+ resultBuf = builder.create<mlir::arith::SelectOp>(loc, resultCmp, currBuf,
+ resultBuf);
+ resultLen = builder.create<mlir::arith::SelectOp>(loc, resultCmp, currLen,
+ resultLen);
+ }
+
+ // now that we know the lexicographically biggest/smallest char and which char
+ // had the biggest len, we can populate a temp CBV and return it
+ fir::CharBoxValue temp = createCharacterTemp(resultBuf.getType(), biggestLen);
+ auto toBuf = temp;
+ fir::CharBoxValue fromBuf{resultBuf, resultLen};
+ createAssign(toBuf, fromBuf);
+ return temp;
+}
diff --git a/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp b/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
index e34123ffa4098..a310b50c1c997 100644
--- a/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
+++ b/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
@@ -1442,6 +1442,44 @@ hlfir::ForallIndexOp::canonicalize(hlfir::ForallIndexOp indexOp,
return mlir::success();
}
+//===----------------------------------------------------------------------===//
+// CharExtremumOp
+//===----------------------------------------------------------------------===//
+
+mlir::LogicalResult hlfir::CharExtremumOp::verify() {
+ if (getStrings().size() < 2)
+ return emitOpError("must be provided at least two string operands");
+ unsigned kind = getCharacterKind(getResult().getType());
+ for (auto string : getStrings())
+ if (kind != getCharacterKind(string.getType()))
+ return emitOpError("strings must have the same KIND as the result type");
+ return mlir::success();
+}
+
+void hlfir::CharExtremumOp::build(mlir::OpBuilder &builder,
+ mlir::OperationState &result,
+ hlfir::CharExtremumPredicate predicate,
+ mlir::ValueRange strings) {
+
+ fir::CharacterType::LenType resultTypeLen = 0;
+ assert(!strings.empty() && "must contain operands");
+ unsigned kind = getCharacterKind(strings[0].getType());
+ for (auto string : strings)
+ if (auto cstLen = getCharacterLengthIfStatic(string.getType())) {
+ resultTypeLen = std::max(resultTypeLen, *cstLen);
+ } else {
+ resultTypeLen = fir::CharacterType::unknownLen();
+ break;
+ }
+ auto resultType = hlfir::ExprType::get(
+ builder.getContext(), hlfir::ExprType::Shape{},
+ fir::CharacterType::get(builder.getContext(), kind, resultTypeLen),
+ false);
+
+ build(builder, result, resultType, predicate, strings);
+}
+
#include "flang/Optimizer/HLFIR/HLFIROpInterfaces.cpp.inc"
#define GET_OP_CLASSES
+#include "flang/Optimizer/HLFIR/HLFIREnums.cpp.inc"
#include "flang/Optimizer/HLFIR/HLFIROps.cpp.inc"
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp b/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp
index 513a9ff3dd709..db816d1a56904 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp
@@ -591,6 +591,54 @@ struct ElementalOpConversion
return mlir::success();
}
};
+struct CharExtremumOpConversion
+ : public mlir::OpConversionPattern<hlfir::CharExtremumOp> {
+ using mlir::OpConversionPattern<hlfir::CharExtremumOp>::OpConversionPattern;
+ explicit CharExtremumOpConversion(mlir::MLIRContext *ctx)
+ : mlir::OpConversionPattern<hlfir::CharExtremumOp>{ctx} {}
+ mlir::LogicalResult
+ matchAndRewrite(hlfir::CharExtremumOp char_extremum, OpAdaptor adaptor,
+ mlir::ConversionPatternRewriter &rewriter) const override {
+ mlir::Location loc = char_extremum->getLoc();
+ auto module = char_extremum->getParentOfType<mlir::ModuleOp>();
+ auto predicate = char_extremum.getPredicate();
+ bool predIsMin =
+ predicate == hlfir::CharExtremumPredicate::min ? true : false;
+ fir::FirOpBuilder builder(rewriter, fir::getKindMapping(module));
+ assert(adaptor.getStrings().size() >= 2 &&
+ "must have at least two strings operands");
+ auto numOperands = adaptor.getStrings().size();
+
+ std::vector<hlfir::Entity> chars;
+ std::vector<
+ std::pair<fir::ExtendedValue, std::optional<hlfir::CleanupFunction>>>
+ pairs;
+ llvm::SmallVector<fir::CharBoxValue> opCBVs;
+ for (size_t i = 0; i < numOperands; ++i) {
+ chars.emplace_back(getBufferizedExprStorage(adaptor.getStrings()[i]));
+ pairs.emplace_back(
+ hlfir::translateToExtendedValue(loc, builder, chars[i]));
+ assert(!pairs[i].second && "expected variables");
+ opCBVs.emplace_back(*pairs[i].first.getCharBox());
+ }
+
+ fir::ExtendedValue res =
+ fir::factory::CharacterExprHelper{builder, loc}.createCharExtremum(
+ predIsMin, opCBVs);
+ mlir::Type addrType = fir::ReferenceType::get(
+ hlfir::getFortranElementType(char_extremum.getResult().getType()));
+ mlir::Value cast = builder.createConvert(loc, addrType, fir::getBase(res));
+ res = fir::substBase(res, cast);
+ hlfir::Entity hlfirTempRes =
+ hlfir::Entity{hlfir::genDeclare(loc, builder, res, ".tmp.char_extremum",
+ fir::FortranVariableFlagsAttr{})
+ .getBase()};
+ mlir::Value bufferizedExpr =
+ packageBufferizedExpr(loc, builder, hlfirTempRes, false);
+ rewriter.replaceOp(char_extremum, bufferizedExpr);
+ return mlir::success();
+ }
+};
class BufferizeHLFIR : public hlfir::impl::BufferizeHLFIRBase<BufferizeHLFIR> {
public:
@@ -605,11 +653,12 @@ class BufferizeHLFIR : public hlfir::impl::BufferizeHLFIRBase<BufferizeHLFIR> {
auto module = this->getOperation();
auto *context = &getContext();
mlir::RewritePatternSet patterns(context);
- patterns.insert<ApplyOpConversion, AsExprOpConversion, AssignOpConversion,
- AssociateOpConversion, ConcatOpConversion,
- DestroyOpConversion, ElementalOpConversion,
- EndAssociateOpConversion, NoReassocOpConversion,
- SetLengthOpConversion, ShapeOfOpConversion>(context);
+ patterns
+ .insert<ApplyOpConversion, AsExprOpConversion, AssignOpConversion,
+ AssociateOpConversion, CharExtremumOpConversion,
+ ConcatOpConversion, DestroyOpConversion, ElementalOpConversion,
+ EndAssociateOpConversion, NoReassocOpConversion,
+ SetLengthOpConversion, ShapeOfOpConversion>(context);
mlir::ConversionTarget target(*context);
// Note that YieldElementOp is not marked as an illegal operation.
// It must be erased by its parent converter and there is no explicit
diff --git a/flang/test/HLFIR/char_extremum-bufferization.fir b/flang/test/HLFIR/char_extremum-bufferization.fir
new file mode 100644
index 0000000000000..4ce1471ae3271
--- /dev/null
+++ b/flang/test/HLFIR/char_extremum-bufferization.fir
@@ -0,0 +1,473 @@
+// Test hlfir.concat operation lowering to operations operating on memory.
+
+// RUN: fir-opt %s -bufferize-hlfir | FileCheck %s
+
+func.func @_QPmax1(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.boxchar<1> {fir.bindc_name = "c2"}, %arg2: !fir.boxchar<1> {fir.bindc_name = "c3"}) {
+ %0:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %1:2 = hlfir.declare %0#0 typeparams %0#1 {uniq_name = "_QFmax1Ec1"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %2:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %3:2 = hlfir.declare %2#0 typeparams %2#1 {uniq_name = "_QFmax1Ec2"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %4:2 = fir.unboxchar %arg2 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %5:2 = hlfir.declare %4#0 typeparams %4#1 {uniq_name = "_QFmax1Ec3"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %6 = hlfir.char_extremum max, %3#0, %5#0 : (!fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+ hlfir.assign %6 to %1#0 : !hlfir.expr<!fir.char<1,?>>, !fir.boxchar<1>
+ hlfir.destroy %6 : !hlfir.expr<!fir.char<1,?>>
+ return
+}
+
+// CHECK: func.func @_QPmax1(%[[ARG0:.*]]: !fir.boxchar<1> {fir.bindc_name = "c1"}, %[[ARG1:.*]]: !fir.boxchar<1> {fir.bindc_name = "c2"}, %[[ARG2:.*]]: !fir.boxchar<1> {fir.bindc_name = "c3"}) {
+// CHECK: %[[VAL_0:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_0]]#0 typeparams %[[VAL_0]]#1 {uniq_name = "_QFmax1Ec1"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[ARG1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_2]]#0 typeparams %[[VAL_2]]#1 {uniq_name = "_QFmax1Ec2"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[ARG2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_4]]#0 typeparams %[[VAL_4]]#1 {uniq_name = "_QFmax1Ec3"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_6:.*]] = arith.cmpi uge, %[[VAL_2]]#1, %[[VAL_4]]#1 : index
+// CHECK: %[[VAL_7:.*]] = arith.select %[[VAL_6]], %[[VAL_2]]#1, %[[VAL_4]]#1 : index
+// CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_5]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_3]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_4]]#1 : (index) -> i64
+// CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_2]]#1 : (index) -> i64
+// CHECK: %[[VAL_12:.*]] = fir.call @_FortranACharacterCompareScalar1(%[[VAL_8]], %[[VAL_9]], %[[VAL_10]], %[[VAL_11]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+// CHECK: %[[C0_I32:.*]] = arith.constant 0 : i32
+// CHECK: %[[VAL_13:.*]] = arith.cmpi sgt, %[[VAL_12]], %[[C0_I32]] : i32
+// CHECK: %[[VAL_14:.*]] = arith.select %[[VAL_13]], %[[VAL_5]]#1, %[[VAL_3]]#1 : !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_15:.*]] = arith.select %[[VAL_13]], %[[VAL_4]]#1, %[[VAL_2]]#1 : index
+// CHECK: %[[VAL_16:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_7]] : index) {bindc_name = ".chrtmp"}
+// CHECK: %[[VAL_17:.*]] = arith.cmpi slt, %[[VAL_7]], %[[VAL_15]] : index
+// CHECK: %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_7]], %[[VAL_15]] : index
+// CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
+// CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (index) -> i64
+// CHECK: %[[VAL_20:.*]] = arith.muli %[[C1_I64]], %[[VAL_19]] : i64
+// CHECK: %[[FALSE:.*]] = arith.constant false
+// CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_16]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_14]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_21]], %[[VAL_22]], %[[VAL_20]], %[[FALSE]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
+// CHECK: %[[C1:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_7]], %[[C1]] : index
+// CHECK: %[[C32_I8:.*]] = arith.constant 32 : i8
+// CHECK: %[[VAL_24:.*]] = fir.undefined !fir.char<1>
+// CHECK: %[[VAL_25:.*]] = fir.insert_value %[[VAL_24]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
+// CHECK: %[[C1_0:.*]] = arith.constant 1 : index
+// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_18:.*]] to %[[VAL_23]] step %[[C1_0]] {
+// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_16]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+// CHECK: %[[VAL_31:.*]] = fir.coordinate_of %[[VAL_30]], %[[ARG3]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+// CHECK: fir.store %[[VAL_25:.*]] to %[[VAL_31]] : !fir.ref<!fir.char<1>>
+// CHECK: }
+// CHECK: %[[VAL_26:.*]]:2 = hlfir.declare %[[VAL_16]] typeparams %[[VAL_7]] {uniq_name = ".tmp.char_extremum"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[FALSE_1:.*]] = arith.constant false
+// CHECK: %[[VAL_27:.*]] = fir.undefined tuple<!fir.boxchar<1>, i1>
+// CHECK: %[[VAL_28:.*]] = fir.insert_value %[[VAL_27]], %[[FALSE_1]], [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1>
+// CHECK: %[[VAL_29:.*]] = fir.insert_value %[[VAL_28]], %[[VAL_26]]#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1>
+// CHECK: hlfir.assign %[[VAL_26]]#0 to %[[VAL_1]]#0 : !fir.boxchar<1>, !fir.boxchar<1>
+// CHECK: return
+// CHECK: }
+
+func.func @_QPmin1(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.boxchar<1> {fir.bindc_name = "c2"}, %arg2: !fir.boxchar<1> {fir.bindc_name = "c3"}) {
+ %0:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %1:2 = hlfir.declare %0#0 typeparams %0#1 {uniq_name = "_QFmin1Ec1"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %2:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %3:2 = hlfir.declare %2#0 typeparams %2#1 {uniq_name = "_QFmin1Ec2"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %4:2 = fir.unboxchar %arg2 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %5:2 = hlfir.declare %4#0 typeparams %4#1 {uniq_name = "_QFmin1Ec3"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %6 = hlfir.char_extremum min, %3#0, %5#0 : (!fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+ hlfir.assign %6 to %1#0 : !hlfir.expr<!fir.char<1,?>>, !fir.boxchar<1>
+ hlfir.destroy %6 : !hlfir.expr<!fir.char<1,?>>
+ return
+}
+
+// CHECK: func.func @_QPmin1(%[[ARG0:.*]]: !fir.boxchar<1> {fir.bindc_name = "c1"}, %[[ARG1:.*]]: !fir.boxchar<1> {fir.bindc_name = "c2"}, %[[ARG2:.*]]: !fir.boxchar<1> {fir.bindc_name = "c3"}) {
+// CHECK: %[[VAL_0:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_0]]#0 typeparams %[[VAL_0]]#1 {uniq_name = "_QFmin1Ec1"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[ARG1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_2]]#0 typeparams %[[VAL_2]]#1 {uniq_name = "_QFmin1Ec2"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[ARG2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_4]]#0 typeparams %[[VAL_4]]#1 {uniq_name = "_QFmin1Ec3"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_6:.*]] = arith.cmpi uge, %[[VAL_2]]#1, %[[VAL_4]]#1 : index
+// CHECK: %[[VAL_7:.*]] = arith.select %[[VAL_6]], %[[VAL_2]]#1, %[[VAL_4]]#1 : index
+// CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_5]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_3]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_4]]#1 : (index) -> i64
+// CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_2]]#1 : (index) -> i64
+// CHECK: %[[VAL_12:.*]] = fir.call @_FortranACharacterCompareScalar1(%[[VAL_8]], %[[VAL_9]], %[[VAL_10]], %[[VAL_11]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+// CHECK: %[[C0_I32:.*]] = arith.constant 0 : i32
+// CHECK: %[[VAL_13:.*]] = arith.cmpi slt, %[[VAL_12]], %[[C0_I32]] : i32
+// CHECK: %[[VAL_14:.*]] = arith.select %[[VAL_13]], %[[VAL_5]]#1, %[[VAL_3]]#1 : !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_15:.*]] = arith.select %[[VAL_13]], %[[VAL_4]]#1, %[[VAL_2]]#1 : index
+// CHECK: %[[VAL_16:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_7]] : index) {bindc_name = ".chrtmp"}
+// CHECK: %[[VAL_17:.*]] = arith.cmpi slt, %[[VAL_7]], %[[VAL_15]] : index
+// CHECK: %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_7]], %[[VAL_15]] : index
+// CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
+// CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (index) -> i64
+// CHECK: %[[VAL_20:.*]] = arith.muli %[[C1_I64]], %[[VAL_19]] : i64
+// CHECK: %[[FALSE:.*]] = arith.constant false
+// CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_16]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_14]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_21]], %[[VAL_22]], %[[VAL_20]], %[[FALSE]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
+// CHECK: %[[C1:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_7]], %[[C1]] : index
+// CHECK: %[[C32_I8:.*]] = arith.constant 32 : i8
+// CHECK: %[[VAL_24:.*]] = fir.undefined !fir.char<1>
+// CHECK: %[[VAL_25:.*]] = fir.insert_value %[[VAL_24]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
+// CHECK: %[[C1_0:.*]] = arith.constant 1 : index
+// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_18:.*]] to %[[VAL_23]] step %[[C1_0]] {
+// CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_16]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+// CHECK: %[[VAL_31:.*]] = fir.coordinate_of %[[VAL_30]], %[[ARG3]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+// CHECK: fir.store %[[VAL_25:.*]] to %[[VAL_31]] : !fir.ref<!fir.char<1>>
+// CHECK: }
+// CHECK: %[[VAL_26:.*]]:2 = hlfir.declare %[[VAL_16]] typeparams %[[VAL_7]] {uniq_name = ".tmp.char_extremum"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[FALSE_1:.*]] = arith.constant false
+// CHECK: %[[VAL_27:.*]] = fir.undefined tuple<!fir.boxchar<1>, i1>
+// CHECK: %[[VAL_28:.*]] = fir.insert_value %[[VAL_27]], %[[FALSE_1]], [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1>
+// CHECK: %[[VAL_29:.*]] = fir.insert_value %[[VAL_28]], %[[VAL_26]]#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1>
+// CHECK: hlfir.assign %[[VAL_26]]#0 to %[[VAL_1]]#0 : !fir.boxchar<1>, !fir.boxchar<1>
+// CHECK: return
+// CHECK: }
+
+func.func @_QPmax2(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.boxchar<1> {fir.bindc_name = "c2"}, %arg2: !fir.boxchar<1> {fir.bindc_name = "c3"}) {
+ %0:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %1 = fir.convert %0#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,?>>>
+ %c100 = arith.constant 100 : index
+ %2 = fir.shape %c100 : (index) -> !fir.shape<1>
+ %3:2 = hlfir.declare %1(%2) typeparams %0#1 {uniq_name = "_QFmax2Ec1"} : (!fir.ref<!fir.array<100x!fir.char<1,?>>>, !fir.shape<1>, index) -> (!fir.box<!fir.array<100x!fir.char<1,?>>>, !fir.ref<!fir.array<100x!fir.char<1,?>>>)
+ %4:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %c10 = arith.constant 10 : index
+ %5 = fir.convert %4#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,10>>>
+ %c100_0 = arith.constant 100 : index
+ %6 = fir.shape %c100_0 : (index) -> !fir.shape<1>
+ %7:2 = hlfir.declare %5(%6) typeparams %c10 {uniq_name = "_QFmax2Ec2"} : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.shape<1>, index) -> (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.ref<!fir.array<100x!fir.char<1,10>>>)
+ %8:2 = fir.unboxchar %arg2 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %c20 = arith.constant 20 : index
+ %9 = fir.convert %8#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,20>>>
+ %c100_1 = arith.constant 100 : index
+ %10 = fir.shape %c100_1 : (index) -> !fir.shape<1>
+ %11:2 = hlfir.declare %9(%10) typeparams %c20 {uniq_name = "_QFmax2Ec3"} : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, !fir.shape<1>, index) -> (!fir.ref<!fir.array<100x!fir.char<1,20>>>, !fir.ref<!fir.array<100x!fir.char<1,20>>>)
+ %c1 = arith.constant 1 : index
+ %12 = hlfir.designate %7#0 (%c1) typeparams %c10 : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, index, index) -> !fir.ref<!fir.char<1,10>>
+ %c1_2 = arith.constant 1 : index
+ %13 = hlfir.designate %11#0 (%c1_2) typeparams %c20 : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, index, index) -> !fir.ref<!fir.char<1,20>>
+ %14 = hlfir.char_extremum max, %12, %13 : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,20>>
+ %c1_3 = arith.constant 1 : index
+ %15 = hlfir.designate %3#0 (%c1_3) typeparams %0#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+ hlfir.assign %14 to %15 : !hlfir.expr<!fir.char<1,20>>, !fir.boxchar<1>
+ hlfir.destroy %14 : !hlfir.expr<!fir.char<1,20>>
+ return
+}
+
+// CHECK: func.func @_QPmax2(%[[ARG0:.*]]: !fir.boxchar<1> {fir.bindc_name = "c1"}, %[[ARG1:.*]]: !fir.boxchar<1> {fir.bindc_name = "c2"}, %[[ARG2:.*]]: !fir.boxchar<1> {fir.bindc_name = "c3"}) {
+// CHECK: %[[VAL_0:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_1:.*]] = fir.convert %[[VAL_0]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,?>>>
+// CHECK: %[[C100:.*]] = arith.constant 100 : index
+// CHECK: %[[VAL_2:.*]] = fir.shape %[[C100]] : (index) -> !fir.shape<1>
+// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_2]]) typeparams %[[VAL_0]]#1 {uniq_name = "_QFmax2Ec1"} : (!fir.ref<!fir.array<100x!fir.char<1,?>>>, !fir.shape<1>, index) -> (!fir.box<!fir.array<100x!fir.char<1,?>>>, !fir.ref<!fir.array<100x!fir.char<1,?>>>)
+// CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[ARG1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[C10:.*]] = arith.constant 10 : index
+// CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,10>>>
+// CHECK: %[[C100_0:.*]] = arith.constant 100 : index
+// CHECK: %[[VAL_6:.*]] = fir.shape %[[C100_0]] : (index) -> !fir.shape<1>
+// CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_6]]) typeparams %[[C10]] {uniq_name = "_QFmax2Ec2"} : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.shape<1>, index) -> (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.ref<!fir.array<100x!fir.char<1,10>>>)
+// CHECK: %[[VAL_8:.*]]:2 = fir.unboxchar %[[ARG2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[C20:.*]] = arith.constant 20 : index
+// CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,20>>>
+// CHECK: %[[C100_1:.*]] = arith.constant 100 : index
+// CHECK: %[[VAL_10:.*]] = fir.shape %[[C100_1]] : (index) -> !fir.shape<1>
+// CHECK: %[[VAL_11:.*]]:2 = hlfir.declare %[[VAL_9]](%[[VAL_10]]) typeparams %[[C20]] {uniq_name = "_QFmax2Ec3"} : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, !fir.shape<1>, index) -> (!fir.ref<!fir.array<100x!fir.char<1,20>>>, !fir.ref<!fir.array<100x!fir.char<1,20>>>)
+// CHECK: %[[C1:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[C1]]) typeparams %[[C1]]0 : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, index, index) -> !fir.ref<!fir.char<1,10>>
+// CHECK: %[[C1_2:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_13:.*]] = hlfir.designate %[[VAL_11]]#0 (%[[C1_2]]) typeparams %[[C20]] : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, index, index) -> !fir.ref<!fir.char<1,20>>
+// CHECK: %[[VAL_14:.*]] = arith.cmpi uge, %[[C10]], %[[C20]] : index
+// CHECK: %[[VAL_15:.*]] = arith.select %[[VAL_14]], %[[C10]], %[[C20]] : index
+// CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,20>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_12]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_18:.*]] = fir.convert %[[C20]] : (index) -> i64
+// CHECK: %[[VAL_19:.*]] = fir.convert %[[C10]] : (index) -> i64
+// CHECK: %[[VAL_20:.*]] = fir.call @_FortranACharacterCompareScalar1(%[[VAL_16]], %[[VAL_17]], %[[VAL_18]], %[[VAL_19]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+// CHECK: %[[C0_I32:.*]] = arith.constant 0 : i32
+// CHECK: %[[VAL_21:.*]] = arith.cmpi sgt, %[[VAL_20]], %[[C0_I32]] : i32
+// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_12]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,20>>) -> !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_24:.*]] = arith.select %[[VAL_21]], %[[VAL_23]], %[[VAL_22]] : !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_25:.*]] = arith.select %[[VAL_21]], %[[C20]], %[[C10]] : index
+// CHECK: %[[VAL_26:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_15]] : index) {bindc_name = ".chrtmp"}
+// CHECK: %[[VAL_27:.*]] = arith.cmpi slt, %[[VAL_15]], %[[VAL_25]] : index
+// CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_15]], %[[VAL_25]] : index
+// CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
+// CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (index) -> i64
+// CHECK: %[[VAL_30:.*]] = arith.muli %[[C1_I64]], %[[VAL_29]] : i64
+// CHECK: %[[FALSE:.*]] = arith.constant false
+// CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_24]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_31]], %[[VAL_32]], %[[VAL_30]], %[[FALSE]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
+// CHECK: %[[C1_3:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_33:.*]] = arith.subi %[[VAL_15]], %[[C1_3]] : index
+// CHECK: %[[C32_I8:.*]] = arith.constant 32 : i8
+// CHECK: %[[VAL_34:.*]] = fir.undefined !fir.char<1>
+// CHECK: %[[VAL_35:.*]] = fir.insert_value %[[VAL_34]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
+// CHECK: %[[C1_4:.*]] = arith.constant 1 : index
+// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_28:.*]] to %[[VAL_33]] step %[[C1_4]] {
+// CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+// CHECK: %[[VAL_43:.*]] = fir.coordinate_of %[[VAL_42]], %[[ARG3]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+// CHECK: fir.store %[[VAL_35:.*]] to %[[VAL_43]] : !fir.ref<!fir.char<1>>
+// CHECK: }
+// CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,20>>
+// CHECK: %[[VAL_37:.*]]:2 = hlfir.declare %[[VAL_36]] typeparams %[[VAL_15]] {uniq_name = ".tmp.char_extremum"} : (!fir.ref<!fir.char<1,20>>, index) -> (!fir.ref<!fir.char<1,20>>, !fir.ref<!fir.char<1,20>>)
+// CHECK: %[[FALSE_5:.*]] = arith.constant false
+// CHECK: %[[VAL_38:.*]] = fir.undefined tuple<!fir.ref<!fir.char<1,20>>, i1>
+// CHECK: %[[VAL_39:.*]] = fir.insert_value %[[VAL_38]], %[[FALSE_5]], [1 : index] : (tuple<!fir.ref<!fir.char<1,20>>, i1>, i1) -> tuple<!fir.ref<!fir.char<1,20>>, i1>
+// CHECK: %[[VAL_40:.*]] = fir.insert_value %[[VAL_39]], %[[VAL_37]]#0, [0 : index] : (tuple<!fir.ref<!fir.char<1,20>>, i1>, !fir.ref<!fir.char<1,20>>) -> tuple<!fir.ref<!fir.char<1,20>>, i1>
+// CHECK: %[[C1_6:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_41:.*]] = hlfir.designate %[[VAL_3]]#0 (%[[C1_6]]) typeparams %[[VAL_0]]#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+// CHECK: hlfir.assign %[[VAL_37]]#0 to %[[VAL_41:.*]] : !fir.ref<!fir.char<1,20>>, !fir.boxchar<1>
+// CHECK: return
+// CHECK: }
+
+func.func @_QPmin2(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.boxchar<1> {fir.bindc_name = "c2"}, %arg2: !fir.boxchar<1> {fir.bindc_name = "c3"}) {
+ %0:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %1 = fir.convert %0#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,?>>>
+ %c100 = arith.constant 100 : index
+ %2 = fir.shape %c100 : (index) -> !fir.shape<1>
+ %3:2 = hlfir.declare %1(%2) typeparams %0#1 {uniq_name = "_QFmin2Ec1"} : (!fir.ref<!fir.array<100x!fir.char<1,?>>>, !fir.shape<1>, index) -> (!fir.box<!fir.array<100x!fir.char<1,?>>>, !fir.ref<!fir.array<100x!fir.char<1,?>>>)
+ %4:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %c10 = arith.constant 10 : index
+ %5 = fir.convert %4#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,10>>>
+ %c100_0 = arith.constant 100 : index
+ %6 = fir.shape %c100_0 : (index) -> !fir.shape<1>
+ %7:2 = hlfir.declare %5(%6) typeparams %c10 {uniq_name = "_QFmin2Ec2"} : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.shape<1>, index) -> (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.ref<!fir.array<100x!fir.char<1,10>>>)
+ %8:2 = fir.unboxchar %arg2 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %c20 = arith.constant 20 : index
+ %9 = fir.convert %8#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,20>>>
+ %c100_1 = arith.constant 100 : index
+ %10 = fir.shape %c100_1 : (index) -> !fir.shape<1>
+ %11:2 = hlfir.declare %9(%10) typeparams %c20 {uniq_name = "_QFmin2Ec3"} : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, !fir.shape<1>, index) -> (!fir.ref<!fir.array<100x!fir.char<1,20>>>, !fir.ref<!fir.array<100x!fir.char<1,20>>>)
+ %c1 = arith.constant 1 : index
+ %12 = hlfir.designate %7#0 (%c1) typeparams %c10 : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, index, index) -> !fir.ref<!fir.char<1,10>>
+ %c1_2 = arith.constant 1 : index
+ %13 = hlfir.designate %11#0 (%c1_2) typeparams %c20 : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, index, index) -> !fir.ref<!fir.char<1,20>>
+ %14 = hlfir.char_extremum min, %12, %13 : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,20>>
+ %c1_3 = arith.constant 1 : index
+ %15 = hlfir.designate %3#0 (%c1_3) typeparams %0#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+ hlfir.assign %14 to %15 : !hlfir.expr<!fir.char<1,20>>, !fir.boxchar<1>
+ hlfir.destroy %14 : !hlfir.expr<!fir.char<1,20>>
+ return
+}
+
+// CHECK: func.func @_QPmin2(%[[ARG0:.*]]: !fir.boxchar<1> {fir.bindc_name = "c1"}, %[[ARG1:.*]]: !fir.boxchar<1> {fir.bindc_name = "c2"}, %[[ARG2:.*]]: !fir.boxchar<1> {fir.bindc_name = "c3"}) {
+// CHECK: %[[VAL_0:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_1:.*]] = fir.convert %[[VAL_0]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,?>>>
+// CHECK: %[[C100:.*]] = arith.constant 100 : index
+// CHECK: %[[VAL_2:.*]] = fir.shape %[[C100]] : (index) -> !fir.shape<1>
+// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_2]]) typeparams %[[VAL_0]]#1 {uniq_name = "_QFmin2Ec1"} : (!fir.ref<!fir.array<100x!fir.char<1,?>>>, !fir.shape<1>, index) -> (!fir.box<!fir.array<100x!fir.char<1,?>>>, !fir.ref<!fir.array<100x!fir.char<1,?>>>)
+// CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[ARG1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[C10:.*]] = arith.constant 10 : index
+// CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,10>>>
+// CHECK: %[[C100_0:.*]] = arith.constant 100 : index
+// CHECK: %[[VAL_6:.*]] = fir.shape %[[C100_0]] : (index) -> !fir.shape<1>
+// CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_6]]) typeparams %[[C10]] {uniq_name = "_QFmin2Ec2"} : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.shape<1>, index) -> (!fir.ref<!fir.array<100x!fir.char<1,10>>>, !fir.ref<!fir.array<100x!fir.char<1,10>>>)
+// CHECK: %[[VAL_8:.*]]:2 = fir.unboxchar %[[ARG2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[C20:.*]] = arith.constant 20 : index
+// CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,20>>>
+// CHECK: %[[C100_1:.*]] = arith.constant 100 : index
+// CHECK: %[[VAL_10:.*]] = fir.shape %[[C100_1]] : (index) -> !fir.shape<1>
+// CHECK: %[[VAL_11:.*]]:2 = hlfir.declare %[[VAL_9]](%[[VAL_10]]) typeparams %[[C20]] {uniq_name = "_QFmin2Ec3"} : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, !fir.shape<1>, index) -> (!fir.ref<!fir.array<100x!fir.char<1,20>>>, !fir.ref<!fir.array<100x!fir.char<1,20>>>)
+// CHECK: %[[C1:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[C1]]) typeparams %[[C1]]0 : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, index, index) -> !fir.ref<!fir.char<1,10>>
+// CHECK: %[[C1_2:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_13:.*]] = hlfir.designate %[[VAL_11]]#0 (%[[C1_2]]) typeparams %[[C20]] : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, index, index) -> !fir.ref<!fir.char<1,20>>
+// CHECK: %[[VAL_14:.*]] = arith.cmpi uge, %[[C10]], %[[C20]] : index
+// CHECK: %[[VAL_15:.*]] = arith.select %[[VAL_14]], %[[C10]], %[[C20]] : index
+// CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,20>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_12]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_18:.*]] = fir.convert %[[C20]] : (index) -> i64
+// CHECK: %[[VAL_19:.*]] = fir.convert %[[C10]] : (index) -> i64
+// CHECK: %[[VAL_20:.*]] = fir.call @_FortranACharacterCompareScalar1(%[[VAL_16]], %[[VAL_17]], %[[VAL_18]], %[[VAL_19]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+// CHECK: %[[C0_I32:.*]] = arith.constant 0 : i32
+// CHECK: %[[VAL_21:.*]] = arith.cmpi slt, %[[VAL_20]], %[[C0_I32]] : i32
+// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_12]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,20>>) -> !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_24:.*]] = arith.select %[[VAL_21]], %[[VAL_23]], %[[VAL_22]] : !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_25:.*]] = arith.select %[[VAL_21]], %[[C20]], %[[C10]] : index
+// CHECK: %[[VAL_26:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_15]] : index) {bindc_name = ".chrtmp"}
+// CHECK: %[[VAL_27:.*]] = arith.cmpi slt, %[[VAL_15]], %[[VAL_25]] : index
+// CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_15]], %[[VAL_25]] : index
+// CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
+// CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (index) -> i64
+// CHECK: %[[VAL_30:.*]] = arith.muli %[[C1_I64]], %[[VAL_29]] : i64
+// CHECK: %[[FALSE:.*]] = arith.constant false
+// CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_24]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_31]], %[[VAL_32]], %[[VAL_30]], %[[FALSE]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
+// CHECK: %[[C1_3:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_33:.*]] = arith.subi %[[VAL_15]], %[[C1_3]] : index
+// CHECK: %[[C32_I8:.*]] = arith.constant 32 : i8
+// CHECK: %[[VAL_34:.*]] = fir.undefined !fir.char<1>
+// CHECK: %[[VAL_35:.*]] = fir.insert_value %[[VAL_34]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
+// CHECK: %[[C1_4:.*]] = arith.constant 1 : index
+// CHECK: fir.do_loop %[[ARG3:.*]] = %[[VAL_28:.*]] to %[[VAL_33]] step %[[C1_4]] {
+// CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+// CHECK: %[[VAL_43:.*]] = fir.coordinate_of %[[VAL_42]], %[[ARG3]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+// CHECK: fir.store %[[VAL_35:.*]] to %[[VAL_43]] : !fir.ref<!fir.char<1>>
+// CHECK: }
+// CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,20>>
+// CHECK: %[[VAL_37:.*]]:2 = hlfir.declare %[[VAL_36]] typeparams %[[VAL_15]] {uniq_name = ".tmp.char_extremum"} : (!fir.ref<!fir.char<1,20>>, index) -> (!fir.ref<!fir.char<1,20>>, !fir.ref<!fir.char<1,20>>)
+// CHECK: %[[FALSE_5:.*]] = arith.constant false
+// CHECK: %[[VAL_38:.*]] = fir.undefined tuple<!fir.ref<!fir.char<1,20>>, i1>
+// CHECK: %[[VAL_39:.*]] = fir.insert_value %[[VAL_38]], %[[FALSE_5]], [1 : index] : (tuple<!fir.ref<!fir.char<1,20>>, i1>, i1) -> tuple<!fir.ref<!fir.char<1,20>>, i1>
+// CHECK: %[[VAL_40:.*]] = fir.insert_value %[[VAL_39]], %[[VAL_37]]#0, [0 : index] : (tuple<!fir.ref<!fir.char<1,20>>, i1>, !fir.ref<!fir.char<1,20>>) -> tuple<!fir.ref<!fir.char<1,20>>, i1>
+// CHECK: %[[C1_6:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_41:.*]] = hlfir.designate %[[VAL_3]]#0 (%[[C1_6]]) typeparams %[[VAL_0]]#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+// CHECK: hlfir.assign %[[VAL_37]]#0 to %[[VAL_41:.*]] : !fir.ref<!fir.char<1,20>>, !fir.boxchar<1>
+// CHECK: return
+// CHECK: }
+
+func.func @_QPmax3(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.boxchar<1> {fir.bindc_name = "c2"}, %arg2: !fir.boxchar<1> {fir.bindc_name = "c3"}, %arg3: !fir.boxchar<1> {fir.bindc_name = "c4"}) {
+ %0:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %1:2 = hlfir.declare %0#0 typeparams %0#1 {uniq_name = "_QFmax3Ec1"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %2:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %3:2 = hlfir.declare %2#0 typeparams %2#1 {uniq_name = "_QFmax3Ec2"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %4:2 = fir.unboxchar %arg2 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %5:2 = hlfir.declare %4#0 typeparams %4#1 {uniq_name = "_QFmax3Ec3"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %6:2 = fir.unboxchar %arg3 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %7:2 = hlfir.declare %6#0 typeparams %6#1 {uniq_name = "_QFmax3Ec4"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %8 = hlfir.char_extremum max, %3#0, %5#0, %7#0 : (!fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+ hlfir.assign %8 to %1#0 : !hlfir.expr<!fir.char<1,?>>, !fir.boxchar<1>
+ hlfir.destroy %8 : !hlfir.expr<!fir.char<1,?>>
+ return
+}
+
+// CHECK: func.func @_QPmax3(%[[ARG0:.*]]: !fir.boxchar<1> {fir.bindc_name = "c1"}, %[[ARG1:.*]]: !fir.boxchar<1> {fir.bindc_name = "c2"}, %[[ARG2:.*]]: !fir.boxchar<1> {fir.bindc_name = "c3"}, %[[ARG3:.*]]: !fir.boxchar<1> {fir.bindc_name = "c4"}) {
+// CHECK: %[[VAL_0:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_0]]#0 typeparams %[[VAL_0]]#1 {uniq_name = "_QFmax3Ec1"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[ARG1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_2]]#0 typeparams %[[VAL_2]]#1 {uniq_name = "_QFmax3Ec2"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[ARG2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_4]]#0 typeparams %[[VAL_4]]#1 {uniq_name = "_QFmax3Ec3"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_6:.*]]:2 = fir.unboxchar %[[ARG3]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]]#0 typeparams %[[VAL_6]]#1 {uniq_name = "_QFmax3Ec4"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_8:.*]] = arith.cmpi uge, %[[VAL_2]]#1, %[[VAL_4]]#1 : index
+// CHECK: %[[VAL_9:.*]] = arith.select %[[VAL_8]], %[[VAL_2]]#1, %[[VAL_4]]#1 : index
+// CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_5]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_3]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_4]]#1 : (index) -> i64
+// CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_2]]#1 : (index) -> i64
+// CHECK: %[[VAL_14:.*]] = fir.call @_FortranACharacterCompareScalar1(%[[VAL_10]], %[[VAL_11]], %[[VAL_12]], %[[VAL_13]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+// CHECK: %[[C0_I32:.*]] = arith.constant 0 : i32
+// CHECK: %[[VAL_15:.*]] = arith.cmpi sgt, %[[VAL_14]], %[[C0_I32]] : i32
+// CHECK: %[[VAL_16:.*]] = arith.select %[[VAL_15]], %[[VAL_5]]#1, %[[VAL_3]]#1 : !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_17:.*]] = arith.select %[[VAL_15]], %[[VAL_4]]#1, %[[VAL_2]]#1 : index
+// CHECK: %[[VAL_18:.*]] = arith.cmpi uge, %[[VAL_9]], %[[VAL_6]]#1 : index
+// CHECK: %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_9]], %[[VAL_6]]#1 : index
+// CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_7]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_16]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_6]]#1 : (index) -> i64
+// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_17]] : (index) -> i64
+// CHECK: %[[VAL_24:.*]] = fir.call @_FortranACharacterCompareScalar1(%[[VAL_20]], %[[VAL_21]], %[[VAL_22]], %[[VAL_23]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+// CHECK: %[[C0_I32_0:.*]] = arith.constant 0 : i32
+// CHECK: %[[VAL_25:.*]] = arith.cmpi sgt, %[[VAL_24]], %[[C0_I32_0]] : i32
+// CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_25]], %[[VAL_7]]#1, %[[VAL_16]] : !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_27:.*]] = arith.select %[[VAL_25]], %[[VAL_6]]#1, %[[VAL_17]] : index
+// CHECK: %[[VAL_28:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_19]] : index) {bindc_name = ".chrtmp"}
+// CHECK: %[[VAL_29:.*]] = arith.cmpi slt, %[[VAL_19]], %[[VAL_27]] : index
+// CHECK: %[[VAL_30:.*]] = arith.select %[[VAL_29]], %[[VAL_19]], %[[VAL_27]] : index
+// CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
+// CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
+// CHECK: %[[VAL_32:.*]] = arith.muli %[[C1_I64]], %[[VAL_31]] : i64
+// CHECK: %[[FALSE:.*]] = arith.constant false
+// CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_28]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_33]], %[[VAL_34]], %[[VAL_32]], %[[FALSE]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
+// CHECK: %[[C1:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_19]], %[[C1]] : index
+// CHECK: %[[C32_I8:.*]] = arith.constant 32 : i8
+// CHECK: %[[VAL_36:.*]] = fir.undefined !fir.char<1>
+// CHECK: %[[VAL_37:.*]] = fir.insert_value %[[VAL_36]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
+// CHECK: %[[C1_1:.*]] = arith.constant 1 : index
+// CHECK: fir.do_loop %[[ARG4:.*]] = %[[VAL_30:.*]] to %[[VAL_35]] step %[[C1_1]] {
+// CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_28]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+// CHECK: %[[VAL_43:.*]] = fir.coordinate_of %[[VAL_42]], %[[ARG4]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+// CHECK: fir.store %[[VAL_37:.*]] to %[[VAL_43]] : !fir.ref<!fir.char<1>>
+// CHECK: }
+// CHECK: %[[VAL_38:.*]]:2 = hlfir.declare %[[VAL_28]] typeparams %[[VAL_19]] {uniq_name = ".tmp.char_extremum"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[FALSE_2:.*]] = arith.constant false
+// CHECK: %[[VAL_39:.*]] = fir.undefined tuple<!fir.boxchar<1>, i1>
+// CHECK: %[[VAL_40:.*]] = fir.insert_value %[[VAL_39]], %[[FALSE_2]], [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1>
+// CHECK: %[[VAL_41:.*]] = fir.insert_value %[[VAL_40]], %[[VAL_38]]#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1>
+// CHECK: hlfir.assign %[[VAL_38]]#0 to %[[VAL_1]]#0 : !fir.boxchar<1>, !fir.boxchar<1>
+// CHECK: return
+// CHECK: }
+
+func.func @_QPmin3(%arg0: !fir.boxchar<1> {fir.bindc_name = "c1"}, %arg1: !fir.boxchar<1> {fir.bindc_name = "c2"}, %arg2: !fir.boxchar<1> {fir.bindc_name = "c3"}, %arg3: !fir.boxchar<1> {fir.bindc_name = "c4"}) {
+ %0:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %1:2 = hlfir.declare %0#0 typeparams %0#1 {uniq_name = "_QFmin3Ec1"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %2:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %3:2 = hlfir.declare %2#0 typeparams %2#1 {uniq_name = "_QFmin3Ec2"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %4:2 = fir.unboxchar %arg2 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %5:2 = hlfir.declare %4#0 typeparams %4#1 {uniq_name = "_QFmin3Ec3"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %6:2 = fir.unboxchar %arg3 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ %7:2 = hlfir.declare %6#0 typeparams %6#1 {uniq_name = "_QFmin3Ec4"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+ %8 = hlfir.char_extremum min, %3#0, %5#0, %7#0 : (!fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+ hlfir.assign %8 to %1#0 : !hlfir.expr<!fir.char<1,?>>, !fir.boxchar<1>
+ hlfir.destroy %8 : !hlfir.expr<!fir.char<1,?>>
+ return
+}
+
+// CHECK: func.func @_QPmin3(%[[ARG0:.*]]: !fir.boxchar<1> {fir.bindc_name = "c1"}, %[[ARG1:.*]]: !fir.boxchar<1> {fir.bindc_name = "c2"}, %[[ARG2:.*]]: !fir.boxchar<1> {fir.bindc_name = "c3"}, %[[ARG3:.*]]: !fir.boxchar<1> {fir.bindc_name = "c4"}) {
+// CHECK: %[[VAL_0:.*]]:2 = fir.unboxchar %[[ARG0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_0]]#0 typeparams %[[VAL_0]]#1 {uniq_name = "_QFmin3Ec1"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_2:.*]]:2 = fir.unboxchar %[[ARG1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_2]]#0 typeparams %[[VAL_2]]#1 {uniq_name = "_QFmin3Ec2"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[ARG2]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_4]]#0 typeparams %[[VAL_4]]#1 {uniq_name = "_QFmin3Ec3"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_6:.*]]:2 = fir.unboxchar %[[ARG3]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+// CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]]#0 typeparams %[[VAL_6]]#1 {uniq_name = "_QFmin3Ec4"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[VAL_8:.*]] = arith.cmpi uge, %[[VAL_2]]#1, %[[VAL_4]]#1 : index
+// CHECK: %[[VAL_9:.*]] = arith.select %[[VAL_8]], %[[VAL_2]]#1, %[[VAL_4]]#1 : index
+// CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_5]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_3]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_4]]#1 : (index) -> i64
+// CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_2]]#1 : (index) -> i64
+// CHECK: %[[VAL_14:.*]] = fir.call @_FortranACharacterCompareScalar1(%[[VAL_10]], %[[VAL_11]], %[[VAL_12]], %[[VAL_13]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+// CHECK: %[[C0_I32:.*]] = arith.constant 0 : i32
+// CHECK: %[[VAL_15:.*]] = arith.cmpi slt, %[[VAL_14]], %[[C0_I32]] : i32
+// CHECK: %[[VAL_16:.*]] = arith.select %[[VAL_15]], %[[VAL_5]]#1, %[[VAL_3]]#1 : !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_17:.*]] = arith.select %[[VAL_15]], %[[VAL_4]]#1, %[[VAL_2]]#1 : index
+// CHECK: %[[VAL_18:.*]] = arith.cmpi uge, %[[VAL_9]], %[[VAL_6]]#1 : index
+// CHECK: %[[VAL_19:.*]] = arith.select %[[VAL_18]], %[[VAL_9]], %[[VAL_6]]#1 : index
+// CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_7]]#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_16]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_6]]#1 : (index) -> i64
+// CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_17]] : (index) -> i64
+// CHECK: %[[VAL_24:.*]] = fir.call @_FortranACharacterCompareScalar1(%[[VAL_20]], %[[VAL_21]], %[[VAL_22]], %[[VAL_23]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+// CHECK: %[[C0_I32_0:.*]] = arith.constant 0 : i32
+// CHECK: %[[VAL_25:.*]] = arith.cmpi slt, %[[VAL_24]], %[[C0_I32_0]] : i32
+// CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_25]], %[[VAL_7]]#1, %[[VAL_16]] : !fir.ref<!fir.char<1,?>>
+// CHECK: %[[VAL_27:.*]] = arith.select %[[VAL_25]], %[[VAL_6]]#1, %[[VAL_17]] : index
+// CHECK: %[[VAL_28:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_19]] : index) {bindc_name = ".chrtmp"}
+// CHECK: %[[VAL_29:.*]] = arith.cmpi slt, %[[VAL_19]], %[[VAL_27]] : index
+// CHECK: %[[VAL_30:.*]] = arith.select %[[VAL_29]], %[[VAL_19]], %[[VAL_27]] : index
+// CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
+// CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
+// CHECK: %[[VAL_32:.*]] = arith.muli %[[C1_I64]], %[[VAL_31]] : i64
+// CHECK: %[[FALSE:.*]] = arith.constant false
+// CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_28]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+// CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_33]], %[[VAL_34]], %[[VAL_32]], %[[FALSE]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
+// CHECK: %[[C1:.*]] = arith.constant 1 : index
+// CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_19]], %[[C1]] : index
+// CHECK: %[[C32_I8:.*]] = arith.constant 32 : i8
+// CHECK: %[[VAL_36:.*]] = fir.undefined !fir.char<1>
+// CHECK: %[[VAL_37:.*]] = fir.insert_value %[[VAL_36]], %[[C32_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
+// CHECK: %[[C1_1:.*]] = arith.constant 1 : index
+// CHECK: fir.do_loop %[[ARG4:.*]] = %[[VAL_30:.*]] to %[[VAL_35]] step %[[C1_1]] {
+// CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_28]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+// CHECK: %[[VAL_43:.*]] = fir.coordinate_of %[[VAL_42]], %[[ARG4]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+// CHECK: fir.store %[[VAL_37:.*]] to %[[VAL_43]] : !fir.ref<!fir.char<1>>
+// CHECK: }
+// CHECK: %[[VAL_38:.*]]:2 = hlfir.declare %[[VAL_28]] typeparams %[[VAL_19]] {uniq_name = ".tmp.char_extremum"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+// CHECK: %[[FALSE_2:.*]] = arith.constant false
+// CHECK: %[[VAL_39:.*]] = fir.undefined tuple<!fir.boxchar<1>, i1>
+// CHECK: %[[VAL_40:.*]] = fir.insert_value %[[VAL_39]], %[[FALSE_2]], [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1>
+// CHECK: %[[VAL_41:.*]] = fir.insert_value %[[VAL_40]], %[[VAL_38]]#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1>
+// CHECK: hlfir.assign %[[VAL_38]]#0 to %[[VAL_1]]#0 : !fir.boxchar<1>, !fir.boxchar<1>
+// CHECK: return
+// CHECK: }
diff --git a/flang/test/HLFIR/char_extremum.fir b/flang/test/HLFIR/char_extremum.fir
new file mode 100644
index 0000000000000..aa4b8d65898b9
--- /dev/null
+++ b/flang/test/HLFIR/char_extremum.fir
@@ -0,0 +1,130 @@
+// Test hlfir.char_extremum operation parse, verify (no errors), and unparse.
+
+// RUN: fir-opt %s | fir-opt | FileCheck %s
+
+
+// variable check
+func.func @char_extremum_min_var(%arg0: !fir.ref<!fir.char<1,10>>, %arg1: !fir.ref<!fir.char<1,20>>) {
+ %0 = hlfir.char_extremum min, %arg0, %arg1 : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,10>>
+ return
+}
+
+// CHECK-LABEL: func.func @char_extremum_min_var(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !fir.ref<!fir.char<1,10>>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !fir.ref<!fir.char<1,20>>) {
+// CHECK: %{{.*}} = hlfir.char_extremum min, %[[VAL_0]], %[[VAL_1]] : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,10>>
+
+func.func @char_extremum_max_var(%arg0: !fir.ref<!fir.char<1,10>>, %arg1: !fir.ref<!fir.char<1,20>>) {
+%0 = hlfir.char_extremum min, %arg0, %arg1 : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,20>>
+return
+}
+
+// CHECK-LABEL: func.func @char_extremum_max_var(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !fir.ref<!fir.char<1,10>>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !fir.ref<!fir.char<1,20>>) {
+// CHECK: %{{.*}} = hlfir.char_extremum min, %[[VAL_0]], %[[VAL_1]] : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,20>>
+
+func.func @char_extremum_min_var_variadic(%arg0: !fir.ref<!fir.char<1,10>>, %arg1: !fir.ref<!fir.char<1,20>>, %arg2: !fir.ref<!fir.char<1,30>>) {
+ %0 = hlfir.char_extremum min, %arg0, %arg1, %arg2 : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>, !fir.ref<!fir.char<1,30>>) -> !hlfir.expr<!fir.char<1,10>>
+ return
+}
+
+// CHECK-LABEL: func.func @char_extremum_min_var_variadic(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !fir.ref<!fir.char<1,10>>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !fir.ref<!fir.char<1,20>>,
+// CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<!fir.char<1,30>>) {
+// CHECK: %{{.*}} = hlfir.char_extremum min, %[[VAL_0]], %[[VAL_1]], %[[VAL_2]] : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>, !fir.ref<!fir.char<1,30>>) -> !hlfir.expr<!fir.char<1,10>>
+
+func.func @char_extremum_max_var_variadic(%arg0: !fir.ref<!fir.char<1,10>>, %arg1: !fir.ref<!fir.char<1,20>>, %arg2: !fir.ref<!fir.char<1,30>>) {
+ %0 = hlfir.char_extremum max, %arg0, %arg1, %arg2 : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>, !fir.ref<!fir.char<1,30>>) -> !hlfir.expr<!fir.char<1,30>>
+ return
+}
+
+// CHECK-LABEL: func.func @char_extremum_max_var_variadic(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !fir.ref<!fir.char<1,10>>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !fir.ref<!fir.char<1,20>>,
+// CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<!fir.char<1,30>>) {
+// CHECK: %{{.*}} = hlfir.char_extremum max, %[[VAL_0]], %[[VAL_1]], %[[VAL_2]] : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>, !fir.ref<!fir.char<1,30>>) -> !hlfir.expr<!fir.char<1,30>>
+
+
+// boxchar check
+func.func @char_extremum_min_boxchar(%arg0: !fir.boxchar<1>, %arg1: !fir.boxchar<1>) {
+ %0 = hlfir.char_extremum min, %arg0, %arg1 : (!fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+ return
+}
+// CHECK-LABEL: func.func @char_extremum_min_boxchar(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !fir.boxchar<1>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !fir.boxchar<1>) {
+// CHECK: %{{.*}} = hlfir.char_extremum min, %[[VAL_0]], %[[VAL_1]] : (!fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+
+func.func @char_extremum_max_boxchar(%arg0: !fir.boxchar<1>, %arg1: !fir.boxchar<1>) {
+ %0 = hlfir.char_extremum max, %arg0, %arg1 : (!fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+ return
+}
+// CHECK-LABEL: func.func @char_extremum_max_boxchar(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !fir.boxchar<1>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !fir.boxchar<1>) {
+// CHECK: %{{.*}} = hlfir.char_extremum max, %[[VAL_0]], %[[VAL_1]] : (!fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+
+func.func @char_extremum_min_boxchar_variadic(%arg0: !fir.boxchar<1>, %arg1: !fir.boxchar<1>, %arg2: !fir.boxchar<1>, %arg3: !fir.boxchar<1>) {
+ %0 = hlfir.char_extremum min, %arg0, %arg1, %arg2, %arg3 : (!fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+ return
+}
+// CHECK-LABEL: func.func @char_extremum_min_boxchar_variadic(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !fir.boxchar<1>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !fir.boxchar<1>,
+// CHECK-SAME: %[[VAL_2:[a-zA-Z0-9_]*]]: !fir.boxchar<1>,
+// CHECK-SAME: %[[VAL_3:[a-zA-Z0-9_]*]]: !fir.boxchar<1>) {
+// CHECK: %{{.*}} = hlfir.char_extremum min, %[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]] : (!fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+
+func.func @char_extremum_max_boxchar_variadic(%arg0: !fir.boxchar<1>, %arg1: !fir.boxchar<1>, %arg2: !fir.boxchar<1>, %arg3: !fir.boxchar<1>) {
+ %0 = hlfir.char_extremum max, %arg0, %arg1, %arg2, %arg3 : (!fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+ return
+}
+// CHECK-LABEL: func.func @char_extremum_max_boxchar_variadic(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !fir.boxchar<1>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !fir.boxchar<1>,
+// CHECK-SAME: %[[VAL_2:[a-zA-Z0-9_]*]]: !fir.boxchar<1>,
+// CHECK-SAME: %[[VAL_3:[a-zA-Z0-9_]*]]: !fir.boxchar<1>) {
+// CHECK: %{{.*}} = hlfir.char_extremum max, %[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]] : (!fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+
+
+//expr check
+func.func @char_extremum_min_expr(%arg0: !hlfir.expr<!fir.char<1,10>>, %arg1: !hlfir.expr<!fir.char<1,20>>) {
+ %0 = hlfir.char_extremum min, %arg0, %arg1 : (!hlfir.expr<!fir.char<1,10>>, !hlfir.expr<!fir.char<1,20>>) -> (!hlfir.expr<!fir.char<1,10>>)
+ return
+}
+// CHECK-LABEL: func.func @char_extremum_min_expr(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,10>>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,20>>) {
+// CHECK: %{{.*}} = hlfir.char_extremum min, %[[VAL_0]], %[[VAL_1]] : (!hlfir.expr<!fir.char<1,10>>, !hlfir.expr<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,10>>
+
+func.func @char_extremum_max_expr(%arg0: !hlfir.expr<!fir.char<1,10>>, %arg1: !hlfir.expr<!fir.char<1,20>>) {
+ %0 = hlfir.char_extremum max, %arg0, %arg1 : (!hlfir.expr<!fir.char<1,10>>, !hlfir.expr<!fir.char<1,20>>) -> (!hlfir.expr<!fir.char<1,20>>)
+ return
+}
+// CHECK-LABEL: func.func @char_extremum_max_expr(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,10>>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,20>>) {
+// CHECK: %{{.*}} = hlfir.char_extremum max, %[[VAL_0]], %[[VAL_1]] : (!hlfir.expr<!fir.char<1,10>>, !hlfir.expr<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,20>>
+
+func.func @char_extremum_min_expr_variadic(%arg0: !hlfir.expr<!fir.char<1,10>>, %arg1: !hlfir.expr<!fir.char<1,20>>, %arg2: !hlfir.expr<!fir.char<1,30>>) {
+ %0 = hlfir.char_extremum min, %arg0, %arg1, %arg2 : (!hlfir.expr<!fir.char<1,10>>, !hlfir.expr<!fir.char<1,20>>, !hlfir.expr<!fir.char<1,30>>) -> (!hlfir.expr<!fir.char<1,10>>)
+ return
+}
+// CHECK-LABEL: func.func @char_extremum_min_expr_variadic(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,10>>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,20>>,
+// CHECK-SAME: %[[VAL_2:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,30>>) {
+// CHECK: %{{.*}} = hlfir.char_extremum min, %[[VAL_0]], %[[VAL_1]], %[[VAL_2]] : (!hlfir.expr<!fir.char<1,10>>, !hlfir.expr<!fir.char<1,20>>, !hlfir.expr<!fir.char<1,30>>) -> !hlfir.expr<!fir.char<1,10>>
+
+func.func @char_extremum_max_expr_variadic(%arg0: !hlfir.expr<!fir.char<1,10>>, %arg1: !hlfir.expr<!fir.char<1,20>>, %arg2: !hlfir.expr<!fir.char<1,30>>) {
+ %0 = hlfir.char_extremum max, %arg0, %arg1, %arg2 : (!hlfir.expr<!fir.char<1,10>>, !hlfir.expr<!fir.char<1,20>>, !hlfir.expr<!fir.char<1,30>>) -> (!hlfir.expr<!fir.char<1,30>>)
+ return
+}
+// CHECK-LABEL: func.func @char_extremum_max_expr_variadic(
+// CHECK-SAME: %[[VAL_0:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,10>>,
+// CHECK-SAME: %[[VAL_1:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,20>>,
+// CHECK-SAME: %[[VAL_2:[a-zA-Z0-9_]*]]: !hlfir.expr<!fir.char<1,30>>) {
+// CHECK: %{{.*}} = hlfir.char_extremum max, %[[VAL_0]], %[[VAL_1]], %[[VAL_2]] : (!hlfir.expr<!fir.char<1,10>>, !hlfir.expr<!fir.char<1,20>>, !hlfir.expr<!fir.char<1,30>>) -> !hlfir.expr<!fir.char<1,30>>
+
More information about the flang-commits
mailing list