IRGen: Emit Objective-C resilient class stubs if experimental flag is on

slavapestov · slavapestov · commit 68c07620cd39 · 2019-03-26T18:53:09.000-04:00
Non-generic classes with resilient ancestry do not have statically-emitted
metadata, so we can now emit an Objective-C resilient class stub instead.

Also, when emitting an Objective-C category, reference the class stub if
the class has resilient ancestry; previously this case would hit an assert.

Note that class stubs always start with a zero word, with the address point
pointing immediately after. This works around a linker issue, where the
linker tries to coalesce categories and gets confused upon encountering a
class stub.
diff --git a/include/swift/ABI/Metadata.h b/include/swift/ABI/Metadata.h
@@ -3683,9 +3683,17 @@ struct TargetResilientSuperclass {
   TargetRelativeDirectPointer<Runtime, const void, /*nullable*/true> Superclass;
 };
 
+/// A structure that stores a reference to an Objective-C class stub.
+///
+/// This is not the class stub itself; it is part of a class context
+/// descriptor.
 template <typename Runtime>
-struct TargetObjCResilientClassStub {
-  /// A relative pointer to an Objective-C resilient class stub:
+struct TargetObjCResilientClassStubInfo {
+  /// A relative pointer to an Objective-C resilient class stub.
+  ///
+  /// We do not declare a struct type for class stubs since the Swift runtime
+  /// does not need to interpret them. The class stub struct is part of
+  /// the Objective-C ABI, and is laid out as follows:
   /// - isa pointer, always 1
   /// - an update callback, of type 'Class (*)(Class *, objc_class_stub *)'
   ///
@@ -3710,7 +3718,7 @@ class TargetClassDescriptor final
                               TargetMethodDescriptor<Runtime>,
                               TargetOverrideTableHeader<Runtime>,
                               TargetMethodOverrideDescriptor<Runtime>,
-                              TargetObjCResilientClassStub<Runtime>> {
+                              TargetObjCResilientClassStubInfo<Runtime>> {
 private:
   using TrailingGenericContextObjects =
     TrailingGenericContextObjects<TargetClassDescriptor<Runtime>,
@@ -3722,7 +3730,7 @@ class TargetClassDescriptor final
                                   TargetMethodDescriptor<Runtime>,
                                   TargetOverrideTableHeader<Runtime>,
                                   TargetMethodOverrideDescriptor<Runtime>,
-                                  TargetObjCResilientClassStub<Runtime>>;
+                                  TargetObjCResilientClassStubInfo<Runtime>>;
 
   using TrailingObjects =
     typename TrailingGenericContextObjects::TrailingObjects;
@@ -3738,8 +3746,8 @@ class TargetClassDescriptor final
     TargetForeignMetadataInitialization<Runtime>;
   using SingletonMetadataInitialization =
     TargetSingletonMetadataInitialization<Runtime>;
-  using ObjCResilientClassStub =
-    TargetObjCResilientClassStub<Runtime>;
+  using ObjCResilientClassStubInfo =
+    TargetObjCResilientClassStubInfo<Runtime>;
 
   using StoredPointer = typename Runtime::StoredPointer;
   using StoredPointerDifference = typename Runtime::StoredPointerDifference;
@@ -3777,8 +3785,8 @@ class TargetClassDescriptor final
     /// positive size of metadata objects of this class (in words).
     uint32_t MetadataPositiveSizeInWords;
 
-    /// Classes with resilient ancestry instead use this flags word to
-    /// indicate the presence of an Objective-C resilient class stub.
+    /// Otherwise, these flags are used to do things like indicating
+    /// the presence of an Objective-C resilient class stub.
     ExtraClassDescriptorFlags ExtraClassFlags;
   };
 
@@ -3855,7 +3863,7 @@ class TargetClassDescriptor final
     return getOverrideTable()->NumEntries;
   }
 
-  size_t numTrailingObjects(OverloadToken<ObjCResilientClassStub>) const {
+  size_t numTrailingObjects(OverloadToken<ObjCResilientClassStubInfo>) const {
     return hasObjCResilientClassStub() ? 1 : 0;
   }
 
@@ -3980,7 +3988,7 @@ class TargetClassDescriptor final
   }
 
   /// Whether this context descriptor references an Objective-C resilient
-  /// class stub. See the description of TargetObjCResilientClassStub above
+  /// class stub. See the above description of TargetObjCResilientClassStubInfo
   /// for details.
   bool hasObjCResilientClassStub() const {
     if (!hasResilientSuperclass())
@@ -3992,7 +4000,7 @@ class TargetClassDescriptor final
     if (!hasObjCResilientClassStub())
       return nullptr;
 
-    return this->template getTrailingObjects<ObjCResilientClassStub>()
+    return this->template getTrailingObjects<ObjCResilientClassStubInfo>()
       ->Stub.get();
   }
 
diff --git a/include/swift/ABI/MetadataValues.h b/include/swift/ABI/MetadataValues.h
@@ -1315,7 +1315,7 @@ class ExtraClassDescriptorFlags : public FlagSet<uint32_t> {
   enum {
     /// Set if the context descriptor includes a pointer to an Objective-C
     /// resilient class stub structure. See the description of
-    /// TargetObjCResilientClassStub in Metadata.h for details.
+    /// TargetObjCResilientClassStubInfo in Metadata.h for details.
     ///
     /// Only meaningful for class descriptors when Objective-C interop is
     /// enabled.
diff --git a/lib/IRGen/GenCast.cpp b/lib/IRGen/GenCast.cpp
@@ -107,7 +107,8 @@ FailableCastResult irgen::emitClassIdenticalCast(IRGenFunction &IGF,
   llvm::Value *targetMetadata;
   if ((targetMetadata =
            tryEmitConstantHeapMetadataRef(IGF.IGM, toType.getASTType(),
-                                          /*allowUninitialized*/ false))) {
+                                          /*allowUninitialized*/ false,
+                                          /*allowStub*/ false))) {
     // ok
   } else {
     targetMetadata
diff --git a/lib/IRGen/GenClass.cpp b/lib/IRGen/GenClass.cpp
@@ -1207,7 +1207,9 @@ namespace {
       else {
         auto type = getSelfType(getClass()).getASTType();
         llvm::Constant *metadata =
-          tryEmitConstantHeapMetadataRef(IGM, type, /*allowUninit*/ true);
+          tryEmitConstantHeapMetadataRef(IGM, type,
+                                         /*allowUninit*/ true,
+                                         /*allowStub*/ true);
         assert(metadata &&
                "extended objc class doesn't have constant metadata?");
         fields.add(metadata);
@@ -2048,6 +2050,48 @@ static llvm::Function *emitObjCMetadataUpdateFunction(IRGenModule &IGM,
   return f;
 }
 
+/// We emit Objective-C class stubs for non-generic classes with resilient
+/// ancestry. This lets us attach categories to the class even though it
+/// does not have statically-emitted metadata.
+bool irgen::hasObjCResilientClassStub(IRGenModule &IGM, ClassDecl *D) {
+  assert(IGM.getClassMetadataStrategy(D) == ClassMetadataStrategy::Resilient);
+  return (!D->isGenericContext() &&
+          IGM.ObjCInterop &&
+          IGM.Context.LangOpts.EnableObjCResilientClassStubs);
+}
+
+void irgen::emitObjCResilientClassStub(IRGenModule &IGM, ClassDecl *D) {
+  assert(hasObjCResilientClassStub(IGM, D));
+
+  llvm::Constant *fields[] = {
+    llvm::ConstantInt::get(IGM.SizeTy, 0), // reserved
+    llvm::ConstantInt::get(IGM.SizeTy, 1), // isa
+    IGM.getAddrOfObjCMetadataUpdateFunction(D, NotForDefinition)
+  };
+  auto init = llvm::ConstantStruct::get(IGM.ObjCFullResilientClassStubTy,
+                                        makeArrayRef(fields));
+
+  // Define the full stub. This is a private symbol.
+  auto fullObjCStub = cast<llvm::GlobalVariable>(
+      IGM.getAddrOfObjCResilientClassStub(D, ForDefinition,
+                                          TypeMetadataAddress::FullMetadata));
+  fullObjCStub->setInitializer(init);
+
+  // Emit the metadata update function referenced above.
+  emitObjCMetadataUpdateFunction(IGM, D);
+
+  // Apply the offset.
+  auto *objcStub = llvm::ConstantExpr::getBitCast(fullObjCStub, IGM.Int8PtrTy);
+  objcStub = llvm::ConstantExpr::getInBoundsGetElementPtr(
+      IGM.Int8Ty, objcStub, IGM.getSize(IGM.getPointerSize()));
+  objcStub = llvm::ConstantExpr::getPointerCast(objcStub,
+      IGM.ObjCResilientClassStubTy->getPointerTo());
+
+  auto entity = LinkEntity::forObjCResilientClassStub(
+      D, TypeMetadataAddress::AddressPoint);
+  IGM.defineAlias(entity, objcStub);
+}
+
 /// Emit the private data (RO-data) associated with a class.
 llvm::Constant *irgen::emitClassPrivateData(IRGenModule &IGM,
                                             ClassDecl *cls) {
diff --git a/lib/IRGen/GenClass.h b/lib/IRGen/GenClass.h
@@ -170,6 +170,14 @@ namespace irgen {
                                     llvm::Value *selfValue,
                                     llvm::Value *metadataValue);
 
+  /// We emit Objective-C class stubs for non-generic classes with resilient
+  /// ancestry. This lets us attach categories to the class even though it
+  /// does not have statically-emitted metadata.
+  bool hasObjCResilientClassStub(IRGenModule &IGM, ClassDecl *D);
+
+  /// Emit a resilient class stub.
+  void emitObjCResilientClassStub(IRGenModule &IGM, ClassDecl *D);
+
   /// Emit the constant fragile offset of the given property inside an instance
   /// of the class.
   llvm::Constant *
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -1631,6 +1631,7 @@ namespace {
 
       // union {
       //   uint32_t MetadataPositiveSizeInWords;
+      //   ExtraClassContextFlags ExtraClassFlags;
       // };
       if (!MetadataLayout) {
         // FIXME: do something meaningful for foreign classes?
@@ -1639,7 +1640,10 @@ namespace {
         B.addInt32(MetadataLayout->getSize().getOffsetToEnd()
                      / IGM.getPointerSize());
       } else {
-        B.addInt32(0); // currently unused
+        ExtraClassDescriptorFlags flags;
+        if (hasObjCResilientClassStub(IGM, getType()))
+          flags.setObjCResilientClassStub(true);
+        B.addInt32(flags.getOpaqueValue());
       }
 
       // uint32_t NumImmediateMembers;
@@ -2552,7 +2556,8 @@ namespace {
       Type type = Target->mapTypeIntoContext(Target->getSuperclass());
       auto *metadata = tryEmitConstantHeapMetadataRef(
           IGM, type->getCanonicalType(),
-          /*allowUninit*/ false);
+          /*allowUninit*/ false,
+          /*allowStub*/ false);
       assert(metadata != nullptr);
       B.add(metadata);
     }
@@ -3137,6 +3142,26 @@ void irgen::emitClassMetadata(IRGenModule &IGM, ClassDecl *classDecl,
   if (IGM.ObjCInterop) {
     switch (strategy) {
     case ClassMetadataStrategy::Resilient:
+      // Even non-@objc classes can have Objective-C categories attached, so
+      // we always emit a resilient class stub as long as -enable-objc-interop
+      // is set.
+      if (hasObjCResilientClassStub(IGM, classDecl)) {
+        emitObjCResilientClassStub(IGM, classDecl);
+
+        if (classDecl->isObjC()) {
+          auto *stub = IGM.getAddrOfObjCResilientClassStub(
+              classDecl, NotForDefinition,
+              TypeMetadataAddress::AddressPoint);
+          emitObjCClassSymbol(IGM, classDecl, stub);
+
+          // @_objc_non_lazy_realization is only for use by the standard
+          // library, and we cannot support it with Objective-C class
+          // stubs (which there are none of in the standard library).
+          assert(!classDecl->getAttrs().hasAttribute<ObjCNonLazyRealizationAttr>());
+          IGM.addObjCClass(stub, /*eagerInitialization=*/false);
+        }
+      }
+      break;
     case ClassMetadataStrategy::Singleton:
       break;
     
diff --git a/lib/IRGen/MetadataRequest.cpp b/lib/IRGen/MetadataRequest.cpp
@@ -508,14 +508,20 @@ irgen::getRuntimeReifiedType(IRGenModule &IGM, CanType type) {
 /// Attempts to return a constant heap metadata reference for a
 /// class type.  This is generally only valid for specific kinds of
 /// ObjC reference, like superclasses or category references.
-llvm::Constant *irgen::tryEmitConstantHeapMetadataRef(IRGenModule &IGM,
-                                                      CanType type,
-                                              bool allowDynamicUninitialized) {
+llvm::Constant *
+irgen::tryEmitConstantHeapMetadataRef(IRGenModule &IGM,
+                                      CanType type,
+                                      bool allowDynamicUninitialized,
+                                      bool allowStub) {
   auto theDecl = type->getClassOrBoundGenericClass();
   assert(theDecl && "emitting constant heap metadata ref for non-class type?");
 
   switch (IGM.getClassMetadataStrategy(theDecl)) {
   case ClassMetadataStrategy::Resilient:
+    if (allowStub && IGM.Context.LangOpts.EnableObjCResilientClassStubs) {
+      return IGM.getAddrOfObjCResilientClassStub(theDecl, NotForDefinition,
+                                            TypeMetadataAddress::AddressPoint);
+    }
     return nullptr;
 
   case ClassMetadataStrategy::Singleton:
diff --git a/lib/IRGen/MetadataRequest.h b/lib/IRGen/MetadataRequest.h
@@ -592,7 +592,8 @@ CanType getRuntimeReifiedType(IRGenModule &IGM, CanType type);
 /// by a constant.
 llvm::Constant *tryEmitConstantHeapMetadataRef(IRGenModule &IGM,
                                                CanType type,
-                                               bool allowUninitialized);
+                                               bool allowUninitialized,
+                                               bool allowStub);
 
 enum class MetadataValueType { ObjCClass, TypeMetadata };
 
diff --git a/lib/TBDGen/TBDGen.cpp b/lib/TBDGen/TBDGen.cpp
@@ -345,9 +345,16 @@ void TBDGenVisitor::visitClassDecl(ClassDecl *CD) {
 
   // Types with resilient superclasses have some extra symbols.
   if (CD->checkAncestry(AncestryFlags::ResilientOther) ||
-      CD->hasResilientMetadata())
+      CD->hasResilientMetadata()) {
     addSymbol(LinkEntity::forClassMetadataBaseOffset(CD));
 
+    auto &Ctx = CD->getASTContext();
+    if (Ctx.LangOpts.EnableObjCResilientClassStubs) {
+      addSymbol(LinkEntity::forObjCResilientClassStub(
+          CD, TypeMetadataAddress::AddressPoint));
+    }
+  }
+
   // Emit dispatch thunks for every new vtable entry.
   struct VTableVisitor : public SILVTableVisitor<VTableVisitor> {
     TBDGenVisitor &TBD;
diff --git a/test/IRGen/class_update_callback_with_stub.swift b/test/IRGen/class_update_callback_with_stub.swift
diff --git a/test/Inputs/resilient_objc_class.swift b/test/Inputs/resilient_objc_class.swift
