[DefaultOverides] Install in vtables at runtime.

Author: nate-chandler

include/swift/ABI/Metadata.h

@@ -654,6 +654,54 @@ using TargetRelativeProtocolRequirementPointer =
 using RelativeProtocolRequirementPointer =
   TargetRelativeProtocolRequirementPointer<InProcess>;
 
+/// An entry in the default override table, consisting of one of our methods
+/// `replacement` together with (1) another of our methods `original` which
+/// might have been overridden by a subclass and (2) an implementation of
+/// `replacement` to be used by such a subclass if it does not provide its own
+/// implementation.
+template <typename Runtime>
+struct TargetMethodDefaultOverrideDescriptor {
+  /// The method which replaced the original at call-sites.
+  TargetRelativeMethodDescriptorPointer<Runtime> Replacement;
+
+  /// The method originally called at such call sites.
+  TargetRelativeMethodDescriptorPointer<Runtime> Original;
+
+  union {
+    TargetCompactFunctionPointer<Runtime, void, /*nullable*/ true> Impl;
+    TargetRelativeDirectPointer<Runtime, void, /*nullable*/ true> AsyncImpl;
+    TargetRelativeDirectPointer<Runtime, void, /*nullable*/ true> CoroImpl;
+  };
+
+  bool isData() const {
+    auto *replacement = Replacement.get();
+    assert(replacement && "no replacement");
+    return replacement->Flags.isData();
+  }
+
+  void *getImpl() const {
+    auto *replacement = Replacement.get();
+    assert(replacement && "no replacement");
+    if (replacement->Flags.isAsync()) {
+      return AsyncImpl.get();
+    } else if (replacement->Flags.isCalleeAllocatedCoroutine()) {
+      return CoroImpl.get();
+    } else {
+      return Impl.get();
+    }
+  }
+};
+
+/// Header for a table of default override descriptors.  Such a table is a
+/// variable-sized structure whose length is stored in this header which is
+/// followed by that many TargetMethodDefaultOverrideDescriptors.
+template <typename Runtime>
+struct TargetMethodDefaultOverrideTableHeader {
+  /// The number of TargetMethodDefaultOverrideDescriptor records following this
+  /// header in the class's nominal type descriptor.
+  uint32_t NumEntries;
+};
+
 /// An entry in the method override table, referencing a method from one of our
 /// ancestor classes, together with an implementation.
 template <typename Runtime>
@@ -4205,9 +4253,11 @@ class swift_ptrauth_struct_context_descriptor(ClassDescriptor)
                               TargetCanonicalSpecializedMetadataAccessorsListEntry<Runtime>,
                               TargetCanonicalSpecializedMetadatasCachingOnceToken<Runtime>,
                               InvertibleProtocolSet,
-                              TargetSingletonMetadataPointer<Runtime>> {
+                              TargetSingletonMetadataPointer<Runtime>,
+                              TargetMethodDefaultOverrideTableHeader<Runtime>,
+                              TargetMethodDefaultOverrideDescriptor<Runtime>> {
 private:
-  using TrailingGenericContextObjects =
+  using TrailingGenericContextObjects = 
     swift::TrailingGenericContextObjects<TargetClassDescriptor<Runtime>,
                                          TargetTypeGenericContextDescriptorHeader,
                                          TargetResilientSuperclass<Runtime>,
@@ -4223,7 +4273,9 @@ class swift_ptrauth_struct_context_descriptor(ClassDescriptor)
                                          TargetCanonicalSpecializedMetadataAccessorsListEntry<Runtime>,
                                          TargetCanonicalSpecializedMetadatasCachingOnceToken<Runtime>,
                                          InvertibleProtocolSet,
-                                         TargetSingletonMetadataPointer<Runtime>>;
+                                         TargetSingletonMetadataPointer<Runtime>,
+                                         TargetMethodDefaultOverrideTableHeader<Runtime>,
+                                         TargetMethodDefaultOverrideDescriptor<Runtime>>;
 
   using TrailingObjects =
     typename TrailingGenericContextObjects::TrailingObjects;
@@ -4254,6 +4306,10 @@ class swift_ptrauth_struct_context_descriptor(ClassDescriptor)
   using MetadataCachingOnceToken =
       TargetCanonicalSpecializedMetadatasCachingOnceToken<Runtime>;
   using SingletonMetadataPointer = TargetSingletonMetadataPointer<Runtime>;
+  using DefaultOverrideTableHeader =
+      TargetMethodDefaultOverrideTableHeader<Runtime>;
+  using DefaultOverrideDescriptor =
+      TargetMethodDefaultOverrideDescriptor<Runtime>;
 
   using StoredPointer = typename Runtime::StoredPointer;
   using StoredPointerDifference = typename Runtime::StoredPointerDifference;
@@ -4399,6 +4455,16 @@ class swift_ptrauth_struct_context_descriptor(ClassDescriptor)
     return this->hasSingletonMetadataPointer() ? 1 : 0;
   }
 
+  size_t numTrailingObjects(OverloadToken<DefaultOverrideTableHeader>) const {
+    return hasDefaultOverrideTable() ? 1 : 0;
+  }
+
+  size_t numTrailingObjects(OverloadToken<DefaultOverrideDescriptor>) const {
+    if (!hasDefaultOverrideTable())
+      return 0;
+    return getDefaultOverrideTable()->NumEntries;
+  }
+
 public:
   const TargetRelativeDirectPointer<Runtime, const void, /*nullable*/true> &
   getResilientSuperclass() const {
@@ -4430,6 +4496,10 @@ class swift_ptrauth_struct_context_descriptor(ClassDescriptor)
     return FieldOffsetVectorOffset;
   }
 
+  bool hasDefaultOverrideTable() const {
+    return getTypeContextDescriptorFlags().class_hasDefaultOverrideTable();
+  }
+
   bool isActor() const {
     return this->getTypeContextDescriptorFlags().class_isActor();
   }
@@ -4476,6 +4546,20 @@ class swift_ptrauth_struct_context_descriptor(ClassDescriptor)
             numTrailingObjects(OverloadToken<MethodOverrideDescriptor>{})};
   }
 
+  const DefaultOverrideTableHeader *getDefaultOverrideTable() const {
+    if (!hasDefaultOverrideTable())
+      return nullptr;
+    return this->template getTrailingObjects<DefaultOverrideTableHeader>();
+  }
+
+  llvm::ArrayRef<DefaultOverrideDescriptor> getDefaultOverrideDescriptors()
+      const {
+    if (!hasDefaultOverrideTable())
+      return {};
+    return {this->template getTrailingObjects<DefaultOverrideDescriptor>(),
+            numTrailingObjects(OverloadToken<DefaultOverrideDescriptor>{})};
+  }
+
   /// Return the bounds of this class's metadata.
   TargetClassMetadataBounds<Runtime> getMetadataBounds() const {
     if (!hasResilientSuperclass())

stdlib/public/runtime/Metadata.cpp

@@ -3682,9 +3682,11 @@ static void installOverrideInVTable(ContextDescriptor const *baseContext,
 }
 
 /// Using the information in the class context descriptor, fill in in the
-/// immediate vtable entries for the class and install overrides of any
-/// superclass vtable entries.
-static void initClassVTable(ClassMetadata *self) {
+/// immediate vtable entries for the class install overrides of any
+/// superclass vtable entries, and install any default overrides if appropriate.
+static void initClassVTable(ClassMetadata *self,
+                            llvm::SmallVectorImpl<const ClassDescriptor *>
+                                &superclassesWithDefaultOverrides) {
   const auto *description = self->getDescription();
   auto *classWords = reinterpret_cast<void **>(self);
 
@@ -3706,14 +3708,46 @@ static void initClassVTable(ClassMetadata *self) {
     return;
   }
 
+  auto hasSuperclassWithDefaultOverride =
+      superclassesWithDefaultOverrides.size() > 0;
+  std::unordered_set<const MethodDescriptor *> seenDescriptors;
+
+  // Install our overrides.
   auto *overrideTable = description->getOverrideTable();
   auto overrideDescriptors = description->getMethodOverrideDescriptors();
   for (auto &descriptor : overrideDescriptors) {
+    if (hasSuperclassWithDefaultOverride)
+      seenDescriptors.insert(descriptor.Method);
+
     installOverrideInVTable(
         descriptor.Class.get(), descriptor.Method.get(),
         [&descriptor]() { return descriptor.getImpl(); }, overrideTable,
         classWords);
   }
+
+  if (!hasSuperclassWithDefaultOverride) {
+    // No ancestor had default overrides to consider, so we're done.
+    return;
+  }
+
+  // Install any necessary default overrides.
+  for (auto *description : superclassesWithDefaultOverrides) {
+    assert(description->hasDefaultOverrideTable());
+    auto *header = description->getDefaultOverrideTable();
+    assert(header->NumEntries > 0 && "default override table with 0 entries");
+    auto entries = description->getDefaultOverrideDescriptors();
+    for (auto &entry : entries) {
+      auto *original = entry.Original.get();
+      if (!seenDescriptors.count(original))
+        continue;
+      auto *replacement = entry.Replacement.get();
+      if (seenDescriptors.count(replacement))
+        continue;
+      installOverrideInVTable(
+          description, replacement, [&entry]() { return entry.getImpl(); },
+          header, classWords);
+    }
+  }
 }
 
 static void initClassFieldOffsetVector(ClassMetadata *self,
@@ -4059,6 +4093,7 @@ _swift_initClassMetadataImpl(ClassMetadata *self,
   auto superDependencyAndSuper = getSuperclassMetadata(self, allowDependency);
   if (superDependencyAndSuper.first)
     return superDependencyAndSuper.first;
+
   auto super = superDependencyAndSuper.second;
 
   self->Superclass = super;
@@ -4079,14 +4114,36 @@ _swift_initClassMetadataImpl(ClassMetadata *self,
       nullptr);
 #endif
 
+  // To populate the vtable, we must check our ancestors for default overloads.
+  // We may obstructed by dependencies, however, so do it now before doing any
+  // setup.
+  llvm::SmallVector<const ClassDescriptor *, 16>
+      superclassesWithDefaultOverrides;
+  if (self->getDescription()->hasOverrideTable()) {
+    const ClassMetadata *super = superDependencyAndSuper.second;
+    while (super && !super->isPureObjC()) {
+      const auto *description = super->getDescription();
+      if (description->hasDefaultOverrideTable()) {
+        // This superclass has default overrides.  Record it for later
+        // traversal.
+        superclassesWithDefaultOverrides.push_back(description);
+      }
+      auto superDependencyAndSuper =
+          getSuperclassMetadata(super, allowDependency);
+      if (superDependencyAndSuper.first)
+        return superDependencyAndSuper.first;
+      super = superDependencyAndSuper.second;
+    }
+  }
+
   // Copy field offsets, generic arguments and (if necessary) vtable entries
   // from our superclass.
   copySuperclassMetadataToSubclass(self, layoutFlags);
 
   // Copy the class's immediate methods from the nominal type descriptor
   // to the class metadata.
   if (!hasStaticVTable(layoutFlags))
-    initClassVTable(self);
+    initClassVTable(self, superclassesWithDefaultOverrides);
 
   initClassFieldOffsetVector(self, numFields, fieldTypes, fieldOffsets);