[flang][hlfir] initial work towards hlfir.char_extremum op

[cabreraam]

Summary

My initial work towards an hlfir.char_extremum op.

@jeanPerier, I'm using these 3 commits:

• Commit 1
• Commit 2
• Commit 3

as a foundation for this work.
I still need to add tests like in your flang/test/HLFIR/concat.fir, but once I do that, I'll start working on:

• translating expr --> hlfir
• char_extremum codegen

What do you think so far? An okay direction so far? Anything I should be aware of going forward?

---

2023-05-02
Added some preliminary support for code-gen.
Feedback appreciated!

Relevant files:
+ BufferizeHLFIR.cpp
+ Character.cpp
+ Character.h
+ char_extremum-bufferization.fir

[cabreraam]

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

325

this should not return index. this should return the minimum/maximum string. I'll fix that later

332

maybe this should be AnyScalarCharacterEntity again

[cabreraam]

Also need to run clang-format. Will eventually do that.

[cabreraam]

• [flang][hlfir] correction to hlfir.char_extremum doc string
• [flang][hlfir] first attempt at parsing test for hlfir.char_extremum
• [flang][hlfir] convertcall.cpp work towards hlfir.char_extremum
• [flang][hlfir] lowering hlfir.char_extremum
• [flang][hlfir] start of test for max.f03

[cabreraam]

• [flang][hlfir] remove some fluff

[cabreraam]

This comment was removed by cabreraam.

[cabreraam]

flang/lib/Lower/ConvertCall.cpp

1479

This is where the logic for variadic arguments should go.

@jeanPerier what's a good way to initialize a mlir::ValueRange without assuming the size of operands?

[jeanPerier]

This looks like a great draft to me.

flang/lib/Lower/ConvertCall.cpp

1472

You likely need to only fall here for character min/max (missing condition on the result or operand type).

1479

Doesn't passing operands directly works? I believe an mlir::ValueRange can be implicitely constructed from an llvm::SmallVector<mlir::Value>.

flang/test/Lower/HLFIR/max.f03

16 ↗

(On Diff #508470)

nit: it seems the file is missing a new line here.

[cabreraam]

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

566

Need to address this! This is fine if predicate == hlfir::CharExtremumPredicate::min, but we want the opposite if the predicate is min.

[cabreraam]

• [flang][hlfir] correction to hlfir.char_extremum doc string
• [flang][hlfir] first attempt at parsing test for hlfir.char_extremum
• [flang][hlfir] convertcall.cpp work towards hlfir.char_extremum
• [flang][hlfir] lowering hlfir.char_extremum
• [flang][hlfir] start of test for max.f03
• [flang][hlfir] remove some fluff
• [flang][hlfir] make changes based on jean's suggestions

[cabreraam]

I implemented your suggestions! I should be finished editing the test with all of the FileCheck stuff by tomorrow.

This is what the output of bbc max.f03 looks like:

mlir-asm-printer: Verifying operation: func.func
func.func @_QPconcat3(%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 = "_QFconcat3Ec1"} : (!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 = "_QFconcat3Ec2"} : (!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 = "_QFconcat3Ec3"} : (!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 = "_QFconcat3Ec4"} : (!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
}
ImplicitTypeIDRegistry::lookupOrInsert(Fortran::lower::VerifierPass)
ImplicitTypeIDRegistry::lookupOrInsert(mlir::detail::OpToOpPassAdaptor)
ImplicitTypeIDRegistry::lookupOrInsert(mlir::detail::PreservedAnalyses::AllAnalysesType)
mlir-asm-printer: Verifying operation: builtin.module
module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
  func.func @_QPmax_char(%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 = "_QFmax_charEc1"} : (!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 = "_QFmax_charEc2"} : (!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 = "_QFmax_charEc3"} : (!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
  }
  func.func @_QPconcat_2(%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 = "_QFconcat_2Ec1"} : (!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 = "_QFconcat_2Ec2"} : (!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 = "_QFconcat_2Ec3"} : (!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,10>>
    %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,10>>, !fir.boxchar<1>
    hlfir.destroy %14 : !hlfir.expr<!fir.char<1,10>>
    return
  }
  func.func @_QPconcat3(%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 = "_QFconcat3Ec1"} : (!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 = "_QFconcat3Ec2"} : (!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 = "_QFconcat3Ec3"} : (!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 = "_QFconcat3Ec4"} : (!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
  }
}

flang/lib/Lower/ConvertCall.cpp

1479

Ope, you were right. That worked!

[jeanPerier]

flang/lib/Lower/ConvertCall.cpp

1457–1463

That is a bit overkill (to loop through the arguments), looking at the first is sufficient. But better yet, you should just be able to do if ((intrinsicName == "min" || intrinsicName == "max") && hlfir::getFortranElementType(callContext.resultType.value()).isa<fir::CharacterType>())

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

566

Actually, the condition is always the reverse: the result length is always the length of the longest operand (for both min and max). You may just want to use std::max for more clarity:

if (auto cstLen = getCharacterLengthIfStatic(string.getType())) {
  resultTypeLen = std::max(resultTypeLen, *cstLen);
} ...

[cabreraam]

• [flang][hlfir] correction to hlfir.char_extremum doc string
• [flang][hlfir] first attempt at parsing test for hlfir.char_extremum
• [flang][hlfir] convertcall.cpp work towards hlfir.char_extremum
• [flang][hlfir] lowering hlfir.char_extremum
• [flang][hlfir] start of test for max.f03
• [flang][hlfir] remove some fluff
• [flang][hlfir] make changes based on jean's suggestions
• [flang][hlfir] implemented Jeans suggestions and added a test to check lowering Fortran to HLFIR char extremum

[cabreraam]

• clang-format

[cabreraam]

Addressed your most recent feedback and added another test!

[jeanPerier]

Looks good

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

566

Nit: character length are always positive (character(n) is sanitized to character(max(0,n))) in lowering, so you do not need the if (resultTypeLen == 0) case, it is the same as std::max(resultTypeLen, *cstLen); given *cstLen >=0.
An even if we failed to sanitized the incoming operand lengths, it is safer to return a value that is guaranteed to be positive here.

[cabreraam]

• [flang][hlfir] correction to hlfir.char_extremum doc string
• [flang][hlfir] first attempt at parsing test for hlfir.char_extremum
• [flang][hlfir] convertcall.cpp work towards hlfir.char_extremum
• [flang][hlfir] lowering hlfir.char_extremum
• [flang][hlfir] start of test for max.f03
• [flang][hlfir] remove some fluff
• [flang][hlfir] make changes based on jean's suggestions
• [flang][hlfir] implemented Jeans suggestions and added a test to check lowering Fortran to HLFIR char extremum
• clang-format
• [flang][hlfir] addressing some of Jean's nits

[cabreraam]

Updating D143326: [flang][hlfir] initial work towards hlfir.char_extremum op

[cabreraam]

• [flang][hlfir] correction to hlfir.char_extremum doc string
• [flang][hlfir] first attempt at parsing test for hlfir.char_extremum
• [flang][hlfir] convertcall.cpp work towards hlfir.char_extremum
• [flang][hlfir] lowering hlfir.char_extremum
• [flang][hlfir] start of test for max.f03
• [flang][hlfir] remove some fluff
• [flang][hlfir] make changes based on jean's suggestions
• [flang][hlfir] implemented Jeans suggestions and added a test to check lowering Fortran to HLFIR char extremum
• [flang][hlfir] rebase for hlfir.char_extremum
• [flang][hlfir] addressing some of Jean's nits
• [flang][hlfir] prelim work towards adding codegen for hlfir.char_extremum
• [flang][hlfir] added codegen for variadic args and

[jeanPerier]

Thanks for the updated patch!

flang/lib/Optimizer/Builder/Character.cpp

823

Using llvm::ArrayRef<fir::CharBox> might be better. It forces the caller to pass characters (and std::vector is not a type that is used in lowering that uses llvm data structures).

827–829

You are losing knowledge about the result length that you had in the hlfir operation that new about the result type length if it was something known at compile time. Static alloc are easier to optimize, hoist out of loops....

You should likely add a result mlir::Type argument to createCharExtremum2, and get it from the hlfir operation when calling this helper.

849–850

MIN/MAX are comparing the lexicographical order of the characters, not their length. So the logic here needs to be a lot more complex. While it can be done inlined, it will generate a lot of code.

I would suggest using
fir::runtime::genCharCompare(builder, loc, pred, lhs, rhs) (https://github.com/llvm/llvm-project/blob/6c8d8d10455a3d38a92102ae3a94e1c06d3eb363/flang/include/flang/Optimizer/Builder/Runtime/Character.h#L46) instead.

863

The result length is always the one from the longest argument, both for MIN and MAX. In case the result length is known in the result type (my comment above), you should also directly compute it from the type, to avoid the select on the length.

I would suggest doing something to split the (compile time) loop looking for the biggestLen, and the one looking for the extremum. The first loop would only be done if the result type length is unknown.

865–877

You need to call the assignment logic here (fir::factory::CharacterExprHelper::createAssign) to deal with the potential padding (the "biggest"/"smallest" in lexicographical order may have smaller length than the result).

flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp

659

Nit: use llvm::SmallVector<fir::CharBox> here instead (fir::ExtentdedValue are bigger, so if you know you have CharBox, better to store that).

676

You could pass addrType here I think and let createCharExtremum2 use the info inside for static length result, and ensure the returned value has the correct address type.

[cabreraam]

• [flang][hlfir] correction to hlfir.char_extremum doc string
• [flang][hlfir] first attempt at parsing test for hlfir.char_extremum
• [flang][hlfir] convertcall.cpp work towards hlfir.char_extremum
• [flang][hlfir] lowering hlfir.char_extremum
• [flang][hlfir] start of test for max.f03
• [flang][hlfir] remove some fluff
• [flang][hlfir] make changes based on jean's suggestions
• [flang][hlfir] implemented Jeans suggestions and added a test to check lowering Fortran to HLFIR char extremum
• [flang][hlfir] rebase for hlfir.char_extremum
• [flang][hlfir] addressing some of Jean's nits
• [flang][hlfir] prelim work towards adding codegen for hlfir.char_extremum
• [flang][hlfir] added codegen for variadic args and
• [flang][hlfir] current work towards hlfir.char_extremum

[cabreraam]

flang/lib/Optimizer/Builder/Character.cpp

919–937

@jeanPerier @tblah @jacob-crawley

I am struggling mightily here. Ultimately I still have the same issue with mismatched types.

The issue is, I want to be able to hold onto the character type that has the biggest/smallest len based on the genCharCompare result.

However, when you use things like mlir::arith::Select or even using an if statement where you specify the return type, the return type will vary based on the character buffer that gets selected (assuming that both of the lengths are known at compile time). I cannot figure out how to solve this.

I feel like a solution could include something like:

• based on the output of genCharCompare I should be able to select between the two character buffers
• I want to cast both to the result type that's the biggest (if i'm looking for max) or the smallest (if I'm looking for min).
• Then, I can just use mlir::arith::SelectOp to select the character buffer I want because the types will be the same!
• Then I can just discard whichever one I don't need and then keep going through the rest of the character strings to perform the same comparisons

Thoughts? Any help is appreciated!

[cabreraam]

flang/lib/Optimizer/Builder/Character.cpp

919–937

I could cast to the appropriate type in the if/then/else logic, but I don’t know how to get that SSA value to persist out of the loop without knowing the type before hand.

[jeanPerier]

flang/lib/Optimizer/Builder/Character.cpp

919–937

The issue is, I want to be able to hold onto the character type that has the biggest/smallest len based on the genCharCompare result.

I do not think you need this. genCharCompare is doing a lexicographical compare, you need this to determine which operand should be assigned to the temp, but not to find the biggest length.

To find the biggest length, you just need to compare and select the operand's length to find the biggest length (regardless of whether this is character min/max).

Then, once you have that, you can allocate the result buffer and do the lexicographical compare to select the operand. You will need to thread both the address and length of the extremum until the assignment. You can just cast the addresses to fir.ref<fir.char<?xkind>> to get uniform type in the select. This could be optimized if all the operands have the same compile time constant length in a second time.
See below on on to create such type.

I want to cast both to the result type that's the biggest (if i'm looking for max) or the smallest (if I'm looking for min).

The result type is independent of whether this is a character min/max. It always has the length of the longest operand. The MIN/MAX aspect only imapct the value selected to fill the result, not the result length.

Creating the fir.ref<fir.char<?>> type:

auto kind = recoverCharacterType(resultType).getFKind(); // resultType could also be the first operand type.
auto typeLen = fir::CharacterType::unknownLen();
auto charTy = fir::CharacterType::get(builder.getContext(), kind, typeLen);
auto charRefType = fir::ReferenceType::get(charTy);

Then you can cast all the buffer with this type before selecting them, and you can select the length next to that.

[cabreraam]

• [flang][hlfir] correction to hlfir.char_extremum doc string
• [flang][hlfir] first attempt at parsing test for hlfir.char_extremum
• [flang][hlfir] convertcall.cpp work towards hlfir.char_extremum
• [flang][hlfir] lowering hlfir.char_extremum
• [flang][hlfir] start of test for max.f03
• [flang][hlfir] remove some fluff
• [flang][hlfir] make changes based on jean's suggestions
• [flang][hlfir] implemented Jeans suggestions and added a test to check lowering Fortran to HLFIR char extremum
• [flang][hlfir] addressing some of Jean's nits
• [flang][hlfir] prelim work towards adding codegen for hlfir.char_extremum
• [flang][hlfir] added codegen for variadic args and
• [flang][hlfir] current work towards hlfir.char_extremum
• [flang][hlfir] latest attempt at codegen for

[cabreraam]

flang/lib/Optimizer/Builder/Character.cpp

919–937

This was immensely helpful!

What I ended up doing was casting both candidate buffers to the biggest size because I'll know that after the the arith::CmpI compare. Then, I selected the the correct buffer based on the genCharCompare. I took a look at the resulting code-gen -- which is in char_extremum-bufferization.fir -- for the case when the lengths are known at compiler time -- the max2 and min2 tests -- and the character type's length does get returned when creating the resulting CharBovValue.

Let me know what you think!

[cabreraam]

• [flang][hlfir] correction to hlfir.char_extremum doc string
• [flang][hlfir] first attempt at parsing test for hlfir.char_extremum
• [flang][hlfir] convertcall.cpp work towards hlfir.char_extremum
• [flang][hlfir] lowering hlfir.char_extremum
• [flang][hlfir] start of test for max.f03
• [flang][hlfir] remove some fluff
• [flang][hlfir] make changes based on jean's suggestions
• [flang][hlfir] implemented Jeans suggestions and added a test to check lowering Fortran to HLFIR char extremum
• [flang][hlfir] addressing some of Jean's nits
• [flang][hlfir] prelim work towards adding codegen for hlfir.char_extremum
• [flang][hlfir] added codegen for variadic args and
• [flang][hlfir] current work towards hlfir.char_extremum
• [flang][hlfir] latest attempt at codegen for
• [flang] reverting this back to original state

[jeanPerier]

Thanks for the update, it is staring to get shape!

flang/lib/Optimizer/Builder/Character.cpp

926–930

Casting to the biggest length could actually lead to bugs: FIR will happily assume the resulting buffer from the select has the length indicated in its type, while if a "smaller" buffer was selected, this is not true and would lead to out of bounds read while later doing the assignment.

Starting by casting to unknown length is good enough. If both have the same constant length, the select result can have that type. This case is easy to cover by only doing the buffer cast to unknown length if recoverCharacterType(resultBuf.getType()) != recoverCharacterType(currBuf.getType()).

954

This may still read past the "from" buffer if the extremum has smaller length than the result. Please use fir::factory::CharacterExprHelper::createAssign as previously suggested to deal with the padding as needed.

[cabreraam]

• [flang][hlfir] correction to hlfir.char_extremum doc string
• [flang][hlfir] first attempt at parsing test for hlfir.char_extremum
• [flang][hlfir] convertcall.cpp work towards hlfir.char_extremum
• [flang][hlfir] lowering hlfir.char_extremum
• [flang][hlfir] start of test for max.f03
• [flang][hlfir] remove some fluff
• [flang][hlfir] make changes based on jean's suggestions
• [flang][hlfir] implemented Jeans suggestions and added a test to check lowering Fortran to HLFIR char extremum
• [flang][hlfir] addressing some of Jean's nits
• [flang][hlfir] prelim work towards adding codegen for hlfir.char_extremum
• [flang][hlfir] added codegen for variadic args and
• [flang][hlfir] current work towards hlfir.char_extremum
• [flang][hlfir] latest attempt at codegen for
• [flang][hlfir] cast currBuf and resultBuf to unknown then recover len after lexical compare if known

[cabreraam]

If you think this looks good, let me know! I'll create separate patches for op definition/code-gen and then one for lowering.

flang/lib/Optimizer/Builder/Character.cpp

833–835

Casting to the biggest length could actually lead to bugs: FIR will happily assume the resulting buffer from the select has the length indicated in its type, while if a "smaller" buffer was selected, this is not true and would lead to out of bounds read while later doing the assignment.

Starting by casting to unknown length is good enough. If both have the same constant length, the select result can have that type. This case is easy to cover by only doing the buffer cast to unknown length if recoverCharacterType(resultBuf.getType()) != recoverCharacterType(currBuf.getType()).

I now convert to a character type with unknownLen and then recover the length in lines 844-849 if the length is known at compile time. See tests max2 and min2 in char_extremum-bufferization.fir as proof that this conversion happens.

856

This may still read past the "from" buffer if the extremum has smaller length than the result. Please use fir::factory::CharacterExprHelper::createAssign as previously suggested to deal with the padding as needed.

Done!

954

This may still read past the "from" buffer if the extremum has smaller length than the result. Please use fir::factory::CharacterExprHelper::createAssign as previously suggested to deal with the padding as needed.

[jeanPerier]

Thanks for the update

flang/lib/Optimizer/Builder/Character.cpp

844–849

This likely will never be used since resultLen is produced by a fir.select (unless there is only one argument, which is not legal) and no folding occurred yet (maybe mlir::Fold could succeed here, I am not sure, but I think it is to leave that up to the next canonicalization pass).

flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp

613

I am not sure a vector is needed here, it is stored and used inside the same loop,

614

Same here.

634

Nit: we lack a proper convention to name temps, but they all start with "." to underline this is not a user variable name. ".tmp.char_extremum" would also give more info about the purpose of this temp.

[cabreraam]

flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp

614

The uses for this are outside of the scope of the for loop; I use them when I pass opCBVs to the createCharExtremum helper.

flang/include/flang/Optimizer/Builder/Character.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_OPTIMIZER_BUILDER_CHARACTER_H
 #define FORTRAN_OPTIMIZER_BUILDER_CHARACTER_H
 
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
+#include "flang/Optimizer/Builder/Runtime/Character.h"
 
 namespace fir {
 class FirOpBuilder;
 }
 
 namespace fir::factory {
 
 /// Helper to facilitate lowering of CHARACTER in FIR.
public:
   /// It handles cases where \p lhs and \p rhs may overlap.
   void createAssign(const fir::ExtendedValue &lhs,
                     const fir::ExtendedValue &rhs);
 
   /// Create lhs // rhs in temp obtained with fir.alloca
   fir::CharBoxValue createConcatenate(const fir::CharBoxValue &lhs,
                                       const fir::CharBoxValue &rhs);
 
+  /// Create {max,min}(lhs,rhs) in temp obtained with fir.alloca
+  /// TODO: delete this. `createCharExtremum2` is the better solution
+  fir::CharBoxValue createCharExtremum(bool predIsMin,
+                                       const fir::CharBoxValue &lhs,
+                                       const fir::CharBoxValue &rhs);
+  /// Create {max,min}(lhs,rhs) in temp obtained with fir.alloca
+  /*fir::CharBoxValue createCharExtremum2(
+      bool predIsMin,
+      const llvm::SmallVector<const fir::CharBoxValue *> &opExvs);*/
+
+  /// Create {max,min}(lhs,rhs) in temp obtained with fir.alloca
+  fir::CharBoxValue
+  createCharExtremum3(bool predIsMin,
+                      const llvm::SmallVector<fir::CharBoxValue> &opCBVs);
+
   /// LEN_TRIM intrinsic.
   mlir::Value createLenTrim(const fir::CharBoxValue &str);
 
   /// Embox \p addr and \p len and return fir.boxchar.
   /// Take care of type conversions before emboxing.
   /// \p len is converted to the integer type for character lengths if needed.
   mlir::Value createEmboxChar(mlir::Value addr, mlir::Value len);
   /// Create a fir.boxchar for \p str. If \p str is not in memory, a temp is

flang/include/flang/Optimizer/HLFIR/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS HLFIROpBase.td)
 mlir_tablegen(HLFIRTypes.h.inc -gen-typedef-decls -typedefs-dialect=hlfir)
 mlir_tablegen(HLFIRTypes.cpp.inc -gen-typedef-defs -typedefs-dialect=hlfir)
 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)
 mlir_tablegen(HLFIROpInterfaces.cpp.inc -gen-op-interface-defs)
 mlir_tablegen(HLFIROps.h.inc -gen-op-decls)
 mlir_tablegen(HLFIROps.cpp.inc -gen-op-defs)
 
 set(LLVM_TARGET_DEFINITIONS Passes.td)
 mlir_tablegen(Passes.h.inc -gen-pass-decls -name HLFIR)
 
 add_public_tablegen_target(HLFIROpsIncGen)

flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h

 /// Is this a type that can be used for an HLFIR variable ?
 bool isFortranVariableType(mlir::Type);
 bool isFortranScalarCharacterType(mlir::Type);
 bool isFortranScalarCharacterExprType(mlir::Type);
 } // namespace hlfir
 
 #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"
 
 #define GET_ATTRDEF_CLASSES
 #include "flang/Optimizer/HLFIR/HLFIRAttributes.h.inc"
 
 namespace hlfir {
 /// Get the element type of a Fortran entity type.

flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td

 /// Definition of the HLFIR dialect and core hlfir.expr type
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_DIALECT_HLFIR_OP_BASE
 #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"
 
 def hlfir_Dialect : Dialect {
   let name = "hlfir";
 
   let summary = "High Level Fortran IR.";
 

 def AnyFortranLogicalOrI1ArrayObject : Type<IsMaskArgumentPred,
     "A scalar i1 or logical or an array-like object containing logicals">;
 
 def IsFortranLogicalArrayPred
         : CPred<"::hlfir::isFortranLogicalArrayObject($_self)">;
 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

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

def hlfir_ConcatOp : hlfir_Op<"concat", []> {
   let hasVerifier = 1;
 }
 
 def hlfir_AnyOp : hlfir_Op<"any", []> {
   let summary = "ANY transformational intrinsic";
   let description = [{
     Takes a logical array MASK as argument, optionally along a particular dimension,
     and returns true if any element of MASK is true.
   }];
 
   let arguments = (ins
     AnyFortranLogicalArrayObject:$mask,
     Optional<AnyIntegerType>:$dim
   );
 
   let results = (outs AnyFortranValue);
 
   let assemblyFormat = [{
     $mask  (`dim` $dim^)?  attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
let extraClassDeclaration = [{
     /// Implement OrderedAssignmentTreeOpInterface interface.
     void getLeafRegions(llvm::SmallVectorImpl<mlir::Region*>& regions) {}
     mlir::Region* getSubTreeRegion() { return nullptr; }
   }];
 
   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

flang/lib/Lower/ConvertCall.cpp

for (size_t i = 0; i < loweredActuals.size(); ++i) {
       std::optional<PreparedActualArgument> arg = loweredActuals[i];
       if (!arg) {
         operands.emplace_back();
         continue;
       }
       hlfir::Entity actual = arg->getOriginalActual();
       mlir::Value valArg;
 
+      // if intrinsic handler has no lowering rules
+      if (!argLowering) {
+        valArg = hlfir::loadTrivialScalar(loc, builder, actual);
+      } else {
         fir::ArgLoweringRule argRules =
             fir::lowerIntrinsicArgumentAs(*argLowering, i);
         if (!argRules.handleDynamicOptional &&
             argRules.lowerAs != fir::LowerIntrinsicArgAs::Inquired)
           valArg = hlfir::derefPointersAndAllocatables(loc, builder, actual);
         else
           valArg = actual.getBase();
+      }
 
       operands.emplace_back(valArg);
     }
     return operands;
   };
 
   auto computeResultType = [&](mlir::Value argArray,
                                mlir::Type stmtResultType) -> mlir::Type {
if (intrinsicName == "any") {
     if (dim)
       dim = hlfir::loadTrivialScalar(loc, builder, hlfir::Entity{dim});
     mlir::Type resultTy = computeResultType(mask, *callContext.resultType);
     hlfir::AnyOp anyOp = builder.create<hlfir::AnyOp>(loc, resultTy, mask, dim);
 
     return {hlfir::EntityWithAttributes{anyOp.getResult()}};
   }
 
+  if ((intrinsicName == "min" || intrinsicName == "max") &&
+      hlfir::getFortranElementType(callContext.resultType.value())
+          .isa<fir::CharacterType>()) {
+    llvm::SmallVector<mlir::Value> operands = getOperandVector(loweredActuals);
+    assert(operands.size() >= 2);
+
+    hlfir::CharExtremumPredicate pred = (intrinsicName == "min")
+                                            ? hlfir::CharExtremumPredicate::min
+                                            : hlfir::CharExtremumPredicate::max;
+    hlfir::CharExtremumOp charExtremumOp =
+        builder.create<hlfir::CharExtremumOp>(loc, pred,
+                                              mlir::ValueRange{operands});
+    return {hlfir::EntityWithAttributes{charExtremumOp.getResult()}};
+  }
+
   // TODO add hlfir operations for other transformational intrinsics here
 
   // fallback to calling the intrinsic via fir.call
   return genIntrinsicRefCore(loweredActuals, intrinsic, argLowering,
                              callContext);
 }
 
 namespace {
 template <typename ElementalCallBuilderImpl>
 class ElementalCallBuilder {
 public:
   std::optional<hlfir::EntityWithAttributes>
   genElementalCall(PreparedActualArguments &loweredActuals, bool isImpure,
                    CallContext &callContext) {
     mlir::Location loc = callContext.loc;
     fir::FirOpBuilder &builder = callContext.getBuilder();
     unsigned numArgs = loweredActuals.size();

flang/lib/Optimizer/Builder/Character.cpp

 }
 
 mlir::Type
 fir::factory::getCharacterProcedureTupleType(mlir::Type funcPointerType) {
   mlir::MLIRContext *context = funcPointerType.getContext();
   mlir::Type lenType = mlir::IntegerType::get(context, 64);
   return mlir::TupleType::get(context, {funcPointerType, lenType});
 }
+
+// TODO: remove this. `createCharExtremum2` is the better solution.
+fir::CharBoxValue fir::factory::CharacterExprHelper::createCharExtremum(
+    bool predIsMin, const fir::CharBoxValue &lhs,
+    const fir::CharBoxValue &rhs) {
+  auto lhsLen = builder.createConvert(loc, builder.getCharacterLengthType(),
+                                      lhs.getLen());
+  auto rhsLen = builder.createConvert(loc, builder.getCharacterLengthType(),
+                                      rhs.getLen());
+  mlir::Value lhsBigger = builder.create<mlir::arith::CmpIOp>(
+      loc, mlir::arith::CmpIPredicate::ugt, lhsLen, rhsLen);
+  mlir::Value lhsCBB = getCharBoxBuffer(lhs);
+  mlir::Value rhsCBB = getCharBoxBuffer(rhs);
+  mlir::Value biggestChar =
+      builder.create<mlir::arith::SelectOp>(loc, lhsBigger, lhsCBB, rhsCBB);
+  mlir::Value biggestLen =
+      builder.create<mlir::arith::SelectOp>(loc, lhsBigger, lhsLen, rhsLen);
+  auto temp = createCharacterTemp(biggestChar.getType(), biggestLen);
+  auto lowerBound =
+      builder.createIntegerConstant(loc, builder.getIndexType(), 0);
+  auto one = builder.createIntegerConstant(loc, biggestLen.getType(), 1);
+  auto upperBound = builder.create<mlir::arith::SubIOp>(loc, biggestLen, one);
+  mlir::Value fromBuff = predIsMin ? builder.create<mlir::arith::SelectOp>(
+                                         loc, lhsBigger, rhsCBB, lhsCBB)
+                                   : biggestChar;
+  auto toBuff = getCharBoxBuffer(temp);
+  fir::factory::DoLoopHelper{builder, loc}.createLoop(
+      lowerBound, upperBound, one,
+      [&](fir::FirOpBuilder &bldr, mlir::Value index) {
+        auto charVal = createLoadCharAt(fromBuff, index);
+        createStoreCharAt(toBuff, index, charVal);
+      });
+  return temp;
+}
+
+/*fir::CharBoxValue fir::factory::CharacterExprHelper::createCharExtremum2(
+    bool predIsMin,
+    const llvm::SmallVector<const fir::CharBoxValue *> &opExvs) {
+
+  auto resultChar = *opExvs[0];
+
+  auto typeLen = fir::CharacterType::unknownLen();
+  auto kind = recoverCharacterType(resultChar.getBuffer().getType()).getFKind();
+  auto charTy = fir::CharacterType::get(builder.getContext(), kind, typeLen);
+  auto type = fir::ReferenceType::get(charTy);
+  auto buffer = builder.createConvert(loc, type, resultChar.getBuffer());
+  fir::CharBoxValue castedResultCBV{buffer, resultChar.getLen()};
+
+  mlir::Value resultCharCBB = getCharBoxBuffer(castedResultCBV);
+  mlir::Value biggestLen = builder.createConvert(
+      loc, builder.getCharacterLengthType(), (*opExvs[0]).getLen());
+  mlir::Value smallestLen = biggestLen;
+
+  for (size_t i = 1; i < opExvs.size(); ++i) {
+    auto compareChar = *opExvs[i];
+    auto castedBuffer =
+        builder.createConvert(loc, type, compareChar.getBuffer());
+    fir::CharBoxValue castedCompareCBV{castedBuffer, compareChar.getLen()};
+    auto compareCharCBB = getCharBoxBuffer(castedCompareCBV);
+    auto compareCharLen = builder.createConvert(
+        loc, builder.getCharacterLengthType(), compareChar.getLen());
+
+    mlir::Value lhsBigger = builder.create<mlir::arith::CmpIOp>(
+        loc, mlir::arith::CmpIPredicate::uge, biggestLen, compareCharLen);
+    biggestLen = builder.create<mlir::arith::SelectOp>(
+        loc, lhsBigger, biggestLen, compareCharLen);
+
+    if (predIsMin) {
+      auto lhsSmaller = builder.create<mlir::arith::CmpIOp>(
+          loc, mlir::arith::CmpIPredicate::ult, smallestLen, compareCharLen);
+      resultCharCBB = builder.create<mlir::arith::SelectOp>(
+          loc, lhsSmaller, resultCharCBB, compareCharCBB);
+    } else
+      resultCharCBB = builder.create<mlir::arith::SelectOp>(
+          loc, lhsBigger, resultCharCBB, compareCharCBB);
+  }
+  auto resultLen = predIsMin ? smallestLen : biggestLen;
+  auto temp = createCharacterTemp(resultCharCBB.getType(), biggestLen);
+  auto lowerBound =
+      builder.createIntegerConstant(loc, builder.getIndexType(), 0);
+  auto one = builder.createIntegerConstant(loc, biggestLen.getType(), 1);
+  auto upperBound = builder.create<mlir::arith::SubIOp>(loc, resultLen, one);
+  auto toBuff = getCharBoxBuffer(temp);
+  fir::factory::DoLoopHelper{builder, loc}.createLoop(
+      lowerBound, upperBound, one,
+      [&](fir::FirOpBuilder &bldr, mlir::Value index) {
+        auto charVal = createLoadCharAt(resultCharCBB, index);
+        createStoreCharAt(toBuff, index, charVal);
+      });
+  return temp;
+}*/
+
+fir::CharBoxValue fir::factory::CharacterExprHelper::createCharExtremum3(
+    // bool predIsMin, llvm::ArrayRef<fir::CharBoxValue> &opCBVs) {
+    bool predIsMin, const llvm::SmallVector<fir::CharBoxValue> &opCBVs) {
+  // inputs: we are given a vector of all of the charboxes of the arguments
+  // passed to the char_extremum  op, as well as the predicate for whether we
+  // want llt, lle, lgt, lle
+  //
+  // 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 are undefined.
+
+  // now we will need to loop over all of the opearnds in the vector.
+  // before loop, set first operand as biggest/smallest char.
+  // TODO: look at how concat does it. we will probably do something similar
+  // with temp. So, don't create temp until after the for loop is done
+
+  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;
+
+  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);
+
+    // the cmp you pass should reflect whether predIsMin is true or false
+    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 biggest size) time!
+    auto typeLen = fir::CharacterType::unknownLen();
+    if (auto cstLen = getIntIfConstant(biggestLen))
+      typeLen = *cstLen;
+    auto kind = recoverCharacterType(firstBuf.getType()).getFKind();
+    auto charTy = fir::CharacterType::get(builder.getContext(), kind, typeLen);
+    auto type = fir::ReferenceType::get(charTy);
+    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);
+    // at this point, I think the correct things are selected and casted!
+  }
+
+  // now that we know the biggest/smallest char and len, we can populate a temp
+  // CBV and return it
+  fir::CharBoxValue temp = createCharacterTemp(resultBuf.getType(), biggestLen);
+  auto lowerBound =
+      builder.createIntegerConstant(loc, builder.getIndexType(), 0);
+  auto one = builder.createIntegerConstant(loc, resultLen.getType(), 1);
+  auto upperBound = builder.create<mlir::arith::SubIOp>(loc, resultLen, one);
+  auto toBuf = getCharBoxBuffer(temp);
+  auto fromBuf = resultBuf;
+  fir::factory::DoLoopHelper{builder, loc}.createLoop(
+      lowerBound, upperBound, one,
+      [&](fir::FirOpBuilder &bldr, mlir::Value index) {
+        auto charVal = createLoadCharAt(fromBuf, index);
+        createStoreCharAt(toBuf, index, charVal);
+      });
+  return temp;
+}
 No newline at end of file

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

static mlir::LogicalResult verifyReductionOp(ReductionOp reductionOp) {
   llvm::ArrayRef<int64_t> arrayShape = arrayTy.getShape();
 
   if (mask) {
     fir::SequenceType maskSeq =
         hlfir::getFortranElementOrSequenceType(mask.getType())
             .dyn_cast<fir::SequenceType>();
     llvm::ArrayRef<int64_t> maskShape;
 
     if (maskSeq)
       maskShape = maskSeq.getShape();
 
     if (!maskShape.empty()) {
       if (maskShape.size() != arrayShape.size())
         return reductionOp->emitWarning("MASK must be conformable to ARRAY");
       static_assert(fir::SequenceType::getUnknownExtent() ==
                     hlfir::ExprType::getUnknownExtent());
       constexpr int64_t unknownExtent = fir::SequenceType::getUnknownExtent();
hlfir::ForallIndexOp::canonicalize(hlfir::ForallIndexOp indexOp,
   rewriter.restoreInsertionPoint(insertPt);
   if (indexOp.use_empty()) {
     rewriter.eraseOp(indexOp);
     return mlir::success();
   }
   return mlir::failure();
 }
 
+//===----------------------------------------------------------------------===//
+// 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/HLFIROps.cpp.inc"
+#include "flang/Optimizer/HLFIR/HLFIREnums.cpp.inc"
+#include "flang/Optimizer/HLFIR/HLFIROps.cpp.inc"
 No newline at end of file

flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp

matchAndRewrite(hlfir::ElementalOp elemental, OpAdaptor adaptor,
     builder.restoreInsertionPoint(insPt);
 
     mlir::Value bufferizedExpr =
         packageBufferizedExpr(loc, builder, temp, cleanup);
     rewriter.replaceOp(elemental, bufferizedExpr);
     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} {}
+  // TODO: remove this. this was for use with `createCharExtremum`
+  /*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");
+    // It seems like we should be able to handle variadic args with a little
+    // more effort. For feedback though, see what folks think for the case where
+    // it's just 2 args.
+    if (adaptor.getStrings().size() > 2)
+      TODO(loc, "codegen of optimized chained char_extremum of more than two "
+                "strings");
+    hlfir::Entity lhs = getBufferizedExprStorage(adaptor.getStrings()[0]);
+    hlfir::Entity rhs = getBufferizedExprStorage(adaptor.getStrings()[1]);
+    auto [lhsExv, c1] = hlfir::translateToExtendedValue(loc, builder, lhs);
+    auto [rhsExv, c2] = hlfir::translateToExtendedValue(loc, builder, rhs);
+    assert(!c1 && !c2 && "expected variables");
+    // things are different here! `createConcatenate` drives the bus
+    fir::ExtendedValue res =
+        fir::factory::CharacterExprHelper{builder, loc}.createCharExtremum(
+            predIsMin, *lhsExv.getCharBox(), *rhsExv.getCharBox());
+    // Ensure the memory type is the same as the result type.
+    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",
+                                        fir::FortranVariableFlagsAttr{})
+                          .getBase()};
+    mlir::Value bufferizedExpr =
+        packageBufferizedExpr(loc, builder, hlfirTempRes, false);
+    rewriter.replaceOp(char_extremum, bufferizedExpr);
+    return mlir::success();
+  }*/
+  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}.createCharExtremum3(
+            predIsMin, opCBVs); //, resultType);
+    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",
+                                        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:
   void runOnOperation() override {
     // TODO: make this a pass operating on FuncOp. The issue is that
     // FirOpBuilder helpers may generate new FuncOp because of runtime/llvm
     // intrinsics calls creation. This may create race conflict if the pass is
     // scheduled on FuncOp. A solution could be to provide an optional mutex
     // when building a FirOpBuilder and locking around FuncOp and GlobalOp
     // creation, but this needs a bit more thinking, so at this point the pass
     // is scheduled on the moduleOp.
     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,
     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
     // conversion pattern to YieldElementOp itself. If any YieldElementOp
     // survives this pass, the verifier will detect it because it has to be
     // a child of ElementalOp and ElementalOp's are explicitly illegal.
     target.addIllegalOp<hlfir::ApplyOp, hlfir::AssociateOp, hlfir::ElementalOp,
                         hlfir::EndAssociateOp, hlfir::SetLengthOp>();

flang/test/HLFIR/char_extremum-bufferization.fir

+// Test hlfir.concat operation lowering to operations operating on memory.
+
+// RUN: fir-opt %s -bufferize-hlfir | FileCheck %s
+// XFAIL: *
+
+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
+}
+
+// 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 = arith.cmpi uge, %2#1, %4#1 : index
+//   %7 = arith.select %6, %2#1, %4#1 : index
+//   %8 = fir.convert %5#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %9 = fir.convert %3#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %10 = fir.convert %4#1 : (index) -> i64
+//   %11 = fir.convert %2#1 : (index) -> i64
+//   %12 = fir.call @_FortranACharacterCompareScalar1(%8, %9, %10, %11) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+//   %c0_i32 = arith.constant 0 : i32
+//   %13 = arith.cmpi sgt, %12, %c0_i32 : i32
+//   %14 = arith.select %13, %5#1, %3#1 : !fir.ref<!fir.char<1,?>>
+//   %15 = arith.select %13, %4#1, %2#1 : index
+//   %16 = fir.alloca !fir.char<1,?>(%7 : index) {bindc_name = ".chrtmp"}
+//   %c0 = arith.constant 0 : index
+//   %c1 = arith.constant 1 : index
+//   %17 = arith.subi %15, %c1 : index
+//   fir.do_loop %arg3 = %c0 to %17 step %c1 {
+//     %22 = fir.convert %14 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %23 = fir.coordinate_of %22, %arg3 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     %24 = fir.load %23 : !fir.ref<!fir.char<1>>
+//     %25 = fir.convert %16 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %26 = fir.coordinate_of %25, %arg3 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     fir.store %24 to %26 : !fir.ref<!fir.char<1>>
+//   }
+//   %18:2 = hlfir.declare %16 typeparams %7 {uniq_name = "tmp"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+//   %false = arith.constant false
+//   %19 = fir.undefined tuple<!fir.boxchar<1>, i1>
+//   %20 = fir.insert_value %19, %false, [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1>
+//   %21 = fir.insert_value %20, %18#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1>
+//   hlfir.assign %18#0 to %1#0 : !fir.boxchar<1>, !fir.boxchar<1>
+//   return
+// }
+
+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
+}
+
+// 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 = arith.cmpi uge, %2#1, %4#1 : index
+//   %7 = arith.select %6, %2#1, %4#1 : index
+//   %8 = fir.convert %5#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %9 = fir.convert %3#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %10 = fir.convert %4#1 : (index) -> i64
+//   %11 = fir.convert %2#1 : (index) -> i64
+//   %12 = fir.call @_FortranACharacterCompareScalar1(%8, %9, %10, %11) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+//   %c0_i32 = arith.constant 0 : i32
+//   %13 = arith.cmpi slt, %12, %c0_i32 : i32
+//   %14 = arith.select %13, %5#1, %3#1 : !fir.ref<!fir.char<1,?>>
+//   %15 = arith.select %13, %4#1, %2#1 : index
+//   %16 = fir.alloca !fir.char<1,?>(%7 : index) {bindc_name = ".chrtmp"}
+//   %c0 = arith.constant 0 : index
+//   %c1 = arith.constant 1 : index
+//   %17 = arith.subi %15, %c1 : index
+//   fir.do_loop %arg3 = %c0 to %17 step %c1 {
+//     %22 = fir.convert %14 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %23 = fir.coordinate_of %22, %arg3 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     %24 = fir.load %23 : !fir.ref<!fir.char<1>>
+//     %25 = fir.convert %16 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %26 = fir.coordinate_of %25, %arg3 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     fir.store %24 to %26 : !fir.ref<!fir.char<1>>
+//   }
+//   %18:2 = hlfir.declare %16 typeparams %7 {uniq_name = "tmp"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+//   %false = arith.constant false
+//   %19 = fir.undefined tuple<!fir.boxchar<1>, i1>
+//   %20 = fir.insert_value %19, %false, [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1>
+//   %21 = fir.insert_value %20, %18#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1>
+//   hlfir.assign %18#0 to %1#0 : !fir.boxchar<1>, !fir.boxchar<1>
+//   return
+// }
+
+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
+}
+
+// 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 = arith.cmpi uge, %c10, %c20 : index
+//   %15 = arith.select %14, %c10, %c20 : index
+//   %16 = fir.convert %13 : (!fir.ref<!fir.char<1,20>>) -> !fir.ref<i8>
+//   %17 = fir.convert %12 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
+//   %18 = fir.convert %c20 : (index) -> i64
+//   %19 = fir.convert %c10 : (index) -> i64
+//   %20 = fir.call @_FortranACharacterCompareScalar1(%16, %17, %18, %19) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+//   %c0_i32 = arith.constant 0 : i32
+//   %21 = arith.cmpi sgt, %20, %c0_i32 : i32
+//   %22 = fir.convert %12 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<!fir.char<1,?>>
+//   %23 = fir.convert %13 : (!fir.ref<!fir.char<1,20>>) -> !fir.ref<!fir.char<1,?>>
+//   %24 = arith.select %21, %23, %22 : !fir.ref<!fir.char<1,?>>
+//   %25 = arith.select %21, %c20, %c10 : index
+//   %26 = fir.alloca !fir.char<1,?>(%15 : index) {bindc_name = ".chrtmp"}
+//   %c0 = arith.constant 0 : index
+//   %c1_3 = arith.constant 1 : index
+//   %27 = arith.subi %25, %c1_3 : index
+//   fir.do_loop %arg3 = %c0 to %27 step %c1_3 {
+//     %34 = fir.convert %24 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %35 = fir.coordinate_of %34, %arg3 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     %36 = fir.load %35 : !fir.ref<!fir.char<1>>
+//     %37 = fir.convert %26 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %38 = fir.coordinate_of %37, %arg3 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     fir.store %36 to %38 : !fir.ref<!fir.char<1>>
+//   }
+//   %28 = fir.convert %26 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,20>>
+//   %29:2 = hlfir.declare %28 typeparams %15 {uniq_name = "tmp"} : (!fir.ref<!fir.char<1,20>>, index) -> (!fir.ref<!fir.char<1,20>>, !fir.ref<!fir.char<1,20>>)
+//   %false = arith.constant false
+//   %30 = fir.undefined tuple<!fir.ref<!fir.char<1,20>>, i1>
+//   %31 = fir.insert_value %30, %false, [1 : index] : (tuple<!fir.ref<!fir.char<1,20>>, i1>, i1) -> tuple<!fir.ref<!fir.char<1,20>>, i1>
+//   %32 = fir.insert_value %31, %29#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>
+//   %c1_4 = arith.constant 1 : index
+//   %33 = hlfir.designate %3#0 (%c1_4)  typeparams %0#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+//   hlfir.assign %29#0 to %33 : !fir.ref<!fir.char<1,20>>, !fir.boxchar<1>
+//   return
+// }
+
+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
+}
+
+// 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 = arith.cmpi uge, %c10, %c20 : index
+//   %15 = arith.select %14, %c10, %c20 : index
+//   %16 = fir.convert %13 : (!fir.ref<!fir.char<1,20>>) -> !fir.ref<i8>
+//   %17 = fir.convert %12 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<i8>
+//   %18 = fir.convert %c20 : (index) -> i64
+//   %19 = fir.convert %c10 : (index) -> i64
+//   %20 = fir.call @_FortranACharacterCompareScalar1(%16, %17, %18, %19) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+//   %c0_i32 = arith.constant 0 : i32
+//   %21 = arith.cmpi slt, %20, %c0_i32 : i32
+//   %22 = fir.convert %12 : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<!fir.char<1,?>>
+//   %23 = fir.convert %13 : (!fir.ref<!fir.char<1,20>>) -> !fir.ref<!fir.char<1,?>>
+//   %24 = arith.select %21, %23, %22 : !fir.ref<!fir.char<1,?>>
+//   %25 = arith.select %21, %c20, %c10 : index
+//   %26 = fir.alloca !fir.char<1,?>(%15 : index) {bindc_name = ".chrtmp"}
+//   %c0 = arith.constant 0 : index
+//   %c1_3 = arith.constant 1 : index
+//   %27 = arith.subi %25, %c1_3 : index
+//   fir.do_loop %arg3 = %c0 to %27 step %c1_3 {
+//     %34 = fir.convert %24 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %35 = fir.coordinate_of %34, %arg3 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     %36 = fir.load %35 : !fir.ref<!fir.char<1>>
+//     %37 = fir.convert %26 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %38 = fir.coordinate_of %37, %arg3 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     fir.store %36 to %38 : !fir.ref<!fir.char<1>>
+//   }
+//   %28 = fir.convert %26 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.char<1,20>>
+//   %29:2 = hlfir.declare %28 typeparams %15 {uniq_name = "tmp"} : (!fir.ref<!fir.char<1,20>>, index) -> (!fir.ref<!fir.char<1,20>>, !fir.ref<!fir.char<1,20>>)
+//   %false = arith.constant false
+//   %30 = fir.undefined tuple<!fir.ref<!fir.char<1,20>>, i1>
+//   %31 = fir.insert_value %30, %false, [1 : index] : (tuple<!fir.ref<!fir.char<1,20>>, i1>, i1) -> tuple<!fir.ref<!fir.char<1,20>>, i1>
+//   %32 = fir.insert_value %31, %29#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>
+//   %c1_4 = arith.constant 1 : index
+//   %33 = hlfir.designate %3#0 (%c1_4)  typeparams %0#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+//   hlfir.assign %29#0 to %33 : !fir.ref<!fir.char<1,20>>, !fir.boxchar<1>
+//   return
+// }
+
+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
+}
+
+// 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 = arith.cmpi uge, %2#1, %4#1 : index
+//   %9 = arith.select %8, %2#1, %4#1 : index
+//   %10 = fir.convert %5#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %11 = fir.convert %3#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %12 = fir.convert %4#1 : (index) -> i64
+//   %13 = fir.convert %2#1 : (index) -> i64
+//   %14 = fir.call @_FortranACharacterCompareScalar1(%10, %11, %12, %13) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+//   %c0_i32 = arith.constant 0 : i32
+//   %15 = arith.cmpi sgt, %14, %c0_i32 : i32
+//   %16 = arith.select %15, %5#1, %3#1 : !fir.ref<!fir.char<1,?>>
+//   %17 = arith.select %15, %4#1, %2#1 : index
+//   %18 = arith.cmpi uge, %9, %6#1 : index
+//   %19 = arith.select %18, %9, %6#1 : index
+//   %20 = fir.convert %7#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %21 = fir.convert %16 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %22 = fir.convert %6#1 : (index) -> i64
+//   %23 = fir.convert %17 : (index) -> i64
+//   %24 = fir.call @_FortranACharacterCompareScalar1(%20, %21, %22, %23) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+//   %c0_i32_0 = arith.constant 0 : i32
+//   %25 = arith.cmpi sgt, %24, %c0_i32_0 : i32
+//   %26 = arith.select %25, %7#1, %16 : !fir.ref<!fir.char<1,?>>
+//   %27 = arith.select %25, %6#1, %17 : index
+//   %28 = fir.alloca !fir.char<1,?>(%19 : index) {bindc_name = ".chrtmp"}
+//   %c0 = arith.constant 0 : index
+//   %c1 = arith.constant 1 : index
+//   %29 = arith.subi %27, %c1 : index
+//   fir.do_loop %arg4 = %c0 to %29 step %c1 {
+//     %34 = fir.convert %26 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %35 = fir.coordinate_of %34, %arg4 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     %36 = fir.load %35 : !fir.ref<!fir.char<1>>
+//     %37 = fir.convert %28 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %38 = fir.coordinate_of %37, %arg4 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     fir.store %36 to %38 : !fir.ref<!fir.char<1>>
+//   }
+//   %30:2 = hlfir.declare %28 typeparams %19 {uniq_name = "tmp"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+//   %false = arith.constant false
+//   %31 = fir.undefined tuple<!fir.boxchar<1>, i1>
+//   %32 = fir.insert_value %31, %false, [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1>
+//   %33 = fir.insert_value %32, %30#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1>
+//   hlfir.assign %30#0 to %1#0 : !fir.boxchar<1>, !fir.boxchar<1>
+//   return
+// }
+
+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
+}
+
+// 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 = arith.cmpi uge, %2#1, %4#1 : index
+//   %9 = arith.select %8, %2#1, %4#1 : index
+//   %10 = fir.convert %5#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %11 = fir.convert %3#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %12 = fir.convert %4#1 : (index) -> i64
+//   %13 = fir.convert %2#1 : (index) -> i64
+//   %14 = fir.call @_FortranACharacterCompareScalar1(%10, %11, %12, %13) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+//   %c0_i32 = arith.constant 0 : i32
+//   %15 = arith.cmpi slt, %14, %c0_i32 : i32
+//   %16 = arith.select %15, %5#1, %3#1 : !fir.ref<!fir.char<1,?>>
+//   %17 = arith.select %15, %4#1, %2#1 : index
+//   %18 = arith.cmpi uge, %9, %6#1 : index
+//   %19 = arith.select %18, %9, %6#1 : index
+//   %20 = fir.convert %7#1 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %21 = fir.convert %16 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+//   %22 = fir.convert %6#1 : (index) -> i64
+//   %23 = fir.convert %17 : (index) -> i64
+//   %24 = fir.call @_FortranACharacterCompareScalar1(%20, %21, %22, %23) : (!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32
+//   %c0_i32_0 = arith.constant 0 : i32
+//   %25 = arith.cmpi slt, %24, %c0_i32_0 : i32
+//   %26 = arith.select %25, %7#1, %16 : !fir.ref<!fir.char<1,?>>
+//   %27 = arith.select %25, %6#1, %17 : index
+//   %28 = fir.alloca !fir.char<1,?>(%19 : index) {bindc_name = ".chrtmp"}
+//   %c0 = arith.constant 0 : index
+//   %c1 = arith.constant 1 : index
+//   %29 = arith.subi %27, %c1 : index
+//   fir.do_loop %arg4 = %c0 to %29 step %c1 {
+//     %34 = fir.convert %26 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %35 = fir.coordinate_of %34, %arg4 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     %36 = fir.load %35 : !fir.ref<!fir.char<1>>
+//     %37 = fir.convert %28 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
+//     %38 = fir.coordinate_of %37, %arg4 : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
+//     fir.store %36 to %38 : !fir.ref<!fir.char<1>>
+//   }
+//   %30:2 = hlfir.declare %28 typeparams %19 {uniq_name = "tmp"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+//   %false = arith.constant false
+//   %31 = fir.undefined tuple<!fir.boxchar<1>, i1>
+//   %32 = fir.insert_value %31, %false, [1 : index] : (tuple<!fir.boxchar<1>, i1>, i1) -> tuple<!fir.boxchar<1>, i1>
+//   %33 = fir.insert_value %32, %30#0, [0 : index] : (tuple<!fir.boxchar<1>, i1>, !fir.boxchar<1>) -> tuple<!fir.boxchar<1>, i1>
+//   hlfir.assign %30#0 to %1#0 : !fir.boxchar<1>, !fir.boxchar<1>
+//   return
+// }
+// func.func private @_FortranACharacterCompareScalar1(!fir.ref<i8>, !fir.ref<i8>, i64, i64) -> i32 attributes {fir.runtime}
 No newline at end of file

flang/test/HLFIR/char_extremum.fir

+// 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>>
+

flang/test/Lower/HLFIR/char_extremum.f03

+! Test lowering of the max and min intrinsics on character types to HLFIR
+! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+
+subroutine max1(c1, c2, c3)
+  character(*) :: c1, c2, c3
+  c1 = max(c2,c3)
+end subroutine
+
+! CHECK-LABEL: func.func @_QPmax1
+! CHECK:  %[[VAL_0:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_1:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_0]]#0 typeparams %[[VAL_0]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_2:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_3:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_2]]#0 typeparams %[[VAL_2]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_4:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_5:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_4]]#0 typeparams %[[VAL_4]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_6:[a-zA-Z0-9_]*]] = hlfir.char_extremum max, %[[VAL_3]]#0, %[[VAL_5]]#0 : (!fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+! CHECK:  hlfir.assign %[[VAL_6]] to %[[VAL_1]]#0 : !hlfir.expr<!fir.char<1,?>>, !fir.boxchar<1>
+! CHECK:  hlfir.destroy %[[VAL_6]] : !hlfir.expr<!fir.char<1,?>>
+
+subroutine min1(c1, c2, c3)
+  character(*) :: c1, c2, c3
+  c1 = min(c2,c3)
+end subroutine
+! CHECK-LABEL: func.func @_QPmin1
+! CHECK:  %[[VAL_0:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_1:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_0]]#0 typeparams %[[VAL_0]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_2:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_3:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_2]]#0 typeparams %[[VAL_2]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_4:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_5:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_4]]#0 typeparams %[[VAL_4]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_6:[a-zA-Z0-9_]*]] = hlfir.char_extremum min, %[[VAL_3]]#0, %[[VAL_5]]#0 : (!fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+! CHECK:  hlfir.assign %[[VAL_6]] to %[[VAL_1]]#0 : !hlfir.expr<!fir.char<1,?>>, !fir.boxchar<1>
+! CHECK:  hlfir.destroy %[[VAL_6]] : !hlfir.expr<!fir.char<1,?>>
+! CHECK:  return
+
+subroutine max2(c1, c2, c3)
+  character(*) :: c1(100)
+  character :: c2(100)*10, c3(100)*20
+  c1(1) = max(c2(1),c3(1))
+end subroutine
+! CHECK-LABEL:  func.func @_QPmax2
+! CHECK:  %[[VAL_0:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_1:[a-zA-Z0-9_]*]] = fir.convert %[[VAL_0]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,?>>>
+! CHECK:  %[[VAL_C100:[a-zA-Z0-9_]*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_2:[a-zA-Z0-9_]*]]  = fir.shape %[[VAL_C100]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_3:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_2]]) typeparams %[[VAL_0]]#1 {{.*}} : (!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:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_C10:[a-zA-Z0-9_]*]] = arith.constant 10 : index
+! CHECK:  %[[VAL_5:[a-zA-Z0-9_]*]] = fir.convert %[[VAL_4]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,10>>>
+! CHECK:  %[[VAL_C100_0:[a-zA-Z0-9_]*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_6:[a-zA-Z0-9_]*]] = fir.shape %[[VAL_C100_0]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_7:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_6]]) typeparams %[[VAL_C10]] {{.*}} : (!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:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_C20:[a-zA-Z0-9_]*]] = arith.constant 20 : index
+! CHECK:  %[[VAL_9:[a-zA-Z0-9_]*]] = fir.convert %[[VAL_8]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,20>>>
+! CHECK:  %[[VAL_C100_1:[a-zA-Z0-9_]*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_10:[a-zA-Z0-9_]*]] = fir.shape %[[VAL_C100_1]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_11:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_9]](%[[VAL_10]]) typeparams %[[VAL_C20]] {{.*}} : (!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:  %[[VAL_C1:[a-zA-Z0-9_]*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_12:[a-zA-Z0-9_]*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_C1]])  typeparams %[[VAL_C10]] : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, index, index) -> !fir.ref<!fir.char<1,10>>
+! CHECK:  %[[VAL_C1_2:[a-zA-Z0-9_]*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_13:[a-zA-Z0-9_]*]] = hlfir.designate %[[VAL_11]]#0 (%[[VAL_C1_2]])  typeparams %[[VAL_C20]] : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, index, index) -> !fir.ref<!fir.char<1,20>>
+! CHECK:  %[[VAL_14:[a-zA-Z0-9_]*]] = hlfir.char_extremum max, %[[VAL_12]], %[[VAL_13]] : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,20>>
+! CHECK:  %c1_3 = arith.constant 1 : index
+! CHECK:  %[[VAL_15:[a-zA-Z0-9_]*]] = hlfir.designate %[[VAL_3]]#0 (%c1_3)  typeparams %[[VAL_0]]#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+! CHECK:  hlfir.assign %[[VAL_14]] to %[[VAL_15]] : !hlfir.expr<!fir.char<1,20>>, !fir.boxchar<1>
+! CHECK:  hlfir.destroy %[[VAL_14]] : !hlfir.expr<!fir.char<1,20>>
+
+subroutine min2(c1, c2, c3)
+  character(*) :: c1(100)
+  character :: c2(100)*10, c3(100)*20
+  c1(1) = min(c2(1),c3(1))
+end subroutine
+! CHECK-LABEL: func.func @_QPmin2
+! CHECK:  %[[VAL_0:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_1:[a-zA-Z0-9_]*]] = fir.convert %[[VAL_0]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,?>>>
+! CHECK:  %[[VAL_C100:[a-zA-Z0-9_]*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_2:[a-zA-Z0-9_]*]] = fir.shape %[[VAL_C100]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_3:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_2]]) typeparams %[[VAL_0]]#1 {{.*}} : (!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:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_C10:[a-zA-Z0-9_]*]] = arith.constant 10 : index
+! CHECK:  %[[VAL_5:[a-zA-Z0-9_]*]] = fir.convert %[[VAL_4]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,10>>>
+! CHECK:  %[[VAL_C100_0:[a-zA-Z0-9_]*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_6:[a-zA-Z0-9_]*]] = fir.shape %[[VAL_C100_0]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_7:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_5]](%[[VAL_6]]) typeparams %[[VAL_C10]] {{.*}} : (!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:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg2 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_C20:[a-zA-Z0-9_]*]] = arith.constant 20 : index
+! CHECK:  %[[VAL_C9:[a-zA-Z0-9_]*]] = fir.convert %[[VAL_8]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<100x!fir.char<1,20>>>
+! CHECK:  %[[VAL_C100_1:[a-zA-Z0-9_]*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_10:[a-zA-Z0-9_]*]] = fir.shape %[[VAL_C100_1]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_11:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_C9]](%[[VAL_10]]) typeparams %[[VAL_C20]] {{.*}} : (!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:  %[[VAL_C1:[a-zA-Z0-9_]*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_12:[a-zA-Z0-9_]*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_C1]])  typeparams %[[VAL_C10]] : (!fir.ref<!fir.array<100x!fir.char<1,10>>>, index, index) -> !fir.ref<!fir.char<1,10>>
+! CHECK:  %[[VAL_C1_2:[a-zA-Z0-9_]*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_13:[a-zA-Z0-9_]*]] = hlfir.designate %[[VAL_11]]#0 (%[[VAL_C1_2]])  typeparams %[[VAL_C20]] : (!fir.ref<!fir.array<100x!fir.char<1,20>>>, index, index) -> !fir.ref<!fir.char<1,20>>
+! CHECK:  %[[VAL_14:[a-zA-Z0-9_]*]] = hlfir.char_extremum min, %[[VAL_12]], %[[VAL_13]] : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,20>>
+! CHECK:  %[[VAL_C1_3:[a-zA-Z0-9_]*]] = arith.constant 1 : index
+! CHECK:  %[[VAL_15:[a-zA-Z0-9_]*]] = hlfir.designate %[[VAL_3]]#0 (%[[VAL_C1_3]])  typeparams %[[VAL_0]]#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+! CHECK:  hlfir.assign %[[VAL_14]] to %[[VAL_15]] : !hlfir.expr<!fir.char<1,20>>, !fir.boxchar<1>
+! CHECK:  hlfir.destroy %[[VAL_14]] : !hlfir.expr<!fir.char<1,20>>
+
+subroutine max3(c1, c2, c3, c4)
+  character(*) :: c1, c2, c3, c4
+  c1 = max(c2, c3, c4)
+end subroutine
+! CHECK-LABEL: func.func @_QPmax3
+! CHECK:  %[[VAL_0:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_1:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_0]]#0 typeparams %[[VAL_0]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_2:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_3:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_2]]#0 typeparams %[[VAL_2]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_4:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg2 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_5:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_4]]#0 typeparams %[[VAL_4]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_6:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg3 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_7:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_6]]#0 typeparams %[[VAL_6]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_8:[a-zA-Z0-9_]*]] = hlfir.char_extremum max, %[[VAL_3]]#0, %[[VAL_5]]#0, %[[VAL_7]]#0 : (!fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+! CHECK:  hlfir.assign %[[VAL_8]] to %[[VAL_1]]#0 : !hlfir.expr<!fir.char<1,?>>, !fir.boxchar<1>
+! CHECK:  hlfir.destroy %[[VAL_8]] : !hlfir.expr<!fir.char<1,?>>
+
+subroutine min3(c1, c2, c3, c4)
+  character(*) :: c1, c2, c3, c4
+  c1 = min(c2, c3, c4)
+end subroutine
+! CHECK-LABEL: func.func @_QPmin3
+! CHECK:  %[[VAL_0:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg0 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_1:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_0]]#0 typeparams %[[VAL_0]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_2:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg1 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_3:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_2]]#0 typeparams %[[VAL_2]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_4:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg2 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_5:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_4]]#0 typeparams %[[VAL_4]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_6:[a-zA-Z0-9_]*]]:2 = fir.unboxchar %arg3 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_7:[a-zA-Z0-9_]*]]:2 = hlfir.declare %[[VAL_6]]#0 typeparams %[[VAL_6]]#1 {{.*}} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+! CHECK:  %[[VAL_8:[a-zA-Z0-9_]*]] = hlfir.char_extremum min, %[[VAL_3]]#0, %[[VAL_5]]#0, %[[VAL_7]]#0 : (!fir.boxchar<1>, !fir.boxchar<1>, !fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+! CHECK:  hlfir.assign %[[VAL_8]] to %[[VAL_1]]#0 : !hlfir.expr<!fir.char<1,?>>, !fir.boxchar<1>
+! CHECK:  hlfir.destroy %[[VAL_8]] : !hlfir.expr<!fir.char<1,?>>