[CIR][CIRGen] Support CodeGen for vbase constructors

1. Add new `cir.vtt.address_point` op for visiting the element of VTT to
initialize the virtual pointer.
2. Implement `getVirtualBaseClassOffset` method which provides a virtual offset
to adjust to actual virtual pointers in virtual base.
3. Follows the original clang CodeGen scheme for the implementation of most
other parts.

@bcardosolopes's note: this is cherry-picked from an older PR from Jing Zhang and
slightly modified for updates: applied review, test, doc and operation syntax.
It does not yet has LLVM lowering support, I'm going to make incremental
changes on top of this.  Any necessary CIR modifications to this design should
follow up shortly too. Also, to make this work I also added more logic to
`addImplicitStructorParam`s` and `buildThisParam`.

Author: Laity000

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

@@ -2399,6 +2399,65 @@ def VTableAddrPointOp : CIR_Op<"vtable.address_point",
   let hasVerifier = 1;
 }
 
+//===----------------------------------------------------------------------===//
+// VTTAddrPointOp
+//===----------------------------------------------------------------------===//
+
+def VTTAddrPointOp : CIR_Op<"vtt.address_point",
+    [Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
+  let summary = "Get the VTT address point";
+  let description = [{
+    The `vtt.address_point` operation retrieves an element from the VTT,
+    which is the address point of a C++ vtable. In virtual inheritance,
+    A set of internal `__vptr` for an object are initialized by this operation,
+    which assigns an element from the VTT. The initialization order is as follows:
+
+    The complete object constructors and destructors find the VTT,
+    via the mangled name of VTT global variable. They pass the address of
+    the subobject's sub-VTT entry in the VTT as a second parameter
+    when calling the base object constructors and destructors.
+    The base object constructors and destructors use the addresses passed to
+    initialize the primary virtual pointer and virtual pointers that point to
+    the classes which either have virtual bases or override virtual functions
+    with a virtual step.
+
+    The first parameter is either the mangled name of VTT global variable
+    or the address of the subobject's sub-VTT entry in the VTT.
+    The second parameter `offset` provides a virtual step to adjust to
+    the actual address point of the vtable.
+
+    The return type is always a `!cir.ptr<!cir.ptr<void>>`.
+
+    Example:
+    ```mlir
+    cir.global linkonce_odr @_ZTV1B = ...
+    ...
+    %3 = cir.base_class_addr(%1 : !cir.ptr<!ty_D> nonnull) [0] -> !cir.ptr<!ty_B>
+    %4 = cir.vtt.address_point @_ZTT1D, offset = 1 -> !cir.ptr<!cir.ptr<!void>>
+    cir.call @_ZN1BC2Ev(%3, %4)
+    ```
+    Or:
+    ```mlir
+    %7 = cir.vtt.address_point %3 : !cir.ptr<!cir.ptr<!void>>, offset = 1 -> !cir.ptr<!cir.ptr<!void>>
+    ```
+  }];
+
+  let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$name,
+                       Optional<CIR_AnyType>:$sym_addr,
+                       I32Attr:$offset);
+  let results = (outs Res<CIR_PointerType, "", []>:$addr);
+
+  let assemblyFormat = [{
+      ($name^)?
+      ($sym_addr^ `:` type($sym_addr))?
+      `,`
+      `offset` `=` $offset
+    `->` qualified(type($addr)) attr-dict
+  }];
+
+  let hasVerifier = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // SetBitfieldOp
 //===----------------------------------------------------------------------===//

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -31,6 +31,7 @@
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Types.h"
+#include "mlir/IR/Value.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FloatingPointMode.h"
@@ -695,6 +696,18 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     return Address(baseAddr, ptrTy, addr.getAlignment());
   }
 
+  mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy,
+                                 mlir::Value addr, uint64_t offset) {
+    return create<mlir::cir::VTTAddrPointOp>(
+        loc, retTy, mlir::FlatSymbolRefAttr{}, addr, offset);
+  }
+
+  mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy,
+                                 mlir::FlatSymbolRefAttr sym, uint64_t offset) {
+    return create<mlir::cir::VTTAddrPointOp>(loc, retTy, sym, mlir::Value{},
+                                             offset);
+  }
+
   // FIXME(cir): CIRGenBuilder class should have an attribute with a reference
   // to the module so that we don't have search for it or pass it around.
   // FIXME(cir): Track a list of globals, or at least the last one inserted, so

clang/lib/CIR/CodeGen/CIRGenCXXABI.cpp

@@ -66,7 +66,7 @@ void CIRGenCXXABI::buildThisParam(CIRGenFunction &CGF,
       isThisCompleteObject(CGF.CurGD)) {
     CGF.CXXABIThisAlignment = Layout.getAlignment();
   } else {
-    llvm_unreachable("NYI");
+    CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment();
   }
 }
 

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -95,7 +95,8 @@ class CIRGenCXXABI {
       clang::CXXCtorType Type, bool ForVirtualBase, bool Delegating) = 0;
 
   /// Emit the ABI-specific prolog for the function
-  virtual void buildInstanceFunctionProlog(CIRGenFunction &CGF) = 0;
+  virtual void buildInstanceFunctionProlog(SourceLocation Loc,
+                                           CIRGenFunction &CGF) = 0;
 
   /// Get the type of the implicit "this" parameter used by a method. May return
   /// zero if no specific type is applicable, e.g. if the ABI expects the "this"
@@ -120,6 +121,14 @@ class CIRGenCXXABI {
     return CGF.CXXStructorImplicitParamDecl;
   }
 
+  mlir::Value getStructorImplicitParamValue(CIRGenFunction &CGF) {
+    return CGF.CXXStructorImplicitParamValue;
+  }
+
+  void setStructorImplicitParamValue(CIRGenFunction &CGF, mlir::Value val) {
+    CGF.CXXStructorImplicitParamValue = val;
+  }
+
   /// Perform ABI-specific "this" argument adjustment required prior to
   /// a call of a virtual function.
   /// The "VirtualCall" argument is true iff the call itself is virtual.
@@ -319,6 +328,11 @@ class CIRGenCXXABI {
 
   virtual void buildBadCastCall(CIRGenFunction &CGF, mlir::Location loc) = 0;
 
+  virtual mlir::Value
+  getVirtualBaseClassOffset(mlir::Location loc, CIRGenFunction &CGF,
+                            Address This, const CXXRecordDecl *ClassDecl,
+                            const CXXRecordDecl *BaseClassDecl) = 0;
+
   virtual mlir::Value buildDynamicCast(CIRGenFunction &CGF, mlir::Location Loc,
                                        QualType SrcRecordTy,
                                        QualType DestRecordTy,

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -1186,14 +1186,18 @@ CIRGenTypes::arrangeCXXStructorDeclaration(GlobalDecl GD) {
   if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
     // A base class inheriting constructor doesn't get forwarded arguments
     // needed to construct a virtual base (or base class thereof)
-    assert(!CD->getInheritedConstructor() && "Inheritance NYI");
+    if (auto Inherited = CD->getInheritedConstructor())
+      PassParams = inheritingCtorHasParams(Inherited, GD.getCtorType());
   }
 
   CanQual<FunctionProtoType> FTP = GetFormalType(MD);
 
   if (PassParams)
     appendParameterTypes(*this, argTypes, paramInfos, FTP);
 
+  CIRGenCXXABI::AddedStructorArgCounts AddedArgs =
+      TheCXXABI.buildStructorSignature(GD, argTypes);
+  (void)AddedArgs;
   assert(paramInfos.empty() && "NYI");
 
   assert(!MD->isVariadic() && "Variadic fns NYI");

clang/lib/CIR/CodeGen/CIRGenClass.cpp

@@ -689,9 +689,8 @@ static Address ApplyNonVirtualAndVirtualOffset(
   CharUnits alignment;
   if (virtualOffset) {
     assert(nearestVBase && "virtual offset without vbase?");
-    llvm_unreachable("NYI");
-    // alignment = CGF.CGM.getVBaseAlignment(addr.getAlignment(),
-    //                                       derivedClass, nearestVBase);
+    alignment = CGF.CGM.getVBaseAlignment(addr.getAlignment(), derivedClass,
+                                          nearestVBase);
   } else {
     alignment = addr.getAlignment();
   }
@@ -714,7 +713,11 @@ void CIRGenFunction::initializeVTablePointer(mlir::Location loc,
   CharUnits NonVirtualOffset = CharUnits::Zero();
 
   if (CGM.getCXXABI().isVirtualOffsetNeededForVTableField(*this, Vptr)) {
-    llvm_unreachable("NYI");
+    // We need to use the virtual base offset offset because the virtual base
+    // might have a different offset in the most derived class.
+    VirtualOffset = CGM.getCXXABI().getVirtualBaseClassOffset(
+        loc, *this, LoadCXXThisAddress(), Vptr.VTableClass, Vptr.NearestVBase);
+    NonVirtualOffset = Vptr.OffsetFromNearestVBase;
   } else {
     // We can just use the base offset in the complete class.
     NonVirtualOffset = Vptr.Base.getBaseOffset();
@@ -797,7 +800,16 @@ void CIRGenFunction::getVTablePointers(BaseSubobject Base,
     bool BaseDeclIsNonVirtualPrimaryBase;
 
     if (I.isVirtual()) {
-      llvm_unreachable("NYI");
+      // Check if we've visited this virtual base before.
+      if (!VBases.insert(BaseDecl).second)
+        continue;
+
+      const ASTRecordLayout &Layout =
+          getContext().getASTRecordLayout(VTableClass);
+
+      BaseOffset = Layout.getVBaseClassOffset(BaseDecl);
+      BaseOffsetFromNearestVBase = CharUnits::Zero();
+      BaseDeclIsNonVirtualPrimaryBase = false;
     } else {
       const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
 
@@ -1449,18 +1461,34 @@ mlir::Value CIRGenFunction::GetVTTParameter(GlobalDecl GD, bool ForVirtualBase,
   const CXXRecordDecl *RD = cast<CXXMethodDecl>(CurCodeDecl)->getParent();
   const CXXRecordDecl *Base = cast<CXXMethodDecl>(GD.getDecl())->getParent();
 
+  uint64_t SubVTTIndex;
+
   if (Delegating) {
     llvm_unreachable("NYI");
   } else if (RD == Base) {
     llvm_unreachable("NYI");
   } else {
-    llvm_unreachable("NYI");
+    const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
+    CharUnits BaseOffset = ForVirtualBase ? Layout.getVBaseClassOffset(Base)
+                                          : Layout.getBaseClassOffset(Base);
+
+    SubVTTIndex =
+        CGM.getVTables().getSubVTTIndex(RD, BaseSubobject(Base, BaseOffset));
+    assert(SubVTTIndex != 0 && "Sub-VTT index must be greater than zero!");
   }
 
+  auto Loc = CGM.getLoc(RD->getBeginLoc());
   if (CGM.getCXXABI().NeedsVTTParameter(CurGD)) {
-    llvm_unreachable("NYI");
+    // A VTT parameter was passed to the constructor, use it.
+    auto VTT = LoadCXXVTT();
+    return CGM.getBuilder().createVTTAddrPoint(Loc, VTT.getType(), VTT,
+                                               SubVTTIndex);
   } else {
-    llvm_unreachable("NYI");
+    // We're the complete constructor, so get the VTT by name.
+    auto VTT = CGM.getVTables().getAddrOfVTT(RD);
+    return CGM.getBuilder().createVTTAddrPoint(
+        Loc, CGM.getBuilder().getPointerTo(CGM.VoidPtrTy),
+        mlir::FlatSymbolRefAttr::get(VTT.getSymNameAttr()), SubVTTIndex);
   }
 }
 
@@ -1645,8 +1673,25 @@ CIRGenModule::getDynamicOffsetAlignment(clang::CharUnits actualBaseAlign,
   return std::min(actualBaseAlign, expectedTargetAlign);
 }
 
-/// Emit a loop to call a particular constructor for each of several members of
-/// an array.
+/// Return the best known alignment for a pointer to a virtual base,
+/// given the alignment of a pointer to the derived class.
+clang::CharUnits
+CIRGenModule::getVBaseAlignment(CharUnits actualDerivedAlign,
+                                const CXXRecordDecl *derivedClass,
+                                const CXXRecordDecl *vbaseClass) {
+  // The basic idea here is that an underaligned derived pointer might
+  // indicate an underaligned base pointer.
+
+  assert(vbaseClass->isCompleteDefinition());
+  auto &baseLayout = getASTContext().getASTRecordLayout(vbaseClass);
+  CharUnits expectedVBaseAlign = baseLayout.getNonVirtualAlignment();
+
+  return getDynamicOffsetAlignment(actualDerivedAlign, derivedClass,
+                                   expectedVBaseAlign);
+}
+
+/// Emit a loop to call a particular constructor for each of several members
+/// of an array.
 ///
 /// \param ctor the constructor to call for each element
 /// \param arrayType the type of the array to initialize
@@ -1663,8 +1708,8 @@ void CIRGenFunction::buildCXXAggrConstructorCall(
                               NewPointerIsChecked, zeroInitialize);
 }
 
-/// Emit a loop to call a particular constructor for each of several members of
-/// an array.
+/// Emit a loop to call a particular constructor for each of several members
+/// of an array.
 ///
 /// \param ctor the constructor to call for each element
 /// \param numElements the number of elements in the array;
@@ -1749,7 +1794,8 @@ void CIRGenFunction::buildCXXAggrConstructorCall(
               AggValueSlot::DoesNotOverlap, AggValueSlot::IsNotZeroed,
               NewPointerIsChecked ? AggValueSlot::IsSanitizerChecked
                                   : AggValueSlot::IsNotSanitizerChecked);
-          buildCXXConstructorCall(ctor, Ctor_Complete, /*ForVirtualBase=*/false,
+          buildCXXConstructorCall(ctor, Ctor_Complete,
+                                  /*ForVirtualBase=*/false,
                                   /*Delegating=*/false, currAVS, E);
           builder.create<mlir::cir::YieldOp>(loc);
         });

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -1301,7 +1301,7 @@ void CIRGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
   }
 
   if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) {
-    CGM.getCXXABI().buildInstanceFunctionProlog(*this);
+    CGM.getCXXABI().buildInstanceFunctionProlog(Loc, *this);
 
     const auto *MD = cast<CXXMethodDecl>(D);
     if (MD->getParent()->isLambda() && MD->getOverloadedOperator() == OO_Call) {

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -1585,6 +1585,14 @@ class CIRGenFunction : public CIRGenTypeCache {
   }
   Address LoadCXXThisAddress();
 
+  /// Load the VTT parameter to base constructors/destructors have virtual
+  /// bases. FIXME: Every place that calls LoadCXXVTT is something that needs to
+  /// be abstracted properly.
+  mlir::Value LoadCXXVTT() {
+    assert(CXXStructorImplicitParamValue && "no VTT value for this function");
+    return CXXStructorImplicitParamValue;
+  }
+
   /// Convert the given pointer to a complete class to the given direct base.
   Address getAddressOfDirectBaseInCompleteClass(mlir::Location loc,
                                                 Address Value,