[CIR][Codegen] Fixes global variables that point to another globals (#1277)

Testing CIR with `csmith` is in progress! And this PR is not a small
one, so I need to apologize. But looks like there is a problem that may
affect the run time.


### Problem
Consider the next code:
```
#include  <stdio.h>
typedef struct {    
   int f0 : 24;      
   int f1;
   int f2;
} S;

static S g1 = {2799, 9, 123};
static int *g2 = &g1.f2;

int main() {
 printf("check: %d\n",*g2);  
 return 0;
}
```
This program dumps anything but not `123`. 
So basically we don't support global variables that refer to another
globals in the case of aggregate types.
This PR fixes global views for two cases: structs and array of structs
(see the tests).

There is an issue with unions too, but I think we will discuss it later,
once we will agree on the approach

### Some details
For the example above, `g1` variable is created in two steps:
1) The variable is created with the `S` type. In our case it's
`!cir.struct<struct "S" {!cir.array<!cir.int<u, 8> x 3>, !cir.int<s,
32>, !cir.int<s, 32>}`(which differs from the OG btw, and may be I need
to take a look at the bit fields again - but it's not a problem right
now)
2) For the left side we create anon structure of type `
!cir.struct<struct {!cir.int<u, 8>, !cir.int<u, 8>, !cir.int<u, 8>,
!cir.int<u, 8>, !cir.int<s, 32>, !cir.int<s, 32>}>` which is the same as
in OG and then `g1` is replaced with the new type.

Basically the same happens in the OG. But then the `replaceAllUsesWith`
solves all the possible problems.
In our case  we can not do it this easy. The `g2` is: 
```
cir.global @G2 = #cir.global_view<@g1, [2 : i32]> : !cir.ptr<!s32i> 
```
The problem is in the indexes! After `g1` is replaced, the index in
`g2`'s `GlobalViewAttr`still points to the old type!!!
So  we have to create a new `GlobalViewAttr` with new indexes! 

### Solution
My solution is based on the `computeGlobalViewIndicesFromFlatOffset`
function from `CIRGenBuilder` that is basically a mapping from indexes
to offset. I compute an offset and then map it back to the indexes with
for the new type.

May be there is a better solution though, have some ideas? 


#### Implementation details
Most of the changes are in the `CIRGenModule` where we do the
replacement.
Also, there are some changes in `CIRGenBuilder` - I moved
`computeGlobalViewIndicesFromFlatOffset` to `cpp` with no changes and
added the opposite function `computeOffsetFromGlobalViewIndices`.

One more fix is more important - is about `GlobalViewAttr` indexes
generation for vtable. I suggest we don't set the first index to zero in
CIR and add it in the lowering - in this case we can do it uniformly as
```
if (isa<mlir::LLVM::LLVMArrayType, mlir::LLVM::LLVMStructType>(sourceType))
      indices.push_back(0);    
```
The previous approach was not completely correct - we have to add the
leading zero index for the anon structures as well:
```
if (stTy.isIdentified())
        indices.push_back(0); // Wrong
```
Thus, there are some changes in tests as well. It's not an unrelated
issue - we have to fix it - either now or as a separated PR that should
come before this one.

Also, I added tests with the covered cases with the original LLVM IR,
just for comparison - so there are some divergences as well.

Finally - this code was already tested with `csmith` and I don't have
any problems so far. Once we'll fix unions I will have more information.

Author: gitoleg

clang/include/clang/CIR/Dialect/IR/CIRAttrs.td

@@ -622,6 +622,30 @@ def GlobalViewAttr : CIR_Attr<"GlobalView", "global_view", [TypedAttrInterface]>
       cir.global external @elt_ptr = #cir.global_view<@rgb, [1]> : !cir.ptr<i8>
       cir.global external @table_of_ptrs = #cir.const_array<[#cir.global_view<@rgb, [1]> : !cir.ptr<i8>] : !cir.array<!cir.ptr<i8> x 1>>
     ```
+    
+    Note, that unlike LLVM IR's gep instruction, CIR doesn't add the leading zero index
+    when it's known to be constant zero, e.g. for pointers, i.e. we use indexes exactly
+    to access sub elements or for the offset. The leading zero index is added later in
+    the lowering.
+        
+    Example:
+    ```
+    struct A {
+      int a;
+    };
+
+    struct B:  virtual A {
+      int b;
+    };
+    ```
+    VTT for B:
+    ```
+    cir.global linkonce_odr @_ZTT1B = #cir.const_array<[#cir.global_view<@_ZTV1B, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 1>    
+    ```
+    The same for LLVM IR after CIR:
+    ```
+    @_ZTT1B = linkonce_odr global [1 x ptr] [ptr getelementptr inbounds ({ [3 x ptr] }, ptr @_ZTV1B, i32 0, i32 0, i32 3)], align 8
+    ```
   }];
 
   let parameters = (ins AttributeSelfTypeParameter<"">:$type,

clang/lib/CIR/CodeGen/CIRGenBuilder.cpp

@@ -63,3 +63,74 @@ cir::ConstantOp CIRGenBuilderTy::getConstInt(mlir::Location loc, mlir::Type t,
   assert(intTy && "expected cir::IntType");
   return create<cir::ConstantOp>(loc, intTy, cir::IntAttr::get(t, C));
 }
+
+void CIRGenBuilderTy::computeGlobalViewIndicesFromFlatOffset(
+    int64_t Offset, mlir::Type Ty, cir::CIRDataLayout Layout,
+    llvm::SmallVectorImpl<int64_t> &Indices) {
+  if (!Offset)
+    return;
+
+  mlir::Type SubType;
+
+  auto getIndexAndNewOffset =
+      [](int64_t Offset, int64_t EltSize) -> std::pair<int64_t, int64_t> {
+    int64_t DivRet = Offset / EltSize;
+    if (DivRet < 0)
+      DivRet -= 1; // make sure offset is positive
+    int64_t ModRet = Offset - (DivRet * EltSize);
+    return {DivRet, ModRet};
+  };
+
+  if (auto ArrayTy = mlir::dyn_cast<cir::ArrayType>(Ty)) {
+    int64_t EltSize = Layout.getTypeAllocSize(ArrayTy.getEltType());
+    SubType = ArrayTy.getEltType();
+    const auto [Index, NewOffset] = getIndexAndNewOffset(Offset, EltSize);
+    Indices.push_back(Index);
+    Offset = NewOffset;
+  } else if (auto StructTy = mlir::dyn_cast<cir::StructType>(Ty)) {
+    auto Elts = StructTy.getMembers();
+    int64_t Pos = 0;
+    for (size_t I = 0; I < Elts.size(); ++I) {
+      int64_t EltSize =
+          (int64_t)Layout.getTypeAllocSize(Elts[I]).getFixedValue();
+      unsigned AlignMask = Layout.getABITypeAlign(Elts[I]).value() - 1;
+      if (StructTy.getPacked())
+        AlignMask = 0;
+      Pos = (Pos + AlignMask) & ~AlignMask;
+      assert(Offset >= 0);
+      if (Offset < Pos + EltSize) {
+        Indices.push_back(I);
+        SubType = Elts[I];
+        Offset -= Pos;
+        break;
+      }
+      Pos += EltSize;
+    }
+  } else {
+    llvm_unreachable("unexpected type");
+  }
+
+  assert(SubType);
+  computeGlobalViewIndicesFromFlatOffset(Offset, SubType, Layout, Indices);
+}
+
+uint64_t CIRGenBuilderTy::computeOffsetFromGlobalViewIndices(
+    const cir::CIRDataLayout &layout, mlir::Type typ,
+    llvm::ArrayRef<int64_t> indexes) {
+
+  uint64_t offset = 0;
+  for (auto idx : indexes) {
+    if (auto sTy = dyn_cast<cir::StructType>(typ)) {
+      offset += sTy.getElementOffset(layout.layout, idx);
+      assert(idx < sTy.getMembers().size());
+      typ = sTy.getMembers()[idx];
+    } else if (auto arTy = dyn_cast<cir::ArrayType>(typ)) {
+      typ = arTy.getEltType();
+      offset += layout.getTypeAllocSize(typ) * idx;
+    } else {
+      llvm_unreachable("NYI");
+    }
+  }
+
+  return offset;
+}

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -146,6 +146,20 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
     return cir::GlobalViewAttr::get(type, symbol, indices);
   }
 
+  cir::GlobalViewAttr getGlobalViewAttr(cir::PointerType type,
+                                        cir::GlobalOp globalOp,
+                                        llvm::ArrayRef<int64_t> indices) {
+    llvm::SmallVector<mlir::Attribute> attrs;
+    for (auto ind : indices) {
+      auto a =
+          mlir::IntegerAttr::get(mlir::IntegerType::get(getContext(), 64), ind);
+      attrs.push_back(a);
+    }
+
+    mlir::ArrayAttr arAttr = mlir::ArrayAttr::get(getContext(), attrs);
+    return getGlobalViewAttr(type, globalOp, arAttr);
+  }
+
   mlir::Attribute getString(llvm::StringRef str, mlir::Type eltTy,
                             unsigned size = 0) {
     unsigned finalSize = size ? size : str.size();
@@ -941,51 +955,12 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
   // yet, return them.
   void computeGlobalViewIndicesFromFlatOffset(
       int64_t Offset, mlir::Type Ty, cir::CIRDataLayout Layout,
-      llvm::SmallVectorImpl<int64_t> &Indices) {
-    if (!Offset)
-      return;
-
-    mlir::Type SubType;
-
-    auto getIndexAndNewOffset =
-        [](int64_t Offset, int64_t EltSize) -> std::pair<int64_t, int64_t> {
-      int64_t DivRet = Offset / EltSize;
-      if (DivRet < 0)
-        DivRet -= 1; // make sure offset is positive
-      int64_t ModRet = Offset - (DivRet * EltSize);
-      return {DivRet, ModRet};
-    };
-
-    if (auto ArrayTy = mlir::dyn_cast<cir::ArrayType>(Ty)) {
-      int64_t EltSize = Layout.getTypeAllocSize(ArrayTy.getEltType());
-      SubType = ArrayTy.getEltType();
-      auto const [Index, NewOffset] = getIndexAndNewOffset(Offset, EltSize);
-      Indices.push_back(Index);
-      Offset = NewOffset;
-    } else if (auto StructTy = mlir::dyn_cast<cir::StructType>(Ty)) {
-      auto Elts = StructTy.getMembers();
-      int64_t Pos = 0;
-      for (size_t I = 0; I < Elts.size(); ++I) {
-        int64_t EltSize =
-            (int64_t)Layout.getTypeAllocSize(Elts[I]).getFixedValue();
-        unsigned AlignMask = Layout.getABITypeAlign(Elts[I]).value() - 1;
-        Pos = (Pos + AlignMask) & ~AlignMask;
-        assert(Offset >= 0);
-        if (Offset < Pos + EltSize) {
-          Indices.push_back(I);
-          SubType = Elts[I];
-          Offset -= Pos;
-          break;
-        }
-        Pos += EltSize;
-      }
-    } else {
-      llvm_unreachable("unexpected type");
-    }
+      llvm::SmallVectorImpl<int64_t> &Indices);
 
-    assert(SubType);
-    computeGlobalViewIndicesFromFlatOffset(Offset, SubType, Layout, Indices);
-  }
+  // Convert high-level indices (e.g. from GlobalViewAttr) to byte offset
+  uint64_t computeOffsetFromGlobalViewIndices(const cir::CIRDataLayout &layout,
+                                              mlir::Type t,
+                                              llvm::ArrayRef<int64_t> indexes);
 
   cir::StackSaveOp createStackSave(mlir::Location loc, mlir::Type ty) {
     return create<cir::StackSaveOp>(loc, ty);

clang/lib/CIR/CodeGen/CIRGenExprConst.cpp

@@ -756,7 +756,6 @@ bool ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD,
               .getAddressPoint(BaseSubobject(CD, Offset));
       assert(!cir::MissingFeatures::ptrAuth());
       mlir::ArrayAttr indices = builder.getArrayAttr({
-          builder.getI32IntegerAttr(0),
           builder.getI32IntegerAttr(addressPoint.VTableIndex),
           builder.getI32IntegerAttr(addressPoint.AddressPointIndex),
       });

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -9,9 +9,7 @@
 // This is the internal per-translation-unit state used for CIR translation.
 //
 //===----------------------------------------------------------------------===//
-
 #include "CIRGenModule.h"
-
 #include "CIRGenCXXABI.h"
 #include "CIRGenCstEmitter.h"
 #include "CIRGenFunction.h"
@@ -797,9 +795,75 @@ void CIRGenModule::setNonAliasAttributes(GlobalDecl GD, mlir::Operation *GO) {
   assert(!cir::MissingFeatures::setTargetAttributes());
 }
 
+static llvm::SmallVector<int64_t> indexesOfArrayAttr(mlir::ArrayAttr indexes) {
+  llvm::SmallVector<int64_t> inds;
+
+  for (mlir::Attribute i : indexes) {
+    auto ind = dyn_cast<mlir::IntegerAttr>(i);
+    assert(ind && "expect MLIR integer attribute");
+    inds.push_back(ind.getValue().getSExtValue());
+  }
+
+  return inds;
+}
+
+static bool isViewOnGlobal(GlobalOp glob, GlobalViewAttr view) {
+  return view.getSymbol().getValue() == glob.getSymName();
+}
+
+static GlobalViewAttr createNewGlobalView(CIRGenModule &CGM, GlobalOp newGlob,
+                                          GlobalViewAttr attr,
+                                          mlir::Type oldTy) {
+  if (!attr.getIndices() || !isViewOnGlobal(newGlob, attr))
+    return attr;
+
+  llvm::SmallVector<int64_t> oldInds = indexesOfArrayAttr(attr.getIndices());
+  llvm::SmallVector<int64_t> newInds;
+  CIRGenBuilderTy &bld = CGM.getBuilder();
+  const CIRDataLayout &layout = CGM.getDataLayout();
+  mlir::MLIRContext *ctxt = bld.getContext();
+  auto newTy = newGlob.getSymType();
+
+  auto offset = bld.computeOffsetFromGlobalViewIndices(layout, oldTy, oldInds);
+  bld.computeGlobalViewIndicesFromFlatOffset(offset, newTy, layout, newInds);
+  cir::PointerType newPtrTy;
+
+  if (isa<cir::StructType>(oldTy))
+    newPtrTy = cir::PointerType::get(ctxt, newTy);
+  else if (cir::ArrayType oldArTy = dyn_cast<cir::ArrayType>(oldTy))
+    newPtrTy = dyn_cast<cir::PointerType>(attr.getType());
+
+  if (newPtrTy)
+    return bld.getGlobalViewAttr(newPtrTy, newGlob, newInds);
+
+  llvm_unreachable("NYI");
+}
+
+static mlir::Attribute getNewInitValue(CIRGenModule &CGM, GlobalOp newGlob,
+                                       mlir::Type oldTy, GlobalOp user,
+                                       mlir::Attribute oldInit) {
+  if (auto oldView = mlir::dyn_cast<cir::GlobalViewAttr>(oldInit)) {
+    return createNewGlobalView(CGM, newGlob, oldView, oldTy);
+  } else if (auto oldArray = mlir::dyn_cast<ConstArrayAttr>(oldInit)) {
+    llvm::SmallVector<mlir::Attribute> newArray;
+    auto eltsAttr = dyn_cast<mlir::ArrayAttr>(oldArray.getElts());
+    for (auto elt : eltsAttr) {
+      if (auto view = dyn_cast<GlobalViewAttr>(elt))
+        newArray.push_back(createNewGlobalView(CGM, newGlob, view, oldTy));
+      else if (auto view = dyn_cast<ConstArrayAttr>(elt))
+        newArray.push_back(getNewInitValue(CGM, newGlob, oldTy, user, elt));
+    }
+
+    auto &builder = CGM.getBuilder();
+    mlir::Attribute ar = mlir::ArrayAttr::get(builder.getContext(), newArray);
+    return builder.getConstArray(ar, cast<cir::ArrayType>(oldArray.getType()));
+  } else {
+    llvm_unreachable("NYI");
+  }
+}
+
 void CIRGenModule::replaceGlobal(cir::GlobalOp Old, cir::GlobalOp New) {
   assert(Old.getSymName() == New.getSymName() && "symbol names must match");
-
   // If the types does not match, update all references to Old to the new type.
   auto OldTy = Old.getSymType();
   auto NewTy = New.getSymType();
@@ -809,6 +873,7 @@ void CIRGenModule::replaceGlobal(cir::GlobalOp Old, cir::GlobalOp New) {
   if (oldAS != newAS) {
     llvm_unreachable("NYI");
   }
+
   if (OldTy != NewTy) {
     auto OldSymUses = Old.getSymbolUses(theModule.getOperation());
     if (OldSymUses.has_value()) {
@@ -823,11 +888,16 @@ void CIRGenModule::replaceGlobal(cir::GlobalOp Old, cir::GlobalOp New) {
               cir::PointerType::get(&getMLIRContext(), NewTy));
 
           mlir::OpBuilder::InsertionGuard guard(builder);
-          builder.setInsertionPointAfter(UserOp);
+          builder.setInsertionPointAfter(GGO);
           mlir::Type ptrTy = builder.getPointerTo(OldTy);
           mlir::Value cast =
               builder.createBitcast(GGO->getLoc(), UseOpResultValue, ptrTy);
           UseOpResultValue.replaceAllUsesExcept(cast, cast.getDefiningOp());
+        } else if (auto glob = dyn_cast<cir::GlobalOp>(UserOp)) {
+          if (auto init = glob.getInitialValue()) {
+            auto nw = getNewInitValue(*this, New, OldTy, glob, init.value());
+            glob.setInitialValueAttr(nw);
+          }
         }
       }
     }
@@ -1083,7 +1153,8 @@ CIRGenModule::getAddrOfGlobalVarAttr(const VarDecl *D, mlir::Type Ty,
     Ty = getTypes().convertTypeForMem(ASTTy);
 
   auto globalOp = getOrCreateCIRGlobal(D, Ty, IsForDefinition);
-  return builder.getGlobalViewAttr(builder.getPointerTo(Ty), globalOp);
+  auto ptrTy = builder.getPointerTo(globalOp.getSymType());
+  return builder.getGlobalViewAttr(ptrTy, globalOp);
 }
 
 mlir::Operation *CIRGenModule::getWeakRefReference(const ValueDecl *VD) {

clang/lib/CIR/CodeGen/CIRGenVTables.cpp

@@ -622,8 +622,7 @@ void CIRGenVTables::emitVTTDefinition(cir::GlobalOp VTT,
              "Did not find ctor vtable address point!");
     }
 
-    mlir::Attribute Idxs[3] = {
-        CGM.getBuilder().getI32IntegerAttr(0),
+    mlir::Attribute Idxs[2] = {
         CGM.getBuilder().getI32IntegerAttr(AddressPoint.VTableIndex),
         CGM.getBuilder().getI32IntegerAttr(AddressPoint.AddressPointIndex),
     };

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

@@ -680,12 +680,8 @@ lowerCirAttrAsValue(mlir::Operation *parentOp, cir::GlobalViewAttr globalAttr,
   if (globalAttr.getIndices()) {
     llvm::SmallVector<mlir::LLVM::GEPArg> indices;
 
-    if (auto stTy = dyn_cast<mlir::LLVM::LLVMStructType>(sourceType)) {
-      if (stTy.isIdentified())
-        indices.push_back(0);
-    } else if (isa<mlir::LLVM::LLVMArrayType>(sourceType)) {
+    if (isa<mlir::LLVM::LLVMArrayType, mlir::LLVM::LLVMStructType>(sourceType))
       indices.push_back(0);
-    }
 
     for (auto idx : globalAttr.getIndices()) {
       auto intAttr = dyn_cast<mlir::IntegerAttr>(idx);