IRGen: Correctly calculate base offset variable for generic classes

If a generic class has non-resilient ancestry, we cannot use
the template size so far as the constant value of the base offset
variable, because the template will not contain entries for all
metadata members; instead, use metadata layout as with everything
else.

Author: slavapestov

lib/IRGen/GenMeta.cpp

@@ -2937,11 +2937,6 @@ namespace {
       return B.getNextOffsetFromGlobal() - TemplateHeaderSize;
     }
 
-    /// Ignore the destructor and value witness table.
-    Size getNextOffsetFromAddressPoint() const {
-      return getNextOffsetFromTemplateHeader() - AddressPoint;
-    }
-
     template <class... T>
     void addGenericArgument(CanType type, T &&...args) {
       FillOps.push_back({type, None});
@@ -3194,7 +3189,6 @@ namespace {
 
   public:
     void noteResilientSuperclass() {
-      // FIXME: Perform sliding
       HasResilientSuperclass = true;
     }
 
@@ -3224,8 +3218,10 @@ namespace {
 
         // Otherwise, we know the offset at compile time, even if our
         // clients do not, so just emit a constant.
-        auto value = asImpl().getNextOffsetFromAddressPoint().getValue();
-        auto *init = llvm::ConstantInt::get(IGM.SizeTy, value);
+        auto &layout = IGM.getMetadataLayout(theClass);
+
+        auto value = layout.getStartOfImmediateMembers();
+        auto *init = llvm::ConstantInt::get(IGM.SizeTy, value.getValue());
 
         offsetVar->setInitializer(init);
         offsetVar->setConstant(true);
@@ -3503,13 +3499,15 @@ namespace {
       Address sizeSlot = IGF.Builder.CreateConstByteArrayGEP(
           metadataAsBytes,
           layout.getMetadataSizeOffset());
-      sizeSlot = IGF.Builder.CreateBitCast(sizeSlot, IGM.Int32Ty->getPointerTo());
+      sizeSlot = IGF.Builder.CreateBitCast(sizeSlot,
+                                           IGM.Int32Ty->getPointerTo());
       llvm::Value *size = IGF.Builder.CreateLoad(sizeSlot);
 
       Address addressPointSlot = IGF.Builder.CreateConstByteArrayGEP(
           metadataAsBytes,
           layout.getMetadataAddressPointOffset());
-      addressPointSlot = IGF.Builder.CreateBitCast(addressPointSlot, IGM.Int32Ty->getPointerTo());
+      addressPointSlot = IGF.Builder.CreateBitCast(addressPointSlot,
+                                                   IGM.Int32Ty->getPointerTo());
       llvm::Value *addressPoint = IGF.Builder.CreateLoad(addressPointSlot);
 
       size = IGF.Builder.CreateSub(size, addressPoint);
@@ -3653,10 +3651,6 @@ namespace {
       AddressPoint = B.getNextOffsetFromGlobal();
     }
 
-    Size getNextOffsetFromAddressPoint() const {
-      return B.getNextOffsetFromGlobal() - AddressPoint;
-    }
-
     void addSuperClass() {
       // If this is a root class, use SwiftObject as our formal parent.
       if (!Target->hasSuperclass()) {

lib/IRGen/MetadataLayout.cpp

@@ -250,6 +250,8 @@ ClassMetadataLayout::ClassMetadataLayout(IRGenModule &IGM, ClassDecl *decl)
       // If our superclass is resilient to us, or the class itself is resilient
       // to us, we will access metadata members relative to a base offset.
       if (forClass == Target) {
+        Layout.StartOfImmediateMembers = getNextOffset();
+
         if (Layout.HasResilientSuperclass ||
             IGM.isResilient(forClass, ResilienceExpansion::Maximal)) {
           assert(!DynamicOffsetBase);

lib/IRGen/MetadataLayout.h

@@ -169,6 +169,8 @@ class ClassMetadataLayout : public NominalMetadataLayout {
 private:
   bool HasResilientSuperclass = false;
 
+  StoredOffset StartOfImmediateMembers;
+
   StoredOffset MetadataSize;
   StoredOffset MetadataAddressPoint;
 
@@ -262,6 +264,12 @@ class ClassMetadataLayout : public NominalMetadataLayout {
 
   Offset getFieldOffsetVectorOffset(IRGenFunction &IGF) const;
 
+  /// If the start of the immediate members is statically known, this
+  /// method will return it. Otherwise, it will assert.
+  Size getStartOfImmediateMembers() const {
+    return StartOfImmediateMembers.getStaticOffset();
+  }
+
   /// The number of members to add after superclass metadata. The size of
   /// this metadata is the superclass size plus the number of immediate
   /// members in the class itself.

test/IRGen/class_resilience.swift

@@ -59,6 +59,10 @@
 
 // CHECK: @_T016class_resilience16MyResilientChildCMo = {{(protected )?}}constant [[INT]] {{60|96}}
 
+// CHECK: @_T016class_resilience24MyResilientGenericParentCMo = {{(protected )?}}constant [[INT]] {{52|80}}
+
+// CHECK: @_T016class_resilience24MyResilientConcreteChildCMo = {{(protected )?}}constant [[INT]] {{64|104}}
+
 import resilient_class
 import resilient_struct
 import resilient_enum
@@ -164,6 +168,23 @@ public class MyResilientChild : MyResilientParent {
 }
 
 
+public class MyResilientGenericParent<T> {
+  public let t: T
+
+  public init(t: T) {
+    self.t = t
+  }
+}
+
+public class MyResilientConcreteChild : MyResilientGenericParent<Int> {
+  public let x: Int
+
+  public init(x: Int) {
+    self.x = x
+    super.init(t: x)
+  }
+}
+
 extension ResilientGenericOutsideParent {
   public func genericExtensionMethod() -> A.Type {
     return A.self