For individual runtime records for types/protocols/conformances, add and use new mangling suffixes

Author: kubamracek

docs/ABI/Mangling.rst

@@ -137,6 +137,13 @@ Globals
   global ::= type assoc-type-list 'MXA'  // generic parameter ref (HISTORICAL)
   global ::= protocol 'Mp'               // protocol descriptor
 
+  global ::= protocol 'Hr'               // protocol descriptor runtime record
+  global ::= nominal-type 'Hn'           // nominal type descriptor runtime record
+  #if SWIFT_RUNTIME_VERSION >= 5.1
+    global ::= opaque-type 'Ho'          // opaque type descriptor runtime record
+  #endif
+  global ::= protocol-conformance 'Hc'   // protocol conformance runtime record
+
   global ::= nominal-type 'Mo'           // class metadata immediate member base offset
 
   global ::= type 'MF'                   // metadata for remote mirrors: field descriptor

include/swift/AST/ASTMangler.h

@@ -252,6 +252,8 @@ class ASTMangler : public Mangler {
   std::string mangleTypeForTypeName(Type type);
 
   std::string mangleOpaqueTypeDescriptor(const OpaqueTypeDecl *decl);
+
+  std::string mangleOpaqueTypeDescriptorRecord(const OpaqueTypeDecl *decl);
 
   std::string mangleDeclType(const ValueDecl *decl);
 

include/swift/Demangling/DemangleNodes.def

@@ -157,6 +157,7 @@ CONTEXT_NODE(NativeOwningMutableAddressor)
 CONTEXT_NODE(NativePinningAddressor)
 CONTEXT_NODE(NativePinningMutableAddressor)
 NODE(NominalTypeDescriptor)
+NODE(NominalTypeDescriptorRecord)
 NODE(NonObjCAttribute)
 NODE(Number)
 NODE(ObjCAsyncCompletionHandlerImpl)
@@ -182,7 +183,9 @@ NODE(ProtocolConformanceRefInTypeModule)
 NODE(ProtocolConformanceRefInProtocolModule)
 NODE(ProtocolConformanceRefInOtherModule)
 NODE(ProtocolDescriptor)
+NODE(ProtocolDescriptorRecord)
 NODE(ProtocolConformanceDescriptor)
+NODE(ProtocolConformanceDescriptorRecord)
 NODE(ProtocolList)
 NODE(ProtocolListWithClass)
 NODE(ProtocolListWithAnyObject)
@@ -289,6 +292,7 @@ NODE(AccessorFunctionReference)
 NODE(OpaqueType)
 NODE(OpaqueTypeDescriptorSymbolicReference)
 NODE(OpaqueTypeDescriptor)
+NODE(OpaqueTypeDescriptorRecord)
 NODE(OpaqueTypeDescriptorAccessor)
 NODE(OpaqueTypeDescriptorAccessorImpl)
 NODE(OpaqueTypeDescriptorAccessorKey)

include/swift/IRGen/Linking.h

@@ -218,10 +218,18 @@ class LinkEntity {
     /// The pointer is a NominalTypeDecl*.
     NominalTypeDescriptor,
 
+    /// The nominal type descriptor runtime record for a nominal type.
+    /// The pointer is a NominalTypeDecl*.
+    NominalTypeDescriptorRecord,
+
     /// The descriptor for an opaque type.
     /// The pointer is an OpaqueTypeDecl*.
     OpaqueTypeDescriptor,
 
+    /// The runtime record for a descriptor for an opaque type.
+    /// The pointer is an OpaqueTypeDecl*.
+    OpaqueTypeDescriptorRecord,
+
     /// The descriptor accessor for an opaque type used for dynamic functions.
     /// The pointer is an OpaqueTypeDecl*.
     OpaqueTypeDescriptorAccessor,
@@ -268,6 +276,10 @@ class LinkEntity {
     /// The pointer is a ProtocolDecl*.
     ProtocolDescriptor,
 
+    /// The protocol descriptor runtime record for a protocol type.
+    /// The pointer is a ProtocolDecl*.
+    ProtocolDescriptorRecord,
+
     /// The alias referring to the base of the requirements within the
     /// protocol descriptor, which is used to determine the offset of a
     /// particular requirement in the witness table.
@@ -368,6 +380,10 @@ class LinkEntity {
     /// The pointer is a RootProtocolConformance*.
     ProtocolConformanceDescriptor,
 
+    /// The protocol conformance descriptor runtime record for a conformance.
+    /// The pointer is a RootProtocolConformance*.
+    ProtocolConformanceDescriptorRecord,
+
     // These are both type kinds and protocol-conformance kinds.
 
     /// A lazy protocol witness accessor function. The pointer is a
@@ -477,6 +493,7 @@ class LinkEntity {
 
   static bool isRootProtocolConformanceKind(Kind k) {
     return (k == Kind::ProtocolConformanceDescriptor ||
+            k == Kind::ProtocolConformanceDescriptorRecord ||
             k == Kind::ProtocolWitnessTable);
   }
 
@@ -830,12 +847,24 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity forNominalTypeDescriptorRecord(NominalTypeDecl *decl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::NominalTypeDescriptorRecord, decl);
+    return entity;
+  }
+
   static LinkEntity forOpaqueTypeDescriptor(OpaqueTypeDecl *decl) {
     LinkEntity entity;
     entity.setForDecl(Kind::OpaqueTypeDescriptor, decl);
     return entity;
   }
 
+  static LinkEntity forOpaqueTypeDescriptorRecord(OpaqueTypeDecl *decl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::OpaqueTypeDescriptorRecord, decl);
+    return entity;
+  }
+
   static LinkEntity forOpaqueTypeDescriptorAccessor(OpaqueTypeDecl *decl) {
     LinkEntity entity;
     entity.setForDecl(Kind::OpaqueTypeDescriptorAccessor, decl);
@@ -898,6 +927,12 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity forProtocolDescriptorRecord(ProtocolDecl *decl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::ProtocolDescriptorRecord, decl);
+    return entity;
+  }
+
   static LinkEntity forProtocolRequirementsBaseDescriptor(ProtocolDecl *decl) {
     LinkEntity entity;
     entity.setForDecl(Kind::ProtocolRequirementsBaseDescriptor, decl);
@@ -1066,6 +1101,14 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity
+  forProtocolConformanceDescriptorRecord(const RootProtocolConformance *C) {
+    LinkEntity entity;
+    entity.setForProtocolConformance(Kind::ProtocolConformanceDescriptorRecord,
+                                     C);
+    return entity;
+  }
+
   static LinkEntity forCoroutineContinuationPrototype(CanSILFunctionType type) {
     LinkEntity entity;
     entity.setForType(Kind::CoroutineContinuationPrototype, type);

lib/AST/ASTMangler.cpp

@@ -3330,3 +3330,11 @@ std::string ASTMangler::mangleOpaqueTypeDescriptor(const OpaqueTypeDecl *decl) {
   appendOperator("MQ");
   return finalize();
 }
+
+std::string
+ASTMangler::mangleOpaqueTypeDescriptorRecord(const OpaqueTypeDecl *decl) {
+  beginMangling();
+  appendOpaqueDeclName(decl);
+  appendOperator("Ho");
+  return finalize();
+}

lib/Demangling/Demangler.cpp

@@ -793,6 +793,18 @@ NodePointer Demangler::demangleOperator() {
       case 'p':
         return createWithChild(
             Node::Kind::ProtocolConformanceRefInProtocolModule, popProtocol());
+
+      // Runtime records (type/protocol/conformance)
+      case 'c':
+        return createWithChild(Node::Kind::ProtocolConformanceDescriptorRecord,
+                               popProtocolConformance());
+      case 'n':
+        return createWithPoppedType(Node::Kind::NominalTypeDescriptorRecord);
+      case 'o': // XXX
+        return createWithChild(Node::Kind::OpaqueTypeDescriptorRecord, popNode());
+      case 'r':
+        return createWithChild(Node::Kind::ProtocolDescriptorRecord, popProtocol());
+
       default:
         pushBack();
         pushBack();

lib/Demangling/NodePrinter.cpp

@@ -439,6 +439,7 @@ class NodePrinter {
     case Node::Kind::NativePinningAddressor:
     case Node::Kind::NativePinningMutableAddressor:
     case Node::Kind::NominalTypeDescriptor:
+    case Node::Kind::NominalTypeDescriptorRecord:
     case Node::Kind::NonObjCAttribute:
     case Node::Kind::Number:
     case Node::Kind::ObjCAsyncCompletionHandlerImpl:
@@ -447,6 +448,7 @@ class NodePrinter {
     case Node::Kind::ObjCMetadataUpdateFunction:
     case Node::Kind::ObjCResilientClassStub:
     case Node::Kind::OpaqueTypeDescriptor:
+    case Node::Kind::OpaqueTypeDescriptorRecord:
     case Node::Kind::OpaqueTypeDescriptorAccessor:
     case Node::Kind::OpaqueTypeDescriptorAccessorImpl:
     case Node::Kind::OpaqueTypeDescriptorAccessorKey:
@@ -463,8 +465,10 @@ class NodePrinter {
     case Node::Kind::PropertyDescriptor:
     case Node::Kind::ProtocolConformance:
     case Node::Kind::ProtocolConformanceDescriptor:
+    case Node::Kind::ProtocolConformanceDescriptorRecord:
     case Node::Kind::MetadataInstantiationCache:
     case Node::Kind::ProtocolDescriptor:
+    case Node::Kind::ProtocolDescriptorRecord:
     case Node::Kind::ProtocolRequirementsBaseDescriptor:
     case Node::Kind::ProtocolSelfConformanceDescriptor:
     case Node::Kind::ProtocolSelfConformanceWitness:
@@ -2017,10 +2021,18 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     Printer << "protocol conformance descriptor for ";
     print(Node->getChild(0), depth + 1);
     return nullptr;
+  case Node::Kind::ProtocolConformanceDescriptorRecord:
+    Printer << "protocol conformance descriptor runtime record for ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
   case Node::Kind::ProtocolDescriptor:
     Printer << "protocol descriptor for ";
     print(Node->getChild(0), depth + 1);
     return nullptr;
+  case Node::Kind::ProtocolDescriptorRecord:
+    Printer << "protocol descriptor runtime record for ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
   case Node::Kind::ProtocolRequirementsBaseDescriptor:
     Printer << "protocol requirements base descriptor for ";
     print(Node->getChild(0), depth + 1);
@@ -2123,10 +2135,18 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     Printer << "nominal type descriptor for ";
     print(Node->getChild(0), depth + 1);
     return nullptr;
+  case Node::Kind::NominalTypeDescriptorRecord:
+    Printer << "nominal type descriptor runtime record for ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
   case Node::Kind::OpaqueTypeDescriptor:
     Printer << "opaque type descriptor for ";
     print(Node->getChild(0), depth + 1);
     return nullptr;
+  case Node::Kind::OpaqueTypeDescriptorRecord:
+    Printer << "opaque type descriptor runtime record for ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
   case Node::Kind::OpaqueTypeDescriptorAccessor:
     Printer << "opaque type descriptor accessor for ";
     print(Node->getChild(0), depth + 1);

lib/Demangling/OldRemangler.cpp

@@ -639,6 +639,12 @@ ManglingError Remangler::mangleNominalTypeDescriptor(Node *node,
   return mangleSingleChildNode(node, depth + 1); // type
 }
 
+ManglingError Remangler::mangleNominalTypeDescriptorRecord(Node *node,
+                                                           unsigned depth) {
+  Buffer << "Hn";
+  return mangleSingleChildNode(node, depth + 1); // type
+}
+
 ManglingError Remangler::manglePropertyDescriptor(Node *node, unsigned depth) {
   // not supported
   return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
@@ -659,6 +665,12 @@ ManglingError Remangler::mangleProtocolDescriptor(Node *node, unsigned depth) {
   return mangleProtocolWithoutPrefix(node->begin()[0], depth + 1);
 }
 
+ManglingError Remangler::mangleProtocolDescriptorRecord(Node *node,
+                                                        unsigned depth) {
+  Buffer << "Hr";
+  return mangleProtocolWithoutPrefix(node->begin()[0], depth + 1);
+}
+
 ManglingError
 Remangler::mangleProtocolRequirementsBaseDescriptor(Node *node,
                                                     unsigned depth) {
@@ -679,6 +691,13 @@ ManglingError Remangler::mangleProtocolConformanceDescriptor(Node *node,
   return mangleProtocolConformance(node->begin()[0], depth + 1);
 }
 
+ManglingError
+Remangler::mangleProtocolConformanceDescriptorRecord(Node *node,
+                                                     unsigned depth) {
+  Buffer << "Hc";
+  return mangleProtocolConformance(node->begin()[0], depth + 1);
+}
+
 ManglingError
 Remangler::mangleProtocolSelfConformanceDescriptor(Node *node, unsigned depth) {
   Buffer << "MS";
@@ -2624,6 +2643,10 @@ ManglingError Remangler::mangleOpaqueTypeDescriptor(Node *node,
                                                     unsigned depth) {
   return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
+ManglingError Remangler::mangleOpaqueTypeDescriptorRecord(Node *node,
+                                                          unsigned depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
 ManglingError Remangler::mangleOpaqueTypeDescriptorAccessor(Node *node,
                                                             unsigned depth) {
   return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);

lib/Demangling/Remangler.cpp

@@ -2116,13 +2116,27 @@ ManglingError Remangler::mangleNominalTypeDescriptor(Node *node,
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleNominalTypeDescriptorRecord(Node *node,
+                                                           unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
+  Buffer << "Hn";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleOpaqueTypeDescriptor(Node *node,
                                                     unsigned depth) {
   RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "MQ";
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleOpaqueTypeDescriptorRecord(Node *node,
+                                                          unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
+  Buffer << "Ho";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleOpaqueTypeDescriptorAccessor(Node *node,
                                                             unsigned depth) {
   RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
@@ -2419,6 +2433,13 @@ ManglingError Remangler::mangleProtocolDescriptor(Node *node, unsigned depth) {
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleProtocolDescriptorRecord(Node *node,
+                                                        unsigned depth) {
+  RETURN_IF_ERROR(manglePureProtocol(getSingleChild(node), depth + 1));
+  Buffer << "Hr";
+  return ManglingError::Success;
+}
+
 ManglingError
 Remangler::mangleProtocolRequirementsBaseDescriptor(Node *node,
                                                     unsigned depth) {
@@ -2441,6 +2462,14 @@ ManglingError Remangler::mangleProtocolConformanceDescriptor(Node *node,
   return ManglingError::Success;
 }
 
+ManglingError
+Remangler::mangleProtocolConformanceDescriptorRecord(Node *node,
+                                                     unsigned depth) {
+  RETURN_IF_ERROR(mangleProtocolConformance(node->getChild(0), depth + 1));
+  Buffer << "Hc";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleProtocolList(Node *node, Node *superclass,
                                             bool hasExplicitAnyObject,
                                             unsigned depth) {

lib/IRGen/IRGenMangler.cpp

@@ -180,6 +180,14 @@ std::string IRGenMangler::mangleProtocolConformanceDescriptor(
   return finalize();
 }
 
+std::string IRGenMangler::mangleProtocolConformanceDescriptorRecord(
+                                 const RootProtocolConformance *conformance) {
+  beginMangling();
+  appendProtocolConformance(conformance);
+  appendOperator("Hc");
+  return finalize();
+}
+
 std::string IRGenMangler::mangleProtocolConformanceInstantiationCache(
                                  const RootProtocolConformance *conformance) {
   beginMangling();