[flang] Handle boxed characters that are values when doing a conversion

[clementval]

Summary

Character conversion requires memory storage as it operates on a
sequence of code points.

This patch is part of the upstreaming effort from fir-dev branch.

Co-authored-by: Eric Schweitz <[e-mail]>

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Lower/ConvertExpr.cpp

return fromExpr.match(
                         TC2 == TC1) {
             // Use char_convert. Each code point is translated from a
             // narrower/wider encoding to the target encoding. For example, 'A'
             // may be translated from 0x41 : i8 to 0x0041 : i16. The symbol
             // for euro (0x20AC : i16) may be translated from a wide character
             // to "0xE2 0x82 0xAC" : UTF-8.
             mlir::Value bufferSize = boxchar.getLen();
             auto kindMap = builder.getKindMap();
-            auto fromBits = kindMap.getCharacterBitsize(
-                fir::unwrapRefType(boxchar.getAddr().getType())
+            mlir::Value boxCharAddr = boxchar.getAddr();
+            auto fromTy = boxCharAddr.getType();
+            if (auto charTy = fromTy.dyn_cast<fir::CharacterType>()) {
+              // boxchar is a value, not a variable. Turn it into a temporary.
+              // As a value, it ought to have a constant LEN value.
+              assert(charTy.hasConstantLen() && "must have constant length");
+              mlir::Value tmp = builder.createTemporary(loc, charTy);
+              builder.create<fir::StoreOp>(loc, boxCharAddr, tmp);
+              boxCharAddr = tmp;
+            }
+            auto fromBits =
+                kindMap.getCharacterBitsize(fir::unwrapRefType(fromTy)
                                                 .cast<fir::CharacterType>()
                                                 .getFKind());
             auto toBits = kindMap.getCharacterBitsize(
                 ty.cast<fir::CharacterType>().getFKind());
             if (toBits < fromBits) {
               // Scale by relative ratio to give a buffer of the same length.
               auto ratio = builder.createIntegerConstant(
                   loc, bufferSize.getType(), fromBits / toBits);
               bufferSize =
                   builder.create<mlir::arith::MulIOp>(loc, bufferSize, ratio);
             }
             auto dest = builder.create<fir::AllocaOp>(
                 loc, ty, mlir::ValueRange{bufferSize});
-            builder.create<fir::CharConvertOp>(loc, boxchar.getAddr(),
+            builder.create<fir::CharConvertOp>(loc, boxCharAddr,
                                                boxchar.getLen(), dest);
             return fir::CharBoxValue{dest, boxchar.getLen()};
           } else {
             fir::emitFatalError(
                 loc, "unsupported evaluate::Convert between CHARACTER type "
                      "category and non-CHARACTER category");
           }
         },

flang/test/Fir/achar.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+! Tests ACHAR lowering (converting an INTEGER to a CHARACTER (singleton, LEN=1)
+! along with conversion of CHARACTER to another KIND.
+subroutine achar_test1(a)
+  integer, parameter :: ckind = 2
+  integer, intent(in) :: a
+  character(kind=ckind, len=1) :: ch
+
+  ch = achar(a)
+  call achar_test1_foo(ch)
+end subroutine achar_test1
+
+! CHECK-LABEL: func @_QPachar_test1(
+! CHECK-SAME: %[[arg:.*]]: !fir.ref<i32> {fir.bindc_name = "a"}) {
+! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.char<1>
+! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.char<2> {bindc_name = "ch", uniq_name = "_QFachar_test1Ech"}
+! CHECK: %[[VAL_2:.*]] = fir.load %[[arg]] : !fir.ref<i32>
+! CHECK: %[[VAL_5:.*]] = fir.undefined !fir.char<1>
+! CHECK: %[[VAL_6:.*]] = fir.insert_value %[[VAL_5]], %{{.*}}, [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
+! CHECK: fir.store %[[VAL_6]] to %[[VAL_0]] : !fir.ref<!fir.char<1>>
+! CHECK: %[[VAL_7:.*]] = fir.alloca !fir.char<2,?>(%{{.*}} : index)
+! CHECK: fir.char_convert %[[VAL_0]] for %{{.*}} to %[[VAL_7]] : !fir.ref<!fir.char<1>>, index, !fir.ref<!fir.char<2,?>>
+! CHECK: fir.call @_QPachar_test1_foo(%{{.*}}) : (!fir.boxchar<2>) -> ()