merge main into amd-staging (llvm#3842)

Author: z1-cciauto

clang/lib/AST/ByteCode/InterpState.cpp

@@ -59,7 +59,8 @@ InterpState::~InterpState() {
 void InterpState::cleanup() {
   // As a last resort, make sure all pointers still pointing to a dead block
   // don't point to it anymore.
-  Alloc.cleanup();
+  if (Alloc)
+    Alloc->cleanup();
 }
 
 Frame *InterpState::getCurrentFrame() { return Current; }
@@ -99,10 +100,13 @@ void InterpState::deallocate(Block *B) {
 }
 
 bool InterpState::maybeDiagnoseDanglingAllocations() {
-  bool NoAllocationsLeft = !Alloc.hasAllocations();
+  if (!Alloc)
+    return true;
+
+  bool NoAllocationsLeft = !Alloc->hasAllocations();
 
   if (!checkingPotentialConstantExpression()) {
-    for (const auto &[Source, Site] : Alloc.allocation_sites()) {
+    for (const auto &[Source, Site] : Alloc->allocation_sites()) {
       assert(!Site.empty());
 
       CCEDiag(Source->getExprLoc(), diag::note_constexpr_memory_leak)

clang/lib/AST/ByteCode/InterpState.h

@@ -115,7 +115,13 @@ class InterpState final : public State, public SourceMapper {
 
   void setEvalLocation(SourceLocation SL) { this->EvalLocation = SL; }
 
-  DynamicAllocator &getAllocator() { return Alloc; }
+  DynamicAllocator &getAllocator() {
+    if (!Alloc) {
+      Alloc = std::make_unique<DynamicAllocator>();
+    }
+
+    return *Alloc.get();
+  }
 
   /// Diagnose any dynamic allocations that haven't been freed yet.
   /// Will return \c false if there were any allocations to diagnose,
@@ -161,7 +167,7 @@ class InterpState final : public State, public SourceMapper {
   /// Reference to the offset-source mapping.
   SourceMapper *M;
   /// Allocator used for dynamic allocations performed via the program.
-  DynamicAllocator Alloc;
+  std::unique_ptr<DynamicAllocator> Alloc;
 
 public:
   /// Reference to the module containing all bytecode.

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -107,6 +107,10 @@ class CIRGenCXXABI {
   virtual void emitVTableDefinitions(CIRGenVTables &cgvt,
                                      const CXXRecordDecl *rd) = 0;
 
+  /// Emit any tables needed to implement virtual inheritance.  For Itanium,
+  /// this emits virtual table tables.
+  virtual void emitVirtualInheritanceTables(const CXXRecordDecl *rd) = 0;
+
   /// Returns true if the given destructor type should be emitted as a linkonce
   /// delegating thunk, regardless of whether the dtor is defined in this TU or
   /// not.

clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp

@@ -85,6 +85,7 @@ class CIRGenItaniumCXXABI : public CIRGenCXXABI {
       const clang::CXXRecordDecl *nearestVBase) override;
   void emitVTableDefinitions(CIRGenVTables &cgvt,
                              const CXXRecordDecl *rd) override;
+  void emitVirtualInheritanceTables(const CXXRecordDecl *rd) override;
 
   bool doStructorsInitializeVPtrs(const CXXRecordDecl *vtableClass) override {
     return true;
@@ -335,6 +336,13 @@ void CIRGenItaniumCXXABI::emitVTableDefinitions(CIRGenVTables &cgvt,
   }
 }
 
+void CIRGenItaniumCXXABI::emitVirtualInheritanceTables(
+    const CXXRecordDecl *rd) {
+  CIRGenVTables &vtables = cgm.getVTables();
+  cir::GlobalOp vtt = vtables.getAddrOfVTT(rd);
+  vtables.emitVTTDefinition(vtt, cgm.getVTableLinkage(rd), rd);
+}
+
 void CIRGenItaniumCXXABI::emitDestructorCall(
     CIRGenFunction &cgf, const CXXDestructorDecl *dd, CXXDtorType type,
     bool forVirtualBase, bool delegating, Address thisAddr, QualType thisTy) {

clang/lib/CIR/CodeGen/CIRGenVTables.cpp

@@ -15,6 +15,7 @@
 #include "CIRGenCXXABI.h"
 #include "CIRGenModule.h"
 #include "mlir/IR/Types.h"
+#include "clang/AST/VTTBuilder.h"
 #include "clang/AST/VTableBuilder.h"
 #include "llvm/ADT/SmallVector.h"
 
@@ -60,7 +61,7 @@ void CIRGenVTables::generateClassData(const CXXRecordDecl *rd) {
   assert(!cir::MissingFeatures::generateDebugInfo());
 
   if (rd->getNumVBases())
-    cgm.errorNYI(rd->getSourceRange(), "emitVirtualInheritanceTables");
+    cgm.getCXXABI().emitVirtualInheritanceTables(rd);
 
   cgm.getCXXABI().emitVTableDefinitions(*this, rd);
 }
@@ -76,12 +77,6 @@ mlir::Attribute CIRGenVTables::getVTableComponent(
   assert(!cir::MissingFeatures::vtableRelativeLayout());
 
   switch (component.getKind()) {
-  case VTableComponent::CK_VCallOffset:
-    cgm.errorNYI("getVTableComponent: VCallOffset");
-    return mlir::Attribute();
-  case VTableComponent::CK_VBaseOffset:
-    cgm.errorNYI("getVTableComponent: VBaseOffset");
-    return mlir::Attribute();
   case VTableComponent::CK_CompleteDtorPointer:
     cgm.errorNYI("getVTableComponent: CompleteDtorPointer");
     return mlir::Attribute();
@@ -92,6 +87,14 @@ mlir::Attribute CIRGenVTables::getVTableComponent(
     cgm.errorNYI("getVTableComponent: UnusedFunctionPointer");
     return mlir::Attribute();
 
+  case VTableComponent::CK_VCallOffset:
+    return builder.getConstPtrAttr(builder.getUInt8PtrTy(),
+                                   component.getVCallOffset().getQuantity());
+
+  case VTableComponent::CK_VBaseOffset:
+    return builder.getConstPtrAttr(builder.getUInt8PtrTy(),
+                                   component.getVBaseOffset().getQuantity());
+
   case VTableComponent::CK_OffsetToTop:
     return builder.getConstPtrAttr(builder.getUInt8PtrTy(),
                                    component.getOffsetToTop().getQuantity());
@@ -175,6 +178,66 @@ void CIRGenVTables::createVTableInitializer(cir::GlobalOp &vtableOp,
   cgm.setInitializer(vtableOp, vtableAttr);
 }
 
+cir::GlobalOp CIRGenVTables::generateConstructionVTable(
+    const CXXRecordDecl *rd, const BaseSubobject &base, bool baseIsVirtual,
+    cir::GlobalLinkageKind linkage, VTableAddressPointsMapTy &addressPoints) {
+  assert(!cir::MissingFeatures::generateDebugInfo());
+
+  std::unique_ptr<VTableLayout> vtLayout(
+      getItaniumVTableContext().createConstructionVTableLayout(
+          base.getBase(), base.getBaseOffset(), baseIsVirtual, rd));
+
+  // Add the address points.
+  addressPoints = vtLayout->getAddressPoints();
+
+  // Get the mangled construction vtable name.
+  SmallString<256> outName;
+  llvm::raw_svector_ostream out(outName);
+  cast<ItaniumMangleContext>(cgm.getCXXABI().getMangleContext())
+      .mangleCXXCtorVTable(rd, base.getBaseOffset().getQuantity(),
+                           base.getBase(), out);
+  SmallString<256> name(outName);
+
+  assert(!cir::MissingFeatures::vtableRelativeLayout());
+
+  cir::RecordType vtType = getVTableType(*vtLayout);
+
+  // Construction vtable symbols are not part of the Itanium ABI, so we cannot
+  // guarantee that they actually will be available externally. Instead, when
+  // emitting an available_externally VTT, we provide references to an internal
+  // linkage construction vtable. The ABI only requires complete-object vtables
+  // to be the same for all instances of a type, not construction vtables.
+  if (linkage == cir::GlobalLinkageKind::AvailableExternallyLinkage)
+    linkage = cir::GlobalLinkageKind::InternalLinkage;
+
+  llvm::Align align = cgm.getDataLayout().getABITypeAlign(vtType);
+  mlir::Location loc = cgm.getLoc(rd->getSourceRange());
+
+  // Create the variable that will hold the construction vtable.
+  cir::GlobalOp vtable = cgm.createOrReplaceCXXRuntimeVariable(
+      loc, name, vtType, linkage, CharUnits::fromQuantity(align));
+
+  // V-tables are always unnamed_addr.
+  assert(!cir::MissingFeatures::opGlobalUnnamedAddr());
+
+  mlir::Attribute rtti = cgm.getAddrOfRTTIDescriptor(
+      loc, cgm.getASTContext().getCanonicalTagType(base.getBase()));
+
+  // Create and set the initializer.
+  createVTableInitializer(vtable, *vtLayout, rtti,
+                          cir::isLocalLinkage(vtable.getLinkage()));
+
+  // Set properties only after the initializer has been set to ensure that the
+  // GV is treated as definition and not declaration.
+  assert(!vtable.isDeclaration() && "Shouldn't set properties on declaration");
+  cgm.setGVProperties(vtable, rd);
+
+  assert(!cir::MissingFeatures::vtableEmitMetadata());
+  assert(!cir::MissingFeatures::vtableRelativeLayout());
+
+  return vtable;
+}
+
 /// Compute the required linkage of the vtable for the given class.
 ///
 /// Note that we only call this at the end of the translation unit.
@@ -226,6 +289,109 @@ cir::GlobalLinkageKind CIRGenModule::getVTableLinkage(const CXXRecordDecl *rd) {
   return cir::GlobalLinkageKind::ExternalLinkage;
 }
 
+cir::GlobalOp CIRGenVTables::getAddrOfVTT(const CXXRecordDecl *rd) {
+  assert(rd->getNumVBases() && "Only classes with virtual bases need a VTT");
+
+  SmallString<256> outName;
+  llvm::raw_svector_ostream out(outName);
+  cast<ItaniumMangleContext>(cgm.getCXXABI().getMangleContext())
+      .mangleCXXVTT(rd, out);
+  StringRef name = outName.str();
+
+  // This will also defer the definition of the VTT.
+  (void)cgm.getCXXABI().getAddrOfVTable(rd, CharUnits());
+
+  VTTBuilder builder(cgm.getASTContext(), rd, /*GenerateDefinition=*/false);
+
+  auto arrayType = cir::ArrayType::get(cgm.getBuilder().getUInt8PtrTy(),
+                                       builder.getVTTComponents().size());
+  llvm::Align align =
+      cgm.getDataLayout().getABITypeAlign(cgm.getBuilder().getUInt8PtrTy());
+  cir::GlobalOp vtt = cgm.createOrReplaceCXXRuntimeVariable(
+      cgm.getLoc(rd->getSourceRange()), name, arrayType,
+      cir::GlobalLinkageKind::ExternalLinkage, CharUnits::fromQuantity(align));
+  cgm.setGVProperties(vtt, rd);
+  return vtt;
+}
+
+static cir::GlobalOp
+getAddrOfVTTVTable(CIRGenVTables &cgvt, CIRGenModule &cgm,
+                   const CXXRecordDecl *mostDerivedClass,
+                   const VTTVTable &vtable, cir::GlobalLinkageKind linkage,
+                   VTableLayout::AddressPointsMapTy &addressPoints) {
+  if (vtable.getBase() == mostDerivedClass) {
+    assert(vtable.getBaseOffset().isZero() &&
+           "Most derived class vtable must have a zero offset!");
+    // This is a regular vtable.
+    return cgm.getCXXABI().getAddrOfVTable(mostDerivedClass, CharUnits());
+  }
+  return cgvt.generateConstructionVTable(
+      mostDerivedClass, vtable.getBaseSubobject(), vtable.isVirtual(), linkage,
+      addressPoints);
+}
+
+/// Emit the definition of the given vtable.
+void CIRGenVTables::emitVTTDefinition(cir::GlobalOp vttOp,
+                                      cir::GlobalLinkageKind linkage,
+                                      const CXXRecordDecl *rd) {
+  VTTBuilder builder(cgm.getASTContext(), rd, /*GenerateDefinition=*/true);
+
+  mlir::MLIRContext *mlirContext = &cgm.getMLIRContext();
+
+  auto arrayType = cir::ArrayType::get(cgm.getBuilder().getUInt8PtrTy(),
+                                       builder.getVTTComponents().size());
+
+  SmallVector<cir::GlobalOp> vtables;
+  SmallVector<VTableAddressPointsMapTy> vtableAddressPoints;
+  for (const VTTVTable &vtt : builder.getVTTVTables()) {
+    vtableAddressPoints.push_back(VTableAddressPointsMapTy());
+    vtables.push_back(getAddrOfVTTVTable(*this, cgm, rd, vtt, linkage,
+                                         vtableAddressPoints.back()));
+  }
+
+  SmallVector<mlir::Attribute> vttComponents;
+  for (const VTTComponent &vttComponent : builder.getVTTComponents()) {
+    const VTTVTable &vttVT = builder.getVTTVTables()[vttComponent.VTableIndex];
+    cir::GlobalOp vtable = vtables[vttComponent.VTableIndex];
+    VTableLayout::AddressPointLocation addressPoint;
+    if (vttVT.getBase() == rd) {
+      // Just get the address point for the regular vtable.
+      addressPoint =
+          getItaniumVTableContext().getVTableLayout(rd).getAddressPoint(
+              vttComponent.VTableBase);
+    } else {
+      addressPoint = vtableAddressPoints[vttComponent.VTableIndex].lookup(
+          vttComponent.VTableBase);
+      assert(addressPoint.AddressPointIndex != 0 &&
+             "Did not find ctor vtable address point!");
+    }
+
+    mlir::Attribute indices[2] = {
+        cgm.getBuilder().getI32IntegerAttr(addressPoint.VTableIndex),
+        cgm.getBuilder().getI32IntegerAttr(addressPoint.AddressPointIndex),
+    };
+
+    auto indicesAttr = mlir::ArrayAttr::get(mlirContext, indices);
+    cir::GlobalViewAttr init = cgm.getBuilder().getGlobalViewAttr(
+        cgm.getBuilder().getUInt8PtrTy(), vtable, indicesAttr);
+
+    vttComponents.push_back(init);
+  }
+
+  auto init = cir::ConstArrayAttr::get(
+      arrayType, mlir::ArrayAttr::get(mlirContext, vttComponents));
+
+  vttOp.setInitialValueAttr(init);
+
+  // Set the correct linkage.
+  vttOp.setLinkage(linkage);
+  mlir::SymbolTable::setSymbolVisibility(
+      vttOp, CIRGenModule::getMLIRVisibility(vttOp));
+
+  if (cgm.supportsCOMDAT() && vttOp.isWeakForLinker())
+    vttOp.setComdat(true);
+}
+
 void CIRGenVTables::emitThunks(GlobalDecl gd) {
   const CXXMethodDecl *md =
       cast<CXXMethodDecl>(gd.getDecl())->getCanonicalDecl();

clang/lib/CIR/CodeGen/CIRGenVTables.h

@@ -30,6 +30,9 @@ class CIRGenVTables {
 
   clang::VTableContextBase *vtContext;
 
+  /// Address points for a single vtable.
+  using VTableAddressPointsMapTy = clang::VTableLayout::AddressPointsMapTy;
+
   mlir::Attribute
   getVTableComponent(const VTableLayout &layout, unsigned componentIndex,
                      mlir::Attribute rtti, unsigned &nextVTableThunkIndex,
@@ -55,6 +58,19 @@ class CIRGenVTables {
     return *llvm::cast<clang::ItaniumVTableContext>(vtContext);
   }
 
+  /// Generate a construction vtable for the given base subobject.
+  cir::GlobalOp
+  generateConstructionVTable(const CXXRecordDecl *rd, const BaseSubobject &base,
+                             bool baseIsVirtual, cir::GlobalLinkageKind linkage,
+                             VTableAddressPointsMapTy &addressPoints);
+
+  /// Get the address of the VTT for the given record decl.
+  cir::GlobalOp getAddrOfVTT(const CXXRecordDecl *rd);
+
+  /// Emit the definition of the given vtable.
+  void emitVTTDefinition(cir::GlobalOp vttOp, cir::GlobalLinkageKind linkage,
+                         const CXXRecordDecl *rd);
+
   /// Emit the associated thunks for the given global decl.
   void emitThunks(GlobalDecl gd);
 

clang/lib/CIR/Dialect/IR/CIRDataLayout.cpp

@@ -24,15 +24,6 @@ void CIRDataLayout::reset(mlir::DataLayoutSpecInterface spec) {
 }
 
 llvm::Align CIRDataLayout::getAlignment(mlir::Type ty, bool useABIAlign) const {
-  if (auto recTy = llvm::dyn_cast<cir::RecordType>(ty)) {
-    // Packed record types always have an ABI alignment of one.
-    if (recTy && recTy.getPacked() && useABIAlign)
-      return llvm::Align(1);
-
-    // Get the layout annotation... which is lazily created on demand.
-    llvm_unreachable("getAlignment()) for record type is not implemented");
-  }
-
   // FIXME(cir): This does not account for differnt address spaces, and relies
   // on CIR's data layout to give the proper alignment.
   assert(!cir::MissingFeatures::addressSpace());