[rebase] workaround LLVM dialect array constant issue with dense attributes

StringLitOp use to be translated to things like:

llvm.func @character_literal2() -> !llvm.array<2 x i16> {
  %0 = llvm.mlir.constant(dense<[234, 456]> : vector<2xi16>) : !llvm.array<2 x i16>
  llvm.return %0 : !llvm.array<2 x i16>
}

Now yields error:

Function return type does not match operand type of return inst!
  ret <2 x i16> <i16 234, i16 456>, !dbg !7
 [2 x i16]error: could not emit LLVM-IR

Yet, using dense attr looks the right things to do given mlir tests like
https://github.com/llvm/llvm-project/blob/e356027016c6365b3d8924f54c33e2c63d931492/mlir/test/Target/LLVMIR/llvmir.mlir#L31

So there might be an MLIR regression here. In the short-term, use
a chain of insert_value as a fallback.

Author: jeanPerier

flang/lib/Optimizer/CodeGen/CodeGen.cpp

@@ -701,21 +701,30 @@ struct StringLitOpConversion : public FIROpConversion<fir::StringLitOp> {
     if (attr.isa<mlir::StringAttr>()) {
       rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(constop, ty, attr);
     } else {
-      // convert the array attr to a dense elements attr
-      // LLVMIR dialect knows how to lower the latter to LLVM IR
+      // FIXME: As of llvm head 85bf221f204eafc1142a064f1650ffa9d9e03dad, using
+      // a dense elements attr causes llvm ir verification error:
+      //   %0 = llvm.mlir.constant(dense<[234, 456]> : vector<2xi16>) : !llvm.array<2 x i16>
+      //   creates a vector type constant instead of an array, later
+      //   conflicting with its usage. It is likely an MLIR bug that should
+      //   be investigated. In the meantime, do a dumb chain of inserts.
       auto arr = attr.cast<mlir::ArrayAttr>();
-      auto size = constop.getSize().cast<mlir::IntegerAttr>().getInt();
       auto charTy = constop.getType().cast<fir::CharacterType>();
       auto bits = lowerTy().characterBitsize(charTy);
       auto intTy = rewriter.getIntegerType(bits);
-      auto det = mlir::VectorType::get({size}, intTy);
-      // convert each character to a precise bitsize
-      SmallVector<mlir::Attribute, 64> vec;
-      for (auto a : arr.getValue())
-        vec.push_back(mlir::IntegerAttr::get(
-            intTy, a.cast<mlir::IntegerAttr>().getValue().sextOrTrunc(bits)));
-      auto dea = mlir::DenseElementsAttr::get(det, vec);
-      rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(constop, ty, dea);
+      auto loc = constop.getLoc();
+
+      mlir::Value cst = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
+      for (auto a : llvm::enumerate(arr.getValue())) {
+        // convert each character to a precise bitsize
+        auto elemAttr =
+          mlir::IntegerAttr::get(
+            intTy, a.value().cast<mlir::IntegerAttr>().getValue().sextOrTrunc(bits));
+        auto elemCst = rewriter.create<mlir::LLVM::ConstantOp>(loc, intTy, elemAttr);
+        auto index = mlir::ArrayAttr::get(constop.getContext(), rewriter.getI32IntegerAttr(a.index()));
+        cst = rewriter.create<mlir::LLVM::InsertValueOp>(
+          loc, ty, cst, elemCst, index);
+      }
+      rewriter.replaceOp(constop, cst);
     }
     return success();
   }