IRGen: Introduce ClassMetadataStrategy to clean up some checks

This consolidates the various doesClassMetadataRequire*() checks, making
them more managable.

This also adds a forth state, ClassMetadataStrategy::Update. This will be used
when deploying to the new Objective-C runtime. For now it's not plumbed through.

Progress on <rdar://problem/47649465>.

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/GenClass.cpp

@@ -105,7 +105,7 @@ namespace {
 } // end anonymous namespace
 
 /// Return the lowered type for the class's 'self' type within its context.
-static SILType getSelfType(ClassDecl *base) {
+static SILType getSelfType(const ClassDecl *base) {
   auto loweredTy = base->getDeclaredTypeInContext()->getCanonicalType();
   return SILType::getPrimitiveObjectType(loweredTy);
 }
@@ -2131,10 +2131,17 @@ llvm::Constant *irgen::emitClassPrivateData(IRGenModule &IGM,
   builder.buildMetaclassStub();
 
   HasUpdateCallback_t hasUpdater = DoesNotHaveUpdateCallback;
-  if (doesClassMetadataRequireUpdate(IGM, cls) &&
-      !doesClassMetadataRequireInitialization(IGM, cls)) {
+
+  switch (IGM.getClassMetadataStrategy(cls)) {
+  case ClassMetadataStrategy::Resilient:
+  case ClassMetadataStrategy::Singleton:
+  case ClassMetadataStrategy::Fixed:
+    break;
+  case ClassMetadataStrategy::Update:
+  case ClassMetadataStrategy::FixedOrUpdate:
     hasUpdater = HasUpdateCallback;
     emitObjCMetadataUpdateFunction(IGM, cls);
+    break;
   }
 
   // Then build the class RO-data.
@@ -2293,40 +2300,26 @@ ClassDecl *irgen::getRootClassForMetaclass(IRGenModule &IGM, ClassDecl *C) {
                                      IGM.Context.Id_SwiftObject);
 }
 
-bool irgen::doesClassMetadataRequireRelocation(IRGenModule &IGM,
-                                               ClassDecl *theClass) {
+ClassMetadataStrategy
+IRGenModule::getClassMetadataStrategy(const ClassDecl *theClass) {
   SILType selfType = getSelfType(theClass);
-  auto &selfTI = IGM.getTypeInfo(selfType).as<ClassTypeInfo>();
-
-  // A completely fragile layout does not change whether the metadata
-  // requires *relocation*, since that only depends on resilient class
-  // ancestry, or the class itself being generic.
-  auto &layout = selfTI.getClassLayout(IGM, selfType,
-                                       /*forBackwardDeployment=*/false);
-  return layout.doesMetadataRequireRelocation();
-}
+  auto &selfTI = getTypeInfo(selfType).as<ClassTypeInfo>();
 
-bool irgen::doesClassMetadataRequireInitialization(IRGenModule &IGM,
-                                                   ClassDecl *theClass) {
-  SILType selfType = getSelfType(theClass);
-  auto &selfTI = IGM.getTypeInfo(selfType).as<ClassTypeInfo>();
-
-  // If we have a fragile layout used for backward deployment, we must use
-  // idempotent initialization; swift_initClassMetadata() does not work with
-  // statically registered classes.
-  auto &layout = selfTI.getClassLayout(IGM, selfType,
-                                       /*forBackwardDeployment=*/true);
-  return layout.doesMetadataRequireInitialization();
-}
+  auto &resilientLayout = selfTI.getClassLayout(*this, selfType,
+                                              /*forBackwardDeployment=*/false);
+  auto &fragileLayout = selfTI.getClassLayout(*this, selfType,
+                                              /*forBackwardDeployment=*/true);
 
-bool irgen::doesClassMetadataRequireUpdate(IRGenModule &IGM,
-                                           ClassDecl *theClass) {
-  SILType selfType = getSelfType(theClass);
-  auto &selfTI = IGM.getTypeInfo(selfType).as<ClassTypeInfo>();
+  if (resilientLayout.doesMetadataRequireRelocation())
+    return ClassMetadataStrategy::Resilient;
+
+  if (fragileLayout.doesMetadataRequireInitialization())
+    return ClassMetadataStrategy::Singleton;
+
+  if (resilientLayout.doesMetadataRequireInitialization())
+    return ClassMetadataStrategy::FixedOrUpdate;
 
-  auto &layout = selfTI.getClassLayout(IGM, selfType,
-                                       /*forBackwardDeployment=*/false);
-  return layout.doesMetadataRequireInitialization();
+  return ClassMetadataStrategy::Fixed;
 }
 
 bool irgen::hasKnownSwiftMetadata(IRGenModule &IGM, CanType type) {

lib/IRGen/GenClass.h

@@ -75,6 +75,45 @@ namespace irgen {
     HasUpdateCallback = true
   };
 
+  /// Creates a layout for the class \p classType with allocated tail elements
+  /// \p tailTypes.
+  ///
+  /// The caller is responsible for deleting the returned StructLayout.
+  StructLayout *getClassLayoutWithTailElems(IRGenModule &IGM, SILType classType,
+                                            llvm::ArrayRef<SILType> tailTypes);
+
+  ClassDecl *getRootClassForMetaclass(IRGenModule &IGM, ClassDecl *theClass);
+
+  enum class ClassMetadataStrategy {
+    /// Does the given class have resilient ancestry, or is the class itself
+    /// generic?
+    Resilient,
+
+    /// Does the class require at in-place initialization because of
+    /// non-fixed size properties or generic ancestry? The class does not
+    /// export a static symbol visible to Objective-C code.
+    Singleton,
+
+    /// A more restricted case of the above. Does the class require at in-place
+    /// initialization because of non-fixed size properties, while exporting a
+    /// static symbol visible to Objective-C code? The Objective-C runtime is
+    /// able to initialize the metadata by calling the update callback stored
+    /// in rodata. This strategy can only be used if the class availability
+    /// restricts its use to newer Objective-C runtimes that support this
+    /// feature.
+    Update,
+
+    /// An even more restricted case of the above. The class requires in-place
+    /// initialization on newer Objective-C runtimes, but the metadata is
+    /// statically valid on older runtimes because field offsets were computed
+    /// assuming type layouts loaded from a legacy type info YAML file.
+    FixedOrUpdate,
+
+    /// The class metadata is completely static and only Objective-C runtime
+    /// realization (and possibly field offset sliding) must be performed.
+    Fixed
+  };
+
   std::pair<Size,Size>
   emitClassPrivateDataFields(IRGenModule &IGM,
                              ConstantStructBuilder &builder,
@@ -146,32 +185,6 @@ namespace irgen {
                            SILType baseType,
                            VarDecl *field);
 
-  /// Creates a layout for the class \p classType with allocated tail elements
-  /// \p tailTypes.
-  ///
-  /// The caller is responsible for deleting the returned StructLayout.
-  StructLayout *getClassLayoutWithTailElems(IRGenModule &IGM, SILType classType,
-                                            llvm::ArrayRef<SILType> tailTypes);
-
-  ClassDecl *getRootClassForMetaclass(IRGenModule &IGM, ClassDecl *theClass);
-
-  /// Does the given class have resilient ancestry, or is the class itself
-  /// generic?
-  bool doesClassMetadataRequireRelocation(IRGenModule &IGM,
-                                          ClassDecl *theClass);
-
-  /// Does the class require at least in-place initialization because of
-  /// non-fixed size properties or generic ancestry? If the class requires
-  /// relocation, this also returns true.
-  bool doesClassMetadataRequireInitialization(IRGenModule &IGM,
-                                              ClassDecl *theClass);
-
-  /// Does the class require at least an in-place update on newer Objective-C
-  /// runtimes? If the class requires full initialization or relocation, this
-  /// also returns true.
-  bool doesClassMetadataRequireUpdate(IRGenModule &IGM,
-                                      ClassDecl *theClass);
-
   /// Load the instance size and alignment mask from a reference to
   /// class type metadata of the given type.
   std::pair<llvm::Value *, llvm::Value *>