Index: include/clang/Basic/DiagnosticSemaKinds.td =================================================================== --- include/clang/Basic/DiagnosticSemaKinds.td +++ include/clang/Basic/DiagnosticSemaKinds.td @@ -2371,6 +2371,9 @@ def warn_cconv_varargs : Warning< "%0 calling convention ignored on variadic function">, InGroup; +def warn_cconv_structors : Warning< + "%0 calling convention ignored on constructor/destructor">, + InGroup; def err_regparm_mismatch : Error<"function declared with regparm(%0) " "attribute was previously declared " "%plural{0:without the regparm|:with the regparm(%1)}1 attribute">; Index: include/clang/Sema/DeclSpec.h =================================================================== --- include/clang/Sema/DeclSpec.h +++ include/clang/Sema/DeclSpec.h @@ -2208,6 +2208,9 @@ /// redeclaration time if the decl is static. bool isStaticMember(); + /// Returns true if this declares a constructor or a destructor. + bool isCtorOrDtor(); + void setRedeclaration(bool Val) { Redeclaration = Val; } bool isRedeclaration() const { return Redeclaration; } }; Index: include/clang/Sema/Sema.h =================================================================== --- include/clang/Sema/Sema.h +++ include/clang/Sema/Sema.h @@ -2915,7 +2915,8 @@ /// Adjust the calling convention of a method to be the ABI default if it /// wasn't specified explicitly. This handles method types formed from /// function type typedefs and typename template arguments. - void adjustMemberFunctionCC(QualType &T, bool IsStatic); + void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, + SourceLocation Loc); // Check if there is an explicit attribute, but only look through parens. // The intent is to look for an attribute on the current declarator, but not Index: lib/Sema/DeclSpec.cpp =================================================================== --- lib/Sema/DeclSpec.cpp +++ lib/Sema/DeclSpec.cpp @@ -351,6 +351,11 @@ getName().OperatorFunctionId.Operator)); } +bool Declarator::isCtorOrDtor() { + return (getName().getKind() == UnqualifiedId::IK_ConstructorName) || + (getName().getKind() == UnqualifiedId::IK_DestructorName); +} + bool DeclSpec::hasTagDefinition() const { if (!TypeSpecOwned) return false; Index: lib/Sema/SemaDecl.cpp =================================================================== --- lib/Sema/SemaDecl.cpp +++ lib/Sema/SemaDecl.cpp @@ -7219,7 +7219,8 @@ << DeclSpec::getSpecifierName(TSCS); if (D.isFirstDeclarationOfMember()) - adjustMemberFunctionCC(R, D.isStaticMember()); + adjustMemberFunctionCC(R, D.isStaticMember(), D.isCtorOrDtor(), + D.getIdentifierLoc()); bool isFriend = false; FunctionTemplateDecl *FunctionTemplate = nullptr; Index: lib/Sema/SemaType.cpp =================================================================== --- lib/Sema/SemaType.cpp +++ lib/Sema/SemaType.cpp @@ -2269,8 +2269,11 @@ // Adjust the default free function calling convention to the default method // calling convention. + bool IsCtorOrDtor = + (Entity.getNameKind() == DeclarationName::CXXConstructorName) || + (Entity.getNameKind() == DeclarationName::CXXDestructorName); if (T->isFunctionType()) - adjustMemberFunctionCC(T, /*IsStatic=*/false); + adjustMemberFunctionCC(T, /*IsStatic=*/false, IsCtorOrDtor, Loc); return Context.getMemberPointerType(T, Class.getTypePtr()); } @@ -5842,24 +5845,51 @@ return false; } -void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic) { +void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, + SourceLocation Loc) { FunctionTypeUnwrapper Unwrapped(*this, T); const FunctionType *FT = Unwrapped.get(); bool IsVariadic = (isa(FT) && cast(FT)->isVariadic()); - - // Only adjust types with the default convention. For example, on Windows we - // should adjust a __cdecl type to __thiscall for instance methods, and a - // __thiscall type to __cdecl for static methods. CallingConv CurCC = FT->getCallConv(); - CallingConv FromCC = + CallingConv DefaultCC = Context.getDefaultCallingConvention(IsVariadic, IsStatic); - CallingConv ToCC = Context.getDefaultCallingConvention(IsVariadic, !IsStatic); - if (CurCC != FromCC || FromCC == ToCC) - return; + CallingConv ToCC; - if (hasExplicitCallingConv(T)) - return; + // MS compiler ignores explicit calling convention attributes on structors. We + // should do the same. + if (Context.getTargetInfo().getCXXABI().isMicrosoft() && IsCtorOrDtor) { + // getDefaultCallingConvention provides incorrect answer for structors in 32 + // bit MS ABI environment. This probably should be fixed. + if (Context.getTargetInfo().getTriple().isArch32Bit()) + DefaultCC = CC_X86ThisCall; + + if (CurCC == DefaultCC) + return; + + // __declspec(dllexport) got transformed to CC_C and allowed. + if (CurCC == CC_C) + return; + + ToCC = DefaultCC; + + // Issue a warning on ignored calling convention -- except of __stdcall. + // Again, this is what MS compiler does. + if (CurCC != CC_X86StdCall) + Diag(Loc, diag::warn_cconv_structors) + << FunctionType::getNameForCallConv(CurCC); + // Default adjustment. + } else { + // Only adjust types with the default convention. For example, on Windows + // we should adjust a __cdecl type to __thiscall for instance methods, and a + // __thiscall type to __cdecl for static methods. + ToCC = Context.getDefaultCallingConvention(IsVariadic, !IsStatic); + if (CurCC != DefaultCC || DefaultCC == ToCC) + return; + + if (hasExplicitCallingConv(T)) + return; + } FT = Context.adjustFunctionType(FT, FT->getExtInfo().withCallingConv(ToCC)); QualType Wrapped = Unwrapped.wrap(*this, FT); Index: test/CodeGenCXX/microsoft-abi-structors.cpp =================================================================== --- test/CodeGenCXX/microsoft-abi-structors.cpp +++ test/CodeGenCXX/microsoft-abi-structors.cpp @@ -5,6 +5,7 @@ // RUN: FileCheck --check-prefix DTORS %s < %t // RUN: FileCheck --check-prefix DTORS2 %s < %t // RUN: FileCheck --check-prefix DTORS3 %s < %t +// RUN: FileCheck --check-prefix DTORS4 %s < %t // // RUN: %clang_cc1 -emit-llvm %s -o - -mconstructor-aliases -triple=x86_64-pc-win32 -fno-rtti | FileCheck --check-prefix DTORS-X64 %s @@ -458,3 +459,18 @@ // CHECK: (%"struct.(anonymous namespace)::A"* %this, i32 %should_call_delete) // CHECK: define internal x86_thiscallcc void @"\01??1A@?A@@UAE@XZ" // CHECK: (%"struct.(anonymous namespace)::A"* %this) + +// Check that we correctly transform __stdcall to __thiscall for ctors and +// dtors. +class G { + public: + __stdcall G() {}; +// DTORS4: define linkonce_odr x86_thiscallcc %class.G* @"\01??0G@@QAE@XZ" + __stdcall ~G() {}; +// DTORS4: define linkonce_odr x86_thiscallcc void @"\01??1G@@QAE@XZ" +}; + +extern void testG() { + G g; +} + Index: test/SemaCXX/decl-microsoft-call-conv.cpp =================================================================== --- test/SemaCXX/decl-microsoft-call-conv.cpp +++ test/SemaCXX/decl-microsoft-call-conv.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -std=c++14 -triple i686-pc-win32 -fms-extensions -verify %s +// RUN: %clang_cc1 -std=c++14 -triple i686-pc-win32 -fms-extensions -DMSABI -verify %s // RUN: %clang_cc1 -std=c++14 -triple i686-pc-mingw32 -verify %s // RUN: %clang_cc1 -std=c++14 -triple i686-pc-mingw32 -fms-extensions -verify %s @@ -74,6 +74,11 @@ static void static_member_variadic_default(int x, ...); static void __cdecl static_member_variadic_cdecl(int x, ...); + + // Structors can't be other than default in MS ABI environment +#ifdef MSABI + __vectorcall S(); // expected-warning {{vectorcall calling convention ignored on constructor/destructor}} +#endif }; void __cdecl S::member_default1() {} // expected-error {{function declared 'cdecl' here was previously declared without calling convention}}