[fir] Add !fir.char type conversion

[rovka]

Summary

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

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

[clementval]

LGTM. Thanks

[clementval]

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

66

Nit: add a blank line after the comment like other tests.

[awarzynski]

flang/lib/Optimizer/CodeGen/TypeConverter.h

159

[nit] Shouldn't this be:

• !fir.char<n, 12> --> !llvm.array<12 x ix*>
• !fir.char<n, ?> --> ix*

instead?

[rovka]

flang/lib/Optimizer/CodeGen/TypeConverter.h

159

Actually, now that you mention it, I'm noticing we're doing !fir.char<n, ?> -> ix, not ix*. Are we supposed to return LLVMPointerType::get(iTy) instead?

[awarzynski]

flang/lib/Optimizer/CodeGen/TypeConverter.h

159

Are we supposed to return LLVMPointerType::get(iTy) instead?

I don't know the answer to this question, but making the comment consistent with the implementation (and the tests) will make any potential debugging easier :-)

[rovka]

Fixed with commit 81c99c5404c1

So, to answer my own question, stuff in fir-dev seems to know when it needs to add a pointer, and I think a "plain" !fir.char is never expected as a function parameter. I'm not sure if there's a less misleading way to write a test for this.

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(
+        [&](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); });
     addConversion(
         [&](fir::RecordType derived) { return convertRecordType(derived); });
if (requiresExtendedDesc(ele)) {
               mlir::LLVM::LLVMArrayType::get(rowTy, numLenParams));
         }
     }
     return mlir::LLVM::LLVMPointerType::get(
         mlir::LLVM::LLVMStructType::getLiteral(&getContext(), dataDescFields,
                                                /*isPacked=*/false));
   }
 
+  unsigned characterBitsize(fir::CharacterType charTy) {
+    return kindMapping.getCharacterBitsize(charTy.getFKind());
+  }
+
+  // fir.char<n>  -->  llvm<"ix*">   where ix is scaled by kind mapping
+  mlir::Type convertCharType(fir::CharacterType charTy) {
+    auto iTy = mlir::IntegerType::get(&getContext(), characterBitsize(charTy));
+    if (charTy.getLen() == fir::CharacterType::unknownLen())
+      return iTy;
+    return mlir::LLVM::LLVMArrayType::get(iTy, charTy.getLen());
+  }
+
   // Use the target specifics to figure out how to map complex to LLVM IR. The
   // use of complex values in function signatures is handled before conversion
   // to LLVM IR dialect here.
   //
   // fir.complex<T> | std.complex<T>    --> llvm<"{t,t}">
   template <typename C>
   mlir::Type convertComplexType(C cmplx) {
     LLVM_DEBUG(llvm::dbgs() << "type convert: " << cmplx << '\n');

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

 // CHECK-SAME: !llvm.ptr<struct<(ptr<i64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>
 
 func private @foo3(%arg0: !fir.box<!fir.type<derived{f:f32}>>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: !llvm.ptr<struct<(ptr<struct<"derived", (f32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>>
 
 // -----
 
+// Test char types `!fir.char<k, n>`
+
+func private @foo0(%arg0: !fir.char<1, 4>, %arg1: !fir.char<1, ?>)
+// CHECK-LABEL: foo0
+// CHECK-SAME: !llvm.array<4 x i8>
+// CHECK-SAME: i8
+
+func private @foo1(%arg0: !fir.char<2, 12>, %arg1: !fir.char<2, ?>)
+// CHECK-LABEL: foo1
+// CHECK-SAME: !llvm.array<12 x i16>
+// CHECK-SAME: i16
+
+func private @foo2(%arg0: !fir.char<4, 8>, %arg1: !fir.char<4, ?>)
+// CHECK-LABEL: foo2
+// CHECK-SAME: !llvm.array<8 x i32>
+// CHECK-SAME: i32
+
+// -----
+
 // Test `!fir.logical<KIND>` conversion.
 
 func private @foo0(%arg0: !fir.logical<1>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: i8
 
 func private @foo1(%arg0: !fir.logical<2>)
 // CHECK-LABEL: foo1