Merge pull request #3285 from slavapestov/multi-payload-enum-reflection

Author: swift-ci

include/swift/Reflection/Records.h

@@ -111,6 +111,14 @@ enum class FieldDescriptorKind : uint16_t {
   Class,
   Enum,
 
+  // Fixed-size multi-payload enums have a special descriptor format that
+  // encodes spare bits.
+  //
+  // FIXME: Actually implement this. For now, a descriptor with this kind
+  // just means we also have a builtin descriptor from which we get the
+  // size and alignment.
+  MultiPayloadEnum,
+
   // A Swift opaque protocol. There are no fields, just a record for the
   // type itself.
   Protocol,
@@ -145,6 +153,22 @@ class FieldDescriptor {
 
   using const_iterator = FieldRecordIterator;
 
+  bool isEnum() const {
+    return (Kind == FieldDescriptorKind::Enum ||
+            Kind == FieldDescriptorKind::MultiPayloadEnum);
+  }
+
+  bool isClass() const {
+    return (Kind == FieldDescriptorKind::Class ||
+            Kind == FieldDescriptorKind::ObjCClass);
+  }
+
+  bool isProtocol() const {
+    return (Kind == FieldDescriptorKind::Protocol ||
+            Kind == FieldDescriptorKind::ClassProtocol ||
+            Kind == FieldDescriptorKind::ObjCProtocol);
+  }
+
   const_iterator begin() const {
     auto Begin = getFieldRecordBuffer();
     auto End = Begin + NumFields;

include/swift/Reflection/TypeLowering.h

@@ -36,11 +36,17 @@ class BuiltinTypeDescriptor;
 
 // Defined in TypeLowering.cpp, not public -- they're friends below
 class LowerType;
+class EnumTypeInfoBuilder;
 class RecordTypeInfoBuilder;
 class ExistentialTypeInfoBuilder;
 
 enum class RecordKind : unsigned {
+  Invalid,
+
+  // A Swift tuple type.
   Tuple,
+
+  // A Swift struct type.
   Struct,
 
   // An enum with no payload cases. The record will have no fields, but
@@ -51,6 +57,10 @@ enum class RecordKind : unsigned {
   // field, being the enum payload.
   SinglePayloadEnum,
 
+  // An enum with multiple payload cases. The record consists of a multiple
+  // fields, one for each enum payload.
+  MultiPayloadEnum,
+
   // A Swift-native function is always a function pointer followed by a
   // retainable, nullable context pointer.
   ThickFunction,
@@ -237,6 +247,7 @@ class TypeConverter {
 
 private:
   friend class swift::reflection::LowerType;
+  friend class swift::reflection::EnumTypeInfoBuilder;
   friend class swift::reflection::RecordTypeInfoBuilder;
   friend class swift::reflection::ExistentialTypeInfoBuilder;
 
@@ -272,15 +283,15 @@ class TypeConverter {
 /// tuples, structs, thick functions, etc.
 class RecordTypeInfoBuilder {
   TypeConverter &TC;
-  unsigned Size, Alignment, Stride, NumExtraInhabitants;
+  unsigned Size, Alignment, NumExtraInhabitants;
   RecordKind Kind;
   std::vector<FieldInfo> Fields;
   bool Empty;
   bool Invalid;
 
 public:
   RecordTypeInfoBuilder(TypeConverter &TC, RecordKind Kind)
-    : TC(TC), Size(0), Alignment(1), Stride(0), NumExtraInhabitants(0),
+    : TC(TC), Size(0), Alignment(1), NumExtraInhabitants(0),
       Kind(Kind), Empty(true), Invalid(false) {}
 
   bool isInvalid() const {
@@ -289,7 +300,10 @@ class RecordTypeInfoBuilder {
 
   unsigned addField(unsigned fieldSize, unsigned fieldAlignment,
                     unsigned numExtraInhabitants);
+
+  // Add a field of a record type, such as a struct.
   void addField(const std::string &Name, const TypeRef *TR);
+
   const RecordTypeInfo *build();
 
   unsigned getNumFields() const {
@@ -299,13 +313,6 @@ class RecordTypeInfoBuilder {
   unsigned getFieldOffset(unsigned Index) const {
     return Fields[Index].Offset;
   }
-
-  void setNumExtraInhabitants(unsigned numExtraInhabitants) {
-    // We can only take away extra inhabitants while performing
-    // record layout, never add new ones.
-    assert(numExtraInhabitants <= NumExtraInhabitants);
-    NumExtraInhabitants = numExtraInhabitants;
-  }
 };
 
 }

include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -72,6 +72,10 @@ typedef enum swift_layout_kind {
   // field, being the enum payload.
   SWIFT_SINGLE_PAYLOAD_ENUM,
 
+  // An enum with multiple payload cases. The record consists of a multiple
+  // fields, one for each enum payload.
+  SWIFT_MULTI_PAYLOAD_ENUM,
+
   SWIFT_THICK_FUNCTION,
 
   SWIFT_OPAQUE_EXISTENTIAL,

lib/IRGen/GenEnum.h

@@ -173,10 +173,10 @@ class EnumImplStrategy {
   /// storage type, calculates its size and alignment, and produces the
   /// TypeInfo for the enum.
   virtual TypeInfo *completeEnumTypeLayout(TypeConverter &TC,
-                                            SILType Type,
-                                            EnumDecl *theEnum,
-                                            llvm::StructType *enumTy) = 0;
-  
+                                           SILType Type,
+                                           EnumDecl *theEnum,
+                                           llvm::StructType *enumTy) = 0;
+
   const TypeInfo &getTypeInfo() const {
     assert(TI);
     return *TI;

lib/IRGen/GenMeta.cpp

@@ -5677,6 +5677,9 @@ namespace {
 /// the protocol descriptor, and for ObjC interop, references to the descriptor
 /// that the ObjC runtime uses for uniquing.
 void IRGenModule::emitProtocolDecl(ProtocolDecl *protocol) {
+  // Emit remote reflection metadata for the protocol.
+  emitFieldMetadataRecord(protocol);
+
   // If the protocol is Objective-C-compatible, go through the path that
   // produces an ObjC-compatible protocol_t.
   if (protocol->isObjC()) {
@@ -5706,8 +5709,6 @@ void IRGenModule::emitProtocolDecl(ProtocolDecl *protocol) {
                                                    init->getType()));
   var->setConstant(true);
   var->setInitializer(init);
-
-  emitFieldMetadataRecord(protocol);
 }
 
 /// \brief Load a reference to the protocol descriptor for the given protocol.

lib/IRGen/GenReflection.cpp

@@ -197,7 +197,7 @@ class ReflectionMetadataBuilder : public ConstantBuilder<> {
           else if (auto PD = dyn_cast<ProtocolDecl>(Nominal))
             IGM.ImportedProtocols.insert(PD);
           else
-            IGM.BuiltinTypes.insert(CanType(t));
+            IGM.OpaqueTypes.insert(Nominal);
         }
     });
   }
@@ -352,7 +352,18 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
         IGM, enumDecl->getDeclaredTypeInContext()
                      ->getCanonicalType());
 
-    addConstantInt16(uint16_t(FieldDescriptorKind::Enum));
+    auto kind = FieldDescriptorKind::Enum;
+
+    // If this is a fixed-size multi-payload enum, we have to emit a descriptor
+    // with the size and alignment of the type, because the reflection library
+    // cannot derive this information at runtime.
+    if (strategy.getElementsWithPayload().size() > 1 &&
+        !strategy.needsPayloadSizeInMetadata()) {
+      kind = FieldDescriptorKind::MultiPayloadEnum;
+      IGM.OpaqueTypes.insert(enumDecl);
+    }
+
+    addConstantInt16(uint16_t(kind));
     addConstantInt16(fieldRecordSize);
     addConstantInt32(strategy.getElementsWithPayload().size() +
                      strategy.getElementsWithNoPayload().size());
@@ -448,25 +459,40 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
   }
 };
 
-class BuiltinTypeMetadataBuilder : public ReflectionMetadataBuilder {
-  void addBuiltinType(CanType builtinType) {
-    addTypeRef(builtinType->getASTContext().TheBuiltinModule, builtinType);
+class FixedTypeMetadataBuilder : public ReflectionMetadataBuilder {
+  void addFixedType(Module *module, CanType type,
+                    const FixedTypeInfo &ti) {
+    addTypeRef(module, type);
 
-    auto &ti = cast<FixedTypeInfo>(IGM.getTypeInfoForUnlowered(builtinType));
     addConstantInt32(ti.getFixedSize().getValue());
     addConstantInt32(ti.getFixedAlignment().getValue());
     addConstantInt32(ti.getFixedStride().getValue());
     addConstantInt32(ti.getFixedExtraInhabitantCount(IGM));
   }
 
+  void addBuiltinType(CanType builtinType) {
+    auto &ti = cast<FixedTypeInfo>(IGM.getTypeInfoForUnlowered(builtinType));
+    addFixedType(builtinType->getASTContext().TheBuiltinModule, builtinType, ti);
+  }
+
+  void addOpaqueType(const NominalTypeDecl *nominalDecl) {
+    auto &ti = cast<FixedTypeInfo>(IGM.getTypeInfoForUnlowered(
+        nominalDecl->getDeclaredTypeInContext()->getCanonicalType()));
+
+    addFixedType(nominalDecl->getParentModule(),
+                 nominalDecl->getDeclaredType()->getCanonicalType(), ti);
+  }
+
   void layout() {
-    for (auto builtinType : IGM.BuiltinTypes) {
+    for (auto builtinType : IGM.BuiltinTypes)
       addBuiltinType(builtinType);
-    }
+
+    for (auto nominalDecl : IGM.OpaqueTypes)
+      addOpaqueType(nominalDecl);
   }
 
 public:
-  BuiltinTypeMetadataBuilder(IRGenModule &IGM)
+  FixedTypeMetadataBuilder(IRGenModule &IGM)
     : ReflectionMetadataBuilder(IGM) {}
 
   llvm::GlobalVariable *emit() {
@@ -889,7 +915,7 @@ void IRGenModule::emitBuiltinReflectionMetadata() {
   for (auto PD : ImportedProtocols)
     emitFieldMetadataRecord(PD);
 
-  BuiltinTypeMetadataBuilder builder(*this);
+  FixedTypeMetadataBuilder builder(*this);
   auto var = builder.emit();
   if (var)
     addUsedGlobal(var);

lib/IRGen/IRGenModule.h

@@ -719,12 +719,17 @@ class IRGenModule {
   /// Builtin types referenced by types in this module when emitting
   /// reflection metadata.
   llvm::SetVector<CanType> BuiltinTypes;
+  /// Opaque but fixed-size types for which we also emit builtin type
+  /// descriptors, allowing the reflection library to layout these types
+  /// without knowledge of their contents. This includes imported structs
+  /// and fixed-size multi-payload enums.
+  llvm::SetVector<const NominalTypeDecl *> OpaqueTypes;
   /// Imported classes referenced by types in this module when emitting
   /// reflection metadata.
-  llvm::SetVector<ClassDecl *> ImportedClasses;
+  llvm::SetVector<const ClassDecl *> ImportedClasses;
   /// Imported protocols referenced by types in this module when emitting
   /// reflection metadata.
-  llvm::SetVector<ProtocolDecl *> ImportedProtocols;
+  llvm::SetVector<const ProtocolDecl *> ImportedProtocols;
 
   llvm::Constant *getAddrOfStringForTypeRef(StringRef Str);
   llvm::Constant *getAddrOfFieldName(StringRef Name);