Merge pull request #63961 from slavapestov/variadic-generic-types-plumbing

Start working on runtime support for variadic generic types

Author: slavapestov

include/swift/ABI/GenericContext.h

@@ -30,6 +30,38 @@ struct TargetProtocolConformanceDescriptor;
 template <typename Runtime>
 struct TargetGenericContext;
 
+class GenericContextDescriptorFlags {
+  uint16_t Value;
+
+public:
+  constexpr GenericContextDescriptorFlags() : Value(0) {}
+
+  explicit constexpr GenericContextDescriptorFlags(uint16_t value)
+    : Value(value) {}
+
+  constexpr GenericContextDescriptorFlags(bool hasTypePacks)
+    : GenericContextDescriptorFlags(
+        GenericContextDescriptorFlags((uint16_t)0)
+          .withHasTypePacks(hasTypePacks)) {}
+
+  /// Whether this generic context has at least one type parameter
+  /// pack, in which case the generic context will have a trailing
+  /// GenericParamPackShapeHeader.
+  constexpr bool hasTypePacks() const {
+    return (Value & 0x1) != 0;
+  }
+
+  constexpr GenericContextDescriptorFlags
+  withHasTypePacks(bool hasTypePacks) const {
+    return GenericContextDescriptorFlags((uint16_t)(
+      (Value & ~0x1) | (hasTypePacks ? 0x1 : 0)));
+  }
+
+  constexpr uint16_t getIntValue() const {
+    return Value;
+  }
+};
+
 template <typename Runtime>
 struct TargetGenericContextDescriptorHeader {
   /// The number of (source-written) generic parameters, and thus
@@ -39,8 +71,8 @@ struct TargetGenericContextDescriptorHeader {
   ///
   /// A GenericParamDescriptor corresponds to a type metadata pointer
   /// in the arguments layout when isKeyArgument() is true.
-  /// isKeyArgument() will be false if the parameter has been unified
-  /// unified with a different parameter or an associated type.
+  /// isKeyArgument() will be false if the parameter has been made
+  /// equivalent to a different parameter or a concrete type.
   uint16_t NumParams;
 
   /// The number of GenericRequirementDescriptors in this generic
@@ -66,18 +98,22 @@ struct TargetGenericContextDescriptorHeader {
   /// hasKeyArgument()).
   uint16_t NumKeyArguments;
 
-  /// In principle, the size of the "extra" area of the argument
+  /// Originally this was the size of the "extra" area of the argument
   /// layout, in words.  The idea was that extra arguments would
   /// include generic parameters and conformances that are not part
   /// of the identity of the context; however, it's unclear why we
-  /// would ever want such a thing.  As a result, this section is
-  /// unused, and this field is always zero.  It can be repurposed
-  /// as long as it remains zero in code which must be compatible
-  /// with existing Swift runtimes.
-  uint16_t NumExtraArguments;
+  /// would ever want such a thing.  As a result, in pre-5.8 runtimes
+  /// this field is always zero.  New flags can only be added as long
+  /// as they remains zero in code which must be compatible with
+  /// older Swift runtimes.
+  GenericContextDescriptorFlags Flags;
 
   uint32_t getNumArguments() const {
-    return NumKeyArguments + NumExtraArguments;
+    // Note: this used to be NumKeyArguments + NumExtraArguments,
+    // and flags was named NumExtraArguments, which is why Flags
+    // must remain zero when backward deploying to Swift 5.7 or
+    // earlier.
+    return NumKeyArguments;
   }
 
   /// Return the total size of the argument layout, in words.
@@ -163,7 +199,7 @@ class TargetGenericRequirementDescriptor {
     return offsetof(typename std::remove_reference<decltype(*this)>::type, Type);
   }
 
-  /// Retreive the offset to the Type field
+  /// Retreive the offset to the Param field
   constexpr inline auto
   getParamOffset() const -> typename Runtime::StoredSize {
     return offsetof(typename std::remove_reference<decltype(*this)>::type, Param);
@@ -199,6 +235,7 @@ class TargetGenericRequirementDescriptor {
     case GenericRequirementKind::Protocol:
     case GenericRequirementKind::SameConformance:
     case GenericRequirementKind::SameType:
+    case GenericRequirementKind::SameShape:
       return true;
     }
 
@@ -208,6 +245,25 @@ class TargetGenericRequirementDescriptor {
 using GenericRequirementDescriptor =
   TargetGenericRequirementDescriptor<InProcess>;
 
+struct GenericParamPackShapeHeader {
+  /// The number of generic parameters which are packs.
+  ///
+  /// Must equal the number of GenericParamDescriptors whose kind is
+  /// GenericParamKind::TypePack.
+  uint16_t NumTypePacks;
+
+  /// The number of equivalence classes in the same-shape relation.
+  uint16_t NumShapeClasses;
+};
+
+struct GenericParamPackShapeDescriptor {
+  /// The equivalence class of this generic parameter pack under
+  /// the same-shape relation.
+  ///
+  /// Must be less than GenericParamPackShapeHeader::NumShapeClasses.
+  uint16_t ShapeClass;
+};
+
 /// An array of generic parameter descriptors, all
 /// GenericParamDescriptor::implicit(), which is by far
 /// the most common case.  Some generic context storage can
@@ -243,14 +299,21 @@ class RuntimeGenericSignature {
   TargetGenericContextDescriptorHeader<Runtime> Header;
   const GenericParamDescriptor *Params;
   const TargetGenericRequirementDescriptor<Runtime> *Requirements;
+  GenericParamPackShapeHeader PackShapeHeader;
+  const GenericParamPackShapeDescriptor *PackShapeDescriptors;
+
 public:
   RuntimeGenericSignature()
-    : Header{0, 0, 0, 0}, Params(nullptr), Requirements(nullptr) {}
+    : Header{0, 0, 0, 0}, Params(nullptr), Requirements(nullptr),
+      PackShapeHeader{0, 0}, PackShapeDescriptors(nullptr) {}
 
   RuntimeGenericSignature(const TargetGenericContextDescriptorHeader<Runtime> &header,
                           const GenericParamDescriptor *params,
-                          const TargetGenericRequirementDescriptor<Runtime> *requirements)
-    : Header(header), Params(params), Requirements(requirements) {}
+                          const TargetGenericRequirementDescriptor<Runtime> *requirements,
+                          const GenericParamPackShapeHeader &packShapeHeader,
+                          const GenericParamPackShapeDescriptor *packShapeDescriptors)
+    : Header(header), Params(params), Requirements(requirements),
+      PackShapeHeader(packShapeHeader), PackShapeDescriptors(packShapeDescriptors) {}
 
   llvm::ArrayRef<GenericParamDescriptor> getParams() const {
     return llvm::makeArrayRef(Params, Header.NumParams);
@@ -260,6 +323,10 @@ class RuntimeGenericSignature {
     return llvm::makeArrayRef(Requirements, Header.NumRequirements);
   }
 
+  llvm::ArrayRef<GenericParamPackShapeDescriptor> getPackShapeDescriptors() const {
+    return llvm::makeArrayRef(PackShapeDescriptors, PackShapeHeader.NumTypePacks);
+  }
+
   size_t getArgumentLayoutSizeInWords() const {
     return Header.getArgumentLayoutSizeInWords();
   }
@@ -350,6 +417,8 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
       TargetGenericContextHeaderType<Runtime>,
       GenericParamDescriptor,
       TargetGenericRequirementDescriptor<Runtime>,
+      GenericParamPackShapeHeader,
+      GenericParamPackShapeDescriptor,
       FollowingTrailingObjects...>
 {
 protected:
@@ -362,6 +431,8 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     GenericContextHeaderType,
     GenericParamDescriptor,
     GenericRequirementDescriptor,
+    GenericParamPackShapeHeader,
+    GenericParamPackShapeDescriptor,
     FollowingTrailingObjects...>;
   friend TrailingObjects;
 
@@ -415,6 +486,23 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     return {this->template getTrailingObjects<GenericRequirementDescriptor>(),
             getGenericContextHeader().NumRequirements};
   }
+  
+  GenericParamPackShapeHeader getGenericParamPackShapeHeader() const {
+    if (!asSelf()->isGeneric())
+      return {0, 0};
+    if (!getGenericContextHeader().Flags.hasTypePacks())
+      return {0, 0};
+    return *this->template getTrailingObjects<GenericParamPackShapeHeader>();
+  }
+
+  llvm::ArrayRef<GenericParamPackShapeDescriptor> getGenericParamPackShapeDescriptors() const {
+    auto header = getGenericParamPackShapeHeader();
+    if (header.NumTypePacks == 0)
+      return {};
+
+    return {this->template getTrailingObjects<GenericParamPackShapeDescriptor>(),
+            header.NumTypePacks};
+  }
 
   /// Return the amount of space that the generic arguments take up in
   /// metadata of this type.
@@ -427,7 +515,9 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     if (!asSelf()->isGeneric()) return RuntimeGenericSignature<Runtime>();
     return {getGenericContextHeader(),
             getGenericParams().data(),
-            getGenericRequirements().data()};
+            getGenericRequirements().data(),
+            getGenericParamPackShapeHeader(),
+            getGenericParamPackShapeDescriptors().data()};
   }
 
 protected:
@@ -443,6 +533,23 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     return asSelf()->isGeneric() ? getGenericContextHeader().NumRequirements : 0;
   }
 
+  size_t numTrailingObjects(OverloadToken<GenericParamPackShapeHeader>) const {
+    if (!asSelf()->isGeneric())
+      return 0;
+
+    return getGenericContextHeader().Flags.hasTypePacks() ? 1 : 0;
+  }
+
+  size_t numTrailingObjects(OverloadToken<GenericParamPackShapeDescriptor>) const {
+    if (!asSelf()->isGeneric())
+      return 0;
+
+    if (!getGenericContextHeader().Flags.hasTypePacks())
+      return 0;
+
+    return getGenericParamPackShapeHeader().NumTypePacks;
+  }
+
 #if defined(_MSC_VER) && _MSC_VER < 1920
 #undef OverloadToken
 #endif

include/swift/ABI/Metadata.h

@@ -1929,7 +1929,13 @@ struct TargetExtendedExistentialTypeShape
       GenericParamDescriptor,
       // Requirements for requirement signature, followed by requirements
       // for generalization signature
-      TargetGenericRequirementDescriptor<Runtime>> {
+      TargetGenericRequirementDescriptor<Runtime>,
+      // Optional header describing any type packs in the generalization
+      // signature.
+      GenericParamPackShapeHeader,
+      // For each type pack in the generalization signature, a descriptor
+      // storing the shape class.
+      GenericParamPackShapeDescriptor> {
 private:
   using RelativeValueWitnessTablePointer =
     TargetRelativeIndirectablePointer<Runtime,
@@ -1942,7 +1948,9 @@ struct TargetExtendedExistentialTypeShape
       TargetExistentialTypeExpression<Runtime>,
       RelativeValueWitnessTablePointer,
       GenericParamDescriptor,
-      TargetGenericRequirementDescriptor<Runtime>>;
+      TargetGenericRequirementDescriptor<Runtime>,
+      GenericParamPackShapeHeader,
+      GenericParamPackShapeDescriptor>;
   friend TrailingObjects;
 
   template<typename T>
@@ -1965,10 +1973,21 @@ struct TargetExtendedExistentialTypeShape
          + (Flags.hasImplicitGenSigParams() ? 0 : getNumGenSigParams());
   }
 
-  size_t numTrailingObjects(OverloadToken<GenericRequirementDescriptor>) const {
+  size_t numTrailingObjects(OverloadToken<TargetGenericRequirementDescriptor<Runtime>>) const {
     return getNumGenSigRequirements() + getNumReqSigRequirements();
   }
 
+  size_t numTrailingObjects(OverloadToken<GenericParamPackShapeHeader>) const {
+    return (Flags.hasTypePacks() ? 1 : 0);
+  }
+
+  size_t numTrailingObjects(OverloadToken<GenericParamPackShapeDescriptor>) const {
+    if (!Flags.hasTypePacks())
+      return 0;
+
+    return getGenSigPackShapeHeader().NumTypePacks;
+  }
+
   const TargetGenericContextDescriptorHeader<Runtime> *
   getGenSigHeader() const {
     assert(hasGeneralizationSignature());
@@ -2013,7 +2032,8 @@ struct TargetExtendedExistentialTypeShape
   TargetGenericContextDescriptorHeader<Runtime> ReqSigHeader;
 
   RuntimeGenericSignature<Runtime> getRequirementSignature() const {
-    return {ReqSigHeader, getReqSigParams(), getReqSigRequirements()};
+    return {ReqSigHeader, getReqSigParams(), getReqSigRequirements(),
+            {0, 0}, nullptr};
   }
 
   unsigned getNumReqSigParams() const {
@@ -2092,7 +2112,8 @@ struct TargetExtendedExistentialTypeShape
 
   RuntimeGenericSignature<Runtime> getGeneralizationSignature() const {
     if (!hasGeneralizationSignature()) return RuntimeGenericSignature<Runtime>();
-    return {*getGenSigHeader(), getGenSigParams(), getGenSigRequirements()};
+    return {*getGenSigHeader(), getGenSigParams(), getGenSigRequirements(),
+            getGenSigPackShapeHeader(), getGenSigPackShapeDescriptors()};
   }
 
   unsigned getNumGenSigParams() const {
@@ -2121,6 +2142,20 @@ struct TargetExtendedExistentialTypeShape
     return getReqSigRequirements() + ReqSigHeader.NumRequirements;
   }
 
+  GenericParamPackShapeHeader getGenSigPackShapeHeader() const {
+    assert(hasGeneralizationSignature());
+    if (!Flags.hasTypePacks())
+      return {0, 0};
+    return *this->template getTrailingObjects<GenericParamPackShapeHeader>();
+  }
+
+  const GenericParamPackShapeDescriptor *getGenSigPackShapeDescriptors() const {
+    assert(hasGeneralizationSignature());
+    if (!Flags.hasTypePacks())
+      return nullptr;
+    return this->template getTrailingObjects<GenericParamPackShapeDescriptor>();
+  }
+
   /// Return the amount of space used in ExtendedExistentialTypeMetadata
   /// for this shape to store the generalization arguments.
   unsigned getGenSigArgumentLayoutSizeInWords() const {
@@ -4863,6 +4898,57 @@ class RuntimeDiscoverableAttributeRecord
   }
 };
 
+enum class PackLifetime : uint8_t {
+  OnStack = 0,
+  OnHeap = 1
+};
+
+/// A pointer to a metadata or witness table pack. If the LSB is set,
+/// the pack is allocated on the heap; otherwise, it is allocated on
+/// the stack.
+template<typename Runtime, template <typename> class Pointee>
+class TargetPackPointer {
+  typename Runtime::StoredSize Ptr;
+
+  using PointerType = typename Runtime::template Pointer<const Pointee<Runtime>>;
+
+public:
+  explicit TargetPackPointer(typename Runtime::StoredSize rawPtr) : Ptr(rawPtr) {}
+
+  explicit TargetPackPointer(PointerType const *ptr, PackLifetime lifetime)
+    : Ptr(reinterpret_cast<typename Runtime::StoredSize>(ptr) |
+          (lifetime == PackLifetime::OnHeap ? 1 : 0)) {}
+
+  const PointerType *getElements() const {
+    return reinterpret_cast<const PointerType *>(Ptr & ~1);
+  }
+
+  PointerType *getElements() {
+    return reinterpret_cast<PointerType *>(Ptr & ~1);
+  }
+
+  const PointerType *getPointer() const {
+    return reinterpret_cast<const PointerType *>(Ptr);
+  }
+
+
+  PackLifetime getLifetime() const {
+    return (bool)(Ptr & 1) ? PackLifetime::OnHeap : PackLifetime::OnStack;
+  }
+};
+
+/// A pointer to a metadata pack.
+template<typename Runtime>
+using TargetMetadataPackPointer = TargetPackPointer<Runtime, TargetMetadata>;
+
+using MetadataPackPointer = TargetMetadataPackPointer<InProcess>;
+
+/// A pointer to a witness table pack.
+template<typename Runtime>
+using TargetWitnessTablePackPointer = TargetPackPointer<Runtime, TargetWitnessTable>;
+
+using WitnessTablePackPointer = TargetWitnessTablePackPointer<InProcess>;
+
 } // end namespace swift
 
 #pragma clang diagnostic pop