Metadata emission for extended existential type shapes

Author: rjmccall

include/swift/ABI/MetadataValues.h

@@ -865,7 +865,7 @@ class ExtendedExistentialTypeShapeFlags {
       (Data & ~SpecialKindMask) | (int_type(kind) << SpecialKindShift));
   }
   constexpr ExtendedExistentialTypeShapeFlags
-  withHasTypeExpresssion(bool hasTypeExpression) const {
+  withHasTypeExpression(bool hasTypeExpression) const {
     return ExtendedExistentialTypeShapeFlags(
       hasTypeExpression ? (Data | HasTypeExpression)
                         : (Data & ~HasTypeExpression));

include/swift/AST/IRGenOptions.h

@@ -189,6 +189,12 @@ struct PointerAuthOptions : clang::PointerAuthOptions {
 
   /// The swift async context entry in the extended frame info.
   PointerAuthSchema AsyncContextExtendedFrameEntry;
+
+  /// Extended existential type shapes in flight.
+  PointerAuthSchema ExtendedExistentialTypeShape;
+
+  /// Non-unique extended existential type shapes in flight.
+  PointerAuthSchema NonUniqueExtendedExistentialTypeShape;
 };
 
 enum class JITDebugArtifact : unsigned {

include/swift/IRGen/Linking.h

@@ -119,6 +119,16 @@ class LinkEntity {
     // This field appears in SILFunction.
     IsDynamicallyReplaceableImplShift = 8,
     IsDynamicallyReplaceableImplMask = ~KindMask,
+
+    // These fields appear in ExtendedExistentialTypeShape.
+    ExtendedExistentialIsUniqueShift = 8,
+    ExtendedExistentialIsUniqueMask = 0x100,
+    ExtendedExistentialIsSharedShift = 9,
+    ExtendedExistentialIsSharedMask = 0x200,
+    ExtendedExistentialMetatypeDepthShift = 10,
+    ExtendedExistentialMetatypeDepthMask =
+      ~(KindMask | ExtendedExistentialIsUniqueMask |
+        ExtendedExistentialIsSharedMask),
   };
 #define LINKENTITY_SET_FIELD(field, value) (value << field##Shift)
 #define LINKENTITY_GET_FIELD(value, field) ((value & field##Mask) >> field##Shift)
@@ -493,6 +503,11 @@ class LinkEntity {
     /// Accessible function record, which describes a function that can be
     /// looked up by name by the runtime.
     AccessibleFunctionRecord,
+
+    /// Extended existential type shape.
+    /// Pointer is the (generalized) existential type.
+    /// SecondaryPointer is the GenericSignatureImpl*.
+    ExtendedExistentialTypeShape,
   };
   friend struct llvm::DenseMapInfo<LinkEntity>;
 
@@ -1352,6 +1367,24 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity forExtendedExistentialTypeShape(CanGenericSignature genSig,
+                                                    CanExistentialType
+                                                      existentialType,
+                                                    unsigned metatypeDepth,
+                                                    bool isUnique,
+                                                    bool isShared) {
+    LinkEntity entity;
+    entity.Pointer = existentialType.getPointer();
+    entity.SecondaryPointer =
+      const_cast<GenericSignatureImpl*>(genSig.getPointer());
+    entity.Data =
+        LINKENTITY_SET_FIELD(Kind, unsigned(Kind::ExtendedExistentialTypeShape))
+      | LINKENTITY_SET_FIELD(ExtendedExistentialIsUnique, unsigned(isUnique))
+      | LINKENTITY_SET_FIELD(ExtendedExistentialIsShared, unsigned(isShared))
+      | LINKENTITY_SET_FIELD(ExtendedExistentialMetatypeDepth, metatypeDepth);
+    return entity;
+  }
+
   void mangle(llvm::raw_ostream &out) const;
   void mangle(SmallVectorImpl<char> &buffer) const;
   std::string mangleAsString() const;
@@ -1445,6 +1478,32 @@ class LinkEntity {
         SecondaryPointer);
   }
 
+  CanGenericSignature getExtendedExistentialTypeShapeGenSig() const {
+    assert(getKind() == Kind::ExtendedExistentialTypeShape);
+    return CanGenericSignature(
+             reinterpret_cast<const GenericSignatureImpl*>(SecondaryPointer));
+  }
+
+  CanExistentialType getExtendedExistentialTypeShapeType() const {
+    assert(getKind() == Kind::ExtendedExistentialTypeShape);
+    return cast<ExistentialType>(CanType(reinterpret_cast<TypeBase*>(Pointer)));
+  }
+
+  bool isExtendedExistentialTypeShapeUnique() const {
+    assert(getKind() == Kind::ExtendedExistentialTypeShape);
+    return LINKENTITY_GET_FIELD(Data, ExtendedExistentialIsUnique);
+  }
+
+  bool isExtendedExistentialTypeShapeShared() const {
+    assert(getKind() == Kind::ExtendedExistentialTypeShape);
+    return LINKENTITY_GET_FIELD(Data, ExtendedExistentialIsShared);
+  }
+
+  unsigned getExtendedExistentialTypeShapeMetatypeDepth() const {
+    assert(getKind() == Kind::ExtendedExistentialTypeShape);
+    return LINKENTITY_GET_FIELD(Data, ExtendedExistentialMetatypeDepth);
+  }
+
   bool isDynamicallyReplaceable() const {
     assert(getKind() == Kind::SILFunction);
     return LINKENTITY_GET_FIELD(Data, IsDynamicallyReplaceableImpl);

include/swift/Runtime/RuntimeFunctions.def

@@ -1076,6 +1076,36 @@ FUNCTION(GetExistentialMetadata,
          ATTRS(NoUnwind, ReadOnly, WillReturn),
          EFFECT(MetaData)) // ?
 
+// const ExtendedExistentialTypeShape *
+// swift_getExtendedExistentialTypeShape(
+//             const NonUniqueExtendedExistentialTypeShape *nonUnique);
+FUNCTION(GetExtendedExistentialTypeShape,
+         swift_getExtendedExistentialTypeShape, C_CC, AlwaysAvailable,
+         RETURNS(TypeMetadataPtrTy),
+         ARGS(Int8PtrTy, Int8PtrPtrTy),
+         ATTRS(NoUnwind, ArgMemOnly, WillReturn),
+         EFFECT(MetaData)) // ?
+
+// Metadata *swift_getExtendedExistentialTypeMetadata(
+//             const NonUniqueExtendedExistentialTypeShape *shape,
+//             const void * const *generalizationArgs);
+FUNCTION(GetExtendedExistentialTypeMetadata,
+         swift_getExtendedExistentialTypeMetadata, C_CC, AlwaysAvailable,
+         RETURNS(TypeMetadataPtrTy),
+         ARGS(Int8PtrTy, Int8PtrPtrTy),
+         ATTRS(NoUnwind, ArgMemOnly, WillReturn),
+         EFFECT(MetaData)) // ?
+
+// Metadata *swift_getExtendedExistentialTypeMetadata_unique(
+//             const ExtendedExistentialTypeShape *shape,
+//             const void * const *generalizationArgs);
+FUNCTION(GetExtendedExistentialTypeMetadataUnique,
+         swift_getExtendedExistentialTypeMetadata_unique, C_CC, AlwaysAvailable,
+         RETURNS(TypeMetadataPtrTy),
+         ARGS(Int8PtrTy, Int8PtrPtrTy),
+         ATTRS(NoUnwind, ArgMemOnly, WillReturn),
+         EFFECT(MetaData)) // ?
+
 // Metadata *swift_relocateClassMetadata(TypeContextDescriptor *descriptor,
 //                                       const void *pattern);
 FUNCTION(RelocateClassMetadata,