[ms-cxxabi] Fix the base/complete dtor logic.

[pcc]

Summary

Previously it was thought that the Microsoft ABI used '?1' for
complete dtors. In fact, '?1' is for base dtors, and '?_D' is for
complete dtors. (Some confusion arose from documentation referring
to complete dtors as 'vbase dtors'.) The dtor forms other than the
base dtor are emitted by a TU when required by that TU, even when
the body is not present.

Also, fix the implicit parameter belonging to deleting destructors.
That parameter is an integer, not a boolean.

[rnk]

test/CodeGenCXX/microsoft-abi-structors.cpp

238

So, in the MS ABI, key methods basically don't exist, right? All class data is all comdat, all the time, and only emitted if it's used in the TU. At least that's what I see so far.

[pcc]

test/CodeGenCXX/microsoft-abi-structors.cpp

238

That's also my understanding.

[timurrrr]

Previously it was thought that the Microsoft ABI used '?1' for
complete dtors. In fact, '?1' is for base dtors, and '?_D' is for
complete dtors. (Some confusion arose from documentation referring
to complete dtors as 'vbase dtors'.)

Well if you look at the debug information CL generates for this code:

struct A { virtual ~A(); };
struct B : virtual A { virtual ~B(); };

you'll notice that ??1B@@UAE@XZ is B::~B
and ??_DB@@QAEXXZ is B::'vbase destructor'.

Yes, one needs to use a ?_D in order to destroy an object of a class with virtual bases - so "vbase dtor" means "the one that destroys the virtual bases as its last action" and yes it's similar to Itanium's complete destructors in this sense.

However, destroying an object of a class without virtual bases in Microsoft ABI doesn't need to use a ?_D destructor and it uses a ?1 dtor [and this saves us some size on each object file],
in contrast with the Itanium ABI which always uses complete dtors to destroy objects, but optimizes the object file sizes by using dtor type aliases.

Do you agree with this data points and reasoning?

I'd still prefer that we use ?1.

Can you for example let the CGCXXABI tell you which CXXDtorType to use to destroy an object of a given type?
Or at least add a few FIXME that this in fact should be ?1 but works for us as long as we define extra auxillary dtors.

lib/AST/MicrosoftMangle.cpp

509

Please add a test that checks mangling of a static in a destructor of a class with virtual bases

lib/CodeGen/CGCXX.cpp

244

This comment is no longer true?

You should also describe how Base/Complete/Deleting dtors work as a comment somewhere in MicrosoftCXXABI
or generalize the comments at the CXXDtorType definition
(e.g. Base = dtor to destroy this as a base or as a complete object if there are no virtual bases, etc)

test/CodeGenCXX/microsoft-abi-structors.cpp

55

I think these should be checked by an extra FileChecker invocation to be 100% they are not emitted in this TU.

247

how about
"of the auxillary dtor types, despite the base destructor is not being defined in this TU."

250

In fact, defining a vbase destructor is not required in this TU if we get back to using ?1 dtors for classes without virtual bases.

[timurrrr]

which always uses complete dtors to destroy objects

Correction: I've accidentally ignored the existence of deleting/virtual destructors while writing this, but it doesn't change the remaining logic.

[timurrrr]

you'll notice that ??1B@@UAE@XZ is B::~B
and ??_DB@@QAEXXZ is B::'vbase destructor'.

I've forgotten to add the emphasis: ?1B@ does not mean "B base destructor", it really just means "B destructor".
Well, you can tell it is a "B base destructor", but with a slightly different meaning of "base" (not only a base class but also "B basic/simple destructor").

[timurrrr]

I suppose a similar patch has landed already?
Can we close this one?

include/clang/Basic/TargetCXXABI.h

public:
   }
 
   /// \brief Does this ABI have different entrypoints for complete-object
   /// and base-subobject constructors?
   bool hasConstructorVariants() const {
     return isItaniumFamily();
   }
 
-  /// \brief Does this ABI have different entrypoints for complete-object
-  /// and base-subobject destructors?
-  bool hasDestructorVariants() const {
-    return isItaniumFamily();
-  }
-
   /// \brief Does this ABI allow virtual bases to be primary base classes?
   bool hasPrimaryVBases() const {
     return isItaniumFamily();
   }
 
   /// \brief Can an out-of-line inline function serve as a key function?
   ///
   /// This flag is only useful in ABIs where type data (for example,

lib/AST/MicrosoftMangle.cpp

case DeclarationName::CXXConstructorName:
       break;
       
     case DeclarationName::CXXDestructorName:
       if (ND == Structor)
         // If the named decl is the C++ destructor we're mangling,
         // use the type we were given.
         mangleCXXDtorType(static_cast<CXXDtorType>(StructorType));
       else
-        // Otherwise, use the complete destructor name. This is relevant if a
+        // Otherwise, use the base destructor name. This is relevant if a
         // class with a destructor is declared within a destructor.
-        mangleCXXDtorType(Dtor_Complete);
+        mangleCXXDtorType(Dtor_Base);
       break;
       
     case DeclarationName::CXXConversionFunctionName:
       // <operator-name> ::= ?B # (cast)
       // The target type is encoded as the return type.
       Out << "?B";
       break;
       

 }
 
 void MicrosoftCXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
   switch (T) {
   case Dtor_Deleting:
     Out << "?_G";
     return;
   case Dtor_Base:
-    // FIXME: We should be asked to mangle base dtors.
-    // However, fixing this would require larger changes to the CodeGenModule.
-    // Please put llvm_unreachable here when CGM is changed.
-    // For now, just mangle a base dtor the same way as a complete dtor...
-  case Dtor_Complete:
     Out << "?1";
     return;
+  case Dtor_Complete:
+    Out << "?_D";
+    return;
   }
   llvm_unreachable("Unsupported dtor type?");
 }
 
 void MicrosoftCXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO,
                                                  SourceLocation Loc) {
   switch (OO) {
   //                     ?0 # constructor

lib/CodeGen/CGCXX.cpp

if (!fnInfo)
     fnInfo = &getTypes().arrangeCXXConstructorDeclaration(ctor, ctorType);
 
   llvm::FunctionType *fnType = getTypes().GetFunctionType(*fnInfo);
   return cast<llvm::Function>(GetOrCreateLLVMFunction(name, fnType, GD,
                                                       /*ForVTable=*/false));
 }
 
 void CodeGenModule::EmitCXXDestructors(const CXXDestructorDecl *D) {
+  if (getTarget().getCXXABI().isItaniumFamily()) {
     // The destructor in a virtual table is always a 'deleting'
     // destructor, which calls the complete destructor and then uses the
     // appropriate operator delete.
     if (D->isVirtual())
       EmitGlobal(GlobalDecl(D, Dtor_Deleting));
    
     // The destructor used for destructing this as a most-derived class;
     // call the base destructor and then destructs any virtual bases.
     EmitGlobal(GlobalDecl(D, Dtor_Complete));
+  }
 
   // The destructor used for destructing this as a base class; ignores
   // virtual bases.
   EmitGlobal(GlobalDecl(D, Dtor_Base));
 }
 
 void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *dtor,
                                       CXXDtorType dtorType) {
   // The complete destructor is equivalent to the base destructor for
   // classes with no virtual bases, so try to emit it as an alias.

lib/CodeGen/CGClass.cpp

void CodeGenFunction::EmitDestructorBody(FunctionArgList &Args) {
   // we'd introduce *two* handler blocks.
   switch (DtorType) {
   case Dtor_Deleting: llvm_unreachable("already handled deleting case");
 
   case Dtor_Complete:
     // Enter the cleanup scopes for virtual bases.
     EnterDtorCleanups(Dtor, Dtor_Complete);
 
-    if (!isTryBody &&
-        CGM.getTarget().getCXXABI().hasDestructorVariants()) {
+    if (!isTryBody) {
       EmitCXXDestructorCall(Dtor, Dtor_Base, /*ForVirtualBase=*/false,
                             /*Delegating=*/false, LoadCXXThis());
       break;
     }
     // Fallthrough: act like we're in the base variant.
       
   case Dtor_Base:
     // Enter the cleanup scopes for fields and non-virtual bases.

lib/CodeGen/CodeGenModule.cpp

CodeGenModule::getFunctionLinkage(GlobalDecl GD) {
   if (D->hasAttr<WeakAttr>())
     return llvm::Function::WeakAnyLinkage;
   
   // 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.
+  if (getTarget().getCXXABI().isMicrosoft() && isa<CXXDestructorDecl>(D)) {
+    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.
 
   // In C++, the compiler has to emit a definition in every translation unit
   // that references the function.  We should use linkonce_odr because
   // a) if all references in this translation unit are optimized away, we

lib/CodeGen/MicrosoftCXXABI.cpp

virtual llvm::Constant *EmitMemberPointerConversion(const CastExpr *E,
                                                       llvm::Constant *Src);
 
   virtual llvm::Value *
   EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
                                   llvm::Value *&This,
                                   llvm::Value *MemPtr,
                                   const MemberPointerType *MPT);
 
+  virtual bool NeedsBodylessEmission(GlobalDecl GD);
+
 };
 
 }
 
 llvm::Value *MicrosoftCXXABI::adjustToCompleteObject(CodeGenFunction &CGF,
                                                      llvm::Value *ptr,
                                                      QualType type) {
   // FIXME: implement

 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) {
-    // The scalar deleting destructor takes an implicit bool parameter.
-    ArgTys.push_back(CGM.getContext().BoolTy);
+    // 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;
   }
if (isa<CXXConstructorDecl>(MD) && MD->getParent()->getNumVBases()) {
     ImplicitParamDecl *IsMostDerived
       = ImplicitParamDecl::Create(Context, 0,
                                   CGF.CurGD.getDecl()->getLocation(),
                                   &Context.Idents.get("is_most_derived"),
                                   Context.IntTy);
     Params.push_back(IsMostDerived);
     getStructorImplicitParamDecl(CGF) = IsMostDerived;
   } else if (IsDeletingDtor(CGF.CurGD)) {
-    ImplicitParamDecl *ShouldDelete
+    // Deleting dtors decide their behavior based on the second parameter,
+    // an integer in which the 2 lowest bits are significant.  The lower bit
+    // decides whether to deallocate memory, and the higher bit decides whether
+    // to treat the operand like an array allocated with 'new []'.
+    ImplicitParamDecl *Flags
       = ImplicitParamDecl::Create(Context, 0,
                                   CGF.CurGD.getDecl()->getLocation(),
-                                  &Context.Idents.get("should_call_delete"),
-                                  Context.BoolTy);
-    Params.push_back(ShouldDelete);
-    getStructorImplicitParamDecl(CGF) = ShouldDelete;
+                                  &Context.Idents.get("flags"),
+                                  Context.IntTy);
+    Params.push_back(Flags);
+    getStructorImplicitParamDecl(CGF) = Flags;
   }
 }
 
 void MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
   EmitThisParam(CGF);
   if (needThisReturn(CGF.CurGD)) {
     CGF.Builder.CreateStore(getThisValue(CGF), CGF.ReturnValue);
   }
void MicrosoftCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
   }
 
   if (IsDeletingDtor(CGF.CurGD)) {
     assert(getStructorImplicitParamDecl(CGF) &&
            "no implicit parameter for a deleting destructor?");
     getStructorImplicitParamValue(CGF)
       = CGF.Builder.CreateLoad(
           CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)),
-          "should_call_delete");
+          "flags");
   }
 }
 
 llvm::Value *MicrosoftCXXABI::EmitConstructorCall(CodeGenFunction &CGF,
                                           const CXXConstructorDecl *D,
                                           CXXCtorType Type, bool ForVirtualBase,
                                           bool Delegating,
                                           llvm::Value *This,
RValue MicrosoftCXXABI::EmitVirtualDestructorCall(CodeGenFunction &CGF,
   // by passing an implicit bool parameter.
   const CGFunctionInfo *FInfo
       = &CGM.getTypes().arrangeCXXDestructor(Dtor, Dtor_Deleting);
   llvm::Type *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
   llvm::Value *Callee = CGF.BuildVirtualCall(Dtor, Dtor_Deleting, This, Ty);
 
   ASTContext &Context = CGF.getContext();
   llvm::Value *ImplicitParam
-    = llvm::ConstantInt::get(llvm::IntegerType::getInt1Ty(CGF.getLLVMContext()),
-                             DtorType == Dtor_Deleting);
+   = llvm::ConstantInt::get(llvm::IntegerType::getInt32Ty(CGF.getLLVMContext()),
 
   return CGF.EmitCXXMemberCall(Dtor, CallLoc, Callee, ReturnValue, This,
-                               ImplicitParam, Context.BoolTy, 0, 0);
+                               ImplicitParam, Context.IntTy, 0, 0);
 }
 
 bool MicrosoftCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
                                    QualType elementType) {
   // Microsoft seems to completely ignore the possibility of a
   // two-argument usual deallocation function.
   return elementType.isDestructedType();
 }
if (NonVirtualBaseAdjustment) {
     llvm::Value *Ptr = Builder.CreateBitCast(This, Builder.getInt8PtrTy());
     Ptr = Builder.CreateInBoundsGEP(Ptr, NonVirtualBaseAdjustment);
     This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
   }
 
   return Builder.CreateBitCast(FunctionPointer, FTy->getPointerTo());
 }
 
+bool MicrosoftCXXABI::NeedsBodylessEmission(GlobalDecl GD) {
+  // In the Microsoft ABI, all destructor types except the base destructor are
+  // not emitted with the definition, and must be emitted on demand.
+  if (isa<CXXDestructorDecl>(GD.getDecl()))
+    return GD.getDtorType() != Dtor_Base;
+  return false;
+}
+
 CGCXXABI *clang::CodeGen::CreateMicrosoftCXXABI(CodeGenModule &CGM) {
   return new MicrosoftCXXABI(CGM);
 }
 

test/CodeGenCXX/microsoft-abi-static-initializers.cpp

 // RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s
 
 struct S {
-  S() {}
-  ~S() {}
+  S();
+  ~S();
 } s;
 
 // CHECK: define internal void [[INIT_s:@.*global_var.*]] [[NUW:#[0-9]+]]
 // CHECK: %{{[.0-9A-Z_a-z]+}} = call x86_thiscallcc %struct.S* @"\01??0S@@QAE@XZ"
 // CHECK: call i32 @atexit(void ()* @"__dtor_\01?s@@3US@@A")
 // CHECK: ret void
 
-// CHECK: define internal void @"__dtor_\01?s@@3US@@A"() [[NUW]] {
+// CHECK: define linkonce_odr x86_thiscallcc void @"\01??_DS@@QAE@XZ"
 // CHECK: call x86_thiscallcc void @"\01??1S@@QAE@XZ"
 // CHECK: ret void
 
+// CHECK: define internal void @"__dtor_\01?s@@3US@@A"() [[NUW]] {
+// CHECK: call x86_thiscallcc void @"\01??_DS@@QAE@XZ"
+// CHECK: ret void
+
 // Force WeakODRLinkage by using templates
 class A {
  public:
   A() {}
   ~A() {}
 };
 
 template<typename T>

 
 // CHECK: define internal void [[INIT_foo:@.*global_var.*]] [[NUW]]
 // CHECK: %{{[.0-9A-Z_a-z]+}} = call x86_thiscallcc %class.A* @"\01??0A@@QAE@XZ"
 // CHECK: call i32 @atexit(void ()* [[FOO_DTOR:@"__dtor_.*foo@.*]])
 // CHECK: ret void
 
 // CHECK: define linkonce_odr x86_thiscallcc %class.A* @"\01??0A@@QAE@XZ"
 
-// CHECK: define linkonce_odr x86_thiscallcc void @"\01??1A@@QAE@XZ"
-
 // CHECK: define internal void [[FOO_DTOR]]
-// CHECK: call x86_thiscallcc void @"\01??1A@@QAE@XZ"{{.*}}foo
+// CHECK: call x86_thiscallcc void @"\01??_DA@@QAE@XZ"{{.*}}foo
 // CHECK: ret void
 
+// CHECK: define linkonce_odr x86_thiscallcc void @"\01??1A@@QAE@XZ"
+
 // CHECK: define internal void @_GLOBAL__I_a() [[NUW]] {
 // CHECK: call void [[INIT_s]]
 // CHECK: call void [[INIT_foo]]
 // CHECK: ret void
 
 // CHECK: attributes [[NUW]] = { nounwind }

test/CodeGenCXX/microsoft-abi-structors.cpp

 // RUN: %clang_cc1 -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 -fno-rtti > %t 2>&1
 // RUN: FileCheck %s < %t
-// Using a different check prefix as the inline destructors might be placed
+// Using a different check prefix as the inline con/destructors might be placed
 // anywhere in the output.
-// RUN: FileCheck --check-prefix=DTORS %s < %t
+// RUN: FileCheck --check-prefix=CTOR1 %s < %t
+// RUN: FileCheck --check-prefix=DTOR1 %s < %t
+// RUN: FileCheck --check-prefix=DTOR2 %s < %t
+// RUN: FileCheck --check-prefix=DTOR3 %s < %t
+// RUN: FileCheck --check-prefix=DTOR4 %s < %t
+// RUN: FileCheck --check-prefix=DTOR5 %s < %t
+// RUN: FileCheck --check-prefix=DTOR6 %s < %t
 
 namespace basic {
 
 class A {
  public:
   A() { }
   ~A() { }
 };
 
 void no_constructor_destructor_infinite_recursion() {
   A a;
 
 // CHECK:      define linkonce_odr x86_thiscallcc %"class.basic::A"* @"\01??0A@basic@@QAE@XZ"(%"class.basic::A"* %this)
 // CHECK:        [[THIS_ADDR:%[.0-9A-Z_a-z]+]] = alloca %"class.basic::A"*, align 4
 // CHECK-NEXT:   store %"class.basic::A"* %this, %"class.basic::A"** [[THIS_ADDR]], align 4
 // CHECK-NEXT:   [[T1:%[.0-9A-Z_a-z]+]] = load %"class.basic::A"** [[THIS_ADDR]]
 // CHECK-NEXT:   ret %"class.basic::A"* [[T1]]
 // CHECK-NEXT: }
 
 // Make sure that the destructor doesn't call itself:
-// CHECK: define {{.*}} @"\01??1A@basic@@QAE@XZ"
-// CHECK-NOT: call void @"\01??1A@basic@@QAE@XZ"
-// CHECK: ret
+// DTOR1: define {{.*}} @"\01??1A@basic@@QAE@XZ"
+// DTOR1-NOT: call void @"\01??1A@basic@@QAE@XZ"
+// DTOR1: ret
 }
 
 struct B {
   B();
+  ~B();
 };
 
 // Tests that we can define constructors outside the class (PR12784).
 B::B() {
   // CHECK: define x86_thiscallcc %"struct.basic::B"* @"\01??0B@basic@@QAE@XZ"(%"struct.basic::B"* %this)
   // CHECK: ret
 }
 
+// Tests that we can define destructors outside the class.
+B::~B() {
+  // CHECK: define x86_thiscallcc void @"\01??1B@basic@@QAE@XZ"(%"struct.basic::B"* %this)
+  // CHECK: ret
+}
+
+// We shouldn't emit the other destructor forms as they aren't needed by the TU.
+// CHECK-NOT: @"\01??_DB@basic@@UAE@XZ"
+// CHECK-NOT: @"\01??_GB@basic@@UAEPAXI@Z"
+// CHECK-NOT: @"\01??_EB@basic@@UAEPAXI@Z"
+
 struct C {
   virtual ~C() {
 // Complete destructor first:
-// DTORS: define {{.*}} x86_thiscallcc void @"\01??1C@basic@@UAE@XZ"(%"struct.basic::C"* %this)
+// DTOR2: define {{.*}} x86_thiscallcc void @"\01??1C@basic@@UAE@XZ"(%"struct.basic::C"* %this)
 
 // Then, the scalar deleting destructor (used in the vtable):
 // FIXME: add a test that verifies that the out-of-line scalar deleting
 // destructor is linkonce_odr too.
-// DTORS:      define linkonce_odr x86_thiscallcc void @"\01??_GC@basic@@UAEPAXI@Z"(%"struct.basic::C"* %this, i1 zeroext %should_call_delete)
-// DTORS:        %[[FROMBOOL:[0-9a-z]+]] = zext i1 %should_call_delete to i8
-// DTORS-NEXT:   store i8 %[[FROMBOOL]], i8* %[[SHOULD_DELETE_VAR:[0-9a-z._]+]], align 1
-// DTORS:        %[[SHOULD_DELETE_VALUE:[0-9a-z._]+]] = load i8* %[[SHOULD_DELETE_VAR]]
-// DTORS:        call x86_thiscallcc void @"\01??1C@basic@@UAE@XZ"(%"struct.basic::C"* %[[THIS:[0-9a-z]+]])
-// DTORS-NEXT:   %[[CONDITION:[0-9]+]] = icmp eq i8 %[[SHOULD_DELETE_VALUE]], 0
-// DTORS-NEXT:   br i1 %[[CONDITION]], label %[[CONTINUE_LABEL:[0-9a-z._]+]], label %[[CALL_DELETE_LABEL:[0-9a-z._]+]]
-//
-// DTORS:      [[CALL_DELETE_LABEL]]
-// DTORS-NEXT:   %[[THIS_AS_VOID:[0-9a-z]+]] = bitcast %"struct.basic::C"* %[[THIS]] to i8*
-// DTORS-NEXT:   call void @"\01??3@YAXPAX@Z"(i8* %[[THIS_AS_VOID]]) [[NUW:#[0-9]+]]
-// DTORS-NEXT:   br label %[[CONTINUE_LABEL]]
+// DTOR3:      define linkonce_odr x86_thiscallcc void @"\01??_GC@basic@@UAEPAXI@Z"(%"struct.basic::C"* %this, i32 %flags)
+// DTOR3:        store i32 %flags, i32* %[[FLAGS_VAR:[0-9a-z._]+]], align 4
+// DTOR3:        %[[FLAGS_VALUE:[0-9a-z._]+]] = load i32* %[[FLAGS_VAR]]
+// DTOR3:        call x86_thiscallcc void @"\01??_DC@basic@@UAE@XZ"(%"struct.basic::C"* %[[THIS:[0-9a-z]+]])
+// DTOR3-NEXT:   %[[CONDITION:[0-9]+]] = icmp eq i32 %[[FLAGS_VALUE]], 0
+// DTOR3-NEXT:   br i1 %[[CONDITION]], label %[[CONTINUE_LABEL:[0-9a-z._]+]], label %[[CALL_DELETE_LABEL:[0-9a-z._]+]]
+//
+// DTOR3:      [[CALL_DELETE_LABEL]]
+// DTOR3-NEXT:   %[[THIS_AS_VOID:[0-9a-z]+]] = bitcast %"struct.basic::C"* %[[THIS]] to i8*
+// DTOR3-NEXT:   call void @"\01??3@YAXPAX@Z"(i8* %[[THIS_AS_VOID]]) [[NUW:#[0-9]+]]
+// DTOR3-NEXT:   br label %[[CONTINUE_LABEL]]
 //
-// DTORS:      [[CONTINUE_LABEL]]
-// DTORS-NEXT:   ret void
+// DTOR3:      [[CONTINUE_LABEL]]
+// DTOR3-NEXT:   ret void
   }
   virtual void foo();
 };
 
 // Emits the vftable in the output.
 void C::foo() {}
 
 void check_vftable_offset() {
   C c;
 // The vftable pointer should point at the beginning of the vftable.
 // CHECK: [[THIS_PTR:%[0-9]+]] = bitcast %"struct.basic::C"* {{.*}} to i8***
 // CHECK: store i8** getelementptr inbounds ([2 x i8*]* @"\01??_7C@basic@@6B@", i64 0, i64 0), i8*** [[THIS_PTR]]
 }
 
 void call_complete_dtor(C *obj_ptr) {
 // CHECK: define void @"\01?call_complete_dtor@basic@@YAXPAUC@1@@Z"(%"struct.basic::C"* %obj_ptr)
   obj_ptr->~C();
 // CHECK: %[[OBJ_PTR_VALUE:.*]] = load %"struct.basic::C"** %{{.*}}, align 4
-// CHECK-NEXT: %[[PVTABLE:.*]] = bitcast %"struct.basic::C"* %[[OBJ_PTR_VALUE]] to void (%"struct.basic::C"*, i1)***
-// CHECK-NEXT: %[[VTABLE:.*]] = load void (%"struct.basic::C"*, i1)*** %[[PVTABLE]]
-// CHECK-NEXT: %[[PVDTOR:.*]] = getelementptr inbounds void (%"struct.basic::C"*, i1)** %[[VTABLE]], i64 0
-// CHECK-NEXT: %[[VDTOR:.*]] = load void (%"struct.basic::C"*, i1)** %[[PVDTOR]]
-// CHECK-NEXT: call x86_thiscallcc void %[[VDTOR]](%"struct.basic::C"* %[[OBJ_PTR_VALUE]], i1 zeroext false)
+// CHECK-NEXT: %[[PVTABLE:.*]] = bitcast %"struct.basic::C"* %[[OBJ_PTR_VALUE]] to void (%"struct.basic::C"*, i32)***
+// CHECK-NEXT: %[[VTABLE:.*]] = load void (%"struct.basic::C"*, i32)*** %[[PVTABLE]]
+// CHECK-NEXT: %[[PVDTOR:.*]] = getelementptr inbounds void (%"struct.basic::C"*, i32)** %[[VTABLE]], i64 0
+// CHECK-NEXT: %[[VDTOR:.*]] = load void (%"struct.basic::C"*, i32)** %[[PVDTOR]]
+// CHECK-NEXT: call x86_thiscallcc void %[[VDTOR]](%"struct.basic::C"* %[[OBJ_PTR_VALUE]], i32 0)
 // CHECK-NEXT: ret void
 }
 
 void call_deleting_dtor(C *obj_ptr) {
 // CHECK: define void @"\01?call_deleting_dtor@basic@@YAXPAUC@1@@Z"(%"struct.basic::C"* %obj_ptr)
   delete obj_ptr;
 // CHECK:      %[[OBJ_PTR_VALUE:.*]] = load %"struct.basic::C"** %{{.*}}, align 4
 // CHECK:      br i1 {{.*}}, label %[[DELETE_NULL:.*]], label %[[DELETE_NOTNULL:.*]]
 
 // CHECK:      [[DELETE_NOTNULL]]
-// CHECK-NEXT:   %[[PVTABLE:.*]] = bitcast %"struct.basic::C"* %[[OBJ_PTR_VALUE]] to void (%"struct.basic::C"*, i1)***
-// CHECK-NEXT:   %[[VTABLE:.*]] = load void (%"struct.basic::C"*, i1)*** %[[PVTABLE]]
-// CHECK-NEXT:   %[[PVDTOR:.*]] = getelementptr inbounds void (%"struct.basic::C"*, i1)** %[[VTABLE]], i64 0
-// CHECK-NEXT:   %[[VDTOR:.*]] = load void (%"struct.basic::C"*, i1)** %[[PVDTOR]]
-// CHECK-NEXT:   call x86_thiscallcc void %[[VDTOR]](%"struct.basic::C"* %[[OBJ_PTR_VALUE]], i1 zeroext true)
+// CHECK-NEXT:   %[[PVTABLE:.*]] = bitcast %"struct.basic::C"* %[[OBJ_PTR_VALUE]] to void (%"struct.basic::C"*, i32)***
+// CHECK-NEXT:   %[[VTABLE:.*]] = load void (%"struct.basic::C"*, i32)*** %[[PVTABLE]]
+// CHECK-NEXT:   %[[PVDTOR:.*]] = getelementptr inbounds void (%"struct.basic::C"*, i32)** %[[VTABLE]], i64 0
+// CHECK-NEXT:   %[[VDTOR:.*]] = load void (%"struct.basic::C"*, i32)** %[[PVDTOR]]
+// CHECK-NEXT:   call x86_thiscallcc void %[[VDTOR]](%"struct.basic::C"* %[[OBJ_PTR_VALUE]], i32 1)
 // CHECK:      ret void
 }
 
 struct D {
   static int foo();
 
   D() {
     static int ctor_static = foo();
     // CHECK that the static in the ctor gets mangled correctly:
-    // CHECK: @"\01?ctor_static@?1???0D@basic@@QAE@XZ@4HA"
+    // CTOR1: @"\01?ctor_static@?1???0D@basic@@QAE@XZ@4HA"
   }
   ~D() {
     static int dtor_static = foo();
     // CHECK that the static in the dtor gets mangled correctly:
-    // CHECK: @"\01?dtor_static@?1???1D@basic@@QAE@XZ@4HA"
+    // DTOR4: @"\01?dtor_static@?1???1D@basic@@QAE@XZ@4HA"
   }
 };
 
 void use_D() { D c; }
 
-// DTORS: attributes [[NUW]] = { nounwind{{.*}} }
+// DTOR3: attributes [[NUW]] = { nounwind{{.*}} }
 
 } // end namespace basic
 
 
 namespace constructors {
 
 struct A {
   A() {}
E::E() {
   // CHECK: call x86_thiscallcc %"struct.constructors::C"* @"\01??0C@constructors@@QAE@XZ"(%"struct.constructors::C"* %{{.*}}, i32 0)
   // CHECK-NEXT: br label %[[SKIP_VBASES]]
   //
   // CHECK: [[SKIP_VBASES]]
   // CHECK: ret
 }
 
 } // end namespace constructors
+
+namespace bodyless_dtors {
+
+struct A {
+  A();
+  virtual void f(); // TODO: remove this function once we disable the key
+                    // function logic for the MS ABI.
+  virtual ~A();
+};
+
+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: 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 {
+  ~A();
+};
+
+struct B : virtual A {
+  ~B();
+};
+
+// DTOR6: define linkonce_odr x86_thiscallcc void @"\01??_DB@virtual_bases@@QAE@XZ"
+// DTOR6: call x86_thiscallcc void @"\01??1B@virtual_bases@@QAE@XZ"
+// DTOR6: call x86_thiscallcc void @"\01??1A@virtual_bases@@QAE@XZ"
+
+void f(B *b) {
+  b->~B();
+}
+
+}