---

yaml
---
r: 349343
b: refs/heads/master-next
c: 010a765
h: refs/heads/master
i:
  349341: dfb3419
  349339: b543c47
  349335: d8acde1
  349327: c4c73f6
  349311: a906671

Author: swift-ci

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 7be53c233d87541da11cd037eb74d847267e52a9
+refs/heads/master-next: 010a765a49b9c611dc141909d3df2b86da47f992
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/stdlib/public/runtime/MetadataLookup.cpp

@@ -28,6 +28,7 @@
 #include "swift/Runtime/Mutex.h"
 #include "swift/Strings.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
@@ -195,9 +196,20 @@ namespace {
   };
 } // end anonymous namespace
 
+inline llvm::hash_code llvm::hash_value(StringRef S) {
+  return hash_combine_range(S.begin(), S.end());
+}
+
 struct TypeMetadataPrivateState {
   ConcurrentMap<NominalTypeDescriptorCacheEntry> NominalCache;
   ConcurrentReadableArray<TypeMetadataSection> SectionsToScan;
+  
+  llvm::DenseMap<llvm::StringRef,
+                 llvm::SmallDenseSet<const ContextDescriptor *, 1>>
+    ContextDescriptorCache;
+  size_t ConformanceDescriptorLastSectionScanned = 0;
+  size_t TypeContextDescriptorLastSectionScanned = 0;
+  Mutex ContextDescriptorCacheLock;
 
   TypeMetadataPrivateState() {
     initializeTypeMetadataRecordLookup();
@@ -214,6 +226,29 @@ _registerTypeMetadataRecords(TypeMetadataPrivateState &T,
   T.SectionsToScan.push_back(TypeMetadataSection{begin, end});
 }
 
+/// Iterate over type metadata sections starting from the given index.
+/// The index is updated to the current number of sections. Passing
+/// the same index to the next call will iterate over any sections that were
+/// added after the previous call.
+///
+/// Takes a function to call for each section found. The two parameters are
+/// the start and end of the section.
+static void _forEachTypeMetadataSectionAfter(
+  TypeMetadataPrivateState &T,
+  size_t *start,
+  const std::function<void(const TypeMetadataRecord *,
+                           const TypeMetadataRecord *)> &f) {
+  auto snapshot = T.SectionsToScan.snapshot();
+  if (snapshot.Count > *start) {
+    auto *begin = snapshot.begin() + *start;
+    auto *end = snapshot.end();
+    for (auto *section = begin; section != end; section++) {
+      f(section->Begin, section->End);
+    }
+    *start = snapshot.Count;
+  }
+}
+
 void swift::addImageTypeMetadataRecordBlockCallback(const void *records,
                                                     uintptr_t recordsSize) {
   assert(recordsSize % sizeof(TypeMetadataRecord) == 0
@@ -603,6 +638,70 @@ _searchTypeMetadataRecords(TypeMetadataPrivateState &T,
   return nullptr;
 }
 
+// Read ContextDescriptors for any loaded images that haven't already been
+// scanned, if any.
+static void
+_scanAdditionalContextDescriptors(TypeMetadataPrivateState &T) {
+  _forEachTypeMetadataSectionAfter(
+    T,
+    &T.TypeContextDescriptorLastSectionScanned,
+    [&T](const TypeMetadataRecord *Begin,
+         const TypeMetadataRecord *End) {
+      for (const auto *record = Begin; record != End; record++) {
+        if (auto ntd = record->getContextDescriptor()) {
+          if (auto type = llvm::dyn_cast<TypeContextDescriptor>(ntd)) {
+            auto identity = ParsedTypeIdentity::parse(type);
+            auto name = identity.getABIName();
+            T.ContextDescriptorCache[name].insert(type);
+          }
+        }
+      }
+    });
+
+  _forEachProtocolConformanceSectionAfter(
+    &T.ConformanceDescriptorLastSectionScanned,
+    [&T](const ProtocolConformanceRecord *Begin,
+       const ProtocolConformanceRecord *End) {
+    for (const auto *record = Begin; record != End; record++) {
+      if (auto ntd = record[0]->getTypeDescriptor()) {
+        if (auto type = llvm::dyn_cast<TypeContextDescriptor>(ntd)) {
+          auto identity = ParsedTypeIdentity::parse(type);
+          auto name = identity.getABIName();
+          T.ContextDescriptorCache[name].insert(type);
+        }
+      }
+    }
+  });
+}
+
+// Search for a ContextDescriptor in the context descriptor cache matching the
+// given demangle node. Returns the found node, or nullptr if no match was
+// found.
+static llvm::SmallDenseSet<const ContextDescriptor *, 1>
+_findContextDescriptorInCache(TypeMetadataPrivateState &T,
+                              Demangle::NodePointer node) {
+  if (node->getNumChildren() < 2)
+    return { };
+
+  auto nameNode = node->getChild(1);
+
+  // Declarations synthesized by the Clang importer get a small tag
+  // string in addition to their name.
+  if (nameNode->getKind() == Demangle::Node::Kind::RelatedEntityDeclName)
+    nameNode = nameNode->getChild(1);
+
+  if (nameNode->getKind() != Demangle::Node::Kind::Identifier)
+    return { };
+
+  auto name = nameNode->getText();
+  
+  auto iter = T.ContextDescriptorCache.find(name);
+  if (iter == T.ContextDescriptorCache.end())
+    return { };
+
+  return iter->getSecond();
+}
+
 static const ContextDescriptor *
 _findContextDescriptor(Demangle::NodePointer node,
                            Demangle::Demangler &Dem) {
@@ -630,16 +729,49 @@ _findContextDescriptor(Demangle::NodePointer node,
   if (auto Value = T.NominalCache.find(mangledName))
     return Value->getDescription();
 
-  // Check type metadata records
-  foundContext = _searchTypeMetadataRecords(T, node);
+  // Scan any newly loaded images for context descriptors, then try the context
+  // descriptor cache. This must be done with the cache's lock held.
+  llvm::SmallDenseSet<const ContextDescriptor *, 1> cachedContexts;
+  {
+    ScopedLock guard(T.ContextDescriptorCacheLock);
+    _scanAdditionalContextDescriptors(T);
+    cachedContexts = _findContextDescriptorInCache(T, node);
+  }
 
-  // Check protocol conformances table. Note that this has no support for
-  // resolving generic types yet.
-  if (!foundContext)
-    foundContext = _searchConformancesByMangledTypeName(node);
+  bool foundInCache = false;
+  for (auto cachedContext : cachedContexts) {
+    if (_contextDescriptorMatchesMangling(cachedContext, node)) {
+      foundContext = cachedContext;
+      foundInCache = true;
+      break;
+    }
+  }
+
+  if (!foundContext) {
+    // Slow path, as a fallback if the cache itself isn't capturing everything.
+    (void)foundInCache;
+
+    // Check type metadata records
+    foundContext = _searchTypeMetadataRecords(T, node);
+
+    // Check protocol conformances table. Note that this has no support for
+    // resolving generic types yet.
+    if (!foundContext)
+      foundContext = _searchConformancesByMangledTypeName(node);
+  }
 
   if (foundContext) {
     T.NominalCache.getOrInsert(mangledName, foundContext);
+
+#ifndef NDEBUG
+    // If we found something in the slow path but not in the cache, it is a
+    // bug in the cache. Fail in assertions builds.
+    if (!foundInCache) {
+      fatalError(0,
+                 "_findContextDescriptor cache miss for demangled tree:\n%s\n",
+                 getNodeTreeAsString(node).c_str());
+    }
+#endif
   }
 
   return foundContext;

branches/master-next/stdlib/public/runtime/Private.h

@@ -249,6 +249,19 @@ class TypeInfo {
   const ContextDescriptor *
   _searchConformancesByMangledTypeName(Demangle::NodePointer node);
 
+  /// Iterate over protocol conformance sections starting from the given index.
+  /// The index is updated to the current number of protocol sections. Passing
+  /// the same index to the next call will iterate over any sections that were
+  /// added after the previous call.
+  ///
+  /// Takes a function to call for each section found. The two parameters are
+  /// the start and end of the section.
+  void
+  _forEachProtocolConformanceSectionAfter(
+    size_t *start, 
+    const std::function<void(const ProtocolConformanceRecord *,
+                             const ProtocolConformanceRecord *)> &f);
+
   Demangle::NodePointer _swift_buildDemanglingForMetadata(const Metadata *type,
                                                       Demangle::Demangler &Dem);
 

branches/master-next/stdlib/public/runtime/ProtocolConformance.cpp

@@ -634,6 +634,22 @@ swift::_searchConformancesByMangledTypeName(Demangle::NodePointer node) {
   return nullptr;
 }
 
+void
+swift::_forEachProtocolConformanceSectionAfter(
+  size_t *start, 
+  const std::function<void(const ProtocolConformanceRecord *,
+                           const ProtocolConformanceRecord *)> &f) {
+  auto snapshot = Conformances.get().SectionsToScan.snapshot();
+  if (snapshot.Count > *start) {
+    auto *begin = snapshot.begin() + *start;
+    auto *end = snapshot.end();
+    for (auto *section = begin; section != end; section++) {
+      f(section->Begin, section->End);
+    }
+    *start = snapshot.Count;
+  }
+}
+
 bool swift::_checkGenericRequirements(
                       llvm::ArrayRef<GenericRequirementDescriptor> requirements,
                       SmallVectorImpl<const void *> &extraArguments,