[lldb] Allow SymbolTable regex search functions to match mangled name

[augusto2112]

Summary

It may be useful to search symbol table entries by mangled instead
of demangled names. Add this optional functionality in the SymbolTable
functions.

[aprantl]

It sounds like it should be possible to test this with lldb-test?

[augusto2112]

@aprantl do you mean dumping this with lldb-test? I'm not seeing a way to do this. If you're thinking about symbols that reads the symbol file not the symbol table.

[labath]

Who sets this flag? How do you intend to use it?

lldb/include/lldb/Core/Module.h

267

Could this be Mangled::NamePreference instead of bool ?

[augusto2112]

In D130803#3690754, @labath wrote:

Who sets this flag? How do you intend to use it?

I need this change downstream to search for certain swift mangled names by querying Module::FindSymbolsMatchingRegExAndType. It seemed general enough that we might want this upstream.

lldb/include/lldb/Core/Module.h

267

Ok! Wasn't aware of that enum. I'll change that.

[augusto2112]

Added test and updated functions to use Mangled::NamePreference instead of a bool

[JDevlieghere]

lldb/test/Shell/Symtab/Inputs/t.yaml

60 ↗

(On Diff #449440)

You could make this slightly smaller by dropping the content of the __unwind_info and __eh_frame below.

[JDevlieghere]

LGTM

[augusto2112]

Removed unwind_info and eh_frame sections from test yaml file.

[labath]

In D130803#3691363, @augusto2112 wrote:

In D130803#3690754, @labath wrote:

Who sets this flag? How do you intend to use it?

I need this change downstream to search for certain swift mangled names by querying Module::FindSymbolsMatchingRegExAndType. It seemed general enough that we might want this upstream.

That's ok. The reason I was asking was because it affects the ways in which one can test that.

lldb/test/Shell/Symtab/Inputs/t.yaml

1 ↗

(On Diff #449483)

Use a more descriptive name for the file.

I'd also consider using an elf file for this test, simply because their yaml form is much more concise (and you can strip out pretty much everything except the symtab, and use an unlinked .o file as the template, and still have it work).

[augusto2112]

Updated test to use elf object file.

lldb/include/lldb/Core/Module.h

const Symbol *FindFirstSymbolWithNameAndType(
       ConstString name, lldb::SymbolType symbol_type = lldb::eSymbolTypeAny);
 
   void FindSymbolsWithNameAndType(ConstString name,
                                   lldb::SymbolType symbol_type,
                                   SymbolContextList &sc_list);
 
   void FindSymbolsMatchingRegExAndType(const RegularExpression &regex,
                                        lldb::SymbolType symbol_type,
-                                       SymbolContextList &sc_list);
+                                       SymbolContextList &sc_list,
+                                       bool match_against_demangled = false);
 
   /// Find a function symbols in the object file's symbol table.
   ///
   /// \param[in] name
   ///     The name of the symbol that we are looking for.
   ///
   /// \param[in] name_type_mask
   ///     A mask that has one or more bitwise OR'ed values from the

lldb/include/lldb/Symbol/Symtab.h

public:
   uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
                                               lldb::SymbolType symbol_type,
                                               std::vector<uint32_t> &matches);
   uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
                                               lldb::SymbolType symbol_type,
                                               Debug symbol_debug_type,
                                               Visibility symbol_visibility,
                                               std::vector<uint32_t> &matches);
-  uint32_t
-  AppendSymbolIndexesMatchingRegExAndType(const RegularExpression &regex,
-                                          lldb::SymbolType symbol_type,
-                                          std::vector<uint32_t> &indexes);
+  uint32_t AppendSymbolIndexesMatchingRegExAndType(
+      const RegularExpression &regex, lldb::SymbolType symbol_type,
+      std::vector<uint32_t> &indexes, bool match_against_demangled = false);
   uint32_t AppendSymbolIndexesMatchingRegExAndType(
       const RegularExpression &regex, lldb::SymbolType symbol_type,
       Debug symbol_debug_type, Visibility symbol_visibility,
-      std::vector<uint32_t> &indexes);
+      std::vector<uint32_t> &indexes, bool match_against_demangled = false);
   void FindAllSymbolsWithNameAndType(ConstString name,
                                      lldb::SymbolType symbol_type,
                                      std::vector<uint32_t> &symbol_indexes);
   void FindAllSymbolsWithNameAndType(ConstString name,
                                      lldb::SymbolType symbol_type,
                                      Debug symbol_debug_type,
                                      Visibility symbol_visibility,
                                      std::vector<uint32_t> &symbol_indexes);
-  void FindAllSymbolsMatchingRexExAndType(
-      const RegularExpression &regex, lldb::SymbolType symbol_type,
-      Debug symbol_debug_type, Visibility symbol_visibility,
-      std::vector<uint32_t> &symbol_indexes);
+  void FindAllSymbolsMatchingRexExAndType(const RegularExpression &regex,
+                                          lldb::SymbolType symbol_type,
+                                          Debug symbol_debug_type,
+                                          Visibility symbol_visibility,
+                                          std::vector<uint32_t> &symbol_indexes,
+                                          bool match_against_demangled = false);
   Symbol *FindFirstSymbolWithNameAndType(ConstString name,
                                          lldb::SymbolType symbol_type,
                                          Debug symbol_debug_type,
                                          Visibility symbol_visibility);
   Symbol *FindSymbolAtFileAddress(lldb::addr_t file_addr);
   Symbol *FindSymbolContainingFileAddress(lldb::addr_t file_addr);
   void ForEachSymbolContainingFileAddress(
       lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback);

lldb/source/Core/Module.cpp

if (Symtab *symtab = GetSymtab()) {
     std::vector<uint32_t> symbol_indexes;
     symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes);
     SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
   }
 }
 
 void Module::FindSymbolsMatchingRegExAndType(const RegularExpression &regex,
                                              SymbolType symbol_type,
-                                             SymbolContextList &sc_list) {
+                                             SymbolContextList &sc_list,
+                                             bool match_against_demangled) {
   // No need to protect this call using m_mutex all other method calls are
   // already thread safe.
   LLDB_SCOPED_TIMERF(
       "Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)",
       regex.GetText().str().c_str(), symbol_type);
   if (Symtab *symtab = GetSymtab()) {
     std::vector<uint32_t> symbol_indexes;
     symtab->FindAllSymbolsMatchingRexExAndType(
         regex, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny,
-        symbol_indexes);
+        symbol_indexes, match_against_demangled);
     SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
   }
 }
 
 void Module::PreloadSymbols() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   SymbolFile *sym_file = GetSymbolFile();
   if (!sym_file)

lldb/source/Symbol/Symtab.cpp

while (pos != indexes.end()) {
         pos = indexes.erase(pos);
     }
   }
   return indexes.size();
 }
 
 uint32_t Symtab::AppendSymbolIndexesMatchingRegExAndType(
     const RegularExpression &regexp, SymbolType symbol_type,
-    std::vector<uint32_t> &indexes) {
+    std::vector<uint32_t> &indexes, bool match_against_demangled) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   uint32_t prev_size = indexes.size();
   uint32_t sym_end = m_symbols.size();
 
   for (uint32_t i = 0; i < sym_end; i++) {
     if (symbol_type == eSymbolTypeAny ||
         m_symbols[i].GetType() == symbol_type) {
-      const char *name = m_symbols[i].GetName().AsCString();
+      const char *name =
+          match_against_demangled
+              ? m_symbols[i].GetMangled().GetMangledName().AsCString()
+              : m_symbols[i].GetName().AsCString();
       if (name) {
         if (regexp.Execute(name))
           indexes.push_back(i);
       }
     }
   }
   return indexes.size() - prev_size;
 }
 
 uint32_t Symtab::AppendSymbolIndexesMatchingRegExAndType(
     const RegularExpression &regexp, SymbolType symbol_type,
     Debug symbol_debug_type, Visibility symbol_visibility,
-    std::vector<uint32_t> &indexes) {
+    std::vector<uint32_t> &indexes, bool match_against_demangled) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   uint32_t prev_size = indexes.size();
   uint32_t sym_end = m_symbols.size();
 
   for (uint32_t i = 0; i < sym_end; i++) {
     if (symbol_type == eSymbolTypeAny ||
         m_symbols[i].GetType() == symbol_type) {
       if (!CheckSymbolAtIndex(i, symbol_debug_type, symbol_visibility))
         continue;
 
-      const char *name = m_symbols[i].GetName().AsCString();
+      const char *name =
+          match_against_demangled
+              ? m_symbols[i].GetMangled().GetMangledName().AsCString()
+              : m_symbols[i].GetName().AsCString();
       if (name) {
         if (regexp.Execute(name))
           indexes.push_back(i);
       }
     }
   }
   return indexes.size() - prev_size;
 }
if (name) {
     AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_debug_type,
                                        symbol_visibility, symbol_indexes);
   }
 }
 
 void Symtab::FindAllSymbolsMatchingRexExAndType(
     const RegularExpression &regex, SymbolType symbol_type,
     Debug symbol_debug_type, Visibility symbol_visibility,
-    std::vector<uint32_t> &symbol_indexes) {
+    std::vector<uint32_t> &symbol_indexes, bool match_against_demangled) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   AppendSymbolIndexesMatchingRegExAndType(regex, symbol_type, symbol_debug_type,
-                                          symbol_visibility, symbol_indexes);
+                                          symbol_visibility, symbol_indexes,
+                                          match_against_demangled);
 }
 
 Symbol *Symtab::FindFirstSymbolWithNameAndType(ConstString name,
                                                SymbolType symbol_type,
                                                Debug symbol_debug_type,
                                                Visibility symbol_visibility) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   LLDB_SCOPED_TIMER();