Classify C++ structs as loadable or address-only

include/swift/AST/Decl.h

@@ -558,10 +558,12 @@ class alignas(1 << DeclAlignInBits) Decl {
     IsIncompatibleWithWeakReferences : 1
   );
 
-  SWIFT_INLINE_BITFIELD(StructDecl, NominalTypeDecl, 1,
+  SWIFT_INLINE_BITFIELD(StructDecl, NominalTypeDecl, 1+1,
     /// True if this struct has storage for fields that aren't accessible in
     /// Swift.
-    HasUnreferenceableStorage : 1
+    HasUnreferenceableStorage : 1,
+    /// True if this struct is imported from C++ and not trivially copyable.
+    IsCxxNotTriviallyCopyable : 1
   );
 
   SWIFT_INLINE_BITFIELD(EnumDecl, NominalTypeDecl, 2+1,
@@ -3822,6 +3824,14 @@ class StructDecl final : public NominalTypeDecl {
   void setHasUnreferenceableStorage(bool v) {
     Bits.StructDecl.HasUnreferenceableStorage = v;
   }
+
+  bool isCxxNotTriviallyCopyable() const {
+    return Bits.StructDecl.IsCxxNotTriviallyCopyable;
+  }
+
+  void setIsCxxNotTriviallyCopyable(bool v) {
+    Bits.StructDecl.IsCxxNotTriviallyCopyable = v;
+  }
 };
 
 /// This is the base type for AncestryOptions. Each flag describes possible

lib/AST/Decl.cpp

@@ -4090,6 +4090,7 @@ StructDecl::StructDecl(SourceLoc StructLoc, Identifier Name, SourceLoc NameLoc,
     StructLoc(StructLoc)
 {
   Bits.StructDecl.HasUnreferenceableStorage = false;
+  Bits.StructDecl.IsCxxNotTriviallyCopyable = false;
 }
 
 bool NominalTypeDecl::hasMemberwiseInitializer() const {

lib/ClangImporter/ImportDecl.cpp

@@ -48,6 +48,7 @@
 #include "clang/AST/DeclCXX.h"
 #include "clang/Basic/CharInfo.h"
 #include "swift/Basic/Statistic.h"
+#include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/Lookup.h"
@@ -3468,6 +3469,25 @@ namespace {
 
       result->setHasUnreferenceableStorage(hasUnreferenceableStorage);
 
+      if (auto cxxRecordDecl = dyn_cast<clang::CXXRecordDecl>(decl)) {
+        result->setIsCxxNotTriviallyCopyable(
+            !cxxRecordDecl->isTriviallyCopyable());
+
+        for (auto ctor : cxxRecordDecl->ctors()) {
+          if (ctor->isCopyConstructor() &&
+              (ctor->isDeleted() || ctor->getAccess() != clang::AS_public)) {
+            result->setIsCxxNotTriviallyCopyable(true);
+            break;
+          }
+        }
+
+        if (auto dtor = cxxRecordDecl->getDestructor()) {
+          if (dtor->isDeleted() || dtor->getAccess() != clang::AS_public) {
+            result->setIsCxxNotTriviallyCopyable(true);
+          }
+        }
+      }
+
       return result;
     }
 

lib/SIL/IR/TypeLowering.cpp

@@ -1446,6 +1446,10 @@ namespace {
       if (handleResilience(structType, D, properties))
         return handleAddressOnly(structType, properties);
 
+      if (D->isCxxNotTriviallyCopyable()) {
+        properties.setAddressOnly();
+      }
+
       auto subMap = structType->getContextSubstitutionMap(&TC.M, D);
 
       // Classify the type according to its stored properties.

test/Interop/Cxx/class/Inputs/loadable-types.h

@@ -0,0 +1,158 @@
+#ifndef TEST_INTEROP_CXX_CLASS_INPUTS_LOADABLE_TYPES_H
+#define TEST_INTEROP_CXX_CLASS_INPUTS_LOADABLE_TYPES_H
+
+struct EmptyStruct {};
+
+// Tests for individual special members
+
+struct StructWithDefaultConstructor {
+  StructWithDefaultConstructor() {}
+};
+
+struct StructWithAdditionalConstructor {
+  StructWithAdditionalConstructor() {}
+  StructWithAdditionalConstructor(int parameter) {}
+};
+
+struct StructWithCopyConstructor {
+  StructWithCopyConstructor(const StructWithCopyConstructor &) {}
+};
+
+struct StructWithInheritedCopyConstructor : StructWithCopyConstructor {};
+
+struct StructWithSubobjectCopyConstructor {
+  StructWithCopyConstructor subobject;
+};
+
+struct StructWithDefaultedCopyConstructor {
+  StructWithDefaultedCopyConstructor(
+      const StructWithDefaultedCopyConstructor &) = default;
+};
+
+struct StructWithInheritedDefaultedCopyConstructor
+    : StructWithDefaultedCopyConstructor {};
+
+struct StructWithSubobjectDefaultedCopyConstructor {
+  StructWithDefaultedCopyConstructor subobject;
+};
+
+struct StructWithPrivateDefaultedCopyConstructor {
+private:
+  StructWithPrivateDefaultedCopyConstructor(
+      const StructWithPrivateDefaultedCopyConstructor &) = default;
+};
+
+struct StructWithInheritedPrivateDefaultedCopyConstructor
+    : StructWithPrivateDefaultedCopyConstructor {};
+
+struct StructWithSubobjectPrivateDefaultedCopyConstructor {
+  StructWithPrivateDefaultedCopyConstructor subobject;
+};
+
+struct StructWithMoveConstructor {
+  StructWithMoveConstructor(StructWithMoveConstructor &&) {}
+};
+
+struct StructWithInheritedMoveConstructor : StructWithMoveConstructor {};
+
+struct StructWithSubobjectMoveConstructor {
+  StructWithMoveConstructor subobject;
+};
+
+struct StructWithCopyAssignment {
+  StructWithCopyAssignment &operator=(const StructWithCopyAssignment &) {}
+};
+
+struct StructWithInheritedCopyAssignment : StructWithCopyAssignment {};
+
+struct StructWithSubobjectCopyAssignment {
+  StructWithCopyAssignment subobject;
+};
+
+struct StructWithMoveAssignment {
+  StructWithMoveAssignment &operator=(StructWithMoveAssignment &&) {}
+};
+
+struct StructWithInheritedMoveAssignment : StructWithMoveAssignment {};
+
+struct StructWithSubobjectMoveAssignment {
+  StructWithMoveAssignment subobject;
+};
+
+struct StructWithDestructor {
+  ~StructWithDestructor(){}
+};
+
+struct StructWithInheritedDestructor : StructWithDestructor {};
+
+struct StructWithSubobjectDestructor {
+  StructWithDestructor subobject;
+};
+
+struct StructWithDefaultedDestructor {
+  ~StructWithDefaultedDestructor() = default;
+};
+
+struct StructWithInheritedDefaultedDestructor : StructWithDefaultedDestructor {
+};
+
+struct StructWithSubobjectDefaultedDestructor {
+  StructWithDefaultedDestructor subobject;
+};
+
+struct StructWithPrivateDefaultedDestructor {
+private:
+  ~StructWithPrivateDefaultedDestructor() = default;
+};
+
+struct StructWithInheritedPrivateDefaultedDestructor
+    : StructWithPrivateDefaultedDestructor {};
+
+struct StructWithSubobjectPrivateDefaultedDestructor {
+  StructWithPrivateDefaultedDestructor subobject;
+};
+
+// Tests for common sets of special member functions.
+
+struct StructTriviallyCopyableMovable {
+  StructTriviallyCopyableMovable(const StructTriviallyCopyableMovable &) =
+      default;
+  StructTriviallyCopyableMovable(StructTriviallyCopyableMovable &&) = default;
+  StructTriviallyCopyableMovable &
+  operator=(const StructTriviallyCopyableMovable &) = default;
+  StructTriviallyCopyableMovable &
+  operator=(StructTriviallyCopyableMovable &&) = default;
+  ~StructTriviallyCopyableMovable() = default;
+};
+
+struct StructNonCopyableTriviallyMovable {
+  StructNonCopyableTriviallyMovable(const StructNonCopyableTriviallyMovable &) =
+      delete;
+  StructNonCopyableTriviallyMovable(StructNonCopyableTriviallyMovable &&) =
+      default;
+  StructNonCopyableTriviallyMovable &
+  operator=(const StructNonCopyableTriviallyMovable &) = delete;
+  StructNonCopyableTriviallyMovable &
+  operator=(StructNonCopyableTriviallyMovable &&) = default;
+  ~StructNonCopyableTriviallyMovable() = default;
+};
+
+struct StructNonCopyableNonMovable {
+  StructNonCopyableNonMovable(const StructNonCopyableNonMovable &) = delete;
+  StructNonCopyableNonMovable(StructNonCopyableNonMovable &&) = default;
+  StructNonCopyableNonMovable &
+  operator=(const StructNonCopyableNonMovable &) = delete;
+  StructNonCopyableNonMovable &
+  operator=(StructNonCopyableNonMovable &&) = default;
+  ~StructNonCopyableNonMovable() = default;
+};
+
+struct StructDeletedDestructor {
+  StructDeletedDestructor(const StructDeletedDestructor &) = default;
+  StructDeletedDestructor(StructDeletedDestructor &&) = default;
+  StructDeletedDestructor &operator=(const StructDeletedDestructor &) = default;
+  StructDeletedDestructor &operator=(StructDeletedDestructor &&) = default;
+  ~StructDeletedDestructor() = delete;
+};
+
+#endif

test/Interop/Cxx/class/Inputs/module.modulemap

@@ -2,6 +2,10 @@ module AccessSpecifiers {
   header "access-specifiers.h"
 }
 
+module LoadableTypes {
+  header "loadable-types.h"
+}
+
 module MemberwiseInitializer {
   header "memberwise-initializer.h"
 }