[Runtime] Cache protocol conformance descriptors, not witness tables.

The conformance cache was caching the witness table for a conformance
`T: P`, where `T` is a concrete type and `P` is a protocol. However, it
essentially picked one of potentially many witness tables for that
conformance, because retroactive conformances might produce different results
from different modules.

Make the conformance cache what is says it is: a cache of the conformance
descriptor for a given `T: P`, potentially filtered by a module (when
requested). Clients of the conformance cache can choose how to interpret
the protocol conformance descriptor, e.g., by instantiating a witness table.

We can bring back a specific conformance cache for swift_conformsToProtocol()
if it is profitable.

(cherry picked from commit 0af2af00a739a4d912d2a9c3b196449e4164484f)

Author: DougGregor

stdlib/public/runtime/Private.h

@@ -507,6 +507,12 @@ class TypeInfo {
                              const Metadata *type,
                              const ProtocolConformanceDescriptor *conformance);
 
+  /// Determine whether the given type conforms to the given Swift protocol,
+  /// returning the appropriate protocol conformance descriptor when it does.
+  const ProtocolConformanceDescriptor *
+  _conformsToSwiftProtocol(const Metadata * const type,
+                           const ProtocolDescriptor *protocol);
+
   /// Retrieve an associated type witness from the given witness table.
   ///
   /// \param wtable The witness table.

stdlib/public/runtime/ProtocolConformance.cpp

@@ -200,14 +200,14 @@ namespace {
   private:
     const void *Type; 
     const ProtocolDescriptor *Proto;
-    std::atomic<const WitnessTable *> Table;
+    std::atomic<const ProtocolConformanceDescriptor *> Description;
     std::atomic<size_t> FailureGeneration;
 
   public:
     ConformanceCacheEntry(ConformanceCacheKey key,
-                          const WitnessTable *table,
+                          const ProtocolConformanceDescriptor *description,
                           size_t failureGeneration)
-      : Type(key.Type), Proto(key.Proto), Table(table),
+      : Type(key.Type), Proto(key.Proto), Description(description),
         FailureGeneration(failureGeneration) {
     }
 
@@ -227,22 +227,22 @@ namespace {
     }
 
     bool isSuccessful() const {
-      return Table.load(std::memory_order_relaxed) != nullptr;
+      return Description.load(std::memory_order_relaxed) != nullptr;
     }
 
-    void makeSuccessful(const WitnessTable *table) {
-      Table.store(table, std::memory_order_release);
+    void makeSuccessful(const ProtocolConformanceDescriptor *description) {
+      Description.store(description, std::memory_order_release);
     }
 
     void updateFailureGeneration(size_t failureGeneration) {
       assert(!isSuccessful());
       FailureGeneration.store(failureGeneration, std::memory_order_relaxed);
     }
-    
-    /// Get the cached witness table, if successful.
-    const WitnessTable *getWitnessTable() const {
+
+    /// Get the cached conformance descriptor, if successful.
+    const ProtocolConformanceDescriptor *getDescription() const {
       assert(isSuccessful());
-      return Table.load(std::memory_order_acquire);
+      return Description.load(std::memory_order_acquire);
     }
 
     /// Get the generation in which this lookup failed.
@@ -263,21 +263,22 @@ struct ConformanceState {
   }
 
   void cacheSuccess(const void *type, const ProtocolDescriptor *proto,
-                    const WitnessTable *witness) {
+                    const ProtocolConformanceDescriptor *description) {
     auto result = Cache.getOrInsert(ConformanceCacheKey(type, proto),
-                                    witness, 0);
+                                    description, 0);
 
     // If the entry was already present, we may need to update it.
     if (!result.second) {
-      result.first->makeSuccessful(witness);
+      result.first->makeSuccessful(description);
     }
   }
 
   void cacheFailure(const void *type, const ProtocolDescriptor *proto,
                     size_t failureGeneration) {
-    auto result = Cache.getOrInsert(ConformanceCacheKey(type, proto),
-                                    (const WitnessTable *) nullptr,
-                                    failureGeneration);
+    auto result =
+      Cache.getOrInsert(ConformanceCacheKey(type, proto),
+                        (const ProtocolConformanceDescriptor *) nullptr,
+                        failureGeneration);
 
     // If the entry was already present, we may need to update it.
     if (!result.second) {
@@ -344,21 +345,22 @@ swift::swift_registerProtocolConformances(const ProtocolConformanceRecord *begin
 
 
 struct ConformanceCacheResult {
-  // true if witnessTable is an authoritative result as-is.
+  // true if description is an authoritative result as-is.
   // false if more searching is required (for example, because a cached
   // failure was returned in failureEntry but it is out-of-date.
   bool isAuthoritative;
 
-  // The matching witness table, or null if no cached conformance was found.
-  const WitnessTable *witnessTable;
+  // The matching conformance descriptor, or null if no cached conformance
+  // was found.
+  const ProtocolConformanceDescriptor *description;
 
   // If the search fails, this may be the negative cache entry for the
   // queried type itself. This entry may be null or out-of-date.
   ConformanceCacheEntry *failureEntry;
 
   static ConformanceCacheResult
-  cachedSuccess(const WitnessTable *table) {
-    return ConformanceCacheResult { true, table, nullptr };
+  cachedSuccess(const ProtocolConformanceDescriptor *description) {
+    return ConformanceCacheResult { true, description, nullptr };
   }
 
   static ConformanceCacheResult
@@ -381,7 +383,7 @@ static const void *getConformanceCacheTypeKey(const Metadata *type) {
   return type;
 }
 
-/// Search for a witness table in the ConformanceCache.
+/// Search for a conformance descriptor in the ConformanceCache.
 static
 ConformanceCacheResult
 searchInConformanceCache(const Metadata *type,
@@ -396,7 +398,7 @@ searchInConformanceCache(const Metadata *type,
     if (auto *Value = C.findCached(type, protocol)) {
       if (Value->isSuccessful()) {
         // Found a conformance on the type or some superclass. Return it.
-        return ConformanceCacheResult::cachedSuccess(Value->getWitnessTable());
+        return ConformanceCacheResult::cachedSuccess(Value->getDescription());
       }
 
       // Found a negative cache entry.
@@ -438,7 +440,7 @@ searchInConformanceCache(const Metadata *type,
     // Hash and lookup the type-protocol pair in the cache.
     if (auto *Value = C.findCached(typeKey, protocol)) {
       if (Value->isSuccessful())
-        return ConformanceCacheResult::cachedSuccess(Value->getWitnessTable());
+        return ConformanceCacheResult::cachedSuccess(Value->getDescription());
 
       // We don't try to cache negative responses for generic
       // patterns.
@@ -530,17 +532,17 @@ namespace {
   };
 }
 
-static const WitnessTable *
-swift_conformsToProtocolImpl(const Metadata * const type,
-                             const ProtocolDescriptor *protocol) {
+const ProtocolConformanceDescriptor *
+swift::_conformsToSwiftProtocol(const Metadata * const type,
+                                const ProtocolDescriptor *protocol) {
   auto &C = Conformances.get();
 
   // See if we have a cached conformance. The ConcurrentMap data structure
   // allows us to insert and search the map concurrently without locking.
   auto FoundConformance = searchInConformanceCache(type, protocol);
   // If the result (positive or negative) is authoritative, return it.
   if (FoundConformance.isAuthoritative)
-    return FoundConformance.witnessTable;
+    return FoundConformance.description;
 
   auto failureEntry = FoundConformance.failureEntry;
 
@@ -560,16 +562,6 @@ swift_conformsToProtocolImpl(const Metadata * const type,
     return nullptr;
   }
 
-  /// Local function to retrieve the witness table and record the result.
-  auto recordWitnessTable = [&](const ProtocolConformanceDescriptor &descriptor,
-                                const Metadata *type) {
-    auto witnessTable = descriptor.getWitnessTable(type);
-    if (witnessTable)
-      C.cacheSuccess(type, protocol, witnessTable);
-    else
-      C.cacheFailure(type, protocol, snapshot.count());
-  };
-
   // Really scan conformance records.
   for (size_t i = startIndex; i < endIndex; i++) {
     auto &section = snapshot.Start[i];
@@ -588,23 +580,33 @@ swift_conformsToProtocolImpl(const Metadata * const type,
         if (!matchingType)
           matchingType = type;
 
-        recordWitnessTable(descriptor, matchingType);
+        C.cacheSuccess(matchingType, protocol, &descriptor);
       }
     }
   }
 
   // Conformance scan is complete.
-  // Search the cache once more, and this time update the cache if necessary.
 
+  // Search the cache once more, and this time update the cache if necessary.
   FoundConformance = searchInConformanceCache(type, protocol);
   if (FoundConformance.isAuthoritative) {
-    return FoundConformance.witnessTable;
+    return FoundConformance.description;
   } else {
     C.cacheFailure(type, protocol, snapshot.count());
     return nullptr;
   }
 }
 
+static const WitnessTable *
+swift_conformsToProtocolImpl(const Metadata * const type,
+                             const ProtocolDescriptor *protocol) {
+  auto description = _conformsToSwiftProtocol(type, protocol);
+  if (!description)
+    return nullptr;
+
+  return description->getWitnessTable(type);
+}
+
 const ContextDescriptor *
 swift::_searchConformancesByMangledTypeName(Demangle::NodePointer node) {
   auto &C = Conformances.get();