[MS] Always use base dtors in place of complete/vbase dtors when possible

[rnk]

Summary

Previously we tried too hard to uphold the fiction that destructor
variants work like they do on Itanium throughout the ABI-neutral parts
of clang. This lead to MS C++ ABI incompatiblities and other bugs. Now,
-mconstructor-aliases will no longer control this ABI detail, and clang
-cc1's LLVM IR output will be this much closer to the clang driver's.

Based on a patch by Zahira Ammarguellat:

https://reviews.llvm.org/D39063

I've tried to move the logic that Zahira added into MicrosoftCXXABI.cpp.
There is only one ABI-specific detail sticking out, and that is in
CodeGenModule::getAddrOfCXXStructor, where we collapse complete dtors to
base dtors in the MS ABI.

This fixes PR32990.

[rjmccall]

LGTM.

[zahiraam]

LGTM 2. It fixes PR32990.

[rnk]

Thanks! I'm sorry I wasn't able to express these ideas better in D39063.

[rnk]

And, this appears to have broken clang's self-host:
http://lab.llvm.org:8011/builders/clang-x86-windows-msvc2015/builds/10799

Time to debug.

[rnk]

Should be fixed in rL327754.

clang/lib/CodeGen/CGCXX.cpp

 llvm::Constant *CodeGenModule::getAddrOfCXXStructor(
     const CXXMethodDecl *MD, StructorType Type, const CGFunctionInfo *FnInfo,
     llvm::FunctionType *FnType, bool DontDefer,
     ForDefinition_t IsForDefinition) {
   GlobalDecl GD;
   if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
     GD = GlobalDecl(CD, toCXXCtorType(Type));
   } else {
+    // Always alias equivalent complete destructors to base destructors in the
+    // MS ABI.
+    if (getTarget().getCXXABI().isMicrosoft() &&
+        Type == StructorType::Complete && MD->getParent()->getNumVBases() == 0)
+      Type = StructorType::Base;
     GD = GlobalDecl(cast<CXXDestructorDecl>(MD), toCXXDtorType(Type));
   }
 
   if (!FnType) {
     if (!FnInfo)
       FnInfo = &getTypes().arrangeCXXStructorDeclaration(MD, Type);
     FnType = getTypes().GetFunctionType(*FnInfo);
   }

clang/lib/CodeGen/CGCXXABI.h

buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
                          SmallVectorImpl<CanQualType> &ArgTys) = 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.
   virtual bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
                                       CXXDtorType DT) const = 0;
 
+  virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
+                                          const CXXDestructorDecl *Dtor,
+                                          CXXDtorType DT) const;
+
+  virtual llvm::GlobalValue::LinkageTypes
+  getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor,
+                          CXXDtorType DT) const;
+
   /// Emit destructor variants required by this ABI.
   virtual void EmitCXXDestructors(const CXXDestructorDecl *D) = 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"
   /// parameter to point to some artificial offset in a complete object due to
   /// vbases being reordered.
   virtual const CXXRecordDecl *

clang/lib/CodeGen/CGCXXABI.cpp

CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
                                         const CXXRecordDecl *RD) {
   if (CGM.getTarget().getCXXABI().hasConstructorVariants())
     llvm_unreachable("shouldn't be called in this ABI");
 
   ErrorUnsupportedABI(CGF, "complete object detection in ctor");
   return nullptr;
 }
 
+void CGCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
+                                          const CXXDestructorDecl *Dtor,
+                                          CXXDtorType DT) const {
+  // Assume the base C++ ABI has no special rules for destructor variants.
+  CGM.setDLLImportDLLExport(GV, Dtor);
+}
+
+llvm::GlobalValue::LinkageTypes CGCXXABI::getCXXDestructorLinkage(
+    GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const {
+  // Delegate back to CGM by default.
+  return CGM.getLLVMLinkageForDeclarator(Dtor, Linkage,
+                                         /*isConstantVariable=*/false);
+}
+
 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
   return false;
 }
 
 llvm::CallInst *
 CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
                                               llvm::Value *Exn) {
   // Just call std::terminate and ignore the violating exception.

clang/lib/CodeGen/CodeGenModule.cpp

 
 void CodeGenModule::setDSOLocal(llvm::GlobalValue *GV) const {
   GV->setDSOLocal(shouldAssumeDSOLocal(*this, GV));
 }
 
 void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
                                           GlobalDecl GD) const {
   const auto *D = dyn_cast<NamedDecl>(GD.getDecl());
+  // C++ destructors have a few C++ ABI specific special cases.
   if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
-    if (getCXXABI().useThunkForDtorVariant(Dtor, GD.getDtorType())) {
-      // Don't dllexport/import destructor thunks.
-      GV->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
-      return;
-    }
-  }
+    getCXXABI().setCXXDestructorDLLStorage(GV, Dtor, GD.getDtorType());
   setDLLImportDLLExport(GV, D);
 }
 
 void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
                                           const NamedDecl *D) const {
   if (D && D->isExternallyVisible()) {
     if (D->hasAttr<DLLImportAttr>())
       GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);

 }
 
 llvm::GlobalValue::LinkageTypes
 CodeGenModule::getFunctionLinkage(GlobalDecl GD) {
   const auto *D = cast<FunctionDecl>(GD.getDecl());
 
   GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
 
-  if (isa<CXXDestructorDecl>(D) &&
-      getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
-                                         GD.getDtorType())) {
-    // Destructor variants in the Microsoft C++ ABI are always internal or
-    // linkonce_odr thunks emitted on an as-needed basis.
-    return Linkage == GVA_Internal ? llvm::GlobalValue::InternalLinkage
-                                   : llvm::GlobalValue::LinkOnceODRLinkage;
-  }
+  if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
+    return getCXXABI().getCXXDestructorLinkage(Linkage, Dtor, GD.getDtorType());
 
   if (isa<CXXConstructorDecl>(D) &&
       cast<CXXConstructorDecl>(D)->isInheritingConstructor() &&
       Context.getTargetInfo().getCXXABI().isMicrosoft()) {
     // Our approach to inheriting constructors is fundamentally different from
     // that used by the MS ABI, so keep our inheriting constructor thunks
     // internal rather than trying to pick an unambiguous mangling for them.
     return llvm::GlobalValue::InternalLinkage;

clang/lib/CodeGen/MicrosoftCXXABI.cpp

buildStructorSignature(const CXXMethodDecl *MD, StructorType T,
                          SmallVectorImpl<CanQualType> &ArgTys) override;
 
   /// Non-base dtors should be emitted as delegating thunks in this ABI.
   bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
                               CXXDtorType DT) const override {
     return DT != Dtor_Base;
   }
 
+  void setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
+                                  const CXXDestructorDecl *Dtor,
+                                  CXXDtorType DT) const override;
+
+  llvm::GlobalValue::LinkageTypes
+  getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor,
+                          CXXDtorType DT) const override;
+
   void EmitCXXDestructors(const CXXDestructorDecl *D) override;
 
   const CXXRecordDecl *
   getThisArgumentTypeForMethod(const CXXMethodDecl *MD) override {
     MD = MD->getCanonicalDecl();
     if (MD->isVirtual() && !isa<CXXDestructorDecl>(MD)) {
       MicrosoftVTableContext::MethodVFTableLocation ML =
           CGM.getMicrosoftVTableContext().getMethodVFTableLocation(MD);
if (FPT->isVariadic()) {
       ArgTys.push_back(getContext().IntTy);
       ++Added.Suffix;
     }
   }
 
   return Added;
 }
 
+void MicrosoftCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
+                                                 const CXXDestructorDecl *Dtor,
+                                                 CXXDtorType DT) const {
+  // Deleting destructor variants are never imported or exported. Give them the
+  // default storage class.
+  if (DT == Dtor_Deleting) {
+    GV->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
+  } else {
+    const NamedDecl *ND = Dtor;
+    CGM.setDLLImportDLLExport(GV, ND);
+  }
+}
+
+llvm::GlobalValue::LinkageTypes MicrosoftCXXABI::getCXXDestructorLinkage(
+    GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const {
+  // Internal things are always internal, regardless of attributes. After this,
+  // we know the thunk is externally visible.
+  if (Linkage == GVA_Internal)
+    return llvm::GlobalValue::InternalLinkage;
+
+  switch (DT) {
+  case Dtor_Base:
+    // The base destructor most closely tracks the user-declared constructor, so
+    // we delegate back to the normal declarator case.
+    return CGM.getLLVMLinkageForDeclarator(Dtor, Linkage,
+                                           /*isConstantVariable=*/false);
+  case Dtor_Complete:
+    // The complete destructor is like an inline function, but it may be
+    // imported and therefore must be exported as well. This requires changing
+    // the linkage if a DLL attribute is present.
+    if (Dtor->hasAttr<DLLExportAttr>())
+      return llvm::GlobalValue::WeakODRLinkage;
+    if (Dtor->hasAttr<DLLImportAttr>())
+      return llvm::GlobalValue::AvailableExternallyLinkage;
+    return llvm::GlobalValue::LinkOnceODRLinkage;
+  case Dtor_Deleting:
+    // Deleting destructors are like inline functions. They have vague linkage
+    // and are emitted everywhere they are used. They are internal if the class
+    // is internal.
+    return llvm::GlobalValue::LinkOnceODRLinkage;
+  case Dtor_Comdat:
+    llvm_unreachable("MS C++ ABI does not support comdat dtors");
+  }
+  llvm_unreachable("invalid dtor type");
+}
+
 void MicrosoftCXXABI::EmitCXXDestructors(const CXXDestructorDecl *D) {
   // The TU defining a dtor is only guaranteed to emit a base destructor.  All
   // other destructor variants are delegating thunks.
   CGM.EmitGlobal(GlobalDecl(D, Dtor_Base));
 }
 
 CharUnits
 MicrosoftCXXABI::getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) {
CGCXXABI::AddedStructorArgs MicrosoftCXXABI::addImplicitConstructorArgs(
   Args.add(RV, getContext().IntTy);
   return AddedStructorArgs::suffix(1);
 }
 
 void MicrosoftCXXABI::EmitDestructorCall(CodeGenFunction &CGF,
                                          const CXXDestructorDecl *DD,
                                          CXXDtorType Type, bool ForVirtualBase,
                                          bool Delegating, Address This) {
+  // Use the base destructor variant in place of the complete destructor variant
+  // if the class has no virtual bases. This effectively implements some of the
+  // -mconstructor-aliases optimization, but as part of the MS C++ ABI.
+  if (Type == Dtor_Complete && DD->getParent()->getNumVBases() == 0)
+    Type = Dtor_Base;
+
   CGCallee Callee = CGCallee::forDirect(
                           CGM.getAddrOfCXXStructor(DD, getFromDtorType(Type)),
                                         DD);
 
   if (DD->isVirtual()) {
     assert(Type != CXXDtorType::Dtor_Deleting &&
            "The deleting destructor should only be called via a virtual call");
     This = adjustThisArgumentForVirtualFunctionCall(CGF, GlobalDecl(DD, Type),
static void emitCXXConstructor(CodeGenModule &CGM,
                                StructorType ctorType) {
   // There are no constructor variants, always emit the complete destructor.
   llvm::Function *Fn = CGM.codegenCXXStructor(ctor, StructorType::Complete);
   CGM.maybeSetTrivialComdat(*ctor, *Fn);
 }
 
 static void emitCXXDestructor(CodeGenModule &CGM, const CXXDestructorDecl *dtor,
                               StructorType dtorType) {
-  // The complete destructor is equivalent to the base destructor for
-  // classes with no virtual bases, so try to emit it as an alias.
-  if (!dtor->getParent()->getNumVBases() &&
-      (dtorType == StructorType::Complete || dtorType == StructorType::Base)) {
-    bool ProducedAlias = !CGM.TryEmitDefinitionAsAlias(
-        GlobalDecl(dtor, Dtor_Complete), GlobalDecl(dtor, Dtor_Base));
-    if (ProducedAlias) {
-      if (dtorType == StructorType::Complete)
-        return;
-      if (dtor->isVirtual())
-        CGM.getVTables().EmitThunks(GlobalDecl(dtor, Dtor_Complete));
-    }
-  }
+  // Emit the base destructor if the base and complete (vbase) destructors are
+  // equivalent. This effectively implements -mconstructor-aliases as part of
+  // the ABI.
+  if (dtorType == StructorType::Complete &&
+      dtor->getParent()->getNumVBases() == 0)
+    dtorType = StructorType::Base;
 
   // 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 == StructorType::Base && !CGM.TryEmitBaseDestructorAsAlias(dtor))
     return;
 

clang/test/CodeGenCXX/cxx2a-destroying-delete.cpp

 // CHECK-MSABI: br i1
 //
 // CHECK-MSABI-NOT: call{{ }}
 // CHECK-MSABI: getelementptr {{.*}}, i64 24
 // CHECK-MSABI-NOT: call{{ }}
 // CHECK-MSABI: call void @"\01??3F@@SAXPEAU0@Udestroying_delete_t@std@@_KW4align_val_t@2@@Z"({{.*}}, i64 48, i64 16)
 // CHECK-MSABI: br label %[[RETURN:.*]]
 //
-// CHECK-MSABI: call void @"\01??_DH@@QEAAXXZ"(
+// CHECK-MSABI: call void @"\01??1H@@UEAA@XZ"(
 // CHECK-MSABI: br label %[[RETURN]]
 //
 // CHECK-MSABI: }
 
 struct I : H { virtual ~I(); alignas(32) char buffer[32]; } i;
 I::~I() { call_in_dtor(); }
 // CHECK-ITANIUM-LABEL: define void @_ZN1ID0Ev(
 // CHECK-ITANIUM-NOT: call

 // CHECK-MSABI: br i1
 //
 // CHECK-MSABI-NOT: call{{ }}
 // CHECK-MSABI: getelementptr {{.*}}, i64 24
 // CHECK-MSABI-NOT: call{{ }}
 // CHECK-MSABI: call void @"\01??3F@@SAXPEAU0@Udestroying_delete_t@std@@_KW4align_val_t@2@@Z"({{.*}}, i64 96, i64 32)
 // CHECK-MSABI: br label %[[RETURN:.*]]
 //
-// CHECK-MSABI: call void @"\01??_DI@@QEAAXXZ"(
+// CHECK-MSABI: call void @"\01??1I@@UEAA@XZ"(
 // CHECK-MSABI: br label %[[RETURN]]
 //
 // CHECK-MSABI: }

clang/test/CodeGenCXX/debug-info-ms-dtor-thunks.cpp

 // RUN: %clang_cc1 -triple i686--windows -emit-llvm -debug-info-kind=line-tables-only -x c++ %s -fms-extensions -o - | FileCheck %s
 
 struct __declspec(dllexport) S { virtual ~S(); };
 struct __declspec(dllexport) T { virtual ~T(); };
 struct __declspec(dllexport) U : S, T { virtual ~U(); };
 
 // CHECK-LABEL: define {{.*}} @"\01??_GS@@UAEPAXI@Z"
-// CHECK: call x86_thiscallcc void @"\01??_DS@@QAEXXZ"(%struct.S* %this1){{.*}}!dbg !{{[0-9]+}}
+// CHECK: call x86_thiscallcc void @"\01??1S@@UAE@XZ"(%struct.S* %this1){{.*}}!dbg !{{[0-9]+}}
 
 // CHECK-LABEL: define {{.*}} @"\01??_GT@@UAEPAXI@Z"
-// CHECK: call x86_thiscallcc void @"\01??_DT@@QAEXXZ"(%struct.T* %this1){{.*}}!dbg !{{[0-9]+}}
+// CHECK: call x86_thiscallcc void @"\01??1T@@UAE@XZ"(%struct.T* %this1){{.*}}!dbg !{{[0-9]+}}
 
 // CHECK-LABEL: define {{.*}} @"\01??_GU@@UAEPAXI@Z"
-// CHECK: call x86_thiscallcc void @"\01??_DU@@QAEXXZ"(%struct.U* %this1){{.*}}!dbg !{{[0-9]+}}
+// CHECK: call x86_thiscallcc void @"\01??1U@@UAE@XZ"(%struct.U* %this1){{.*}}!dbg !{{[0-9]+}}

clang/test/CodeGenCXX/dllexport-dtor-thunks.cpp

 // RUN: %clang_cc1 -mconstructor-aliases -fms-extensions %s -emit-llvm -o - -triple x86_64-windows-msvc | FileCheck %s
 
 struct __declspec(dllexport) A { virtual ~A(); };
 struct __declspec(dllexport) B { virtual ~B(); };
 struct __declspec(dllexport) C : A, B { virtual ~C(); };
 C::~C() {}
 
+// CHECK: define dso_local dllexport void @"\01??1C@@UEAA@XZ"
 // This thunk should *not* be dllexport.
 // CHECK: define linkonce_odr dso_local i8* @"\01??_EC@@W7EAAPEAXI@Z"
-// CHECK: define dso_local dllexport void @"\01??1C@@UEAA@XZ"

clang/test/CodeGenCXX/dllimport-dtor-thunks.cpp

 // RUN: %clang_cc1 -mconstructor-aliases %s -triple x86_64-windows-msvc -fms-extensions -emit-llvm -o - | FileCheck %s
 
-// FIXME: We should really consider removing -mconstructor-aliases for MS C++
-// ABI. The risk of bugs introducing ABI incompatibility under
-// -mno-constructor-aliases is too high.
-
 // PR32990
 
 // Introduces the virtual destructor. We should use the base destructor
 // directly, no thunk needed.
 struct __declspec(dllimport) ImportIntroVDtor {
   virtual ~ImportIntroVDtor() {}
 };
 

 
 // The destructors are called in reverse order of construction. Only the third
 // needs the complete destructor (_D).
 // CHECK-LABEL: define dso_local void @testit()
 // CHECK:  call void @"\01??_DImportVBaseOverrideVDtor@@QEAAXXZ"(%struct.ImportVBaseOverrideVDtor* %{{.*}})
 // CHECK:  call void @"\01??1ImportOverrideVDtor@@UEAA@XZ"(%struct.ImportOverrideVDtor* %{{.*}})
 // CHECK:  call void @"\01??1ImportIntroVDtor@@UEAA@XZ"(%struct.ImportIntroVDtor* %{{.*}})
 
-// CHECK-LABEL: define linkonce_odr dso_local void @"\01??_DImportVBaseOverrideVDtor@@QEAAXXZ"
+// CHECK-LABEL: declare dllimport void @"\01??_DImportVBaseOverrideVDtor@@QEAAXXZ"
 // CHECK-LABEL: declare dllimport void @"\01??1ImportOverrideVDtor@@UEAA@XZ"
 // CHECK-LABEL: declare dllimport void @"\01??1ImportIntroVDtor@@UEAA@XZ"

clang/test/CodeGenCXX/exceptions-cxx-new.cpp

void test_cleanup() {
   f(1);
 }
 
 // CHECK-LABEL: define dso_local {{.*}} @"\01?test_cleanup@@YAXXZ"(
 // CHECK:   invoke i32 @"\01?f@@YAHH@Z"(i32 1)
 // CHECK:           to label %[[LEAVE_FUNC:.*]] unwind label %[[CLEANUP:.*]]
 
 // CHECK: [[LEAVE_FUNC]]
-// CHECK:   call x86_thiscallcc void @"\01??_DCleanup@@QAEXXZ"(
+// CHECK:   call x86_thiscallcc void @"\01??1Cleanup@@QAE@XZ"(
 // CHECK:   ret void
 
 // CHECK: [[CLEANUP]]
 // CHECK:   %[[CLEANUPPAD:.*]] = cleanuppad within none []
-// CHECK:   call x86_thiscallcc void @"\01??_DCleanup@@QAEXXZ"(
+// CHECK:   call x86_thiscallcc void @"\01??1Cleanup@@QAE@XZ"(
 // CHECK:   cleanupret from %[[CLEANUPPAD]] unwind to caller
 
 
 // CHECK-LABEL: define {{.*}} void @"\01??1Cleanup@@QAE@XZ"(
 // CHECK:   invoke i32 @"\01?f@@YAHH@Z"(i32 -1)
 // CHECK:           to label %[[LEAVE_FUNC:.*]] unwind label %[[TERMINATE:.*]]
 
 // CHECK: [[LEAVE_FUNC]]
 // CHECK:   ret void
 
 // CHECK: [[TERMINATE]]
 // CHECK:   %[[CLEANUPPAD:.*]] = cleanuppad within none []
 // CHECK-NEXT:   call void @"\01?terminate@@YAXXZ"() {{.*}} [ "funclet"(token %[[CLEANUPPAD]]) ]
 

clang/test/CodeGenCXX/inheriting-constructor.cpp

namespace inalloca_nonvirt {
   // WIN32: call {{.*}} @"\01??0Z@@QAE@XZ"(
   // WIN32: %[[ARG2:.*]] = getelementptr {{.*}} %[[ARGMEM]]
   // WIN32: store i32 2, i32* %[[ARG2]]
   // WIN32: %[[ARG4:.*]] = getelementptr {{.*}} %[[ARGMEM]]
   // WIN32: store {{.*}}* %[[TMP]], {{.*}}** %[[ARG4]]
   // WIN32: call {{.*}} @"\01??0A@inalloca_nonvirt@@QAE@UQ@@H0$$QAU2@@Z"(%{{[^,]*}}, <{{.*}}>* inalloca %[[ARGMEM]])
   // WIN32: call void @llvm.stackrestore(
   // WIN32: call {{.*}} @"\01??0Z@@QAE@XZ"(
-  // WIN32: call {{.*}} @"\01??_DQ@@QAEXXZ"(
+  // WIN32: call {{.*}} @"\01??1Q@@QAE@XZ"(
 
   // On Win64, the Q arguments would be destroyed in the callee. We don't yet
   // support that in the non-inlined case, so we force inlining.
   // WIN64: %[[TMP:.*]] = alloca
   // WIN64: %[[ARG3:.*]] = alloca
   // WIN64: %[[ARG1:.*]] = alloca
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[TMP]], i32 4)
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[ARG3]], i32 3)
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[ARG1]], i32 1)
   // WIN64: call {{.*}} @"\01??0Z@@QEAA@XZ"(
   // WIN64: call {{.*}} @"\01??0A@inalloca_nonvirt@@QEAA@UQ@@H0$$QEAU2@@Z"(%{{.*}}, %{{.*}}* %[[ARG1]], i32 2, %{{.*}}* %[[ARG3]], %{{.*}} %[[TMP]])
   // WIN64: call {{.*}} @"\01??0Z@@QEAA@XZ"(
-  // WIN64: call void @"\01??_DQ@@QEAAXXZ"({{.*}}* %[[TMP]])
+  // WIN64: call void @"\01??1Q@@QEAA@XZ"({{.*}}* %[[TMP]])
 
   struct C : B { using B::B; };
   C c(1, 2, 3, 4);
   // MSABI-LABEL: define internal void @"\01??__Ec@inalloca_nonvirt@@YAXXZ"(
 
   // On Win32, the inalloca call can't be forwarded so we force inlining.
   // WIN32: %[[TMP:.*]] = alloca
   // WIN32: call i8* @llvm.stacksave()
   // WIN32: %[[ARGMEM:.*]] = alloca inalloca
   // WIN32: call {{.*}} @"\01??0Q@@QAE@H@Z"(%{{.*}}* %[[TMP]], i32 4)
   // WIN32: %[[ARG3:.*]] = getelementptr {{.*}} %[[ARGMEM]]
   // WIN32: call {{.*}} @"\01??0Q@@QAE@H@Z"({{.*}}* %[[ARG3]], i32 3)
   // WIN32: %[[ARG1:.*]] = getelementptr {{.*}} %[[ARGMEM]]
   // WIN32: call {{.*}} @"\01??0Q@@QAE@H@Z"({{.*}}* %[[ARG1]], i32 1)
   // WIN32: call {{.*}} @"\01??0Z@@QAE@XZ"(
   // WIN32: %[[ARG2:.*]] = getelementptr {{.*}} %[[ARGMEM]]
   // WIN32: store i32 2, i32* %[[ARG2]]
   // WIN32: %[[ARG4:.*]] = getelementptr {{.*}} %[[ARGMEM]]
   // WIN32: store {{.*}}* %[[TMP]], {{.*}}** %[[ARG4]]
   // WIN32: call {{.*}} @"\01??0A@inalloca_nonvirt@@QAE@UQ@@H0$$QAU2@@Z"(%{{[^,]*}}, <{{.*}}>* inalloca %[[ARGMEM]])
   // WIN32: call void @llvm.stackrestore(
   // WIN32: call {{.*}} @"\01??0Z@@QAE@XZ"(
-  // WIN32: call {{.*}} @"\01??_DQ@@QAEXXZ"(
+  // WIN32: call {{.*}} @"\01??1Q@@QAE@XZ"(
 
   // On Win64, the Q arguments would be destroyed in the callee. We don't yet
   // support that in the non-inlined case, so we force inlining.
   // WIN64: %[[TMP:.*]] = alloca
   // WIN64: %[[ARG3:.*]] = alloca
   // WIN64: %[[ARG1:.*]] = alloca
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[TMP]], i32 4)
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[ARG3]], i32 3)
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[ARG1]], i32 1)
   // WIN64: call {{.*}} @"\01??0Z@@QEAA@XZ"(
   // WIN64: call {{.*}} @"\01??0A@inalloca_nonvirt@@QEAA@UQ@@H0$$QEAU2@@Z"(%{{.*}}, %{{.*}}* %[[ARG1]], i32 2, %{{.*}}* %[[ARG3]], %{{.*}} %[[TMP]])
   // WIN64: call {{.*}} @"\01??0Z@@QEAA@XZ"(
-  // WIN64: call void @"\01??_DQ@@QEAAXXZ"({{.*}}* %[[TMP]])
+  // WIN64: call void @"\01??1Q@@QEAA@XZ"({{.*}}* %[[TMP]])
 }
 
 namespace inalloca_virt {
   struct A { A(Q, int, Q, Q&&); int n; };
   struct B : Z, virtual A { Z z; using A::A; };
   B b(1, 2, 3, 4);
 
   // MSABI-LABEL: define internal void @"\01??__Eb@inalloca_virt@@YAXXZ"(
namespace inalloca_virt {
   // WIN32: call {{.*}} @"\01??0A@inalloca_virt@@QAE@UQ@@H0$$QAU2@@Z"(%{{[^,]*}}, <{{.*}}>* inalloca %[[ARGMEM]])
   // WIN32: call void @llvm.stackrestore(
   // WIN32: br
   //
   // Note that if we jumped directly to here we would fail to stackrestore and
   // destroy the parameters, but that's not actually possible.
   // WIN32: call {{.*}} @"\01??0Z@@QAE@XZ"(
   // WIN32: call {{.*}} @"\01??0Z@@QAE@XZ"(
-  // WIN32: call {{.*}} @"\01??_DQ@@QAEXXZ"(
+  // WIN32: call {{.*}} @"\01??1Q@@QAE@XZ"(
 
   // On Win64, the Q arguments would be destroyed in the callee. We don't yet
   // support that in the non-inlined case, so we force inlining.
   // WIN64: %[[TMP:.*]] = alloca
   // WIN64: %[[ARG3:.*]] = alloca
   // WIN64: %[[ARG1:.*]] = alloca
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[TMP]], i32 4)
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[ARG3]], i32 3)
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[ARG1]], i32 1)
   // WIN64: br i1
   // WIN64: call {{.*}} @"\01??0A@inalloca_virt@@QEAA@UQ@@H0$$QEAU2@@Z"(%{{.*}}, %{{.*}}* %[[ARG1]], i32 2, %{{.*}}* %[[ARG3]], %{{.*}} %[[TMP]])
   // WIN64: br
   // WIN64: call {{.*}} @"\01??0Z@@QEAA@XZ"(
   // WIN64: call {{.*}} @"\01??0Z@@QEAA@XZ"(
-  // WIN64: call void @"\01??_DQ@@QEAAXXZ"({{.*}}* %[[TMP]])
+  // WIN64: call void @"\01??1Q@@QEAA@XZ"({{.*}}* %[[TMP]])
 
   struct C : B { using B::B; };
   C c(1, 2, 3, 4);
   // ITANIUM-LABEL: define linkonce_odr void @_ZN13inalloca_virt1CD1Ev(
 
   // MSABI-LABEL: define internal void @"\01??__Ec@inalloca_virt@@YAXXZ"(
 
   // On Win32, the inalloca call can't be forwarded so we force inlining.
namespace inalloca_virt {
   // WIN32: br i1 %[[IS_MOST_DERIVED_i1]]
   //
   // Note: this block is unreachable.
   // WIN32: store {{.*}} @"\01??_8B@inalloca_virt@@7B@"
   // WIN32: br
   //
   // WIN32: call {{.*}} @"\01??0Z@@QAE@XZ"(
   // WIN32: call {{.*}} @"\01??0Z@@QAE@XZ"(
-  // WIN32: call {{.*}} @"\01??_DQ@@QAEXXZ"(
+  // WIN32: call {{.*}} @"\01??1Q@@QAE@XZ"(
 
   // On Win64, the Q arguments would be destroyed in the callee. We don't yet
   // support that in the non-inlined case, so we force inlining.
   // WIN64: %[[TMP:.*]] = alloca
   // WIN64: %[[ARG3:.*]] = alloca
   // WIN64: %[[ARG1:.*]] = alloca
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[TMP]], i32 4)
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[ARG3]], i32 3)
   // WIN64: call {{.*}} @"\01??0Q@@QEAA@H@Z"({{.*}}* %[[ARG1]], i32 1)
   // WIN64: br i1
   // WIN64: store {{.*}} @"\01??_8C@inalloca_virt@@7B@"
   // WIN64: call {{.*}} @"\01??0A@inalloca_virt@@QEAA@UQ@@H0$$QEAU2@@Z"(%{{.*}}, %{{.*}}* %[[ARG1]], i32 2, %{{.*}}* %[[ARG3]], %{{.*}} %[[TMP]])
   // WIN64: br
   // WIN64: br i1
   // (Unreachable block)
   // WIN64: store {{.*}} @"\01??_8B@inalloca_virt@@7B@"
   // WIN64: br
   // WIN64: call {{.*}} @"\01??0Z@@QEAA@XZ"(
   // WIN64: call {{.*}} @"\01??0Z@@QEAA@XZ"(
-  // WIN64: call void @"\01??_DQ@@QEAAXXZ"({{.*}}* %[[TMP]])
+  // WIN64: call void @"\01??1Q@@QEAA@XZ"({{.*}}* %[[TMP]])
 }
 
 namespace inline_nonvirt {
   struct A { A(Q, int, Q, Q&&, ...); int n; };
   struct B : Z, A { Z z; using A::A; };
   B b(1, 2, 3, 4, 5, 6);
   // Inlined all the way down to the A ctor.
   // ITANIUM-LABEL: define {{.*}} @__cxx_global_var_init

clang/test/CodeGenCXX/microsoft-abi-dynamic-cast.cpp

 S3 *f(S2 &s) {
   Cleanup c;
   return dynamic_cast<S3 *>(&s);
 }
 // CHECK-LABEL: define dso_local %"struct.PR25606::S3"* @"\01?f@PR25606@@YAPAUS3@1@AAUS2@1@@Z"(
 // CHECK:    [[CALL:%.*]] = invoke i8* @__RTDynamicCast
 
 // CHECK:    [[BC:%.*]] = bitcast i8* [[CALL]] to %"struct.PR25606::S3"*
-// CHECK:    call x86_thiscallcc void @"\01??_DCleanup@PR25606@@QAEXXZ"(
+// CHECK:    call x86_thiscallcc void @"\01??1Cleanup@PR25606@@QAE@XZ"(
 // CHECK:    ret %"struct.PR25606::S3"* [[BC]]
 }

clang/test/CodeGenCXX/microsoft-abi-methods.cpp

 void constructors() {
   Child c;
 // Make sure that the Base constructor call in the Child constructor uses
 // the right calling convention:
 // CHECK: define linkonce_odr dso_local x86_thiscallcc %class.Child* @"\01??0Child@@QAE@XZ"
 // CHECK: %{{[.0-9A-Z_a-z]+}} = call x86_thiscallcc %class.Base* @"\01??0Base@@QAE@XZ"
 // CHECK: ret
 
-// Make sure that the Base constructor definition uses the right CC:
-// CHECK: define linkonce_odr dso_local x86_thiscallcc %class.Base* @"\01??0Base@@QAE@XZ"
-
 // Make sure that the Base destructor call in the Child denstructor uses
 // the right calling convention:
 // CHECK: define linkonce_odr dso_local x86_thiscallcc void @"\01??1Child@@QAE@XZ"
 // CHECK: call x86_thiscallcc void @"\01??1Base@@QAE@XZ"
 // CHECK: ret
 
+// Make sure that the Base constructor definition uses the right CC:
+// CHECK: define linkonce_odr dso_local x86_thiscallcc %class.Base* @"\01??0Base@@QAE@XZ"
+
 // Make sure that the Base destructor definition uses the right CC:
 // CHECK: define linkonce_odr dso_local x86_thiscallcc void @"\01??1Base@@QAE@XZ"
 }

clang/test/CodeGenCXX/regcall.cpp

 
 #ifndef WIN_TEST
   __regcall 
 #endif
   ~test_class(){--x;}
   // CHECK-LIN-DAG: define linkonce_odr x86_regcallcc void @_ZN10test_classD2Ev
   // CHECK-LIN-DAG: define linkonce_odr x86_regcallcc void @_ZN10test_classD1Ev
   // Windows ignores calling convention on constructor/destructors.
-  // CHECK-WIN64-DAG: define linkonce_odr dso_local void @"\01??_Dtest_class@@QEAAXXZ"
-  // CHECK-WIN32-DAG: define linkonce_odr dso_local x86_thiscallcc void @"\01??_Dtest_class@@QAEXXZ"
+  // CHECK-WIN64-DAG: define linkonce_odr dso_local void @"\01??1test_class@@QEAA@XZ"
+  // CHECK-WIN32-DAG: define linkonce_odr dso_local x86_thiscallcc void @"\01??1test_class@@QAE@XZ"
   
   test_class& __regcall operator+=(const test_class&){
     return *this;
   }
   // CHECK-LIN-DAG: define linkonce_odr x86_regcallcc dereferenceable(4) %class.test_class* @_ZN10test_classpLERKS_
   // CHECK-WIN64-DAG: define linkonce_odr dso_local x86_regcallcc dereferenceable(4) %class.test_class* @"\01??Ytest_class@@QEAwAEAV0@AEBV0@@Z"
   // CHECK-WIN32-DAG: define linkonce_odr dso_local x86_regcallcc dereferenceable(4) %class.test_class* @"\01??Ytest_class@@QAwAAV0@ABV0@@Z"
   void __regcall do_thing(){}

clang/test/CodeGenCoroutines/coro-eh-cleanup.cpp

coro_t f() {
   co_return;
 }
 
 // CHECK: @"\01?f@@YA?AUcoro_t@@XZ"(
 // CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 // CHECK:       to label %[[CONT:.+]] unwind label %[[EHCLEANUP:.+]]
 // CHECK: [[EHCLEANUP]]:
 // CHECK:   %[[INNERPAD:.+]] = cleanuppad within none []
-// CHECK:   call void @"\01??_DCleanup@@QEAAXXZ"(
+// CHECK:   call void @"\01??1Cleanup@@QEAA@XZ"(
 // CHECK:   cleanupret from %{{.+}} unwind label %[[CATCHDISPATCH:.+]]
 
 // CHECK: [[CATCHDISPATCH]]:
 // CHECK:   catchswitch within none [label %[[CATCHPAD:.+]]] unwind label %[[COROENDBB:.+]]
 // CHECK: [[CATCHPAD]]:
 // CHECK:   call void @"\01?unhandled_exception@promise_type@coro_t@@QEAAXXZ"
 
 // CHECK: [[COROENDBB]]:

clang/test/CodeGenCoroutines/coro-promise-dtor.cpp

 // CHECK:  %[[IS_ACTIVE:.+]] = load i1, i1* %gro.active
 // CHECK:  br i1 %[[IS_ACTIVE]], label %[[CLEANUP1:.+]], label
 
 // CHECK: [[CLEANUP1]]:
 // CHECK:  %[[NRVO:.+]] = load i1, i1* %nrvo
 // CHECK:  br i1 %[[NRVO]], label %{{.+}}, label %[[DTOR:.+]]
 
 // CHECK: [[DTOR]]:
-// CHECK:  call void @"\01??_Dcoro_t@@QEAAXXZ"(
+// CHECK:  call void @"\01??1coro_t@@QEAA@XZ"(

clang/test/CodeGenCoroutines/coro-unhandled-exception.cpp

coro_t f() {
   co_return;
 }
 
 // CHECK: @"\01?f@@YA?AUcoro_t@@XZ"(
 // CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 // CHECK:       to label %{{.+}} unwind label %[[EHCLEANUP:.+]]
 // CHECK: [[EHCLEANUP]]:
 // CHECK:   %[[INNERPAD:.+]] = cleanuppad within none []
-// CHECK:   call void @"\01??_DCleanup@@QEAAXXZ"(
+// CHECK:   call void @"\01??1Cleanup@@QEAA@XZ"(
 // CHECK:   cleanupret from %[[INNERPAD]] unwind label %[[CATCHSW:.+]]
 // CHECK: [[CATCHSW]]:
 // CHECK:   %[[CATCHSWTOK:.+]] = catchswitch within none [label %[[CATCH:.+]]] unwind label
 // CHECK: [[CATCH]]:
 // CHECK:   %[[CATCHTOK:.+]] = catchpad within [[CATCHSWTOK:.+]]
 // CHECK:   call void @"\01?unhandled_exception@promise_type@coro_t@@QEAAXXZ"
 // CHECK:   catchret from %[[CATCHTOK]] to label %[[CATCHRETDEST:.+]]
 // CHECK: [[CATCHRETDEST]]: