Merge pull request #28020 from adrian-prantl/56521648

Debug Info: Avoid type uniquing clashes for bound generic enums.

Author: adrian-prantl

lib/IRGen/IRGenDebugInfo.cpp

@@ -1001,6 +1001,29 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     return BitWidth;
   }
 
+  /// 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);
+    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),
+        llvm::dwarf::DW_LANG_Swift);
+  }
+
   llvm::DIType *createPointerSizedStruct(llvm::DIScope *Scope, StringRef Name,
                                          llvm::DIFile *File, unsigned Line,
                                          llvm::DINode::DIFlags Flags,
@@ -1414,12 +1437,9 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
       auto *Decl = EnumTy->getDecl();
       auto L = getDebugLoc(*this, Decl);
       auto *File = getOrCreateFile(L.Filename);
-      if (Opts.DebugInfoLevel > IRGenDebugInfoLevel::ASTTypes)
-        return createEnumType(DbgTy, Decl, MangledName, Scope, File, L.Line,
-                              Flags);
-      else
-        return createOpaqueStruct(Scope, Decl->getName().str(), File, L.Line,
-                                  SizeInBits, AlignInBits, Flags, MangledName);
+      return createOpaqueStructWithSizedContainer(
+          Scope, Decl->getName().str(), File, L.Line, SizeInBits, AlignInBits,
+          Flags, MangledName);
     }
 
     case TypeKind::BuiltinVector: {

test/DebugInfo/BoundGenericEnum.swift

@@ -0,0 +1,87 @@
+// RUN: %target-swift-frontend %s -Onone -emit-ir -g -o - -module-name a \
+// RUN:   -disable-debugger-shadow-copies | %FileCheck %s
+public enum Result<Value> {
+  case success(Value)
+  case failure(Error)
+}
+
+extension Result {
+  public func map<U>(_ transform: (Value) -> U) -> Result<U> {
+    switch self {
+    case .success(let value):
+      return .success(transform(value))
+    case .failure(let error):
+      return .failure(error)
+    }
+  }
+}
+
+func use<T>(_ t : T) {
+}
+
+public class SomeClass {
+  public let s = "hello"
+}
+
+extension Result where Value : SomeClass {
+  public func f() -> Self {
+    use(self)
+    return map({ $0 })
+  }  
+}
+
+extension Result {
+  public func g() {
+    use(self)
+  }  
+}
+
+let x : Result<SomeClass> = .success(SomeClass())
+let y : Result<(Int64, Int64, Int64, Int64)> = .success((1, 2, 3, 4))
+x.f()
+y.g()
+
+// Here we have three types, all named $s1a6ResultOyxGD (---> a.Result<A>),
+// but with different storage sizes:
+//
+//   0. Unsized from the subroutine tupe of map<U>.
+//   1. Enum wrapping a pointer-sized object [map() and f()].
+//   2. Enum wrapping a 4x64-bit tuple.
+//
+// Test that bound generic enums are *not* using their mangled name as a unique
+// identifier.
+
+// (0) unsized.
+// CHECK: !DISubprogram(name: "map", {{.*}}line: 9, type: ![[SBTY:[0-9]+]]
+// CHECK: ![[SBTY]] = !DISubroutineType(types: ![[SBTYS:[0-9]+]])
+// CHECK: ![[SBTYS]] = !{!{{[0-9]+}}, !{{[0-9]+}}, ![[SELFTY:[0-9]+]]}
+// CHECK: ![[SELFTY]] =
+// CHECK-SAME:  !DICompositeType(tag: DW_TAG_structure_type, {{.*}}line: 3,
+// CHECK-SAME:                   elements: ![[UNSIZED_ELTS:[0-9]+]]
+// CHECK: ![[UNSIZED_ELTS]] = !{![[UNSIZED_MEM:[0-9]+]]}
+// CHECK: ![[UNSIZED_MEM]] = !DIDerivedType(tag: DW_TAG_member,
+// CHECK-SAME:                              baseType: ![[UNIQ:[0-9]+]]
+
+// The unique unsized type.
+// CHECK: ![[UNIQ]] = !DICompositeType(
+// CHECK-SAME:            tag: DW_TAG_structure_type, name: "Result",
+// CHECK-SAME:            line: 3,
+// CHECK-NOT:             size:
+// CHECK-SAME:            runtimeLang: DW_LANG_Swift,
+// CHECK-SAME:            identifier: "$s1a6ResultOyxGD")
+
+// (2)
+// CHECK: !DILocalVariable(name: "self", arg: 2, {{.*}}line: 9,
+// CHECK-SAME:             type: ![[C_TUP:[0-9]+]]
+// CHECK: ![[C_TUP]] = !DIDerivedType(tag: DW_TAG_const_type,
+// CHECK-SAME:                        baseType: ![[TUP:[0-9]+]])
+// CHECK: ![[TUP]] = !DICompositeType(tag: DW_TAG_structure_type,
+// CHECK-SAME:                        line: 3, size: {{256|512}},
+
+// (1)
+// CHECK: !DILocalVariable(name: "self", arg: 1, {{.*}}line: 27,
+// CHECK-SAME:             type: ![[C_CLASS:[0-9]+]]
+// CHECK: ![[C_CLASS]] = !DIDerivedType(tag: DW_TAG_const_type,
+// CHECK-SAME:                          baseType: ![[CLASS:[0-9]+]])
+// CHECK: ![[CLASS]] = !DICompositeType(tag: DW_TAG_structure_type,
+// CHECK-SAME:                          line: 3, size:

test/DebugInfo/bound-namealiastype.swift

@@ -9,7 +9,10 @@ func dispatch_queue_create() -> dispatch_queue_t! {
 }
 
 // CHECK: !DIGlobalVariable(name: "queue",
-// CHECK-SAME:              line: [[@LINE+3]], type: ![[T:[0-9]+]]
-// CHECK: ![[T]] = !DICompositeType(
+// CHECK-SAME:              line: [[@LINE+6]], type: ![[TY_CONTAINER:[0-9]+]]
+// CHECK: ![[TY_CONTAINER]] = !DICompositeType({{.*}}elements: ![[TY_ELTS:[0-9]+]]
+// CHECK: ![[TY_ELTS]] = !{![[TY_MEMBER:[0-9]+]]}
+// CHECK: ![[TY_MEMBER]] = !DIDerivedType(tag: DW_TAG_member, {{.*}}baseType: ![[TY:[0-9]+]]
+// CHECK: ![[TY]] = !DICompositeType(
 // CHECK-SAME:             identifier: "$s4main16dispatch_queue_taSgD"
 public var queue = dispatch_queue_create()

test/DebugInfo/enum.swift

@@ -52,7 +52,6 @@ let r = Color.Red
 let c = MaybeIntPair.just(74, 75)
 // CHECK: !DICompositeType({{.*}}name: "Maybe",
 // CHECK-SAME:             line: [[@LINE-8]],
-// CHECK-SAME:             size: 8{{[,)]}}
 // CHECK-SAME:             identifier: "$s4enum5MaybeOyAA5ColorOGD"
 let movie : Maybe<Color> = .none
 
@@ -79,8 +78,12 @@ public enum Tuple<P> {
 
 func bar<T>(_ x : Tuple<T>) -> Tuple<T> { return x }
 
-// CHECK: ![[LIST:.*]] = !DICompositeType({{.*}}identifier: "$s4enum4ListOyxGD"
-// CHECK-DAG: ![[LET_LIST:.*]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: ![[LIST]])
+// CHECK-DAG: ![[LIST:.*]] = !DICompositeType({{.*}}identifier: "$s4enum4ListOyxGD"
+// CHECK-DAG: ![[LIST_MEMBER:.*]] = !DIDerivedType(tag: DW_TAG_member, {{.*}} baseType: ![[LIST]]
+// CHECK-DAG: ![[LIST_ELTS:.*]] = !{![[LIST_MEMBER]]}
+// CHECK-DAG: ![[LIST_CONTAINER:.*]] = !DICompositeType({{.*}}elements: ![[LIST_ELTS]]
+
+// CHECK-DAG: ![[LET_LIST:.*]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: ![[LIST_CONTAINER]])
 // CHECK-DAG: !DILocalVariable(name: "self", arg: 1, {{.*}} line: [[@LINE+4]], type: ![[LET_LIST]], flags: DIFlagArtificial)
 public enum List<T> {
        indirect case Tail(List, T)

test/DebugInfo/generic_enum.swift

@@ -17,7 +17,10 @@ func wrapTrivialGeneric<T, U>(_ t: T, u: U) -> TrivialGeneric<T, U> {
   return .x(t, u)
 }
 // CHECK-DAG: ![[T1:.*]] = !DICompositeType({{.*}}identifier: "$s12generic_enum14TrivialGenericOys5Int64VSSGD"
-// CHECK-DAG: !DIGlobalVariable(name: "tg",{{.*}} line: [[@LINE+2]],{{.*}} type: ![[T1]],{{.*}} isLocal: false, isDefinition: true
+// CHECK-DAG: ![[T1_MEMBER:.*]] = !DIDerivedType(tag: DW_TAG_member, {{.*}}baseType: ![[T1]]
+// CHECK-DAG: ![[T1_ELTS:.*]] = !{![[T1_MEMBER]]}
+// CHECK-DAG: ![[T1_CONTAINER:.*]] = !DICompositeType({{.*}}elements: ![[T1_ELTS]]
+// CHECK-DAG: !DIGlobalVariable(name: "tg",{{.*}} line: [[@LINE+2]],{{.*}} type: ![[T1_CONTAINER]],{{.*}} isLocal: false, isDefinition: true
 // CHECK-DAG: !DICompositeType({{.*}}, name: "TrivialGeneric", {{.*}}identifier: "$s12generic_enum14TrivialGenericOys5Int64VSSGD"
 var tg : TrivialGeneric<Int64, String> = .x(23, "skidoo")
 switch tg {

test/DebugInfo/protocol-sugar.swift

@@ -4,5 +4,8 @@ protocol B {}
 typealias C = B & A
 protocol D {}
 var p: (C & D)?
-// CHECK-DAG: !DIGlobalVariable(name: "p", {{.*}}type: ![[TY:[0-9]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "p", {{.*}}type: ![[TY_CONTAINER:[0-9]+]]
+// CHECK-DAG: ![[TY_CONTAINER]] = !DICompositeType({{.*}}elements: ![[TY_ELTS:[0-9]+]]
+// CHECK-DAG: ![[TY_ELTS]] = !{![[TY_MEMBER:[0-9]+]]}
+// CHECK-DAG: ![[TY_MEMBER]] = !DIDerivedType(tag: DW_TAG_member, {{.*}}baseType: ![[TY:[0-9]+]]
 // CHECK-DAG: ![[TY]] = {{.*}}identifier: "$s4main1A_AA1BAA1DpXSpSgD"