[CIR][Lowering] Support lowering of const arrays of structs (llvm#370)

This PR fixes CIR lowering for the next case.

```
void foo() {
    struct {
        int a;
        int b;
    } a[1] = {{0,1}};
}
```
Note, we don't create attribute here and lower such const arrays as
values.

Author: gitoleg

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -1047,24 +1047,21 @@ class CIRConstantLowering
     // then memcopyied into the stack (as done in Clang).
     else if (auto arrTy = op.getType().dyn_cast<mlir::cir::ArrayType>()) {
       // Fetch operation constant array initializer.
-      if (auto constArr = op.getValue().dyn_cast<mlir::cir::ConstArrayAttr>()) {
-        // Lower constant array initializer.
-        auto denseAttr = lowerConstArrayAttr(constArr, typeConverter);
-        if (!denseAttr.has_value()) {
-          op.emitError()
-              << "unsupported lowering for #cir.const_array with element type "
-              << arrTy.getEltType();
-          return mlir::failure();
-        }
 
+      auto constArr = op.getValue().dyn_cast<mlir::cir::ConstArrayAttr>();
+      if (!constArr && !isa<mlir::cir::ZeroAttr>(op.getValue()))
+        return op.emitError() << "array does not have a constant initializer";
+
+      std::optional<mlir::Attribute> denseAttr;
+      if (constArr &&
+          (denseAttr = lowerConstArrayAttr(constArr, typeConverter))) {
         attr = denseAttr.value();
-      } else if (auto zero = op.getValue().dyn_cast<mlir::cir::ZeroAttr>()) {
-        auto initVal = lowerCirAttrAsValue(op, zero, rewriter, typeConverter);
+      } else {
+        auto initVal =
+            lowerCirAttrAsValue(op, op.getValue(), rewriter, typeConverter);
         rewriter.replaceAllUsesWith(op, initVal);
         rewriter.eraseOp(op);
         return mlir::success();
-      } else {
-        return op.emitError() << "array does not have a constant initializer";
       }
     } else if (const auto structAttr =
                    op.getValue().dyn_cast<mlir::cir::ConstStructAttr>()) {

clang/test/CIR/Lowering/const.cir

@@ -3,6 +3,8 @@
 
 !s32i = !cir.int<s, 32>
 !s8i = !cir.int<s, 8>
+!ty_22anon2E122 = !cir.struct<struct "anon.1" {!cir.int<s, 32>, !cir.int<s, 32>} #cir.record.decl.ast>
+
 module {
   cir.func @testConstArrInit() {
     %0 = cir.const(#cir.const_array<"string\00" : !cir.array<!s8i x 7>> : !cir.array<!s8i x 7>) : !cir.array<!s8i x 7>
@@ -15,4 +17,24 @@ module {
     // CHECK: cir.llvmir.zeroinit : !llvm.array<3 x i32>
     cir.return
   }
+
+  cir.func @testConstArrayOfStructs() {
+    %0 = cir.alloca !cir.array<!ty_22anon2E122 x 1>, cir.ptr <!cir.array<!ty_22anon2E122 x 1>>, ["a"] {alignment = 4 : i64}
+    %1 = cir.const(#cir.const_array<[#cir.const_struct<{#cir.int<0> : !s32i, #cir.int<1> : !s32i}> : !ty_22anon2E122]> : !cir.array<!ty_22anon2E122 x 1>) : !cir.array<!ty_22anon2E122 x 1>
+    cir.store %1, %0 : !cir.array<!ty_22anon2E122 x 1>, cir.ptr <!cir.array<!ty_22anon2E122 x 1>>
+    cir.return
+  }
+  // CHECK:  llvm.func @testConstArrayOfStructs()
+  // CHECK:    %0 = llvm.mlir.constant(1 : index) : i64
+  // CHECK:    %1 = llvm.alloca %0 x !llvm.array<1 x struct<"struct.anon.1", (i32, i32)>> {alignment = 4 : i64} : (i64) -> !llvm.ptr
+  // CHECK:    %2 = llvm.mlir.undef : !llvm.array<1 x struct<"struct.anon.1", (i32, i32)>>
+  // CHECK:    %3 = llvm.mlir.undef : !llvm.struct<"struct.anon.1", (i32, i32)>
+  // CHECK:    %4 = llvm.mlir.constant(0 : i32) : i32
+  // CHECK:    %5 = llvm.insertvalue %4, %3[0] : !llvm.struct<"struct.anon.1", (i32, i32)>
+  // CHECK:    %6 = llvm.mlir.constant(1 : i32) : i32
+  // CHECK:    %7 = llvm.insertvalue %6, %5[1] : !llvm.struct<"struct.anon.1", (i32, i32)>
+  // CHECK:    %8 = llvm.insertvalue %7, %2[0] : !llvm.array<1 x struct<"struct.anon.1", (i32, i32)>>
+  // CHECK:    llvm.store %8, %1 : !llvm.array<1 x struct<"struct.anon.1", (i32, i32)>>, !llvm.ptr
+  // CHECK:    llvm.return
+
 }