Clang crashed while checking for deletion of copy and move ctors

[oontvoo]

Summary

Repro:
template <class> class __attribute__((trivial_abi)) a { a(a &&); };

Crash:

@     0x559d129463fc  clang::CXXRecordDecl::defaultedCopyConstructorIsDeleted()
 @     0x559d1288d3e5  clang::Sema::checkIllFormedTrivialABIStruct()::$_7::operator()()
 @     0x559d12884c34  clang::Sema::checkIllFormedTrivialABIStruct()
 @     0x559d1288412e  clang::Sema::CheckCompletedCXXClass()
 @     0x559d1288d843  clang::Sema::ActOnFinishCXXMemberSpecification()
 @     0x559d12020109  clang::Parser::ParseCXXMemberSpecification()
 @     0x559d1201e80c  clang::Parser::ParseClassSpecifier()
 @     0x559d1204e807  clang::Parser::ParseDeclarationSpecifiers()
 @     0x559d120e9aa9  clang::Parser::ParseSingleDeclarationAfterTemplate()
 @     0x559d120e8f21  clang::Parser::ParseTemplateDeclarationOrSpecialization()
 @     0x559d120e8886  clang::Parser::ParseDeclarationStartingWithTemplate()
 @     0x559d1204a1d4  clang::Parser::ParseDeclaration()
 @     0x559d12004b1d  clang::Parser::ParseExternalDeclaration()
 @     0x559d12017689  clang::Parser::ParseInnerNamespace()
 @     0x559d12017024  clang::Parser::ParseNamespace()
 @     0x559d1204a29b  clang::Parser::ParseDeclaration()
 @     0x559d12004c74  clang::Parser::ParseExternalDeclaration()

[oontvoo]

add test

[oontvoo]

Dont skip checking even for templated type

[oontvoo]

Add more tests

[oontvoo]

updated diff

[oontvoo]

updated diff

[rsmith]

clang/lib/Sema/SemaDeclCXX.cpp

9735

This is not the right fallback answer if the class is a dependent type -- we don't yet know if there's a non-deleted copy or move constructor if one might be implicitly declared, so we should conservatively assume that there might be one. It'd probably be easiest to return true from this function at the very start if the type is dependent (because we don't know if there's a non-deleted copy or move constructor).

clang/test/SemaObjCXX/attr-trivial-abi.mm

61–63

We should not diagnose this, because instantiations of this template might have non-deleted copy or move constructors. (We don't know yet when parsing the template definition.)

[oontvoo]

prevent diagnostics for dependent types

[oontvoo]

lint

[oontvoo]

one more test

clang/lib/Sema/SemaDeclCXX.cpp

if (!isTemplateInstantiation(RD.getTemplateSpecializationKind())) {
       Diag(RD.getAttr<TrivialABIAttr>()->getLocation(),
            diag::note_cannot_use_trivial_abi_reason) << &RD << N;
     }
     RD.dropAttr<TrivialABIAttr>();
   };
 
   // Ill-formed if the copy and move constructors are deleted.
   auto HasNonDeletedCopyOrMoveConstructor = [&]() {
+    // If the type is dependent, then assume it might have
+    // implicit copy or move ctor because we won't know yet at this point.
+    if (RD.isDependentType())
+      return true;
     if (RD.needsImplicitCopyConstructor() &&
         !RD.defaultedCopyConstructorIsDeleted())
       return true;
     if (RD.needsImplicitMoveConstructor() &&
         !RD.defaultedMoveConstructorIsDeleted())
       return true;
     for (const CXXConstructorDecl *CD : RD.ctors())
       if (CD->isCopyOrMoveConstructor() && !CD->isDeleted())
         return true;
     return false;
   };
 
   if (!HasNonDeletedCopyOrMoveConstructor()) {
     PrintDiagAndRemoveAttr(0);
     return;
   }
 
   // Ill-formed if the struct has virtual functions.

clang/test/SemaCXX/attr-trivial-abi.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
+
+void __attribute__((trivial_abi)) foo(); // expected-warning {{'trivial_abi' attribute only applies to classes}}
+
+// Should not crash.
+template <class>
+class __attribute__((trivial_abi)) a { a(a &&); };
+
+struct [[clang::trivial_abi]] S0 {
+  int a;
+};
+
+struct __attribute__((trivial_abi)) S1 {
+  int a;
+};
+
+struct __attribute__((trivial_abi)) S3 { // expected-warning {{'trivial_abi' cannot be applied to 'S3'}} expected-note {{is polymorphic}}
+  virtual void m();
+};
+
+struct S3_2 {
+  virtual void m();
+} __attribute__((trivial_abi)); // expected-warning {{'trivial_abi' cannot be applied to 'S3_2'}} expected-note {{is polymorphic}}
+
+struct __attribute__((trivial_abi)) S3_3 { // expected-warning {{'trivial_abi' cannot be applied to 'S3_3'}} expected-note {{has a field of a non-trivial class type}}
+  S3_3(S3_3 &&);
+  S3_2 s32;
+};
+
+// Diagnose invalid trivial_abi even when the type is templated because it has a non-trivial field.
+template <class T>
+struct __attribute__((trivial_abi)) S3_4 { // expected-warning {{'trivial_abi' cannot be applied to 'S3_4'}} expected-note {{has a field of a non-trivial class type}}
+  S3_4(S3_4 &&);
+  S3_2 s32;
+};
+
+struct S4 {
+  int a;
+};
+
+struct __attribute__((trivial_abi)) S5 : public virtual S4 { // expected-warning {{'trivial_abi' cannot be applied to 'S5'}} expected-note {{has a virtual base}}
+};
+
+struct __attribute__((trivial_abi)) S9 : public S4 {
+};
+
+struct __attribute__((trivial_abi(1))) S8 { // expected-error {{'trivial_abi' attribute takes no arguments}}
+  int a;
+};
+
+// Do not warn about deleted ctors  when 'trivial_abi' is used to annotate a template class.
+template <class T>
+struct __attribute__((trivial_abi)) S10 {
+  T p;
+};
+
+S10<int *> p1;
+
+template <class T>
+struct S14 {
+  T a;
+};
+
+template <class T>
+struct __attribute__((trivial_abi)) S15 : S14<T> {
+};
+
+S15<int> s15;
+
+template <class T>
+struct __attribute__((trivial_abi)) S16 {
+  S14<T> a;
+};
+
+S16<int> s16;
+
+template <class T>
+struct __attribute__((trivial_abi)) S17 {
+};
+
+S17<int> s17;
+
+namespace deletedCopyMoveConstructor {
+struct __attribute__((trivial_abi)) CopyMoveDeleted { // expected-warning {{'trivial_abi' cannot be applied to 'CopyMoveDeleted'}} expected-note {{copy constructors and move constructors are all deleted}}
+  CopyMoveDeleted(const CopyMoveDeleted &) = delete;
+  CopyMoveDeleted(CopyMoveDeleted &&) = delete;
+};
+
+struct __attribute__((trivial_abi)) S18 { // expected-warning {{'trivial_abi' cannot be applied to 'S18'}} expected-note {{copy constructors and move constructors are all deleted}}
+  CopyMoveDeleted a;
+};
+
+struct __attribute__((trivial_abi)) CopyDeleted {
+  CopyDeleted(const CopyDeleted &) = delete;
+  CopyDeleted(CopyDeleted &&) = default;
+};
+
+struct __attribute__((trivial_abi)) MoveDeleted {
+  MoveDeleted(const MoveDeleted &) = default;
+  MoveDeleted(MoveDeleted &&) = delete;
+};
+
+struct __attribute__((trivial_abi)) S19 { // expected-warning {{'trivial_abi' cannot be applied to 'S19'}} expected-note {{copy constructors and move constructors are all deleted}}
+  CopyDeleted a;
+  MoveDeleted b;
+};
+
+// This is fine since the move constructor isn't deleted.
+struct __attribute__((trivial_abi)) S20 {
+  int &&a; // a member of rvalue reference type deletes the copy constructor.
+};
+} // namespace deletedCopyMoveConstructor

clang/test/SemaObjCXX/attr-trivial-abi.mm

struct __attribute__((trivial_abi)) S11 { // expected-warning {{'trivial_abi' cannot be applied to 'S11'}} expected-note {{has a field of a non-trivial class type}}
   S6 a[2];
 };
 
 struct __attribute__((trivial_abi(1))) S8 { // expected-error {{'trivial_abi' attribute takes no arguments}}
   int a;
 };
 
 // Do not warn when 'trivial_abi' is used to annotate a template class.
-template<class T>
+template <class T>
 struct __attribute__((trivial_abi)) S10 {
   T p;
 };
 
 S10<int *> p1;
 S10<__weak id> p2;
 
 template<>
 struct __attribute__((trivial_abi)) S10<id> { // expected-warning {{'trivial_abi' cannot be applied to 'S10<id>'}} expected-note {{has a __weak field}}
   __weak id a;
 };
 
 template<class T>
 struct S14 {
   T a;
   __weak id b;
 };
 
-template<class T>
+template <class T>
 struct __attribute__((trivial_abi)) S15 : S14<T> {
 };
 
 S15<int> s15;
 
-template<class T>
+template <class T>
 struct __attribute__((trivial_abi)) S16 {
   S14<T> a;
 };
 
 S16<int> s16;
 
-template<class T>
+template <class T>
 struct __attribute__((trivial_abi)) S17 { // expected-warning {{'trivial_abi' cannot be applied to 'S17'}} expected-note {{has a __weak field}}
+  S17();
+  S17(S17 &&);
+  __weak id a;
+};
+
+struct __attribute__((trivial_abi)) S18 { // expected-warning {{'trivial_abi' cannot be applied to 'S18'}} expected-note {{has a __weak field}}
   __weak id a;
 };
 
 S17<int> s17;
 
 namespace deletedCopyMoveConstructor {
   struct __attribute__((trivial_abi)) CopyMoveDeleted { // expected-warning {{'trivial_abi' cannot be applied to 'CopyMoveDeleted'}} expected-note {{copy constructors and move constructors are all deleted}}
     CopyMoveDeleted(const CopyMoveDeleted &) = delete;