From: David Majnemer Date: Thu, 16 Jan 2014 20:05:57 +0000 (+0000) Subject: MS ABI: Improve selection of an inheritance model X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=fada0978a377b6c5c7b15cbeafeb51ffde2e5b89;p=clang MS ABI: Improve selection of an inheritance model The MSVC ABI is rather finicky about the exact representation of it's pointer-to-member representation. The exact position of when and where it will go with one representation versus another appears to be when it desires the pointer-to-member to be complete. To properly implement this in clang, do several things: - Give up on tracking the polymorphic nature of the class. It isn't useful to Sema and is only pertinent when choosing CodeGen-time details like whether the field-offset can be 0 instead of -1. - Insist on locking-in the inheritance model when we ask our pointer-to-member type to be complete. From there, grab the underlying CXXRecordDecl and try to make *that* complete. Once we've done this, we can calculate it's inheritance model and apply it using an attribute. N.B. My first bullet point is a lie. We will eventually care about the specifics of whether or not a CXXRecordDecl is or is not polymorphic because MSVC compatible mangling of such things depends on it. However, I believe we will handle this in a rather different way. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@199416 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/AST/DeclCXX.h b/include/clang/AST/DeclCXX.h index 75f20e2462..aee2aad475 100644 --- a/include/clang/AST/DeclCXX.h +++ b/include/clang/AST/DeclCXX.h @@ -17,6 +17,7 @@ #define LLVM_CLANG_AST_DECLCXX_H #include "clang/AST/ASTUnresolvedSet.h" +#include "clang/AST/Attr.h" #include "clang/AST/Decl.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" @@ -258,16 +259,6 @@ public: TypeSourceInfo *getTypeSourceInfo() const { return BaseTypeInfo; } }; -/// The inheritance model to use for member pointers of a given CXXRecordDecl. -enum MSInheritanceModel { - MSIM_Single, - MSIM_SinglePolymorphic, - MSIM_Multiple, - MSIM_MultiplePolymorphic, - MSIM_Virtual, - MSIM_Unspecified -}; - /// \brief Represents a C++ struct/union/class. /// /// FIXME: This class will disappear once we've properly taught RecordDecl @@ -1608,7 +1599,9 @@ public: } /// \brief Returns the inheritance model used for this record. - MSInheritanceModel getMSInheritanceModel() const; + MSInheritanceAttr::Spelling getMSInheritanceModel() const; + /// \brief Locks-in the inheritance model for this class. + void setMSInheritanceModel(); /// \brief Determine whether this lambda expression was known to be dependent /// at the time it was created, even if its context does not appear to be diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h index 9711bf7821..13c4fe908c 100644 --- a/include/clang/AST/Type.h +++ b/include/clang/AST/Type.h @@ -2205,6 +2205,7 @@ public: } const Type *getClass() const { return Class; } + CXXRecordDecl *getMostRecentCXXRecordDecl() const; bool isSugared() const { return false; } QualType desugar() const { return QualType(this, 0); } diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td index caee244d63..95526d7781 100644 --- a/include/clang/Basic/Attr.td +++ b/include/clang/Basic/Attr.td @@ -1377,16 +1377,11 @@ def MSInheritance : InheritableAttr { let Spellings = [Keyword<"__single_inheritance">, Keyword<"__multiple_inheritance">, Keyword<"__virtual_inheritance">, - // We use an empty string to denote an unspecified - // inheritance attribute. - Keyword<"">]; + Keyword<"__unspecified_inheritance">]; let Accessors = [Accessor<"IsSingle", [Keyword<"__single_inheritance">]>, Accessor<"IsMultiple", [Keyword<"__multiple_inheritance">]>, Accessor<"IsVirtual", [Keyword<"__virtual_inheritance">]>, - Accessor<"IsUnspecified", [Keyword<"">]>]; - // This index is based off the Spellings list and corresponds to the empty - // keyword "spelling." - let AdditionalMembers = [{static const int UnspecifiedSpellingIndex = 3;}]; + Accessor<"IsUnspecified", [Keyword<"__unspecified_inheritance">]>]; } def Unaligned : IgnoredAttr { diff --git a/lib/AST/MicrosoftCXXABI.cpp b/lib/AST/MicrosoftCXXABI.cpp index 26e967570a..c3478747a6 100644 --- a/lib/AST/MicrosoftCXXABI.cpp +++ b/lib/AST/MicrosoftCXXABI.cpp @@ -92,28 +92,43 @@ static bool usesMultipleInheritanceModel(const CXXRecordDecl *RD) { return false; } -static MSInheritanceModel MSInheritanceAttrToModel(MSInheritanceAttr *Attr) { +static MSInheritanceAttr::Spelling +MSInheritanceAttrToModel(const MSInheritanceAttr *Attr) { if (Attr->IsSingle()) - return MSIM_Single; + return MSInheritanceAttr::Keyword_single_inheritance; else if (Attr->IsMultiple()) - return MSIM_Multiple; + return MSInheritanceAttr::Keyword_multiple_inheritance; else if (Attr->IsVirtual()) - return MSIM_Virtual; + return MSInheritanceAttr::Keyword_virtual_inheritance; assert(Attr->IsUnspecified() && "Expected unspecified inheritance attr"); - return MSIM_Unspecified; + return MSInheritanceAttr::Keyword_unspecified_inheritance; } -MSInheritanceModel CXXRecordDecl::getMSInheritanceModel() const { - if (MSInheritanceAttr *IA = this->getAttr()) - return MSInheritanceAttrToModel(IA); - // If there was no explicit attribute, the record must be defined already, and - // we can figure out the inheritance model from its other properties. - if (this->getNumVBases() > 0) - return MSIM_Virtual; - if (usesMultipleInheritanceModel(this)) - return this->isPolymorphic() ? MSIM_MultiplePolymorphic : MSIM_Multiple; - return this->isPolymorphic() ? MSIM_SinglePolymorphic : MSIM_Single; +static MSInheritanceAttr::Spelling +calculateInheritanceModel(const CXXRecordDecl *RD) { + if (!RD->hasDefinition()) + return MSInheritanceAttr::Keyword_unspecified_inheritance; + if (RD->getNumVBases() > 0) + return MSInheritanceAttr::Keyword_virtual_inheritance; + if (usesMultipleInheritanceModel(RD)) + return MSInheritanceAttr::Keyword_multiple_inheritance; + return MSInheritanceAttr::Keyword_single_inheritance; +} + +MSInheritanceAttr::Spelling +CXXRecordDecl::getMSInheritanceModel() const { + MSInheritanceAttr *IA = getAttr(); + assert(IA && "Expected MSInheritanceAttr on the CXXRecordDecl!"); + return MSInheritanceAttrToModel(IA); +} + +void CXXRecordDecl::setMSInheritanceModel() { + if (hasAttr()) + return; + + addAttr(MSInheritanceAttr::CreateImplicit( + getASTContext(), calculateInheritanceModel(this), getSourceRange())); } // Returns the number of pointer and integer slots used to represent a member @@ -146,9 +161,9 @@ MSInheritanceModel CXXRecordDecl::getMSInheritanceModel() const { // }; static std::pair getMSMemberPointerSlots(const MemberPointerType *MPT) { - const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl(); - MSInheritanceModel Inheritance = RD->getMSInheritanceModel(); - unsigned Ptrs; + const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); + MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); + unsigned Ptrs = 0; unsigned Ints = 0; if (MPT->isMemberFunctionPointer()) { // Member function pointers are a struct of a function pointer followed by a @@ -156,26 +171,29 @@ getMSMemberPointerSlots(const MemberPointerType *MPT) { // function pointer is a real function if it is non-virtual and a vftable // slot thunk if it is virtual. The ints select the object base passed for // the 'this' pointer. - Ptrs = 1; // First slot is always a function pointer. + Ptrs = 1; // First slot is always a function pointer. switch (Inheritance) { - case MSIM_Unspecified: ++Ints; // VBTableOffset - case MSIM_Virtual: ++Ints; // VirtualBaseAdjustmentOffset - case MSIM_MultiplePolymorphic: - case MSIM_Multiple: ++Ints; // NonVirtualBaseAdjustment - case MSIM_SinglePolymorphic: - case MSIM_Single: break; // Nothing + case MSInheritanceAttr::Keyword_unspecified_inheritance: + ++Ints; // VBTableOffset + case MSInheritanceAttr::Keyword_virtual_inheritance: + ++Ints; // VirtualBaseAdjustmentOffset + case MSInheritanceAttr::Keyword_multiple_inheritance: + ++Ints; // NonVirtualBaseAdjustment + case MSInheritanceAttr::Keyword_single_inheritance: + break; // Nothing } } else { // Data pointers are an aggregate of ints. The first int is an offset // followed by vbtable-related offsets. - Ptrs = 0; + Ints = 1; // We always have a field offset. switch (Inheritance) { - case MSIM_Unspecified: ++Ints; // VBTableOffset - case MSIM_Virtual: ++Ints; // VirtualBaseAdjustmentOffset - case MSIM_MultiplePolymorphic: - case MSIM_Multiple: // Nothing - case MSIM_SinglePolymorphic: - case MSIM_Single: ++Ints; // Field offset + case MSInheritanceAttr::Keyword_unspecified_inheritance: + ++Ints; // VBTableOffset + case MSInheritanceAttr::Keyword_virtual_inheritance: + ++Ints; // VirtualBaseAdjustmentOffset + case MSInheritanceAttr::Keyword_multiple_inheritance: + case MSInheritanceAttr::Keyword_single_inheritance: + break; // Nothing } } return std::make_pair(Ptrs, Ints); diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp index cbb8bc6131..ff64a994e3 100644 --- a/lib/AST/Type.cpp +++ b/lib/AST/Type.cpp @@ -2444,3 +2444,7 @@ QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) { return DK_none; } + +CXXRecordDecl *MemberPointerType::getMostRecentCXXRecordDecl() const { + return getClass()->getAsCXXRecordDecl()->getMostRecentDecl(); +} diff --git a/lib/CodeGen/MicrosoftCXXABI.cpp b/lib/CodeGen/MicrosoftCXXABI.cpp index 32f8ab2fb5..875591d0df 100644 --- a/lib/CodeGen/MicrosoftCXXABI.cpp +++ b/lib/CodeGen/MicrosoftCXXABI.cpp @@ -1322,25 +1322,29 @@ void MicrosoftCXXABI::EmitGuardedInit(CodeGenFunction &CGF, const VarDecl &D, } // Member pointer helpers. -static bool hasVBPtrOffsetField(MSInheritanceModel Inheritance) { - return Inheritance == MSIM_Unspecified; +static bool hasVBPtrOffsetField(MSInheritanceAttr::Spelling Inheritance) { + return Inheritance == MSInheritanceAttr::Keyword_unspecified_inheritance; } static bool hasOnlyOneField(bool IsMemberFunction, - MSInheritanceModel Inheritance) { - return Inheritance <= MSIM_SinglePolymorphic || - (!IsMemberFunction && Inheritance <= MSIM_MultiplePolymorphic); + MSInheritanceAttr::Spelling Inheritance) { + if (IsMemberFunction) + return Inheritance <= MSInheritanceAttr::Keyword_single_inheritance; + return Inheritance <= MSInheritanceAttr::Keyword_multiple_inheritance; } // Only member pointers to functions need a this adjustment, since it can be // combined with the field offset for data pointers. -static bool hasNonVirtualBaseAdjustmentField(bool IsMemberFunction, - MSInheritanceModel Inheritance) { - return (IsMemberFunction && Inheritance >= MSIM_Multiple); +static bool +hasNonVirtualBaseAdjustmentField(bool IsMemberFunction, + MSInheritanceAttr::Spelling Inheritance) { + return IsMemberFunction && + Inheritance >= MSInheritanceAttr::Keyword_multiple_inheritance; } -static bool hasVirtualBaseAdjustmentField(MSInheritanceModel Inheritance) { - return Inheritance >= MSIM_Virtual; +static bool +hasVirtualBaseAdjustmentField(MSInheritanceAttr::Spelling Inheritance) { + return Inheritance >= MSInheritanceAttr::Keyword_virtual_inheritance; } // Use zero for the field offset of a null data member pointer if we can @@ -1349,8 +1353,10 @@ static bool hasVirtualBaseAdjustmentField(MSInheritanceModel Inheritance) { // use zero for null. If there are multiple fields, we can use zero even if it // is a valid field offset because null-ness testing will check the other // fields. -static bool nullFieldOffsetIsZero(MSInheritanceModel Inheritance) { - return Inheritance != MSIM_Multiple && Inheritance != MSIM_Single; +static bool nullFieldOffsetIsZero(const CXXRecordDecl *RD) { + return RD->getMSInheritanceModel() >= + MSInheritanceAttr::Keyword_virtual_inheritance || + (RD->hasDefinition() && RD->isPolymorphic()); } bool MicrosoftCXXABI::isZeroInitializable(const MemberPointerType *MPT) { @@ -1362,16 +1368,16 @@ bool MicrosoftCXXABI::isZeroInitializable(const MemberPointerType *MPT) { // The virtual base adjustment field is always -1 for null, so if we have one // we can't zero initialize. The field offset is sometimes also -1 if 0 is a // valid field offset. - const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl(); - MSInheritanceModel Inheritance = RD->getMSInheritanceModel(); + const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); + MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); return (!hasVirtualBaseAdjustmentField(Inheritance) && - nullFieldOffsetIsZero(Inheritance)); + nullFieldOffsetIsZero(RD)); } llvm::Type * MicrosoftCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) { - const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl(); - MSInheritanceModel Inheritance = RD->getMSInheritanceModel(); + const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); + MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); llvm::SmallVector fields; if (MPT->isMemberFunctionPointer()) fields.push_back(CGM.VoidPtrTy); // FunctionPointerOrVirtualThunk @@ -1395,13 +1401,13 @@ void MicrosoftCXXABI:: GetNullMemberPointerFields(const MemberPointerType *MPT, llvm::SmallVectorImpl &fields) { assert(fields.empty()); - const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl(); - MSInheritanceModel Inheritance = RD->getMSInheritanceModel(); + const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); + MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); if (MPT->isMemberFunctionPointer()) { // FunctionPointerOrVirtualThunk fields.push_back(llvm::Constant::getNullValue(CGM.VoidPtrTy)); } else { - if (nullFieldOffsetIsZero(Inheritance)) + if (nullFieldOffsetIsZero(RD)) fields.push_back(getZeroInt()); // FieldOffset else fields.push_back(getAllOnesInt()); // FieldOffset @@ -1433,7 +1439,7 @@ MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField, const CXXRecordDecl *RD, CharUnits NonVirtualBaseAdjustment) { - MSInheritanceModel Inheritance = RD->getMSInheritanceModel(); + MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); // Single inheritance class member pointer are represented as scalars instead // of aggregates. @@ -1464,7 +1470,7 @@ MicrosoftCXXABI::EmitFullMemberPointer(llvm::Constant *FirstField, llvm::Constant * MicrosoftCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset) { - const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl(); + const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); llvm::Constant *FirstField = llvm::ConstantInt::get(CGM.IntTy, offset.getQuantity()); return EmitFullMemberPointer(FirstField, /*IsMemberFunction=*/false, RD, @@ -1487,8 +1493,8 @@ llvm::Constant *MicrosoftCXXABI::EmitMemberPointer(const APValue &MP, // FIXME PR15713: Support virtual inheritance paths. if (const CXXMethodDecl *MD = dyn_cast(MPD)) - return BuildMemberPointer(MPT->getClass()->getAsCXXRecordDecl(), - MD, ThisAdjustment); + return BuildMemberPointer(MPT->getMostRecentCXXRecordDecl(), MD, + ThisAdjustment); CharUnits FieldOffset = getContext().toCharUnitsFromBits(getContext().getFieldOffset(MPD)); @@ -1501,6 +1507,7 @@ MicrosoftCXXABI::BuildMemberPointer(const CXXRecordDecl *RD, CharUnits NonVirtualBaseAdjustment) { assert(MD->isInstance() && "Member function must not be static!"); MD = MD->getCanonicalDecl(); + RD = RD->getMostRecentDecl(); CodeGenTypes &Types = CGM.getTypes(); llvm::Constant *FirstField; @@ -1578,8 +1585,8 @@ MicrosoftCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF, // If this is a single field member pointer (single inheritance), this is a // single icmp. - const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl(); - MSInheritanceModel Inheritance = RD->getMSInheritanceModel(); + const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); + MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); if (hasOnlyOneField(MPT->isMemberFunctionPointer(), Inheritance)) return Builder.CreateICmp(Eq, L, R); @@ -1760,8 +1767,8 @@ MicrosoftCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, llvm::Type *PType = CGF.ConvertTypeForMem(MPT->getPointeeType())->getPointerTo(AS); CGBuilderTy &Builder = CGF.Builder; - const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl(); - MSInheritanceModel Inheritance = RD->getMSInheritanceModel(); + const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); + MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); // Extract the fields we need, regardless of model. We'll apply them if we // have them. @@ -1795,9 +1802,9 @@ MicrosoftCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, return Builder.CreateBitCast(Addr, PType); } -static MSInheritanceModel +static MSInheritanceAttr::Spelling getInheritanceFromMemptr(const MemberPointerType *MPT) { - return MPT->getClass()->getAsCXXRecordDecl()->getMSInheritanceModel(); + return MPT->getMostRecentCXXRecordDecl()->getMSInheritanceModel(); } llvm::Value * @@ -1817,15 +1824,17 @@ MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF, const MemberPointerType *SrcTy = E->getSubExpr()->getType()->castAs(); const MemberPointerType *DstTy = E->getType()->castAs(); - MSInheritanceModel SrcInheritance = getInheritanceFromMemptr(SrcTy); - MSInheritanceModel DstInheritance = getInheritanceFromMemptr(DstTy); bool IsFunc = SrcTy->isMemberFunctionPointer(); // If the classes use the same null representation, reinterpret_cast is a nop. bool IsReinterpret = E->getCastKind() == CK_ReinterpretMemberPointer; - if (IsReinterpret && (IsFunc || - nullFieldOffsetIsZero(SrcInheritance) == - nullFieldOffsetIsZero(DstInheritance))) + if (IsReinterpret && IsFunc) + return Src; + + CXXRecordDecl *SrcRD = SrcTy->getMostRecentCXXRecordDecl(); + CXXRecordDecl *DstRD = DstTy->getMostRecentCXXRecordDecl(); + if (IsReinterpret && + nullFieldOffsetIsZero(SrcRD) == nullFieldOffsetIsZero(DstRD)) return Src; CGBuilderTy &Builder = CGF.Builder; @@ -1854,6 +1863,7 @@ MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF, llvm::Value *NonVirtualBaseAdjustment = 0; llvm::Value *VirtualBaseAdjustmentOffset = 0; llvm::Value *VBPtrOffset = 0; + MSInheritanceAttr::Spelling SrcInheritance = SrcRD->getMSInheritanceModel(); if (!hasOnlyOneField(IsFunc, SrcInheritance)) { // We need to extract values. unsigned I = 0; @@ -1884,6 +1894,7 @@ MicrosoftCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF, // FIXME PR15713: Support conversions through virtually derived classes. // Recompose dst from the null struct and the adjusted fields from src. + MSInheritanceAttr::Spelling DstInheritance = DstRD->getMSInheritanceModel(); llvm::Value *Dst; if (hasOnlyOneField(IsFunc, DstInheritance)) { Dst = FirstField; @@ -1929,8 +1940,8 @@ MicrosoftCXXABI::EmitMemberPointerConversion(const CastExpr *E, if (E->getCastKind() == CK_ReinterpretMemberPointer) return Src; - MSInheritanceModel SrcInheritance = getInheritanceFromMemptr(SrcTy); - MSInheritanceModel DstInheritance = getInheritanceFromMemptr(DstTy); + MSInheritanceAttr::Spelling SrcInheritance = getInheritanceFromMemptr(SrcTy); + MSInheritanceAttr::Spelling DstInheritance = getInheritanceFromMemptr(DstTy); // Decompose src. llvm::Constant *FirstField = Src; @@ -1991,13 +2002,13 @@ MicrosoftCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, assert(MPT->isMemberFunctionPointer()); const FunctionProtoType *FPT = MPT->getPointeeType()->castAs(); - const CXXRecordDecl *RD = MPT->getClass()->getAsCXXRecordDecl(); + const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType( CGM.getTypes().arrangeCXXMethodType(RD, FPT)); CGBuilderTy &Builder = CGF.Builder; - MSInheritanceModel Inheritance = RD->getMSInheritanceModel(); + MSInheritanceAttr::Spelling Inheritance = RD->getMSInheritanceModel(); // Extract the fields we need, regardless of model. We'll apply them if we // have them. diff --git a/lib/Sema/SemaCast.cpp b/lib/Sema/SemaCast.cpp index 63cb15db52..499e8b18be 100644 --- a/lib/Sema/SemaCast.cpp +++ b/lib/Sema/SemaCast.cpp @@ -21,6 +21,7 @@ #include "clang/AST/ExprObjC.h" #include "clang/AST/RecordLayout.h" #include "clang/Basic/PartialDiagnostic.h" +#include "clang/Basic/TargetInfo.h" #include "clang/Sema/Initialization.h" #include "llvm/ADT/SmallVector.h" #include @@ -1779,6 +1780,13 @@ static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, return TC_Failed; } + if (Self.Context.getTargetInfo().getCXXABI().isMicrosoft()) { + // We need to determine the inheritance model that the class will use if + // haven't yet. + Self.RequireCompleteType(OpRange.getBegin(), SrcType, 0); + Self.RequireCompleteType(OpRange.getBegin(), DestType, 0); + } + // Don't allow casting between member pointers of different sizes. if (Self.Context.getTypeSize(DestMemPtr) != Self.Context.getTypeSize(SrcMemPtr)) { diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp index bc674d53d7..30edc48dd5 100644 --- a/lib/Sema/SemaType.cpp +++ b/lib/Sema/SemaType.cpp @@ -1753,35 +1753,6 @@ QualType Sema::BuildMemberPointerType(QualType T, QualType Class, return QualType(); } - // C++ allows the class type in a member pointer to be an incomplete type. - // In the Microsoft ABI, the size of the member pointer can vary - // according to the class type, which means that we really need a - // complete type if possible, which means we need to instantiate templates. - // - // If template instantiation fails or the type is just incomplete, we have to - // add an extra slot to the member pointer. Yes, this does cause problems - // when passing pointers between TUs that disagree about the size. - if (Context.getTargetInfo().getCXXABI().isMicrosoft()) { - CXXRecordDecl *RD = Class->getAsCXXRecordDecl(); - if (RD && !RD->hasAttr()) { - // Lock in the inheritance model on the first use of a member pointer. - // Otherwise we may disagree about the size at different points in the TU. - // FIXME: MSVC picks a model on the first use that needs to know the size, - // rather than on the first mention of the type, e.g. typedefs. - if (RequireCompleteType(Loc, Class, 0) && !RD->isBeingDefined()) { - // We know it doesn't have an attribute and it's incomplete, so use the - // unspecified inheritance model. If we're in the record body, we can - // figure out the inheritance model. - for (CXXRecordDecl::redecl_iterator I = RD->redecls_begin(), - E = RD->redecls_end(); I != E; ++I) { - I->addAttr(::new (Context) MSInheritanceAttr(RD->getSourceRange(), - Context, - MSInheritanceAttr::UnspecifiedSpellingIndex)); - } - } - } - } - // Adjust the default free function calling convention to the default method // calling convention. if (T->isFunctionType()) @@ -5096,6 +5067,18 @@ bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T, } } + // We lock in the inheritance model once somebody has asked us to ensure + // that a pointer-to-member type is complete. + if (Context.getTargetInfo().getCXXABI().isMicrosoft()) { + if (const MemberPointerType *MPTy = T->getAs()) { + if (!MPTy->getClass()->isDependentType()) { + RequireCompleteType(Loc, QualType(MPTy->getClass(), 0), 0); + + MPTy->getMostRecentCXXRecordDecl()->setMSInheritanceModel(); + } + } + } + return false; } diff --git a/test/SemaCXX/microsoft-abi-ptm.cpp b/test/SemaCXX/microsoft-abi-ptm.cpp new file mode 100644 index 0000000000..8ee8a2d4a2 --- /dev/null +++ b/test/SemaCXX/microsoft-abi-ptm.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -triple %ms_abi_triple -std=c++11 -fsyntax-only -fms-extensions -fms-compatibility %s + +namespace Test1 { +struct A; +void f(int A::*mp); +struct A { }; +static_assert(sizeof(int A::*) == sizeof(int), "pointer-to-member should be sizeof(int)"); +} + +namespace Test2 { +struct A; +void f(int A::*mp); +static_assert(sizeof(int A::*) == sizeof(int) * 3, "pointer-to-member should be sizeof(int) * 3"); +struct A { }; +static_assert(sizeof(int A::*) == sizeof(int) * 3, "pointer-to-member should still be sizeof(int) * 3"); +} + +namespace Test3 { +struct A; +typedef int A::*p; +struct __single_inheritance A; +p my_ptr; +static_assert(sizeof(int A::*) == sizeof(int), "pointer-to-member should be sizeof(int)"); +}