Register and look up field descriptors using TypeInfoProvider

Author: augusto2112

include/swift/Reflection/ReflectionContext.h

@@ -228,7 +228,8 @@ class ReflectionContext
   }
 
   template <typename T>
-  bool readMachOSections(
+  llvm::Optional<uint64_t>
+  readMachOSections(
       RemoteAddress ImageStart,
       llvm::SmallVector<llvm::StringRef, 1> PotentialModuleNames = {}) {
     auto Buf =
@@ -350,7 +351,7 @@ class ReflectionContext
                            {MPEnumMdSec.first, MPEnumMdSec.second},
                            PotentialModuleNames};
 
-    this->addReflectionInfo(info);
+    auto InfoID = this->addReflectionInfo(info);
 
     // Find the __DATA segment.
     for (unsigned I = 0; I < NumCommands; ++I) {
@@ -374,10 +375,10 @@ class ReflectionContext
 
     savedBuffers.push_back(std::move(Buf));
     savedBuffers.push_back(std::move(Sections));
-    return true;
+    return InfoID;
   }
 
-  bool readPECOFFSections(
+  llvm::Optional<uint64_t> readPECOFFSections(
       RemoteAddress ImageStart,
       llvm::SmallVector<llvm::StringRef, 1> PotentialModuleNames = {}) {
     auto DOSHdrBuf = this->getReader().readBytes(
@@ -477,11 +478,10 @@ class ReflectionContext
                            {ConformMdSec.first, ConformMdSec.second},
                            {MPEnumMdSec.first, MPEnumMdSec.second},
                            PotentialModuleNames};
-    this->addReflectionInfo(Info);
-    return true;
+    return this->addReflectionInfo(Info);
   }
 
-  bool readPECOFF(RemoteAddress ImageStart,
+  llvm::Optional<uint64_t> readPECOFF(RemoteAddress ImageStart,
                   llvm::SmallVector<llvm::StringRef, 1> PotentialModuleNames = {}) {
     auto Buf = this->getReader().readBytes(ImageStart,
                                            sizeof(llvm::object::dos_header));
@@ -505,7 +505,7 @@ class ReflectionContext
   }
 
   template <typename T>
-  bool readELFSections(
+  llvm::Optional<uint64_t> readELFSections(
       RemoteAddress ImageStart,
       llvm::Optional<llvm::sys::MemoryBlock> FileBuffer,
       llvm::SmallVector<llvm::StringRef, 1> PotentialModuleNames = {}) {
@@ -673,8 +673,7 @@ class ReflectionContext
                            {MPEnumMdSec.first, MPEnumMdSec.second},
                            PotentialModuleNames};
 
-    this->addReflectionInfo(info);
-    return true;
+    return this->addReflectionInfo(info);
   }
 
   /// Parses metadata information from an ELF image. Because the Section
@@ -693,22 +692,22 @@ class ReflectionContext
   ///     instance's memory reader.
   ///
   /// \return
-  ///     /b True if the metadata information was parsed successfully,
-  ///     /b false otherwise.
-  bool
+  ///     \b  The newly added reflection info ID if successful,
+  ///     \b llvm::None otherwise.
+  llvm::Optional<uint64_t>
   readELF(RemoteAddress ImageStart,
           llvm::Optional<llvm::sys::MemoryBlock> FileBuffer,
           llvm::SmallVector<llvm::StringRef, 1> PotentialModuleNames = {}) {
     auto Buf =
         this->getReader().readBytes(ImageStart, sizeof(llvm::ELF::Elf64_Ehdr));
     if (!Buf)
-      return false;
+      return llvm::None;
 
     // Read the header.
     auto Hdr = reinterpret_cast<const llvm::ELF::Elf64_Ehdr *>(Buf.get());
 
     if (!Hdr->checkMagic())
-      return false;
+      return llvm::None;
 
     // Check if we have a ELFCLASS32 or ELFCLASS64
     unsigned char FileClass = Hdr->getFileClass();
@@ -719,11 +718,11 @@ class ReflectionContext
       return readELFSections<ELFTraits<llvm::ELF::ELFCLASS32>>(
           ImageStart, FileBuffer, PotentialModuleNames);
     } else {
-      return false;
+      return llvm::None;
     }
   }
 
-  bool
+  llvm::Optional<uint64_t>
   addImage(RemoteAddress ImageStart,
            llvm::SmallVector<llvm::StringRef, 1> PotentialModuleNames = {}) {
     // Read the first few bytes to look for a magic header.
@@ -761,7 +760,7 @@ class ReflectionContext
     }
 
     // We don't recognize the format.
-    return false;
+    return llvm::None;
   }
 
   /// Adds an image using the FindSection closure to find the swift metadata
@@ -770,9 +769,9 @@ class ReflectionContext
   ///     of freeing the memory buffer in the RemoteRef return value.
   ///     process.
   /// \return
-  ///     \b True if any of the reflection sections were registered,
-  ///     \b false otherwise.
-  bool
+  ///     \b  The newly added reflection info ID if successful,
+  ///     \b llvm::None otherwise.
+  llvm::Optional<uint64_t>
   addImage(llvm::function_ref<
                std::pair<RemoteRef<void>, uint64_t>(ReflectionSectionKind)>
                FindSection,
@@ -798,7 +797,7 @@ class ReflectionContext
 
     // If we didn't find any sections, return.
     if (llvm::all_of(Pairs, [](const auto &Pair) { return !Pair.first; }))
-      return false;
+      return {};
 
     ReflectionInfo Info = {{Pairs[0].first, Pairs[0].second},
                            {Pairs[1].first, Pairs[1].second},
@@ -809,12 +808,11 @@ class ReflectionContext
                            {Pairs[6].first, Pairs[6].second},
                            {Pairs[7].first, Pairs[7].second},
                            PotentialModuleNames};
-    this->addReflectionInfo(Info);
-    return true;
+    return addReflectionInfo(Info);
   }
 
-  void addReflectionInfo(ReflectionInfo I) {
-    getBuilder().addReflectionInfo(I);
+  llvm::Optional<uint64_t> addReflectionInfo(ReflectionInfo I) {
+    return getBuilder().addReflectionInfo(I);
   }
 
   bool ownsObject(RemoteAddress ObjectAddress) {

include/swift/Reflection/TypeRefBuilder.h

@@ -915,10 +915,13 @@ class TypeRefBuilder {
   /// Parsing reflection metadata
   ///
 
-  void addReflectionInfo(ReflectionInfo I) {
+  /// Add the ReflectionInfo and return a unique ID for the reflection image
+  /// added. Since we only add reflection infos, the ID can be its index.
+  llvm::Optional<uint64_t> addReflectionInfo(ReflectionInfo I) {
     ReflectionInfos.push_back(I);
+    return ReflectionInfos.size() - 1;
   }
-  
+
   const std::vector<ReflectionInfo> &getReflectionInfos() {
     return ReflectionInfos;
   }
@@ -939,9 +942,15 @@ class TypeRefBuilder {
   llvm::Optional<std::string> normalizeReflectionName(RemoteRef<char> name);
   bool reflectionNameMatches(RemoteRef<char> reflectionName,
                              StringRef searchName);
-  void populateFieldTypeInfoCacheWithReflectionAtIndex(size_t Index);
+  void populateFieldTypeInfoCacheWithReflectionAtIndex(
+      size_t Index, remote::TypeInfoProvider *ExternalTypeInfo);
+  llvm::Optional<RemoteRef<FieldDescriptor>>
+  findFieldDescriptorAtIndex(size_t Index, const std::string &MangledName,
+                             remote::TypeInfoProvider *ExternalTypeInfo);
+
   llvm::Optional<RemoteRef<FieldDescriptor>>
-  findFieldDescriptorAtIndex(size_t Index, const std::string &MangledName);
+  getFieldDescriptorFromProvider(const std::string &MangledName,
+                                 remote::TypeInfoProvider *ExternalTypeInfo);
 
 public:
   RemoteRef<char> readTypeRef(uint64_t remoteAddr);
@@ -1052,10 +1061,13 @@ class TypeRefBuilder {
                     const std::string &Member,
                     StringRef Protocol);
 
-  const TypeRef *lookupSuperclass(const TypeRef *TR);
+  const TypeRef *lookupSuperclass(const TypeRef *TR,
+                                  remote::TypeInfoProvider *ExternalTypeInfo);
 
   /// Load unsubstituted field types for a nominal type.
-  RemoteRef<FieldDescriptor> getFieldTypeInfo(const TypeRef *TR);
+  RemoteRef<FieldDescriptor>
+  getFieldTypeInfo(const TypeRef *TR,
+                   remote::TypeInfoProvider *ExternalTypeInfo);
 
   /// Get the parsed and substituted field types for a nominal type.
   bool getFieldTypeRefs(const TypeRef *TR, RemoteRef<FieldDescriptor> FD,

include/swift/Remote/TypeInfoProvider.h

@@ -17,12 +17,33 @@
 #ifndef SWIFT_REMOTE_TYPEINFOPROVIDER_H
 #define SWIFT_REMOTE_TYPEINFOPROVIDER_H
 
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Optional.h"
+
+#include <vector>
+#include <string>
+
 namespace swift {
 namespace reflection {
 class TypeInfo;
+
+template <typename T>
+class ReflectionSection;
+class FieldDescriptorIterator;
+using FieldSection = ReflectionSection<FieldDescriptorIterator>;
 }
 namespace remote {
 
+/// A struct with the information to locate a specific field descriptor.
+struct FieldDescriptorLocator {
+  /// The reflection info ID the field descriptor belongs to.
+  uint64_t InfoID;
+
+  /// The offset of the field descriptor in the FieldSection buffer.
+  uint64_t Offset;
+};
+
 /// An abstract interface for providing external type layout information.
 struct TypeInfoProvider {
   virtual ~TypeInfoProvider() = default;
@@ -32,6 +53,26 @@ struct TypeInfoProvider {
   /// info, for example.
   virtual const reflection::TypeInfo *
   getTypeInfo(llvm::StringRef mangledName) = 0;
+
+  /// Register the field descriptors of a reflection info with a given id with
+  /// their corresponding mangled names. The amount of field descriptors and
+  /// mangled names must be the same. If a field descriptor does not have a
+  /// mangled name a corresponding empty string must be in the mangled_names
+  /// vector.
+  virtual void registerFieldDescriptors(
+      uint64_t InfoID,
+      const swift::reflection::FieldSection &FieldDescriptors,
+      const llvm::ArrayRef<std::string> &MangledNames) = 0;
+
+  /// Retrieve a pair representing the reflection info id and the offset of a
+  /// field descriptor in the field section buffer, if available.
+  virtual llvm::Optional<FieldDescriptorLocator>
+  getFieldDescriptorLocator(const std::string &Name) = 0;
+
+  /// Returns whether looking for a mangled name in reflection info with a given
+  /// id could possibly return information that couldn't be provided by the
+  /// TypeInfoProvider.
+  virtual bool shouldParseReflectionInfoWithId(uint64_t InfoID) = 0;
 };
 
 } // namespace remote

stdlib/public/Reflection/TypeLowering.cpp

@@ -1201,7 +1201,7 @@ class ExistentialTypeInfoBuilder {
     return false;
   }
 
-  void examineProtocols() {
+  void examineProtocols(remote::TypeInfoProvider *ExternalTypeInfo) {
     if (isSingleError()) {
       Representation = ExistentialTypeRepresentation::Error;
       // No extra witness table for protocol<Error>
@@ -1223,7 +1223,7 @@ class ExistentialTypeInfoBuilder {
         continue;
       }
 
-      auto FD = TC.getBuilder().getFieldTypeInfo(P);
+      auto FD = TC.getBuilder().getFieldTypeInfo(P, ExternalTypeInfo);
       if (FD == nullptr) {
         DEBUG_LOG(fprintf(stderr, "No field descriptor: "); P->dump())
         Invalid = true;
@@ -1239,7 +1239,8 @@ class ExistentialTypeInfoBuilder {
           Representation = ExistentialTypeRepresentation::Class;
           ++WitnessTableCount;
 
-          if (auto *Superclass = TC.getBuilder().lookupSuperclass(P)) {
+          if (auto *Superclass =
+                  TC.getBuilder().lookupSuperclass(P, ExternalTypeInfo)) {
             // ObjC class info should be available in the metadata, so it's safe
             // to not pass an external provider here. This helps preserving the
             // layering.
@@ -1290,7 +1291,8 @@ class ExistentialTypeInfoBuilder {
     Protocols.push_back(P);
   }
 
-  void addProtocolComposition(const ProtocolCompositionTypeRef *PC) {
+  void addProtocolComposition(const ProtocolCompositionTypeRef *PC,
+                              remote::TypeInfoProvider *ExternalTypeInfo) {
     for (auto *T : PC->getProtocols()) {
       addProtocol(T);
     }
@@ -1301,8 +1303,7 @@ class ExistentialTypeInfoBuilder {
     if (auto *T = PC->getSuperclass()) {
       // Anything else should either be a superclass constraint, or
       // we have an invalid typeref.
-      if (!isa<NominalTypeRef>(T) &&
-          !isa<BoundGenericTypeRef>(T) &&
+      if (!isa<NominalTypeRef>(T) && !isa<BoundGenericTypeRef>(T) &&
           !isa<ObjCClassTypeRef>(T)) {
         DEBUG_LOG(fprintf(stderr, "Bad existential member: "); T->dump())
         Invalid = true;
@@ -1315,7 +1316,7 @@ class ExistentialTypeInfoBuilder {
         return;
       }
 
-      const auto &FD = TC.getBuilder().getFieldTypeInfo(T);
+      const auto &FD = TC.getBuilder().getFieldTypeInfo(T, ExternalTypeInfo);
       if (FD == nullptr) {
         DEBUG_LOG(fprintf(stderr, "No field descriptor: "); T->dump())
         Invalid = true;
@@ -1350,7 +1351,7 @@ class ExistentialTypeInfoBuilder {
   }
 
   const TypeInfo *build(remote::TypeInfoProvider *ExternalTypeInfo) {
-    examineProtocols();
+    examineProtocols(ExternalTypeInfo);
 
     if (Invalid)
       return nullptr;
@@ -1421,7 +1422,7 @@ class ExistentialTypeInfoBuilder {
   }
 
   const TypeInfo *buildMetatype(remote::TypeInfoProvider *ExternalTypeInfo) {
-    examineProtocols();
+    examineProtocols(ExternalTypeInfo);
 
     if (Invalid)
       return nullptr;
@@ -2226,7 +2227,7 @@ class LowerType
   }
 
   const TypeInfo *visitAnyNominalTypeRef(const TypeRef *TR) {
-    auto FD = TC.getBuilder().getFieldTypeInfo(TR);
+    auto FD = TC.getBuilder().getFieldTypeInfo(TR, ExternalTypeInfo);
     if (FD == nullptr || FD->isStruct()) {
       // Maybe this type is opaque -- look for a builtin
       // descriptor to see if we at least know its size
@@ -2325,7 +2326,7 @@ class LowerType
   const TypeInfo *
   visitProtocolCompositionTypeRef(const ProtocolCompositionTypeRef *PC) {
     ExistentialTypeInfoBuilder builder(TC);
-    builder.addProtocolComposition(PC);
+    builder.addProtocolComposition(PC, ExternalTypeInfo);
     return builder.build(ExternalTypeInfo);
   }
 
@@ -2354,7 +2355,7 @@ class LowerType
     auto *TR = EM->getInstanceType();
 
     if (auto *PC = dyn_cast<ProtocolCompositionTypeRef>(TR)) {
-      builder.addProtocolComposition(PC);
+      builder.addProtocolComposition(PC, ExternalTypeInfo);
     } else {
       DEBUG_LOG(fprintf(stderr, "Invalid existential metatype: "); EM->dump());
       return nullptr;
@@ -2515,7 +2516,7 @@ TypeConverter::getTypeInfo(const TypeRef *TR,
 const TypeInfo *TypeConverter::getClassInstanceTypeInfo(
     const TypeRef *TR, unsigned start,
     remote::TypeInfoProvider *ExternalTypeInfo) {
-  auto FD = getBuilder().getFieldTypeInfo(TR);
+  auto FD = getBuilder().getFieldTypeInfo(TR, ExternalTypeInfo);
   if (FD == nullptr) {
     DEBUG_LOG(fprintf(stderr, "No field descriptor: "); TR->dump());
     return nullptr;

stdlib/public/Reflection/TypeRef.cpp

@@ -1365,7 +1365,7 @@ class TypeRefSubstitution
         break;
 
       // If we didn't find the member type, check the superclass.
-      auto *Superclass = Builder.lookupSuperclass(SubstBase);
+      auto *Superclass = Builder.lookupSuperclass(SubstBase, nullptr);
       if (Superclass == nullptr)
         break;