Reflection: Compute if types are bitwise takable

Bitwise takability is now part of the layout of a type, because
non-bitwise takable types are never stored inline in an
existential or resilient global's buffer, even if they would
fit.

The basic rule is that weak references, unknown-refcounted
unowned references, and aggregates that contain them, are not
bitwise takable, whereas everything else is bitwise takable.

Also, since the bitwise takable for an unowned reference
depends on the reference counting style, we have to record the
superclass of a protocol, if any, to correctly determine the
reference counting style of the protocol existential.

Author: slavapestov

include/swift/Reflection/Records.h

@@ -402,10 +402,23 @@ class BuiltinTypeDescriptor {
 
 public:
   uint32_t Size;
-  uint32_t Alignment;
+
+  // - Least significant 16 bits are the alignment.
+  // - Bit 16 is 'bitwise takable'.
+  // - Remaining bits are reserved.
+  uint32_t AlignmentAndFlags;
+
   uint32_t Stride;
   uint32_t NumExtraInhabitants;
 
+  bool isBitwiseTakable() const {
+    return (AlignmentAndFlags >> 16) & 1;
+  }
+
+  uint32_t getAlignment() const {
+    return AlignmentAndFlags & 0xffff;
+  }
+
   bool hasMangledTypeName() const {
     return TypeName;
   }

include/swift/Reflection/ReflectionContext.h

@@ -541,13 +541,17 @@ class ReflectionContext
       return nullptr;
 
     // Initialize the builder.
-    Builder.addField(*OffsetToFirstCapture, sizeof(StoredPointer),
-                     /*numExtraInhabitants=*/0);
+    Builder.addField(*OffsetToFirstCapture,
+                     /*alignment=*/sizeof(StoredPointer),
+                     /*numExtraInhabitants=*/0,
+                     /*bitwiseTakable=*/true);
 
     // Skip the closure's necessary bindings struct, if it's present.
     auto SizeOfNecessaryBindings = Info.NumBindings * sizeof(StoredPointer);
-    Builder.addField(SizeOfNecessaryBindings, sizeof(StoredPointer),
-                     /*numExtraInhabitants=*/0);
+    Builder.addField(/*size=*/SizeOfNecessaryBindings,
+                     /*alignment=*/sizeof(StoredPointer),
+                     /*numExtraInhabitants=*/0,
+                     /*bitwiseTakable=*/true);
 
     // FIXME: should be unordered_set but I'm too lazy to write a hash
     // functor

include/swift/Reflection/TypeLowering.h

@@ -110,13 +110,16 @@ enum class TypeInfoKind : unsigned {
 class TypeInfo {
   TypeInfoKind Kind;
   unsigned Size, Alignment, Stride, NumExtraInhabitants;
+  bool BitwiseTakable;
 
 public:
   TypeInfo(TypeInfoKind Kind,
            unsigned Size, unsigned Alignment,
-           unsigned Stride, unsigned NumExtraInhabitants)
+           unsigned Stride, unsigned NumExtraInhabitants,
+           bool BitwiseTakable)
     : Kind(Kind), Size(Size), Alignment(Alignment), Stride(Stride),
-      NumExtraInhabitants(NumExtraInhabitants) {
+      NumExtraInhabitants(NumExtraInhabitants),
+      BitwiseTakable(BitwiseTakable) {
     assert(Alignment > 0);
   }
 
@@ -126,6 +129,7 @@ class TypeInfo {
   unsigned getAlignment() const { return Alignment; }
   unsigned getStride() const { return Stride; }
   unsigned getNumExtraInhabitants() const { return NumExtraInhabitants; }
+  bool isBitwiseTakable() const { return BitwiseTakable; }
 
   void dump() const;
   void dump(std::ostream &OS, unsigned Indent = 0) const;
@@ -162,9 +166,10 @@ class RecordTypeInfo : public TypeInfo {
 public:
   RecordTypeInfo(unsigned Size, unsigned Alignment,
                  unsigned Stride, unsigned NumExtraInhabitants,
+                 bool BitwiseTakable,
                  RecordKind SubKind, const std::vector<FieldInfo> &Fields)
     : TypeInfo(TypeInfoKind::Record, Size, Alignment, Stride,
-               NumExtraInhabitants),
+               NumExtraInhabitants, BitwiseTakable),
       SubKind(SubKind), Fields(Fields) {}
 
   RecordKind getRecordKind() const { return SubKind; }
@@ -185,9 +190,10 @@ class ReferenceTypeInfo : public TypeInfo {
 public:
   ReferenceTypeInfo(unsigned Size, unsigned Alignment,
                     unsigned Stride, unsigned NumExtraInhabitants,
-                    ReferenceKind SubKind, ReferenceCounting Refcounting)
+                    bool BitwiseTakable, ReferenceKind SubKind,
+                    ReferenceCounting Refcounting)
     : TypeInfo(TypeInfoKind::Reference, Size, Alignment, Stride,
-               NumExtraInhabitants),
+               NumExtraInhabitants, BitwiseTakable),
       SubKind(SubKind), Refcounting(Refcounting) {}
 
   ReferenceKind getReferenceKind() const {
@@ -286,6 +292,7 @@ class TypeConverter {
 class RecordTypeInfoBuilder {
   TypeConverter &TC;
   unsigned Size, Alignment, NumExtraInhabitants;
+  bool BitwiseTakable;
   RecordKind Kind;
   std::vector<FieldInfo> Fields;
   bool Empty;
@@ -294,14 +301,15 @@ class RecordTypeInfoBuilder {
 public:
   RecordTypeInfoBuilder(TypeConverter &TC, RecordKind Kind)
     : TC(TC), Size(0), Alignment(1), NumExtraInhabitants(0),
-      Kind(Kind), Empty(true), Invalid(false) {}
+      BitwiseTakable(true), Kind(Kind), Empty(true), Invalid(false) {}
 
   bool isInvalid() const {
     return Invalid;
   }
 
   unsigned addField(unsigned fieldSize, unsigned fieldAlignment,
-                    unsigned numExtraInhabitants);
+                    unsigned numExtraInhabitants,
+                    bool bitwiseTakable);
 
   // Add a field of a record type, such as a struct.
   void addField(const std::string &Name, const TypeRef *TR);

lib/IRGen/GenReflection.cpp

@@ -426,11 +426,11 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
   }
 
   void layoutProtocol() {
-    auto protocolDecl = cast<ProtocolDecl>(NTD);
+    auto PD = cast<ProtocolDecl>(NTD);
     FieldDescriptorKind Kind;
-    if (protocolDecl->isObjC())
+    if (PD->isObjC())
       Kind = FieldDescriptorKind::ObjCProtocol;
-    else if (protocolDecl->requiresClass())
+    else if (PD->requiresClass())
       Kind = FieldDescriptorKind::ClassProtocol;
     else
       Kind = FieldDescriptorKind::Protocol;
@@ -446,8 +446,11 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
     addNominalRef(NTD);
 
     auto *CD = dyn_cast<ClassDecl>(NTD);
+    auto *PD = dyn_cast<ProtocolDecl>(NTD);
     if (CD && CD->getSuperclass()) {
       addTypeRef(CD->getSuperclass()->getCanonicalType());
+    } else if (PD && PD->getDeclaredType()->getSuperclass()) {
+      addTypeRef(PD->getDeclaredType()->getSuperclass()->getCanonicalType());
     } else {
       B.addInt32(0);
     }
@@ -515,7 +518,13 @@ class FixedTypeMetadataBuilder : public ReflectionMetadataBuilder {
     addTypeRef(type);
 
     B.addInt32(ti->getFixedSize().getValue());
-    B.addInt32(ti->getFixedAlignment().getValue());
+
+    auto alignment = ti->getFixedAlignment().getValue();
+    unsigned bitwiseTakable =
+      (ti->isBitwiseTakable(ResilienceExpansion::Minimal) == IsBitwiseTakable
+       ? 1 : 0);
+    B.addInt32(alignment | (bitwiseTakable << 16));
+
     B.addInt32(ti->getFixedStride().getValue());
     B.addInt32(ti->getFixedExtraInhabitantCount(IGM));
   }

stdlib/public/Reflection/TypeLowering.cpp

@@ -77,6 +77,7 @@ class PrintTypeInfo {
     printField("alignment", TI.getAlignment());
     printField("stride", TI.getStride());
     printField("num_extra_inhabitants", TI.getNumExtraInhabitants());
+    printField("bitwise_takable", TI.isBitwiseTakable());
   }
 
   void printFields(const RecordTypeInfo &TI) {
@@ -190,8 +191,12 @@ void TypeInfo::dump(std::ostream &OS, unsigned Indent) const {
 }
 
 BuiltinTypeInfo::BuiltinTypeInfo(const BuiltinTypeDescriptor *descriptor)
-    : TypeInfo(TypeInfoKind::Builtin, descriptor->Size, descriptor->Alignment,
-               descriptor->Stride, descriptor->NumExtraInhabitants),
+    : TypeInfo(TypeInfoKind::Builtin,
+               descriptor->Size,
+               descriptor->getAlignment(),
+               descriptor->Stride,
+               descriptor->NumExtraInhabitants,
+               descriptor->isBitwiseTakable()),
       Name(descriptor->getMangledTypeName(0)) {}
 
 /// Utility class for building values that contain witness tables.
@@ -263,6 +268,29 @@ class ExistentialTypeInfoBuilder {
         case FieldDescriptorKind::ClassProtocol:
           Representation = ExistentialTypeRepresentation::Class;
           WitnessTableCount++;
+
+          if (auto *Superclass = TC.getBuilder().lookupSuperclass(P)) {
+            auto *SuperclassTI = TC.getTypeInfo(Superclass);
+            if (SuperclassTI == nullptr) {
+              DEBUG_LOG(std::cerr << "No TypeInfo for superclass: ";
+                        Superclass->dump());
+              Invalid = true;
+              continue;
+            }
+
+            if (!isa<ReferenceTypeInfo>(SuperclassTI)) {
+              DEBUG_LOG(std::cerr << "Superclass not a reference type: ";
+                        SuperclassTI->dump());
+              Invalid = true;
+              continue;
+            }
+
+            if (cast<ReferenceTypeInfo>(SuperclassTI)->getReferenceCounting()
+                == ReferenceCounting::Native) {
+              Refcounting = ReferenceCounting::Native;
+            }
+          }
+
           continue;
         case FieldDescriptorKind::Protocol:
           WitnessTableCount++;
@@ -397,9 +425,12 @@ class ExistentialTypeInfoBuilder {
 
       // Non-class existentials consist of a three-word buffer,
       // value metadata, and finally zero or more witness tables.
+      // The buffer is always bitwise takable, since non-bitwise
+      // takable payloads are stored out of line.
       builder.addField(TI->getSize() * 3,
                        TI->getAlignment(),
-                       /*numExtraInhabitants=*/0);
+                       /*numExtraInhabitants=*/0,
+                       /*bitwiseTakable=*/true);
       builder.addField("metadata", TC.getAnyMetatypeTypeRef());
       break;
     }
@@ -441,7 +472,8 @@ class ExistentialTypeInfoBuilder {
 
 unsigned RecordTypeInfoBuilder::addField(unsigned fieldSize,
                                          unsigned fieldAlignment,
-                                         unsigned numExtraInhabitants) {
+                                         unsigned numExtraInhabitants,
+                                         bool bitwiseTakable) {
   assert(fieldAlignment > 0);
 
   // Align the current size appropriately
@@ -456,6 +488,9 @@ unsigned RecordTypeInfoBuilder::addField(unsigned fieldSize,
   // Update the aggregate alignment
   Alignment = std::max(Alignment, fieldAlignment);
 
+  // The aggregate is bitwise takable if all elements are.
+  BitwiseTakable &= bitwiseTakable;
+
   switch (Kind) {
   // The extra inhabitants of a struct or tuple are the same as the extra
   // inhabitants of the field that has the most.
@@ -500,7 +535,8 @@ void RecordTypeInfoBuilder::addField(const std::string &Name,
 
   unsigned offset = addField(TI->getSize(),
                              TI->getAlignment(),
-                             TI->getNumExtraInhabitants());
+                             TI->getNumExtraInhabitants(),
+                             TI->isBitwiseTakable());
   Fields.push_back({Name, offset, TR, *TI});
 }
 
@@ -515,7 +551,8 @@ const RecordTypeInfo *RecordTypeInfoBuilder::build() {
 
   return TC.makeTypeInfo<RecordTypeInfo>(
       Size, Alignment, Stride,
-      NumExtraInhabitants, Kind, Fields);
+      NumExtraInhabitants, BitwiseTakable,
+      Kind, Fields);
 }
 
 const ReferenceTypeInfo *
@@ -548,13 +585,28 @@ TypeConverter::getReferenceTypeInfo(ReferenceKind Kind,
   }
 
   unsigned numExtraInhabitants = BuiltinTI->NumExtraInhabitants;
-  if (Kind == ReferenceKind::Weak)
+  bool bitwiseTakable = true;
+
+  switch (Kind) {
+  case ReferenceKind::Strong:
+    break;
+  case ReferenceKind::Weak:
     numExtraInhabitants = 0;
+    bitwiseTakable = false;
+    break;
+  case ReferenceKind::Unowned:
+    if (Refcounting == ReferenceCounting::Unknown)
+      bitwiseTakable = false;
+    break;
+  case ReferenceKind::Unmanaged:
+    break;
+  }
 
   auto *TI = makeTypeInfo<ReferenceTypeInfo>(BuiltinTI->Size,
-                                             BuiltinTI->Alignment,
+                                             BuiltinTI->getAlignment(),
                                              BuiltinTI->Stride,
                                              numExtraInhabitants,
+                                             bitwiseTakable,
                                              Kind, Refcounting);
   ReferenceCache[key] = TI;
   return TI;
@@ -619,7 +671,12 @@ const TypeInfo *TypeConverter::getEmptyTypeInfo() {
   if (EmptyTI != nullptr)
     return EmptyTI;
 
-  EmptyTI = makeTypeInfo<TypeInfo>(TypeInfoKind::Builtin, 0, 1, 1, 0);
+  EmptyTI = makeTypeInfo<TypeInfo>(TypeInfoKind::Builtin,
+                                   /*Size=*/0,
+                                   /*Alignment=*/1,
+                                   /*Stride=*/1,
+                                   /*ExtraInhabitants=*/0,
+                                   /*BitwiseTakable=*/true);
   return EmptyTI;
 }
 
@@ -919,6 +976,7 @@ static unsigned getNumTagBytes(size_t size, unsigned emptyCases,
 class EnumTypeInfoBuilder {
   TypeConverter &TC;
   unsigned Size, Alignment, NumExtraInhabitants;
+  bool BitwiseTakable;
   RecordKind Kind;
   std::vector<FieldInfo> Cases;
   bool Invalid;
@@ -942,14 +1000,15 @@ class EnumTypeInfoBuilder {
 
     Size = std::max(Size, TI->getSize());
     Alignment = std::max(Alignment, TI->getAlignment());
+    BitwiseTakable &= TI->isBitwiseTakable();
 
     Cases.push_back({Name, /*offset=*/0, TR, *TI});
   }
 
 public:
   EnumTypeInfoBuilder(TypeConverter &TC)
     : TC(TC), Size(0), Alignment(1), NumExtraInhabitants(0),
-      Kind(RecordKind::Invalid), Invalid(false) {}
+      BitwiseTakable(true), Kind(RecordKind::Invalid), Invalid(false) {}
 
   const TypeInfo *
   build(const TypeRef *TR,
@@ -1028,8 +1087,9 @@ class EnumTypeInfoBuilder {
       auto *FixedDescriptor = TC.getBuilder().getBuiltinTypeInfo(TR);
       if (FixedDescriptor) {
         Size = FixedDescriptor->Size;
-        Alignment = FixedDescriptor->Alignment;
+        Alignment = FixedDescriptor->getAlignment();
         NumExtraInhabitants = FixedDescriptor->NumExtraInhabitants;
+        BitwiseTakable = FixedDescriptor->isBitwiseTakable();
       } else {
         // Dynamic multi-payload enums do not have extra inhabitants
         NumExtraInhabitants = 0;
@@ -1052,7 +1112,8 @@ class EnumTypeInfoBuilder {
 
     return TC.makeTypeInfo<RecordTypeInfo>(
         Size, Alignment, Stride,
-        NumExtraInhabitants, Kind, Cases);
+        NumExtraInhabitants, BitwiseTakable,
+        Kind, Cases);
   }
 };
 
@@ -1263,10 +1324,12 @@ class LowerType
       // Destructure the existential and replace the "object"
       // field with the right reference kind.
       } else if (SubKind == RecordKind::ClassExistential) {
+        bool BitwiseTakable = RecordTI->isBitwiseTakable();
         std::vector<FieldInfo> Fields;
         for (auto &Field : RecordTI->getFields()) {
           if (Field.Name == "object") {
             auto *FieldTI = rebuildStorageTypeInfo(&Field.TI, Kind);
+            BitwiseTakable &= FieldTI->isBitwiseTakable();
             Fields.push_back({Field.Name, Field.Offset, Field.TR, *FieldTI});
             continue;
           }
@@ -1278,6 +1341,7 @@ class LowerType
             RecordTI->getAlignment(),
             RecordTI->getStride(),
             RecordTI->getNumExtraInhabitants(),
+            BitwiseTakable,
             SubKind, Fields);
       }
     }
@@ -1354,7 +1418,10 @@ const TypeInfo *TypeConverter::getClassInstanceTypeInfo(const TypeRef *TR,
 
     // Start layout from the given instance start offset. This should
     // be the superclass instance size.
-    builder.addField(start, 1, /*numExtraInhabitants=*/0);
+    builder.addField(/*size=*/start,
+                     /*alignment=*/1,
+                     /*numExtraInhabitants=*/0,
+                     /*bitwiseTakable=*/true);
 
     for (auto Field : Fields)
       builder.addField(Field.Name, Field.TR);