[CIR][Codegen] Fixes global variables that point to another globals

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);