r310401 - PR19668, PR23034: Fix handling of move constructors and deleted copy

Vassil Vassilev via cfe-commits cfe-commits at lists.llvm.org
Thu Aug 10 01:09:43 PDT 2017


It looks like I can not reproduce it on osx (non-arm)... :(
On 09/08/17 22:54, Diana Picus wrote:
> Reverting this also fixed the selfhost bots:
> http://lab.llvm.org:8011/builders/clang-cmake-thumbv7-a15-full-sh/builds/2142
> http://lab.llvm.org:8011/builders/clang-cmake-armv7-a15-selfhost/builds/2309
> http://lab.llvm.org:8011/builders/clang-cmake-armv7-a15-selfhost-neon/builds/1819
>
> I'm afraid the logs for those look even less helpful.
>
> On 9 August 2017 at 16:17, Diana Picus <diana.picus at linaro.org> wrote:
>> Hi,
>>
>> See attached. FWIW, when I ran this on a very similar machine, I got
>> 194 failures, all of which went away after reverting. So there might
>> be something fishy going on.
>>
>> Regards,
>> Diana
>>
>> On 9 August 2017 at 15:02, Vassil Vassilev <v.g.vassilev at gmail.com> wrote:
>>> Hi Diana,
>>>
>>>    It seems the service is down. Could you send us the details of the
>>> failures (incl stack traces if any)
>>>
>>> Many thanks,
>>> Vassil
>>>
>>> On 09/08/17 15:27, Diana Picus via cfe-commits wrote:
>>>> Hi Richard,
>>>>
>>>> I'm sorry but I've reverted this in r310464 because it was breaking
>>>> some ASAN tests on this bot:
>>>> http://lab.llvm.org:8011/builders/clang-cmake-armv7-a15-full/builds/9452
>>>>
>>>> Please let me know if I can help debug this.
>>>>
>>>> Cheers,
>>>> Diana
>>>>
>>>> On 8 August 2017 at 21:14, Richard Smith via cfe-commits
>>>> <cfe-commits at lists.llvm.org> wrote:
>>>>> I forgot to say:
>>>>>
>>>>> Based on a patch by Vassil Vassilev, which was based on a patch by Bernd
>>>>> Schmidt, which was based on a patch by Reid Kleckner.
>>>>>
>>>>> On 8 August 2017 at 12:12, Richard Smith via cfe-commits
>>>>> <cfe-commits at lists.llvm.org> wrote:
>>>>>> Author: rsmith
>>>>>> Date: Tue Aug  8 12:12:28 2017
>>>>>> New Revision: 310401
>>>>>>
>>>>>> URL: http://llvm.org/viewvc/llvm-project?rev=310401&view=rev
>>>>>> Log:
>>>>>> PR19668, PR23034: Fix handling of move constructors and deleted copy
>>>>>> constructors when deciding whether classes should be passed indirectly.
>>>>>>
>>>>>> This fixes ABI differences between Clang and GCC:
>>>>>>
>>>>>>    * Previously, Clang ignored the move constructor when making this
>>>>>>      determination. It now takes the move constructor into account, per
>>>>>>      https://github.com/itanium-cxx-abi/cxx-abi/pull/17 (this change may
>>>>>>      seem recent, but the ABI change was agreed on the Itanium C++ ABI
>>>>>>      list a long time ago).
>>>>>>
>>>>>>    * Previously, Clang's behavior when the copy constructor was deleted
>>>>>>      was unstable -- depending on whether the lazy declaration of the
>>>>>>      copy constructor had been triggered, you might get different
>>>>>> behavior.
>>>>>>      We now eagerly declare the copy constructor whenever its deletedness
>>>>>>      is unclear, and ignore deleted copy/move constructors when looking
>>>>>> for
>>>>>>      a trivial such constructor.
>>>>>>
>>>>>> This also fixes an ABI difference between Clang and MSVC:
>>>>>>
>>>>>>    * If the copy constructor would be implicitly deleted (but has not
>>>>>> been
>>>>>>      lazily declared yet), for instance because the class has an rvalue
>>>>>>      reference member, we would pass it directly. We now pass such a
>>>>>> class
>>>>>>      indirectly, matching MSVC.
>>>>>>
>>>>>> Modified:
>>>>>>       cfe/trunk/include/clang/AST/DeclCXX.h
>>>>>>       cfe/trunk/lib/AST/ASTImporter.cpp
>>>>>>       cfe/trunk/lib/AST/DeclCXX.cpp
>>>>>>       cfe/trunk/lib/CodeGen/CGCXXABI.cpp
>>>>>>       cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp
>>>>>>       cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp
>>>>>>       cfe/trunk/lib/Sema/SemaDeclCXX.cpp
>>>>>>       cfe/trunk/lib/Serialization/ASTReaderDecl.cpp
>>>>>>       cfe/trunk/lib/Serialization/ASTWriter.cpp
>>>>>>       cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp
>>>>>>       cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
>>>>>>
>>>>>> Modified: cfe/trunk/include/clang/AST/DeclCXX.h
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/DeclCXX.h?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/include/clang/AST/DeclCXX.h (original)
>>>>>> +++ cfe/trunk/include/clang/AST/DeclCXX.h Tue Aug  8 12:12:28 2017
>>>>>> @@ -375,6 +375,7 @@ class CXXRecordDecl : public RecordDecl
>>>>>>        /// \brief These flags are \c true if a defaulted corresponding
>>>>>> special
>>>>>>        /// member can't be fully analyzed without performing overload
>>>>>> resolution.
>>>>>>        /// @{
>>>>>> +    unsigned NeedOverloadResolutionForCopyConstructor : 1;
>>>>>>        unsigned NeedOverloadResolutionForMoveConstructor : 1;
>>>>>>        unsigned NeedOverloadResolutionForMoveAssignment : 1;
>>>>>>        unsigned NeedOverloadResolutionForDestructor : 1;
>>>>>> @@ -383,6 +384,7 @@ class CXXRecordDecl : public RecordDecl
>>>>>>        /// \brief These flags are \c true if an implicit defaulted
>>>>>> corresponding
>>>>>>        /// special member would be defined as deleted.
>>>>>>        /// @{
>>>>>> +    unsigned DefaultedCopyConstructorIsDeleted : 1;
>>>>>>        unsigned DefaultedMoveConstructorIsDeleted : 1;
>>>>>>        unsigned DefaultedMoveAssignmentIsDeleted : 1;
>>>>>>        unsigned DefaultedDestructorIsDeleted : 1;
>>>>>> @@ -415,6 +417,12 @@ class CXXRecordDecl : public RecordDecl
>>>>>>        /// constructor.
>>>>>>        unsigned HasDefaultedDefaultConstructor : 1;
>>>>>>
>>>>>> +    /// \brief True if this class can be passed in a
>>>>>> non-address-preserving
>>>>>> +    /// fashion (such as in registers) according to the C++ language
>>>>>> rules.
>>>>>> +    /// This does not imply anything about how the ABI in use will
>>>>>> actually
>>>>>> +    /// pass an object of this class.
>>>>>> +    unsigned CanPassInRegisters : 1;
>>>>>> +
>>>>>>        /// \brief True if a defaulted default constructor for this class
>>>>>> would
>>>>>>        /// be constexpr.
>>>>>>        unsigned DefaultedDefaultConstructorIsConstexpr : 1;
>>>>>> @@ -811,18 +819,50 @@ public:
>>>>>>        return data().FirstFriend.isValid();
>>>>>>      }
>>>>>>
>>>>>> +  /// \brief \c true if a defaulted copy constructor for this class
>>>>>> would
>>>>>> be
>>>>>> +  /// deleted.
>>>>>> +  bool defaultedCopyConstructorIsDeleted() const {
>>>>>> +    assert((!needsOverloadResolutionForCopyConstructor() ||
>>>>>> +            (data().DeclaredSpecialMembers & SMF_CopyConstructor)) &&
>>>>>> +           "this property has not yet been computed by Sema");
>>>>>> +    return data().DefaultedCopyConstructorIsDeleted;
>>>>>> +  }
>>>>>> +
>>>>>> +  /// \brief \c true if a defaulted move constructor for this class
>>>>>> would
>>>>>> be
>>>>>> +  /// deleted.
>>>>>> +  bool defaultedMoveConstructorIsDeleted() const {
>>>>>> +    assert((!needsOverloadResolutionForMoveConstructor() ||
>>>>>> +            (data().DeclaredSpecialMembers & SMF_MoveConstructor)) &&
>>>>>> +           "this property has not yet been computed by Sema");
>>>>>> +    return data().DefaultedMoveConstructorIsDeleted;
>>>>>> +  }
>>>>>> +
>>>>>> +  /// \brief \c true if a defaulted destructor for this class would be
>>>>>> deleted.
>>>>>> +  bool defaultedDestructorIsDeleted() const {
>>>>>> +    return !data().DefaultedDestructorIsDeleted;
>>>>>> +  }
>>>>>> +
>>>>>> +  /// \brief \c true if we know for sure that this class has a single,
>>>>>> +  /// accessible, unambiguous copy constructor that is not deleted.
>>>>>> +  bool hasSimpleCopyConstructor() const {
>>>>>> +    return !hasUserDeclaredCopyConstructor() &&
>>>>>> +           !data().DefaultedCopyConstructorIsDeleted;
>>>>>> +  }
>>>>>> +
>>>>>>      /// \brief \c true if we know for sure that this class has a single,
>>>>>>      /// accessible, unambiguous move constructor that is not deleted.
>>>>>>      bool hasSimpleMoveConstructor() const {
>>>>>>        return !hasUserDeclaredMoveConstructor() && hasMoveConstructor()
>>>>>> &&
>>>>>>               !data().DefaultedMoveConstructorIsDeleted;
>>>>>>      }
>>>>>> +
>>>>>>      /// \brief \c true if we know for sure that this class has a single,
>>>>>>      /// accessible, unambiguous move assignment operator that is not
>>>>>> deleted.
>>>>>>      bool hasSimpleMoveAssignment() const {
>>>>>>        return !hasUserDeclaredMoveAssignment() && hasMoveAssignment() &&
>>>>>>               !data().DefaultedMoveAssignmentIsDeleted;
>>>>>>      }
>>>>>> +
>>>>>>      /// \brief \c true if we know for sure that this class has an
>>>>>> accessible
>>>>>>      /// destructor that is not deleted.
>>>>>>      bool hasSimpleDestructor() const {
>>>>>> @@ -878,7 +918,16 @@ public:
>>>>>>      /// \brief Determine whether we need to eagerly declare a defaulted
>>>>>> copy
>>>>>>      /// constructor for this class.
>>>>>>      bool needsOverloadResolutionForCopyConstructor() const {
>>>>>> -    return data().HasMutableFields;
>>>>>> +    // C++17 [class.copy.ctor]p6:
>>>>>> +    //   If the class definition declares a move constructor or move
>>>>>> assignment
>>>>>> +    //   operator, the implicitly declared copy constructor is defined
>>>>>> as
>>>>>> +    //   deleted.
>>>>>> +    // In MSVC mode, sometimes a declared move assignment does not
>>>>>> delete
>>>>>> an
>>>>>> +    // implicit copy constructor, so defer this choice to Sema.
>>>>>> +    if (data().UserDeclaredSpecialMembers &
>>>>>> +        (SMF_MoveConstructor | SMF_MoveAssignment))
>>>>>> +      return true;
>>>>>> +    return data().NeedOverloadResolutionForCopyConstructor;
>>>>>>      }
>>>>>>
>>>>>>      /// \brief Determine whether an implicit copy constructor for this
>>>>>> type
>>>>>> @@ -919,7 +968,16 @@ public:
>>>>>>               needsImplicitMoveConstructor();
>>>>>>      }
>>>>>>
>>>>>> -  /// \brief Set that we attempted to declare an implicitly move
>>>>>> +  /// \brief Set that we attempted to declare an implicit copy
>>>>>> +  /// constructor, but overload resolution failed so we deleted it.
>>>>>> +  void setImplicitCopyConstructorIsDeleted() {
>>>>>> +    assert((data().DefaultedCopyConstructorIsDeleted ||
>>>>>> +            needsOverloadResolutionForCopyConstructor()) &&
>>>>>> +           "Copy constructor should not be deleted");
>>>>>> +    data().DefaultedCopyConstructorIsDeleted = true;
>>>>>> +  }
>>>>>> +
>>>>>> +  /// \brief Set that we attempted to declare an implicit move
>>>>>>      /// constructor, but overload resolution failed so we deleted it.
>>>>>>      void setImplicitMoveConstructorIsDeleted() {
>>>>>>        assert((data().DefaultedMoveConstructorIsDeleted ||
>>>>>> @@ -1316,6 +1374,18 @@ public:
>>>>>>        return data().HasIrrelevantDestructor;
>>>>>>      }
>>>>>>
>>>>>> +  /// \brief Determine whether this class has at least one trivial,
>>>>>> non-deleted
>>>>>> +  /// copy or move constructor.
>>>>>> +  bool canPassInRegisters() const {
>>>>>> +    return data().CanPassInRegisters;
>>>>>> +  }
>>>>>> +
>>>>>> +  /// \brief Set that we can pass this RecordDecl in registers.
>>>>>> +  // FIXME: This should be set as part of completeDefinition.
>>>>>> +  void setCanPassInRegisters(bool CanPass) {
>>>>>> +    data().CanPassInRegisters = CanPass;
>>>>>> +  }
>>>>>> +
>>>>>>      /// \brief Determine whether this class has a non-literal or/
>>>>>> volatile
>>>>>> type
>>>>>>      /// non-static data member or base class.
>>>>>>      bool hasNonLiteralTypeFieldsOrBases() const {
>>>>>>
>>>>>> Modified: cfe/trunk/lib/AST/ASTImporter.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ASTImporter.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/lib/AST/ASTImporter.cpp (original)
>>>>>> +++ cfe/trunk/lib/AST/ASTImporter.cpp Tue Aug  8 12:12:28 2017
>>>>>> @@ -956,12 +956,16 @@ bool ASTNodeImporter::ImportDefinition(R
>>>>>>        ToData.HasUninitializedFields = FromData.HasUninitializedFields;
>>>>>>        ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
>>>>>>        ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
>>>>>> +    ToData.NeedOverloadResolutionForCopyConstructor
>>>>>> +      = FromData.NeedOverloadResolutionForCopyConstructor;
>>>>>>        ToData.NeedOverloadResolutionForMoveConstructor
>>>>>>          = FromData.NeedOverloadResolutionForMoveConstructor;
>>>>>>        ToData.NeedOverloadResolutionForMoveAssignment
>>>>>>          = FromData.NeedOverloadResolutionForMoveAssignment;
>>>>>>        ToData.NeedOverloadResolutionForDestructor
>>>>>>          = FromData.NeedOverloadResolutionForDestructor;
>>>>>> +    ToData.DefaultedCopyConstructorIsDeleted
>>>>>> +      = FromData.DefaultedCopyConstructorIsDeleted;
>>>>>>        ToData.DefaultedMoveConstructorIsDeleted
>>>>>>          = FromData.DefaultedMoveConstructorIsDeleted;
>>>>>>        ToData.DefaultedMoveAssignmentIsDeleted
>>>>>> @@ -973,6 +977,7 @@ bool ASTNodeImporter::ImportDefinition(R
>>>>>>          = FromData.HasConstexprNonCopyMoveConstructor;
>>>>>>        ToData.HasDefaultedDefaultConstructor
>>>>>>          = FromData.HasDefaultedDefaultConstructor;
>>>>>> +    ToData.CanPassInRegisters = FromData.CanPassInRegisters;
>>>>>>        ToData.DefaultedDefaultConstructorIsConstexpr
>>>>>>          = FromData.DefaultedDefaultConstructorIsConstexpr;
>>>>>>        ToData.HasConstexprDefaultConstructor
>>>>>>
>>>>>> Modified: cfe/trunk/lib/AST/DeclCXX.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/DeclCXX.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/lib/AST/DeclCXX.cpp (original)
>>>>>> +++ cfe/trunk/lib/AST/DeclCXX.cpp Tue Aug  8 12:12:28 2017
>>>>>> @@ -55,15 +55,18 @@ CXXRecordDecl::DefinitionData::Definitio
>>>>>>          HasOnlyCMembers(true), HasInClassInitializer(false),
>>>>>>          HasUninitializedReferenceMember(false),
>>>>>> HasUninitializedFields(false),
>>>>>>          HasInheritedConstructor(false), HasInheritedAssignment(false),
>>>>>> +      NeedOverloadResolutionForCopyConstructor(false),
>>>>>>          NeedOverloadResolutionForMoveConstructor(false),
>>>>>>          NeedOverloadResolutionForMoveAssignment(false),
>>>>>>          NeedOverloadResolutionForDestructor(false),
>>>>>> +      DefaultedCopyConstructorIsDeleted(false),
>>>>>>          DefaultedMoveConstructorIsDeleted(false),
>>>>>>          DefaultedMoveAssignmentIsDeleted(false),
>>>>>>          DefaultedDestructorIsDeleted(false),
>>>>>> HasTrivialSpecialMembers(SMF_All),
>>>>>>          DeclaredNonTrivialSpecialMembers(0),
>>>>>> HasIrrelevantDestructor(true),
>>>>>>          HasConstexprNonCopyMoveConstructor(false),
>>>>>>          HasDefaultedDefaultConstructor(false),
>>>>>> +      CanPassInRegisters(false),
>>>>>>          DefaultedDefaultConstructorIsConstexpr(true),
>>>>>>          HasConstexprDefaultConstructor(false),
>>>>>>          HasNonLiteralTypeFieldsOrBases(false),
>>>>>> ComputedVisibleConversions(false),
>>>>>> @@ -352,8 +355,10 @@ CXXRecordDecl::setBases(CXXBaseSpecifier
>>>>>>          setHasVolatileMember(true);
>>>>>>
>>>>>>        // Keep track of the presence of mutable fields.
>>>>>> -    if (BaseClassDecl->hasMutableFields())
>>>>>> +    if (BaseClassDecl->hasMutableFields()) {
>>>>>>          data().HasMutableFields = true;
>>>>>> +      data().NeedOverloadResolutionForCopyConstructor = true;
>>>>>> +    }
>>>>>>
>>>>>>        if (BaseClassDecl->hasUninitializedReferenceMember())
>>>>>>          data().HasUninitializedReferenceMember = true;
>>>>>> @@ -406,6 +411,8 @@ void CXXRecordDecl::addedClassSubobject(
>>>>>>      //    -- a direct or virtual base class B that cannot be
>>>>>> copied/moved
>>>>>> [...]
>>>>>>      //    -- a non-static data member of class type M (or array thereof)
>>>>>>      //       that cannot be copied or moved [...]
>>>>>> +  if (!Subobj->hasSimpleCopyConstructor())
>>>>>> +    data().NeedOverloadResolutionForCopyConstructor = true;
>>>>>>      if (!Subobj->hasSimpleMoveConstructor())
>>>>>>        data().NeedOverloadResolutionForMoveConstructor = true;
>>>>>>
>>>>>> @@ -426,6 +433,7 @@ void CXXRecordDecl::addedClassSubobject(
>>>>>>      //    -- any non-static data member has a type with a destructor
>>>>>>      //       that is deleted or inaccessible from the defaulted [ctor or
>>>>>> dtor].
>>>>>>      if (!Subobj->hasSimpleDestructor()) {
>>>>>> +    data().NeedOverloadResolutionForCopyConstructor = true;
>>>>>>        data().NeedOverloadResolutionForMoveConstructor = true;
>>>>>>        data().NeedOverloadResolutionForDestructor = true;
>>>>>>      }
>>>>>> @@ -711,8 +719,10 @@ void CXXRecordDecl::addedMember(Decl *D)
>>>>>>          data().IsStandardLayout = false;
>>>>>>
>>>>>>        // Keep track of the presence of mutable fields.
>>>>>> -    if (Field->isMutable())
>>>>>> +    if (Field->isMutable()) {
>>>>>>          data().HasMutableFields = true;
>>>>>> +      data().NeedOverloadResolutionForCopyConstructor = true;
>>>>>> +    }
>>>>>>
>>>>>>        // C++11 [class.union]p8, DR1460:
>>>>>>        //   If X is a union, a non-static data member of X that is not an
>>>>>> anonymous
>>>>>> @@ -756,6 +766,12 @@ void CXXRecordDecl::addedMember(Decl *D)
>>>>>>          //   A standard-layout class is a class that:
>>>>>>          //    -- has no non-static data members of type [...] reference,
>>>>>>          data().IsStandardLayout = false;
>>>>>> +
>>>>>> +      // C++1z [class.copy.ctor]p10:
>>>>>> +      //   A defaulted copy constructor for a class X is defined as
>>>>>> deleted if X has:
>>>>>> +      //    -- a non-static data member of rvalue reference type
>>>>>> +      if (T->isRValueReferenceType())
>>>>>> +        data().DefaultedCopyConstructorIsDeleted = true;
>>>>>>        }
>>>>>>
>>>>>>        if (!Field->hasInClassInitializer() && !Field->isMutable()) {
>>>>>> @@ -809,6 +825,10 @@ void CXXRecordDecl::addedMember(Decl *D)
>>>>>>            // We may need to perform overload resolution to determine
>>>>>> whether a
>>>>>>            // field can be moved if it's const or volatile qualified.
>>>>>>            if (T.getCVRQualifiers() & (Qualifiers::Const |
>>>>>> Qualifiers::Volatile)) {
>>>>>> +          // We need to care about 'const' for the copy constructor
>>>>>> because an
>>>>>> +          // implicit copy constructor might be declared with a
>>>>>> non-const
>>>>>> +          // parameter.
>>>>>> +          data().NeedOverloadResolutionForCopyConstructor = true;
>>>>>>              data().NeedOverloadResolutionForMoveConstructor = true;
>>>>>>              data().NeedOverloadResolutionForMoveAssignment = true;
>>>>>>            }
>>>>>> @@ -819,6 +839,8 @@ void CXXRecordDecl::addedMember(Decl *D)
>>>>>>            //    -- X is a union-like class that has a variant member
>>>>>> with a
>>>>>>            //       non-trivial [corresponding special member]
>>>>>>            if (isUnion()) {
>>>>>> +          if (FieldRec->hasNonTrivialCopyConstructor())
>>>>>> +            data().DefaultedCopyConstructorIsDeleted = true;
>>>>>>              if (FieldRec->hasNonTrivialMoveConstructor())
>>>>>>                data().DefaultedMoveConstructorIsDeleted = true;
>>>>>>              if (FieldRec->hasNonTrivialMoveAssignment())
>>>>>> @@ -830,6 +852,8 @@ void CXXRecordDecl::addedMember(Decl *D)
>>>>>>            // For an anonymous union member, our overload resolution will
>>>>>> perform
>>>>>>            // overload resolution for its members.
>>>>>>            if (Field->isAnonymousStructOrUnion()) {
>>>>>> +          data().NeedOverloadResolutionForCopyConstructor |=
>>>>>> +
>>>>>> FieldRec->data().NeedOverloadResolutionForCopyConstructor;
>>>>>>              data().NeedOverloadResolutionForMoveConstructor |=
>>>>>>
>>>>>> FieldRec->data().NeedOverloadResolutionForMoveConstructor;
>>>>>>              data().NeedOverloadResolutionForMoveAssignment |=
>>>>>> @@ -915,8 +939,10 @@ void CXXRecordDecl::addedMember(Decl *D)
>>>>>>            }
>>>>>>
>>>>>>            // Keep track of the presence of mutable fields.
>>>>>> -        if (FieldRec->hasMutableFields())
>>>>>> +        if (FieldRec->hasMutableFields()) {
>>>>>>              data().HasMutableFields = true;
>>>>>> +          data().NeedOverloadResolutionForCopyConstructor = true;
>>>>>> +        }
>>>>>>
>>>>>>            // C++11 [class.copy]p13:
>>>>>>            //   If the implicitly-defined constructor would satisfy the
>>>>>> @@ -1450,7 +1476,7 @@ void CXXRecordDecl::completeDefinition()
>>>>>>
>>>>>>    void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap
>>>>>> *FinalOverriders) {
>>>>>>      RecordDecl::completeDefinition();
>>>>>> -
>>>>>> +
>>>>>>      // If the class may be abstract (but hasn't been marked as such),
>>>>>> check
>>>>>> for
>>>>>>      // any pure final overriders.
>>>>>>      if (mayBeAbstract()) {
>>>>>>
>>>>>> Modified: cfe/trunk/lib/CodeGen/CGCXXABI.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGCXXABI.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/lib/CodeGen/CGCXXABI.cpp (original)
>>>>>> +++ cfe/trunk/lib/CodeGen/CGCXXABI.cpp Tue Aug  8 12:12:28 2017
>>>>>> @@ -30,38 +30,9 @@ void CGCXXABI::ErrorUnsupportedABI(CodeG
>>>>>>    }
>>>>>>
>>>>>>    bool CGCXXABI::canCopyArgument(const CXXRecordDecl *RD) const {
>>>>>> -  // If RD has a non-trivial move or copy constructor, we cannot copy
>>>>>> the
>>>>>> -  // argument.
>>>>>> -  if (RD->hasNonTrivialCopyConstructor() ||
>>>>>> RD->hasNonTrivialMoveConstructor())
>>>>>> -    return false;
>>>>>> -
>>>>>> -  // If RD has a non-trivial destructor, we cannot copy the argument.
>>>>>> -  if (RD->hasNonTrivialDestructor())
>>>>>> -    return false;
>>>>>> -
>>>>>>      // We can only copy the argument if there exists at least one
>>>>>> trivial,
>>>>>>      // non-deleted copy or move constructor.
>>>>>> -  // FIXME: This assumes that all lazily declared copy and move
>>>>>> constructors are
>>>>>> -  // not deleted.  This assumption might not be true in some corner
>>>>>> cases.
>>>>>> -  bool CopyDeleted = false;
>>>>>> -  bool MoveDeleted = false;
>>>>>> -  for (const CXXConstructorDecl *CD : RD->ctors()) {
>>>>>> -    if (CD->isCopyConstructor() || CD->isMoveConstructor()) {
>>>>>> -      assert(CD->isTrivial());
>>>>>> -      // We had at least one undeleted trivial copy or move ctor.
>>>>>> Return
>>>>>> -      // directly.
>>>>>> -      if (!CD->isDeleted())
>>>>>> -        return true;
>>>>>> -      if (CD->isCopyConstructor())
>>>>>> -        CopyDeleted = true;
>>>>>> -      else
>>>>>> -        MoveDeleted = true;
>>>>>> -    }
>>>>>> -  }
>>>>>> -
>>>>>> -  // If all trivial copy and move constructors are deleted, we cannot
>>>>>> copy the
>>>>>> -  // argument.
>>>>>> -  return !(CopyDeleted && MoveDeleted);
>>>>>> +  return RD->canPassInRegisters();
>>>>>>    }
>>>>>>
>>>>>>    llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
>>>>>>
>>>>>> Modified: cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp (original)
>>>>>> +++ cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp Tue Aug  8 12:12:28 2017
>>>>>> @@ -63,11 +63,8 @@ public:
>>>>>>      bool classifyReturnType(CGFunctionInfo &FI) const override;
>>>>>>
>>>>>>      RecordArgABI getRecordArgABI(const CXXRecordDecl *RD) const override
>>>>>> {
>>>>>> -    // Structures with either a non-trivial destructor or a non-trivial
>>>>>> -    // copy constructor are always indirect.
>>>>>> -    // FIXME: Use canCopyArgument() when it is fixed to handle lazily
>>>>>> declared
>>>>>> -    // special members.
>>>>>> -    if (RD->hasNonTrivialDestructor() ||
>>>>>> RD->hasNonTrivialCopyConstructor())
>>>>>> +    // If C++ prohibits us from making a copy, pass by address.
>>>>>> +    if (!canCopyArgument(RD))
>>>>>>          return RAA_Indirect;
>>>>>>        return RAA_Default;
>>>>>>      }
>>>>>> @@ -1014,10 +1011,8 @@ bool ItaniumCXXABI::classifyReturnType(C
>>>>>>      if (!RD)
>>>>>>        return false;
>>>>>>
>>>>>> -  // Return indirectly if we have a non-trivial copy ctor or
>>>>>> non-trivial
>>>>>> dtor.
>>>>>> -  // FIXME: Use canCopyArgument() when it is fixed to handle lazily
>>>>>> declared
>>>>>> -  // special members.
>>>>>> -  if (RD->hasNonTrivialDestructor() ||
>>>>>> RD->hasNonTrivialCopyConstructor()) {
>>>>>> +  // If C++ prohibits us from making a copy, return by address.
>>>>>> +  if (!canCopyArgument(RD)) {
>>>>>>        auto Align =
>>>>>> CGM.getContext().getTypeAlignInChars(FI.getReturnType());
>>>>>>        FI.getReturnInfo() = ABIArgInfo::getIndirect(Align,
>>>>>> /*ByVal=*/false);
>>>>>>        return true;
>>>>>>
>>>>>> Modified: cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp (original)
>>>>>> +++ cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp Tue Aug  8 12:12:28 2017
>>>>>> @@ -819,46 +819,44 @@ MicrosoftCXXABI::getRecordArgABI(const C
>>>>>>        return RAA_Default;
>>>>>>
>>>>>>      case llvm::Triple::x86_64:
>>>>>> -    // Win64 passes objects with non-trivial copy ctors indirectly.
>>>>>> -    if (RD->hasNonTrivialCopyConstructor())
>>>>>> -      return RAA_Indirect;
>>>>>> -
>>>>>> -    // If an object has a destructor, we'd really like to pass it
>>>>>> indirectly
>>>>>> +    // If a class has a destructor, we'd really like to pass it
>>>>>> indirectly
>>>>>>        // because it allows us to elide copies.  Unfortunately, MSVC
>>>>>> makes
>>>>>> that
>>>>>>        // impossible for small types, which it will pass in a single
>>>>>> register or
>>>>>>        // stack slot. Most objects with dtors are large-ish, so handle
>>>>>> that
>>>>>> early.
>>>>>>        // We can't call out all large objects as being indirect because
>>>>>> there are
>>>>>>        // multiple x64 calling conventions and the C++ ABI code shouldn't
>>>>>> dictate
>>>>>>        // how we pass large POD types.
>>>>>> +    //
>>>>>> +    // Note: This permits small classes with nontrivial destructors to
>>>>>> be
>>>>>> +    // passed in registers, which is non-conforming.
>>>>>>        if (RD->hasNonTrivialDestructor() &&
>>>>>>            getContext().getTypeSize(RD->getTypeForDecl()) > 64)
>>>>>>          return RAA_Indirect;
>>>>>>
>>>>>> -    // If this is true, the implicit copy constructor that Sema would
>>>>>> have
>>>>>> -    // created would not be deleted. FIXME: We should provide a more
>>>>>> direct way
>>>>>> -    // for CodeGen to ask whether the constructor was deleted.
>>>>>> -    if (!RD->hasUserDeclaredCopyConstructor() &&
>>>>>> -        !RD->hasUserDeclaredMoveConstructor() &&
>>>>>> -        !RD->needsOverloadResolutionForMoveConstructor() &&
>>>>>> -        !RD->hasUserDeclaredMoveAssignment() &&
>>>>>> -        !RD->needsOverloadResolutionForMoveAssignment())
>>>>>> -      return RAA_Default;
>>>>>> -
>>>>>> -    // Otherwise, Sema should have created an implicit copy constructor
>>>>>> if
>>>>>> -    // needed.
>>>>>> -    assert(!RD->needsImplicitCopyConstructor());
>>>>>> -
>>>>>> -    // We have to make sure the trivial copy constructor isn't deleted.
>>>>>> -    for (const CXXConstructorDecl *CD : RD->ctors()) {
>>>>>> -      if (CD->isCopyConstructor()) {
>>>>>> -        assert(CD->isTrivial());
>>>>>> -        // We had at least one undeleted trivial copy ctor.  Return
>>>>>> directly.
>>>>>> -        if (!CD->isDeleted())
>>>>>> -          return RAA_Default;
>>>>>> +    // If a class has at least one non-deleted, trivial copy
>>>>>> constructor,
>>>>>> it
>>>>>> +    // is passed according to the C ABI. Otherwise, it is passed
>>>>>> indirectly.
>>>>>> +    //
>>>>>> +    // Note: This permits classes with non-trivial copy or move ctors
>>>>>> to
>>>>>> be
>>>>>> +    // passed in registers, so long as they *also* have a trivial copy
>>>>>> ctor,
>>>>>> +    // which is non-conforming.
>>>>>> +    if (RD->needsImplicitCopyConstructor()) {
>>>>>> +      // If the copy ctor has not yet been declared, we can read its
>>>>>> triviality
>>>>>> +      // off the AST.
>>>>>> +      if (!RD->defaultedCopyConstructorIsDeleted() &&
>>>>>> +          RD->hasTrivialCopyConstructor())
>>>>>> +        return RAA_Default;
>>>>>> +    } else {
>>>>>> +      // Otherwise, we need to find the copy constructor(s) and ask.
>>>>>> +      for (const CXXConstructorDecl *CD : RD->ctors()) {
>>>>>> +        if (CD->isCopyConstructor()) {
>>>>>> +          // We had at least one nondeleted trivial copy ctor.  Return
>>>>>> directly.
>>>>>> +          if (!CD->isDeleted() && CD->isTrivial())
>>>>>> +            return RAA_Default;
>>>>>> +        }
>>>>>>          }
>>>>>>        }
>>>>>>
>>>>>> -    // The trivial copy constructor was deleted.  Return indirectly.
>>>>>> +    // We have no trivial, non-deleted copy constructor.
>>>>>>        return RAA_Indirect;
>>>>>>      }
>>>>>>
>>>>>>
>>>>>> Modified: cfe/trunk/lib/Sema/SemaDeclCXX.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDeclCXX.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/lib/Sema/SemaDeclCXX.cpp (original)
>>>>>> +++ cfe/trunk/lib/Sema/SemaDeclCXX.cpp Tue Aug  8 12:12:28 2017
>>>>>> @@ -5726,6 +5726,53 @@ static void DefineImplicitSpecialMember(
>>>>>>      }
>>>>>>    }
>>>>>>
>>>>>> +/// Determine whether a type is permitted to be passed or returned in
>>>>>> +/// registers, per C++ [class.temporary]p3.
>>>>>> +static bool computeCanPassInRegisters(Sema &S, CXXRecordDecl *D) {
>>>>>> +  if (D->isDependentType() || D->isInvalidDecl())
>>>>>> +    return false;
>>>>>> +
>>>>>> +  // Per C++ [class.temporary]p3, the relevant condition is:
>>>>>> +  //   each copy constructor, move constructor, and destructor of X is
>>>>>> +  //   either trivial or deleted, and X has at least one non-deleted
>>>>>> copy
>>>>>> +  //   or move constructor
>>>>>> +  bool HasNonDeletedCopyOrMove = false;
>>>>>> +
>>>>>> +  if (D->needsImplicitCopyConstructor() &&
>>>>>> +      !D->defaultedCopyConstructorIsDeleted()) {
>>>>>> +    if (!D->hasTrivialCopyConstructor())
>>>>>> +      return false;
>>>>>> +    HasNonDeletedCopyOrMove = true;
>>>>>> +  }
>>>>>> +
>>>>>> +  if (S.getLangOpts().CPlusPlus11 && D->needsImplicitMoveConstructor()
>>>>>> &&
>>>>>> +      !D->defaultedMoveConstructorIsDeleted()) {
>>>>>> +    if (!D->hasTrivialMoveConstructor())
>>>>>> +      return false;
>>>>>> +    HasNonDeletedCopyOrMove = true;
>>>>>> +  }
>>>>>> +
>>>>>> +  if (D->needsImplicitDestructor() &&
>>>>>> !D->defaultedDestructorIsDeleted()
>>>>>> &&
>>>>>> +      !D->hasTrivialDestructor())
>>>>>> +    return false;
>>>>>> +
>>>>>> +  for (const CXXMethodDecl *MD : D->methods()) {
>>>>>> +    if (MD->isDeleted())
>>>>>> +      continue;
>>>>>> +
>>>>>> +    auto *CD = dyn_cast<CXXConstructorDecl>(MD);
>>>>>> +    if (CD && CD->isCopyOrMoveConstructor())
>>>>>> +      HasNonDeletedCopyOrMove = true;
>>>>>> +    else if (!isa<CXXDestructorDecl>(MD))
>>>>>> +      continue;
>>>>>> +
>>>>>> +    if (!MD->isTrivial())
>>>>>> +      return false;
>>>>>> +  }
>>>>>> +
>>>>>> +  return HasNonDeletedCopyOrMove;
>>>>>> +}
>>>>>> +
>>>>>>    /// \brief Perform semantic checks on a class definition that has been
>>>>>>    /// completing, introducing implicitly-declared members, checking for
>>>>>>    /// abstract types, etc.
>>>>>> @@ -5870,6 +5917,8 @@ void Sema::CheckCompletedCXXClass(CXXRec
>>>>>>      }
>>>>>>
>>>>>>      checkClassLevelDLLAttribute(Record);
>>>>>> +
>>>>>> +  Record->setCanPassInRegisters(computeCanPassInRegisters(*this,
>>>>>> Record));
>>>>>>    }
>>>>>>
>>>>>>    /// Look up the special member function that would be called by a
>>>>>> special
>>>>>> @@ -7496,8 +7545,7 @@ void Sema::ActOnFinishCXXMemberSpecifica
>>>>>>
>>>>>> reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
>>>>>>                  FieldCollector->getCurNumFields()), LBrac, RBrac,
>>>>>> AttrList);
>>>>>>
>>>>>> -  CheckCompletedCXXClass(
>>>>>> -                        dyn_cast_or_null<CXXRecordDecl>(TagDecl));
>>>>>> +  CheckCompletedCXXClass(dyn_cast_or_null<CXXRecordDecl>(TagDecl));
>>>>>>    }
>>>>>>
>>>>>>    /// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
>>>>>> @@ -11929,8 +11977,10 @@ CXXConstructorDecl *Sema::DeclareImplici
>>>>>>      Scope *S = getScopeForContext(ClassDecl);
>>>>>>      CheckImplicitSpecialMemberDeclaration(S, CopyConstructor);
>>>>>>
>>>>>> -  if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor))
>>>>>> +  if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor)) {
>>>>>> +    ClassDecl->setImplicitCopyConstructorIsDeleted();
>>>>>>        SetDeclDeleted(CopyConstructor, ClassLoc);
>>>>>> +  }
>>>>>>
>>>>>>      if (S)
>>>>>>        PushOnScopeChains(CopyConstructor, S, false);
>>>>>>
>>>>>> Modified: cfe/trunk/lib/Serialization/ASTReaderDecl.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Serialization/ASTReaderDecl.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/lib/Serialization/ASTReaderDecl.cpp (original)
>>>>>> +++ cfe/trunk/lib/Serialization/ASTReaderDecl.cpp Tue Aug  8 12:12:28
>>>>>> 2017
>>>>>> @@ -1559,9 +1559,11 @@ void ASTDeclReader::ReadCXXDefinitionDat
>>>>>>      Data.HasUninitializedFields = Record.readInt();
>>>>>>      Data.HasInheritedConstructor = Record.readInt();
>>>>>>      Data.HasInheritedAssignment = Record.readInt();
>>>>>> +  Data.NeedOverloadResolutionForCopyConstructor = Record.readInt();
>>>>>>      Data.NeedOverloadResolutionForMoveConstructor = Record.readInt();
>>>>>>      Data.NeedOverloadResolutionForMoveAssignment = Record.readInt();
>>>>>>      Data.NeedOverloadResolutionForDestructor = Record.readInt();
>>>>>> +  Data.DefaultedCopyConstructorIsDeleted = Record.readInt();
>>>>>>      Data.DefaultedMoveConstructorIsDeleted = Record.readInt();
>>>>>>      Data.DefaultedMoveAssignmentIsDeleted = Record.readInt();
>>>>>>      Data.DefaultedDestructorIsDeleted = Record.readInt();
>>>>>> @@ -1570,6 +1572,7 @@ void ASTDeclReader::ReadCXXDefinitionDat
>>>>>>      Data.HasIrrelevantDestructor = Record.readInt();
>>>>>>      Data.HasConstexprNonCopyMoveConstructor = Record.readInt();
>>>>>>      Data.HasDefaultedDefaultConstructor = Record.readInt();
>>>>>> +  Data.CanPassInRegisters = Record.readInt();
>>>>>>      Data.DefaultedDefaultConstructorIsConstexpr = Record.readInt();
>>>>>>      Data.HasConstexprDefaultConstructor = Record.readInt();
>>>>>>      Data.HasNonLiteralTypeFieldsOrBases = Record.readInt();
>>>>>> @@ -1697,9 +1700,11 @@ void ASTDeclReader::MergeDefinitionData(
>>>>>>      MATCH_FIELD(HasUninitializedFields)
>>>>>>      MATCH_FIELD(HasInheritedConstructor)
>>>>>>      MATCH_FIELD(HasInheritedAssignment)
>>>>>> +  MATCH_FIELD(NeedOverloadResolutionForCopyConstructor)
>>>>>>      MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
>>>>>>      MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
>>>>>>      MATCH_FIELD(NeedOverloadResolutionForDestructor)
>>>>>> +  MATCH_FIELD(DefaultedCopyConstructorIsDeleted)
>>>>>>      MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
>>>>>>      MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
>>>>>>      MATCH_FIELD(DefaultedDestructorIsDeleted)
>>>>>> @@ -1708,6 +1713,7 @@ void ASTDeclReader::MergeDefinitionData(
>>>>>>      MATCH_FIELD(HasIrrelevantDestructor)
>>>>>>      OR_FIELD(HasConstexprNonCopyMoveConstructor)
>>>>>>      OR_FIELD(HasDefaultedDefaultConstructor)
>>>>>> +  MATCH_FIELD(CanPassInRegisters)
>>>>>>      MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
>>>>>>      OR_FIELD(HasConstexprDefaultConstructor)
>>>>>>      MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
>>>>>>
>>>>>> Modified: cfe/trunk/lib/Serialization/ASTWriter.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Serialization/ASTWriter.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/lib/Serialization/ASTWriter.cpp (original)
>>>>>> +++ cfe/trunk/lib/Serialization/ASTWriter.cpp Tue Aug  8 12:12:28 2017
>>>>>> @@ -5875,9 +5875,11 @@ void ASTRecordWriter::AddCXXDefinitionDa
>>>>>>      Record->push_back(Data.HasUninitializedFields);
>>>>>>      Record->push_back(Data.HasInheritedConstructor);
>>>>>>      Record->push_back(Data.HasInheritedAssignment);
>>>>>> +  Record->push_back(Data.NeedOverloadResolutionForCopyConstructor);
>>>>>>      Record->push_back(Data.NeedOverloadResolutionForMoveConstructor);
>>>>>>      Record->push_back(Data.NeedOverloadResolutionForMoveAssignment);
>>>>>>      Record->push_back(Data.NeedOverloadResolutionForDestructor);
>>>>>> +  Record->push_back(Data.DefaultedCopyConstructorIsDeleted);
>>>>>>      Record->push_back(Data.DefaultedMoveConstructorIsDeleted);
>>>>>>      Record->push_back(Data.DefaultedMoveAssignmentIsDeleted);
>>>>>>      Record->push_back(Data.DefaultedDestructorIsDeleted);
>>>>>> @@ -5886,6 +5888,7 @@ void ASTRecordWriter::AddCXXDefinitionDa
>>>>>>      Record->push_back(Data.HasIrrelevantDestructor);
>>>>>>      Record->push_back(Data.HasConstexprNonCopyMoveConstructor);
>>>>>>      Record->push_back(Data.HasDefaultedDefaultConstructor);
>>>>>> +  Record->push_back(Data.CanPassInRegisters);
>>>>>>      Record->push_back(Data.DefaultedDefaultConstructorIsConstexpr);
>>>>>>      Record->push_back(Data.HasConstexprDefaultConstructor);
>>>>>>      Record->push_back(Data.HasNonLiteralTypeFieldsOrBases);
>>>>>>
>>>>>> Modified: cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp (original)
>>>>>> +++ cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp Tue Aug  8 12:12:28
>>>>>> 2017
>>>>>> @@ -1,5 +1,6 @@
>>>>>>    // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown
>>>>>> -emit-llvm
>>>>>> -o - %s | FileCheck %s
>>>>>> -// RUN: %clang_cc1 -std=c++11 -triple x86_64-windows-msvc -emit-llvm -o
>>>>>> -
>>>>>> %s | FileCheck %s -check-prefix=WIN64
>>>>>> +// RUN: %clang_cc1 -std=c++11 -triple x86_64-windows-msvc -emit-llvm -o
>>>>>> -
>>>>>> %s -fms-compatibility -fms-compatibility-version=18 | FileCheck %s
>>>>>> -check-prefix=WIN64 -check-prefix=WIN64-18
>>>>>> +// RUN: %clang_cc1 -std=c++11 -triple x86_64-windows-msvc -emit-llvm -o
>>>>>> -
>>>>>> %s -fms-compatibility -fms-compatibility-version=19 | FileCheck %s
>>>>>> -check-prefix=WIN64 -check-prefix=WIN64-19
>>>>>>
>>>>>>    namespace trivial {
>>>>>>    // Trivial structs should be passed directly.
>>>>>> @@ -52,12 +53,11 @@ void foo(A);
>>>>>>    void bar() {
>>>>>>      foo({});
>>>>>>    }
>>>>>> -// FIXME: The copy ctor is implicitly deleted.
>>>>>> -// CHECK-DISABLED-LABEL: define void @_ZN9move_ctor3barEv()
>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>> -// CHECK-DISABLED-NOT: call
>>>>>> -// CHECK-DISABLED: call void
>>>>>> @_ZN9move_ctor3fooENS_1AE(%"struct.move_ctor::A"* %{{.*}})
>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>> @_ZN9move_ctor3fooENS_1AE(%"struct.move_ctor::A"*)
>>>>>> +// CHECK-LABEL: define void @_ZN9move_ctor3barEv()
>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>> +// CHECK-NOT: call
>>>>>> +// CHECK: call void @_ZN9move_ctor3fooENS_1AE(%"struct.move_ctor::A"*
>>>>>> %{{.*}})
>>>>>> +// CHECK-LABEL: declare void
>>>>>> @_ZN9move_ctor3fooENS_1AE(%"struct.move_ctor::A"*)
>>>>>>
>>>>>>    // WIN64-LABEL: declare void
>>>>>> @"\01?foo at move_ctor@@YAXUA at 1@@Z"(%"struct.move_ctor::A"*)
>>>>>>    }
>>>>>> @@ -73,12 +73,11 @@ void foo(A);
>>>>>>    void bar() {
>>>>>>      foo({});
>>>>>>    }
>>>>>> -// FIXME: The copy ctor is deleted.
>>>>>> -// CHECK-DISABLED-LABEL: define void @_ZN11all_deleted3barEv()
>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>> -// CHECK-DISABLED-NOT: call
>>>>>> -// CHECK-DISABLED: call void
>>>>>> @_ZN11all_deleted3fooENS_1AE(%"struct.all_deleted::A"* %{{.*}})
>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>> @_ZN11all_deleted3fooENS_1AE(%"struct.all_deleted::A"*)
>>>>>> +// CHECK-LABEL: define void @_ZN11all_deleted3barEv()
>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>> +// CHECK-NOT: call
>>>>>> +// CHECK: call void
>>>>>> @_ZN11all_deleted3fooENS_1AE(%"struct.all_deleted::A"* %{{.*}})
>>>>>> +// CHECK-LABEL: declare void
>>>>>> @_ZN11all_deleted3fooENS_1AE(%"struct.all_deleted::A"*)
>>>>>>
>>>>>>    // WIN64-LABEL: declare void
>>>>>> @"\01?foo at all_deleted@@YAXUA at 1@@Z"(%"struct.all_deleted::A"*)
>>>>>>    }
>>>>>> @@ -93,14 +92,15 @@ void foo(A);
>>>>>>    void bar() {
>>>>>>      foo({});
>>>>>>    }
>>>>>> -// FIXME: The copy and move ctors are implicitly deleted.
>>>>>> -// CHECK-DISABLED-LABEL: define void @_ZN18implicitly_deleted3barEv()
>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>> -// CHECK-DISABLED-NOT: call
>>>>>> -// CHECK-DISABLED: call void
>>>>>> @_ZN18implicitly_deleted3fooENS_1AE(%"struct.implicitly_deleted::A"*
>>>>>> %{{.*}})
>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>> @_ZN18implicitly_deleted3fooENS_1AE(%"struct.implicitly_deleted::A"*)
>>>>>> -
>>>>>> -// WIN64-LABEL: declare void
>>>>>>
>>>>>> @"\01?foo at implicitly_deleted@@YAXUA at 1@@Z"(%"struct.implicitly_deleted::A"*)
>>>>>> +// CHECK-LABEL: define void @_ZN18implicitly_deleted3barEv()
>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>> +// CHECK-NOT: call
>>>>>> +// CHECK: call void
>>>>>> @_ZN18implicitly_deleted3fooENS_1AE(%"struct.implicitly_deleted::A"*
>>>>>> %{{.*}})
>>>>>> +// CHECK-LABEL: declare void
>>>>>> @_ZN18implicitly_deleted3fooENS_1AE(%"struct.implicitly_deleted::A"*)
>>>>>> +
>>>>>> +// In MSVC 2013, the copy ctor is not deleted by a move assignment. In
>>>>>> MSVC 2015, it is.
>>>>>> +// WIN64-18-LABEL: declare void
>>>>>> @"\01?foo at implicitly_deleted@@YAXUA at 1@@Z"(i64
>>>>>> +// WIN64-19-LABEL: declare void
>>>>>>
>>>>>> @"\01?foo at implicitly_deleted@@YAXUA at 1@@Z"(%"struct.implicitly_deleted::A"*)
>>>>>>    }
>>>>>>
>>>>>>    namespace one_deleted {
>>>>>> @@ -113,12 +113,11 @@ void foo(A);
>>>>>>    void bar() {
>>>>>>      foo({});
>>>>>>    }
>>>>>> -// FIXME: The copy constructor is implicitly deleted.
>>>>>> -// CHECK-DISABLED-LABEL: define void @_ZN11one_deleted3barEv()
>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>> -// CHECK-DISABLED-NOT: call
>>>>>> -// CHECK-DISABLED: call void
>>>>>> @_ZN11one_deleted3fooENS_1AE(%"struct.one_deleted::A"* %{{.*}})
>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>> @_ZN11one_deleted3fooENS_1AE(%"struct.one_deleted::A"*)
>>>>>> +// CHECK-LABEL: define void @_ZN11one_deleted3barEv()
>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>> +// CHECK-NOT: call
>>>>>> +// CHECK: call void
>>>>>> @_ZN11one_deleted3fooENS_1AE(%"struct.one_deleted::A"* %{{.*}})
>>>>>> +// CHECK-LABEL: declare void
>>>>>> @_ZN11one_deleted3fooENS_1AE(%"struct.one_deleted::A"*)
>>>>>>
>>>>>>    // WIN64-LABEL: declare void
>>>>>> @"\01?foo at one_deleted@@YAXUA at 1@@Z"(%"struct.one_deleted::A"*)
>>>>>>    }
>>>>>> @@ -195,12 +194,10 @@ void foo(B);
>>>>>>    void bar() {
>>>>>>      foo({});
>>>>>>    }
>>>>>> -// FIXME: This class has a non-trivial copy ctor and a trivial copy
>>>>>> ctor.
>>>>>> It's
>>>>>> -// not clear whether we should pass by address or in registers.
>>>>>> -// CHECK-DISABLED-LABEL: define void @_ZN14two_copy_ctors3barEv()
>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>> -// CHECK-DISABLED: call void
>>>>>> @_ZN14two_copy_ctors3fooENS_1BE(%"struct.two_copy_ctors::B"* %{{.*}})
>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>> @_ZN14two_copy_ctors3fooENS_1BE(%"struct.two_copy_ctors::B"*)
>>>>>> +// CHECK-LABEL: define void @_ZN14two_copy_ctors3barEv()
>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>> +// CHECK: call void
>>>>>> @_ZN14two_copy_ctors3fooENS_1BE(%"struct.two_copy_ctors::B"* %{{.*}})
>>>>>> +// CHECK-LABEL: declare void
>>>>>> @_ZN14two_copy_ctors3fooENS_1BE(%"struct.two_copy_ctors::B"*)
>>>>>>
>>>>>>    // WIN64-LABEL: declare void
>>>>>> @"\01?foo at two_copy_ctors@@YAXUB at 1@@Z"(%"struct.two_copy_ctors::B"*)
>>>>>>    }
>>>>>> @@ -212,6 +209,7 @@ struct A {
>>>>>>      void *p;
>>>>>>    };
>>>>>>    void *foo(A a) { return a.p; }
>>>>>> +// CHECK-LABEL: define i8*
>>>>>> @_ZN15definition_only3fooENS_1AE(%"struct.definition_only::A"*
>>>>>>    // WIN64-LABEL: define i8*
>>>>>> @"\01?foo at definition_only@@YAPEAXUA at 1@@Z"(%"struct.definition_only::A"*
>>>>>>    }
>>>>>>
>>>>>> @@ -226,6 +224,7 @@ struct A {
>>>>>>      B b;
>>>>>>    };
>>>>>>    void *foo(A a) { return a.b.p; }
>>>>>> +// CHECK-LABEL: define i8*
>>>>>> @_ZN17deleted_by_member3fooENS_1AE(%"struct.deleted_by_member::A"*
>>>>>>    // WIN64-LABEL: define i8*
>>>>>>
>>>>>> @"\01?foo at deleted_by_member@@YAPEAXUA at 1@@Z"(%"struct.deleted_by_member::A"*
>>>>>>    }
>>>>>>
>>>>>> @@ -239,6 +238,7 @@ struct A : B {
>>>>>>      A();
>>>>>>    };
>>>>>>    void *foo(A a) { return a.p; }
>>>>>> +// CHECK-LABEL: define i8*
>>>>>> @_ZN15deleted_by_base3fooENS_1AE(%"struct.deleted_by_base::A"*
>>>>>>    // WIN64-LABEL: define i8*
>>>>>> @"\01?foo at deleted_by_base@@YAPEAXUA at 1@@Z"(%"struct.deleted_by_base::A"*
>>>>>>    }
>>>>>>
>>>>>> @@ -253,6 +253,7 @@ struct A {
>>>>>>      B b;
>>>>>>    };
>>>>>>    void *foo(A a) { return a.b.p; }
>>>>>> +// CHECK-LABEL: define i8*
>>>>>>
>>>>>> @_ZN22deleted_by_member_copy3fooENS_1AE(%"struct.deleted_by_member_copy::A"*
>>>>>>    // WIN64-LABEL: define i8*
>>>>>>
>>>>>> @"\01?foo at deleted_by_member_copy@@YAPEAXUA at 1@@Z"(%"struct.deleted_by_member_copy::A"*
>>>>>>    }
>>>>>>
>>>>>> @@ -266,6 +267,7 @@ struct A : B {
>>>>>>      A();
>>>>>>    };
>>>>>>    void *foo(A a) { return a.p; }
>>>>>> +// CHECK-LABEL: define i8*
>>>>>> @_ZN20deleted_by_base_copy3fooENS_1AE(%"struct.deleted_by_base_copy::A"*
>>>>>>    // WIN64-LABEL: define i8*
>>>>>>
>>>>>> @"\01?foo at deleted_by_base_copy@@YAPEAXUA at 1@@Z"(%"struct.deleted_by_base_copy::A"*
>>>>>>    }
>>>>>>
>>>>>> @@ -275,6 +277,75 @@ struct A {
>>>>>>      A(const A &o) = delete;
>>>>>>      void *p;
>>>>>>    };
>>>>>> +// CHECK-LABEL: define i8*
>>>>>> @_ZN15explicit_delete3fooENS_1AE(%"struct.explicit_delete::A"*
>>>>>>    // WIN64-LABEL: define i8*
>>>>>> @"\01?foo at explicit_delete@@YAPEAXUA at 1@@Z"(%"struct.explicit_delete::A"*
>>>>>>    void *foo(A a) { return a.p; }
>>>>>>    }
>>>>>> +
>>>>>> +namespace implicitly_deleted_copy_ctor {
>>>>>> +struct A {
>>>>>> +  // No move ctor due to copy assignment.
>>>>>> +  A &operator=(const A&);
>>>>>> +  // Deleted copy ctor due to rvalue ref member.
>>>>>> +  int &&ref;
>>>>>> +};
>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>>
>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1AE(%"struct.implicitly_deleted_copy_ctor::A"*
>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>>
>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAAEAHUA at 1@@Z"(%"struct.implicitly_deleted_copy_ctor::A"*
>>>>>> +int &foo(A a) { return a.ref; }
>>>>>> +
>>>>>> +struct B {
>>>>>> +  // Passed direct: has non-deleted trivial copy ctor.
>>>>>> +  B &operator=(const B&);
>>>>>> +  int &ref;
>>>>>> +};
>>>>>> +int &foo(B b) { return b.ref; }
>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1BE(i32*
>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAAEAHUB at 1@@Z"(i64
>>>>>> +
>>>>>> +struct X { X(const X&); };
>>>>>> +struct Y { Y(const Y&) = default; };
>>>>>> +
>>>>>> +union C {
>>>>>> +  C &operator=(const C&);
>>>>>> +  // Passed indirect: copy ctor deleted due to variant member with
>>>>>> nontrivial copy ctor.
>>>>>> +  X x;
>>>>>> +  int n;
>>>>>> +};
>>>>>> +int foo(C c) { return c.n; }
>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>>
>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1CE(%"union.implicitly_deleted_copy_ctor::C"*
>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>>
>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAHTC at 1@@Z"(%"union.implicitly_deleted_copy_ctor::C"*
>>>>>> +
>>>>>> +struct D {
>>>>>> +  D &operator=(const D&);
>>>>>> +  // Passed indirect: copy ctor deleted due to variant member with
>>>>>> nontrivial copy ctor.
>>>>>> +  union {
>>>>>> +    X x;
>>>>>> +    int n;
>>>>>> +  };
>>>>>> +};
>>>>>> +int foo(D d) { return d.n; }
>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>>
>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1DE(%"struct.implicitly_deleted_copy_ctor::D"*
>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>>
>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAHUD at 1@@Z"(%"struct.implicitly_deleted_copy_ctor::D"*
>>>>>> +
>>>>>> +union E {
>>>>>> +  // Passed direct: has non-deleted trivial copy ctor.
>>>>>> +  E &operator=(const E&);
>>>>>> +  Y y;
>>>>>> +  int n;
>>>>>> +};
>>>>>> +int foo(E e) { return e.n; }
>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1EE(i32
>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAHTE at 1@@Z"(i32
>>>>>> +
>>>>>> +struct F {
>>>>>> +  // Passed direct: has non-deleted trivial copy ctor.
>>>>>> +  F &operator=(const F&);
>>>>>> +  union {
>>>>>> +    Y y;
>>>>>> +    int n;
>>>>>> +  };
>>>>>> +};
>>>>>> +int foo(F f) { return f.n; }
>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1FE(i32
>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAHUF at 1@@Z"(i32
>>>>>> +}
>>>>>>
>>>>>> Modified: cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
>>>>>> URL:
>>>>>>
>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>
>>>>>>
>>>>>> ==============================================================================
>>>>>> --- cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
>>>>>> (original)
>>>>>> +++ cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp Tue Aug
>>>>>> 8 12:12:28 2017
>>>>>> @@ -1108,26 +1108,35 @@ TEST(ConstructorDeclaration, IsExplicit)
>>>>>>    }
>>>>>>
>>>>>>    TEST(ConstructorDeclaration, Kinds) {
>>>>>> -  EXPECT_TRUE(matches("struct S { S(); };",
>>>>>> -                      cxxConstructorDecl(isDefaultConstructor())));
>>>>>> -  EXPECT_TRUE(notMatches("struct S { S(); };",
>>>>>> -                         cxxConstructorDecl(isCopyConstructor())));
>>>>>> -  EXPECT_TRUE(notMatches("struct S { S(); };",
>>>>>> -                         cxxConstructorDecl(isMoveConstructor())));
>>>>>> +  EXPECT_TRUE(matches(
>>>>>> +      "struct S { S(); };",
>>>>>> +      cxxConstructorDecl(isDefaultConstructor(),
>>>>>> unless(isImplicit()))));
>>>>>> +  EXPECT_TRUE(notMatches(
>>>>>> +      "struct S { S(); };",
>>>>>> +      cxxConstructorDecl(isCopyConstructor(), unless(isImplicit()))));
>>>>>> +  EXPECT_TRUE(notMatches(
>>>>>> +      "struct S { S(); };",
>>>>>> +      cxxConstructorDecl(isMoveConstructor(), unless(isImplicit()))));
>>>>>>
>>>>>> -  EXPECT_TRUE(notMatches("struct S { S(const S&); };",
>>>>>> -                         cxxConstructorDecl(isDefaultConstructor())));
>>>>>> -  EXPECT_TRUE(matches("struct S { S(const S&); };",
>>>>>> -                      cxxConstructorDecl(isCopyConstructor())));
>>>>>> -  EXPECT_TRUE(notMatches("struct S { S(const S&); };",
>>>>>> -                         cxxConstructorDecl(isMoveConstructor())));
>>>>>> +  EXPECT_TRUE(notMatches(
>>>>>> +      "struct S { S(const S&); };",
>>>>>> +      cxxConstructorDecl(isDefaultConstructor(),
>>>>>> unless(isImplicit()))));
>>>>>> +  EXPECT_TRUE(matches(
>>>>>> +      "struct S { S(const S&); };",
>>>>>> +      cxxConstructorDecl(isCopyConstructor(), unless(isImplicit()))));
>>>>>> +  EXPECT_TRUE(notMatches(
>>>>>> +      "struct S { S(const S&); };",
>>>>>> +      cxxConstructorDecl(isMoveConstructor(), unless(isImplicit()))));
>>>>>>
>>>>>> -  EXPECT_TRUE(notMatches("struct S { S(S&&); };",
>>>>>> -                         cxxConstructorDecl(isDefaultConstructor())));
>>>>>> -  EXPECT_TRUE(notMatches("struct S { S(S&&); };",
>>>>>> -                         cxxConstructorDecl(isCopyConstructor())));
>>>>>> -  EXPECT_TRUE(matches("struct S { S(S&&); };",
>>>>>> -                      cxxConstructorDecl(isMoveConstructor())));
>>>>>> +  EXPECT_TRUE(notMatches(
>>>>>> +      "struct S { S(S&&); };",
>>>>>> +      cxxConstructorDecl(isDefaultConstructor(),
>>>>>> unless(isImplicit()))));
>>>>>> +  EXPECT_TRUE(notMatches(
>>>>>> +      "struct S { S(S&&); };",
>>>>>> +      cxxConstructorDecl(isCopyConstructor(), unless(isImplicit()))));
>>>>>> +  EXPECT_TRUE(matches(
>>>>>> +      "struct S { S(S&&); };",
>>>>>> +      cxxConstructorDecl(isMoveConstructor(), unless(isImplicit()))));
>>>>>>    }
>>>>>>
>>>>>>    TEST(ConstructorDeclaration, IsUserProvided) {
>>>>>>
>>>>>>
>>>>>> _______________________________________________
>>>>>> cfe-commits mailing list
>>>>>> cfe-commits at lists.llvm.org
>>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> cfe-commits mailing list
>>>>> cfe-commits at lists.llvm.org
>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>
>>>> _______________________________________________
>>>> cfe-commits mailing list
>>>> cfe-commits at lists.llvm.org
>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>
>>>



More information about the cfe-commits mailing list