MS ABI: Implement copy-ctor closures, finish implementing throw

[majnemer]

Summary

This adds support for copy-constructor closures. These are generated
when the C++ runtime has to call a copy-constructor with a particular
calling convention or with default arguments substituted in to the call.

Because the runtime has no mechanism to call the function with a
different calling convention or know-how to evaluate the default
arguments at run-time, we create a thunk which will do all the
appropriate work and package it in a way the runtime can use.

[rnk]

lib/AST/MicrosoftMangle.cpp

793

Keep the Ctor_Complete assertion to avoid decl mangling collisions?

lib/CodeGen/MicrosoftCXXABI.cpp

3332–3335

Surely this can be:

CD->getType()->getAs<FunctionType>()->getCallConv()?

Does the canonical unqualified type step matter in practice?

3336

Can you test the calling convention difference case and the variadic case?

lib/Sema/SemaExprCXX.cpp

829 ↗

(On Diff #21621)

I can see that you need to call BuildCXXDefautlArgExpr to do all the necessary semantic checking, but is it really necessary to maintain a map of all the CXXDefaultArgExprs, rather than simply calling ParmVarDecl::getDefaultArgExpr() during CodeGen?

[majnemer]

lib/AST/MicrosoftMangle.cpp

793

That assertion was never like because Structor was always null for constructors. This assertion is actually wrong in practice because Ctor_Base can happen and weakening the assertion doesn't seem very useful.

lib/CodeGen/MicrosoftCXXABI.cpp

3332–3335

Done.

3336

The different calling convention case is the variadic case.

A test for the variadic case has been added.

lib/Sema/SemaExprCXX.cpp

829 ↗

(On Diff #21621)

Yes because the we won't have an instantiated default argument at CodeGen-time, just the dependent one which won't be suitable.

[majnemer]

• Addressed review comments.

[rnk]

include/clang/Basic/ABI.h

28–29

I'm not super psyched about adding to this enum. What do you think about adding custom entry points to the MS C++ ABI that just tweak internal bools?

lib/AST/MicrosoftMangle.cpp

782–788

Oh dear, does isCopyConstructor() return false for the variadic test case?

[rnk]

lgtm

include/clang/Basic/ABI.h

28–29

Sure, if we think of this as just an enum of different constructor manglings, then I guess this is OK.

test/CodeGenCXX/microsoft-abi-throw.cpp

78

Maybe s/Bad/DoubleDefault/?

include/clang/Basic/ABI.h

 #define LLVM_CLANG_BASIC_ABI_H
 
 #include "llvm/Support/DataTypes.h"
 
 namespace clang {
 
 /// \brief C++ constructor types.
 enum CXXCtorType {
-  Ctor_Complete, ///< Complete object ctor
-  Ctor_Base,     ///< Base object ctor
-  Ctor_Comdat,   ///< The COMDAT used for ctors
-  Ctor_Closure,  ///< Closure variant of a ctor
+  Ctor_Complete,       ///< Complete object ctor
+  Ctor_Base,           ///< Base object ctor
+  Ctor_Comdat,         ///< The COMDAT used for ctors
+  Ctor_CopyingClosure, ///< Copying closure variant of a ctor
+  Ctor_DefaultClosure, ///< Default closure variant of a ctor
 };
 
 /// \brief C++ destructor types.
 enum CXXDtorType {
     Dtor_Deleting, ///< Deleting dtor
     Dtor_Complete, ///< Complete object dtor
     Dtor_Base,     ///< Base object dtor
     Dtor_Comdat    ///< The COMDAT used for dtors

lib/AST/ItaniumMangle.cpp

case Ctor_Complete:
     Out << "C1";
     break;
   case Ctor_Base:
     Out << "C2";
     break;
   case Ctor_Comdat:
     Out << "C5";
     break;
-  case Ctor_Closure:
+  case Ctor_DefaultClosure:
+  case Ctor_CopyingClosure:
     llvm_unreachable("closure constructors don't exist for the Itanium ABI!");
   }
 }
 
 void CXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
   // <ctor-dtor-name> ::= D0  # deleting destructor
   //                  ::= D1  # complete object destructor
   //                  ::= D2  # base object destructor

lib/AST/MicrosoftMangle.cpp

static const DeclContext *getEffectiveDeclContext(const Decl *D) {
 
   return DC;
 }
 
 static const DeclContext *getEffectiveParentContext(const DeclContext *DC) {
   return getEffectiveDeclContext(cast<Decl>(DC));
 }
 
-static const FunctionDecl *getStructor(const FunctionDecl *fn) {
-  if (const FunctionTemplateDecl *ftd = fn->getPrimaryTemplate())
-    return ftd->getTemplatedDecl();
+static const FunctionDecl *getStructor(const NamedDecl *ND) {
+  if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(ND))
+    return FTD->getTemplatedDecl();
+
+  const auto *FD = cast<FunctionDecl>(ND);
+  if (const auto *FTD = FD->getPrimaryTemplate())
+    return FTD->getTemplatedDecl();
 
-  return fn;
+  return FD;
 }
 
 static bool isLambda(const NamedDecl *ND) {
   const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(ND);
   if (!Record)
     return false;
 
   return Record->isLambda();
switch (Name.getNameKind()) {
     }
 
     case DeclarationName::ObjCZeroArgSelector:
     case DeclarationName::ObjCOneArgSelector:
     case DeclarationName::ObjCMultiArgSelector:
       llvm_unreachable("Can't mangle Objective-C selector names here!");
 
     case DeclarationName::CXXConstructorName:
-      if (Structor == ND && StructorType == Ctor_Closure) {
-        const auto *CD = cast<CXXConstructorDecl>(ND);
-        if (CD->isDefaultConstructor()) {
-          Out << "?_F";
-        } else if (CD->isCopyConstructor()) {
+      if (Structor == getStructor(ND)) {
+        if (StructorType == Ctor_CopyingClosure) {
           Out << "?_O";
-        } else {
-          llvm_unreachable("unexpected constructor closure!");
+          return;
         }
-      } else {
-        Out << "?0";
+        if (StructorType == Ctor_DefaultClosure) {
+          Out << "?_F";
+          return;
         }
-      break;
+      }
+      Out << "?0";
+      return;
 
     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 base destructor name. This is relevant if a
void MicrosoftCXXNameMangler::mangleFunctionType(const FunctionType *T,
   CallingConv CC = T->getCallConv();
   if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(D)) {
     if (MD->isInstance())
       HasThisQuals = true;
     if (isa<CXXDestructorDecl>(MD)) {
       IsStructor = true;
     } else if (isa<CXXConstructorDecl>(MD)) {
       IsStructor = true;
-      IsCtorClosure = MD == Structor && StructorType == Ctor_Closure;
+      IsCtorClosure = (StructorType == Ctor_CopyingClosure ||
+                       StructorType == Ctor_DefaultClosure) &&
+                      getStructor(MD) == Structor;
       if (IsCtorClosure)
         CC = getASTContext().getDefaultCallingConvention(
             /*IsVariadic=*/false, /*IsCXXMethod=*/true);
     }
   }
 
   // If this is a C++ instance method, mangle the CVR qualifiers for the
   // this pointer.
if (isa<CXXDestructorDecl>(D) && D == Structor &&
       // The scalar deleting destructor takes 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 << (PointersAre64Bit ? "PEAXI@Z" : "PAXI@Z");
       return;
     }
     if (IsCtorClosure) {
-      const auto *CD = cast<CXXConstructorDecl>(D);
-
       // Default constructor closure and copy constructor closure both return
       // void.
       Out << 'X';
 
-      if (CD->isDefaultConstructor()) {
+      if (StructorType == Ctor_DefaultClosure) {
         // Default constructor closure always has no arguments.
         Out << 'X';
-      } else if (CD->isCopyConstructor()) {
+      } else if (StructorType == Ctor_CopyingClosure) {
         // Copy constructor closure always takes an unqualified reference.
         mangleArgumentType(getASTContext().getLValueReferenceType(
                                Proto->getParamType(0)
                                    ->getAs<LValueReferenceType>()
                                    ->getPointeeType(),
                                /*SpelledAsLValue=*/true),
                            Range);
       } else {

lib/CodeGen/CodeGenTypes.h

 inline StructorType getFromCtorType(CXXCtorType T) {
   switch (T) {
   case Ctor_Complete:
     return StructorType::Complete;
   case Ctor_Base:
     return StructorType::Base;
   case Ctor_Comdat:
     llvm_unreachable("not expecting a COMDAT");
-  case Ctor_Closure:
+  case Ctor_CopyingClosure:
+  case Ctor_DefaultClosure:
     llvm_unreachable("not expecting a closure");
   }
   llvm_unreachable("not a CXXCtorType");
 }
 
 inline CXXDtorType toCXXDtorType(StructorType T) {
   switch (T) {
   case StructorType::Complete:

lib/CodeGen/MicrosoftCXXABI.cpp

void MicrosoftCXXABI::emitCXXStructor(const CXXMethodDecl *MD,
   emitCXXDestructor(CGM, cast<CXXDestructorDecl>(MD), Type);
 }
 
 llvm::Function *
 MicrosoftCXXABI::getAddrOfCXXCopyCtorClosure(const CXXConstructorDecl *CD) {
   // Calculate the mangled name.
   SmallString<256> ThunkName;
   llvm::raw_svector_ostream Out(ThunkName);
-  getMangleContext().mangleCXXCtor(CD, Ctor_Closure, Out);
+  getMangleContext().mangleCXXCtor(CD, Ctor_CopyingClosure, Out);
   Out.flush();
 
   // If the thunk has been generated previously, just return it.
   if (llvm::GlobalValue *GV = CGM.getModule().getNamedValue(ThunkName))
     return cast<llvm::Function>(GV);
 
   // Create the llvm::Function.
   const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeMSCopyCtorClosure(CD);
llvm::Constant *MicrosoftCXXABI::getCatchableType(QualType T,
 
   CXXRecordDecl *RD = T->getAsCXXRecordDecl();
   const CXXConstructorDecl *CD =
       RD ? CGM.getContext().getCopyConstructorForExceptionObject(RD) : nullptr;
   CXXCtorType CT = Ctor_Complete;
   if (CD) {
     CallingConv ExpectedCallingConv = getContext().getDefaultCallingConvention(
         /*IsVariadic=*/false, /*IsCXXMethod=*/true);
-    CallingConv ActualCallingConv = CD->getType()
-                                        ->getCanonicalTypeUnqualified()
-                                        .getAs<FunctionProtoType>()
-                                        ->getExtInfo()
-                                        .getCC();
+    CallingConv ActualCallingConv =
+        CD->getType()->getAs<FunctionProtoType>()->getCallConv();
     if (ExpectedCallingConv != ActualCallingConv || CD->getNumParams() != 1)
-      CT = Ctor_Closure;
+      CT = Ctor_CopyingClosure;
   }
 
   uint32_t Size = getContext().getTypeSizeInChars(T).getQuantity();
   SmallString<256> MangledName;
   {
     llvm::raw_svector_ostream Out(MangledName);
     getMangleContext().mangleCXXCatchableType(T, CD, CT, Size, NVOffset,
                                               VBPtrOffset, VBIndex, Out);
   }
   if (llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(MangledName))
     return getImageRelativeConstant(GV);
 
   // The TypeDescriptor is used by the runtime to determine if a catch handler
   // is appropriate for the exception object.
   llvm::Constant *TD = getImageRelativeConstant(getAddrOfRTTIDescriptor(T));
 
   // The runtime is responsible for calling the copy constructor if the
   // exception is caught by value.
   llvm::Constant *CopyCtor;
   if (CD) {
-    if (CT == Ctor_Closure)
+    if (CT == Ctor_CopyingClosure)
       CopyCtor = getAddrOfCXXCopyCtorClosure(CD);
     else
       CopyCtor = CGM.getAddrOfCXXStructor(CD, StructorType::Complete);
 
     CopyCtor = llvm::ConstantExpr::getBitCast(CopyCtor, CGM.Int8PtrTy);
   } else {
     CopyCtor = llvm::Constant::getNullValue(CGM.Int8PtrTy);
   }

test/CodeGenCXX/microsoft-abi-throw.cpp

-// RUN: %clang_cc1 -emit-llvm -o - -triple=i386-pc-win32 %s -fcxx-exceptions | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -o - -triple=i386-pc-win32 -std=c++11 %s -fcxx-exceptions | FileCheck %s
 
 // CHECK-DAG: @"\01??_R0?AUY@@@8" = linkonce_odr global %rtti.TypeDescriptor7 { i8** @"\01??_7type_info@@6B@", i8* null, [8 x i8] c".?AUY@@\00" }, comdat
 // CHECK-DAG: @"_CT??_R0?AUY@@@8??0Y@@QAE@ABU0@@Z8" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 4, i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUY@@@8" to i8*), i32 0, i32 -1, i32 0, i32 8, i8* bitcast (%struct.Y* (%struct.Y*, %struct.Y*, i32)* @"\01??0Y@@QAE@ABU0@@Z" to i8*) }, section ".xdata", comdat
 // CHECK-DAG: @"\01??_R0?AUZ@@@8" = linkonce_odr global %rtti.TypeDescriptor7 { i8** @"\01??_7type_info@@6B@", i8* null, [8 x i8] c".?AUZ@@\00" }, comdat
 // CHECK-DAG: @"_CT??_R0?AUZ@@@81" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 0, i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUZ@@@8" to i8*), i32 0, i32 -1, i32 0, i32 1, i8* null }, section ".xdata", comdat
 // CHECK-DAG: @"\01??_R0?AUW@@@8" = linkonce_odr global %rtti.TypeDescriptor7 { i8** @"\01??_7type_info@@6B@", i8* null, [8 x i8] c".?AUW@@\00" }, comdat
 // CHECK-DAG: @"_CT??_R0?AUW@@@8??0W@@QAE@ABU0@@Z44" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 4, i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUW@@@8" to i8*), i32 4, i32 -1, i32 0, i32 4, i8* bitcast (%struct.W* (%struct.W*, %struct.W*, i32)* @"\01??0W@@QAE@ABU0@@Z" to i8*) }, section ".xdata", comdat
 // CHECK-DAG: @"\01??_R0?AUM@@@8" = linkonce_odr global %rtti.TypeDescriptor7 { i8** @"\01??_7type_info@@6B@", i8* null, [8 x i8] c".?AUM@@\00" }, comdat
 // CHECK-DAG: @"_CT??_R0?AUM@@@818" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 0, i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUM@@@8" to i8*), i32 8, i32 -1, i32 0, i32 1, i8* null }, section ".xdata", comdat
 // CHECK-DAG: @"\01??_R0?AUV@@@8" = linkonce_odr global %rtti.TypeDescriptor7 { i8** @"\01??_7type_info@@6B@", i8* null, [8 x i8] c".?AUV@@\00" }, comdat
 // CHECK-DAG: @"_CT??_R0?AUV@@@81044" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 0, i8* bitcast (%rtti.TypeDescriptor7* @"\01??_R0?AUV@@@8" to i8*), i32 0, i32 4, i32 4, i32 1, i8* null }, section ".xdata", comdat
 // CHECK-DAG: @"_CTA5?AUY@@" = linkonce_odr unnamed_addr constant %eh.CatchableTypeArray.5 { i32 5, [5 x %eh.CatchableType*] [%eh.CatchableType* @"_CT??_R0?AUY@@@8??0Y@@QAE@ABU0@@Z8", %eh.CatchableType* @"_CT??_R0?AUZ@@@81", %eh.CatchableType* @"_CT??_R0?AUW@@@8??0W@@QAE@ABU0@@Z44", %eh.CatchableType* @"_CT??_R0?AUM@@@818", %eh.CatchableType* @"_CT??_R0?AUV@@@81044"] }, section ".xdata", comdat
 // CHECK-DAG: @"_TI5?AUY@@" = linkonce_odr unnamed_addr constant %eh.ThrowInfo { i32 0, i8* bitcast (void (%struct.Y*)* @"\01??_DY@@QAE@XZ" to i8*), i8* null, i8* bitcast (%eh.CatchableTypeArray.5* @"_CTA5?AUY@@" to i8*) }, section ".xdata", comdat
 // CHECK-DAG: @"_CT??_R0?AUDefault@@@8??_ODefault@@QAEXAAU0@@Z1" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 0, i8* bitcast (%rtti.TypeDescriptor13* @"\01??_R0?AUDefault@@@8" to i8*), i32 0, i32 -1, i32 0, i32 1, i8* bitcast (void (%struct.Default*, %struct.Default*)* @"\01??_ODefault@@QAEXAAU0@@Z" to i8*) }, section ".xdata", comdat
+// CHECK-DAG: @"_CT??_R0?AUVariadic@@@8??_OVariadic@@QAEXAAU0@@Z1" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 0, i8* bitcast (%rtti.TypeDescriptor14* @"\01??_R0?AUVariadic@@@8" to i8*), i32 0, i32 -1, i32 0, i32 1, i8* bitcast (void (%struct.Variadic*, %struct.Variadic*)* @"\01??_OVariadic@@QAEXAAU0@@Z" to i8*) }, section ".xdata", comdat
+// CHECK-DAG: @"_CT??_R0?AUBad@@@8??$?_OH@Bad@@QAEXAAU0@@Z1" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 0, i8* bitcast (%rtti.TypeDescriptor9* @"\01??_R0?AUBad@@@8" to i8*), i32 0, i32 -1, i32 0, i32 1, i8* bitcast (void (%struct.Bad*, %struct.Bad*)* @"\01??$?_OH@Bad@@QAEXAAU0@@Z" to i8*) }, section ".xdata", comdat
 
 
 struct N { ~N(); };
 struct M : private N {};
 struct X {};
 struct Z {};
 struct V : private X {};
 struct W : M, virtual V {};

 // CHECK: %[[this:.*]] = load {{.*}} %[[this_addr]]
 // CHECK: %[[src:.*]] = load {{.*}} %[[src_addr]]
 // CHECK: call x86_thiscallcc {{.*}} @"\01??0Default@@QAE@AAU0@H@Z"({{.*}} %[[this]], {{.*}} %[[src]], i32 42)
 // CHECK: ret void
 
 void h(Default &d) {
   throw d;
 }
+
+struct Variadic {
+  Variadic(Variadic &, ...);
+};
+
+void i(Variadic &v) {
+  throw v;
+}
+
+// CHECK-LABEL: @"\01??_OVariadic@@QAEXAAU0@@Z"
+// CHECK:  %[[src_addr:.*]] = alloca
+// CHECK:  %[[this_addr:.*]] = alloca
+// CHECK:  store {{.*}} %src, {{.*}} %[[src_addr:.*]], align
+// CHECK:  store {{.*}} %this, {{.*}} %[[this_addr:.*]], align
+// CHECK:  %[[this:.*]] = load {{.*}} %[[this_addr]]
+// CHECK:  %[[src:.*]] = load {{.*}} %[[src_addr]]
+// CHECK:  %call = call {{.*}} @"\01??0Variadic@@QAA@AAU0@ZZ"({{.*}} %[[this]], {{.*}} %[[src]])
+// CHECK:  ret void
+
+struct Bad {
+  template <typename T>
+  static int f() {
+    return 0;
+  }
+  template <typename T = int>
+  Bad(Bad &, T = f<T>());
+};
+
+void j(Bad &bad) {
+  throw bad;
+}