Merge pull request swiftlang#22634 from slavapestov/update-callback-new-runtime

Always use update callback for classes when the deployment target is sufficiently new

Author: slavapestov

include/swift/IRGen/Linking.h

@@ -158,8 +158,8 @@ class LinkEntity {
     SwiftMetaclassStub,
 
     /// A callback used by newer Objective-C runtimes to initialize class
-    /// metadata for classes where doesClassMetadataRequireUpdate() is true
-    /// but doesClassMetadataRequireInitialization() is false.
+    /// metadata for classes where getClassMetadataStrategy() is equal to
+    /// ClassMetadataStrategy::Update or ::FixedOrUpdate.
     ObjCMetadataUpdateFunction,
 
     /// A class metadata base offset global variable.  This stores the offset

lib/IRGen/ClassLayout.cpp

@@ -25,19 +25,15 @@ using namespace swift;
 using namespace irgen;
 
 ClassLayout::ClassLayout(const StructLayoutBuilder &builder,
-                         bool isFixedSize,
-                         bool metadataRequiresInitialization,
-                         bool metadataRequiresRelocation,
+                         ClassMetadataOptions options,
                          llvm::Type *classTy,
                          ArrayRef<VarDecl *> allStoredProps,
                          ArrayRef<FieldAccess> allFieldAccesses,
                          ArrayRef<ElementLayout> allElements)
   : MinimumAlign(builder.getAlignment()),
     MinimumSize(builder.getSize()),
     IsFixedLayout(builder.isFixedLayout()),
-    IsFixedSize(isFixedSize),
-    MetadataRequiresInitialization(metadataRequiresInitialization),
-    MetadataRequiresRelocation(metadataRequiresRelocation),
+    Options(options),
     Ty(classTy),
     AllStoredProperties(allStoredProps),
     AllFieldAccesses(allFieldAccesses),

lib/IRGen/ClassLayout.h

@@ -39,6 +39,65 @@ enum class FieldAccess : uint8_t {
   ConstantIndirect
 };
 
+/// A set of flags describing properties of a class's metadata layout.
+/// The presence or absence of these flags determines how much static
+/// knowledge the compiler has of the layout of this class and its
+/// metadata, which in turn will determine the strategy used to emit
+/// and initialize class metadata.
+enum class ClassMetadataFlags {
+  /// Does the class or any of its superclasses have stored properties that
+  /// where dropped due to the Swift language version availability of
+  /// their types?
+  ClassHasMissingMembers = (1 << 0),
+
+  /// Does the class or any of its fragile superclasses have stored
+  /// properties of unknown size, which do *not* depend on generic
+  /// parameters?
+  ///
+  /// This is different from the class itself being resilient or
+  /// having resilient ancestry, because we still have a fixed layout
+  /// for the class metadata in this case.
+  ///
+  /// In fact, for a class with resilient ancestry, this can still be
+  /// false if all of the fields known to us are fixed size.
+  ClassHasResilientMembers = (1 << 1),
+
+  /// Is this class or any of its superclasses generic?
+  ClassHasGenericAncestry = (1 << 2),
+
+  /// Is this class itself generic via the Swift generic system, ie. not a
+  /// lightweight Objective-C generic class?
+  ClassIsGeneric = (1 << 3),
+
+  /// Does the class layout depend on the size or alignment of its
+  /// generic parameters?
+  ///
+  /// This can be the case if the class has generic resilient ancestry
+  /// that depends on the class's generic parameters, of it it has
+  /// fields of generic type that are not fixed size.
+  ClassHasGenericLayout = (1 << 4),
+
+  /// Is this class or any of its superclasses resilient from the viewpoint
+  /// of the current module? This means that their metadata can change size,
+  /// hence field offsets, generic arguments and virtual methods must be
+  /// accessed relative to a metadata base global variable.
+  ///
+  /// Note that a @_fixed_layout class in a resilient module still has
+  /// resilient metadata, so any subclasses will have this flag set;
+  /// to check for resilient stored property layout, check for
+  /// ClassHasResilientMembers.
+  ClassHasResilientAncestry = (1 << 5),
+
+  /// Are any of this class's superclasses defined in Objective-C?
+  /// This means that field offsets must be loaded from field offset globals
+  /// or the field offset vector in the metadata, and the Objective-C runtime
+  /// will slide offsets based on the actual superclass size, which is not
+  /// known at compile time.
+  ClassHasObjCAncestry = (1 << 6)
+};
+
+using ClassMetadataOptions = OptionSet<ClassMetadataFlags>;
+
 class ClassLayout {
   /// The statically-known minimum bound on the alignment.
   Alignment MinimumAlign;
@@ -50,18 +109,7 @@ class ClassLayout {
   /// alignment are exact.
   bool IsFixedLayout;
 
-  /// Do instances of this class have a size and layout known at compile time?
-  ///
-  /// Note: This is a stronger condition than having a fixed layout. The latter
-  /// is true even when the class requires sliding ivars by the Objective-C
-  /// runtime.
-  bool IsFixedSize;
-
-  /// Does the class metadata require initialization?
-  bool MetadataRequiresInitialization;
-
-  /// Does the class metadata require relocation?
-  bool MetadataRequiresRelocation;
+  ClassMetadataOptions Options;
 
   /// The LLVM type for instances of this class.
   llvm::Type *Ty;
@@ -79,9 +127,7 @@ class ClassLayout {
 
 public:
   ClassLayout(const StructLayoutBuilder &builder,
-              bool isFixedSize,
-              bool metadataRequiresInitialization,
-              bool metadataRequiresRelocation,
+              ClassMetadataOptions options,
               llvm::Type *classTy,
               ArrayRef<VarDecl *> allStoredProps,
               ArrayRef<FieldAccess> allFieldAccesses,
@@ -96,14 +142,49 @@ class ClassLayout {
 
   bool isFixedLayout() const { return IsFixedLayout; }
 
-  bool isFixedSize() const { return IsFixedSize; }
+  /// Returns true if the stored property layout of instances of this class
+  /// is known at compile time.
+  ///
+  /// Note that ClassHasResilientAncestry or ClassHasGenericAncestry might
+  /// still be true; the former means the class has resilient metadata, so
+  /// it might still be @_fixed_layout; the latter means we have a generic
+  /// superclass, but it doesn't mean the layout actually depends on any
+  /// generic parameters.
+  bool isFixedSize() const {
+    return !(Options.contains(ClassMetadataFlags::ClassHasMissingMembers) ||
+             Options.contains(ClassMetadataFlags::ClassHasResilientMembers) ||
+             Options.contains(ClassMetadataFlags::ClassHasGenericLayout) ||
+             Options.contains(ClassMetadataFlags::ClassHasObjCAncestry));
+  }
 
+  /// Returns true iff everything about the class metadata layout is statically
+  /// known except field offsets and the instance size and alignment.
+  ///
+  /// Will assert if the class metadata is "more" dynamic; you must check
+  /// doesMetadataRequireRelocation() and doesMetadataRequireInitialization()
+  /// first.
+  bool doesMetadataRequireUpdate() const {
+    assert(!doesMetadataRequireInitialization());
+    return (Options.contains(ClassMetadataFlags::ClassHasResilientMembers) ||
+            Options.contains(ClassMetadataFlags::ClassHasMissingMembers));
+  }
+
+  /// Returns true iff everything about the class metadata layout is statically
+  /// known except the superclass field must be instantiated at runtime because
+  /// it is a generic class type.
+  ///
+  /// Will assert if the class metadata is "more" dynamic; you must check
+  /// doesMetadataRequireRelocation() first.
   bool doesMetadataRequireInitialization() const {
-    return MetadataRequiresInitialization;
+    assert(!doesMetadataRequireRelocation());
+    return Options.contains(ClassMetadataFlags::ClassHasGenericAncestry);
   }
 
+  /// Returns true if the class metadata must be built at runtime because its
+  /// size is not known at compile time. This is the most general case.
   bool doesMetadataRequireRelocation() const {
-    return MetadataRequiresRelocation;
+    return (Options.contains(ClassMetadataFlags::ClassHasResilientAncestry) ||
+            Options.contains(ClassMetadataFlags::ClassIsGeneric));
   }
 
   std::pair<FieldAccess, ElementLayout>