[SR-381]: runtime resolution of type metadata from a name

replace ProtocolConformanceTypeKind with TypeMetadataRecordKind

metadata reference does not need to be indirectable

more efficient check for protocol conformances

remove swift_getMangledTypeName(), not needed yet

kill off Remangle.cpp for non-ObjC builds

cleanup

cleanup

cleanup comments

Author: lhoward

include/swift/ABI/MetadataValues.h

@@ -93,8 +93,8 @@ enum : unsigned {
   NumGenericMetadataPrivateDataWords = 16,
 };
 
-/// Kinds of protocol conformance record.
-enum class ProtocolConformanceTypeKind : unsigned {
+/// Kinds of type metadata/protocol conformance records.
+enum class TypeMetadataRecordKind : unsigned {
   /// The conformance is universal and might apply to any type.
   /// getDirectType() is nil.
   Universal,
@@ -130,7 +130,7 @@ enum class ProtocolConformanceTypeKind : unsigned {
   /// platforms, the class object always is the type metadata.
   UniqueDirectClass = 0xF,
 };
-  
+
 /// Kinds of reference to protocol conformance.
 enum class ProtocolConformanceReferenceKind : unsigned {
   /// A direct reference to a protocol witness table.
@@ -139,32 +139,51 @@ enum class ProtocolConformanceReferenceKind : unsigned {
   /// table.
   WitnessTableAccessor,
 };
-  
-struct ProtocolConformanceFlags {
-private:
+
+// Type metadata record discriminant
+struct TypeMetadataRecordFlags {
+protected:
   using int_type = unsigned;
   int_type Data;
 
   enum : int_type {
     TypeKindMask = 0x0000000FU,
     TypeKindShift = 0,
-    ConformanceKindMask = 0x00000010U,
-    ConformanceKindShift = 4,
   };
 
 public:
-  constexpr ProtocolConformanceFlags() : Data(0) {}
-  constexpr ProtocolConformanceFlags(int_type Data) : Data(Data) {}
+  constexpr TypeMetadataRecordFlags() : Data(0) {}
+  constexpr TypeMetadataRecordFlags(int_type Data) : Data(Data) {}
 
-  constexpr ProtocolConformanceTypeKind getTypeKind() const {
-    return ProtocolConformanceTypeKind((Data >> TypeKindShift) & TypeKindMask);
+  constexpr TypeMetadataRecordKind getTypeKind() const {
+    return TypeMetadataRecordKind((Data >> TypeKindShift) & TypeKindMask);
+  }
+  constexpr TypeMetadataRecordFlags withTypeKind(
+                                        TypeMetadataRecordKind ptk) const {
+    return TypeMetadataRecordFlags(
+                     (Data & ~TypeKindMask) | (int_type(ptk) << TypeKindShift));
   }
+  
+  int_type getValue() const { return Data; }
+};
+
+// Protocol conformance discriminant
+struct ProtocolConformanceFlags : public TypeMetadataRecordFlags {
+private:
+  enum : int_type {
+    ConformanceKindMask = 0x00000010U,
+    ConformanceKindShift = 4,
+  };
+
+public:
+  constexpr ProtocolConformanceFlags() : TypeMetadataRecordFlags(0) {}
+  constexpr ProtocolConformanceFlags(int_type Data) : TypeMetadataRecordFlags(Data) {}
+
   constexpr ProtocolConformanceFlags withTypeKind(
-                                        ProtocolConformanceTypeKind ptk) const {
+                                        TypeMetadataRecordKind ptk) const {
     return ProtocolConformanceFlags(
                      (Data & ~TypeKindMask) | (int_type(ptk) << TypeKindShift));
   }
-  
   constexpr ProtocolConformanceReferenceKind getConformanceKind() const {
     return ProtocolConformanceReferenceKind((Data >> ConformanceKindShift)
                                      & ConformanceKindMask);
@@ -174,8 +193,6 @@ struct ProtocolConformanceFlags {
     return ProtocolConformanceFlags(
        (Data & ~ConformanceKindMask) | (int_type(pck) << ConformanceKindShift));
   }
-  
-  int_type getValue() const { return Data; }
 };
 
 /// Flag that indicates whether an existential type is class-constrained or not.

include/swift/Runtime/Metadata.h

@@ -2125,6 +2125,57 @@ struct GenericWitnessTable {
   void *PrivateData[swift::NumGenericMetadataPrivateDataWords];
 };
 
+/// The structure of a type metadata record.
+///
+/// This contains enough static information to recover type metadata from a
+/// name. It is only emitted for types that do not have an explicit protocol
+/// conformance record. 
+///
+/// This structure is notionally a subtype of a protocol conformance record
+/// but as we cannot change the conformance record layout we have to make do
+/// with some duplicated code.
+struct TypeMetadataRecord {
+private:
+  // Some description of the type that is resolvable at runtime.
+  union {
+    /// A direct reference to the metadata.
+    RelativeDirectPointer<Metadata> DirectType;
+
+    /// The generic metadata pattern for an unbound generic type.
+    RelativeDirectPointer<GenericMetadata> GenericPattern;
+  };
+
+  /// Flags describing the type metadata record.
+  TypeMetadataRecordFlags Flags;
+  
+public:
+  TypeMetadataRecordKind getTypeKind() const {
+    return Flags.getTypeKind();
+  }
+  
+  const Metadata *getDirectType() const {
+    switch (Flags.getTypeKind()) {
+    case TypeMetadataRecordKind::Universal:
+      return nullptr;
+
+    case TypeMetadataRecordKind::UniqueDirectType:
+    case TypeMetadataRecordKind::NonuniqueDirectType:
+    case TypeMetadataRecordKind::UniqueDirectClass:
+      break;
+        
+    case TypeMetadataRecordKind::UniqueIndirectClass:
+    case TypeMetadataRecordKind::UniqueGenericPattern:
+      assert(false && "not direct type metadata");
+    }
+
+    return DirectType;
+  }
+  
+  /// Get the canonical metadata for the type referenced by this record, or
+  /// return null if the record references a generic or universal type.
+  const Metadata *getCanonicalTypeMetadata() const;
+};
+
 /// The structure of a protocol conformance record.
 ///
 /// This contains enough static information to recover the witness table for a
@@ -2177,7 +2228,7 @@ struct ProtocolConformanceRecord {
     return Flags;
   }
 
-  ProtocolConformanceTypeKind getTypeKind() const {
+  TypeMetadataRecordKind getTypeKind() const {
     return Flags.getTypeKind();
   }
   ProtocolConformanceReferenceKind getConformanceKind() const {
@@ -2186,16 +2237,16 @@ struct ProtocolConformanceRecord {
 
   const Metadata *getDirectType() const {
     switch (Flags.getTypeKind()) {
-    case ProtocolConformanceTypeKind::Universal:
+    case TypeMetadataRecordKind::Universal:
       return nullptr;
 
-    case ProtocolConformanceTypeKind::UniqueDirectType:
-    case ProtocolConformanceTypeKind::NonuniqueDirectType:
+    case TypeMetadataRecordKind::UniqueDirectType:
+    case TypeMetadataRecordKind::NonuniqueDirectType:
       break;
 
-    case ProtocolConformanceTypeKind::UniqueDirectClass:
-    case ProtocolConformanceTypeKind::UniqueIndirectClass:
-    case ProtocolConformanceTypeKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueDirectClass:
+    case TypeMetadataRecordKind::UniqueIndirectClass:
+    case TypeMetadataRecordKind::UniqueGenericPattern:
       assert(false && "not direct type metadata");
     }
 
@@ -2205,15 +2256,15 @@ struct ProtocolConformanceRecord {
   // FIXME: This shouldn't exist
   const ClassMetadata *getDirectClass() const {
     switch (Flags.getTypeKind()) {
-    case ProtocolConformanceTypeKind::Universal:
+    case TypeMetadataRecordKind::Universal:
       return nullptr;
-    case ProtocolConformanceTypeKind::UniqueDirectClass:
+    case TypeMetadataRecordKind::UniqueDirectClass:
       break;
 
-    case ProtocolConformanceTypeKind::UniqueDirectType:
-    case ProtocolConformanceTypeKind::NonuniqueDirectType:
-    case ProtocolConformanceTypeKind::UniqueGenericPattern:
-    case ProtocolConformanceTypeKind::UniqueIndirectClass:
+    case TypeMetadataRecordKind::UniqueDirectType:
+    case TypeMetadataRecordKind::NonuniqueDirectType:
+    case TypeMetadataRecordKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueIndirectClass:
       assert(false && "not direct class object");
     }
 
@@ -2224,16 +2275,16 @@ struct ProtocolConformanceRecord {
 
   const ClassMetadata * const *getIndirectClass() const {
     switch (Flags.getTypeKind()) {
-    case ProtocolConformanceTypeKind::Universal:
+    case TypeMetadataRecordKind::Universal:
       return nullptr;
 
-    case ProtocolConformanceTypeKind::UniqueIndirectClass:
+    case TypeMetadataRecordKind::UniqueIndirectClass:
       break;
 
-    case ProtocolConformanceTypeKind::UniqueDirectType:
-    case ProtocolConformanceTypeKind::UniqueDirectClass:
-    case ProtocolConformanceTypeKind::NonuniqueDirectType:
-    case ProtocolConformanceTypeKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueDirectType:
+    case TypeMetadataRecordKind::UniqueDirectClass:
+    case TypeMetadataRecordKind::NonuniqueDirectType:
+    case TypeMetadataRecordKind::UniqueGenericPattern:
       assert(false && "not indirect class object");
     }
 
@@ -2242,16 +2293,16 @@ struct ProtocolConformanceRecord {
 
   const GenericMetadata *getGenericPattern() const {
     switch (Flags.getTypeKind()) {
-    case ProtocolConformanceTypeKind::Universal:
+    case TypeMetadataRecordKind::Universal:
       return nullptr;
 
-    case ProtocolConformanceTypeKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueGenericPattern:
       break;
 
-    case ProtocolConformanceTypeKind::UniqueDirectClass:
-    case ProtocolConformanceTypeKind::UniqueIndirectClass:
-    case ProtocolConformanceTypeKind::UniqueDirectType:
-    case ProtocolConformanceTypeKind::NonuniqueDirectType:
+    case TypeMetadataRecordKind::UniqueDirectClass:
+    case TypeMetadataRecordKind::UniqueIndirectClass:
+    case TypeMetadataRecordKind::UniqueDirectType:
+    case TypeMetadataRecordKind::NonuniqueDirectType:
       assert(false && "not generic metadata pattern");
     }
 
@@ -2817,7 +2868,12 @@ const WitnessTable *swift_conformsToProtocol(const Metadata *type,
 extern "C"
 void swift_registerProtocolConformances(const ProtocolConformanceRecord *begin,
                                         const ProtocolConformanceRecord *end);
-  
+
+/// Register a block of type metadata records dynamic lookup.
+extern "C"
+void swift_registerTypeMetadataRecords(const TypeMetadataRecord *begin,
+                                       const TypeMetadataRecord *end);
+
 /// Return the type name for a given type metadata.
 std::string nameForMetadata(const Metadata *type,
                             bool qualified = true);