Merge pull request swiftlang#33417 from adrian-prantl/55412920

Add a callback to swift::reflection::MemoryReader that allows LLDB to…

Author: adrian-prantl

include/swift/Demangling/TypeDecoder.h

@@ -349,9 +349,8 @@ class TypeDecoder {
 
   BuilderType &Builder;
 
- public:
-  explicit TypeDecoder(BuilderType &Builder)
-    : Builder(Builder) {}
+public:
+  explicit TypeDecoder(BuilderType &Builder) : Builder(Builder) {}
 
   /// Given a demangle tree, attempt to turn it into a type.
   TypeLookupErrorOr<BuiltType> decodeMangledType(NodePointer Node) {

include/swift/Reflection/ReflectionContext.h

@@ -680,7 +680,9 @@ class ReflectionContext
 
   /// Return a description of the layout of a class instance with the given
   /// metadata as its isa pointer.
-  const TypeInfo *getMetadataTypeInfo(StoredPointer MetadataAddress) {
+  const TypeInfo *
+  getMetadataTypeInfo(StoredPointer MetadataAddress,
+                      remote::TypeInfoProvider *ExternalTypeInfo) {
     // See if we cached the layout already
     auto found = Cache.find(MetadataAddress);
     if (found != Cache.end())
@@ -702,7 +704,7 @@ class ReflectionContext
 
         // Perform layout
         if (start)
-          TI = TC.getClassInstanceTypeInfo(TR, *start);
+          TI = TC.getClassInstanceTypeInfo(TR, *start, ExternalTypeInfo);
 
         break;
       }
@@ -718,7 +720,9 @@ class ReflectionContext
 
   /// Return a description of the layout of a class instance with the given
   /// metadata as its isa pointer.
-  const TypeInfo *getInstanceTypeInfo(StoredPointer ObjectAddress) {
+  const TypeInfo *
+  getInstanceTypeInfo(StoredPointer ObjectAddress,
+                      remote::TypeInfoProvider *ExternalTypeInfo) {
     auto MetadataAddress = readMetadataFromInstance(ObjectAddress);
     if (!MetadataAddress)
       return nullptr;
@@ -729,7 +733,7 @@ class ReflectionContext
 
     switch (*kind) {
     case MetadataKind::Class:
-      return getMetadataTypeInfo(*MetadataAddress);
+      return getMetadataTypeInfo(*MetadataAddress, ExternalTypeInfo);
 
     case MetadataKind::HeapLocalVariable: {
       auto CDAddr = this->readCaptureDescriptorFromMetadata(*MetadataAddress);
@@ -751,7 +755,7 @@ class ReflectionContext
 
       auto Info = getBuilder().getClosureContextInfo(CD);
 
-      return getClosureContextInfo(ObjectAddress, Info);
+      return getClosureContextInfo(ObjectAddress, Info, ExternalTypeInfo);
     }
 
     case MetadataKind::HeapGenericLocalVariable: {
@@ -760,7 +764,8 @@ class ReflectionContext
       if (auto Meta = readMetadata(*MetadataAddress)) {
         auto GenericHeapMeta =
           cast<TargetGenericBoxHeapMetadata<Runtime>>(Meta.getLocalBuffer());
-        return getMetadataTypeInfo(GenericHeapMeta->BoxedType);
+        return getMetadataTypeInfo(GenericHeapMeta->BoxedType,
+                                   ExternalTypeInfo);
       }
       return nullptr;
     }
@@ -774,15 +779,15 @@ class ReflectionContext
     }
   }
 
-  bool
-  projectExistential(RemoteAddress ExistentialAddress,
-                     const TypeRef *ExistentialTR,
-                     const TypeRef **OutInstanceTR,
-                     RemoteAddress *OutInstanceAddress) {
+  bool projectExistential(RemoteAddress ExistentialAddress,
+                          const TypeRef *ExistentialTR,
+                          const TypeRef **OutInstanceTR,
+                          RemoteAddress *OutInstanceAddress,
+                          remote::TypeInfoProvider *ExternalTypeInfo) {
     if (ExistentialTR == nullptr)
       return false;
 
-    auto ExistentialTI = getTypeInfo(ExistentialTR);
+    auto ExistentialTI = getTypeInfo(ExistentialTR, ExternalTypeInfo);
     if (ExistentialTI == nullptr)
       return false;
 
@@ -846,14 +851,14 @@ class ReflectionContext
   /// Returns true if the enum case could be successfully determined.  In
   /// particular, note that this code may return false for valid in-memory data
   /// if the compiler used a strategy we do not yet understand.
-  bool projectEnumValue(RemoteAddress EnumAddress,
-                        const TypeRef *EnumTR,
-                        int *CaseIndex) {
+  bool projectEnumValue(RemoteAddress EnumAddress, const TypeRef *EnumTR,
+                        int *CaseIndex,
+                        remote::TypeInfoProvider *ExternalTypeInfo) {
     // Get the TypeInfo and sanity-check it
     if (EnumTR == nullptr) {
       return false;
     }
-    auto TI = getTypeInfo(EnumTR);
+    auto TI = getTypeInfo(EnumTR, ExternalTypeInfo);
     if (TI == nullptr) {
       return false;
     }
@@ -865,11 +870,12 @@ class ReflectionContext
   }
 
   /// Return a description of the layout of a value with the given type.
-  const TypeInfo *getTypeInfo(const TypeRef *TR) {
+  const TypeInfo *getTypeInfo(const TypeRef *TR,
+                              remote::TypeInfoProvider *ExternalTypeInfo) {
     if (TR == nullptr) {
       return nullptr;
     } else {
-      return getBuilder().getTypeConverter().getTypeInfo(TR);
+      return getBuilder().getTypeConverter().getTypeInfo(TR, ExternalTypeInfo);
     }
   }
 
@@ -1160,8 +1166,9 @@ class ReflectionContext
   }
 
 private:
-  const TypeInfo *getClosureContextInfo(StoredPointer Context,
-                                        const ClosureContextInfo &Info) {
+  const TypeInfo *
+  getClosureContextInfo(StoredPointer Context, const ClosureContextInfo &Info,
+                        remote::TypeInfoProvider *ExternalTypeInfo) {
     RecordTypeInfoBuilder Builder(getBuilder().getTypeConverter(),
                                   RecordKind::ClosureContext);
 
@@ -1219,7 +1226,7 @@ class ReflectionContext
         SubstCaptureTR = OrigCaptureTR;
 
       if (SubstCaptureTR != nullptr) {
-        Builder.addField("", SubstCaptureTR);
+        Builder.addField("", SubstCaptureTR, ExternalTypeInfo);
         if (Builder.isInvalid())
           return nullptr;
 

include/swift/Reflection/TypeLowering.h

@@ -22,6 +22,7 @@
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/Casting.h"
 #include "swift/Remote/MetadataReader.h"
+#include "swift/Remote/TypeInfoProvider.h"
 
 #include <memory>
 
@@ -316,7 +317,8 @@ class ReferenceTypeInfo : public TypeInfo {
 class TypeConverter {
   TypeRefBuilder &Builder;
   std::vector<std::unique_ptr<const TypeInfo>> Pool;
-  llvm::DenseMap<const TypeRef *, const TypeInfo *> Cache;
+  llvm::DenseMap<std::pair<const TypeRef *, remote::TypeInfoProvider *>,
+                 const TypeInfo *> Cache;
   llvm::DenseSet<const TypeRef *> RecursionCheck;
   llvm::DenseMap<std::pair<unsigned, unsigned>,
                  const ReferenceTypeInfo *> ReferenceCache;
@@ -347,14 +349,16 @@ class TypeConverter {
   ///
   /// The type must either be concrete, or at least fixed-size, as
   /// determined by the isFixedSize() predicate.
-  const TypeInfo *getTypeInfo(const TypeRef *TR);
+  const TypeInfo *getTypeInfo(const TypeRef *TR,
+                              remote::TypeInfoProvider *externalInfo);
 
   /// Returns layout information for an instance of the given
   /// class.
   ///
   /// Not cached.
-  const TypeInfo *getClassInstanceTypeInfo(const TypeRef *TR,
-                                           unsigned start);
+  const TypeInfo *
+  getClassInstanceTypeInfo(const TypeRef *TR, unsigned start,
+                           remote::TypeInfoProvider *ExternalTypeInfo);
 
 private:
   friend class swift::reflection::LowerType;
@@ -415,7 +419,8 @@ class RecordTypeInfoBuilder {
                     bool bitwiseTakable);
 
   // Add a field of a record type, such as a struct.
-  void addField(const std::string &Name, const TypeRef *TR);
+  void addField(const std::string &Name, const TypeRef *TR,
+                remote::TypeInfoProvider *ExternalTypeInfo);
 
   const RecordTypeInfo *build();
 

include/swift/Reflection/TypeRef.h

@@ -156,8 +156,8 @@ class alignas(void *) TypeRef {
   bool isConcrete() const;
   bool isConcreteAfterSubstitutions(const GenericArgumentMap &Subs) const;
 
-  const TypeRef *
-  subst(TypeRefBuilder &Builder, const GenericArgumentMap &Subs) const;
+  const TypeRef *subst(TypeRefBuilder &Builder,
+                       const GenericArgumentMap &Subs) const;
 
   llvm::Optional<GenericArgumentMap> getSubstMap() const;
 
@@ -301,27 +301,48 @@ class BoundGenericTypeRef final : public TypeRef, public NominalTypeTrait {
 };
 
 class TupleTypeRef final : public TypeRef {
+protected:
   std::vector<const TypeRef *> Elements;
+  std::string Labels;
 
-  static TypeRefID Profile(const std::vector<const TypeRef *> &Elements) {
+  static TypeRefID Profile(const std::vector<const TypeRef *> &Elements,
+                           const std::string &Labels) {
     TypeRefID ID;
     for (auto Element : Elements)
       ID.addPointer(Element);
+    ID.addString(Labels);
     return ID;
   }
 
 public:
-  TupleTypeRef(std::vector<const TypeRef *> Elements)
-      : TypeRef(TypeRefKind::Tuple), Elements(std::move(Elements)) {}
+  TupleTypeRef(std::vector<const TypeRef *> Elements, std::string &&Labels)
+      : TypeRef(TypeRefKind::Tuple), Elements(std::move(Elements)),
+        Labels(Labels) {}
 
   template <typename Allocator>
   static const TupleTypeRef *create(Allocator &A,
-                                    std::vector<const TypeRef *> Elements) {
-    FIND_OR_CREATE_TYPEREF(A, TupleTypeRef, Elements);
-  }
-
-  const std::vector<const TypeRef *> &getElements() const {
-    return Elements;
+                                    std::vector<const TypeRef *> Elements,
+                                    std::string &&Labels) {
+    FIND_OR_CREATE_TYPEREF(A, TupleTypeRef, Elements, Labels);
+  }
+
+  const std::vector<const TypeRef *> &getElements() const { return Elements; };
+  const std::string &getLabelString() const { return Labels; };
+  std::vector<llvm::StringRef> getLabels() const {
+    std::vector<llvm::StringRef> Vec;
+    std::string::size_type End, Start = 0;
+    while (true) {
+      End = Labels.find(' ', Start);
+      if (End == std::string::npos)
+        break;
+      Vec.push_back(llvm::StringRef(Labels.data() + Start, End - Start));
+      Start = End + 1;
+    }
+    // A canonicalized TypeRef has an empty label string.
+    // Pad the vector with empty labels.
+    for (unsigned N = Vec.size(); N < Elements.size(); ++N)
+      Vec.push_back({});
+    return Vec;
   };
 
   static bool classof(const TypeRef *TR) {

include/swift/Reflection/TypeRefBuilder.h

@@ -405,9 +405,7 @@ class TypeRefBuilder {
 
   const TupleTypeRef *createTupleType(llvm::ArrayRef<const TypeRef *> elements,
                                       std::string &&labels) {
-    // FIXME: Add uniqueness checks in TupleTypeRef::Profile and
-    // unittests/Reflection/TypeRef.cpp if using labels for identity.
-    return TupleTypeRef::create(*this, elements);
+    return TupleTypeRef::create(*this, elements, std::move(labels));
   }
 
   const FunctionTypeRef *createFunctionType(
@@ -634,16 +632,14 @@ class TypeRefBuilder {
                     const std::string &Member,
                     StringRef Protocol);
 
-  const TypeRef *
-  lookupSuperclass(const TypeRef *TR);
+  const TypeRef *lookupSuperclass(const TypeRef *TR);
 
   /// Load unsubstituted field types for a nominal type.
-  RemoteRef<FieldDescriptor>
-  getFieldTypeInfo(const TypeRef *TR);
+  RemoteRef<FieldDescriptor> getFieldTypeInfo(const TypeRef *TR);
 
   /// Get the parsed and substituted field types for a nominal type.
-  bool getFieldTypeRefs(const TypeRef *TR,
-                        RemoteRef<FieldDescriptor> FD,
+  bool getFieldTypeRefs(const TypeRef *TR, RemoteRef<FieldDescriptor> FD,
+                        remote::TypeInfoProvider *ExternalTypeInfo,
                         std::vector<FieldTypeInfo> &Fields);
 
   /// Get the primitive type lowering for a builtin type.

include/swift/Remote/MemoryReader.h

@@ -37,7 +37,8 @@ namespace remote {
 class MemoryReader {
 public:
   /// A convenient name for the return type from readBytes.
-  using ReadBytesResult = std::unique_ptr<const void, std::function<void(const void *)>>;
+  using ReadBytesResult =
+      std::unique_ptr<const void, std::function<void(const void *)>>;
 
   virtual bool queryDataLayout(DataLayoutQueryType type, void *inBuffer,
                                void *outBuffer) = 0;
@@ -152,9 +153,8 @@ class MemoryReader {
 
     return resolvePointer(address, pointerData);
   }
-          
 
-  // Parse extra inhabitants stored in a pointer.
+ // Parse extra inhabitants stored in a pointer.
   // Sets *extraInhabitant to -1 if the pointer at this address
   // is actually a valid pointer.
   // Otherwise, it sets *extraInhabitant to the inhabitant

include/swift/Remote/TypeInfoProvider.h

@@ -0,0 +1,39 @@
+//===--- TypeInfoProvider.h - Abstract access to type info ------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 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
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file declares an abstract interface for reading type layout info.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_REMOTE_TYPEINFOPROVIDER_H
+#define SWIFT_REMOTE_TYPEINFOPROVIDER_H
+
+namespace swift {
+namespace reflection {
+class TypeInfo;
+}
+namespace remote {
+
+/// An abstract interface for providing external type layout information.
+struct TypeInfoProvider {
+  virtual ~TypeInfoProvider() = default;
+
+  /// Attempt to read type information about (Clang)imported types that are not
+  /// represented in the metadata. LLDB can read this information from debug
+  /// info, for example.
+  virtual const reflection::TypeInfo *
+  getTypeInfo(llvm::StringRef mangledName) = 0;
+};
+
+} // namespace remote
+} // namespace swift
+#endif

lib/AST/ASTDemangler.cpp

@@ -144,7 +144,7 @@ Type ASTBuilder::createNominalType(GenericTypeDecl *decl, Type parent) {
     return Type();
 
   // If the declaration is generic, fail.
-  if (nominalDecl->getGenericParams())
+  if (auto list = nominalDecl->getGenericParams())
     return Type();
 
   // Imported types can be renamed to be members of other (non-generic)