Demangler: support stack allocation for the Demangler's allocator

The demangler can be initialized with a preallocated memory on the stack. Only in case of an overflow, the bump pointer allocator mallocs new memory.
Also, support that a new instance of a demangler can "borrow" the free memory from an existing demangler. This is useful because in the runtime the demangler is invoked recursively. With this feature, all the nested demanglers can share a single stack allocated space.

Author: eeckstein

Diff for: include/swift/Demangling/Demangle.h

@@ -474,8 +474,10 @@ void mangleIdentifier(const char *data, size_t length,
 
 /// Remangle a demangled parse tree.
 ///
-/// This should always round-trip perfectly with demangleSymbolAsNode.
-std::string mangleNode(NodePointer root);
+/// 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);
 
 using SymbolicResolver =
   llvm::function_ref<Demangle::NodePointer (SymbolicReferenceKind,
@@ -484,14 +486,17 @@ using SymbolicResolver =
 /// Remangle a demangled parse tree, using a callback to resolve
 /// symbolic references.
 ///
-/// This should always round-trip perfectly with demangleSymbolAsNode.
-std::string mangleNode(NodePointer root, SymbolicResolver resolver);
+/// 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);
 
 /// Remangle in the old mangling scheme.
 ///
-/// This is only used for objc-runtime names and should be removed as soon as
-/// we switch to the new mangling for those names as well.
-std::string mangleNodeOld(NodePointer root);
+/// This is only used for objc-runtime names.
+/// If \p BorrowFrom is specified, the initial bump pointer memory is
+/// borrowed from the free memory of BorrowFrom.
+std::string mangleNodeOld(NodePointer root, NodeFactory *BorrowFrom = nullptr);
 
 /// Transform the node structure to a string.
 ///

Diff for: include/swift/Demangling/Demangler.h

@@ -69,7 +69,13 @@ class NodeFactory {
   }
 
   static void freeSlabs(Slab *slab);
-  
+
+  /// If not null, the NodeFactory from which this factory borrowed free memory.
+  NodeFactory *BorrowedFrom = nullptr;
+
+  /// True if some other NodeFactory borrowed free memory from this factory.
+  bool isBorrowed = false;
+
 #ifdef NODE_FACTORY_DEBUGGING
   size_t allocatedMemory = 0;
   static int nestingLevel;
@@ -84,20 +90,54 @@ class NodeFactory {
     nestingLevel++;
 #endif
   }
-  
+
+  /// Provide pre-allocated memory, e.g. memory on the stack.
+  ///
+  /// Only if this memory overflows, the factory begins to malloc.
+  void providePreallocatedMemory(char *Memory, size_t Size) {
+#ifdef NODE_FACTORY_DEBUGGING
+    std::cerr << indent() << "++ provide preallocated memory, size = "
+                          << Size << '\n';
+#endif
+    assert(!CurPtr && !End && !CurrentSlab);
+    CurPtr = Memory;
+    End = CurPtr + Size;
+  }
+
+  /// Borrow free memory from another factory \p BorrowFrom.
+  ///
+  /// While this factory is alive, no allocations can be done in the
+  /// \p BorrowFrom factory.
+  void providePreallocatedMemory(NodeFactory &BorrowFrom) {
+    assert(!CurPtr && !End && !CurrentSlab);
+    assert(!BorrowFrom.isBorrowed && !BorrowedFrom);
+    BorrowFrom.isBorrowed = true;
+    BorrowedFrom = &BorrowFrom;
+    CurPtr = BorrowFrom.CurPtr;
+    End = BorrowFrom.End;
+#ifdef NODE_FACTORY_DEBUGGING
+    std::cerr << indent() << "++ borrow memory, size = "
+                          << (End - CurPtr) << '\n';
+#endif
+  }
+
   virtual ~NodeFactory() {
     freeSlabs(CurrentSlab);
 #ifdef NODE_FACTORY_DEBUGGING
     nestingLevel--;
     std::cerr << indent() << "## Delete NodeFactory: allocated memory = "
                           << allocatedMemory  << '\n';
 #endif
+    if (BorrowedFrom) {
+      BorrowedFrom->isBorrowed = false;
+    }
   }
 
   virtual void clear();
 
   /// Allocates an object of type T or an array of objects of type T.
   template<typename T> T *Allocate(size_t NumObjects = 1) {
+    assert(!isBorrowed);
     size_t ObjectSize = NumObjects * sizeof(T);
     CurPtr = align(CurPtr, alignof(T));
 #ifdef NODE_FACTORY_DEBUGGING
@@ -144,6 +184,7 @@ class NodeFactory {
   /// enlarged by a bigger value.
   template<typename T> void Reallocate(T *&Objects, uint32_t &Capacity,
                                        size_t MinGrowth) {
+    assert(!isBorrowed);
     size_t OldAllocSize = Capacity * sizeof(T);
     size_t AdditionalAlloc = MinGrowth * sizeof(T);
 
@@ -547,7 +588,19 @@ class Demangler : public NodeFactory {
   /// Demangler or with a call of clear().
   NodePointer demangleType(StringRef MangledName);
 };
-  
+
+/// A demangler which uses stack space for its initial memory.
+///
+/// The \p Size paramter specifies the size of the stack space.
+template <size_t Size> class StackAllocatedDemangler : public Demangler {
+  char StackSpace[Size];
+
+public:
+  StackAllocatedDemangler() {
+    providePreallocatedMemory(StackSpace, Size);
+  }
+};
+
 NodePointer demangleOldSymbolAsNode(StringRef MangledName,
                                     NodeFactory &Factory);
 } // end namespace Demangle

Diff for: lib/Demangling/Demangler.cpp

@@ -408,6 +408,7 @@ void NodeFactory::freeSlabs(Slab *slab) {
 }
 
 void NodeFactory::clear() {
+  assert(!isBorrowed);
   if (CurrentSlab) {
 #ifdef NODE_FACTORY_DEBUGGING
     std::cerr << indent() << "## clear: allocated memory = " << allocatedMemory  << "\n";

Diff for: lib/Demangling/OldRemangler.cpp

@@ -214,7 +214,11 @@ namespace {
     std::unordered_map<SubstitutionEntry, unsigned,
                        SubstitutionEntry::Hasher> Substitutions;
   public:
-    Remangler(DemanglerPrinter &out) : Out(out) {}
+    Remangler(DemanglerPrinter &out,
+              NodeFactory *BorrowFrom) : Out(out) {
+      if (BorrowFrom)
+        Factory.providePreallocatedMemory(*BorrowFrom);
+    }
 
     class EntityContext {
       bool AsContext = false;
@@ -2282,10 +2286,10 @@ void Remangler::mangleSugaredParen(Node *node) {
 }
 
 /// The top-level interface to the remangler.
-std::string Demangle::mangleNodeOld(NodePointer node) {
+std::string Demangle::mangleNodeOld(NodePointer node, NodeFactory *BorrowFrom) {
   if (!node) return "";
 
   DemanglerPrinter printer;
-  Remangler(printer).mangle(node);
+  Remangler(printer, BorrowFrom).mangle(node);
   return std::move(printer).str();
 }

Diff for: lib/Demangling/Remangler.cpp

@@ -311,8 +311,12 @@ class Remangler {
 #include "swift/Demangling/DemangleNodes.def"
 
 public:
-  Remangler(DemanglerPrinter &Buffer,
-            SymbolicResolver Resolver) : Buffer(Buffer), Resolver(Resolver) {}
+  Remangler(DemanglerPrinter &Buffer, SymbolicResolver Resolver,
+            NodeFactory *BorrowFrom)
+       : Buffer(Buffer), Resolver(Resolver) {
+    if (BorrowFrom)
+      Factory.providePreallocatedMemory(*BorrowFrom);
+  }
 
   void mangle(Node *node) {
     switch (node->getKind()) {
@@ -2334,19 +2338,20 @@ void Remangler::mangleSugaredParen(Node *node) {
 } // anonymous namespace
 
 /// The top-level interface to the remangler.
-std::string Demangle::mangleNode(NodePointer node) {
+std::string Demangle::mangleNode(NodePointer node, NodeFactory *BorrowFrom) {
   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) {
+Demangle::mangleNode(NodePointer node, SymbolicResolver resolver,
+                     NodeFactory *BorrowFrom) {
   if (!node) return "";
 
   DemanglerPrinter printer;
-  Remangler(printer, resolver).mangle(node);
+  Remangler(printer, resolver, BorrowFrom).mangle(node);
 
   return std::move(printer).str();
 }