[Runtime] Fix protocol conformances on NULL types when back deploying.

Add code to the 5.0 compatibility library that scans for conformances pointing to a NULL type and rewrites them to point to a dummy type that the 5.0 protocol conformance checking code will safely ignore.

Author: mikeash

include/swift/ABI/Metadata.h

@@ -2333,6 +2333,12 @@ struct TargetProtocolConformanceDescriptor final
     return TypeRef.getTypeDescriptor(getTypeKind());
   }
 
+  const TargetContextDescriptor<Runtime> **_getTypeDescriptorLocation() const {
+    if (getTypeKind() != TypeReferenceKind::IndirectTypeDescriptor)
+      return nullptr;
+    return TypeRef.IndirectTypeDescriptor.get();
+  }
+
   /// Retrieve the context of a retroactive conformance.
   const TargetContextDescriptor<Runtime> *getRetroactiveContext() const {
     if (!Flags.isRetroactive()) return nullptr;

stdlib/toolchain/Compatibility50/ProtocolConformance.cpp

@@ -20,10 +20,22 @@
 #include "Overrides.h"
 #include "../../public/runtime/Private.h"
 #include "swift/Basic/Lazy.h"
+#include <mach-o/dyld.h>
+#include <mach-o/getsect.h>
 #include <objc/runtime.h>
 
 using namespace swift;
 
+#if __POINTER_WIDTH__ == 64
+using mach_header_platform = mach_header_64;
+#else
+using mach_header_platform = mach_header;
+#endif
+
+/// The Mach-O section name for the section containing protocol conformances.
+/// This lives within SEG_TEXT.
+constexpr const char ProtocolConformancesSection[] = "__swift5_proto";
+
 // Clone of private function getRootSuperclass. This returns the SwiftObject
 // class in the ABI-stable dylib, regardless of what the local runtime build
 // does, since we're always patching an ABI-stable dylib.
@@ -33,6 +45,50 @@ const ClassMetadata *swift::getRootSuperclass() {
   return (const ClassMetadata *)theClass;
 }
 
+// A dummy target context descriptor to use in conformance records which point
+// to a NULL descriptor. It doesn't have to be completely valid, just something
+// that code reading conformance descriptors will ignore.
+struct {
+  ContextDescriptorFlags flags;
+  int32_t offset;
+} DummyTargetContextDescriptor = {
+  ContextDescriptorFlags().withKind(ContextDescriptorKind::Extension),
+  0
+};
+
+// Search for any protocol conformance descriptors with a NULL type descriptor
+// and rewrite those to point to the dummy descriptor. This occurs when an
+// extension is used to declare a conformance on a weakly linked type and that
+// type is not present at runtime.
+static void addImageCallback(const mach_header *mh, intptr_t vmaddr_slide) {
+  unsigned long size;
+  const uint8_t *section =
+    getsectiondata(reinterpret_cast<const mach_header_platform *>(mh),
+                   SEG_TEXT, ProtocolConformancesSection,
+                   &size);
+  if (!section)
+    return;
+
+  auto recordsBegin
+    = reinterpret_cast<const ProtocolConformanceRecord*>(section);
+  auto recordsEnd
+    = reinterpret_cast<const ProtocolConformanceRecord*>
+                                          (section + size);
+  for (auto record = recordsBegin; record != recordsEnd; record++) {
+    auto descriptor = record->get();
+    if (auto typePtr = descriptor->_getTypeDescriptorLocation()) {
+      if (*typePtr == nullptr)
+        *typePtr = reinterpret_cast<TargetContextDescriptor<InProcess> *>(
+          &DummyTargetContextDescriptor);
+    }
+  }
+}
+
+// Register the add image callback with dyld.
+static void registerAddImageCallback(void *) {
+  _dyld_register_func_for_add_image(addImageCallback);
+}
+
 // Clone of private helper swift::_swiftoverride_class_getSuperclass
 // for use in the override implementation.
 static const Metadata *_swift50override_class_getSuperclass(
@@ -56,6 +112,10 @@ swift::swift50override_conformsToProtocol(const Metadata *type,
   const ProtocolDescriptor *protocol,
   ConformsToProtocol_t *original_conformsToProtocol)
 {
+  // Register our add image callback if necessary.
+  static OnceToken_t token;
+  SWIFT_ONCE_F(token, registerAddImageCallback, nullptr);
+
   // The implementation of swift_conformsToProtocol in Swift 5.0 would return
   // a false negative answer when asking whether a subclass conforms using
   // a conformance from a superclass. Work around this by walking up the