[CIR][CodeGen] Updates GlobalViewAttr's indices computation for the union type (#1584)

This PR introduces a new attribute for the explicit byte offset for
`GlobalViewAttr`. It's a proposal, so feel free to reject it once it's
not good from your point of view.

The problem is (as usually) with globals and unions: looks like we can
not really use indexes in the `GlobalView` to address an array of
unions. For example, the next program prints `4` now, but it should be
`42`:
```
typedef struct {
    long s0;
    int  s1;
} S;

typedef union {
   int  f0;
   S f1;
} U;

static U g1[3] = {{42},{42},{42}};
int* g2 = &g1[1].f1.s1;

int main() {       
   (*g2) = 4;
   printf("%d\n", g1[1].f0);    
   return0;
}
``` 
The problem is that we compute wrong indices in
`CIRGenBuilder::computeGlobalViewIndicesFromFlatOffset`. Maybe it can be
even fixed in this case, but I have a feeling that the fix would be a
bit fragile.

So instead of trying to support indexes for the array of unions I
suggest to use the offset explicitly.

From the implementation point of view there are some changes in
`CIRGenBuilder ` - but nothing really new is in there - I just did not
want to introduce copy-pasta for the `isOffsetInUnion` function that is
pretty the same as former `computeGlobalViewIndicesFromFlatOffset`.

Author: gitoleg

clang/lib/CIR/CodeGen/CIRGenBuilder.cpp

@@ -96,15 +96,21 @@ void CIRGenBuilderTy::computeGlobalViewIndicesFromFlatOffset(
       unsigned AlignMask = Layout.getABITypeAlign(Elts[I]).value() - 1;
       if (RecordTy.getPacked())
         AlignMask = 0;
-      Pos = (Pos + AlignMask) & ~AlignMask;
+      // Union's fields have the same offset, so no need to change Pos here,
+      // we just need to find EltSize that is greater then the required offset.
+      // The same is true for the similar union type check below
+      if (!RecordTy.isUnion())
+        Pos = (Pos + AlignMask) & ~AlignMask;
       assert(Offset >= 0);
       if (Offset < Pos + EltSize) {
         Indices.push_back(I);
         SubType = Elts[I];
         Offset -= Pos;
         break;
       }
-      Pos += EltSize;
+      // No need to update Pos here, see the comment above.
+      if (!RecordTy.isUnion())
+        Pos += EltSize;
     }
   } else {
     llvm_unreachable("unexpected type");

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

@@ -26,6 +26,7 @@ static U1 g = {5};
 // LLVM: @g = internal global { i32 } { i32 5 }
 // FIXME: LLVM output should be: @g = internal global %union.U { i32 5 }
 
+// LLVM: @g2 = global ptr getelementptr inbounds nuw (i8, ptr @g1, i64 24)
 
 void foo() { U arr[2] = {{.b = {1, 2}}, {.a = {1}}}; }
 
@@ -37,3 +38,22 @@ void bar(void) {
 }
 // CIR: cir.global "private" internal dsolocal @g = #cir.const_record<{#cir.int<5> : !s32i}> : !rec_anon_struct
 // CIR: cir.const #cir.const_array<[#cir.global_view<@g> : !cir.ptr<!s32i>, #cir.global_view<@g> : !cir.ptr<!s32i>]> : !cir.array<!cir.ptr<!s32i> x 2>
+
+typedef struct {
+    long s0;
+    int  s1;
+} S_3;
+
+typedef union {
+   int  f0;
+   S_3 f1;
+} U2;
+
+
+static U2 g1[3] = {{0x42},{0x42},{0x42}};
+int* g2 = &g1[1].f1.s1;
+// CIR: cir.global external @g2 = #cir.global_view<@g1, [1, 1, 4]> : !cir.ptr<!s32i>
+
+void baz(void) {
+  (*g2) = 4;
+}