[CIR] Implement deferred V-Table emission (llvm#185655)

We are currently only emitting Vtables that have an 'immediate' need to
emit. There rest, we are supposed to add to a list and emit at the end
of the translation unit if necessary. This patch implements that
infrastructure.

The test added is from classic-codegen and came in at the same time as
the deferred vtable emission over there, and only works with deferred
vtable emission, and while it does test the deferred emission, tests
quite a bit more than that. AND since it came in with the same
functionality in classic codegen, seemed to make sense to come in here
too.

Author: erichkeane

clang/include/clang/CIR/MissingFeatures.h

@@ -150,7 +150,6 @@ struct MissingFeatures {
 
   // Various handling of deferred processing in CIRGenModule.
   static bool cgmRelease() { return false; }
-  static bool deferredVtables() { return false; }
   static bool deferredFuncDecls() { return false; }
 
   // CXXABI

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -127,6 +127,11 @@ class CIRGenCXXABI {
   virtual void emitRethrow(CIRGenFunction &cgf, bool isNoReturn) = 0;
   virtual void emitThrow(CIRGenFunction &cgf, const CXXThrowExpr *e) = 0;
 
+  /// Determine whether it's possible to emit a vtable for \p RD, even
+  /// though we do not know that the vtable has been marked as used by semantic
+  /// analysis.
+  virtual bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const = 0;
+
   virtual void emitBadCastCall(CIRGenFunction &cgf, mlir::Location loc) = 0;
 
   virtual void emitBeginCatch(CIRGenFunction &cgf,

clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp

@@ -105,6 +105,10 @@ class CIRGenItaniumCXXABI : public CIRGenCXXABI {
                                         const CXXDestructorDecl *dtor,
                                         CXXDtorType dtorType, Address thisAddr,
                                         DeleteOrMemberCallExpr e) override;
+
+  bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const override;
+  bool canSpeculativelyEmitVTableAsBaseClass(const CXXRecordDecl *RD) const;
+
   mlir::Value getVTableAddressPoint(BaseSubobject base,
                                     const CXXRecordDecl *vtableClass) override;
   mlir::Value getVTableAddressPointInStructorWithVTT(
@@ -221,6 +225,10 @@ class CIRGenItaniumCXXABI : public CIRGenCXXABI {
   /// the current ABI.
   RTTIUniquenessKind
   classifyRTTIUniqueness(QualType canTy, cir::GlobalLinkageKind linkage) const;
+
+private:
+  bool hasAnyUnusedVirtualInlineFunction(const CXXRecordDecl *rd) const;
+  bool isVTableHidden(const CXXRecordDecl *rd) const;
 };
 
 } // namespace
@@ -1789,7 +1797,7 @@ cir::GlobalOp CIRGenItaniumCXXABI::getAddrOfVTable(const CXXRecordDecl *rd,
     return vtable;
 
   // Queue up this vtable for possible deferred emission.
-  assert(!cir::MissingFeatures::deferredVtables());
+  cgm.addDeferredVTable(rd);
 
   SmallString<256> name;
   llvm::raw_svector_ostream out(name);
@@ -2575,6 +2583,126 @@ void CIRGenItaniumCXXABI::emitBeginCatch(CIRGenFunction &cgf,
   cgf.emitAutoVarCleanups(var);
 }
 
+bool CIRGenItaniumCXXABI::hasAnyUnusedVirtualInlineFunction(
+    const CXXRecordDecl *rd) const {
+  const auto &vtableLayout = cgm.getItaniumVTableContext().getVTableLayout(rd);
+
+  for (const auto &vtableComponent : vtableLayout.vtable_components()) {
+    // Skip empty slot.
+    if (!vtableComponent.isUsedFunctionPointerKind())
+      continue;
+
+    const CXXMethodDecl *method = vtableComponent.getFunctionDecl();
+    const FunctionDecl *fd = method->getDefinition();
+    const bool isInlined =
+        method->getCanonicalDecl()->isInlined() || (fd && fd->isInlined());
+    if (!isInlined)
+      continue;
+
+    StringRef name = cgm.getMangledName(
+        vtableComponent.getGlobalDecl(/*HasVectorDeletingDtors=*/false));
+    auto entry = dyn_cast_or_null<cir::GlobalOp>(cgm.getGlobalValue(name));
+    // This checks if virtual inline function has already been emitted.
+    // Note that it is possible that this inline function would be emitted
+    // after trying to emit vtable speculatively. Because of this we do
+    // an extra pass after emitting all deferred vtables to find and emit
+    // these vtables opportunistically.
+    if (!entry || entry.isDeclaration())
+      return true;
+  }
+  return false;
+}
+
+bool CIRGenItaniumCXXABI::isVTableHidden(const CXXRecordDecl *rd) const {
+  const auto &vtableLayout = cgm.getItaniumVTableContext().getVTableLayout(rd);
+
+  for (const auto &vtableComponent : vtableLayout.vtable_components()) {
+    if (vtableComponent.isRTTIKind()) {
+      const CXXRecordDecl *rttiDecl = vtableComponent.getRTTIDecl();
+      if (rttiDecl->getVisibility() == Visibility::HiddenVisibility)
+        return true;
+    } else if (vtableComponent.isUsedFunctionPointerKind()) {
+      const CXXMethodDecl *method = vtableComponent.getFunctionDecl();
+      if (method->getVisibility() == Visibility::HiddenVisibility &&
+          !method->isDefined())
+        return true;
+    }
+  }
+  return false;
+}
+
+bool CIRGenItaniumCXXABI::canSpeculativelyEmitVTableAsBaseClass(
+    const CXXRecordDecl *rd) const {
+  // We don't emit available_externally vtables if we are in -fapple-kext mode
+  // because kext mode does not permit devirtualization.
+  if (cgm.getLangOpts().AppleKext)
+    return false;
+
+  // If the vtable is hidden then it is not safe to emit an available_externally
+  // copy of vtable.
+  if (isVTableHidden(rd))
+    return false;
+
+  if (cgm.getCodeGenOpts().ForceEmitVTables)
+    return true;
+
+  // A speculative vtable can only be generated if all virtual inline functions
+  // defined by this class are emitted. The vtable in the final program contains
+  // for each virtual inline function not used in the current TU a function that
+  // is equivalent to the unused function. The function in the actual vtable
+  // does not have to be declared under the same symbol (e.g., a virtual
+  // destructor that can be substituted with its base class's destructor). Since
+  // inline functions are emitted lazily and this emissions does not account for
+  // speculative emission of a vtable, we might generate a speculative vtable
+  // with references to inline functions that are not emitted under that name.
+  // This can lead to problems when devirtualizing a call to such a function,
+  // that result in linking errors. Hence, if there are any unused virtual
+  // inline function, we cannot emit the speculative vtable.
+  // FIXME we can still emit a copy of the vtable if we
+  // can emit definition of the inline functions.
+  if (hasAnyUnusedVirtualInlineFunction(rd))
+    return false;
+
+  // For a class with virtual bases, we must also be able to speculatively
+  // emit the VTT, because CodeGen doesn't have separate notions of "can emit
+  // the vtable" and "can emit the VTT". For a base subobject, this means we
+  // need to be able to emit non-virtual base vtables.
+  if (rd->getNumVBases()) {
+    for (const auto &b : rd->bases()) {
+      auto *brd = b.getType()->getAsCXXRecordDecl();
+      assert(brd && "no class for base specifier");
+      if (b.isVirtual() || !brd->isDynamicClass())
+        continue;
+      if (!canSpeculativelyEmitVTableAsBaseClass(brd))
+        return false;
+    }
+  }
+
+  return true;
+}
+
+bool CIRGenItaniumCXXABI::canSpeculativelyEmitVTable(
+    const CXXRecordDecl *rd) const {
+  if (!canSpeculativelyEmitVTableAsBaseClass(rd))
+    return false;
+
+  if (rd->shouldEmitInExternalSource())
+    return false;
+
+  // For a complete-object vtable (or more specifically, for the VTT), we need
+  // to be able to speculatively emit the vtables of all dynamic virtual bases.
+  for (const auto &b : rd->vbases()) {
+    auto *brd = b.getType()->getAsCXXRecordDecl();
+    assert(brd && "no class for base specifier");
+    if (!brd->isDynamicClass())
+      continue;
+    if (!canSpeculativelyEmitVTableAsBaseClass(brd))
+      return false;
+  }
+
+  return true;
+}
+
 static mlir::Value performTypeAdjustment(CIRGenFunction &cgf,
                                          Address initialPtr,
                                          const CXXRecordDecl *unadjustedClass,
@@ -2598,8 +2726,23 @@ static mlir::Value performTypeAdjustment(CIRGenFunction &cgf,
   // Perform the virtual adjustment if we have one.
   mlir::Value resultPtr;
   if (virtualAdjustment) {
-    cgf.cgm.errorNYI("virtual adjustment in thunk");
-    resultPtr = v;
+    mlir::Value vtablePtr = cgf.getVTablePtr(
+        loc, Address(v, clang::CharUnits::One()), unadjustedClass);
+    vtablePtr = builder.createBitcast(vtablePtr, i8PtrTy);
+
+    mlir::Value offset;
+    mlir::Value offsetPtr =
+        cir::PtrStrideOp::create(builder, loc, i8PtrTy, vtablePtr,
+                                 builder.getSInt64(virtualAdjustment, loc));
+    if (cgf.cgm.getItaniumVTableContext().isRelativeLayout()) {
+      assert(!cir::MissingFeatures::vtableRelativeLayout());
+      cgf.cgm.errorNYI("virtual adjustment for relative layout vtables");
+    } else {
+      offset = builder.createAlignedLoad(loc, cgf.ptrDiffTy, offsetPtr,
+                                         cgf.getPointerAlign());
+    }
+
+    resultPtr = cir::PtrStrideOp::create(builder, loc, i8PtrTy, v, offset);
   } else {
     resultPtr = v;
   }

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -350,7 +350,13 @@ void CIRGenModule::emitDeferred() {
   // static function, iterate until no changes are made.
 
   assert(!cir::MissingFeatures::openMP());
-  assert(!cir::MissingFeatures::deferredVtables());
+
+  emitDeferredVTables();
+  // Emitting a vtable doesn't directly cause more vtables to
+  // become deferred, although it can cause functions to be
+  // emitted that then need those vtables.
+  assert(deferredVTables.empty());
+
   assert(!cir::MissingFeatures::cudaSupport());
 
   // Stop if we're out of both deferred vtables and deferred declarations.
@@ -368,9 +374,9 @@ void CIRGenModule::emitDeferred() {
     // If we found out that we need to emit more decls, do that recursively.
     // This has the advantage that the decls are emitted in a DFS and related
     // ones are close together, which is convenient for testing.
-    if (!deferredDeclsToEmit.empty()) {
+    if (!deferredVTables.empty() || !deferredDeclsToEmit.empty()) {
       emitDeferred();
-      assert(deferredDeclsToEmit.empty());
+      assert(deferredVTables.empty() && deferredDeclsToEmit.empty());
     }
   }
 }
@@ -2787,6 +2793,7 @@ CIRGenModule::getGlobalVisibilityAttrFromDecl(const Decl *decl) {
 
 void CIRGenModule::release() {
   emitDeferred();
+  emitVTablesOpportunistically();
   applyReplacements();
 
   theModule->setAttr(cir::CIRDialect::getModuleLevelAsmAttrName(),

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -102,6 +102,12 @@ class CIRGenModule : public CIRGenTypeCache {
 
   llvm::DenseSet<clang::GlobalDecl> diagnosedConflictingDefinitions;
 
+  /// A queue of (optional) vtables to consider emitting.
+  std::vector<const CXXRecordDecl *> deferredVTables;
+
+  /// A queue of (optional) vtables that may be emitted opportunistically.
+  std::vector<const CXXRecordDecl *> opportunisticVTables;
+
   void createCUDARuntime();
 
   /// A helper for constructAttributeList that handles return attributes.
@@ -489,6 +495,10 @@ class CIRGenModule : public CIRGenTypeCache {
   void emitExplicitCastExprType(const ExplicitCastExpr *e,
                                 CIRGenFunction *cgf = nullptr);
 
+  void addDeferredVTable(const CXXRecordDecl *rd) {
+    deferredVTables.push_back(rd);
+  }
+
   /// Emit code for a single global function or variable declaration. Forward
   /// declarations are emitted lazily.
   void emitGlobal(clang::GlobalDecl gd);
@@ -675,6 +685,16 @@ class CIRGenModule : public CIRGenTypeCache {
   /// Emit any needed decls for which code generation was deferred.
   void emitDeferred();
 
+  bool shouldOpportunisticallyEmitVTables();
+  /// Emit any vtables which we deferred and still have a use for.
+  void emitDeferredVTables();
+
+  /// Try to emit external vtables as available_externally if they have emitted
+  /// all inlined virtual functions.  It runs after EmitDeferred() and therefore
+  /// is not allowed to create new references to things that need to be emitted
+  /// lazily.
+  void emitVTablesOpportunistically();
+
   /// Helper for `emitDeferred` to apply actual codegen.
   void emitGlobalDecl(const clang::GlobalDecl &d);
 

clang/lib/CIR/CodeGen/CIRGenVTables.cpp

@@ -940,3 +940,66 @@ void CIRGenVTables::emitThunks(GlobalDecl gd) {
   for (const ThunkInfo &thunk : *thunkInfoVector)
     maybeEmitThunk(gd, thunk, /*forVTable=*/false);
 }
+
+static bool shouldEmitAvailableExternallyVTable(const CIRGenModule &cgm,
+                                                const CXXRecordDecl *rd) {
+  return cgm.getCodeGenOpts().OptimizationLevel > 0 &&
+         cgm.getCXXABI().canSpeculativelyEmitVTable(rd);
+}
+
+/// Given that we're currently at the end of the translation unit, and
+/// we've emitted a reference to the vtable for this class, should
+/// we define that vtable?
+static bool shouldEmitVTableAtEndOfTranslationUnit(CIRGenModule &cgm,
+                                                   const CXXRecordDecl *rd) {
+  // If vtable is internal then it has to be done.
+  if (!cgm.getVTables().isVTableExternal(rd))
+    return true;
+
+  // If it's external then maybe we will need it as available_externally.
+  return shouldEmitAvailableExternallyVTable(cgm, rd);
+}
+
+/// Given that at some point we emitted a reference to one or more
+/// vtables, and that we are now at the end of the translation unit,
+/// decide whether we should emit them.
+void CIRGenModule::emitDeferredVTables() {
+#ifndef NDEBUG
+  // Remember the size of DeferredVTables, because we're going to assume
+  // that this entire operation doesn't modify it.
+  size_t savedSize = deferredVTables.size();
+#endif
+  for (const CXXRecordDecl *rd : deferredVTables) {
+    if (shouldEmitVTableAtEndOfTranslationUnit(*this, rd))
+      vtables.generateClassData(rd);
+    else if (shouldOpportunisticallyEmitVTables())
+      opportunisticVTables.push_back(rd);
+  }
+
+  assert(savedSize == deferredVTables.size() &&
+         "deferred extra vtables during vtable emission?");
+  deferredVTables.clear();
+}
+
+void CIRGenModule::emitVTablesOpportunistically() {
+  // Try to emit external vtables as available_externally if they have emitted
+  // all inlined virtual functions.  It runs after EmitDeferred() and therefore
+  // is not allowed to create new references to things that need to be emitted
+  // lazily. Note that it also uses fact that we eagerly emitting RTTI.
+
+  assert(
+      (opportunisticVTables.empty() || shouldOpportunisticallyEmitVTables()) &&
+      "Only emit opportunistic vtables with optimizations");
+
+  for (const CXXRecordDecl *rd : opportunisticVTables) {
+    assert(getVTables().isVTableExternal(rd) &&
+           "This queue should only contain external vtables");
+    if (getCXXABI().canSpeculativelyEmitVTable(rd))
+      vtables.generateClassData(rd);
+  }
+  opportunisticVTables.clear();
+}
+
+bool CIRGenModule::shouldOpportunisticallyEmitVTables() {
+  return codeGenOpts.OptimizationLevel > 0;
+}

clang/test/CIR/CodeGen/vbase.cpp

@@ -51,9 +51,8 @@ void ppp() { B b; }
 // Note: OGCG speculatively emits the VTT and VTables. This is not yet implemented in CIR.
 
 // Vtable definition for B
-// CIR:  cir.global "private" external @_ZTV1B
-
-// LLVM: @_ZTV1B = external global { [3 x ptr] }
+// CIR: cir.global "private" {{.*}}@_ZTV1B = #cir.vtable<{#cir.const_array<[#cir.ptr<12 : i64> : !cir.ptr<!u8i>, #cir.ptr<null> : !cir.ptr<!u8i>, #cir.global_view<@_ZTI1B> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 3>}> : !rec_anon_struct3 {alignment = 8 : i64}
+// LLVM: @_ZTV1B = linkonce_odr global { [3 x ptr] } { [3 x ptr] [ptr inttoptr (i64 12 to ptr), ptr null, ptr @_ZTI1B] }, comdat, align 8
 
 // OGCG: @_ZTV1B = linkonce_odr unnamed_addr constant { [3 x ptr] } { [3 x ptr] [ptr inttoptr (i64 12 to ptr), ptr null, ptr @_ZTI1B] }, comdat, align 8