[flang] Fix bugs relating to support for characters of different kinds

[clementval]

Summary

Fix bugs relating to support for characters of different kinds. Lowering
was creating bad FIR and MLIR that crashed in conversion to LLVM IR.

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

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

[jeanPerier]

LGTM

flang/lib/Optimizer/Dialect/FIROps.cpp

if (fir::isa_unknown_size_box(getValue().getType()))
     return emitOpError("cannot store !fir.box of unknown rank or type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // StringLitOp
 //===----------------------------------------------------------------------===//
 
-bool fir::StringLitOp::isWideValue() {
-  auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
-  return eleTy.cast<fir::CharacterType>().getFKind() != 1;
+inline fir::CharacterType::KindTy stringLitOpGetKind(fir::StringLitOp op) {
+  auto eleTy = op.getType().cast<fir::SequenceType>().getEleTy();
+  return eleTy.cast<fir::CharacterType>().getFKind();
 }
 
+bool fir::StringLitOp::isWideValue() { return stringLitOpGetKind(*this) != 1; }
+
 static mlir::NamedAttribute
 mkNamedIntegerAttr(mlir::OpBuilder &builder, llvm::StringRef name, int64_t v) {
   assert(v > 0);
   return builder.getNamedAttr(
       name, builder.getIntegerAttr(builder.getIntegerType(64), v));
 }
 
 void fir::StringLitOp::build(mlir::OpBuilder &builder,
mlir::ParseResult fir::StringLitOp::parse(mlir::OpAsmParser &parser,
   mlir::Attribute val;
   mlir::NamedAttrList attrs;
   llvm::SMLoc trailingTypeLoc;
   if (parser.parseAttribute(val, "fake", attrs))
     return mlir::failure();
   if (auto v = val.dyn_cast<mlir::StringAttr>())
     result.attributes.push_back(
         builder.getNamedAttr(fir::StringLitOp::value(), v));
+  else if (auto v = val.dyn_cast<mlir::DenseElementsAttr>())
+    result.attributes.push_back(
+        builder.getNamedAttr(fir::StringLitOp::xlist(), v));
   else if (auto v = val.dyn_cast<mlir::ArrayAttr>())
     result.attributes.push_back(
         builder.getNamedAttr(fir::StringLitOp::xlist(), v));
   else
     return parser.emitError(parser.getCurrentLocation(),
                             "found an invalid constant");
   mlir::IntegerAttr sz;
   mlir::Type type;
void fir::StringLitOp::print(mlir::OpAsmPrinter &p) {
   p << getSize().cast<mlir::IntegerAttr>().getValue() << ") : ";
   p.printType(getType());
 }
 
 mlir::LogicalResult fir::StringLitOp::verify() {
   if (getSize().cast<mlir::IntegerAttr>().getValue().isNegative())
     return emitOpError("size must be non-negative");
   if (auto xl = getOperation()->getAttr(fir::StringLitOp::xlist())) {
-    auto xList = xl.cast<mlir::ArrayAttr>();
+    if (auto xList = xl.dyn_cast<mlir::ArrayAttr>()) {
       for (auto a : xList)
         if (!a.isa<mlir::IntegerAttr>())
-        return emitOpError("values in list must be integers");
+          return emitOpError("values in initializer must be integers");
+    } else if (xl.isa<mlir::DenseElementsAttr>()) {
+      // do nothing
+    } else {
+      return emitOpError("has unexpected attribute");
+    }
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // UnboxProcOp
 //===----------------------------------------------------------------------===//
 

flang/test/Fir/invalid.fir

 // FIR ops diagnotic tests
 
 // RUN: fir-opt -split-input-file -verify-diagnostics %s
 
 // expected-error@+1{{custom op 'fir.string_lit' must have character type}}
 %0 = fir.string_lit "Hello, World!"(13) : !fir.int<32>
 
 // -----
 
 // expected-error@+1{{custom op 'fir.string_lit' found an invalid constant}}
 %0 = fir.string_lit 20(13) : !fir.int<32>
 
 // -----
 
-// expected-error@+1{{'fir.string_lit' op values in list must be integers}}
+// expected-error@+1{{'fir.string_lit' op values in initializer must be integers}}
 %2 = fir.string_lit [158, 2.0](2) : !fir.char<2>
 
 // -----
 
 func.func @bad_rebox_1(%arg0: !fir.ref<!fir.array<?x?xf32>>) {
   %c10 = arith.constant 10 : index
   %0 = fir.shape %c10 : (index) -> !fir.shape<1>
   // expected-error@+1{{op operand #0 must be The type of a Fortran descriptor, but got '!fir.ref<!fir.array<?x?xf32>>'}}

flang/test/Lower/array-wide-char.f90

+! RUN: bbc %s -o - | tco | FileCheck %s
+
+character(LEN=128, KIND=4), PARAMETER :: conarr(3) = &
+     [ character(128,4) :: "now is the time", "for all good men to come", &
+     "to the aid of the country" ]       
+character(LEN=10, KIND=4) :: arr(3) = &
+     [ character(10,4) :: "good buddy", "best buddy", " " ]
+call action_on_char4(conarr)
+call action_on_char4(arr)
+end program
+
+subroutine sub1
+  integer, parameter :: k = 4
+  character(63,k), parameter :: wiggle = k_"wiggle"
+  call sub2(wiggle)
+end subroutine sub1
+
+! CHECK-LABEL: @_QFEarr = internal global [3 x [10 x i32]] [
+! CHECK-SAME: [10 x i32] [i32 103, i32 111, i32 111, i32 100, i32 32, i32 98, i32 117, i32 100, i32 100, i32 121],
+! CHECK-SAME: [10 x i32] [i32 98, i32 101, i32 115, i32 116, i32 32, i32 98, i32 117, i32 100, i32 100, i32 121],
+! CHECK-SAME: [10 x i32] [i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32]]
+! CHECK-LABEL: @_QFsub1ECwiggle = internal constant [63 x i32] [i32 119,
+! CHECK-SAME: i32 105, i32 103, i32 103, i32 108, i32 101, i32 32, i32 32,
+! CHECK: @_QQcl[[inline:.*]] = linkonce constant [63 x i32] [i32 119, i32 105, i32 103, i32 103, i32 108, i32 101, i32 32,
+
+! CHECK-LABEL: define void @_QQmain()
+! CHECK: call void @_QPaction_on_char4(ptr @_QFEarr, i64 10)
+
+! CHECK-LABEL: define void @_QPsub1(
+! CHECK: call void @_QPsub2(ptr @_QQcl.77, i64 63)