Add interface for lookup of external MultiPayloadEnumDescriptor

This is a follow up patch that allows for external DescriptorFinders to
provide MultiPayloadEnumDescriptors (this is done to support embedded
Swift debugging, which encodes the equivalent of Swift metadata as
DWARF).

Author: augusto2112

include/swift/RemoteInspection/DescriptorFinder.h

@@ -93,6 +93,26 @@ struct FieldDescriptorBase {
   getFieldRecords() = 0;
 };
 
+struct MultiPayloadEnumDescriptorBase {
+  virtual ~MultiPayloadEnumDescriptorBase(){};
+
+  virtual llvm::StringRef getMangledTypeName() = 0;
+
+  virtual uint32_t getContentsSizeInWords() const = 0;
+
+  virtual size_t getSizeInBytes() const = 0;
+
+  virtual uint32_t getFlags() const = 0;
+
+  virtual bool usesPayloadSpareBits() const = 0;
+
+  virtual uint32_t getPayloadSpareBitMaskByteOffset() const = 0;
+
+  virtual uint32_t getPayloadSpareBitMaskByteCount() const = 0;
+
+  virtual const uint8_t *getPayloadSpareBits() const = 0;
+
+};
 /// Interface for finding type descriptors. Implementors may provide descriptors
 /// that live inside or outside reflection metadata.
 struct DescriptorFinder {
@@ -104,6 +124,9 @@ struct DescriptorFinder {
 
   virtual std::unique_ptr<FieldDescriptorBase>
   getFieldDescriptor(const TypeRef *TR) = 0;
+
+  virtual std::unique_ptr<MultiPayloadEnumDescriptorBase>
+  getMultiPayloadEnumDescriptor(const TypeRef *TR) = 0;
 };
 
 } // namespace reflection

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -490,8 +490,8 @@ class TypeRefBuilder {
     ClosureContextInfo getClosureContextInfo(RemoteRef<CaptureDescriptor> CD);
 
     /// Get the multipayload enum projection information for a given TR
-    RemoteRef<MultiPayloadEnumDescriptor>
-    getMultiPayloadEnumInfo(const TypeRef *TR);
+    std::unique_ptr<MultiPayloadEnumDescriptorBase>
+    getMultiPayloadEnumDescriptor(const TypeRef *TR) override;
 
     const TypeRef *lookupTypeWitness(const std::string &MangledTypeName,
                                      const std::string &Member,
@@ -515,6 +515,8 @@ class TypeRefBuilder {
     /// Load unsubstituted field types for a nominal type.
     RemoteRef<FieldDescriptor> getFieldTypeInfo(const TypeRef *TR);
 
+    RemoteRef<MultiPayloadEnumDescriptor> getMultiPayloadEnumInfo(const TypeRef *TR);
+
     void populateFieldTypeInfoCacheWithReflectionAtIndex(size_t Index);
 
     llvm::Optional<RemoteRef<FieldDescriptor>>
@@ -1565,15 +1567,16 @@ class TypeRefBuilder {
   }
 
   /// Get the multipayload enum projection information for a given TR
-  RemoteRef<MultiPayloadEnumDescriptor>
-  getMultiPayloadEnumInfo(const TypeRef *TR) {
-    return RDF.getMultiPayloadEnumInfo(TR);
-  }
+  std::unique_ptr<MultiPayloadEnumDescriptorBase>
+  getMultiPayloadEnumDescriptor(const TypeRef *TR);
 
 private:
   /// Get the primitive type lowering for a builtin type.
   RemoteRef<BuiltinTypeDescriptor> getBuiltinTypeInfo(const TypeRef *TR);
 
+  RemoteRef<MultiPayloadEnumDescriptor>
+  getMultiPayloadEnumInfo(const TypeRef *TR);
+
   llvm::Optional<uint64_t> multiPayloadEnumPointerMask;
 
 public:

stdlib/public/RemoteInspection/TypeLowering.cpp

@@ -2294,7 +2294,7 @@ class EnumTypeInfoBuilder {
     // Uncomment the following line to dump the MPE section every time we come through here...
     //TC.getBuilder().dumpMultiPayloadEnumSection(std::cerr); // DEBUG helper
 
-    auto MPEDescriptor = TC.getBuilder().getMultiPayloadEnumInfo(TR);
+    auto MPEDescriptor = TC.getBuilder().getMultiPayloadEnumDescriptor(TR);
     if (MPEDescriptor && MPEDescriptor->usesPayloadSpareBits()) {
       auto PayloadSpareBitMaskByteCount = MPEDescriptor->getPayloadSpareBitMaskByteCount();
       auto PayloadSpareBitMaskByteOffset = MPEDescriptor->getPayloadSpareBitMaskByteOffset();

stdlib/public/RemoteInspection/TypeRefBuilder.cpp

@@ -574,6 +574,50 @@ TypeRefBuilder::getBuiltinTypeDescriptor(const TypeRef *TR) {
   return nullptr;
 }
 
+namespace {
+/// A builtin type descriptor implementation that wraps a reflection builtin
+/// type descriptor.
+class MultiPayloadEnumDescriptorImpl : public MultiPayloadEnumDescriptorBase {
+  RemoteRef<MultiPayloadEnumDescriptor> MPED;
+  TypeRefBuilder &Builder;
+
+public:
+  MultiPayloadEnumDescriptorImpl(RemoteRef<MultiPayloadEnumDescriptor> MPED,
+                                 TypeRefBuilder &Builder)
+      : MultiPayloadEnumDescriptorBase(), MPED(MPED), Builder(Builder) {}
+
+  ~MultiPayloadEnumDescriptorImpl() override {}
+
+  StringRef getMangledTypeName() override {
+    return Builder.getTypeRefString(Builder.readTypeRef(MPED, MPED->TypeName));
+  };
+
+  uint32_t getContentsSizeInWords() const override {
+    return MPED->getContentsSizeInWords();
+  }
+
+  size_t getSizeInBytes() const override { return MPED->getSizeInBytes(); }
+
+  uint32_t getFlags() const override { return MPED->getFlags(); }
+
+  bool usesPayloadSpareBits() const override {
+    return MPED->usesPayloadSpareBits();
+  }
+
+  uint32_t getPayloadSpareBitMaskByteOffset() const override {
+    return MPED->getPayloadSpareBitMaskByteOffset();
+  }
+
+  uint32_t getPayloadSpareBitMaskByteCount() const override {
+    return MPED->getPayloadSpareBitMaskByteCount();
+  }
+
+  const uint8_t *getPayloadSpareBits() const override {
+    return MPED->getPayloadSpareBits();
+  }
+};
+} // namespace
+  
 RemoteRef<MultiPayloadEnumDescriptor>
 TypeRefBuilder::ReflectionTypeDescriptorFinder::getMultiPayloadEnumInfo(
     const TypeRef *TR) {
@@ -620,6 +664,23 @@ TypeRefBuilder::ReflectionTypeDescriptorFinder::getMultiPayloadEnumInfo(
   return nullptr;
 }
 
+std::unique_ptr<MultiPayloadEnumDescriptorBase>
+TypeRefBuilder::ReflectionTypeDescriptorFinder::getMultiPayloadEnumDescriptor(
+    const TypeRef *TR) {
+  if (auto BTI = getMultiPayloadEnumInfo(TR))
+    return std::make_unique<MultiPayloadEnumDescriptorImpl>(BTI, Builder);
+  return nullptr;
+}
+
+std::unique_ptr<MultiPayloadEnumDescriptorBase>
+TypeRefBuilder::getMultiPayloadEnumDescriptor(const TypeRef *TR) {
+  for (auto *DF : getDescriptorFinders())
+    if (auto descriptor = DF->getMultiPayloadEnumDescriptor(TR))
+      return descriptor;
+
+  return nullptr;
+}
+
 RemoteRef<CaptureDescriptor>
 TypeRefBuilder::ReflectionTypeDescriptorFinder::getCaptureDescriptor(
     uint64_t RemoteAddress) {