Create synthetic symbol names on demand to improve memory consumption and startup times.

[clayborg]

Summary

This is a resubmission of https://reviews.llvm.org/D105160 after fixing testing issues.

This fix was created after profiling the target creation of a large C/C++/ObjC application that contained almost 4,000,000 redacted symbol names. The symbol table parsing code was creating names for each of these synthetic symbols and adding them to the name indexes. The code was also adding the object file basename to the end of the symbol name which doesn't allow symbols from different shared libraries to share the names in the constant string pool.

Prior to this fix this was creating 180MB of "___lldb_unnamed_symbol" symbol names and was taking a long time to generate each name, add them to the string pool and then add each of these names to the name index.

This patch fixes the issue by:

not adding a name to synthetic symbols at creation time, and allows name to be dynamically generated when accessed
doesn't add synthetic symbol names to the name indexes, but catches this special case as name lookup time. Users won't typically set breakpoints or lookup these synthetic names, but support was added to do the lookup in case it does happen
removes the object file baseanme from the generated names to allow the names to be shared in the constant string pool
Prior to this fix the startup times for a large application was:
12.5 seconds (cold file caches)
8.5 seconds (warm file caches)

After this fix:
9.7 seconds (cold file caches)
5.7 seconds (warm file caches)

The names of the symbols are auto generated by appending the symbol's UserID to the end of the "___lldb_unnamed_symbol" string and is only done when the name is requested from a synthetic symbol if it has no name.

[wallace]

good luck with the build bots!

[rZhBoYao]

Hi all, I found this patch causing PR52702 in that the parent of this commit and LLDB 12 worked fine.
When disassembling a hello world C program on Linux, LLDB used to show
callq 0x401030 ; symbol stub for: puts
instead of
callq 0x401030 ; symbol stub for: ___lldb_unnamed_symbol36.
Examining the symbol table by running lldb -b -o 'image dump symtab' a.out used to show:

[   18]     20   X Undefined       0x0000000000000000                    0x0000000000000000 0x00000012 puts@GLIBC_2.2.5
                         ........
[   33]     35   X Code            0x0000000000401000                    0x000000000000001b 0x00000212 _init
[   34]     36  S  Trampoline      0x0000000000401030                    0x0000000000000010 0x00000000 puts
[   35]     37  SX Code            0x0000000000401020                    0x0000000000000010 0x00000000 ___lldb_unnamed_symbol1$$a.out

and now (ToT and LLDB 13) it's:

[   18]     20   X Undefined       0x0000000000000000                    0x0000000000000000 0x00000012 puts@GLIBC_2.2.5
                         ........
[   33]     35   X Code            0x0000000000401000                    0x000000000000001b 0x00000212 _init
[   34]     36  S  Trampoline      0x0000000000401030                    0x0000000000000010 0x00000000 ___lldb_unnamed_symbol36
[   35]     37  SX Code            0x0000000000401020                    0x0000000000000010 0x00000000 ___lldb_unnamed_symbol37

image dump symtab libc.so.6 gives similar result.
Before ec1a4917 :

[ 2366]   2367  S  Trampoline      0x0000000000025010 0x00007ffff7df2010 0x0000000000000010 0x00000000 realloc
[ 2367]   2368  S  Trampoline      0x0000000000025020 0x00007ffff7df2020 0x0000000000000010 0x00000000 __tls_get_addr
[ 2368]   2369  S  Trampoline      0x0000000000025030 0x00007ffff7df2030 0x0000000000000010 0x00000000 memalign
[ 2369]   2370  S  Trampoline      0x0000000000025040 0x00007ffff7df2040 0x0000000000000010 0x00000000 _dl_exception_create
[ 2370]   2371  S  Trampoline      0x0000000000025050 0x00007ffff7df2050 0x0000000000000010 0x00000000 __tunable_get_val
[ 2371]   2372  S  Trampoline      0x0000000000025060 0x00007ffff7df2060 0x0000000000000010 0x00000000 _dl_find_dso_for_object
[ 2372]   2373  S  Trampoline      0x0000000000025070 0x00007ffff7df2070 0x0000000000000010 0x00000000 calloc
[ 2373]   2373  SX Code            0x0000000000025000 0x00007ffff7df2000 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol1$$libc.so.6
[ 2374]   2373  SX Code            0x0000000000025300 0x00007ffff7df2300 0x0000000000000040 0x00000000 ___lldb_unnamed_symbol2$$libc.so.6
[ 2375]   2373  SX Code            0x0000000000025340 0x00007ffff7df2340 0x00000000000002f0 0x00000000 ___lldb_unnamed_symbol3$$libc.so.6
[ 2376]   2373  SX Code            0x0000000000025630 0x00007ffff7df2630 0x000000000000000c 0x00000000 ___lldb_unnamed_symbol4$$libc.so.6

After:

[ 2366]   2367  S  Trampoline      0x0000000000025010 0x00007ffff7df2010 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2367
[ 2367]   2368  S  Trampoline      0x0000000000025020 0x00007ffff7df2020 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2368
[ 2368]   2369  S  Trampoline      0x0000000000025030 0x00007ffff7df2030 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2369
[ 2369]   2370  S  Trampoline      0x0000000000025040 0x00007ffff7df2040 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2370
[ 2370]   2371  S  Trampoline      0x0000000000025050 0x00007ffff7df2050 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2371
[ 2371]   2372  S  Trampoline      0x0000000000025060 0x00007ffff7df2060 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2372
[ 2372]   2373  S  Trampoline      0x0000000000025070 0x00007ffff7df2070 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2373
[ 2373]   2374  SX Code            0x0000000000025000 0x00007ffff7df2000 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2374
[ 2374]   2375  SX Code            0x0000000000025300 0x00007ffff7df2300 0x0000000000000040 0x00000000 ___lldb_unnamed_symbol2375
[ 2375]   2376  SX Code            0x0000000000025340 0x00007ffff7df2340 0x00000000000002f0 0x00000000 ___lldb_unnamed_symbol2376
[ 2376]   2377  SX Code            0x0000000000025630 0x00007ffff7df2630 0x000000000000000c 0x00000000 ___lldb_unnamed_symbol2377

Is this intended for the performance boost? It seems to me that "S Trampoline" symbols should be handled differently.

FWIW, I also found that this doesn't affect macOS tho as puts is not even a synthetic symbol:

Index   UserID DSX Type            File Address/Value Load Address       Size               Flags      Name
------- ------ --- --------------- ------------------ ------------------ ------------------ ---------- ----------------------------------
[    0]      0     Data            0x0000000100008008                    0x0000000000000008 0x000e0000 _dyld_private
[    1]      1   X Data            0x0000000100000000                    0x0000000000003f70 0x000f0010 _mh_execute_header
[    2]      2   X Code            0x0000000100003f70                    0x0000000000000014 0x000f0000 main
[    3]      3     Trampoline      0x0000000100003f84                    0x0000000000000006 0x00010100 puts
[    4]      4   X Undefined       0x0000000000000000                    0x0000000000000000 0x00010100 dyld_stub_binder

callq  0x100003f84               ; symbol stub for: puts

[clayborg]

In D106837#3207676, @rZhBoYao wrote:

Hi all, I found this patch causing PR52702 in that the parent of this commit and LLDB 12 worked fine.
When disassembling a hello world C program on Linux, LLDB used to show
callq 0x401030 ; symbol stub for: puts
instead of
callq 0x401030 ; symbol stub for: ___lldb_unnamed_symbol36.
Examining the symbol table by running lldb -b -o 'image dump symtab' a.out used to show:

[   18]     20   X Undefined       0x0000000000000000                    0x0000000000000000 0x00000012 puts@GLIBC_2.2.5
                         ........
[   33]     35   X Code            0x0000000000401000                    0x000000000000001b 0x00000212 _init
[   34]     36  S  Trampoline      0x0000000000401030                    0x0000000000000010 0x00000000 puts
[   35]     37  SX Code            0x0000000000401020                    0x0000000000000010 0x00000000 ___lldb_unnamed_symbol1$$a.out

and now (ToT and LLDB 13) it's:

[   18]     20   X Undefined       0x0000000000000000                    0x0000000000000000 0x00000012 puts@GLIBC_2.2.5
                         ........
[   33]     35   X Code            0x0000000000401000                    0x000000000000001b 0x00000212 _init
[   34]     36  S  Trampoline      0x0000000000401030                    0x0000000000000010 0x00000000 ___lldb_unnamed_symbol36
[   35]     37  SX Code            0x0000000000401020                    0x0000000000000010 0x00000000 ___lldb_unnamed_symbol37

image dump symtab libc.so.6 gives similar result.
Before ec1a4917 :

[ 2366]   2367  S  Trampoline      0x0000000000025010 0x00007ffff7df2010 0x0000000000000010 0x00000000 realloc
[ 2367]   2368  S  Trampoline      0x0000000000025020 0x00007ffff7df2020 0x0000000000000010 0x00000000 __tls_get_addr
[ 2368]   2369  S  Trampoline      0x0000000000025030 0x00007ffff7df2030 0x0000000000000010 0x00000000 memalign
[ 2369]   2370  S  Trampoline      0x0000000000025040 0x00007ffff7df2040 0x0000000000000010 0x00000000 _dl_exception_create
[ 2370]   2371  S  Trampoline      0x0000000000025050 0x00007ffff7df2050 0x0000000000000010 0x00000000 __tunable_get_val
[ 2371]   2372  S  Trampoline      0x0000000000025060 0x00007ffff7df2060 0x0000000000000010 0x00000000 _dl_find_dso_for_object
[ 2372]   2373  S  Trampoline      0x0000000000025070 0x00007ffff7df2070 0x0000000000000010 0x00000000 calloc
[ 2373]   2373  SX Code            0x0000000000025000 0x00007ffff7df2000 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol1$$libc.so.6
[ 2374]   2373  SX Code            0x0000000000025300 0x00007ffff7df2300 0x0000000000000040 0x00000000 ___lldb_unnamed_symbol2$$libc.so.6
[ 2375]   2373  SX Code            0x0000000000025340 0x00007ffff7df2340 0x00000000000002f0 0x00000000 ___lldb_unnamed_symbol3$$libc.so.6
[ 2376]   2373  SX Code            0x0000000000025630 0x00007ffff7df2630 0x000000000000000c 0x00000000 ___lldb_unnamed_symbol4$$libc.so.6

After:

[ 2366]   2367  S  Trampoline      0x0000000000025010 0x00007ffff7df2010 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2367
[ 2367]   2368  S  Trampoline      0x0000000000025020 0x00007ffff7df2020 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2368
[ 2368]   2369  S  Trampoline      0x0000000000025030 0x00007ffff7df2030 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2369
[ 2369]   2370  S  Trampoline      0x0000000000025040 0x00007ffff7df2040 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2370
[ 2370]   2371  S  Trampoline      0x0000000000025050 0x00007ffff7df2050 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2371
[ 2371]   2372  S  Trampoline      0x0000000000025060 0x00007ffff7df2060 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2372
[ 2372]   2373  S  Trampoline      0x0000000000025070 0x00007ffff7df2070 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2373
[ 2373]   2374  SX Code            0x0000000000025000 0x00007ffff7df2000 0x0000000000000010 0x00000000 ___lldb_unnamed_symbol2374
[ 2374]   2375  SX Code            0x0000000000025300 0x00007ffff7df2300 0x0000000000000040 0x00000000 ___lldb_unnamed_symbol2375
[ 2375]   2376  SX Code            0x0000000000025340 0x00007ffff7df2340 0x00000000000002f0 0x00000000 ___lldb_unnamed_symbol2376
[ 2376]   2377  SX Code            0x0000000000025630 0x00007ffff7df2630 0x000000000000000c 0x00000000 ___lldb_unnamed_symbol2377

Is this intended for the performance boost? It seems to me that "S Trampoline" symbols should be handled differently.

It is a huge performance boost for Darwin binaries that are stripped because we end up with many symbols with no names due to the fact that mach-o binaries have a LC_FUNCTION_STARTS load command that details the start of all functions even that won't have symbols in the symbol tables.

FWIW, I also found that this doesn't affect macOS tho as puts is not even a synthetic symbol:

Index   UserID DSX Type            File Address/Value Load Address       Size               Flags      Name
------- ------ --- --------------- ------------------ ------------------ ------------------ ---------- ----------------------------------
[    0]      0     Data            0x0000000100008008                    0x0000000000000008 0x000e0000 _dyld_private
[    1]      1   X Data            0x0000000100000000                    0x0000000000003f70 0x000f0010 _mh_execute_header
[    2]      2   X Code            0x0000000100003f70                    0x0000000000000014 0x000f0000 main
[    3]      3     Trampoline      0x0000000100003f84                    0x0000000000000006 0x00010100 puts
[    4]      4   X Undefined       0x0000000000000000                    0x0000000000000000 0x00010100 dyld_stub_binder

callq  0x100003f84               ; symbol stub for: puts

Looks like you found the underlying issue in https://reviews.llvm.org/D116217. Thanks for finding this issue!

lldb/include/lldb/Symbol/ObjectFile.h

protected:
   /// \param[in] new_arch
   ///     The architecture this module will be set to.
   ///
   /// \return
   ///     Returns \b true if the architecture was changed, \b
   ///     false otherwise.
   bool SetModulesArchitecture(const ArchSpec &new_arch);
 
-  ConstString GetNextSyntheticSymbolName();
-
   static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size,
                                         uint64_t Offset);
 
 private:
   ObjectFile(const ObjectFile &) = delete;
   const ObjectFile &operator=(const ObjectFile &) = delete;
 };
 

lldb/include/lldb/Symbol/Symbol.h

 //===-- Symbol.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_SYMBOL_H
 #define LLDB_SYMBOL_SYMBOL_H
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class Symbol : public SymbolContextScope {
public:
 
   ConstString GetDisplayName() const;
 
   uint32_t GetID() const { return m_uid; }
 
   lldb::LanguageType GetLanguage() const {
     // TODO: See if there is a way to determine the language for a symbol
     // somehow, for now just return our best guess
-    return m_mangled.GuessLanguage();
+    return GetMangled().GuessLanguage();
   }
 
   void SetID(uint32_t uid) { m_uid = uid; }
 
-  Mangled &GetMangled() { return m_mangled; }
+  Mangled &GetMangled() {
+    SynthesizeNameIfNeeded();
+    return m_mangled;
+  }
 
-  const Mangled &GetMangled() const { return m_mangled; }
+  const Mangled &GetMangled() const {
+    SynthesizeNameIfNeeded();
+    return m_mangled;
+  }
 
   ConstString GetReExportedSymbolName() const;
 
   FileSpec GetReExportedSymbolSharedLibrary() const;
 
   void SetReExportedSymbolName(ConstString name);
 
   bool SetReExportedSymbolSharedLibrary(const FileSpec &fspec);
public:
 
   void SetFlags(uint32_t flags) { m_flags = flags; }
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level,
                       Target *target) const;
 
   bool IsSynthetic() const { return m_is_synthetic; }
 
+  bool IsSyntheticWithAutoGeneratedName() const;
+
   void SetIsSynthetic(bool b) { m_is_synthetic = b; }
 
   bool GetSizeIsSynthesized() const { return m_size_is_synthesized; }
 
   void SetSizeIsSynthesized(bool b) { m_size_is_synthesized = b; }
 
   bool IsDebug() const { return m_is_debug; }
 
   void SetDebug(bool b) { m_is_debug = b; }
 
   bool IsExternal() const { return m_is_external; }
 
   void SetExternal(bool b) { m_is_external = b; }
 
   bool IsTrampoline() const;
 
   bool IsIndirect() const;
-  
   bool IsWeak() const { return m_is_weak; }
-  
   void SetIsWeak (bool b) { m_is_weak = b; }
 
   bool GetByteSizeIsValid() const { return m_size_is_valid; }
 
   lldb::addr_t GetByteSize() const;
 
   void SetByteSize(lldb::addr_t size) {
     m_size_is_valid = size > 0;
lldb::DisassemblerSP GetInstructions(const ExecutionContext &exe_ctx,
                                        const char *flavor,
                                        bool prefer_file_cache);
 
   bool GetDisassembly(const ExecutionContext &exe_ctx, const char *flavor,
                       bool prefer_file_cache, Stream &strm);
 
   bool ContainsFileAddress(lldb::addr_t file_addr) const;
 
+  static llvm::StringRef GetSyntheticSymbolPrefix() {
+    return "___lldb_unnamed_symbol";
+  }
+
 protected:
   // This is the internal guts of ResolveReExportedSymbol, it assumes
   // reexport_name is not null, and that module_spec is valid.  We track the
   // modules we've already seen to make sure we don't get caught in a cycle.
 
   Symbol *ResolveReExportedSymbolInModuleSpec(
       Target &target, ConstString &reexport_name,
       lldb_private::ModuleSpec &module_spec,
       lldb_private::ModuleList &seen_modules) const;
 
+  void SynthesizeNameIfNeeded() const;
+
   uint32_t m_uid =
       UINT32_MAX;           // User ID (usually the original symbol table index)
   uint16_t m_type_data = 0; // data specific to m_type
   uint16_t m_type_data_resolved : 1, // True if the data in m_type_data has
                                      // already been calculated
       m_is_synthetic : 1, // non-zero if this symbol is not actually in the
                           // symbol table, but synthesized from other info in
                           // the object file.
uint16_t m_type_data_resolved : 1, // True if the data in m_type_data has
       m_demangled_is_synthesized : 1, // The demangled name was created should
                                       // not be used for expressions or other
                                       // lookups
       m_contains_linker_annotations : 1, // The symbol name contains linker
                                          // annotations, which are optional when
                                          // doing name lookups
       m_is_weak : 1,
       m_type : 6;            // Values from the lldb::SymbolType enum.
-  Mangled m_mangled;         // uniqued symbol name/mangled name pair
+  mutable Mangled m_mangled; // uniqued symbol name/mangled name pair
   AddressRange m_addr_range; // Contains the value, or the section offset
                              // address when the value is an address in a
                              // section, and the size (if any)
   uint32_t m_flags = 0; // A copy of the flags from the original symbol table,
                         // the ObjectFile plug-in can interpret these
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_SYMBOL_H

lldb/include/lldb/Symbol/Symtab.h

 //===-- Symtab.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_SYMTAB_H
 #define LLDB_SYMBOL_SYMTAB_H
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
 #include <map>
 #include <mutex>
 #include <vector>
 
 namespace lldb_private {
case eVisibilityExtern:
       return m_symbols[idx].IsExternal();
 
     case eVisibilityPrivate:
       return !m_symbols[idx].IsExternal();
     }
     return false;
   }
 
+  /// A helper function that looks up full function names.
+  ///
+  /// We generate unique names for synthetic symbols so that users can look
+  /// them up by name when needed. But because doing so is uncommon in normal
+  /// debugger use, we trade off some performance at lookup time for faster
+  /// symbol table building by detecting these symbols and generating their
+  /// names lazily, rather than adding them to the normal symbol indexes. This
+  /// function does the job of first consulting the name indexes, and if that
+  /// fails it extracts the information it needs from the synthetic name and
+  /// locates the symbol.
+  ///
+  /// @param[in] symbol_name The symbol name to search for.
+  ///
+  /// @param[out] indexes The vector if symbol indexes to update with results.
+  ///
+  /// @returns The number of indexes added to the index vector. Zero if no
+  /// matches were found.
+  uint32_t GetNameIndexes(ConstString symbol_name,
+                          std::vector<uint32_t> &indexes);
+
   void SymbolIndicesToSymbolContextList(std::vector<uint32_t> &symbol_indexes,
                                         SymbolContextList &sc_list);
 
   void RegisterMangledNameEntry(
       uint32_t value, std::set<const char *> &class_contexts,
       std::vector<std::pair<NameToIndexMap::Entry, const char *>> &backlog,
       RichManglingContext &rmc);
 

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) {
             eSectionTypeELFSymbolTable, true);
         if (module_section_sp)
           unified_section_list.ReplaceSection(module_section_sp->GetID(),
                                               symtab_section_sp);
         else
           unified_section_list.AddSection(symtab_section_sp);
       }
     }
-  }  
+  }
 }
 
 std::shared_ptr<ObjectFileELF> ObjectFileELF::GetGnuDebugDataObjectFile() {
   if (m_gnu_debug_data_object_file != nullptr)
     return m_gnu_debug_data_object_file;
 
   SectionSP section =
       GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"));
if (CalculateType() == eTypeExecutable) {
       ArchSpec arch = GetArchitecture();
       auto entry_point_addr = GetEntryPointAddress();
       bool is_valid_entry_point =
           entry_point_addr.IsValid() && entry_point_addr.IsSectionOffset();
       addr_t entry_point_file_addr = entry_point_addr.GetFileAddress();
       if (is_valid_entry_point && !m_symtab_up->FindSymbolContainingFileAddress(
                                       entry_point_file_addr)) {
         uint64_t symbol_id = m_symtab_up->GetNumSymbols();
-        Symbol symbol(symbol_id,
-                      GetNextSyntheticSymbolName().GetCString(), // Symbol name.
-                      eSymbolTypeCode, // Type of this symbol.
-                      true,            // Is this globally visible?
-                      false,           // Is this symbol debug info?
-                      false,           // Is this symbol a trampoline?
-                      true,            // Is this symbol artificial?
-                      entry_point_addr.GetSection(), // Section where this
-                                                     // symbol is defined.
-                      0,     // Offset in section or symbol value.
-                      0,     // Size.
-                      false, // Size is valid.
-                      false, // Contains linker annotations?
-                      0);    // Symbol flags.
-        m_symtab_up->AddSymbol(symbol);
+        // Don't set the name for any synthetic symbols, the Symbol
+        // object will generate one if needed when the name is accessed
+        // via accessors.
+        SectionSP section_sp = entry_point_addr.GetSection();
+        Symbol symbol(
+            /*symID=*/symbol_id,
+            /*name=*/llvm::StringRef(), // Name will be auto generated.
+            /*type=*/eSymbolTypeCode,
+            /*external=*/true,
+            /*is_debug=*/false,
+            /*is_trampoline=*/false,
+            /*is_artificial=*/true,
+            /*section_sp=*/section_sp,
+            /*offset=*/0,
+            /*size=*/0, // FDE can span multiple symbols so don't use its size.
+            /*size_is_valid=*/false,
+            /*contains_linker_annotations=*/false,
+            /*flags=*/0);
         // When the entry point is arm thumb we need to explicitly set its
         // class address to reflect that. This is important because expression
         // evaluation relies on correctly setting a breakpoint at this
         // address.
         if (arch.GetMachine() == llvm::Triple::arm &&
-            (entry_point_file_addr & 1))
+            (entry_point_file_addr & 1)) {
+          symbol.GetAddressRef().SetOffset(entry_point_addr.GetOffset() ^ 1);
           m_address_class_map[entry_point_file_addr ^ 1] =
               AddressClass::eCodeAlternateISA;
-        else
+        } else {
           m_address_class_map[entry_point_file_addr] = AddressClass::eCode;
         }
+        m_symtab_up->AddSymbol(symbol);
+      }
     }
 
     m_symtab_up->CalculateSymbolSizes();
   }
 
   return m_symtab_up.get();
 }
 
if (symbol) {
         symbol->SetByteSize(size);
         symbol->SetSizeIsSynthesized(true);
       }
     } else {
       SectionSP section_sp =
           section_list->FindSectionContainingFileAddress(file_addr);
       if (section_sp) {
         addr_t offset = file_addr - section_sp->GetFileAddress();
-        const char *symbol_name = GetNextSyntheticSymbolName().GetCString();
         uint64_t symbol_id = ++last_symbol_id;
+        // Don't set the name for any synthetic symbols, the Symbol
+        // object will generate one if needed when the name is accessed
+        // via accessors.
         Symbol eh_symbol(
-            symbol_id,       // Symbol table index.
-            symbol_name,     // Symbol name.
-            eSymbolTypeCode, // Type of this symbol.
-            true,            // Is this globally visible?
-            false,           // Is this symbol debug info?
-            false,           // Is this symbol a trampoline?
-            true,            // Is this symbol artificial?
-            section_sp,      // Section in which this symbol is defined or null.
-            offset,          // Offset in section or symbol value.
-            0,     // Size:          Don't specify the size as an FDE can
-            false, // Size is valid: cover multiple symbols.
-            false, // Contains linker annotations?
-            0);    // Symbol flags.
+            /*symID=*/symbol_id,
+            /*name=*/llvm::StringRef(), // Name will be auto generated.
+            /*type=*/eSymbolTypeCode,
+            /*external=*/true,
+            /*is_debug=*/false,
+            /*is_trampoline=*/false,
+            /*is_artificial=*/true,
+            /*section_sp=*/section_sp,
+            /*offset=*/offset,
+            /*size=*/0, // FDE can span multiple symbols so don't use its size.
+            /*size_is_valid=*/false,
+            /*contains_linker_annotations=*/false,
+            /*flags=*/0);
         new_symbols.push_back(eh_symbol);
       }
     }
     return true;
   });
 
   for (const Symbol &s : new_symbols)
     symbol_table->AddSymbol(s);

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

 //===-- ObjectFileMachO.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringRef.h"
 
 #include "Plugins/Process/Utility/RegisterContextDarwin_arm.h"
 #include "Plugins/Process/Utility/RegisterContextDarwin_arm64.h"
 #include "Plugins/Process/Utility/RegisterContextDarwin_i386.h"
 #include "Plugins/Process/Utility/RegisterContextDarwin_x86_64.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
if (num_synthetic_function_symbols > 0) {
                   next_symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
                 symbol_byte_size = std::min<lldb::addr_t>(
                     next_symbol_file_addr - symbol_file_addr,
                     section_end_file_addr - symbol_file_addr);
               } else {
                 symbol_byte_size = section_end_file_addr - symbol_file_addr;
               }
               sym[sym_idx].SetID(synthetic_sym_id++);
-              sym[sym_idx].GetMangled().SetDemangledName(
-                  GetNextSyntheticSymbolName());
+              // Don't set the name for any synthetic symbols, the Symbol
+              // object will generate one if needed when the name is accessed
+              // via accessors.
+              sym[sym_idx].GetMangled().SetDemangledName(ConstString());
               sym[sym_idx].SetType(eSymbolTypeCode);
               sym[sym_idx].SetIsSynthetic(true);
               sym[sym_idx].GetAddressRef() = symbol_addr;
               add_symbol_addr(symbol_addr.GetFileAddress());
               if (symbol_flags)
                 sym[sym_idx].SetFlags(symbol_flags);
               if (symbol_byte_size)
                 sym[sym_idx].SetByteSize(symbol_byte_size);

lldb/source/Symbol/ObjectFile.cpp

if (!name.empty()) {
     } else if (name.startswith(".objc_class_name_")) {
       // ObjC v1
       return lldb::eSymbolTypeObjCClass;
     }
   }
   return symbol_type_hint;
 }
 
-ConstString ObjectFile::GetNextSyntheticSymbolName() {
-  llvm::SmallString<256> name;
-  llvm::raw_svector_ostream os(name);
-  ConstString file_name = GetModule()->GetFileSpec().GetFilename();
-  ++m_synthetic_symbol_idx;
-  os << "___lldb_unnamed_symbol" << m_synthetic_symbol_idx << "$$"
-     << file_name.GetStringRef();
-  return ConstString(os.str());
-}
-
 std::vector<ObjectFile::LoadableData>
 ObjectFile::GetLoadableData(Target &target) {
   std::vector<LoadableData> loadables;
   SectionList *section_list = GetSectionList();
   if (!section_list)
     return loadables;
   // Create a list of loadable data from loadable sections
   size_t section_count = section_list->GetNumSections(0);

lldb/source/Symbol/Symbol.cpp

 //===-- Symbol.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/Symbol.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Symtab.h"
Symbol::Symbol(uint32_t symID, const Mangled &mangled, SymbolType type,
                bool size_is_valid, bool contains_linker_annotations,
                uint32_t flags)
     : SymbolContextScope(), m_uid(symID), m_type_data(0),
       m_type_data_resolved(false), m_is_synthetic(is_artificial),
       m_is_debug(is_debug), m_is_external(external), m_size_is_sibling(false),
       m_size_is_synthesized(false),
       m_size_is_valid(size_is_valid || range.GetByteSize() > 0),
       m_demangled_is_synthesized(false),
-      m_contains_linker_annotations(contains_linker_annotations), 
-      m_is_weak(false), m_type(type), m_mangled(mangled), m_addr_range(range), 
+      m_contains_linker_annotations(contains_linker_annotations),
+      m_is_weak(false), m_type(type), m_mangled(mangled), m_addr_range(range),
       m_flags(flags) {}
 
 Symbol::Symbol(const Symbol &rhs)
     : SymbolContextScope(rhs), m_uid(rhs.m_uid), m_type_data(rhs.m_type_data),
       m_type_data_resolved(rhs.m_type_data_resolved),
       m_is_synthetic(rhs.m_is_synthetic), m_is_debug(rhs.m_is_debug),
       m_is_external(rhs.m_is_external),
       m_size_is_sibling(rhs.m_size_is_sibling), m_size_is_synthesized(false),
void Symbol::Clear() {
   m_addr_range.Clear();
 }
 
 bool Symbol::ValueIsAddress() const {
   return m_addr_range.GetBaseAddress().GetSection().get() != nullptr;
 }
 
 ConstString Symbol::GetDisplayName() const {
-  return m_mangled.GetDisplayDemangledName();
+  return GetMangled().GetDisplayDemangledName();
 }
 
 ConstString Symbol::GetReExportedSymbolName() const {
   if (m_type == eSymbolTypeReExported) {
     // For eSymbolTypeReExported, the "const char *" from a ConstString is used
     // as the offset in the address range base address. We can then make this
     // back into a string that is the re-exported name.
     intptr_t str_ptr = m_addr_range.GetBaseAddress().GetOffset();
void Symbol::GetDescription(Stream *s, lldb::DescriptionLevel level,
   } else {
     if (m_size_is_sibling)
       s->Printf(", sibling = %5" PRIu64,
                 m_addr_range.GetBaseAddress().GetOffset());
     else
       s->Printf(", value = 0x%16.16" PRIx64,
                 m_addr_range.GetBaseAddress().GetOffset());
   }
-  ConstString demangled = m_mangled.GetDemangledName();
+  ConstString demangled = GetMangled().GetDemangledName();
   if (demangled)
     s->Printf(", name=\"%s\"", demangled.AsCString());
   if (m_mangled.GetMangledName())
     s->Printf(", mangled=\"%s\"", m_mangled.GetMangledName().AsCString());
 }
 
 void Symbol::Dump(Stream *s, Target *target, uint32_t index,
                   Mangled::NamePreference name_preference) const {
   s->Printf("[%5u] %6u %c%c%c %-15s ", index, GetID(), m_is_debug ? 'D' : ' ',
             m_is_synthetic ? 'S' : ' ', m_is_external ? 'X' : ' ',
             GetTypeAsString());
 
   // Make sure the size of the symbol is up to date before dumping
   GetByteSize();
 
-  ConstString name = m_mangled.GetName(name_preference);
+  ConstString name = GetMangled().GetName(name_preference);
   if (ValueIsAddress()) {
     if (!m_addr_range.GetBaseAddress().Dump(s, nullptr,
                                             Address::DumpStyleFileAddress))
       s->Printf("%*s", 18, "");
 
     s->PutChar(' ');
 
     if (!m_addr_range.GetBaseAddress().Dump(s, target,
if (!m_type_data_resolved) {
       }
     }
     return m_type_data;
   }
   return 0;
 }
 
 bool Symbol::Compare(ConstString name, SymbolType type) const {
-  if (type == eSymbolTypeAny || m_type == type)
-    return m_mangled.GetMangledName() == name ||
-           m_mangled.GetDemangledName() == name;
+  if (type == eSymbolTypeAny || m_type == type) {
+    const Mangled &mangled = GetMangled();
+    return mangled.GetMangledName() == name ||
+           mangled.GetDemangledName() == name;
+  }
   return false;
 }
 
 #define ENUM_TO_CSTRING(x)                                                     \
   case eSymbolType##x:                                                         \
     return #x;
 
 const char *Symbol::GetTypeAsString() const {

 
 lldb::addr_t Symbol::GetLoadAddress(Target *target) const {
   if (ValueIsAddress())
     return GetAddressRef().GetLoadAddress(target);
   else
     return LLDB_INVALID_ADDRESS;
 }
 
-ConstString Symbol::GetName() const { return m_mangled.GetName(); }
+ConstString Symbol::GetName() const { return GetMangled().GetName(); }
 
 ConstString Symbol::GetNameNoArguments() const {
-  return m_mangled.GetName(Mangled::ePreferDemangledWithoutArguments);
+  return GetMangled().GetName(Mangled::ePreferDemangledWithoutArguments);
 }
 
 lldb::addr_t Symbol::ResolveCallableAddress(Target &target) const {
   if (GetType() == lldb::eSymbolTypeUndefined)
     return LLDB_INVALID_ADDRESS;
 
   Address func_so_addr;
 
if (disassembler_sp) {
     return true;
   }
   return false;
 }
 
 bool Symbol::ContainsFileAddress(lldb::addr_t file_addr) const {
   return m_addr_range.ContainsFileAddress(file_addr);
 }
+
+bool Symbol::IsSyntheticWithAutoGeneratedName() const {
+  if (!IsSynthetic())
+    return false;
+  if (!m_mangled)
+    return true;
+  ConstString demangled = m_mangled.GetDemangledName();
+  return demangled.GetStringRef().startswith(GetSyntheticSymbolPrefix());
+}
+
+void Symbol::SynthesizeNameIfNeeded() const {
+  if (m_is_synthetic && !m_mangled) {
+    // Synthetic symbol names don't mean anything, but they do uniquely
+    // identify individual symbols so we give them a unique name. The name
+    // starts with the synthetic symbol prefix, followed by a unique number.
+    // Typically the UserID of a real symbol is the symbol table index of the
+    // symbol in the object file's symbol table(s), so it will be the same
+    // every time you read in the object file. We want the same persistence for
+    // synthetic symbols so that users can identify them across multiple debug
+    // sessions, to understand crashes in those symbols and to reliably set
+    // breakpoints on them.
+    llvm::SmallString<256> name;
+    llvm::raw_svector_ostream os(name);
+    os << GetSyntheticSymbolPrefix() << GetID();
+    m_mangled.SetDemangledName(ConstString(os.str()));
+  }
+}

lldb/source/Symbol/Symtab.cpp

 //===-- Symtab.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <map>
 #include <set>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/RichManglingContext.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/RegularExpression.h"
if (!m_name_indexes_computed) {
     // for all entries during batch processing.
     RichManglingContext rmc;
     for (uint32_t value = 0; value < num_symbols; ++value) {
       Symbol *symbol = &m_symbols[value];
 
       // Don't let trampolines get into the lookup by name map If we ever need
       // the trampoline symbols to be searchable by name we can remove this and
       // then possibly add a new bool to any of the Symtab functions that
-      // lookup symbols by name to indicate if they want trampolines.
-      if (symbol->IsTrampoline())
+      // lookup symbols by name to indicate if they want trampolines. We also
+      // don't want any synthetic symbols with auto generated names in the
+      // name lookups.
+      if (symbol->IsTrampoline() || symbol->IsSyntheticWithAutoGeneratedName())
         continue;
 
       // If the symbol's name string matched a Mangled::ManglingScheme, it is
       // stored in the mangled field.
       Mangled &mangled = symbol->GetMangled();
       if (ConstString name = mangled.GetMangledName()) {
         name_to_index.Append(name, value);
 
void Symtab::SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
 
   // Remove any duplicates if requested
   if (remove_duplicates) {
     auto last = std::unique(indexes.begin(), indexes.end());
     indexes.erase(last, indexes.end());
   }
 }
 
+uint32_t Symtab::GetNameIndexes(ConstString symbol_name,
+                                std::vector<uint32_t> &indexes) {
+  auto &name_to_index = GetNameToSymbolIndexMap(lldb::eFunctionNameTypeNone);
+  const uint32_t count = name_to_index.GetValues(symbol_name, indexes);
+  if (count)
+    return count;
+  // Synthetic symbol names are not added to the name indexes, but they start
+  // with a prefix and end with a the symbol UserID. This allows users to find
+  // these symbols without having to add them to the name indexes. These
+  // queries will not happen very often since the names don't mean anything, so
+  // performance is not paramount in this case.
+  llvm::StringRef name = symbol_name.GetStringRef();
+  // String the synthetic prefix if the name starts with it.
+  if (!name.consume_front(Symbol::GetSyntheticSymbolPrefix()))
+    return 0; // Not a synthetic symbol name
+
+  // Extract the user ID from the symbol name
+  unsigned long long uid = 0;
+  if (getAsUnsignedInteger(name, /*Radix=*/10, uid))
+    return 0; // Failed to extract the user ID as an integer
+  Symbol *symbol = FindSymbolByID(uid);
+  if (symbol == nullptr)
+    return 0;
+  const uint32_t symbol_idx = GetIndexForSymbol(symbol);
+  if (symbol_idx == UINT32_MAX)
+    return 0;
+  indexes.push_back(symbol_idx);
+  return 1;
+}
+
 uint32_t Symtab::AppendSymbolIndexesWithName(ConstString symbol_name,
                                              std::vector<uint32_t> &indexes) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   LLDB_SCOPED_TIMER();
   if (symbol_name) {
     if (!m_name_indexes_computed)
       InitNameIndexes();
 
-    auto &name_to_index = GetNameToSymbolIndexMap(lldb::eFunctionNameTypeNone);
-    return name_to_index.GetValues(symbol_name, indexes);
+    return GetNameIndexes(symbol_name, indexes);
   }
   return 0;
 }
 
 uint32_t Symtab::AppendSymbolIndexesWithName(ConstString symbol_name,
                                              Debug symbol_debug_type,
                                              Visibility symbol_visibility,
                                              std::vector<uint32_t> &indexes) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   LLDB_SCOPED_TIMER();
   if (symbol_name) {
     const size_t old_size = indexes.size();
     if (!m_name_indexes_computed)
       InitNameIndexes();
 
-    auto &name_to_index = GetNameToSymbolIndexMap(lldb::eFunctionNameTypeNone);
     std::vector<uint32_t> all_name_indexes;
     const size_t name_match_count =
-        name_to_index.GetValues(symbol_name, all_name_indexes);
+        GetNameIndexes(symbol_name, all_name_indexes);
     for (size_t i = 0; i < name_match_count; ++i) {
       if (CheckSymbolAtIndex(all_name_indexes[i], symbol_debug_type,
                              symbol_visibility))
         indexes.push_back(all_name_indexes[i]);
     }
     return indexes.size() - old_size;
   }
   return 0;

lldb/test/Shell/ObjectFile/ELF/eh_frame-symbols.yaml

 # RUN: yaml2obj %s >%t
 # RUN: %lldb %t -o "image dump symtab" -b | FileCheck %s
 
 # CHECK: Index   UserID DSX Type            File Address/Value Load Address       Size               Flags      Name
 # CHECK: [    0]      1     SourceFile      0x0000000000000000                    0x0000000000000000 0x00000004 -
-# CHECK: [    1]      2  SX Code            0x0000000000201180                    0x0000000000000010 0x00000000 ___lldb_unnamed_symbol1$${{.*}}
-# CHECK: [    2]      3  SX Code            0x0000000000201190                    0x0000000000000006 0x00000000 ___lldb_unnamed_symbol2$${{.*}}
+# CHECK: [    1]      2  SX Code            0x0000000000201180                    0x0000000000000010 0x00000000 ___lldb_unnamed_symbol{{[0-9]*}}
+# CHECK: [    2]      3  SX Code            0x0000000000201190                    0x0000000000000006 0x00000000 ___lldb_unnamed_symbol{{[0-9]*}}
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:

lldb/test/Shell/SymbolFile/Breakpad/symtab.test

 # RUN: yaml2obj %S/Inputs/basic-elf.yaml -o %T/symtab.out
 # RUN: %lldb %T/symtab.out -o "target symbols add -s symtab.out %S/Inputs/symtab.syms" \
 # RUN:   -s %s | FileCheck %s
 
 # CHECK-LABEL: (lldb) image dump symtab symtab.out
 # CHECK: Symtab, file = {{.*}}symtab.out, num_symbols = 5:
 # CHECK: Index   UserID DSX Type            File Address/Value Load Address       Size               Flags      Name
-# CHECK: [    0]      0  SX Code            0x0000000000400000                    0x00000000000000b0 0x00000000 ___lldb_unnamed_symbol{{[0-9]*}}$$symtab.out
+# CHECK: [    0]      0  SX Code            0x0000000000400000                    0x00000000000000b0 0x00000000 ___lldb_unnamed_symbol{{[0-9]*}}
 # CHECK: [    1]      0   X Code            0x00000000004000b0                    0x000000000000000c 0x00000000 f1_func
 # CHECK: [    2]      0   X Code            0x00000000004000a0                    0x000000000000000d 0x00000000 func_only
 # CHECK: [    3]      0   X Code            0x00000000004000c0                    0x0000000000000010 0x00000000 f2
 # CHECK: [    4]      0   X Code            0x00000000004000d0                    0x0000000000000022 0x00000000 _start
 
 # CHECK-LABEL: (lldb) image lookup -a 0x4000b0 -v
 # CHECK: Address: symtab.out[0x00000000004000b0] (symtab.out.PT_LOAD[0]..text2 + 0)
 # CHECK: Symbol: id = {0x00000000}, range = [0x00000000004000b0-0x00000000004000bc), name="f1_func"