[ABI] Distinguish Swift/ObjC protocols in TargetGenericRequirement.

In a generic requirement, distinguish between Swift and
Objective-C protocols using a spare bit within the relative
(indirectable) reference to the protocol.

Author: DougGregor

include/swift/ABI/Metadata.h

@@ -2303,6 +2303,51 @@ using ProtocolRecord = TargetProtocolRecord<InProcess>;
 
 template<typename Runtime> class TargetGenericRequirementDescriptor;
 
+/// A relative pointer to a protocol descriptor, which provides the relative-
+/// pointer equivalent to \c TargetProtocolDescriptorRef.
+template <typename Runtime>
+class RelativeTargetProtocolDescriptorPointer {
+  union AnyProtocol {
+    TargetProtocolDescriptor<Runtime> descriptor;
+  };
+
+  /// The relative pointer itself.
+  ///
+  /// The \c AnyProtocol value type ensures that we can reference any
+  /// protocol descriptor; it will be reinterpret_cast to the appropriate
+  /// protocol descriptor type.
+  ///
+  /// The \c bool integer value will be false to indicate that the protocol
+  /// is a Swift protocol, or true to indicate that this references
+  /// an Objective-C protocol.
+  RelativeIndirectablePointerIntPair<AnyProtocol, bool> pointer;
+
+#if SWIFT_OBJC_INTEROP
+  bool isObjC() const {
+    return pointer.getInt();
+  }
+#endif
+
+public:
+  /// Retrieve a reference to the protocol.
+  TargetProtocolDescriptorRef<Runtime> getProtocol() const {
+#if SWIFT_OBJC_INTEROP
+    if (isObjC()) {
+      return TargetProtocolDescriptorRef<Runtime>::forObjC(
+          protocol_const_cast(pointer.getPointer()));
+    }
+#endif
+
+    return TargetProtocolDescriptorRef<Runtime>::forSwift(
+        reinterpret_cast<ConstTargetMetadataPointer<
+            Runtime, TargetProtocolDescriptor>>(pointer.getPointer()));
+  }
+
+  operator TargetProtocolDescriptorRef<Runtime>() const {
+    return getProtocol();
+  }
+};
+
 /// The structure of a protocol conformance.
 ///
 /// This contains enough static information to recover the witness table for a
@@ -2334,8 +2379,6 @@ struct TargetProtocolConformanceDescriptor final
 
 private:
   /// The protocol being conformed to.
-  ///
-  /// The remaining low bit is reserved for future use.
   RelativeIndirectablePointer<ProtocolDescriptor> Protocol;
 
   // Some description of the type that conforms to the protocol.
@@ -2704,8 +2747,7 @@ class TargetGenericRequirementDescriptor {
     /// The protocol the param is constrained to.
     ///
     /// Only valid if the requirement has Protocol kind.
-    RelativeIndirectablePointer<TargetProtocolDescriptor<Runtime>,
-                                /*nullable*/ false> Protocol;
+    RelativeTargetProtocolDescriptorPointer<Runtime> Protocol;
 
     /// The conformance the param is constrained to use.
     ///
@@ -2733,8 +2775,8 @@ class TargetGenericRequirementDescriptor {
     return Param;
   }
 
-  /// Retrieve the protocol descriptor for a Protocol requirement.
-  const TargetProtocolDescriptor<Runtime> *getProtocol() const {
+  /// Retrieve the protocol for a Protocol requirement.
+  TargetProtocolDescriptorRef<Runtime> getProtocol() const {
     assert(getKind() == GenericRequirementKind::Protocol);
     return Protocol;
   }

lib/IRGen/GenMeta.cpp

@@ -3853,7 +3853,15 @@ GenericRequirementsMetadata irgen::addGenericRequirements(
         IGM.getConstantReferenceForProtocolDescriptor(protocol);
       addGenericRequirement(IGM, B, metadata, sig, flags,
                             requirement.getFirstType(),
-        [&]{ B.addRelativeAddress(descriptorRef); });
+        [&]{
+          unsigned tag = unsigned(descriptorRef.isIndirect());
+          if (protocol->isObjC())
+            tag |= 0x02;
+          
+          B.addTaggedRelativeOffset(IGM.RelativeAddressTy,
+                                    descriptorRef.getValue(),
+                                    tag);
+        });
       break;
     }
 

stdlib/public/runtime/Casting.cpp

@@ -69,7 +69,7 @@ static const char *class_getName(const ClassMetadata* type) {
 extern "C" const void *swift_dynamicCastObjCProtocolConditional(
                          const void *object,
                          size_t numProtocols,
-                         const ProtocolDescriptor * const *protocols);
+                         Protocol * const *protocols);
 #endif
 
 // Build a user-comprehensible name for a type.
@@ -303,7 +303,7 @@ swift_dynamicCastClassUnconditionalImpl(const void *object,
 
 #if SWIFT_OBJC_INTEROP
 static bool _unknownClassConformsToObjCProtocol(const OpaqueValue *value,
-                                          const ProtocolDescriptor *protocol) {
+                                                Protocol *protocol) {
   const void *object
     = *reinterpret_cast<const void * const *>(value);
   return swift_dynamicCastObjCProtocolConditional(object, 1, &protocol);
@@ -312,11 +312,11 @@ static bool _unknownClassConformsToObjCProtocol(const OpaqueValue *value,
 
 bool swift::_conformsToProtocol(const OpaqueValue *value,
                                 const Metadata *type,
-                                const ProtocolDescriptor *protocol,
+                                ProtocolDescriptorRef protocol,
                                 const WitnessTable **conformance) {
   // Look up the witness table for protocols that need them.
-  if (protocol->Flags.needsWitnessTable()) {
-    auto witness = swift_conformsToProtocol(type, protocol);
+  if (protocol.needsWitnessTable()) {
+    auto witness = swift_conformsToProtocol(type, protocol.getSwiftProtocol());
     if (!witness)
       return false;
     if (conformance)
@@ -330,22 +330,22 @@ bool swift::_conformsToProtocol(const OpaqueValue *value,
   case MetadataKind::Class:
 #if SWIFT_OBJC_INTEROP
     if (value) {
-      return _unknownClassConformsToObjCProtocol(value, protocol);
+      return _unknownClassConformsToObjCProtocol(value,
+                                                 protocol.getObjCProtocol());
     } else {
-      return classConformsToObjCProtocol(type,
-          ProtocolDescriptorRef(protocol, ProtocolDispatchStrategy::ObjC));
+      return classConformsToObjCProtocol(type, protocol);
     }
 #endif
     return false;
 
   case MetadataKind::ObjCClassWrapper: {
 #if SWIFT_OBJC_INTEROP
     if (value) {
-      return _unknownClassConformsToObjCProtocol(value, protocol);
+      return _unknownClassConformsToObjCProtocol(value,
+                                                 protocol.getObjCProtocol());
     } else {
       auto wrapper = cast<ObjCClassWrapperMetadata>(type);
-      return classConformsToObjCProtocol(wrapper->Class,
-          ProtocolDescriptorRef(protocol, ProtocolDispatchStrategy::ObjC));
+      return classConformsToObjCProtocol(wrapper->Class, protocol);
     }
 #endif
     return false;
@@ -354,7 +354,8 @@ bool swift::_conformsToProtocol(const OpaqueValue *value,
   case MetadataKind::ForeignClass:
 #if SWIFT_OBJC_INTEROP
     if (value)
-      return _unknownClassConformsToObjCProtocol(value, protocol);
+      return _unknownClassConformsToObjCProtocol(value,
+                                                 protocol.getObjCProtocol());
     return false;
 #else
    return false;
@@ -387,9 +388,7 @@ static bool _conformsToProtocols(const OpaqueValue *value,
   }
 
   for (auto protocol : existentialType->getProtocols()) {
-    if (!_conformsToProtocol(value, type,
-                             protocol.getProtocolDescriptorUnchecked(),
-                             conformances))
+    if (!_conformsToProtocol(value, type, protocol, conformances))
       return false;
     if (protocol.needsWitnessTable()) {
       assert(*conformances != nullptr);

stdlib/public/runtime/Private.h

@@ -323,7 +323,7 @@ class TypeInfo {
   ///   table will be placed here
   bool _conformsToProtocol(const OpaqueValue *value,
                            const Metadata *type,
-                           const ProtocolDescriptor *protocol,
+                           ProtocolDescriptorRef protocol,
                            const WitnessTable **conformance);
 
   void _swift_getFieldAt(

stdlib/public/runtime/ProtocolConformance.cpp

@@ -711,7 +711,7 @@ bool swift::_checkGenericRequirements(
         return true;
 
       // If we need a witness table, add it.
-      if (req.getProtocol()->Flags.needsWitnessTable()) {
+      if (req.getProtocol().needsWitnessTable()) {
         assert(witnessTable);
         extraArguments.push_back(witnessTable);
       }

test/IRGen/generic_requirement_objc.sil

@@ -0,0 +1,12 @@
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil %s -emit-ir | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Builtin
+
+@objc protocol ObjCProto { }
+
+// CHECK: @"$S24generic_requirement_objc13GenericStructVMn" = 
+// CHECK-SAME: i32 add {{.*}} ptrtoint (i8** @"\01l_OBJC_PROTOCOL_REFERENCE_$__TtP24generic_requirement_objc9ObjCProto_" {{.*}} @"$S24generic_requirement_objc13GenericStructVMn", {{.*}} i32 3)
+
+struct GenericStruct<T: ObjCProto> { }