IRGen: When available, use ClassMetadataStrategy::Update even if we don't have legacy type info

If we know our deployment target has a new Objective-C runtime, we can
emit fixed metadata for classes with resilient types even if those
types do not appear in the YAML legacy type info.

Fixes <rdar://problem/47649465>.

Author: slavapestov

lib/IRGen/ClassLayout.h

@@ -157,13 +157,31 @@ class ClassLayout {
              Options.contains(ClassMetadataFlags::ClassHasObjCAncestry));
   }
 
-  bool doesMetadataRequireInitialization() const {
-    return (Options.contains(ClassMetadataFlags::ClassHasResilientAncestry) ||
-            Options.contains(ClassMetadataFlags::ClassHasGenericAncestry) ||
-            Options.contains(ClassMetadataFlags::ClassHasResilientMembers) ||
+  /// 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 {
+    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 (Options.contains(ClassMetadataFlags::ClassHasResilientAncestry) ||
             Options.contains(ClassMetadataFlags::ClassIsGeneric));

lib/IRGen/GenClass.cpp

@@ -2237,21 +2237,47 @@ IRGenModule::getClassMetadataStrategy(const ClassDecl *theClass) {
 
   auto &resilientLayout = selfTI.getClassLayout(*this, selfType,
                                               /*forBackwardDeployment=*/false);
-  auto &fragileLayout = selfTI.getClassLayout(*this, selfType,
-                                              /*forBackwardDeployment=*/true);
 
   if (resilientLayout.doesMetadataRequireRelocation())
     return ClassMetadataStrategy::Resilient;
 
-  if (fragileLayout.doesMetadataRequireInitialization())
+  // On Windows, we want to force singleton metadata initialization, since
+  // fixed class metadata emission requires an absolute global reference to the
+  // Builtin.NativeObject value witness table in the runtime, which is something
+  // the PE executable format does not support.
+  if (IRGen.Opts.LazyInitializeClassMetadata)
     return ClassMetadataStrategy::Singleton;
 
-  // If the legacy type info was sufficient to produce a fixed fragile layout,
-  // but our resilient layout requires initialization, we can use the fixed
-  // layout on older Objective-C runtimes, and emit an update callback for
-  // newer Objective-C runtimes.
+  // If we have generic ancestry, we have to use the singleton pattern.
   if (resilientLayout.doesMetadataRequireInitialization())
+    return ClassMetadataStrategy::Singleton;
+
+  // If we have resiliently-sized fields, we might be able to use the
+  // update pattern.
+  if (resilientLayout.doesMetadataRequireUpdate()) {
+    // The update pattern only benefits us on platforms with an Objective-C
+    // runtime, otherwise just use the singleton pattern.
+    if (!Context.LangOpts.EnableObjCInterop)
+      return ClassMetadataStrategy::Singleton;
+
+    // If the Objective-C runtime is new enough, we can just use the update
+    // pattern unconditionally.
+    if (Types.doesPlatformSupportObjCMetadataUpdateCallback())
+      return ClassMetadataStrategy::Update;
+
+    // Otherwise, check if we have legacy type info for backward deployment.
+    auto &fragileLayout = selfTI.getClassLayout(*this, selfType,
+                                               /*forBackwardDeployment=*/true);
+
+    // If we still have resiliently-sized fields even when using the legacy
+    // type info, fall back to the singleton pattern.
+    if (fragileLayout.doesMetadataRequireUpdate())
+      return ClassMetadataStrategy::Singleton;
+
+    // We're going to use the legacy type info on older Objective-C runtimes,
+    // and the update callback on newer runtimes.
     return ClassMetadataStrategy::FixedOrUpdate;
+  }
 
   return ClassMetadataStrategy::Fixed;
 }

lib/IRGen/GenType.cpp

@@ -1116,6 +1116,12 @@ TypeConverter::getLegacyTypeInfo(NominalTypeDecl *decl) const {
   return found->second;
 }
 
+// The following Apple platforms support backward deployment of Swift
+// code built with Swift 5.0 running on an old Objective-C runtime
+// that does not support the class metadata update hook.
+//
+// We ship a YAML legacy type info file for these platforms as part
+// of the toolchain.
 static llvm::StringLiteral platformsWithLegacyLayouts[][2] = {
   {"appletvos", "arm64"},
   {"appletvsimulator", "x86_64"},
@@ -1140,6 +1146,26 @@ static bool doesPlatformUseLegacyLayouts(StringRef platformName,
 
   return false;
 }
+
+// The following Apple platforms ship an Objective-C runtime supporting
+// the class metadata update hook:
+//
+// - macOS 10.14.4
+// - iOS 12.2
+// - tvOS 12.2
+// - watchOS 5.2
+static bool doesPlatformSupportObjCMetadataUpdateCallback(
+    const llvm::Triple &triple) {
+  if (triple.isMacOSX())
+    return !triple.isMacOSXVersionLT(10, 14, 4);
+  if (triple.isiOS()) // also returns true on tvOS
+    return !triple.isOSVersionLT(12, 2);
+  if (triple.isWatchOS())
+    return !triple.isOSVersionLT(5, 2);
+
+  return false;
+}
+
 TypeConverter::TypeConverter(IRGenModule &IGM)
   : IGM(IGM),
     FirstType(invalidTypeInfo()) {
@@ -1153,6 +1179,15 @@ TypeConverter::TypeConverter(IRGenModule &IGM)
 
   const auto &Triple = IGM.Context.LangOpts.Target;
 
+  SupportsObjCMetadataUpdateCallback =
+    ::doesPlatformSupportObjCMetadataUpdateCallback(Triple);
+
+  // If our deployment target allows us to rely on the metadata update
+  // callback being called, we don't have to emit a legacy layout for a
+  // class with resiliently-sized fields.
+  if (SupportsObjCMetadataUpdateCallback)
+    return;
+
   // We have a bunch of -parse-stdlib tests that pass a -target in the test
   // suite. To prevent these from failing when the user hasn't build the
   // standard library for that target, we pass -disable-legacy-type-info to

lib/IRGen/GenType.h

@@ -114,6 +114,7 @@ class TypeConverter {
   const LoadableTypeInfo *SwiftRetainablePointerBoxTI = nullptr,
                          *UnknownObjectRetainablePointerBoxTI = nullptr;
 
+  bool SupportsObjCMetadataUpdateCallback = false;
   llvm::StringMap<YAMLTypeInfoNode> LegacyTypeInfos;
   llvm::DenseMap<NominalTypeDecl *, std::string> DeclMangledNames;
 
@@ -159,6 +160,10 @@ class TypeConverter {
     return LoweringMode;
   }
 
+  bool doesPlatformSupportObjCMetadataUpdateCallback() const {
+    return SupportsObjCMetadataUpdateCallback;
+  }
+
   const TypeInfo *getTypeEntry(CanType type);
   const TypeInfo &getCompleteTypeInfo(CanType type);
   const LoadableTypeInfo &getNativeObjectTypeInfo();