[lldb] Don't construct the demangled strings while indexing the symbol table

The symbol table needs to demangle all symbol names when building its
index. However, this doesn't require the full mangled name: we only need
the base name and the function declaration context. Currently, we always
construct the demangled string during indexing and cache it in the
string pool as a way to speed up future lookups.

Constructing the demangled string is by far the most expensive step of
the demangling process, because the output string can be exponentially
larger than the input and unless you're dumping the symbol table, many
of those demangled names will not be needed again.

This patch avoids constructing the full demangled string when we can
partially demangle. This speeds up indexing and reduces memory usage.

I gathered some numbers by attaching to Slack:

Before
------

  Memory usage: 280MB
  Benchmark 1: ./bin/lldb -n Slack -o quit
    Time (mean ± σ):      4.829 s ±  0.518 s    [User: 4.012 s, System: 0.208 s]
    Range (min … max):    4.624 s …  6.294 s    10 runs

After
-----

  Memory usage: 189MB
  Benchmark 1: ./bin/lldb -n Slack -o quit
    Time (mean ± σ):      4.182 s ±  0.025 s    [User: 3.536 s, System: 0.192 s]
    Range (min … max):    4.152 s …  4.233 s    10 runs

Differential revision: https://reviews.llvm.org/D118814

(cherry picked from commit aed965d)

Author: JDevlieghere

lldb/source/Core/Mangled.cpp

@@ -240,24 +240,16 @@ bool Mangled::DemangleWithRichManglingInfo(
   case eManglingSchemeItanium:
     // We want the rich mangling info here, so we don't care whether or not
     // there is a demangled string in the pool already.
-    if (context.FromItaniumName(m_mangled)) {
-      // If we got an info, we have a name. Copy to string pool and connect the
-      // counterparts to accelerate later access in GetDemangledName().
-      m_demangled.SetStringWithMangledCounterpart(context.ParseFullName(),
-                                                  m_mangled);
-      return true;
-    } else {
-      m_demangled.SetCString("");
-      return false;
-    }
+    return context.FromItaniumName(m_mangled);
 
   case eManglingSchemeMSVC: {
     // We have no rich mangling for MSVC-mangled names yet, so first try to
     // demangle it if necessary.
     if (!m_demangled && !m_mangled.GetMangledCounterpart(m_demangled)) {
       if (char *d = GetMSVCDemangledStr(m_mangled.GetCString())) {
-        // If we got an info, we have a name. Copy to string pool and connect
-        // the counterparts to accelerate later access in GetDemangledName().
+        // Without the rich mangling info we have to demangle the full name.
+        // Copy it to string pool and connect the counterparts to accelerate
+        // later access in GetDemangledName().
         m_demangled.SetStringWithMangledCounterpart(llvm::StringRef(d),
                                                     m_mangled);
         ::free(d);

lldb/source/Symbol/Symtab.cpp

@@ -330,10 +330,13 @@ void Symtab::InitNameIndexes() {
 
         const SymbolType type = symbol->GetType();
         if (type == eSymbolTypeCode || type == eSymbolTypeResolver) {
-          if (mangled.DemangleWithRichManglingInfo(rmc, lldb_skip_name))
+          if (mangled.DemangleWithRichManglingInfo(rmc, lldb_skip_name)) {
             RegisterMangledNameEntry(value, class_contexts, backlog, rmc);
+            continue;
+          }
 #ifdef LLDB_ENABLE_SWIFT
-	  else if (SwiftLanguageRuntime::IsSwiftMangledName(name.GetStringRef())) {
+          else if (SwiftLanguageRuntime::IsSwiftMangledName(
+                       name.GetStringRef())) {
             lldb_private::ConstString basename;
             bool is_method = false;
             ConstString mangled_name = mangled.GetMangledName();
@@ -346,6 +349,7 @@ void Symtab::InitNameIndexes() {
                 else
                   basename_to_index.Append(basename, value);
               }
+              continue;
             }
           }
 #endif // LLDB_ENABLE_SWIFT

lldb/test/API/macosx/dyld-trie-symbols/TestDyldTrieSymbols.py

@@ -43,8 +43,6 @@ def test_dyld_trie_symbols(self):
         self.assertEqual(unstripped_Z3pat_symbols.GetSize(), 1)
         unstripped_pat_symbols = unstripped_target.FindSymbols("pat")
         self.assertEqual(unstripped_pat_symbols.GetSize(), 1)
-        unstripped_patint_symbols = unstripped_target.FindSymbols("pat(int)")
-        self.assertEqual(unstripped_patint_symbols.GetSize(), 1)
 
         unstripped_bar_symbols = unstripped_target.FindSymbols("bar")
         self.assertEqual(unstripped_bar_symbols.GetSize(), 1)
@@ -77,8 +75,6 @@ def test_dyld_trie_symbols(self):
         self.assertEqual(stripped_Z3pat_symbols.GetSize(), 1)
         stripped_pat_symbols = stripped_target.FindSymbols("pat")
         self.assertEqual(stripped_pat_symbols.GetSize(), 1)
-        stripped_patint_symbols = stripped_target.FindSymbols("pat(int)")
-        self.assertEqual(stripped_patint_symbols.GetSize(), 1)
 
         # bar should have been strippped.  We should not find it, or the
         # stripping went wrong.