Add interface for lookup up of externally stored type descriptors

Currently, TypeRefBuilder knows how to parse type descriptors from
reflection metadata. We aim to store the same information that lives
in type descriptors externally, as an effort to support embedded Swift
debugging. In order to take advantage of all of the existing type
information parsing code that exists today in remote mirrors, add an
interface for external lookup of type descriptors, and replace all the
usages of type descriptors with their generic counterpart (this patch
only adds support for builtin descriptors, but follow up patches will
add support for other descriptor types).

Author: augusto2112

include/swift/RemoteInspection/ExternalDescriptorFinder.h

@@ -0,0 +1,57 @@
+//===--------------- ExternalDescriptorFinder.h -----------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_REFLECTION_EXTERNAL_DESCRIPTOR_FINDER_H
+#define SWIFT_REFLECTION_EXTERNAL_DESCRIPTOR_FINDER_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace swift {
+namespace reflection {
+
+class TypeRef;
+
+enum class FieldDescriptorKind : uint16_t;
+
+/// A generic interface a builtin type descriptor.
+struct BuiltinTypeDescriptorInterface {
+  const uint32_t Size;
+  const uint32_t Alignment;
+  const uint32_t Stride;
+  const uint32_t NumExtraInhabitants;
+  const bool IsBitwiseTakable;
+  BuiltinTypeDescriptorInterface(uint32_t Size, uint32_t Alignment,
+                                 uint32_t Stride, uint32_t NumExtraInhabitants,
+                                 bool IsBitwiseTakable)
+      : Size(Size), Alignment(Alignment), Stride(Stride),
+        NumExtraInhabitants(NumExtraInhabitants),
+        IsBitwiseTakable(IsBitwiseTakable) {}
+
+  virtual ~BuiltinTypeDescriptorInterface() {};
+
+  virtual bool hasMangledTypeName() = 0;
+  virtual llvm::StringRef getMangledTypeName() = 0;
+  virtual llvm::StringRef readMangledTypeName() = 0;
+};
+
+// Interface for finding type descriptors that lives outside of reflection
+// metadata.
+struct ExternalDescriptorFinder {
+  virtual ~ExternalDescriptorFinder(){};
+
+  virtual std::unique_ptr<BuiltinTypeDescriptorInterface>
+  getBuiltinTypeInfoInterface(const TypeRef *TR) = 0;
+};
+
+} // namespace reflection
+} // namespace swift
+#endif

include/swift/RemoteInspection/TypeLowering.h

@@ -23,6 +23,7 @@
 #include "llvm/Support/Casting.h"
 #include "swift/Remote/MetadataReader.h"
 #include "swift/Remote/TypeInfoProvider.h"
+#include "swift/RemoteInspection/ExternalDescriptorFinder.h"
 
 #include <memory>
 
@@ -174,7 +175,7 @@ class BuiltinTypeInfo : public TypeInfo {
 
 public:
   explicit BuiltinTypeInfo(TypeRefBuilder &builder,
-                           RemoteRef<BuiltinTypeDescriptor> descriptor);
+                           BuiltinTypeDescriptorInterface *descriptor);
 
   /// Construct an empty builtin type info.
   BuiltinTypeInfo()

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -20,6 +20,7 @@
 
 #include "swift/Remote/ExternalTypeRefCache.h"
 #include "swift/Remote/MetadataReader.h"
+#include "swift/RemoteInspection/ExternalDescriptorFinder.h"
 #include "swift/RemoteInspection/MetadataSourceBuilder.h"
 #include "swift/RemoteInspection/Records.h"
 #include "swift/RemoteInspection/TypeLowering.h"
@@ -443,6 +444,8 @@ class TypeRefBuilder {
 
   remote::ExternalTypeRefCache *ExternalTypeRefCache = nullptr;
 
+  ExternalDescriptorFinder *DF;
+
 #define TYPEREF(Id, Parent) \
   std::unordered_map<TypeRefID, const Id##TypeRef *, \
                      TypeRefID::Hash, TypeRefID::Equal> Id##TypeRefs;
@@ -1129,9 +1132,10 @@ class TypeRefBuilder {
 
 public:
   template<typename Runtime>
-  TypeRefBuilder(remote::MetadataReader<Runtime, TypeRefBuilder> &reader,
-                 remote::ExternalTypeRefCache *externalCache = nullptr)
-      : TC(*this), ExternalTypeRefCache(externalCache),
+  TypeRefBuilder(remote::MetadataReader<Runtime, TypeRefBuilder> &reader, 
+                 remote::ExternalTypeRefCache *externalCache = nullptr, 
+                 ExternalDescriptorFinder *DF = nullptr)
+      : TC(*this), ExternalTypeRefCache(externalCache), DF(DF),
       PointerSize(sizeof(typename Runtime::StoredPointer)),
       TypeRefDemangler(
       [this, &reader](RemoteRef<char> string, bool useOpaqueTypeSymbolicReferences) -> Demangle::Node * {
@@ -1209,8 +1213,8 @@ class TypeRefBuilder {
                         remote::TypeInfoProvider *ExternalTypeInfo,
                         std::vector<FieldTypeInfo> &Fields);
 
-  /// Get the primitive type lowering for a builtin type.
-  RemoteRef<BuiltinTypeDescriptor> getBuiltinTypeInfo(const TypeRef *TR);
+  std::unique_ptr<BuiltinTypeDescriptorInterface>
+  getBuiltinTypeInfoInterface(const TypeRef *TR);
 
   /// Get the raw capture descriptor for a remote capture descriptor
   /// address.
@@ -1223,6 +1227,9 @@ class TypeRefBuilder {
   RemoteRef<MultiPayloadEnumDescriptor> getMultiPayloadEnumInfo(const TypeRef *TR);
 
 private:
+  /// Get the primitive type lowering for a builtin type.
+  RemoteRef<BuiltinTypeDescriptor> getBuiltinTypeInfo(const TypeRef *TR);
+
   llvm::Optional<uint64_t> multiPayloadEnumPointerMask;
 
 public:

stdlib/public/RemoteInspection/TypeLowering.cpp

@@ -230,16 +230,12 @@ void TypeInfo::dump(std::ostream &stream, unsigned Indent) const {
 }
 
 BuiltinTypeInfo::BuiltinTypeInfo(TypeRefBuilder &builder,
-                                 RemoteRef<BuiltinTypeDescriptor> descriptor)
-    : TypeInfo(TypeInfoKind::Builtin,
-               descriptor->Size,
-               descriptor->getAlignment(),
-               descriptor->Stride,
+                                 BuiltinTypeDescriptorInterface *descriptor)
+    : TypeInfo(TypeInfoKind::Builtin, descriptor->Size,
+               descriptor->Alignment, descriptor->Stride,
                descriptor->NumExtraInhabitants,
-               descriptor->isBitwiseTakable()),
-      Name(builder.getTypeRefString(
-              builder.readTypeRef(descriptor, descriptor->TypeName)))
-{}
+               descriptor->IsBitwiseTakable),
+      Name(descriptor->readMangledTypeName()) {}
 
 bool BuiltinTypeInfo::readExtraInhabitantIndex(
     remote::MemoryReader &reader, remote::RemoteAddress address,
@@ -1641,9 +1637,8 @@ const RecordTypeInfo *RecordTypeInfoBuilder::build() {
       Kind, Fields);
 }
 
-const ReferenceTypeInfo *
-TypeConverter::getReferenceTypeInfo(ReferenceKind Kind,
-                                    ReferenceCounting Refcounting) {
+const ReferenceTypeInfo *TypeConverter::getReferenceTypeInfo(
+    ReferenceKind Kind, ReferenceCounting Refcounting) {
   auto key = std::make_pair(unsigned(Kind), unsigned(Refcounting));
   auto found = ReferenceCache.find(key);
   if (found != ReferenceCache.end())
@@ -1664,7 +1659,7 @@ TypeConverter::getReferenceTypeInfo(ReferenceKind Kind,
   //
   // Weak references do not have any extra inhabitants.
 
-  auto BuiltinTI = Builder.getBuiltinTypeInfo(TR);
+  auto BuiltinTI = Builder.getBuiltinTypeInfoInterface(TR);
   if (BuiltinTI == nullptr) {
     DEBUG_LOG(fprintf(stderr, "No TypeInfo for reference type: "); TR->dump());
     return nullptr;
@@ -1689,7 +1684,7 @@ TypeConverter::getReferenceTypeInfo(ReferenceKind Kind,
   }
 
   auto *TI = makeTypeInfo<ReferenceTypeInfo>(BuiltinTI->Size,
-                                             BuiltinTI->getAlignment(),
+                                             BuiltinTI->Alignment,
                                              BuiltinTI->Stride,
                                              numExtraInhabitants,
                                              bitwiseTakable,
@@ -1705,13 +1700,14 @@ TypeConverter::getThinFunctionTypeInfo() {
   if (ThinFunctionTI != nullptr)
     return ThinFunctionTI;
 
-  auto descriptor = getBuilder().getBuiltinTypeInfo(getThinFunctionTypeRef());
+  auto descriptor =
+      getBuilder().getBuiltinTypeInfoInterface(getThinFunctionTypeRef());
   if (descriptor == nullptr) {
     DEBUG_LOG(fprintf(stderr, "No TypeInfo for function type\n"));
     return nullptr;
   }
 
-  ThinFunctionTI = makeTypeInfo<BuiltinTypeInfo>(getBuilder(), descriptor);
+  ThinFunctionTI = makeTypeInfo<BuiltinTypeInfo>(getBuilder(), descriptor.get());
 
   return ThinFunctionTI;
 }
@@ -1739,13 +1735,14 @@ TypeConverter::getAnyMetatypeTypeInfo() {
   if (AnyMetatypeTI != nullptr)
     return AnyMetatypeTI;
 
-  auto descriptor = getBuilder().getBuiltinTypeInfo(getAnyMetatypeTypeRef());
+  auto descriptor =
+      getBuilder().getBuiltinTypeInfoInterface(getAnyMetatypeTypeRef());
   if (descriptor == nullptr) {
     DEBUG_LOG(fprintf(stderr, "No TypeInfo for metatype type\n"));
     return nullptr;
   }
 
-  AnyMetatypeTI = makeTypeInfo<BuiltinTypeInfo>(getBuilder(), descriptor);
+  AnyMetatypeTI = makeTypeInfo<BuiltinTypeInfo>(getBuilder(), descriptor.get());
 
   return AnyMetatypeTI;
 }
@@ -2245,7 +2242,7 @@ class EnumTypeInfoBuilder {
 
     // Do we have a fixed layout?
     // TODO: Test whether a missing FixedDescriptor is actually relevant.
-    auto FixedDescriptor = TC.getBuilder().getBuiltinTypeInfo(TR);
+    auto FixedDescriptor = TC.getBuilder().getBuiltinTypeInfoInterface(TR);
     if (!FixedDescriptor || GenericPayloadCases > 0) {
       // This is a "dynamic multi-payload enum".  For example,
       // this occurs with:
@@ -2283,9 +2280,9 @@ class EnumTypeInfoBuilder {
     //  * Has at least two cases with non-zero payload size
     //  * Has a descriptor stored as BuiltinTypeInfo
     Size = FixedDescriptor->Size;
-    Alignment = FixedDescriptor->getAlignment();
+    Alignment = FixedDescriptor->Alignment;
     NumExtraInhabitants = FixedDescriptor->NumExtraInhabitants;
-    BitwiseTakable = FixedDescriptor->isBitwiseTakable();
+    BitwiseTakable = FixedDescriptor->IsBitwiseTakable;
     unsigned Stride = ((Size + Alignment - 1) & ~(Alignment - 1));
     if (Stride == 0)
       Stride = 1;
@@ -2395,12 +2392,12 @@ class LowerType
 
     /// Otherwise, get the fixed layout information from reflection
     /// metadata.
-    auto descriptor = TC.getBuilder().getBuiltinTypeInfo(B);
+    auto descriptor = TC.getBuilder().getBuiltinTypeInfoInterface(B);
     if (descriptor == nullptr) {
       DEBUG_LOG(fprintf(stderr, "No TypeInfo for builtin type: "); B->dump());
       return nullptr;
     }
-    return TC.makeTypeInfo<BuiltinTypeInfo>(TC.getBuilder(), descriptor);
+    return TC.makeTypeInfo<BuiltinTypeInfo>(TC.getBuilder(), descriptor.get());
   }
 
   const TypeInfo *visitAnyNominalTypeRef(const TypeRef *TR) {
@@ -2424,15 +2421,15 @@ class LowerType
       // descriptor to see if we at least know its size
       // and alignment.
       if (auto ImportedTypeDescriptor =
-              TC.getBuilder().getBuiltinTypeInfo(TR)) {
+              TC.getBuilder().getBuiltinTypeInfoInterface(TR)) {
         // This might be an external type we treat as opaque (like C structs),
         // the external type info provider might have better type information,
         // so ask it first.
         if (auto External = QueryExternalTypeInfoProvider())
           return External;
 
         return TC.makeTypeInfo<BuiltinTypeInfo>(TC.getBuilder(),
-                                                ImportedTypeDescriptor);
+                                                ImportedTypeDescriptor.get());
       }
 
       if (FD == nullptr) {

stdlib/public/RemoteInspection/TypeRefBuilder.cpp

@@ -460,6 +460,45 @@ TypeRefBuilder::getBuiltinTypeInfo(const TypeRef *TR) {
   return nullptr;
 }
 
+class BuiltinTypeDescriptorImpl : public BuiltinTypeDescriptorInterface {
+  RemoteRef<BuiltinTypeDescriptor> BTD;
+  TypeRefBuilder &Builder;
+
+public:
+  BuiltinTypeDescriptorImpl(RemoteRef<BuiltinTypeDescriptor> BTD,
+                            TypeRefBuilder &Builder)
+      : BuiltinTypeDescriptorInterface(BTD->Size, BTD->getAlignment(),
+                                       BTD->Stride, BTD->NumExtraInhabitants,
+                                       BTD->isBitwiseTakable()),
+        BTD(BTD), Builder(Builder) {}
+
+  ~BuiltinTypeDescriptorImpl() override {}
+
+  bool hasMangledTypeName() override {
+    return BTD->hasMangledTypeName();
+  }
+
+  llvm::StringRef getMangledTypeName() override {
+    return BTD->getMangledTypeName();
+  }
+
+  StringRef readMangledTypeName() override {
+    return Builder.getTypeRefString(Builder.readTypeRef(BTD, BTD->TypeName));
+  };
+};
+
+std::unique_ptr<BuiltinTypeDescriptorInterface>
+TypeRefBuilder::getBuiltinTypeInfoInterface(const TypeRef *TR) {
+  if (DF) 
+    if (auto descriptor = DF->getBuiltinTypeInfoInterface(TR))
+      return descriptor;
+
+  auto BTI = getBuiltinTypeInfo(TR);
+  if (!BTI)
+    return nullptr;
+  return std::make_unique<BuiltinTypeDescriptorImpl>(BTI, *this);
+}
+
 RemoteRef<MultiPayloadEnumDescriptor>
 TypeRefBuilder::getMultiPayloadEnumInfo(const TypeRef *TR) {
   std::string MangledName;