[ms-cxxabi] Add basic support for vector deleting destructors.

[pcc]

Summary

These destructors are used by cl.exe to implement polymorphic delete[],
a language extension which we don't support (yet). However, we
are forced by the ABI to implement some support for them. This is
because cl.exe, when compiling delete[] with a parameter of pointer to
dynamic class type, will emit a call to the vector deleting destructor
via the vftable. Unless we implement the correct semantics for this
destructor, the wrong number of objects will be deleted and the wrong
memory address will be freed.

To begin with, place a reference to the vector deleting dtor in the
vtable (instead of the scalar deleting dtor), and emit the vector
deleting dtor as a weak alias of the scalar deleting dtor. This is
what cl.exe does when the TU does not contain a new[] expression for
that class type. We don't actually emit the definition of the vector
deleting dtor yet, that will be done in a later change.

[timurrrr]

Out of date?

include/clang/Basic/ABI.h

 enum CXXCtorType {
     Ctor_Complete,          ///< Complete object ctor
     Ctor_Base,              ///< Base object ctor
     Ctor_CompleteAllocating ///< Complete object allocating ctor
 };
 
 /// \brief C++ destructor types.
 enum CXXDtorType {
-    Dtor_Deleting, ///< Deleting dtor
-    Dtor_Complete, ///< Complete object dtor
-    Dtor_Base      ///< Base object dtor
+    Dtor_Deleting,      ///< Deleting dtor
+    Dtor_Complete,      ///< Complete object dtor
+    Dtor_Base,          ///< Base object dtor
+    Dtor_VectorDeleting ///< Vector deleting dtor
 };
 
 /// \brief A return adjustment.
 struct ReturnAdjustment {
   /// \brief The non-virtual adjustment from the derived object to its
   /// nearest virtual base.
   int64_t NonVirtual;
   

lib/AST/ItaniumMangle.cpp

case Dtor_Deleting:
     Out << "D0";
     break;
   case Dtor_Complete:
     Out << "D1";
     break;
   case Dtor_Base:
     Out << "D2";
     break;
+  case Dtor_VectorDeleting:
+    llvm_unreachable("Itanium ABI does not use vector deleting dtors");
   }
 }
 
 void CXXNameMangler::mangleTemplateArgs(
                           const ASTTemplateArgumentListInfo &TemplateArgs) {
   // <template-args> ::= I <template-arg>+ E
   Out << 'I';
   for (unsigned i = 0, e = TemplateArgs.NumTemplateArgs; i != e; ++i)

lib/AST/MicrosoftMangle.cpp

void MicrosoftCXXNameMangler::manglePostfix(const DeclContext *DC,
   else {
     mangleUnqualifiedName(cast<NamedDecl>(DC));
     manglePostfix(DC->getParent(), NoFunction);
   }
 }
 
 void MicrosoftCXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
   switch (T) {
+  case Dtor_VectorDeleting:
+    Out << "?_E";
+    return;
   case Dtor_Deleting:
     Out << "?_G";
     return;
   case Dtor_Base:
     Out << "?1";
     return;
   case Dtor_Complete:
     Out << "?_D";
if (IsInstMethod)
     mangleQualifiers(Qualifiers::fromCVRMask(Proto->getTypeQuals()), false);
 
   mangleCallingConvention(T, IsInstMethod);
 
   // <return-type> ::= <type>
   //               ::= @ # structors (they have no declared return type)
   if (IsStructor) {
     if (isa<CXXDestructorDecl>(D) && D == Structor &&
-        StructorType == Dtor_Deleting) {
-      // The scalar deleting destructor takes an extra int argument.
+        (StructorType == Dtor_Deleting || StructorType == Dtor_VectorDeleting)){
+      // The deleting destructors take an extra int argument.
       // However, the FunctionType generated has 0 arguments.
       // FIXME: This is a temporary hack.
       // Maybe should fix the FunctionType creation instead?
       Out << "PAXI@Z";
       return;
     }
     Out << '@';
   } else {

lib/AST/VTableBuilder.cpp

assert(ReturnAdjustment.isEmpty() &&
            "Destructor can't have return adjustment!");
 
     // FIXME: Should probably add a layer of abstraction for vtable generation.
     if (!isMicrosoftABI()) {
       // Add both the complete destructor and the deleting destructor.
       Components.push_back(VTableComponent::MakeCompleteDtor(DD));
       Components.push_back(VTableComponent::MakeDeletingDtor(DD));
     } else {
-      // Add the scalar deleting destructor.
+      // Add the vector deleting destructor.
       Components.push_back(VTableComponent::MakeDeletingDtor(DD));
     }
   } else {
     // Add the return adjustment if necessary.
     if (!ReturnAdjustment.isEmpty())
       VTableThunks[Components.size()].Return = ReturnAdjustment;
 
     // Add the function.
case VTableComponent::CK_DeletingDtorPointer: {
         Component.getKind() == VTableComponent::CK_CompleteDtorPointer;
       
       const CXXDestructorDecl *DD = Component.getDestructorDecl();
       
       Out << DD->getQualifiedNameAsString();
       if (IsComplete)
         Out << "() [complete]";
       else if (isMicrosoftABI())
-        Out << "() [scalar deleting]";
+        Out << "() [vector deleting]";
       else
         Out << "() [deleting]";
 
       if (DD->isPure())
         Out << " [pure]";
 
       ThunkInfo Thunk = VTableThunks.lookup(I);
       if (!Thunk.isEmpty()) {
for (CXXRecordDecl::method_iterator i = MostDerivedClass->method_begin(),
     if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
       // FIXME: Should add a layer of abstraction for vtable generation.
       if (!isMicrosoftABI()) {
         IndicesMap[VTables.getMethodVTableIndex(GlobalDecl(DD, Dtor_Complete))]
           = MethodName + " [complete]";
         IndicesMap[VTables.getMethodVTableIndex(GlobalDecl(DD, Dtor_Deleting))]
           = MethodName + " [deleting]";
       } else {
-        IndicesMap[VTables.getMethodVTableIndex(GlobalDecl(DD, Dtor_Deleting))]
-          = MethodName + " [scalar deleting]";
+        IndicesMap[VTables.getMethodVTableIndex(
+            GlobalDecl(DD, Dtor_VectorDeleting))]
+          = MethodName + " [vector deleting]";
       }
     } else {
       IndicesMap[VTables.getMethodVTableIndex(MD)] = MethodName;
     }
   }
 
   // Print the vtable indices for all the member functions.
   if (!IndicesMap.empty()) {
if (const CXXMethodDecl *OverriddenMD =
 
           if (!isMicrosoftABI()) {
             // Add both the complete and deleting entries.
             MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] =
               getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Complete));
             MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] =
               getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Deleting));
           } else {
-            // Add the scalar deleting destructor.
-            MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] =
-              getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Deleting));
+            // Add the vector deleting destructor.
+            MethodVTableIndices[GlobalDecl(DD, Dtor_VectorDeleting)] =
+            getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_VectorDeleting));
           }
         } else {
           MethodVTableIndices[MD] = getMethodVTableIndex(OverriddenMD);
         }
         
         // We don't need to add an entry for this method.
         continue;
       }
if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
       if (!isMicrosoftABI()) {
         // Add the complete dtor.
         MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] = CurrentIndex++;
 
         // Add the deleting dtor.
         MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] = CurrentIndex++;
       } else {
         // Add the scalar deleting dtor.
-        MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] = CurrentIndex++;
+        MethodVTableIndices[GlobalDecl(DD, Dtor_VectorDeleting)] =
+          CurrentIndex++;
       }
     } else {
       // Add the entry.
       MethodVTableIndices[MD] = CurrentIndex++;
     }
   }
 
   if (ImplicitVirtualDtor) {

lib/CodeGen/CGCXX.cpp

bool CodeGenModule::TryEmitDefinitionAsAlias(GlobalDecl AliasDecl,
   }
 
   llvm::GlobalValue::LinkageTypes TargetLinkage
     = getFunctionLinkage(TargetDecl);
 
   if (llvm::GlobalValue::isWeakForLinker(TargetLinkage))
     return true;
 
+  EmitDefinitionAsAlias(AliasDecl, TargetDecl);
+  return false;
+}
+
+/// Emit a definition as a global alias for another definition, unconditionally.
+/// Use this function with care as it can produce invalid aliases.  Generally
+/// this function should be used only where there is an ABI requirement to emit
+/// an alias.
+void CodeGenModule::EmitDefinitionAsAlias(GlobalDecl AliasDecl,
+                                          GlobalDecl TargetDecl) {
+  llvm::GlobalValue::LinkageTypes Linkage = getFunctionLinkage(AliasDecl);
+
   // Derive the type for the alias.
   llvm::PointerType *AliasType
     = getTypes().GetFunctionType(AliasDecl)->getPointerTo();
 
   // Find the referrent.  Some aliases might require a bitcast, in
   // which case the caller is responsible for ensuring the soundness
   // of these semantics.
   llvm::GlobalValue *Ref = cast<llvm::GlobalValue>(GetAddrOfGlobal(TargetDecl));
if (Entry) {
     Entry->replaceAllUsesWith(Alias);
     Entry->eraseFromParent();
   } else {
     Alias->setName(MangledName);
   }
 
   // Finally, set up the alias with its proper name and attributes.
   SetCommonAttributes(cast<NamedDecl>(AliasDecl.getDecl()), Alias);
-
-  return false;
 }
 
 void CodeGenModule::EmitCXXConstructors(const CXXConstructorDecl *D) {
   // The constructor used for constructing this as a complete class;
   // constucts the virtual bases, then calls the base constructor.
   if (!D->getParent()->isAbstract()) {
     // We don't need to emit the complete ctor if the class is abstract.
     EmitGlobal(GlobalDecl(D, Ctor_Complete));
void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *dtor,
 
   // The base destructor is equivalent to the base destructor of its
   // base class if there is exactly one non-virtual base class with a
   // non-trivial destructor, there are no fields with a non-trivial
   // destructor, and the body of the destructor is trivial.
   if (dtorType == Dtor_Base && !TryEmitBaseDestructorAsAlias(dtor))
     return;
 
+  // The Microsoft ABI requires that the vector deleting destructor
+  // be weak aliased to the scalar deleting destructor.
+  // TODO: emission of the vector deleting destructor (when required).
+  if (dtorType == Dtor_VectorDeleting) {
+    EmitDefinitionAsAlias(GlobalDecl(dtor, Dtor_VectorDeleting),
+                          GlobalDecl(dtor, Dtor_Deleting));
+    return;
+  }
+
   const CGFunctionInfo &fnInfo =
     getTypes().arrangeCXXDestructor(dtor, dtorType);
 
   llvm::Function *fn =
     cast<llvm::Function>(GetAddrOfCXXDestructor(dtor, dtorType, &fnInfo));
   setFunctionLinkage(GlobalDecl(dtor, dtorType), fn);
 
   CodeGenFunction(*this).GenerateCode(GlobalDecl(dtor, dtorType), fn, fnInfo);

lib/CodeGen/CGClass.cpp

void CodeGenFunction::EmitDestructorBody(FunctionArgList &Args) {
   RunCleanupsScope DtorEpilogue(*this);
   
   // If this is the complete variant, just invoke the base variant;
   // the epilogue will destruct the virtual bases.  But we can't do
   // this optimization if the body is a function-try-block, because
   // we'd introduce *two* handler blocks.
   switch (DtorType) {
   case Dtor_Deleting: llvm_unreachable("already handled deleting case");
+  case Dtor_VectorDeleting: llvm_unreachable("TODO");
 
   case Dtor_Complete:
     // Enter the cleanup scopes for virtual bases.
     EnterDtorCleanups(Dtor, Dtor_Complete);
 
     if (!isTryBody) {
       EmitCXXDestructorCall(Dtor, Dtor_Base, /*ForVirtualBase=*/false,
                             /*Delegating=*/false, LoadCXXThis());

lib/CodeGen/CGVTables.cpp

case VTableComponent::CK_DeletingDtorPointer: {
         llvm_unreachable("Unexpected vtable component kind");
       case VTableComponent::CK_FunctionPointer:
         GD = Component.getFunctionDecl();
         break;
       case VTableComponent::CK_CompleteDtorPointer:
         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
         break;
       case VTableComponent::CK_DeletingDtorPointer:
-        GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
+        GD = GlobalDecl(Component.getDestructorDecl(),
+                        CGM.getTarget().getCXXABI().isMicrosoft()
+                          ? Dtor_VectorDeleting
+                          : Dtor_Deleting);
         break;
       }
 
       if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
         // We have a pure virtual member function.
         if (!PureVirtualFn) {
           llvm::FunctionType *Ty = 
             llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);

lib/CodeGen/CodeGenModule.h

private:
   void EmitAliasDefinition(GlobalDecl GD);
   void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D);
   void EmitObjCIvarInitializations(ObjCImplementationDecl *D);
   
   // C++ related functions.
 
   bool TryEmitDefinitionAsAlias(GlobalDecl Alias, GlobalDecl Target);
   bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D);
+  void EmitDefinitionAsAlias(GlobalDecl Alias, GlobalDecl Target);
 
   void EmitNamespace(const NamespaceDecl *D);
   void EmitLinkageSpec(const LinkageSpecDecl *D);
   void CompleteDIClassType(const CXXMethodDecl* D);
 
   /// EmitCXXConstructors - Emit constructors (base, complete) from a
   /// C++ constructor Decl.
   void EmitCXXConstructors(const CXXConstructorDecl *D);

lib/CodeGen/CodeGenModule.cpp

CodeGenModule::getFunctionLinkage(GlobalDecl GD) {
   
   // In C99 mode, 'inline' functions are guaranteed to have a strong
   // definition somewhere else, so we can use available_externally linkage.
   if (Linkage == GVA_C99Inline)
     return llvm::Function::AvailableExternallyLinkage;
 
   // In the Microsoft ABI, most destructor types are not emitted with the
   // definition, and must be emitted on demand.  Give these linkonce_odr
-  // linkage.
+  // linkage, with the exception of vector deleting destructors, which get
+  // weak linkage because they may not necessarily be referenced in the
+  // translation unit which requires them to be emitted, and they may be
+  // overridden by other translation units.
   if (getTarget().getCXXABI().isMicrosoft() && isa<CXXDestructorDecl>(D)) {
-    if (GD.getDtorType() != Dtor_Base)
+    if (GD.getDtorType() == Dtor_VectorDeleting)
+      return llvm::Function::WeakAnyLinkage;
+    else if (GD.getDtorType() != Dtor_Base)
       return llvm::Function::LinkOnceODRLinkage;
   }
 
   // Note that Apple's kernel linker doesn't support symbol
   // coalescing, so we need to avoid linkonce and weak linkages there.
   // Normally, this means we just map to internal, but for explicit
   // instantiations we'll map to external.
 

lib/CodeGen/MicrosoftCXXABI.cpp

 
 void MicrosoftCXXABI::BuildDestructorSignature(const CXXDestructorDecl *Dtor,
                                                CXXDtorType Type,
                                                CanQualType &ResTy,
                                         SmallVectorImpl<CanQualType> &ArgTys) {
   // 'this' is already in place
   // TODO: 'for base' flag
 
-  if (Type == Dtor_Deleting) {
+  if (Type == Dtor_Deleting || Type == Dtor_VectorDeleting) {
     // The deleting destructors take an implicit int parameter.
     ArgTys.push_back(CGM.getContext().IntTy);
   }
 }
 
 static bool IsDeletingDtor(GlobalDecl GD) {
   const CXXMethodDecl* MD = cast<CXXMethodDecl>(GD.getDecl());
   if (isa<CXXDestructorDecl>(MD)) {
-    return GD.getDtorType() == Dtor_Deleting;
+    return GD.getDtorType() == Dtor_Deleting ||
+           GD.getDtorType() == Dtor_VectorDeleting;
   }
   return false;
 }
 
 void MicrosoftCXXABI::BuildInstanceFunctionParams(CodeGenFunction &CGF,
                                                   QualType &ResTy,
                                                   FunctionArgList &Params) {
   BuildThisParam(CGF, Params);
RValue MicrosoftCXXABI::EmitVirtualDestructorCall(CodeGenFunction &CGF,
                                                   SourceLocation CallLoc,
                                                   ReturnValueSlot ReturnValue,
                                                   llvm::Value *This) {
   assert(DtorType == Dtor_Deleting || DtorType == Dtor_Complete);
 
   // We have only one destructor in the vftable but can get both behaviors
   // by passing an implicit bool parameter.
   const CGFunctionInfo *FInfo
-      = &CGM.getTypes().arrangeCXXDestructor(Dtor, Dtor_Deleting);
+      = &CGM.getTypes().arrangeCXXDestructor(Dtor, Dtor_VectorDeleting);
   llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
-  llvm::Value *Callee = CGF.BuildVirtualCall(Dtor, Dtor_Deleting, This, Ty);
+  llvm::Value *Callee
+    = CGF.BuildVirtualCall(Dtor, Dtor_VectorDeleting, This, Ty);
 
   ASTContext &Context = CGF.getContext();
   llvm::Value *ImplicitParam
    = llvm::ConstantInt::get(llvm::IntegerType::getInt32Ty(CGF.getLLVMContext()),
                             DtorType == Dtor_Deleting);
 
   return CGF.EmitCXXMemberCall(Dtor, CallLoc, Callee, ReturnValue, This,
                                ImplicitParam, Context.IntTy, 0, 0);

test/CodeGenCXX/microsoft-abi-structors.cpp

 };
 
 A::A() {}
 void A::f() {}
 
 // The emission of the ctor requires emission of the vtable and therefore
 // of the other dtor forms, despite not being defined in this TU.
 
+// DTOR5: @"\01??_EA@bodyless_dtors@@UAEPAXI@Z" = alias weak void (%"struct.bodyless_dtors::A"*, i32)* @"\01??_GA@bodyless_dtors@@UAEPAXI@Z"
 // DTOR5: define linkonce_odr x86_thiscallcc void @"\01??_GA@bodyless_dtors@@UAEPAXI@Z"(%"struct.bodyless_dtors::A"* %this, i32 %flags)
 // DTORS: define linkonce_odr x86_thiscallcc void @"\01??_DA@bodyless_dtors@@UAE@XZ"(%"struct.bodyless_dtors::A"* %this)
 
 }
 
 namespace virtual_bases {
 
 struct A {

test/CodeGenCXX/microsoft-abi-vtables-single-inheritance.cpp

struct B : A {
   virtual void f();  // overrides A::f()
   virtual void i();
   virtual void j();
 };
 void B::f() {}
 
 struct C {
   // CHECK-C: Vtable for 'C' (2 entries)
-  // CHECK-C-NEXT: 0 | C::~C() [scalar deleting]
+  // CHECK-C-NEXT: 0 | C::~C() [vector deleting]
   // CHECK-C-NEXT: 1 | void C::f()
   // CHECK-C: VTable indices for 'C' (2 entries).
-  // CHECK-C-NEXT: 0 | C::~C() [scalar deleting]
+  // CHECK-C-NEXT: 0 | C::~C() [vector deleting]
   // CHECK-C-NEXT: 1 | void C::f()
   // Never used, so doesn't emit a vtable.
   virtual ~C();
 
   virtual void f();
 };
 void C::f() {}
 
 struct D {
   // CHECK-D: Vtable for 'D' (2 entries)
   // CHECK-D-NEXT: 0 | void D::f()
-  // CHECK-D-NEXT: 1 | D::~D() [scalar deleting]
+  // CHECK-D-NEXT: 1 | D::~D() [vector deleting]
   // EMITS-VTABLE: @"\01??_7D@@6B@" = unnamed_addr constant [2 x i8*]
   virtual void f();
 
   virtual ~D();
 };
 void D::f() {}
 
 struct E : A {
   // CHECK-E: Vtable for 'E' (5 entries)
   // CHECK-E-NEXT: 0 | void A::f()
   // CHECK-E-NEXT: 1 | void A::g()
   // CHECK-E-NEXT: 2 | void A::h()
-  // CHECK-E-NEXT: 3 | E::~E() [scalar deleting]
+  // CHECK-E-NEXT: 3 | E::~E() [vector deleting]
   // CHECK-E-NEXT: 4 | void E::i()
   // CHECK-E: VTable indices for 'E' (2 entries).
-  // CHECK-E-NEXT: 3 | E::~E() [scalar deleting]
+  // CHECK-E-NEXT: 3 | E::~E() [vector deleting]
   // CHECK-E-NEXT: 4 | void E::i()
 
   // Never used, so doesn't emit a vtable.
   virtual ~E();
   virtual void i();
 };
 void E::i() {}
 
 struct F : A {
   // CHECK-F: Vtable for 'F' (5 entries)
   // CHECK-F-NEXT: 0 | void A::f()
   // CHECK-F-NEXT: 1 | void A::g()
   // CHECK-F-NEXT: 2 | void A::h()
   // CHECK-F-NEXT: 3 | void F::i()
-  // CHECK-F-NEXT: 4 | F::~F() [scalar deleting]
+  // CHECK-F-NEXT: 4 | F::~F() [vector deleting]
   // CHECK-F: VTable indices for 'F' (2 entries).
   // CHECK-F-NEXT: 3 | void F::i()
-  // CHECK-F-NEXT: 4 | F::~F() [scalar deleting]
+  // CHECK-F-NEXT: 4 | F::~F() [vector deleting]
   // EMITS-VTABLE: @"\01??_7F@@6B@" = unnamed_addr constant [5 x i8*]
   virtual void i();
   virtual ~F();
 };
 void F::i() {}
 
 struct G : E {
   // CHECK-G: Vtable for 'G' (6 entries)
   // CHECK-G-NEXT: 0 | void G::f()
   // CHECK-G-NEXT: 1 | void A::g()
   // CHECK-G-NEXT: 2 | void A::h()
-  // CHECK-G-NEXT: 3 | G::~G() [scalar deleting]
+  // CHECK-G-NEXT: 3 | G::~G() [vector deleting]
   // CHECK-G-NEXT: 4 | void E::i()
   // CHECK-G-NEXT: 5 | void G::j()
   // CHECK-G: VTable indices for 'G' (3 entries).
   // CHECK-G-NEXT: 0 | void G::f()
-  // CHECK-G-NEXT: 3 | G::~G() [scalar deleting]
+  // CHECK-G-NEXT: 3 | G::~G() [vector deleting]
   // CHECK-G-NEXT: 5 | void G::j()
   // Never used, so doesn't emit a vtable.
   virtual void f();  // overrides A::f()
   virtual ~G();
   virtual void j();
 };
 void G::j() {}