Remangler: Use a bump-pointer allocated string instead of std::string

Done by replacing DemanglerPrinter with a bump-pointer allocated CharVector buffer.
This avoids malloc calls.

SR-10028
rdar://problem/48575729

Author: eeckstein

include/swift/Demangling/Demangle.h

@@ -490,23 +490,23 @@ void mangleIdentifier(const char *data, size_t length,
                       bool usePunycode = true);
 
 /// Remangle a demangled parse tree.
-///
-/// If \p BorrowFrom is specified, the initial bump pointer memory is
-/// borrowed from the free memory of BorrowFrom.
-std::string mangleNode(NodePointer root,
-                       NodeFactory *BorrowFrom = nullptr);
+std::string mangleNode(NodePointer root);
 
 using SymbolicResolver =
   llvm::function_ref<Demangle::NodePointer (SymbolicReferenceKind,
                                             const void *)>;
 
+/// Remangle a demangled parse tree, using a callback to resolve
+/// symbolic references.
+std::string mangleNode(NodePointer root, SymbolicResolver resolver);
+
 /// Remangle a demangled parse tree, using a callback to resolve
 /// symbolic references.
 ///
-/// If \p BorrowFrom is specified, the initial bump pointer memory is
-/// borrowed from the free memory of BorrowFrom.
-std::string mangleNode(NodePointer root, SymbolicResolver resolver,
-                       NodeFactory *BorrowFrom = nullptr);
+/// The returned string is owned by \p Factory. This means \p Factory must stay
+/// alive as long as the returned string is used.
+llvm::StringRef mangleNode(NodePointer root, SymbolicResolver resolver,
+                           NodeFactory &Factory);
 
 /// Remangle in the old mangling scheme.
 ///

include/swift/Demangling/Demangler.h

@@ -303,6 +303,11 @@ template<typename T> class Vector {
 
   T &back() { return (*this)[NumElems - 1]; }
 
+  void resetSize(size_t toPos) {
+    assert(toPos <= NumElems);
+    NumElems = toPos;
+  }
+
   void push_back(const T &NewElem, NodeFactory &Factory) {
     if (NumElems >= Capacity)
       Factory.Reallocate(Elems, Capacity, /*Growth*/ 1);
@@ -331,6 +336,9 @@ class CharVector : public Vector<char> {
   // Append an integer as readable number.
   void append(int Number, NodeFactory &Factory);
 
+  // Append an unsigned 64 bit integer as readable number.
+  void append(unsigned long long Number, NodeFactory &Factory);
+
   StringRef str() const {
     return StringRef(Elems, NumElems);
   }

include/swift/Reflection/TypeRefBuilder.h

@@ -210,12 +210,12 @@ class TypeRefBuilder {
 
   Optional<std::string>
   createTypeDecl(Node *node, bool &typeAlias) {
-    return Demangle::mangleNode(node, &Dem);
+    return Demangle::mangleNode(node);
   }
 
   BuiltProtocolDecl
   createProtocolDecl(Node *node) {
-    return std::make_pair(Demangle::mangleNode(node, &Dem), false);
+    return std::make_pair(Demangle::mangleNode(node), false);
   }
 
   BuiltProtocolDecl

lib/Demangling/Demangler.cpp

@@ -465,14 +465,23 @@ void CharVector::append(StringRef Rhs, NodeFactory &Factory) {
 }
 
 void CharVector::append(int Number, NodeFactory &Factory) {
-  const int MaxIntPrintSize = 8;
+  const int MaxIntPrintSize = 11;
   if (NumElems + MaxIntPrintSize > Capacity)
     Factory.Reallocate(Elems, Capacity, /*Growth*/ MaxIntPrintSize);
   int Length = snprintf(Elems + NumElems, MaxIntPrintSize, "%d", Number);
   assert(Length > 0 && Length < MaxIntPrintSize);
   NumElems += Length;
 }
 
+void CharVector::append(unsigned long long Number, NodeFactory &Factory) {
+  const int MaxPrintSize = 21;
+  if (NumElems + MaxPrintSize > Capacity)
+    Factory.Reallocate(Elems, Capacity, /*Growth*/ MaxPrintSize);
+  int Length = snprintf(Elems + NumElems, MaxPrintSize, "%llu", Number);
+  assert(Length > 0 && Length < MaxPrintSize);
+  NumElems += Length;
+}
+
 //////////////////////////////////
 // Demangler member functions   //
 //////////////////////////////////

lib/Demangling/Remangler.cpp

@@ -146,15 +146,55 @@ bool SubstitutionEntry::deepEquals(Node *lhs, Node *rhs) const {
   return true;
 }
 
+/// The output string of the Demangler.
+///
+/// It's allocating the string with the provided Factory.
+struct RemanglerBuffer {
+  CharVector Stream;
+  NodeFactory &Factory;
+
+  RemanglerBuffer(NodeFactory &Factory) : Factory(Factory) {
+    Stream.init(Factory, 32);
+  }
+
+  RemanglerBuffer &operator<<(char c) & {
+    Stream.push_back(c, Factory);
+    return *this;
+  }
+
+  RemanglerBuffer &operator<<(llvm::StringRef Value) & {
+    Stream.append(Value, Factory);
+    return *this;
+  }
+
+  RemanglerBuffer &operator<<(int n) & {
+    Stream.append(n, Factory);
+    return *this;
+  }
+
+  RemanglerBuffer &operator<<(unsigned n) & {
+    Stream.append((unsigned long long)n, Factory);
+    return *this;
+  }
+
+  RemanglerBuffer &operator<<(unsigned long n) & {
+    Stream.append((unsigned long long)n, Factory);
+    return *this;
+  }
+
+  RemanglerBuffer &operator<<(unsigned long long n) & {
+    Stream.append(n, Factory);
+    return *this;
+  }
+};
+
 class Remangler {
   template <typename Mangler>
   friend void Mangle::mangleIdentifier(Mangler &M, StringRef ident);
   friend class Mangle::SubstitutionMerging;
 
   const bool UsePunycode = true;
 
-  DemanglerPrinter &Buffer;
-
   Vector<SubstitutionWord> Words;
   Vector<WordReplacement> SubstWordsInIdent;
 
@@ -178,7 +218,9 @@ class Remangler {
 
   // We have to cons up temporary nodes sometimes when remangling
   // nested generics. This factory owns them.
-  NodeFactory Factory;
+  NodeFactory &Factory;
+
+  RemanglerBuffer Buffer;
 
   // A callback for resolving symbolic references.
   SymbolicResolver Resolver;
@@ -209,9 +251,9 @@ class Remangler {
     return it->second;
   }
 
-  StringRef getBufferStr() const { return Buffer.getStringRef(); }
+  StringRef getBufferStr() const { return Buffer.Stream.str(); }
 
-  void resetBuffer(size_t toPos) { Buffer.resetSize(toPos); }
+  void resetBuffer(size_t toPos) { Buffer.Stream.resetSize(toPos); }
 
   template <typename Mangler>
   friend void mangleIdentifier(Mangler &M, StringRef ident);
@@ -348,12 +390,8 @@ class Remangler {
 #include "swift/Demangling/DemangleNodes.def"
 
 public:
-  Remangler(DemanglerPrinter &Buffer, SymbolicResolver Resolver,
-            NodeFactory *BorrowFrom)
-       : Buffer(Buffer), Resolver(Resolver) {
-    if (BorrowFrom)
-      Factory.providePreallocatedMemory(*BorrowFrom);
-  }
+  Remangler(SymbolicResolver Resolver, NodeFactory &Factory)
+       : Factory(Factory), Buffer(Factory), Resolver(Resolver) { }
 
   void mangle(Node *node) {
     switch (node->getKind()) {
@@ -362,6 +400,14 @@ class Remangler {
     }
     unreachable("bad demangling tree node");
   }
+
+  StringRef strRef() {
+    return Buffer.Stream.str();
+  }
+
+  std::string str() {
+    return strRef().str();
+  }
 };
 
 bool Remangler::trySubstitution(Node *node, SubstitutionEntry &entry,
@@ -2373,22 +2419,34 @@ void Remangler::mangleSugaredParen(Node *node) {
 } // anonymous namespace
 
 /// The top-level interface to the remangler.
-std::string Demangle::mangleNode(NodePointer node, NodeFactory *BorrowFrom) {
+std::string Demangle::mangleNode(NodePointer node) {
   return mangleNode(node, [](SymbolicReferenceKind, const void *) -> NodePointer {
     unreachable("should not try to mangle a symbolic reference; "
                 "resolve it to a non-symbolic demangling tree instead");
-  }, BorrowFrom);
+  });
 }
 
 std::string
-Demangle::mangleNode(NodePointer node, SymbolicResolver resolver,
-                     NodeFactory *BorrowFrom) {
+Demangle::mangleNode(NodePointer node, SymbolicResolver resolver) {
   if (!node) return "";
 
-  DemanglerPrinter printer;
-  Remangler(printer, resolver, BorrowFrom).mangle(node);
+  NodeFactory Factory;
+  Remangler remangler(resolver, Factory);
+  remangler.mangle(node);
+
+  return remangler.str();
+}
+
+llvm::StringRef
+Demangle::mangleNode(NodePointer node, SymbolicResolver resolver,
+                     NodeFactory &Factory) {
+  if (!node)
+    return StringRef();
+
+  Remangler remangler(resolver, Factory);
+  remangler.mangle(node);
 
-  return std::move(printer).str();
+  return remangler.strRef();
 }
 
 bool Demangle::isSpecialized(Node *node) {

stdlib/public/Reflection/TypeRefBuilder.cpp

@@ -56,7 +56,7 @@ static std::string normalizeReflectionName(Demangler &dem, StringRef reflectionN
 
   // Remangle the reflection name to resolve symbolic references.
   if (auto node = dem.demangleType(reflectionName)) {
-    return mangleNode(node, &dem);
+    return mangleNode(node);
   }
 
   // Fall back to the raw string.

stdlib/public/runtime/MetadataLookup.cpp

@@ -593,8 +593,8 @@ _findNominalTypeDescriptor(Demangle::NodePointer node,
     return cast<TypeContextDescriptor>(
       (const ContextDescriptor *)symbolicNode->getIndex());
 
-  auto mangledName =
-    Demangle::mangleNode(node, ExpandResolvedSymbolicReferences(Dem), &Dem);
+  StringRef mangledName =
+    Demangle::mangleNode(node, ExpandResolvedSymbolicReferences(Dem), Dem);
 
   // Look for an existing entry.
   // Find the bucket for the metadata entry.
@@ -724,7 +724,7 @@ _findProtocolDescriptor(NodePointer node,
       (const ContextDescriptor *)symbolicNode->getIndex());
 
   mangledName =
-    Demangle::mangleNode(node, ExpandResolvedSymbolicReferences(Dem), &Dem);
+    Demangle::mangleNode(node, ExpandResolvedSymbolicReferences(Dem), Dem).str();
 
   // Look for an existing entry.
   // Find the bucket for the metadata entry.