[flang][codegen] Add type conversion for `fir.boxchar`

[awarzynski]

Summary

This is part of the upstreaming effort from the fir-dev branch in [1].

[1] https://github.com/flang-compiler/f18-llvm-project

Patch originally written by:
Co-authored-by: Eric Schweitz <[e-mail]>
Co-authored-by: Jean Perier <[e-mail]>

[clementval]

LGTM

flang/lib/Optimizer/CodeGen/Target.h

public:
   /// value. An argument value may need to be passed as a (safe) reference
   /// argument.
   virtual Marshalling complexArgumentType(mlir::Type eleTy) const = 0;
 
   /// Type representation of a `complex<eleTy>` type return value. Such a return
   /// value may need to be converted to a hidden reference argument.
   virtual Marshalling complexReturnType(mlir::Type eleTy) const = 0;
 
+  /// Type presentation of a `boxchar<n>` type value in memory.
+  virtual mlir::Type boxcharMemoryType(mlir::Type eleTy) const = 0;
+
   /// Type representation of a `boxchar<n>` type argument when passed by value.
   /// An argument value may need to be passed as a (safe) reference argument.
   ///
   /// A function that returns a `boxchar<n>` type value must already have
   /// converted that return value to a parameter decorated with the 'sret'
   /// Attribute (https://llvm.org/docs/LangRef.html#parameter-attributes).
   /// This requirement is in keeping with Fortran semantics, which require the
   /// caller to allocate the space for the return CHARACTER value and pass

flang/lib/Optimizer/CodeGen/Target.cpp

struct GenericTarget : public CodeGenSpecifics {
 
   mlir::Type complexMemoryType(mlir::Type eleTy) const override {
     assert(fir::isa_real(eleTy));
     // { t, t }   struct of 2 eleTy
     mlir::TypeRange range = {eleTy, eleTy};
     return mlir::TupleType::get(eleTy.getContext(), range);
   }
 
+  mlir::Type boxcharMemoryType(mlir::Type eleTy) const override {
+    auto idxTy = mlir::IntegerType::get(eleTy.getContext(), S::defaultWidth);
+    auto ptrTy = fir::ReferenceType::get(eleTy);
+    // { t*, index }
+    mlir::TypeRange range = {ptrTy, idxTy};
+    return mlir::TupleType::get(eleTy.getContext(), range);
+  }
+
   Marshalling boxcharArgumentType(mlir::Type eleTy, bool sret) const override {
     CodeGenSpecifics::Marshalling marshal;
     auto idxTy = mlir::IntegerType::get(eleTy.getContext(), S::defaultWidth);
     auto ptrTy = fir::ReferenceType::get(eleTy);
     marshal.emplace_back(ptrTy, AT{});
     // Return value arguments are grouped as a pair. Others are passed in a
     // split format with all pointers first (in the declared position) and all
     // LEN arguments appended after all of the dummy arguments.

flang/lib/Optimizer/CodeGen/TypeConverter.h

LLVMTypeConverter(mlir::ModuleOp module)
         kindMapping(getKindMapping(module)),
         specifics(CodeGenSpecifics::get(module.getContext(),
                                         getTargetTriple(module),
                                         getKindMapping(module))) {
     LLVM_DEBUG(llvm::dbgs() << "FIR type converter\n");
 
     // Each conversion should return a value of type mlir::Type.
     addConversion([&](BoxType box) { return convertBoxType(box); });
+    addConversion([&](BoxCharType boxchar) {
+      LLVM_DEBUG(llvm::dbgs() << "type convert: " << boxchar << '\n');
+      return convertType(specifics->boxcharMemoryType(boxchar.getEleTy()));
+    });
     addConversion(
         [&](fir::CharacterType charTy) { return convertCharType(charTy); });
     addConversion([&](fir::LogicalType boolTy) {
       return mlir::IntegerType::get(
           &getContext(), kindMapping.getLogicalBitsize(boolTy.getFKind()));
     });
     addConversion(
         [&](fir::PointerType pointer) { return convertPointerLike(pointer); });

flang/test/Fir/types-to-llvm.fir

 
 func private @foo15(%arg0: !fir.vector<2:!fir.real<10>>)
 // CHECK-LABEL: foo15
 // CHECK-SAME: vector<2xf80>
 
 func private @foo16(%arg0: !fir.vector<2:!fir.real<16>>)
 // CHECK-LABEL: foo16
 // CHECK-SAME: vector<2xf128>
+
+// -----
+
+// Test `!fir.boxchar<n>` conversion
+
+func private @foo0(%arg0: !fir.boxchar<1>)
+// CHECK-LABEL: foo0
+// CHECK-SAME: !llvm.struct<(ptr<i8>, i64)>
+
+func private @foo1(%arg0: !fir.boxchar<2>)
+// CHECK-LABEL: foo1
+// CHECK-SAME: !llvm.struct<(ptr<i16>, i64)>