Runtime: make the demangler use stack allocated memory.

This reduces the amount of mallocs significantly.

Author: eeckstein

include/swift/Reflection/TypeRefBuilder.h

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

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);
+    return mangleNode(node, &dem);
   }
 
   // Fall back to the raw string.

stdlib/public/runtime/Demangle.cpp

@@ -284,7 +284,7 @@ _buildDemanglingForNominalType(const Metadata *type, Demangle::Demangler &Dem) {
   // Gather the complete set of generic arguments that must be written to
   // form this type.
   std::vector<const Metadata *> allGenericArgs;
-  gatherWrittenGenericArgs(type, description, allGenericArgs);
+  gatherWrittenGenericArgs(type, description, allGenericArgs, Dem);
 
   // Demangle the generic arguments.
   std::vector<NodePointer> demangledGenerics;

stdlib/public/runtime/Metadata.cpp

@@ -2189,7 +2189,7 @@ static inline ClassROData *getROData(ClassMetadata *theClass) {
 
 static void initGenericClassObjCName(ClassMetadata *theClass) {
   // Use the remangler to generate a mangled name from the type metadata.
-  Demangle::Demangler Dem;
+  Demangle::StackAllocatedDemangler<4096> Dem;
   // Resolve symbolic references to a unique mangling that can be encoded in
   // the class name.
   Dem.setSymbolicReferenceResolver(ResolveToDemanglingForContext(Dem));
@@ -2202,7 +2202,7 @@ static void initGenericClassObjCName(ClassMetadata *theClass) {
   auto globalNode = Dem.createNode(Demangle::Node::Kind::Global);
   globalNode->addChild(typeNode, Dem);
 
-  auto string = Demangle::mangleNodeOld(globalNode);
+  auto string = Demangle::mangleNodeOld(globalNode, &Dem);
 
   // If the class is in the Swift module, add a $ to the end of the ObjC
   // name. The old and new Swift libraries must be able to coexist in
@@ -5016,7 +5016,7 @@ void swift::verifyMangledNameRoundtrip(const Metadata *metadata) {
 
   if (!verificationEnabled) return;
 
-  Demangle::Demangler Dem;
+  Demangle::StackAllocatedDemangler<1024> Dem;
   Dem.setSymbolicReferenceResolver(ResolveToDemanglingForContext(Dem));
 
   auto node = _swift_buildDemanglingForMetadata(metadata, Dem);

stdlib/public/runtime/MetadataLookup.cpp

@@ -50,16 +50,17 @@ using namespace reflection;
 #include <dlfcn.h>
 #endif
 
-/// Produce a Demangler value suitable for resolving runtime type metadata
-/// strings.
-static Demangler getDemanglerForRuntimeTypeResolution() {
-  Demangler dem;
-  // Resolve symbolic references to type contexts into the absolute address of
-  // the type context descriptor, so that if we see a symbolic reference in the
-  // mangled name we can immediately find the associated metadata.
-  dem.setSymbolicReferenceResolver(ResolveAsSymbolicReference(dem));
-  return dem;
-}
+/// A Demangler suitable for resolving runtime type metadata strings.
+template <class Base = Demangler>
+class DemanglerForRuntimeTypeResolution : public Base {
+public:
+  DemanglerForRuntimeTypeResolution() {
+    // Resolve symbolic references to type contexts into the absolute address of
+    // the type context descriptor, so that if we see a symbolic reference in
+    // the mangled name we can immediately find the associated metadata.
+    Base::setSymbolicReferenceResolver(ResolveAsSymbolicReference(*this));
+  }
+};
 
 NodePointer
 ResolveAsSymbolicReference::operator()(SymbolicReferenceKind kind,
@@ -416,7 +417,7 @@ swift::_contextDescriptorMatchesMangling(const ContextDescriptor *context,
 
       // Check that the context being extended matches as well.
       auto extendedContextNode = node->getChild(1);
-      auto demangler = getDemanglerForRuntimeTypeResolution();
+      DemanglerForRuntimeTypeResolution<> demangler;
 
       auto extendedDescriptorFromNode =
         _findNominalTypeDescriptor(extendedContextNode, demangler);
@@ -593,7 +594,7 @@ _findNominalTypeDescriptor(Demangle::NodePointer node,
       (const ContextDescriptor *)symbolicNode->getIndex());
 
   auto mangledName =
-    Demangle::mangleNode(node, ExpandResolvedSymbolicReferences(Dem));
+    Demangle::mangleNode(node, ExpandResolvedSymbolicReferences(Dem), &Dem);
 
   // Look for an existing entry.
   // Find the bucket for the metadata entry.
@@ -723,7 +724,7 @@ _findProtocolDescriptor(NodePointer node,
       (const ContextDescriptor *)symbolicNode->getIndex());
 
   mangledName =
-    Demangle::mangleNode(node, ExpandResolvedSymbolicReferences(Dem));
+    Demangle::mangleNode(node, ExpandResolvedSymbolicReferences(Dem), &Dem);
 
   // Look for an existing entry.
   // Find the bucket for the metadata entry.
@@ -820,10 +821,13 @@ Optional<unsigned> swift::_depthIndexToFlatIndex(
 /// \returns true if the innermost descriptor is generic.
 bool swift::_gatherGenericParameterCounts(
                                  const ContextDescriptor *descriptor,
-                                 std::vector<unsigned> &genericParamCounts) {
+                                 std::vector<unsigned> &genericParamCounts,
+                                 Demangler &BorrowFrom) {
   // If we have an extension descriptor, extract the extended type and use
   // that.
-  auto demangler = getDemanglerForRuntimeTypeResolution();
+  DemanglerForRuntimeTypeResolution<> demangler;
+  demangler.providePreallocatedMemory(BorrowFrom);
+
   if (auto extension = dyn_cast<ExtensionContextDescriptor>(descriptor)) {
     if (auto extendedType =
             _findExtendedTypeContextDescriptor(extension, demangler))
@@ -835,7 +839,7 @@ bool swift::_gatherGenericParameterCounts(
 
   // Recurse to record the parent context's generic parameters.
   if (auto parent = descriptor->Parent.get())
-    (void)_gatherGenericParameterCounts(parent, genericParamCounts);
+    (void)_gatherGenericParameterCounts(parent, genericParamCounts, demangler);
 
   // Record a new level of generic parameters if the count exceeds the
   // previous count.
@@ -961,7 +965,7 @@ class DecodedMetadataBuilder {
 #if SWIFT_OBJC_INTEROP
     // Look for a Swift-defined @objc protocol with the Swift 3 mangling that
     // is used for Objective-C entities.
-    std::string objcMangledName = "_Tt" + mangleNodeOld(node) + "_";
+    std::string objcMangledName = "_Tt" + mangleNodeOld(node, &demangler) + "_";
     if (auto protocol = objc_getProtocol(objcMangledName.c_str()))
       return ProtocolDescriptorRef::forObjC(protocol);
 #endif
@@ -1024,7 +1028,7 @@ class DecodedMetadataBuilder {
     // Figure out the various levels of generic parameters we have in
     // this type.
     std::vector<unsigned> genericParamCounts;
-    (void)_gatherGenericParameterCounts(typeDecl, genericParamCounts);
+    (void)_gatherGenericParameterCounts(typeDecl, genericParamCounts, demangler);
     unsigned numTotalGenericParams =
         genericParamCounts.empty() ? 0 : genericParamCounts.back();
 
@@ -1048,7 +1052,7 @@ class DecodedMetadataBuilder {
       // If we have a parent, gather it's generic arguments "as written".
       if (parent) {
         gatherWrittenGenericArgs(parent, parent->getTypeContextDescriptor(),
-                                 allGenericArgs);
+                                 allGenericArgs, demangler);
       }
 
       // Add the generic arguments we were given.
@@ -1294,7 +1298,8 @@ static TypeInfo swift_getTypeByMangledNameImpl(
                               StringRef typeName,
                               SubstGenericParameterFn substGenericParam,
                               SubstDependentWitnessTableFn substWitnessTable) {
-  auto demangler = getDemanglerForRuntimeTypeResolution();
+  DemanglerForRuntimeTypeResolution<StackAllocatedDemangler<2048>> demangler;
+
   NodePointer node;
 
   // Check whether this is the convenience syntax "ModuleName.ClassName".
@@ -1620,7 +1625,8 @@ demangleToGenericParamRef(StringRef typeName) {
 void swift::gatherWrittenGenericArgs(
                              const Metadata *metadata,
                              const TypeContextDescriptor *description,
-                             std::vector<const Metadata *> &allGenericArgs) {
+                             std::vector<const Metadata *> &allGenericArgs,
+                             Demangler &BorrowFrom) {
   auto generics = description->getGenericContext();
   if (!generics)
     return;
@@ -1674,7 +1680,8 @@ void swift::gatherWrittenGenericArgs(
 
   // Retrieve the mapping information needed for depth/index -> flat index.
   std::vector<unsigned> genericParamCounts;
-  (void)_gatherGenericParameterCounts(description, genericParamCounts);
+  (void)_gatherGenericParameterCounts(description, genericParamCounts,
+                                      BorrowFrom);
 
   // Walk through the generic requirements to evaluate same-type
   // constraints that are needed to fill in missing generic arguments.

stdlib/public/runtime/Private.h

@@ -386,7 +386,8 @@ class TypeInfo {
   ///
   /// \returns true if the innermost descriptor is generic.
   bool _gatherGenericParameterCounts(const ContextDescriptor *descriptor,
-                                     std::vector<unsigned> &genericParamCounts);
+                                     std::vector<unsigned> &genericParamCounts,
+                                     Demangler &BorrowFrom);
 
   /// Map depth/index to a flat index.
   llvm::Optional<unsigned> _depthIndexToFlatIndex(
@@ -451,7 +452,8 @@ class TypeInfo {
   /// \endcode
   void gatherWrittenGenericArgs(const Metadata *metadata,
                                 const TypeContextDescriptor *description,
-                                std::vector<const Metadata *> &allGenericArgs);
+                                std::vector<const Metadata *> &allGenericArgs,
+                                Demangler &BorrowFrom);
 
   Demangle::NodePointer
   _buildDemanglingForContext(const ContextDescriptor *context,