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

swift::reflection::TypeInfo for (Clang-)imported non-Objective-C types. This is
needed to reflect on the size mixed Swift / Clang types, when no type metadata
is available for the C types.

This is a necessary ingredient for the TypeRef-based Swift context in
LLDB. Because we do not have reflection metadata for pure C types in Swift,
reflection cannot compute TypeInfo for NominalTypeRefs for those types. By
providing this callback, LLDB can supply this information for DWARF, and
reflection can compute TypeInfos for mixed Swift/C types.

Author: adrian-prantl

include/swift/Demangling/TypeDecoder.h

@@ -328,9 +328,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.
   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>
 
@@ -347,14 +348,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 +418,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;
 

include/swift/Reflection/TypeRefBuilder.h

@@ -634,16 +634,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