Implement extended existential shapes and type metadata.

The immediate use case is only concretely-constrained existential
types, which could use a much simpler representation, but I've
future-proofed the representation as much as I can; thus, the
requirement signature can have arbitrary parameters and
requirements, and the type can have an arbitrary type as the
sub-expression.  The latter is also necessary for existential
metatypes.

The chief implementation complexity here is that we must be able
to agree on the identity of an existential type that might be
produced by substitution.  Thus, for example, `any P<T>` when
`T == Int` must resolve to the same type metadata as
`any P<Int>`.  To handle this, we identify the "shape" of the
existential type, consisting of those parts which cannot possibly
be the result of substitution, and then abstract the substitutable
"holes" as an application of a generalization signature.  That
algorithm will come in a later patch; this patch just represents
it.

Uniquing existential shapes from the requirements would be quite
complex because of all the symbolic mangled names they use.
This is particularly true because it's not reasonable to require
translation units to agree about what portions they mangle vs.
reference symbolically.  Instead, we expect the compiler to do
a cryptographic hash of a mangling of the shape, then use that
as the unique key identifying the shape.

This is just the core representation and runtime interface; other
parts of the runtime, such as dynamic casting and demangling
support, will come later.

Author: rjmccall

include/swift/ABI/GenericContext.h

@@ -184,6 +184,13 @@ class TargetGenericRequirementDescriptor {
 using GenericRequirementDescriptor =
   TargetGenericRequirementDescriptor<InProcess>;
 
+/// An array of generic parameter descriptors, all
+/// GenericParamDescriptor::implicit(), which is by far
+/// the most common case.  Some generic context storage can
+/// avoid storing descriptors when they all match this pattern.
+extern const GenericParamDescriptor
+ImplicitGenericParamDescriptors[MaxNumImplicitGenericParamDescriptors];
+
 /// A runtime description of a generic signature.
 class RuntimeGenericSignature {
   GenericContextDescriptorHeader Header;

include/swift/ABI/Metadata.h

@@ -140,6 +140,10 @@ template <class T> struct FullMetadata : T::HeaderType, T {
   FullMetadata() = default;
   constexpr FullMetadata(const HeaderType &header, const T &metadata)
     : HeaderType(header), T(metadata) {}
+
+  template <class... Args>
+  constexpr FullMetadata(const HeaderType &header, Args &&...metadataArgs)
+    : HeaderType(header), T(std::forward<Args>(metadataArgs)...) {}
 };
 
 /// Given a canonical metadata pointer, produce the adjusted metadata pointer.
@@ -1571,7 +1575,14 @@ enum class ExistentialTypeRepresentation {
   Error,
 };
 
-/// The structure of existential type metadata.
+/// The structure of type metadata for simple existential types which
+/// don't require an extended existential descriptor:
+///
+/// - They are existential over a single type T.
+/// - Their head type is that type T.
+/// - Their existential constraints are a composition of protocol
+///   requirements, superclass constraints, and possibly a class
+///   layout constraint on T.
 template <typename Runtime>
 struct TargetExistentialTypeMetadata
   : TargetMetadata<Runtime>,
@@ -1689,6 +1700,357 @@ struct TargetExistentialTypeMetadata
 using ExistentialTypeMetadata
   = TargetExistentialTypeMetadata<InProcess>;
 
+/// A description of the shape of an existential type.
+///
+/// An existential type has the general form:
+///   \exists <signature> . <type>
+///
+/// The signature is called the requirement signature.  In the most
+/// common case (the only one Swift currently supports), it has exactly
+/// one type parameter.  The types and conformances required by this
+/// signature must be stored in the existential container at runtime.
+///
+/// The type is called the type (sub)expression, and it is expressed
+/// in terms of the type parameters introduced by the requirement
+/// signature.  It is required to name each of the type parameters in
+/// an identity position (outside of the base type of a member type
+/// expression).  In the most common case, it is the unique type
+/// parameter type.  Swift currently only supports existential
+/// subexpressions that are either the (unique) type parameter or
+/// a metatype thereof (possibly multiply-derived).
+///
+/// In order to efficiently support generic substitution of the
+/// constraints of existential types, extended existential type
+/// descriptors represent a generalizable form of the existential:
+///   \forall <gen sig> . \exists <req sig> . <type>
+///
+/// The new signature is called the generalization signature of the
+/// shape.  All concrete references to types within the requirement
+/// signature and head type which are not expressed in terms of
+/// the requirement signature are replaced with type parameters freshly
+/// added to the generalization signature.  Any given existential type
+/// is then a specialization of this generalization.
+///
+/// For example, the existential type
+///   \exists <T: Collection where T.Element == Int> . T
+/// is generalized as
+///   \forall <U> . \exists <T: Collection where T.Element == U> . T
+/// and is the application of this generalization at <Int>.
+///
+/// The soundness condition on this is that the generalization
+/// signatures, requirement signatures, and head types must be
+/// identical for any two existential types for which a generic
+/// substitution can carry one to the other.
+///
+/// Only particularly complex existential types are represented with
+/// an explicit existential shape.  Types which are a simple composition
+/// of layout, superclass, and unconstrained protocol constraints on
+/// an opaque or (metatype-of)+-opaque are represented with
+/// ExistentialTypeMetadata or ExistentialMetatypeMetadata.
+/// Types which *can* be represented with those classes *must*
+/// be represented with them.
+template <typename Runtime>
+struct TargetExtendedExistentialTypeShape
+  : swift::ABI::TrailingObjects<
+      TargetExtendedExistentialTypeShape<Runtime>,
+      // Optional generalization signature header
+      TargetGenericContextDescriptorHeader<Runtime>,
+      // Optional type subexpression
+      TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false>,
+      // Optional suggested value witnesses
+      TargetRelativeIndirectablePointer<Runtime, const TargetValueWitnessTable<Runtime>,
+                                        /*nullable*/ false>,
+      // Parameters for requirement signature, followed by parameters
+      // for generalization signature
+      GenericParamDescriptor,
+      // Requirements for requirement signature, followed by requirements
+      // for generalization signature
+      TargetGenericRequirementDescriptor<Runtime>> {
+private:
+  using RelativeStringPointer =
+    TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false>;
+  using RelativeValueWitnessTablePointer =
+    TargetRelativeIndirectablePointer<Runtime,
+                                      const TargetValueWitnessTable<Runtime>,
+                                      /*nullable*/ false>;
+  using TrailingObjects =
+    swift::ABI::TrailingObjects<
+      TargetExtendedExistentialTypeShape<Runtime>,
+      TargetGenericContextDescriptorHeader<Runtime>,
+      RelativeStringPointer,
+      RelativeValueWitnessTablePointer,
+      GenericParamDescriptor,
+      TargetGenericRequirementDescriptor<Runtime>>;
+  friend TrailingObjects;
+
+  template<typename T>
+  using OverloadToken = typename TrailingObjects::template OverloadToken<T>;
+
+  size_t numTrailingObjects(OverloadToken<TargetGenericContextDescriptorHeader<Runtime>>) const {
+    return Flags.hasGeneralizationSignature();
+  }
+
+  size_t numTrailingObjects(OverloadToken<RelativeStringPointer>) const {
+    return Flags.hasTypeExpression();
+  }
+
+  size_t numTrailingObjects(OverloadToken<RelativeValueWitnessTablePointer>) const {
+    return Flags.hasSuggestedValueWitnesses();
+  }
+
+  size_t numTrailingObjects(OverloadToken<GenericParamDescriptor>) const {
+    return (Flags.hasImplicitReqSigParams() ? 0 : getNumReqSigParams())
+         + (Flags.hasImplicitGenSigParams() ? 0 : getNumGenSigParams());
+  }
+
+  size_t numTrailingObjects(OverloadToken<GenericRequirementDescriptor>) const {
+    return getNumGenSigRequirements() + getNumReqSigRequirements();
+  }
+
+  const TargetGenericContextDescriptorHeader<Runtime> *
+  getGenSigHeader() const {
+    assert(hasGeneralizationSignature());
+    return this->template getTrailingObjects<
+                   TargetGenericContextDescriptorHeader<Runtime>>();
+  }
+
+public:
+  using SpecialKind = ExtendedExistentialTypeShapeFlags::SpecialKind;
+
+  /// Flags for the existential shape.
+  ExtendedExistentialTypeShapeFlags Flags;
+
+  /// The header describing the requirement signature of the existential.
+  TargetGenericContextDescriptorHeader<Runtime> ReqSigHeader;
+
+  RuntimeGenericSignature getRequirementSignature() const {
+    return {ReqSigHeader, getReqSigParams(), getReqSigRequirements()};
+  }
+
+  unsigned getNumReqSigParams() const {
+    return ReqSigHeader.NumParams;
+  }
+
+  const GenericParamDescriptor *getReqSigParams() const {
+    return Flags.hasImplicitReqSigParams()
+             ? ImplicitGenericParamDescriptors
+             : this->template getTrailingObjects<GenericParamDescriptor>();
+  }
+
+  unsigned getNumReqSigRequirements() const {
+    return ReqSigHeader.NumRequirements;
+  }
+
+  const TargetGenericRequirementDescriptor<Runtime> *
+  getReqSigRequirements() const {
+    return this->template getTrailingObjects<
+                              TargetGenericRequirementDescriptor<Runtime>>();
+  }
+
+  /// The type expression of the existential, as a symbolic mangled type
+  /// string.  Must be null if the header is just the (single)
+  /// requirement type parameter.
+  TargetPointer<Runtime, const char> getTypeExpression() const {
+    return Flags.hasTypeExpression()
+      ? this->template getTrailingObjects<RelativeStringPointer>()->get()
+      : nullptr;
+  }
+
+  bool isTypeExpressionOpaque() const {
+    return !Flags.hasTypeExpression();
+  }
+
+  /// The suggested value witness table for the existential.
+  /// Required if:
+  /// - the special kind is SpecialKind::ExplicitLayout
+  /// - the special kind is SpecialKind::None and the type head
+  ///   isn't opaque
+  TargetPointer<Runtime, const TargetValueWitnessTable<Runtime>>
+  getSuggestedValueWitnesses() const {
+    return Flags.hasSuggestedValueWitnesses()
+             ? this->template getTrailingObjects<
+                 RelativeValueWitnessTablePointer>()->get()
+             : nullptr;
+  }
+
+  /// Return the amount of space used in the existential container
+  /// for storing the existential arguments (including both the
+  /// type metadata and the conformances).
+  unsigned getContainerSignatureLayoutSizeInWords() const {
+    unsigned rawSize = ReqSigHeader.getArgumentLayoutSizeInWords();
+    switch (Flags.getSpecialKind()) {
+    // The default and explicitly-sized-value-layout cases don't optimize
+    // the storage of the signature.
+    case SpecialKind::None:
+    case SpecialKind::ExplicitLayout:
+      return rawSize;
+
+    // The class and metadata cases don't store type metadata.
+    case SpecialKind::Class:
+    case SpecialKind::Metatype:
+      // Requirement signatures won't have non-key parameters.
+      return rawSize - ReqSigHeader.NumParams;
+    }
+
+    // Assume any future cases don't optimize metadata storage.
+    return rawSize;
+  }
+
+  bool hasGeneralizationSignature() const {
+    return Flags.hasGeneralizationSignature();
+  }
+
+  RuntimeGenericSignature getGeneralizationSignature() const {
+    if (!hasGeneralizationSignature()) return RuntimeGenericSignature();
+    return {*getGenSigHeader(), getGenSigParams(), getGenSigRequirements()};
+  }
+
+  unsigned getNumGenSigParams() const {
+    return hasGeneralizationSignature()
+             ? getGenSigHeader()->NumParams : 0;
+  }
+
+  const GenericParamDescriptor *getGenSigParams() const {
+    assert(hasGeneralizationSignature());
+    if (Flags.hasImplicitGenSigParams())
+      return ImplicitGenericParamDescriptors;
+    auto base = this->template getTrailingObjects<GenericParamDescriptor>();
+    if (!Flags.hasImplicitReqSigParams())
+      base += getNumReqSigParams();
+    return base;
+  }
+
+  unsigned getNumGenSigRequirements() const {
+    return hasGeneralizationSignature()
+             ? getGenSigHeader()->NumRequirements : 0;
+  }
+
+  const TargetGenericRequirementDescriptor<Runtime> *
+  getGenSigRequirements() const {
+    assert(hasGeneralizationSignature());
+    return getReqSigRequirements() + ReqSigHeader.NumRequirements;
+  }
+
+  /// Return the amount of space used in ExtendedExistentialTypeMetadata
+  /// for this shape to store the generalization arguments.
+  unsigned getGenSigArgumentLayoutSizeInWords() const {
+    if (!hasGeneralizationSignature()) return 0;
+    return getGenSigHeader()->getArgumentLayoutSizeInWords();
+  }
+};
+using ExtendedExistentialTypeShape
+  = TargetExtendedExistentialTypeShape<InProcess>;
+
+/// A hash which is guaranteed (ignoring a weakness in the
+/// selected cryptographic hash algorithm) to be unique for the
+/// source string.  Cryptographic hashing is reasonable to use
+/// for certain kinds of complex uniquing performed by the
+/// runtime when the representation being uniqued would otherwise
+/// be prohibitively difficult to hash and compare, such as a
+/// generic signature.
+///
+/// The hash is expected to be computed at compile time and simply
+/// trusted at runtime.  We are therefore not concerned about
+/// malicious collisions: an attacker would have to control the
+/// program text, and there is nothing they can accomplish from a
+/// hash collision that they couldn't do more easily by just changing
+/// the program to do what they want.  We just want a hash with
+/// minimal chance of a birthday-problem collision.  As long as
+/// we use a cryptographic hash algorithm, even a 64-bit hash would
+/// probably do the trick just fine, since the number of objects
+/// being uniqued will be far less than 2^32.  Still, to stay on the
+/// safe side, we use a 128-bit hash; the additional 8 bytes is
+/// fairly marginal compared to the size of (e.g.) even the smallest
+/// existential shape.
+///
+/// We'd like to use BLAKE3 for this, but pending acceptance of
+/// that into LLVM, we're using SHA-256.  We simply truncaate the
+/// hash to the desired length.
+struct UniqueHash {
+  static_assert(NumBytes_UniqueHash % sizeof(uint32_t) == 0,
+                "NumBytes_UniqueHash not a multiple of 4");
+  enum { NumChunks = NumBytes_UniqueHash / sizeof(uint32_t) };
+
+  uint32_t Data[NumChunks];
+
+  friend bool operator==(const UniqueHash &lhs, const UniqueHash &rhs) {
+    for (unsigned i = 0; i != NumChunks; ++i)
+      if (lhs.Data[i] != rhs.Data[i])
+        return false;
+    return true;
+  }
+
+  friend uint32_t hash_value(const UniqueHash &hash) {
+    // It's a cryptographic hash, so there's no point in merging
+    // hash data from multiple chunks.
+    return hash.Data[0];
+  }
+};
+
+/// A descriptor for an extended existential type descriptor which
+/// needs to be uniqued at runtime.
+template <typename Runtime>
+struct TargetNonUniqueExtendedExistentialTypeShape {
+  /// A reference to memory that can be used to cache a globally-unique
+  /// descriptor for this existential shape.
+  TargetRelativeDirectPointer<Runtime,
+    std::atomic<ConstTargetMetadataPointer<Runtime,
+                  TargetExtendedExistentialTypeShape>>> UniqueCache;
+
+  /// A hash of the mangling of the existential shape.
+  ///
+  /// TODO: describe that mangling here
+  UniqueHash Hash;
+
+  /// The local copy of the existential shape descriptor.
+  TargetExtendedExistentialTypeShape<Runtime> LocalCopy;
+};
+using NonUniqueExtendedExistentialTypeShape
+  = TargetNonUniqueExtendedExistentialTypeShape<InProcess>;
+
+/// The structure of type metadata for existential types which require
+/// an extended existential descriptor.
+///
+/// An extended existential type metadata is a concrete application of
+/// an extended existential descriptor to its generalization arguments,
+/// which there may be none of.  See ExtendedExistentialDescriptor.
+template <typename Runtime>
+struct TargetExtendedExistentialTypeMetadata
+  : TargetMetadata<Runtime>,
+    swift::ABI::TrailingObjects<
+      TargetExtendedExistentialTypeMetadata<Runtime>,
+      ConstTargetPointer<Runtime, void>> {
+private:
+  using TrailingObjects =
+    swift::ABI::TrailingObjects<
+      TargetExtendedExistentialTypeMetadata<Runtime>,
+      ConstTargetPointer<Runtime, void>>;
+  friend TrailingObjects;
+
+  template<typename T>
+  using OverloadToken = typename TrailingObjects::template OverloadToken<T>;
+
+  size_t numTrailingObjects(OverloadToken<ConstTargetPointer<Runtime, void>>) const {
+    return Shape->getGenSigLayoutSizeInWords();
+  }
+
+public:
+  explicit constexpr
+  TargetExtendedExistentialTypeMetadata(const ExtendedExistentialTypeShape *shape)
+    : TargetMetadata<Runtime>(MetadataKind::ExtendedExistential),
+      Shape(shape) {}
+
+  TargetSignedPointer<Runtime, const ExtendedExistentialTypeShape *
+                    __ptrauth_swift_nonunique_extended_existential_type_shape>
+    Shape;
+
+  ConstTargetPointer<Runtime, void> const *getGeneralizationArguments() const {
+    return this->template getTrailingObjects<ConstTargetPointer<Runtime, void>>();
+  }
+};
+using ExtendedExistentialTypeMetadata
+  = TargetExtendedExistentialTypeMetadata<InProcess>;
+
 /// The basic layout of an existential metatype type.
 template <typename Runtime>
 struct TargetExistentialMetatypeContainer {