When a generic type has dependent IR and thus requires each

rjmccall · rjmccall · commit 857489c2f66b · 2016-04-29T16:39:16.000-07:00
specialization to be separately lowered in IRGen, use the mangling
of the specialized type as the name of the llvm::StructType instead
of the base, unspecialized type.

This tends to produce fewer collisions between IR type names.
LLVM does unique the names on its own, so that's not strictly
necessary, but it's still a good idea because it makes the test
output more reliable and somewhat easier to read (modulo the
impact of bigger type names).  Collisions will still occur if
the type is specialized at an archetype, since in this case we
will fall back on the unspecialized type.
diff --git a/lib/IRGen/GenClass.cpp b/lib/IRGen/GenClass.cpp
@@ -1846,8 +1846,8 @@ llvm::Constant *irgen::emitObjCProtocolData(IRGenModule &IGM,
 }
 
 const TypeInfo *
-TypeConverter::convertClassType(ClassDecl *D) {
-  llvm::StructType *ST = IGM.createNominalType(D);
+TypeConverter::convertClassType(CanType type, ClassDecl *D) {
+  llvm::StructType *ST = IGM.createNominalType(type);
   llvm::PointerType *irType = ST->getPointerTo();
   ReferenceCounting refcount = ::getReferenceCountingForClass(IGM, D);
   
diff --git a/lib/IRGen/GenEnum.cpp b/lib/IRGen/GenEnum.cpp
@@ -5446,7 +5446,7 @@ const TypeInfo *TypeConverter::convertEnumType(TypeBase *key, CanType type,
   if (IGM.isResilient(theEnum, ResilienceExpansion::Maximal))
     storageType = cast<llvm::StructType>(IGM.OpaquePtrTy->getElementType());
   else
-    storageType = IGM.createNominalType(theEnum);
+    storageType = IGM.createNominalType(type);
 
   // Create a forward declaration for that type.
   addForwardDecl(key, storageType);
diff --git a/lib/IRGen/GenExistential.cpp b/lib/IRGen/GenExistential.cpp
@@ -1298,8 +1298,7 @@ static const TypeInfo *createErrorExistentialTypeInfo(IRGenModule &IGM,
                                       refcounting);
 }
 
-static const TypeInfo *createExistentialTypeInfo(IRGenModule &IGM,
-                                            TypeBase *T,
+static const TypeInfo *createExistentialTypeInfo(IRGenModule &IGM, CanType T,
                                             ArrayRef<ProtocolDecl*> protocols) {
   SmallVector<llvm::Type*, 5> fields;
   SmallVector<ProtocolEntry, 4> entries;
@@ -1318,11 +1317,11 @@ static const TypeInfo *createExistentialTypeInfo(IRGenModule &IGM,
   }
 
   llvm::StructType *type;
-  if (auto *protoT = T->getAs<ProtocolType>())
-    type = IGM.createNominalType(protoT->getDecl());
-  else if (auto *compT = T->getAs<ProtocolCompositionType>())
+  if (isa<ProtocolType>(T))
+    type = IGM.createNominalType(T);
+  else if (auto compT = dyn_cast<ProtocolCompositionType>(T))
     // Protocol composition types are not nominal, but we name them anyway.
-    type = IGM.createNominalType(compT);
+    type = IGM.createNominalType(compT.getPointer());
   else
     llvm_unreachable("unknown existential type kind");
     
@@ -1415,7 +1414,7 @@ static const TypeInfo *createExistentialTypeInfo(IRGenModule &IGM,
 
 const TypeInfo *TypeConverter::convertProtocolType(ProtocolType *T) {
   // Protocol types are nominal.
-  return createExistentialTypeInfo(IGM, T, T->getDecl());
+  return createExistentialTypeInfo(IGM, CanType(T), T->getDecl());
 }
 
 const TypeInfo *
@@ -1424,7 +1423,7 @@ TypeConverter::convertProtocolCompositionType(ProtocolCompositionType *T) {
   SmallVector<ProtocolDecl*, 4> protocols;
   T->getAnyExistentialTypeProtocols(protocols);
 
-  return createExistentialTypeInfo(IGM, T, protocols);
+  return createExistentialTypeInfo(IGM, CanType(T), protocols);
 }
 
 const TypeInfo *
diff --git a/lib/IRGen/GenStruct.cpp b/lib/IRGen/GenStruct.cpp
@@ -842,7 +842,7 @@ const TypeInfo *TypeConverter::convertStructType(TypeBase *key, CanType type,
     return &getResilientStructTypeInfo();
 
   // Create the struct type.
-  auto ty = IGM.createNominalType(D);
+  auto ty = IGM.createNominalType(type);
 
   // Register a forward declaration before we look at any of the child types.
   addForwardDecl(key, ty);
diff --git a/lib/IRGen/GenType.cpp b/lib/IRGen/GenType.cpp
@@ -1533,7 +1533,7 @@ TypeCacheEntry TypeConverter::convertAnyNominalType(CanType type,
       llvm_unreachable("protocol types shouldn't be handled here");
 
     case DeclKind::Class:
-      return convertClassType(cast<ClassDecl>(decl));
+      return convertClassType(type, cast<ClassDecl>(decl));
     case DeclKind::Enum:
       return convertEnumType(type.getPointer(), type, cast<EnumDecl>(decl));
     case DeclKind::Struct:
@@ -1618,9 +1618,17 @@ TypeConverter::getMetatypeTypeInfo(MetatypeRepresentation representation) {
 }
 
 /// createNominalType - Create a new nominal type.
-llvm::StructType *IRGenModule::createNominalType(TypeDecl *decl) {
+llvm::StructType *IRGenModule::createNominalType(CanType type) {
+  assert(type.getNominalOrBoundGenericNominal());
+
+  // We share type infos for different instantiations of a generic type
+  // when the archetypes have the same exemplars.  Mangling the archetypes
+  // in this case can be very misleading, so we just mangle the base name.
+  if (type->hasArchetype())
+    type = type.getNominalOrBoundGenericNominal()->getDeclaredType()
+                                                 ->getCanonicalType();
+
   llvm::SmallString<32> typeName;
-  auto type = decl->getDeclaredType()->getCanonicalType();
   LinkEntity::forTypeMangling(type).mangle(typeName);
   return llvm::StructType::create(getLLVMContext(), typeName.str());
 }
diff --git a/lib/IRGen/GenType.h b/lib/IRGen/GenType.h
@@ -117,7 +117,7 @@ class TypeConverter {
   TypeCacheEntry convertType(CanType T);
   TypeCacheEntry convertAnyNominalType(CanType T, NominalTypeDecl *D);
   const TypeInfo *convertTupleType(TupleType *T);
-  const TypeInfo *convertClassType(ClassDecl *D);
+  const TypeInfo *convertClassType(CanType type, ClassDecl *D);
   const TypeInfo *convertEnumType(TypeBase *key, CanType type, EnumDecl *D);
   const TypeInfo *convertStructType(TypeBase *key, CanType type, StructDecl *D);
   const TypeInfo *convertFunctionType(SILFunctionType *T);
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -564,7 +564,7 @@ class IRGenModule {
   llvm::PointerType *getStoragePointerTypeForUnlowered(Type T);
   llvm::PointerType *getStoragePointerTypeForLowered(CanType T);
   llvm::PointerType *getStoragePointerType(SILType T);
-  llvm::StructType *createNominalType(TypeDecl *D);
+  llvm::StructType *createNominalType(CanType type);
   llvm::StructType *createNominalType(ProtocolCompositionType *T);
   void getSchema(SILType T, ExplosionSchema &schema);
   ExplosionSchema getSchema(SILType T);
diff --git a/test/IRGen/class.sil b/test/IRGen/class.sil
@@ -163,7 +163,7 @@ entry(%x : $ClassConstrainedGenericField<ClassConstraintConformance>):
   %b = load %a : $*ClassConstraintConformance
   return %b : $ClassConstraintConformance
 }
-// CHECK-LABEL: define{{( protected)?}} %C5class26ClassConstraintConformance* @fixed_class_generic_field(%C5class28ClassConstrainedGenericField*)
-// CHECK:         [[FIELD_ADDR_GENERIC:%.*]] = getelementptr inbounds %C5class28ClassConstrainedGenericField, %C5class28ClassConstrainedGenericField* %0, i32 0, i32 1
+// CHECK-LABEL: define{{( protected)?}} %C5class26ClassConstraintConformance* @fixed_class_generic_field(%GC5class28ClassConstrainedGenericFieldCS_26ClassConstraintConformance_*)
+// CHECK:         [[FIELD_ADDR_GENERIC:%.*]] = getelementptr inbounds %GC5class28ClassConstrainedGenericFieldCS_26ClassConstraintConformance_, %GC5class28ClassConstrainedGenericFieldCS_26ClassConstraintConformance_* %0, i32 0, i32 1
 // CHECK:         load %C5class26ClassConstraintConformance*, %C5class26ClassConstraintConformance** [[FIELD_ADDR_GENERIC]]
 
diff --git a/test/IRGen/enum.sil b/test/IRGen/enum.sil
@@ -89,7 +89,7 @@ import Swift
 // -- Dynamic enums. The type layout is opaque; we dynamically bitcast to
 //    the element type.
 // CHECK: %O4enum20DynamicSinglePayload = type <{}>
-// CHECK: [[DYNAMIC_SINGLE_EMPTY_PAYLOAD:%O4enum20DynamicSinglePayload\.[0-9]+]] = type <{ [1 x i8] }>
+// CHECK: [[DYNAMIC_SINGLE_EMPTY_PAYLOAD:%GO4enum20DynamicSinglePayloadT__]] = type <{ [1 x i8] }>
 
 // -- Address-only multi-payload enums. We can't use spare bits.
 // CHECK-64: %O4enum32MultiPayloadAddressOnlySpareBits = type <{ [16 x i8], [1 x i8] }>
@@ -2495,7 +2495,7 @@ struct StructWithWeakVar {
 weak var delegate: delegateProtocol?
 }
 
-// CHECK-64-LABEL: define{{( protected)?}} void @weak_optional(%Sq{{.*}}* noalias nocapture dereferenceable({{.*}}))
+// CHECK-64-LABEL: define{{( protected)?}} void @weak_optional(%GSqV4enum17StructWithWeakVar_* noalias nocapture dereferenceable({{.*}}))
 sil @weak_optional : $@convention(thin) (@in StructWithWeakVar?) -> () {
 entry(%x : $*StructWithWeakVar?):
   // CHECK-64:      icmp eq [[WORD]] {{%.*}}, 0
diff --git a/test/IRGen/enum_spare_bits.sil b/test/IRGen/enum_spare_bits.sil
@@ -48,8 +48,10 @@ enum Archetype<T: AnyObject> {
   case A(T), B(C)
 }
 // can't use spare bits—archetype may be bound to tagged pointer type
-// CHECK-32: [[ARCHETYPE:%O15enum_spare_bits9Archetype.*]] = type <{ [4 x i8], [1 x i8] }>
-// CHECK-64: [[ARCHETYPE:%O15enum_spare_bits9Archetype.*]] = type <{ [8 x i8], [1 x i8] }>
+// CHECK-32: [[ARCHETYPE:%GO15enum_spare_bits9ArchetypeCS_1C_]] = type <{ [4 x i8], [1 x i8] }>
+// CHECK-32: [[ARCHETYPE_OBJC:%GO15enum_spare_bits9ArchetypeCSo8NSObject_]] = type <{ [4 x i8], [1 x i8] }>
+// CHECK-64: [[ARCHETYPE:%GO15enum_spare_bits9ArchetypeCS_1C_]] = type <{ [8 x i8], [1 x i8] }>
+// CHECK-64: [[ARCHETYPE_OBJC:%GO15enum_spare_bits9ArchetypeCSo8NSObject_]] = type <{ [8 x i8], [1 x i8] }>
 
 sil_global @swiftClass: $SwiftClass
 sil_global @objcClass: $ObjCClass
@@ -59,7 +61,7 @@ sil_global @archetypeBoundToSwift: $Archetype<C>
 sil_global @archetypeBoundToObjC: $Archetype<NSObject>
 
 // CHECK: @archetypeBoundToSwift = {{(protected )?}}global [[ARCHETYPE]]
-// CHECK: @archetypeBoundToObjC = {{(protected )?}}global [[ARCHETYPE]]
+// CHECK: @archetypeBoundToObjC = {{(protected )?}}global [[ARCHETYPE_OBJC]]
 
 sil @instantiate_globals : $() -> () {
 entry:
diff --git a/test/IRGen/lazy_multi_file.swift b/test/IRGen/lazy_multi_file.swift
@@ -2,7 +2,7 @@
 
 // REQUIRES: CPU=i386_or_x86_64
 
-// CHECK: %C15lazy_multi_file8Subclass = type <{ %swift.refcounted, %[[OPTIONAL_INT_TY:Sq[^,]+]], [{{[0-9]+}} x i8], %SS }>
+// CHECK: %C15lazy_multi_file8Subclass = type <{ %swift.refcounted, %[[OPTIONAL_INT_TY:GSqSi_]], [{{[0-9]+}} x i8], %SS }>
 // CHECK: %[[OPTIONAL_INT_TY]] = type <{ [{{[0-9]+}} x i8], [1 x i8] }>
 // CHECK: %V15lazy_multi_file13LazyContainer = type <{ %[[OPTIONAL_INT_TY]] }>
 
diff --git a/test/IRGen/partial_apply_forwarder.sil b/test/IRGen/partial_apply_forwarder.sil
@@ -6,7 +6,7 @@ public class C : P {}
 public class D<T : P> {}
 class E {}
 
-// CHECK-LABEL: define internal %C23partial_apply_forwarder1D{{.*}}* @_TPA_unspecialized_uncurried(%swift.refcounted*
+// CHECK-LABEL: define internal %GC23partial_apply_forwarder1DCS_1C_* @_TPA_unspecialized_uncurried(%swift.refcounted*
 // CHECK: [[TYPE:%.*]] = call %swift.type* @_TMaC23partial_apply_forwarder1C()
 // CHECK: [[CAST:%.*]] = bitcast %swift.refcounted* %0 to %C23partial_apply_forwarder1E*
 // CHECK: [[CALL:%.*]] = call %C23partial_apply_forwarder1D* @unspecialized_uncurried(%swift.type* [[TYPE]], i8** getelementptr inbounds ([0 x i8*], [0 x i8*]* @_TWPC23partial_apply_forwarder1CS_1PS_, i32 0, i32 0), %C23partial_apply_forwarder1E* [[CAST]])
diff --git a/test/IRGen/sil_witness_methods.sil b/test/IRGen/sil_witness_methods.sil
@@ -141,7 +141,7 @@ entry:
 // CHECK:         [[LAYOUT:%.*]] = bitcast %swift.refcounted* [[CONTEXT]] to <{ %swift.refcounted, i8* }>*
 // CHECK:         [[WTABLE:%.*]] = getelementptr inbounds <{ %swift.refcounted, i8* }>, <{ %swift.refcounted, i8* }>* [[LAYOUT]], i32 0, i32 1
 // CHECK:         store i8* null, i8** [[WTABLE]]
-// CHECK:         [[RESULT:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (%swift.type* (%C19sil_witness_methods3Bar{{.*}}**, %swift.refcounted*)* @_TPA_generic_type_concrete_method_witness to i8*), %swift.refcounted* undef }, %swift.refcounted* [[CONTEXT]], 1
+// CHECK:         [[RESULT:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (%swift.type* (%GC19sil_witness_methods3BarVS_3FooS1_S1__**, %swift.refcounted*)* @_TPA_generic_type_concrete_method_witness to i8*), %swift.refcounted* undef }, %swift.refcounted* [[CONTEXT]], 1
 // CHECK:         ret { i8*, %swift.refcounted* } [[RESULT]]
 
 sil @partial_apply_concrete_witness : $() -> @callee_owned (@in Bar<Foo, Foo, Foo>) -> @thick Bar<Foo, Foo, Foo>.Type {
diff --git a/test/IRGen/struct_layout.sil b/test/IRGen/struct_layout.sil
@@ -4,10 +4,10 @@ import Builtin
 import Swift
 
 // 64: %V4main14Rdar15410780_A = type <{ i2048, %Vs4Int8 }>
-// 64: %V4main14Rdar15410780_B = type <{ %Sq[[B:(\.[0-9]+)?]] }>
-// 64: %Sq[[B]] = type <{ [257 x i8], [1 x i8] }>
-// 64: %V4main14Rdar15410780_C = type <{ %Sq[[C:(\.[0-9]+)?]] }>
-// 64: %Sq[[C]] = type <{ [24 x i8], [1 x i8] }>
+// 64: %V4main14Rdar15410780_B = type <{ %GSqV4main14Rdar15410780_A_ }>
+// 64: %GSqV4main14Rdar15410780_A_ = type <{ [257 x i8], [1 x i8] }>
+// 64: %V4main14Rdar15410780_C = type <{ %GSqSS_ }>
+// 64: %GSqSS_ = type <{ [24 x i8], [1 x i8] }>
 
 // 64: @_TWVV4main14Rdar15410780_A = hidden constant {{.*}} (i64 257
 // 64: @_TWVV4main14Rdar15410780_B = hidden constant {{.*}} (i64 258
diff --git a/test/IRGen/subclass.swift b/test/IRGen/subclass.swift
@@ -57,7 +57,7 @@ class G<T> : A {
 // Ensure that downcasts to generic types instantiate generic metadata instead
 // of trying to reference global metadata. <rdar://problem/14265663>
 
-// CHECK: define hidden %C8subclass1G{{.*}}* @_TF8subclass9a_to_gintF{{.*}}(%C8subclass1A*) {{.*}} {
+// CHECK: define hidden %GC8subclass1GSi_* @_TF8subclass9a_to_gintF{{.*}}(%C8subclass1A*) {{.*}} {
 func a_to_gint(a: A) -> G<Int> {
   // CHECK: call %swift.type* @_TMaGC8subclass1GSi_()
   // CHECK: call i8* @swift_dynamicCastClassUnconditional

Original file line number	Diff line number	Diff line change
`@@ -1846,8 +1846,8 @@ llvm::Constant *irgen::emitObjCProtocolData(IRGenModule &IGM,`
`1846`	`1846`	`}`
`1847`	`1847`
`1848`	`1848`	`const TypeInfo *`
`1849`		`-TypeConverter::convertClassType(ClassDecl *D) {`
`1850`		`- llvm::StructType *ST = IGM.createNominalType(D);`
	`1849`	`+TypeConverter::convertClassType(CanType type, ClassDecl *D) {`
	`1850`	`+ llvm::StructType *ST = IGM.createNominalType(type);`
`1851`	`1851`	`llvm::PointerType *irType = ST->getPointerTo();`
`1852`	`1852`	`ReferenceCounting refcount = ::getReferenceCountingForClass(IGM, D);`
`1853`	`1853`
Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ entry(%x : $ClassConstrainedGenericField<ClassConstraintConformance>):`
`163`	`163`	`%b = load %a : $*ClassConstraintConformance`
`164`	`164`	`return %b : $ClassConstraintConformance`
`165`	`165`	`}`
`166`		`-// CHECK-LABEL: define{{( protected)?}} %C5class26ClassConstraintConformance* @fixed_class_generic_field(%C5class28ClassConstrainedGenericField*)`
`167`		`-// CHECK: [[FIELD_ADDR_GENERIC:%.]] = getelementptr inbounds %C5class28ClassConstrainedGenericField, %C5class28ClassConstrainedGenericField %0, i32 0, i32 1`
	`166`	`+// CHECK-LABEL: define{{( protected)?}} %C5class26ClassConstraintConformance* @fixed_class_generic_field(%GC5class28ClassConstrainedGenericFieldCS_26ClassConstraintConformance_*)`
	`167`	`+// CHECK: [[FIELD_ADDR_GENERIC:%.]] = getelementptr inbounds %GC5class28ClassConstrainedGenericFieldCS_26ClassConstraintConformance_, %GC5class28ClassConstrainedGenericFieldCS_26ClassConstraintConformance_ %0, i32 0, i32 1`
`168`	`168`	`// CHECK: load %C5class26ClassConstraintConformance, %C5class26ClassConstraintConformance* [[FIELD_ADDR_GENERIC]]`
`169`	`169`