Store the type parameters of bound generics in the debug info.

This is needed to anchor any typedefs that appear in bound generic parameters so
they can be resolved in the typeref-based part of the debugger without needing
to query the Swift module.

Author: adrian-prantl

lib/IRGen/DebugTypeInfo.cpp

@@ -29,7 +29,6 @@ DebugTypeInfo::DebugTypeInfo(swift::Type Ty, llvm::Type *StorageTy, Size size,
                              bool IsMetadata)
     : Type(Ty.getPointer()), StorageType(StorageTy), size(size), align(align),
       DefaultAlignment(HasDefaultAlignment), IsMetadataType(IsMetadata) {
-  assert(StorageType && "StorageType is a nullptr");
   assert(align.getValue() != 0);
 }
 
@@ -53,6 +52,7 @@ DebugTypeInfo DebugTypeInfo::getFromTypeInfo(swift::Type Ty,
     // encounter one.
     size = Size(0);
   }
+  assert(Info.getStorageType() && "StorageType is a nullptr");
   return DebugTypeInfo(Ty.getPointer(), Info.getStorageType(), size,
                        Info.getBestKnownAlignment(), hasDefaultAlignment(Ty),
                        false);
@@ -80,6 +80,7 @@ DebugTypeInfo DebugTypeInfo::getMetadata(swift::Type Ty, llvm::Type *StorageTy,
                                          Size size, Alignment align) {
   DebugTypeInfo DbgTy(Ty.getPointer(), StorageTy, size,
                       align, true, false);
+  assert(StorageTy && "StorageType is a nullptr");
   assert(!DbgTy.isContextArchetype() && "type metadata cannot contain an archetype");
   return DbgTy;
 }
@@ -88,10 +89,17 @@ DebugTypeInfo DebugTypeInfo::getArchetype(swift::Type Ty, llvm::Type *StorageTy,
                                           Size size, Alignment align) {
   DebugTypeInfo DbgTy(Ty.getPointer(), StorageTy, size,
                       align, true, true);
+  assert(StorageTy && "StorageType is a nullptr");
   assert(!DbgTy.isContextArchetype() && "type metadata cannot contain an archetype");
   return DbgTy;
 }
 
+DebugTypeInfo DebugTypeInfo::getForwardDecl(swift::Type Ty) {
+  DebugTypeInfo DbgTy(Ty.getPointer(), nullptr, {}, Alignment(1), true,
+                      false);
+  return DbgTy;
+}
+
 DebugTypeInfo DebugTypeInfo::getGlobal(SILGlobalVariable *GV,
                                        llvm::Type *StorageTy, Size size,
                                        Alignment align) {
@@ -118,6 +126,7 @@ DebugTypeInfo DebugTypeInfo::getObjCClass(ClassDecl *theClass,
                                           Alignment align) {
   DebugTypeInfo DbgTy(theClass->getInterfaceType().getPointer(), StorageType,
                       size, align, true, false);
+  assert(StorageType && "StorageType is a nullptr");
   assert(!DbgTy.isContextArchetype() && "type of objc class cannot be an archetype");
   return DbgTy;
 }

lib/IRGen/DebugTypeInfo.h

@@ -63,6 +63,9 @@ class DebugTypeInfo {
   static DebugTypeInfo getArchetype(swift::Type Ty, llvm::Type *StorageTy,
                                     Size size, Alignment align);
 
+  /// Create a forward declaration for a type whose size is unknown.
+  static DebugTypeInfo getForwardDecl(swift::Type Ty);
+
   /// Create a standalone type from a TypeInfo object.
   static DebugTypeInfo getFromTypeInfo(swift::Type Ty, const TypeInfo &Info);
   /// Global variables.
@@ -89,6 +92,7 @@ class DebugTypeInfo {
   }
 
   bool isNull() const { return Type == nullptr; }
+  bool isForwardDecl() const { return StorageType == nullptr; }
   bool operator==(DebugTypeInfo T) const;
   bool operator!=(DebugTypeInfo T) const;
 

lib/IRGen/IRGenDebugInfo.cpp

@@ -92,6 +92,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
   llvm::DenseMap<const void *, llvm::TrackingMDNodeRef> DIModuleCache;
   llvm::StringMap<llvm::TrackingMDNodeRef> DIFileCache;
   TrackingDIRefMap DIRefMap;
+  TrackingDIRefMap InnerTypeCache;
   /// @}
 
   /// A list of replaceable fwddecls that need to be RAUWed at the end.
@@ -1003,23 +1004,44 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     return BitWidth;
   }
 
+  /// Collect the type parameters of a bound generic type. This is needed to
+  /// anchor any typedefs that may appear in parameters so they can be
+  /// resolved in the debugger without needing to query the Swift module.
+  llvm::DINodeArray collectGenericParams(BoundGenericType *BGT) {
+      SmallVector<llvm::Metadata *, 16> TemplateParams;
+      for (auto Param : BGT->getGenericArgs()) {
+        TemplateParams.push_back(DBuilder.createTemplateTypeParameter(
+            TheCU, "", getOrCreateType(DebugTypeInfo::getForwardDecl(Param))));
+      }
+      return DBuilder.getOrCreateArray(TemplateParams);
+  }
+  
   /// Create a sized container for a sizeless type. Used to represent
   /// BoundGenericEnums that may have different sizes depending on what they are
   /// bound to, but still share a mangled name.
   llvm::DIType *createOpaqueStructWithSizedContainer(
       llvm::DIScope *Scope, StringRef Name, llvm::DIFile *File, unsigned Line,
       unsigned SizeInBits, unsigned AlignInBits, llvm::DINode::DIFlags Flags,
-      StringRef MangledName) {
-    // Let the MDNode folding set do the work of uniquing the inner type. This
-    // should be cheap.
-    llvm::DICompositeType *UniqueType = DBuilder.createStructType(
-        Scope, Name, File, Line, 0, 0, Flags, nullptr,
-        DBuilder.getOrCreateArray(ArrayRef<llvm::Metadata *>()),
-        llvm::dwarf::DW_LANG_Swift, nullptr, MangledName);
+      StringRef MangledName, llvm::DINodeArray BoundParams) {
+    // This uses a separate cache and not DIRefMap for the inner type to avoid
+    // associating the anonymous container (which is specific to the
+    // variable/storage and not the type) with the MangledName.
+    llvm::DICompositeType *UniqueType = nullptr;
+    auto *UID = llvm::MDString::get(IGM.getLLVMContext(), MangledName);
+    if (llvm::Metadata *V = InnerTypeCache.lookup(UID))
+      UniqueType = cast<llvm::DICompositeType>(V);
+    else {
+      UniqueType = DBuilder.createStructType(
+          Scope, Name, File, Line, 0, 0, Flags, nullptr, nullptr,
+          llvm::dwarf::DW_LANG_Swift, nullptr, MangledName);
+      if (BoundParams)
+        DBuilder.replaceArrays(UniqueType, nullptr, BoundParams);
+      InnerTypeCache[UID] = llvm::TrackingMDNodeRef(UniqueType);
+    }
+
     llvm::Metadata *Elements[] = {
         DBuilder.createMemberType(Scope, "", File, 0, SizeInBits,
                                   AlignInBits, 0, Flags, UniqueType)};
-
     return DBuilder.createStructType(
         Scope, "", File, Line, SizeInBits, AlignInBits, Flags,
         /* DerivedFrom */ nullptr, DBuilder.getOrCreateArray(Elements),
@@ -1332,7 +1354,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
       auto L = getDebugLoc(*this, Decl);
       return createOpaqueStructWithSizedContainer(
           Scope, Decl ? Decl->getNameStr() : "", File, L.Line, SizeInBits,
-          AlignInBits, Flags, MangledName);
+          AlignInBits, Flags, MangledName, collectGenericParams(StructTy));
     }
 
     case TypeKind::BoundGenericClass: {
@@ -1441,7 +1463,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
       auto *File = getOrCreateFile(L.Filename);
       return createOpaqueStructWithSizedContainer(
           Scope, Decl->getName().str(), File, L.Line, SizeInBits, AlignInBits,
-          Flags, MangledName);
+          Flags, MangledName, collectGenericParams(EnumTy));
     }
 
     case TypeKind::BuiltinVector: {
@@ -1637,8 +1659,24 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
       if (Decl->isOutermostPrivateOrFilePrivateScope())
         Scope = getFilePrivateScope(Scope, Decl);
 
+    // If this is a forward decl, create one for this mangled name and don't
+    // cache it.
+    if (DbgTy.isForwardDecl() && !isa<TypeAliasType>(DbgTy.getType())) {
+      auto *FwdDecl = DBuilder.createReplaceableCompositeType(
+          llvm::dwarf::DW_TAG_structure_type, MangledName, Scope, 0, 0,
+          llvm::dwarf::DW_LANG_Swift, 0, 0, llvm::DINode::FlagFwdDecl,
+          MangledName);
+      ReplaceMap.emplace_back(
+        std::piecewise_construct, std::make_tuple(DbgTy.getType()),
+          std::make_tuple(static_cast<llvm::Metadata *>(FwdDecl)));
+      return FwdDecl;
+    }
     llvm::DIType *DITy = createType(DbgTy, MangledName, Scope, getFile(Scope));
 
+    // Don't cache a type alias to a forward declaration either.
+    if (DbgTy.isForwardDecl())
+      return DITy;
+
     // Incrementally build the DIRefMap.
     if (auto *CTy = dyn_cast<llvm::DICompositeType>(DITy)) {
 #ifndef NDEBUG

test/DebugInfo/BoundGenericStruct.swift

@@ -0,0 +1,12 @@
+// RUN: %target-swift-frontend %s -O -emit-ir -g -o - | %FileCheck %s
+public struct S<T> {
+  let t : T
+}
+
+public let s = S<Int>(t: 0)
+
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "S",
+// CHECK-SAME:             templateParams: ![[PARAMS:[0-9]+]], identifier:
+// CHECK: ![[PARAMS]] = !{![[INTPARAM:[0-9]+]]}
+// CHECK: ![[INTPARAM]] = !DITemplateTypeParameter(type: ![[INT:[0-9]+]])
+// CHECK: ![[INT]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Int",

test/DebugInfo/enum.swift

@@ -59,7 +59,7 @@ public enum Nothing { }
 public func foo(_ empty : Nothing) { }
 // CHECK: !DICompositeType({{.*}}name: "Nothing", {{.*}}elements: ![[EMPTY]]
 
-// CHECK: !DICompositeType({{.*}}name: "Rose", {{.*}}elements: ![[ELTS:[0-9]+]],
+// CHECK: !DICompositeType({{.*}}name: "Rose",
 // CHECK-SAME:             {{.*}}identifier: "$s4enum4RoseOyxG{{z?}}D")
 enum Rose<A> {
 	case MkRose(() -> A, () -> [Rose<A>])
@@ -69,8 +69,8 @@ enum Rose<A> {
 
 func foo<T>(_ x : Rose<T>) -> Rose<T> { return x }
 
-// CHECK: !DICompositeType({{.*}}name: "Tuple", {{.*}}elements: ![[ELTS:[0-9]+]], {{.*}}identifier: "$s4enum5TupleOyxGD")
-// DWARF: !DICompositeType({{.*}}name: "Tuple", {{.*}}elements: ![[ELTS:[0-9]+]],
+// CHECK: !DICompositeType({{.*}}name: "Tuple", {{.*}}identifier: "$s4enum5TupleOyxGD")
+// DWARF: !DICompositeType({{.*}}name: "Tuple",
 // DWARF-SAME:             {{.*}}identifier: "$s4enum5TupleOyxG{{z?}}D")
 public enum Tuple<P> {
 	case C(P, () -> Tuple)