Get typerefs for existential type metadata

bitjammer · bitjammer · commit bd6d6574119c · 2016-03-04T17:10:40.000-08:00
diff --git a/include/swift/Reflection/ReflectionContext.h b/include/swift/Reflection/ReflectionContext.h
@@ -39,6 +39,10 @@ template <typename Runtime>
 using SharedTargetNominalTypeDescriptorRef
   = std::shared_ptr<TargetNominalTypeDescriptor<Runtime>>;
 
+template <typename Runtime>
+using SharedProtocolDescriptorRef
+  = std::shared_ptr<TargetProtocolDescriptor<Runtime>>;
+
 using FieldSection = ReflectionSection<FieldDescriptorIterator>;
 using AssociatedTypeSection = ReflectionSection<AssociatedTypeIterator>;
 using GenericSection = ReflectionSection<const void *>;
@@ -148,8 +152,20 @@ class ReflectionContext {
         return _readMetadata<TargetEnumMetadata<Runtime>>(Address);
       case MetadataKind::ErrorObject:
         return _readMetadata<TargetEnumMetadata<Runtime>>(Address);
-      case MetadataKind::Existential:
-        return _readMetadata<TargetExistentialTypeMetadata<Runtime>>(Address);
+      case MetadataKind::Existential: {
+        StoredPointer NumProtocolsAddress = Address +
+          TargetExistentialTypeMetadata<Runtime>::OffsetToNumProtocols;
+        StoredPointer NumProtocols;
+        if (!Reader.readInteger(NumProtocolsAddress, &NumProtocols))
+          return nullptr;
+
+        auto TotalSize = sizeof(TargetExistentialTypeMetadata<Runtime>) +
+          NumProtocols *
+            sizeof(ConstTargetMetadataPointer<Runtime, TargetProtocolDescriptor>);
+        
+        return _readMetadata<TargetExistentialTypeMetadata<Runtime>>(Address,
+                                                                     TotalSize);
+      }
       case MetadataKind::ExistentialMetatype:
         return _readMetadata<
           TargetExistentialMetatypeMetadata<Runtime>>(Address);
@@ -216,6 +232,22 @@ class ReflectionContext {
                                             });
   }
 
+  SharedProtocolDescriptorRef<Runtime>
+  readProtocolDescriptor(StoredPointer Address) {
+    auto Size = sizeof(TargetProtocolDescriptor<Runtime>);
+    auto Buffer = (uint8_t *)malloc(Size);
+    if (!Reader.readBytes(Address, Buffer, Size)) {
+      free(Buffer);
+      return nullptr;
+    }
+    auto Casted
+      = reinterpret_cast<TargetProtocolDescriptor<Runtime> *>(Buffer);
+    return SharedProtocolDescriptorRef<Runtime>(Casted,
+                                                      [](void *PD){
+                                                        free(PD);
+                                                      });
+  }
+
   TypeRefVector
   getGenericArguments(StoredPointer MetadataAddress,
                       SharedTargetNominalTypeDescriptorRef<Runtime> Descriptor){
@@ -360,7 +392,21 @@ class ReflectionContext {
     case MetadataKind::Existential: {
       auto Exist = cast<TargetExistentialTypeMetadata<Runtime>>(Meta.get());
       TypeRefVector Protocols;
-      llvm_unreachable("todo");
+      for (size_t i = 0; i < Exist->Protocols.NumProtocols; ++i) {
+        auto ProtocolAddress = Exist->Protocols[i];
+        auto ProtocolDescriptor = readProtocolDescriptor(ProtocolAddress);
+        if (!ProtocolDescriptor)
+          return nullptr;
+        auto MangledName = Reader.readString(ProtocolDescriptor->Name);
+        if (MangledName.empty())
+          return nullptr;
+        auto Demangled = Demangle::demangleSymbolAsNode(MangledName);
+        auto Protocol = TypeRef::fromDemangleNode(Demangled);
+        if (!llvm::isa<ProtocolTypeRef>(Protocol.get()))
+          return nullptr;
+
+        Protocols.push_back(Protocol);
+      }
       return ProtocolCompositionTypeRef::create(Protocols);
     }
     case MetadataKind::Metatype: {
diff --git a/include/swift/Runtime/Metadata.h b/include/swift/Runtime/Metadata.h
@@ -1773,7 +1773,7 @@ using HeapLocalVariableMetadata
 /// Swift-compiled.
 template <typename Runtime>
 struct TargetObjCClassWrapperMetadata : public TargetMetadata<Runtime> {
-  const TargetClassMetadata<Runtime> *Class;
+  ConstTargetMetadataPointer<Runtime, TargetClassMetadata> Class;
 
   static bool classof(const TargetMetadata<Runtime> *metadata) {
     return metadata->getKind() == MetadataKind::ObjCClassWrapper;
@@ -2141,19 +2141,27 @@ struct TargetProtocolDescriptorList {
   using StoredPointer = typename Runtime::StoredPointer;
   StoredPointer NumProtocols;
 
-  const TargetProtocolDescriptor<Runtime> **getProtocols() {
-    return reinterpret_cast<const TargetProtocolDescriptor<Runtime> **>(this + 1);
+  ConstTargetMetadataPointer<Runtime, TargetProtocolDescriptor> *
+  getProtocols() {
+    return reinterpret_cast<
+      ConstTargetMetadataPointer<
+        Runtime, TargetProtocolDescriptor> *>(this + 1);
   }
   
-  const TargetProtocolDescriptor<Runtime> * const *getProtocols() const {
-    return reinterpret_cast<const TargetProtocolDescriptor<Runtime> * const *>(this + 1);
+  ConstTargetMetadataPointer<Runtime, TargetProtocolDescriptor> const *
+  getProtocols() const {
+    return reinterpret_cast<
+      ConstTargetMetadataPointer<
+        Runtime, TargetProtocolDescriptor> const *>(this + 1);
   }
   
-  const TargetProtocolDescriptor<Runtime> *operator[](size_t i) const {
+  ConstTargetMetadataPointer<Runtime, TargetProtocolDescriptor> const &
+  operator[](size_t i) const {
     return getProtocols()[i];
   }
   
-  const TargetProtocolDescriptor<Runtime> *&operator[](size_t i) {
+  ConstTargetMetadataPointer<Runtime, TargetProtocolDescriptor> &
+  operator[](size_t i) {
     return getProtocols()[i];
   }
 
@@ -2173,29 +2181,36 @@ struct TargetLiteralProtocolDescriptorList
   
   template<typename...DescriptorPointers>
   constexpr TargetLiteralProtocolDescriptorList(DescriptorPointers...elements)
-    : TargetProtocolDescriptorList<Runtime>(NUM_PROTOCOLS), Protocols{elements...}
+    : TargetProtocolDescriptorList<Runtime>(NUM_PROTOCOLS),
+      Protocols{elements...}
   {}
 };
+using LiteralProtocolDescriptorList = TargetProtocolDescriptorList<InProcess>;
   
 /// A protocol descriptor. This is not type metadata, but is referenced by
 /// existential type metadata records to describe a protocol constraint.
 /// Its layout is compatible with the Objective-C runtime's 'protocol_t' record
 /// layout.
 template <typename Runtime>
 struct TargetProtocolDescriptor {
+  using StoredPointer = typename Runtime::StoredPointer;
   /// Unused by the Swift runtime.
-  const void *_ObjC_Isa;
+  TargetPointer<Runtime, const void> _ObjC_Isa;
   
   /// The mangled name of the protocol.
-  const char *Name;
+  TargetPointer<Runtime, const char> Name;
   
   /// The list of protocols this protocol refines.
-  const TargetProtocolDescriptorList<Runtime> *InheritedProtocols;
+  ConstTargetMetadataPointer<Runtime, TargetProtocolDescriptorList>
+  InheritedProtocols;
   
   /// Unused by the Swift runtime.
-  const void *_ObjC_InstanceMethods, *_ObjC_ClassMethods,
-             *_ObjC_OptionalInstanceMethods, *_ObjC_OptionalClassMethods,
-             *_ObjC_InstanceProperties;
+  TargetPointer<Runtime, const void>
+  _ObjC_InstanceMethods,
+  _ObjC_ClassMethods,
+  _ObjC_OptionalInstanceMethods,
+  _ObjC_OptionalClassMethods,
+  _ObjC_InstanceProperties;
   
   /// Size of the descriptor record.
   uint32_t DescriptorSize;
@@ -2229,8 +2244,8 @@ struct TargetProtocolDescriptor {
   }
 
   constexpr TargetProtocolDescriptor<Runtime>(const char *Name,
-                               const TargetProtocolDescriptorList<Runtime> *Inherited,
-                               ProtocolDescriptorFlags Flags)
+                        const TargetProtocolDescriptorList<Runtime> *Inherited,
+                        ProtocolDescriptorFlags Flags)
     : _ObjC_Isa(nullptr), Name(Name), InheritedProtocols(Inherited),
       _ObjC_InstanceMethods(nullptr), _ObjC_ClassMethods(nullptr),
       _ObjC_OptionalInstanceMethods(nullptr),
@@ -2304,6 +2319,7 @@ enum class ExistentialTypeRepresentation {
 /// The structure of existential type metadata.
 template <typename Runtime>
 struct TargetExistentialTypeMetadata : public TargetMetadata<Runtime> {
+  using StoredPointer = typename Runtime::StoredPointer;
   /// The number of witness tables and class-constrained-ness of the type.
   ExistentialTypeFlags Flags;
   /// The protocol constraints.
@@ -2354,6 +2370,10 @@ struct TargetExistentialTypeMetadata : public TargetMetadata<Runtime> {
   static bool classof(const TargetMetadata<Runtime> *metadata) {
     return metadata->getKind() == MetadataKind::Existential;
   }
+
+  static constexpr StoredPointer
+  OffsetToNumProtocols = sizeof(TargetMetadata<Runtime>) + sizeof(Flags);
+
 };
 using ExistentialTypeMetadata
   = TargetExistentialTypeMetadata<InProcess>;
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -25,6 +25,7 @@
 #include "swift/SIL/FormalLinkage.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/TypeLowering.h"
+#include "swift/Runtime/Metadata.h"
 #include "swift/ABI/MetadataValues.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/DerivedTypes.h"
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -88,7 +88,6 @@ namespace swift {
   class IRGenOptions;
   class NormalProtocolConformance;
   class ProtocolConformance;
-  class TypeMetadataRecord;
   class ProtocolCompositionType;
   class ProtocolDecl;
   struct SILDeclRef;
diff --git a/lib/Reflection/TypeRef.cpp b/lib/Reflection/TypeRef.cpp
@@ -35,7 +35,7 @@ void TypeRef::dump() const {
 
 void TypeRef::dump(std::ostream &OS, unsigned Indent) const {
   PrintTypeRef(OS, Indent).visit(this);
-  OS << "\n";
+  OS << std::endl;
 }
 
 TypeRefPointer TypeRef::substituteGenerics(ConstTypeRefVector &Substitutions) {
@@ -45,6 +45,10 @@ TypeRefPointer TypeRef::substituteGenerics(ConstTypeRefVector &Substitutions) {
 TypeRefPointer TypeRef::fromDemangleNode(Demangle::NodePointer Node) {
   using NodeKind = Demangle::Node::Kind;
   switch (Node->getKind()) {
+    case NodeKind::Global:
+      return fromDemangleNode(Node->getChild(0));
+    case NodeKind::TypeMangling:
+      return fromDemangleNode(Node->getChild(0));
     case NodeKind::Type:
       return fromDemangleNode(Node->getChild(0));
     case NodeKind::BoundGenericClass:
@@ -76,6 +80,20 @@ TypeRefPointer TypeRef::fromDemangleNode(Demangle::NodePointer Node) {
       auto instance = fromDemangleNode(Node->getChild(0));
       return MetatypeTypeRef::create(instance);
     }
+    case NodeKind::ProtocolList: {
+      TypeRefVector Protocols;
+      auto TypeList = Node->getChild(0);
+      for (auto Type : *TypeList) {
+        if (auto Protocol = fromDemangleNode(Type))
+          Protocols.push_back(Protocol);
+        else
+          return nullptr;
+      }
+      if (Protocols.size() == 1)
+        return Protocols.front();
+      else
+        return ProtocolCompositionTypeRef::create(Protocols);
+    }
     case NodeKind::Protocol: {
       auto moduleName = Node->getChild(0)->getText();
       auto name = Node->getChild(1)->getText();
