[CIR][CodeGen] Removed special handling for array of union

Special handling for array of union was forcing all non-union C arrays to be emitted as CIR arrays, which differs from OG CodeGen, where some arrays are emitted as structs.

Author: tommymcm

clang/lib/CIR/CodeGen/CIRGenExprConst.cpp

@@ -1106,48 +1106,6 @@ class ConstExprEmitter
     }
 
     auto desiredType = CGM.convertType(T);
-    // FIXME(cir): A hack to handle the emission of arrays of unions directly.
-    // See clang/test/CIR/CodeGen/union-array.c and
-    // clang/test/CIR/Lowering/nested-union-array.c for example. The root
-    // cause of these problems is CIR handles union differently than LLVM IR.
-    // So we can't fix the problem fundamentally by mocking LLVM's handling for
-    // unions. In LLVM, the union is basically a struct with the largest member
-    // of the union and consumers cast the union arbitrarily according to their
-    // needs. But in CIR, we tried to express union semantics properly. This is
-    // a fundamental difference.
-    //
-    // Concretely, for the problem here, if we're constructing the initializer
-    // for the array of unions, we can't even assume the type of the elements in
-    // the initializer are the same! It is odd that we can have an array with
-    // different element types. Here we just pretend it is fine by checking if
-    // we're constructing an array for an array of unions. If we didn't do so,
-    // we may meet problems during lowering to LLVM. To solve the problem, we
-    // may need to introduce 2 type systems for CIR: one for the CIR itself and
-    // one for lowering. e.g., we can compare the type of CIR during CIRGen,
-    // analysis and transformations without worrying the concerns here. And
-    // lower to LLVM IR (or anyother dialects) with the proper type.
-    //
-    // (Although the idea to make CIR's type system self contained and generate
-    // LLVM's
-    //  types in later passes look fine, it has engineering level concern that
-    //  it will make the skeleton of CIRGen to be diverged from the traditional
-    //  CodeGen.)
-    //
-    // Besides union, there are other differences between CIR and LLVM's type
-    // system. e.g., LLVM's pointer types are opaque while CIR has concrete
-    // pointer types.
-    bool isDesiredArrayOfUnionDirectly = [&]() {
-      auto desiredArrayType = dyn_cast<cir::ArrayType>(desiredType);
-      if (!desiredArrayType)
-        return false;
-
-      auto elementRecordType =
-          dyn_cast<cir::RecordType>(desiredArrayType.getElementType());
-      if (!elementRecordType)
-        return false;
-
-      return elementRecordType.isUnion();
-    }();
 
     // Emit initializer elements as MLIR attributes and check for common type.
     mlir::Type CommonElementType;
@@ -1159,8 +1117,7 @@ class ConstExprEmitter
 
       if (i == 0)
         CommonElementType = C.getType();
-      else if (isDesiredArrayOfUnionDirectly &&
-               C.getType() != CommonElementType)
+      else if (C.getType() != CommonElementType)
         CommonElementType = nullptr;
       Elts.push_back(std::move(C));
     }

clang/test/CIR/CodeGen/array-init.c

@@ -9,6 +9,22 @@ typedef struct {
   long b;
 } T;
 
+// Test array initialization with different elements.
+typedef struct {
+     long a0;
+     int a1;
+} Inner;
+typedef struct {
+     int b0;
+     Inner b1[1];
+} Outer;
+Outer outers[2] = {
+    {1, {0, 1} },
+    {1, {0, 0} }
+};
+// CIR:  cir.global{{.*}} @outers = #cir.const_record<{#cir.const_record<{#cir.int<1> : !s32i, #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 4>, #cir.const_array<[#cir.const_record<{#cir.int<0> : !s64i, #cir.int<1> : !s32i, #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 4>}> : !rec_anon_struct]> : !cir.array<!rec_anon_struct x 1>}> : !rec_anon_struct2, #cir.const_record<{#cir.int<1> : !s32i, #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 4>, #cir.zero : !cir.array<!rec_Inner x 1>}> : !rec_anon_struct1}> : !rec_anon_struct3 {alignment = 16 : i64}
+// LLVM: @outers = {{.*}}global { { i32, [4 x i8], [1 x { i64, i32, [4 x i8] }] }, { i32, [4 x i8], [1 x %struct.Inner] } } { { i32, [4 x i8], [1 x { i64, i32, [4 x i8] }] } { i32 1, [4 x i8] zeroinitializer, [1 x { i64, i32, [4 x i8] }] [{ i64, i32, [4 x i8] } { i64 0, i32 1, [4 x i8] zeroinitializer }] }, { i32, [4 x i8], [1 x %struct.Inner] } { i32 1, [4 x i8] zeroinitializer, [1 x %struct.Inner] zeroinitializer } }, align 16
+
 void buz(int x) {
   T arr[] = { {x, x}, {0, 0} };
 }