Merge branch 'release/6.0' into eng/PR-125989715-6.0

Author: al45tair

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -29,9 +29,6 @@ private func log(prefix: Bool = true, _ message: @autoclosure () -> String) {
 let lifetimeDependenceDiagnosticsPass = FunctionPass(
   name: "lifetime-dependence-diagnostics")
 { (function: Function, context: FunctionPassContext) in
-  if !context.options.hasFeature(.NonescapableTypes) {
-    return
-  }
   log(prefix: false, "\n--- Diagnosing lifetime dependence in \(function.name)")
   log("\(function)")
 
@@ -45,7 +42,7 @@ let lifetimeDependenceDiagnosticsPass = FunctionPass(
     }
   }
   for instruction in function.instructions {
-    if let markDep = instruction as? MarkDependenceInst {
+    if let markDep = instruction as? MarkDependenceInst, markDep.isUnresolved {
       if let lifetimeDep = LifetimeDependence(markDep, context) {
         analyze(dependence: lifetimeDep, context)
       }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceInsertion.swift

@@ -31,9 +31,6 @@ private func log(prefix: Bool = true, _ message: @autoclosure () -> String) {
 let lifetimeDependenceInsertionPass = FunctionPass(
   name: "lifetime-dependence-insertion")
 { (function: Function, context: FunctionPassContext) in
-  if !context.options.hasFeature(.NonescapableTypes) {
-    return
-  }
   log(prefix: false, "\n--- Inserting lifetime dependence markers in \(function.name)")
 
   for instruction in function.instructions {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -31,9 +31,6 @@ private func log(prefix: Bool = true, _ message: @autoclosure () -> String) {
 let lifetimeDependenceScopeFixupPass = FunctionPass(
   name: "lifetime-dependence-scope-fixup")
 { (function: Function, context: FunctionPassContext) in
-  if !context.options.hasFeature(.NonescapableTypes) {
-    return
-  }
   log(prefix: false, "\n--- Scope fixup for lifetime dependence in \(function.name)")
 
   let localReachabilityCache = LocalVariableReachabilityCache()

include/swift/AST/DiagnosticsIRGen.def

@@ -65,5 +65,9 @@ ERROR(temporary_allocation_alignment_not_power_of_2,none,
 ERROR(explosion_size_oveflow,none,
       "explosion size too large", ())
 
+NOTE(layout_strings_blocked,none,
+     "Layout string value witnesses have been disabled for module '%0' "
+     "through block list entry", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/Basic/BlockListAction.def

@@ -22,5 +22,6 @@
 BLOCKLIST_ACTION(ShouldUseBinaryModule)
 BLOCKLIST_ACTION(ShouldUseTextualModule)
 BLOCKLIST_ACTION(DowngradeInterfaceVerificationFailure)
+BLOCKLIST_ACTION(ShouldUseLayoutStringValueWitnesses)
 
 #undef BLOCKLIST_ACTION

include/swift/Runtime/LibPrespecialized.h

@@ -48,6 +48,7 @@ struct LibPrespecializedData {
 const LibPrespecializedData<InProcess> *getLibPrespecializedData();
 Metadata *getLibPrespecializedMetadata(const TypeContextDescriptor *description,
                                        const void *const *arguments);
+void libPrespecializedImageLoaded();
 
 } // namespace swift
 

lib/AST/ASTContext.cpp

@@ -5867,18 +5867,6 @@ ASTContext::getOpenedExistentialSignature(Type type, GenericSignature parentSig)
   assert(parentSig || !constraint->hasTypeParameter() &&
          "Interface type here requires a parent signature");
 
-  // The opened archetype signature for a protocol type is identical
-  // to the protocol's own canonical generic signature if there aren't any
-  // outer generic parameters to worry about.
-  if (parentSig.isNull()) {
-    if (const auto protoTy = dyn_cast<ProtocolType>(constraint)) {
-      return protoTy->getDecl()->getGenericSignature().getCanonicalSignature();
-    }
-  }
-
-  // Otherwise we need to build a generic signature that captures any outer
-  // generic parameters. This ensures that we keep e.g. generic superclass
-  // existentials contained in a well-formed generic context.
   auto canParentSig = parentSig.getCanonicalSignature();
   auto key = std::make_pair(constraint, canParentSig.getPointer());
   auto found = getImpl().ExistentialSignatures.find(key);

lib/Demangling/OldRemangler.cpp

@@ -242,7 +242,7 @@ bool Remangler::trySubstitution(Node *node, SubstitutionEntry &entry) {
     return true;
 
   // Go ahead and initialize the substitution entry.
-  entry.setNode(node, /*treatAsIdentifier=*/ false);
+  entry = entryForNode(node);
 
   int Idx = findSubstitution(entry);
   if (Idx < 0)

lib/Demangling/Remangler.cpp

@@ -59,47 +59,115 @@ bool SubstitutionEntry::identifierEquals(Node *lhs, Node *rhs) {
   return true;
 }
 
-void SubstitutionEntry::deepHash(Node *node) {
+bool SubstitutionEntry::deepEquals(Node *lhs, Node *rhs) const {
+  if (!lhs->isSimilarTo(rhs))
+    return false;
+
+  for (auto li = lhs->begin(), ri = rhs->begin(), le = lhs->end();
+       li != le; ++li, ++ri) {
+    if (!deepEquals(*li, *ri))
+      return false;
+  }
+
+  return true;
+}
+
+static inline size_t combineHash(size_t currentHash, size_t newValue) {
+  return 33 * currentHash + newValue;
+}
+
+/// Calculate the hash for a node.
+size_t RemanglerBase::hashForNode(Node *node,
+                                  bool treatAsIdentifier) {
+  size_t hash = 0;
+
   if (treatAsIdentifier) {
-    combineHash((size_t) Node::Kind::Identifier);
+    hash = combineHash(hash, (size_t)Node::Kind::Identifier);
     assert(node->hasText());
     switch (node->getKind()) {
     case Node::Kind::InfixOperator:
     case Node::Kind::PrefixOperator:
     case Node::Kind::PostfixOperator:
       for (char c : node->getText()) {
-        combineHash((unsigned char)translateOperatorChar(c));
+        hash = combineHash(hash, (unsigned char)translateOperatorChar(c));
       }
-      return;
+      return hash;
     default:
       break;
     }
   } else {
-    combineHash((size_t) node->getKind());
+    hash = combineHash(hash, (size_t) node->getKind());
   }
   if (node->hasIndex()) {
-    combineHash(node->getIndex());
+    hash = combineHash(hash, node->getIndex());
   } else if (node->hasText()) {
     for (char c : node->getText()) {
-      combineHash((unsigned char) c);
+      hash = combineHash(hash, (unsigned char) c);
     }
   }
   for (Node *child : *node) {
-    deepHash(child);
+    SubstitutionEntry entry = entryForNode(child, treatAsIdentifier);
+    hash = combineHash(hash, entry.hash());
   }
+
+  return hash;
 }
 
-bool SubstitutionEntry::deepEquals(Node *lhs, Node *rhs) const {
-  if (!lhs->isSimilarTo(rhs))
-    return false;
+/// Rotate a size_t by N bits
+static inline size_t rotate(size_t value, size_t shift) {
+  const size_t bits = sizeof(size_t) * 8;
+  return (value >> shift) | (value << (bits - shift));
+}
 
-  for (auto li = lhs->begin(), ri = rhs->begin(), le = lhs->end();
-       li != le; ++li, ++ri) {
-    if (!deepEquals(*li, *ri))
-      return false;
+/// Compute a hash value from a node *pointer*.
+/// Used for look-ups in HashHash.  The numbers in here were determined
+/// experimentally.
+static inline size_t nodeHash(Node *node) {
+  // Multiply by a magic number
+  const size_t nodePrime = ((size_t)node) * 2043;
+
+  // We rotate by a different amount because the alignment of Node
+  // changes depending on the machine's pointer size
+  switch (sizeof(size_t)) {
+  case 4:
+    return rotate(nodePrime, 11);
+  case 8:
+    return rotate(nodePrime, 12);
+  case 16:
+    return rotate(nodePrime, 13);
+  default:
+    return rotate(nodePrime, 12);
   }
-  
-  return true;
+}
+
+/// Construct a SubstitutionEntry for a given node.
+/// This will look in the HashHash to see if we already know the hash
+/// (which avoids recursive hashing on the Node tree).
+SubstitutionEntry RemanglerBase::entryForNode(Node *node,
+                                              bool treatAsIdentifier) {
+  const size_t ident = treatAsIdentifier ? 4 : 0;
+  const size_t hash = nodeHash(node) + ident;
+
+  // Use linear probing with a limit
+  for (size_t n = 0; n < HashHashMaxProbes; ++n) {
+    const size_t ndx = (hash + n) & (HashHashCapacity - 1);
+    SubstitutionEntry entry = HashHash[ndx];
+
+    if (entry.isEmpty()) {
+      size_t entryHash = hashForNode(node, treatAsIdentifier);
+      entry.setNode(node, treatAsIdentifier, entryHash);
+      HashHash[ndx] = entry;
+      return entry;
+    } else if (entry.matches(node, treatAsIdentifier)) {
+      return entry;
+    }
+  }
+
+  // Hash table is full at this hash value
+  SubstitutionEntry entry;
+  size_t entryHash = hashForNode(node, treatAsIdentifier);
+  entry.setNode(node, treatAsIdentifier, entryHash);
+  return entry;
 }
 
 // Find a substitution and return its index.
@@ -340,7 +408,7 @@ bool Remangler::trySubstitution(Node *node, SubstitutionEntry &entry,
     return true;
 
   // Go ahead and initialize the substitution entry.
-  entry.setNode(node, treatAsIdentifier);
+  entry = entryForNode(node, treatAsIdentifier);
 
   int Idx = findSubstitution(entry);
   if (Idx < 0)

lib/Demangling/RemanglerBase.h

@@ -42,10 +42,10 @@ class SubstitutionEntry {
   bool treatAsIdentifier = false;
 
 public:
-  void setNode(Node *node, bool treatAsIdentifier) {
+  void setNode(Node *node, bool treatAsIdentifier, size_t hash) {
     this->treatAsIdentifier = treatAsIdentifier;
     TheNode = node;
-    deepHash(node);
+    StoredHash = hash;
   }
 
   struct Hasher {
@@ -54,6 +54,14 @@ class SubstitutionEntry {
     }
   };
 
+  bool isEmpty() const { return !TheNode; }
+
+  bool matches(Node *node, bool treatAsIdentifier) const {
+    return node == TheNode && treatAsIdentifier == this->treatAsIdentifier;
+  }
+
+  size_t hash() const { return StoredHash; }
+
 private:
   friend bool operator==(const SubstitutionEntry &lhs,
                          const SubstitutionEntry &rhs) {
@@ -69,12 +77,6 @@ class SubstitutionEntry {
 
   static bool identifierEquals(Node *lhs, Node *rhs);
 
-  void combineHash(size_t newValue) {
-    StoredHash = 33 * StoredHash + newValue;
-  }
-
-  void deepHash(Node *node);
-
   bool deepEquals(Node *lhs, Node *rhs) const;
 };
 
@@ -131,6 +133,13 @@ class RemanglerBase {
   // Used to allocate temporary nodes and the output string (in Buffer).
   NodeFactory &Factory;
 
+  // Recursively calculating the node hashes can be expensive if the node tree
+  // is deep, so we keep a hash table mapping (Node *, treatAsIdentifier) pairs
+  // to hashes.
+  static const size_t HashHashCapacity = 512; // Must be a power of 2
+  static const size_t HashHashMaxProbes = 8;
+  SubstitutionEntry HashHash[HashHashCapacity] = {};
+
   // An efficient hash-map implementation in the spirit of llvm's SmallPtrSet:
   // The first 16 substitutions are stored in an inline-allocated array to avoid
   // malloc calls in the common case.
@@ -148,7 +157,16 @@ class RemanglerBase {
   RemanglerBuffer Buffer;
 
 protected:
-  RemanglerBase(NodeFactory &Factory) : Factory(Factory), Buffer(Factory) { }
+  RemanglerBase(NodeFactory &Factory)
+    : Factory(Factory), Buffer(Factory) { }
+
+  /// Compute the hash for a node.
+  size_t hashForNode(Node *node, bool treatAsIdentifier = false);
+
+  /// Construct a SubstitutionEntry for a given node.
+  /// This will look in the HashHash to see if we already know the hash,
+  /// to avoid having to walk the entire subtree.
+  SubstitutionEntry entryForNode(Node *node, bool treatAsIdentifier = false);
 
   /// Find a substitution and return its index.
   /// Returns -1 if no substitution is found.