Use the known type parameters to determine static offsets to stored

properties of classes with generic layouts.

Previously we were falling back on accessing them via the field
offset vector even when we knew everything about the type.

As a minor benefit, this allows RemoteAST to also determine offsets
for members of classes with generic layout.

Half of the test changes are IR type-name uniquing; I'm going to
explore mangling these with the full type where possible.

Author: rjmccall

lib/IRGen/GenClass.cpp

@@ -1173,30 +1173,6 @@ TypeCacheEntry TypeConverter::getTypeEntry(CanType canonicalTy) {
   return convertedTI;
 }
 
-/// A convenience for grabbing the TypeInfo for a class declaration.
-const TypeInfo &TypeConverter::getTypeInfo(ClassDecl *theClass) {
-  // This type doesn't really matter except for serving as a key.
-  CanType theType
-    = getExemplarType(theClass->getDeclaredType()->getCanonicalType());
-
-  // If we have generic parameters, use the bound-generics conversion
-  // routine.  This does an extra level of caching based on the common
-  // class decl.
-  TypeCacheEntry entry;
-  if (theClass->getGenericParams()) {
-    entry = convertAnyNominalType(theType, theClass);
-
-  // Otherwise, just look up the declared type.
-  } else {
-    assert(isa<ClassType>(theType));
-    entry = getTypeEntry(theType);
-  }
-
-  // This will always yield a TypeInfo because forward-declarations
-  // are unnecessary when converting class types.
-  return *entry.get<const TypeInfo*>();
-}
-
 /// Return a TypeInfo the represents opaque storage for a loadable POD value
 /// with the given storage size.
 ///
@@ -1495,10 +1471,15 @@ namespace {
       return false;
     }
 
-    // Classes do not need unique implementations.
-    bool visitClassType(CanClassType type) { return false; }
+    // Conservatively assume classes need unique implementations.
+    bool visitClassType(CanClassType type) {
+      return visitClassDecl(type->getDecl());
+     }
     bool visitBoundGenericClassType(CanBoundGenericClassType type) {
-      return false;
+      return visitClassDecl(type->getDecl());
+    }
+    bool visitClassDecl(ClassDecl *theClass) {
+      return true;
     }
 
     // Reference storage types propagate the decision.
@@ -1522,8 +1503,8 @@ namespace {
 
 static bool isIRTypeDependent(IRGenModule &IGM, NominalTypeDecl *decl) {
   assert(!isa<ProtocolDecl>(decl));
-  if (isa<ClassDecl>(decl)) {
-    return false;
+  if (auto classDecl = dyn_cast<ClassDecl>(decl)) {
+    return IsIRTypeDependent(IGM).visitClassDecl(classDecl);
   } else if (auto structDecl = dyn_cast<StructDecl>(decl)) {
     return IsIRTypeDependent(IGM).visitStructDecl(structDecl);
   } else {
@@ -1587,12 +1568,8 @@ TypeCacheEntry TypeConverter::convertAnyNominalType(CanType type,
   case DeclKind::Protocol:
     llvm_unreachable("protocol types don't take generic parameters");
 
-  case DeclKind::Class: {
-    auto result = convertClassType(cast<ClassDecl>(decl));
-    assert(!Cache.count(key));
-    Cache.insert(std::make_pair(key, result));
-    return result;
-  }
+  case DeclKind::Class:
+    llvm_unreachable("classes are always considered dependent for now");
 
   case DeclKind::Enum: {
     auto type = CanType(decl->getDeclaredTypeInContext());

lib/IRGen/GenType.cpp

@@ -145,7 +145,6 @@ class TypeConverter {
   TypeCacheEntry getTypeEntry(CanType type);
   const TypeInfo &getCompleteTypeInfo(CanType type);
   const TypeInfo *tryGetCompleteTypeInfo(CanType type);
-  const TypeInfo &getTypeInfo(ClassDecl *D);
   const LoadableTypeInfo &getNativeObjectTypeInfo();
   const LoadableTypeInfo &getUnknownObjectTypeInfo();
   const LoadableTypeInfo &getBridgeObjectTypeInfo();

lib/IRGen/GenType.h

@@ -418,9 +418,6 @@ struct ClassLayout {
   ArrayRef<VarDecl*> InheritedStoredProperties;
   /// Lazily-initialized array of all field access methods.
   ArrayRef<FieldAccess> AllFieldAccesses;
-  /// Lazily-initialized metadata access method. See the comment in
-  /// ClassLayoutBuilder.
-  FieldAccess MetadataAccess;
   /// Does the class metadata require dynamic initialization.
   bool MetadataRequiresDynamicInitialization;
 

lib/IRGen/StructLayout.h

@@ -165,6 +165,5 @@ entry(%x : $ClassConstrainedGenericField<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:         [[FIELD_ADDR_CONCRETE:%.*]] = bitcast %objc_object** [[FIELD_ADDR_GENERIC]] to %C5class26ClassConstraintConformance**
-// CHECK:         load %C5class26ClassConstraintConformance*, %C5class26ClassConstraintConformance** [[FIELD_ADDR_CONCRETE]]
+// CHECK:         load %C5class26ClassConstraintConformance*, %C5class26ClassConstraintConformance** [[FIELD_ADDR_GENERIC]]
 

test/IRGen/class.sil

@@ -47,7 +47,7 @@ bb0(%0 : $B<T, U>):
   return %3 : $()
 }
 
-// CHECK-LABEL: define hidden void @test_23121786(%C11fulfillment1A*, %C11fulfillment1A*)
+// CHECK-LABEL: define hidden void @test_23121786(%C11fulfillment1A*, %C11fulfillment1A{{.*}}*)
 sil hidden @test_23121786 : $@convention(thin) <T> (@owned A<A<T>>, @owned A<T>) -> () {
 bb0(%0 : $A<A<T>>, %1 : $A<T>):
   %2 = tuple ()

test/IRGen/fulfillment.sil

@@ -248,12 +248,8 @@ entry(%z : $*F, %c : $RootGeneric<F>):
 }
 
 // CHECK-LABEL: define{{( protected)?}} void @RootGeneric_subst_concrete_fragile_dependent_member_access_y
-// CHECK:   [[TYPE_METADATA_ARRAY:%.*]] = bitcast %swift.type* {{%.*}} to i64*
-// CHECK:   [[Y_OFFSET_ADDR:%.*]] = getelementptr inbounds i64, i64* [[TYPE_METADATA_ARRAY]], i64 16
-// CHECK:   [[Y_OFFSET:%.*]] = load i64, i64* [[Y_OFFSET_ADDR]], align 8
-// CHECK:   [[CLASS_BYTE_ARRAY:%.*]] = bitcast [[ROOTGENERIC]]* {{%.*}} to i8*
-// CHECK:   [[Y_ADDR:%.*]] = getelementptr inbounds i8, i8* [[CLASS_BYTE_ARRAY]], i64 [[Y_OFFSET]]
-// CHECK:   bitcast i8* [[Y_ADDR]] to %Si*
+// CHECK:   [[Y_ADDR:%.*]] = getelementptr inbounds {{.*}}, {{.*}}* %1, i32 0, i32 3
+// CHECK:   bitcast %Si* [[Y_ADDR]] to i8*
 sil @RootGeneric_subst_concrete_fragile_dependent_member_access_y : $(RootGeneric<Int>) -> @out Int {
 entry(%z : $*Int, %c : $RootGeneric<Int>):
   %p = ref_element_addr %c : $RootGeneric<Int>, #RootGeneric.y
@@ -278,12 +274,9 @@ entry(%c : $RootGeneric<F>):
 }
 
 // CHECK-LABEL: define{{( protected)?}} i8 @RootGeneric_subst_concrete_fragile_dependent_member_access_z
-// CHECK:   [[TYPE_METADATA_ARRAY:%.*]] = bitcast %swift.type* {{%.*}} to i64*
-// CHECK:   [[Z_OFFSET_ADDR:%.*]] = getelementptr inbounds i64, i64* [[TYPE_METADATA_ARRAY]], i64 17
-// CHECK:   [[Z_OFFSET:%.*]] = load i64, i64* [[Z_OFFSET_ADDR]], align 8
-// CHECK:   [[CLASS_BYTE_ARRAY:%.*]] = bitcast [[ROOTGENERIC]]* {{%.*}} to i8*
-// CHECK:   [[Z_ADDR:%.*]] = getelementptr inbounds i8, i8* [[CLASS_BYTE_ARRAY]], i64 [[Z_OFFSET]]
-// CHECK:   bitcast i8* [[Z_ADDR]] to %Vs5UInt8*
+// CHECK:   [[Z_ADDR:%.*]] = getelementptr inbounds {{.*}}, {{.*}}* %0, i32 0, i32 4
+// CHECK:   [[T0:%.*]] = getelementptr inbounds %Vs5UInt8, %Vs5UInt8* [[Z_ADDR]], i32 0, i32 0
+// CHECK:   load i8, i8* [[T0]], align
 sil @RootGeneric_subst_concrete_fragile_dependent_member_access_z : $RootGeneric<Int> -> UInt8 {
 entry(%c : $RootGeneric<Int>):
   %p = ref_element_addr %c : $RootGeneric<Int>, #RootGeneric.z

test/IRGen/generic_classes.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 %C23partial_apply_forwarder1D{{.*}}* @_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]])

test/IRGen/partial_apply_forwarder.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* (%C19sil_witness_methods3Bar{{.*}}**, %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 {

test/IRGen/sil_witness_methods.sil

@@ -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 %C8subclass1G{{.*}}* @_TF8subclass9a_to_gintF{{.*}}(%C8subclass1A*) {{.*}} {
 func a_to_gint(a: A) -> G<Int> {
   // CHECK: call %swift.type* @_TMaGC8subclass1GSi_()
   // CHECK: call i8* @swift_dynamicCastClassUnconditional