[Runtime] Don't use the low bit of a WitnessTable pointer in the conformance cache

stdlib/public/runtime/ProtocolConformance.cpp

@@ -537,47 +537,80 @@ namespace {
 
   struct ConformanceCacheEntry {
   private:
-    ConformanceCacheKey Key;
+    /// Storage used when we have global actor isolation on the conformance.
+    struct ExtendedStorage {
+      /// The protocol to which the type conforms.
+      const ProtocolDescriptor *Proto;
+
+      /// The global actor to which this conformance is isolated, or NULL for
+      /// a nonisolated conformances.
+      const Metadata *globalActorIsolationType = nullptr;
+
+      /// When the conformance is global-actor-isolated, this is the conformance
+      /// of globalActorIsolationType to GlobalActor.
+      const WitnessTable *globalActorIsolationWitnessTable = nullptr;
+    };
+
+    const Metadata *Type;
+    llvm::PointerUnion<const ProtocolDescriptor *, const ExtendedStorage *>
+        ProtoOrStorage;
 
-    /// The witness table or along with a bit that indicates whether the
-    /// conformance is isolated to a global actor.
-    llvm::PointerUnion<const WitnessTable *, const ConformanceLookupResult *>
-        WitnessTableOrLookupResult;
+    /// The witness table.
+    const WitnessTable *Witness;
 
   public:
     ConformanceCacheEntry(ConformanceCacheKey key,
                           ConformanceLookupResult result)
-        : Key(key) {
+      : Type(key.Type), Witness(result.witnessTable)
+    {
       if (result.globalActorIsolationType) {
-        WitnessTableOrLookupResult = new ConformanceLookupResult(result);
+        ProtoOrStorage = new ExtendedStorage{
+          key.Proto, result.globalActorIsolationType,
+          result.globalActorIsolationWitnessTable
+        };
       } else {
-        WitnessTableOrLookupResult = result.witnessTable;
+        ProtoOrStorage = key.Proto;
       }
     }
 
     bool matchesKey(const ConformanceCacheKey &key) const {
-      return Key.Type == key.Type && Key.Proto == key.Proto;
+      return Type == key.Type && getProtocol() == key.Proto;
     }
 
     friend llvm::hash_code hash_value(const ConformanceCacheEntry &entry) {
-      return hash_value(entry.Key);
+      return hash_value(entry.getKey());
+    }
+
+    /// Get the protocol.
+    const ProtocolDescriptor *getProtocol() const {
+      if (auto proto = ProtoOrStorage.dyn_cast<const ProtocolDescriptor *>())
+        return proto;
+
+      if (auto storage = ProtoOrStorage.dyn_cast<const ExtendedStorage *>())
+        return storage->Proto;
+
+      return nullptr;
+    }
+
+    /// Get the conformance cache key.
+    ConformanceCacheKey getKey() const {
+      return ConformanceCacheKey(Type, getProtocol());
     }
 
     /// Get the cached witness table, or null if we cached failure.
     const WitnessTable *getWitnessTable() const {
-      if (auto witnessTable = WitnessTableOrLookupResult.dyn_cast<const WitnessTable *>())
-        return witnessTable;
-
-      return WitnessTableOrLookupResult.get<const ConformanceLookupResult *>()
-          ->witnessTable;
+      return Witness;
     }
 
     ConformanceLookupResult getResult() const {
-      if (auto witnessTable = WitnessTableOrLookupResult.dyn_cast<const WitnessTable *>())
-        return ConformanceLookupResult { witnessTable, nullptr, nullptr };
+      if (ProtoOrStorage.is<const ProtocolDescriptor *>())
+        return ConformanceLookupResult { Witness, nullptr, nullptr };
 
-      if (auto lookupResult = WitnessTableOrLookupResult.dyn_cast<const ConformanceLookupResult *>())
-        return *lookupResult;
+      if (auto storage = ProtoOrStorage.dyn_cast<const ExtendedStorage *>()) {
+        return ConformanceLookupResult(
+            Witness, storage->globalActorIsolationType,
+            storage->globalActorIsolationWitnessTable);
+      }
 
       return nullptr;
     }