IRGen: Layout of root classes containing resiliently-sized fields

Now that all the machinery is in place, the ClassMetadataBuilder
can (more accurately) query the ClassLayout instead of trying to
re-derive whether the field offset vector is dependent, etc.

Apart from performing dynamic layout for resiliently-sized fields
in concrete classes, this also lets us *skip* dynamic layout
if we have a generic class without any dependent fields.

I haven't tested subclassing with resilient field layout yet, but
getting that working is the next step and should not be too much
work.

Also, swift_initClassMetadata_UniversalStrategy() only stores
the computed field offsets in the field offset globals when the
Objective-C runtime is available, because it gets the offset
pointers from the Objective-C class rodata. On Linux, we will
need to emit code to copy from the field offset vector into
field offset globals in IRGen. This is pretty easy, but I'll do
it in a follow-up patch so for now the new execution test is
XFAIL'd on Linux.

Author: slavapestov

lib/IRGen/ClassMetadataLayout.h

@@ -84,11 +84,11 @@ template <class Impl> class ClassMetadataLayout : public MetadataLayout<Impl> {
     // consistent metadata layout between generic superclasses and concrete
     // subclasses.
     if (Type superclass = theClass->getSuperclass()) {
+      ClassDecl *superclassDecl = superclass->getClassOrBoundGenericClass();
       // Skip superclass fields if superclass is resilient.
       // FIXME: Needs runtime support to ensure the field offset vector is
       // populated correctly.
-      if (!IGM.isResilient(superclass->getClassOrBoundGenericClass(),
-                           ResilienceScope::Component)) {
+      if (!IGM.isResilient(superclassDecl, ResilienceScope::Component)) {
         addClassMembers(superclass->getClassOrBoundGenericClass());
       }
     }

lib/IRGen/GenClass.cpp

@@ -254,7 +254,7 @@ namespace {
           // If the superclass is in a generic context, conservatively
           // assume the layout depends on generic parameters, since we
           // can't look at stored properties.
-          if (superclass->isGenericContext())
+          if (superclassType.hasArchetype())
             ClassHasConcreteLayout = false;
         } else {
           // Otherwise, we have total knowledge of the class and its

lib/IRGen/GenMeta.cpp

@@ -188,32 +188,19 @@ static bool hasMetadataPattern(IRGenModule &IGM, NominalTypeDecl *theDecl) {
   // Protocols must be special-cased in a few places.
   assert(!isa<ProtocolDecl>(theDecl));
 
-  // Classes imported from Objective-C never have a metadata pattern.
-  if (theDecl->hasClangNode())
-    return false;
-
-  // A generic class, struct, or enum is always initialized at runtime.
+  // For classes, we already computed this when we did the layout.
+  // FIXME: Try not to call this for classes of other modules, by referencing
+  // the metadata accessor instead.
+  if (auto *theClass = dyn_cast<ClassDecl>(theDecl))
+    return getClassHasMetadataPattern(IGM, theClass);
+
+  // Ok, we have a value type. If it is generic, it is always initialized
+  // at runtime.
   if (theDecl->isGenericContext())
     return true;
 
-  // A class with generic ancestry is always initialized at runtime.
-  // TODO: This should be cached in the ClassDecl since it is checked for in
-  // several places.
-  if (auto *theClass = dyn_cast<ClassDecl>(theDecl)) {
-    Type superclassTy = theClass->getSuperclass();
-    while (superclassTy) {
-      if (superclassTy->getClassOrBoundGenericClass()->isGenericContext())
-        return true;
-      superclassTy = superclassTy->getSuperclass(nullptr);
-    }
-
-    // TODO: check if class fields are resilient. Fixed-size check for value
-    // types isn't meaningful here.
-    return false;
-  }
-
-  // If we have fields of resilient type, the metadata still has to be
-  // initialized at runtime.
+  // If the type is not fixed-size, its size depends on resilient types,
+  // and the metadata is initialized at runtime.
   if (!IGM.getTypeInfoForUnlowered(theDecl->getDeclaredType()).isFixedSize())
     return true;
 
@@ -2864,6 +2851,7 @@ namespace {
     }
 
     bool HasRuntimeParent = false;
+
   public:
     /// The 'metadata flags' field in a class is actually a pointer to
     /// the metaclass object for the class.
@@ -3140,7 +3128,15 @@ namespace {
     ClassMetadataBuilder(IRGenModule &IGM, ClassDecl *theClass,
                          const StructLayout &layout,
                          const ClassLayout &fieldLayout)
-      : ClassMetadataBuilderBase(IGM, theClass, layout, fieldLayout) {}
+      : ClassMetadataBuilderBase(IGM, theClass, layout, fieldLayout) {
+
+      assert(layout.isFixedLayout() &&
+             "non-fixed layout classes require a template");
+      // FIXME: Distinguish Objective-C sliding from resilient layout
+      assert((fieldLayout.MetadataAccess == FieldAccess::ConstantDirect ||
+              fieldLayout.MetadataAccess == FieldAccess::NonConstantDirect) &&
+             "resilient superclasses require a template");
+    }
 
     llvm::Constant *getInit() {
       return getInitWithSuggestedType(NumHeapMetadataFields,
@@ -3202,11 +3198,6 @@ namespace {
   {
     typedef GenericMetadataBuilderBase super;
 
-    bool HasDependentFieldOffsetVector = false;
-
-    bool InheritFieldOffsetVectors = false;
-    bool InheritGenericParameters = false;
-    
     Size MetaclassPtrOffset = Size::invalid();
     Size ClassRODataPtrOffset = Size::invalid();
     Size MetaclassRODataPtrOffset = Size::invalid();
@@ -3305,26 +3296,9 @@ namespace {
 
     void noteStartOfFieldOffsets(ClassDecl *whichClass) {
       HasDependentMetadata = true;
-
-      if (whichClass == Target) {
-        // If the metadata contains a field offset vector for the class itself,
-        // then we need to initialize it at runtime.
-        HasDependentFieldOffsetVector = true;
-        return;
-      }
-      
-      // If we have a field offset vector for an ancestor class, we will copy
-      // it from our superclass metadata at instantiation time.
-      InheritFieldOffsetVectors = true;
     }
 
-    void noteEndOfFieldOffsets(ClassDecl *whichClass) {
-      if (whichClass == Target)
-        return;
-      
-      assert(InheritFieldOffsetVectors
-             && "no start of ancestor field offsets?!");
-    }
+    void noteEndOfFieldOffsets(ClassDecl *whichClass) {}
 
     // Suppress GenericMetadataBuilderBase's default behavior of introducing
     // fill ops for generic arguments unless they belong directly to the target
@@ -3338,7 +3312,6 @@ namespace {
         // Lay out the field, but don't fill it in, we will copy it from
         // the superclass.
         HasDependentMetadata = true;
-        InheritGenericParameters = true;
         ClassMetadataBuilderBase::addGenericArgument(type, forClass);
       }
     }
@@ -3353,7 +3326,6 @@ namespace {
         // Lay out the field, but don't provide the fill op, which we'll get
         // from the superclass.
         HasDependentMetadata = true;
-        InheritGenericParameters = true;
         ClassMetadataBuilderBase::addGenericWitnessTable(type, protocol,
                                                          forClass);
       }
@@ -3446,15 +3418,13 @@ namespace {
         IGF.Builder.CreateStore(rodata, rodataPtrSlot);
       }
 
-      // If the field layout is dependent, ask the runtime to populate the
-      // offset vector.
+      // If we have fields that are not fixed-size, ask the runtime to
+      // populate the offset vector.
       //
-      // FIXME: the right check here is if the class layout is dependent or
-      // resilient. Also if only the superclass is resilient, we can get away
+      // FIXME: if only the superclass is resilient, we can get away
       // with sliding field offsets instead of doing the entire layout all
       // over again.
-      if (Target->isGenericContext() &&
-          HasDependentFieldOffsetVector) {
+      if (!Layout.isFixedLayout()) {
         llvm::Value *fieldVector
           = emitAddressOfFieldOffsetVectorInClassMetadata(IGF,
                                                           Target, metadata)
@@ -3505,18 +3475,19 @@ namespace {
                                {metadata, numFields,
                                 firstField.getAddress(), fieldVector});
 
-      } else if (InheritFieldOffsetVectors || InheritGenericParameters) {
+      } else {
         // If we have any ancestor generic parameters or field offset vectors,
         // copy them from the superclass metadata.
         auto initFn = IGF.IGM.getInitializeSuperclassFn();
+
+        bool copyFieldOffsetVectors = false;
+        if (FieldLayout.MetadataAccess != FieldAccess::ConstantDirect)
+          copyFieldOffsetVectors = true;
+
         IGF.Builder.CreateCall(initFn,
                                {metadata,
                                 llvm::ConstantInt::get(IGF.IGM.Int1Ty,
-                                                       InheritFieldOffsetVectors)});
-      } else if (IGF.IGM.ObjCInterop) {
-        // Register the class with the ObjC runtime.
-        llvm::Value *instantiateObjC = IGF.IGM.getInstantiateObjCClassFn();
-        IGF.Builder.CreateCall(instantiateObjC, metadata);
+                                                       copyFieldOffsetVectors)});
       }
     }