[LLDB] Add color to output text when searching for symbols

[varunkumare99]

Summary

added support for colored output for the commands

1. image lookup -r -s <func-regex>
2. image lookup -r -n <func-regex>

For option (1) lookupSymbolInModule(CommandObjectTarget.cpp) is called. We first match the regex against the symbol names. Then update the
name(Symbol Demangled name) with colored matches. So that the symbol when displayed down the line(in SymbolContext.DumpStopContext) is printed
with colored text. Once the symbols are displayed, we restore the original symbols names.(Symbol Demangled name)

For option (2) lookupfunctionInModule(CommandObjectTarget.cpp) is called. As the symbol names are accessed in Module.cpp we repeat the
above process in it.

[labath]

This is definitely not a good way to implement this functionality. There's no telling who else might be accessing the symbols while their names are being changed.

The colouration should be implemented inside the dumping function, without modifying the state of the debugger. I realize that's not currently easy to do, but that's not a reason to do this. It's possible the dumping machinery needs to be refactored to support this kind of customized colouration.

[DavidSpickett]

I agree that this change names - print - restore names is going to cause problems. Pavel is right that this should happen in some dump function somewhere.

But, assuming what you've got works to an extent, you should add some testing first. That will allow you to refactor with less risk. You'll be able to reuse a lot of the tests later, so it's not wasted effort and it'll flush out some corner cases you haven't thought of.

For how to test this I would look to the other commands that have colour (frame was one I think) and anything interacting with the colour settings.
(if you want a cheeky way to find the tests, delete some of the colouring code and run the test suite - whatever fails is going to be interesting to you)

lldb/source/Commands/CommandObjectTarget.cpp

1514

Doesn't seem like you need to enumerate them, so this could be:

for (const auto &p : positions)
   if (pos >= ....)
       return true;
return false;

(https://en.cppreference.com/w/cpp/language/range-for)

Or std::find(..., <lambda>) != positions.end() but same thing really.

Basically prefer iterators unless i is needed for something other than indexing.

If you do need the index but don't want the hassle of handling it yourself, there is an llvm::enumerate in llvm/include/llvm/ADT/STLExtras.h which acts like Python's enumerate.

[DavidSpickett]

And if it helps to refactor in parent patches to make this change easier, go for it. Maybe you add generic colouring support to something, then the last patch hooks it up to the symbol lookup, something along those lines.

[varunkumare99]

In D136462#3878682, @labath wrote:

This is definitely not a good way to implement this functionality. There's no telling who else might be accessing the symbols while their names are being changed.

The colouration should be implemented inside the dumping function, without modifying the state of the debugger. I realize that's not currently easy to do, but that's not a reason to do this. It's possible the dumping machinery needs to be refactored to support this kind of customized colouration.

thank you for the feedback. I will try adding colouration inside a dumping function.

[varunkumare99]

In D136462#3878895, @DavidSpickett wrote:

I agree that this change names - print - restore names is going to cause problems. Pavel is right that this should happen in some dump function somewhere.

But, assuming what you've got works to an extent, you should add some testing first. That will allow you to refactor with less risk. You'll be able to reuse a lot of the tests later, so it's not wasted effort and it'll flush out some corner cases you haven't thought of.

Thanks. I will start out with adding some testing first. Then look into adding colouration in dump functions.

lldb/include/lldb/Core/Module.h

public:
   ///
   /// \param[out] sc_list
   ///     A symbol context list that gets filled in with all of the
   ///     matches.
   void FindFunctions(const RegularExpression &regex,
                      const ModuleFunctionSearchOptions &options,
                      SymbolContextList &sc_list);
 
+  /// Find functions by name, save their orignal names.
+  ///
+  /// If the function is an inlined function, it will have a block,
+  /// representing the inlined function, and the function will be the
+  /// containing function.  If it is not inlined, then the block will be NULL.
+  ///
+  /// \param[in] regex
+  ///     A regular expression to use when matching the name and modify the name
+  ///     with the colored match.
+  ///
+  /// \param[out] sc_list
+  ///     A symbol context list that gets filled in with all of the
+  ///     matches.
+  /// \param[out] origNames
+  //      A vector that gets filled in with all the orignal symbol names.
+
+  void FindFunctionsAndSaveNames(
+      const RegularExpression &regex,
+      const ModuleFunctionSearchOptions &options, SymbolContextList &sc_list,
+      llvm::SmallVector<std::pair<int, llvm::StringRef>> &origNames);
+
+  /// Restore back the original function names.
+  ///
+  /// \param[in] origNames
+  ///     A vector of orignal names of symbols.
+  ///
+  void RestoreOriginalFunctionNames(
+      llvm::SmallVector<std::pair<int, llvm::StringRef>> &origNames);
+
+  /// Helper function used by FindFunctionsAndSaveNames
+  /// \param[in] pos
+  /// current index of symbol name character
+  /// \param[i] positions
+  /// A vector of ranges over the symbol name, where it needs to be colored
+  static bool isColor(size_t pos,
+                      llvm::SmallVector<std::pair<size_t, size_t>> &positions);
+
   /// Find addresses by file/line
   ///
   /// \param[in] target_sp
   ///     The target the addresses are desired for.
   ///
   /// \param[in] file
   ///     Source file to locate.
   ///

lldb/include/lldb/Symbol/Symbol.h

if (ValueIsAddress()) {
       return m_addr_range.GetBaseAddress().GetOffset();
     }
   }
 
   lldb::addr_t ResolveCallableAddress(Target &target) const;
 
   ConstString GetName() const;
 
+  void SetName(llvm::StringRef name);
+
   ConstString GetNameNoArguments() const;
 
   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

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 AppendSymbolIndexesMatchingRegExWithMatchesAndType(
+      Stream &strm, const RegularExpression &regex,
+      lldb::SymbolType symbol_type, std::vector<uint32_t> &indexes,
+      llvm::SmallVector<
+          std::pair<const char *, llvm::SmallVector<llvm::StringRef>>>
+          &allMatches,
+      Mangled::NamePreference name_preference =
+          Mangled::ePreferDemangled) const;
   uint32_t AppendSymbolIndexesMatchingRegExAndType(
       const RegularExpression &regex, lldb::SymbolType symbol_type,
       std::vector<uint32_t> &indexes,
       Mangled::NamePreference name_preference = Mangled::ePreferDemangled);
+  uint32_t AppendSymbolIndexesMatchingRegExWithMatchesAndType(
+      const RegularExpression &regex, lldb::SymbolType symbol_type,
+      Debug symbol_debug_type, Visibility symbol_visibility,
+      std::vector<uint32_t> &indexes,
+      llvm::SmallVector<
+          std::pair<const char *, llvm::SmallVector<llvm::StringRef>>>
+          &allMatches,
+      Mangled::NamePreference name_preference =
+          Mangled::NamePreference::ePreferDemangled);
   uint32_t AppendSymbolIndexesMatchingRegExAndType(
       const RegularExpression &regex, lldb::SymbolType symbol_type,
       Debug symbol_debug_type, Visibility symbol_visibility,
       std::vector<uint32_t> &indexes,
       Mangled::NamePreference name_preference =
           Mangled::NamePreference::ePreferDemangled);
   void FindAllSymbolsWithNameAndType(ConstString name,
                                      lldb::SymbolType symbol_type,

lldb/source/Commands/CommandObjectTarget.cpp

 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
+#include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-private-enumerations.h"
 
 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatAdapters.h"
 
-
 using namespace lldb;
 using namespace lldb_private;
 
 static void DumpTargetInfo(uint32_t target_idx, Target *target,
                            const char *prefix_cstr,
                            bool show_stopped_process_status, Stream &strm) {
   const ArchSpec &target_arch = target->GetArchitecture();
 
if (module) {
     //        }
     //        strm.IndentLess();
     return true;
   }
 
   return false;
 }
 
+static bool isColor(size_t pos,
+                    llvm::SmallVector<std::pair<size_t, size_t>> &positions) {
+  for (size_t i = 0; i < positions.size(); ++i) {
+    if (pos >= positions[i].first && pos <= positions[i].second) {
+      return true;
+    }
+  }
+  return false;
+}
+
 static uint32_t LookupSymbolInModule(CommandInterpreter &interpreter,
                                      Stream &strm, Module *module,
                                      const char *name, bool name_is_regex,
                                      bool verbose, bool all_ranges) {
   if (!module)
     return 0;
 
   Symtab *symtab = module->GetSymtab();
   if (!symtab)
     return 0;
 
   SymbolContext sc;
   std::vector<uint32_t> match_indexes;
   ConstString symbol_name(name);
   uint32_t num_matches = 0;
+  llvm::SmallVector<std::pair<const char *, llvm::SmallVector<llvm::StringRef>>>
+      allMatches;
+
   if (name_is_regex) {
     RegularExpression name_regexp(symbol_name.GetStringRef());
-    num_matches = symtab->AppendSymbolIndexesMatchingRegExAndType(
-        name_regexp, eSymbolTypeAny, match_indexes);
+    num_matches = symtab->AppendSymbolIndexesMatchingRegExWithMatchesAndType(
+        strm, name_regexp, eSymbolTypeAny, match_indexes, allMatches);
   } else {
     num_matches =
         symtab->AppendSymbolIndexesWithName(symbol_name, match_indexes);
   }
 
   if (num_matches > 0) {
+    std::vector<std::pair<int, llvm::StringRef>> origNames;
     strm.Indent();
     strm.Printf("%u symbols match %s'%s' in ", num_matches,
                 name_is_regex ? "the regular expression " : "", name);
     DumpFullpath(strm, &module->GetFileSpec(), 0);
     strm.PutCString(":\n");
     strm.IndentMore();
     for (uint32_t i = 0; i < num_matches; ++i) {
       Symbol *symbol = symtab->SymbolAtIndex(match_indexes[i]);
+
+      // save original symbol names
+      origNames.push_back(std::make_pair(
+          match_indexes[i], symbol->GetDisplayName().GetStringRef()));
+
+      // find the positions of substring matches in symbol name
+      llvm::SmallVector<std::pair<size_t, size_t>> positions;
+      for (size_t j = 0; j < allMatches[i].second.size(); ++j) {
+        size_t pos = symbol->GetDisplayName().GetStringRef().find(
+            allMatches[i].second[j]);
+        if (pos != std::string::npos) {
+          positions.push_back(
+              std::make_pair(pos, pos + allMatches[i].second[j].size() - 1));
+        }
+      }
+
+      llvm::StringRef displayName = symbol->GetDisplayName().GetCString();
+      std::string coloredName;
+      for (size_t j = 0; j < symbol->GetDisplayName().GetStringRef().size();
+           ++j) {
+        if (isColor(j, positions)) {
+          coloredName += ANSI_ESCAPE1(ANSI_FG_COLOR_RED);
+          coloredName += displayName[j];
+          coloredName += ANSI_ESCAPE1(ANSI_CTRL_NORMAL);
+        } else
+          coloredName += displayName[j];
+      }
+      // set colored name
+      symbol->SetName(llvm::StringRef(coloredName));
+
       if (symbol) {
         if (symbol->ValueIsAddress()) {
           DumpAddress(
               interpreter.GetExecutionContext().GetBestExecutionContextScope(),
               symbol->GetAddressRef(), verbose, all_ranges, strm);
           strm.EOL();
         } else {
           strm.IndentMore();
           strm.Indent("    Name: ");
           strm.PutCString(symbol->GetDisplayName().GetStringRef());
           strm.EOL();
+
           strm.Indent("    Value: ");
           strm.Printf("0x%16.16" PRIx64 "\n", symbol->GetRawValue());
           if (symbol->GetByteSizeIsValid()) {
             strm.Indent("    Size: ");
             strm.Printf("0x%16.16" PRIx64 "\n", symbol->GetByteSize());
           }
           strm.IndentLess();
         }
       }
     }
     strm.IndentLess();
+    // set back to original names
+    for (size_t i = 0; i < origNames.size(); ++i) {
+      symtab->SymbolAtIndex(origNames[i].first)->SetName(origNames[i].second);
+    }
   }
   return num_matches;
 }
 
 static void DumpSymbolContextList(ExecutionContextScope *exe_scope,
                                   Stream &strm, SymbolContextList &sc_list,
                                   bool verbose, bool all_ranges) {
   strm.IndentMore();
 
   const uint32_t num_matches = sc_list.GetSize();
 
   for (uint32_t i = 0; i < num_matches; ++i) {
     SymbolContext sc;
     if (sc_list.GetContextAtIndex(i, sc)) {
       AddressRange range;
 
       sc.GetAddressRange(eSymbolContextEverything, 0, true, range);
-
       DumpAddress(exe_scope, range.GetBaseAddress(), verbose, all_ranges, strm);
     }
   }
   strm.IndentLess();
 }
 
 static size_t LookupFunctionInModule(CommandInterpreter &interpreter,
                                      Stream &strm, Module *module,
                                      const char *name, bool name_is_regex,
                                      const ModuleFunctionSearchOptions &options,
                                      bool verbose, bool all_ranges) {
   if (module && name && name[0]) {
+    llvm::SmallVector<std::pair<int, llvm::StringRef>> origNames;
     SymbolContextList sc_list;
     size_t num_matches = 0;
     if (name_is_regex) {
       RegularExpression function_name_regex((llvm::StringRef(name)));
-      module->FindFunctions(function_name_regex, options, sc_list);
+      module->FindFunctionsAndSaveNames(function_name_regex, options, sc_list,
+                                        origNames);
+
     } else {
       ConstString function_name(name);
       module->FindFunctions(function_name, CompilerDeclContext(),
                             eFunctionNameTypeAuto, options, sc_list);
     }
     num_matches = sc_list.GetSize();
     if (num_matches) {
       strm.Indent();
       strm.Printf("%" PRIu64 " match%s found in ", (uint64_t)num_matches,
                   num_matches > 1 ? "es" : "");
       DumpFullpath(strm, &module->GetFileSpec(), 0);
       strm.PutCString(":\n");
       DumpSymbolContextList(
           interpreter.GetExecutionContext().GetBestExecutionContextScope(),
           strm, sc_list, verbose, all_ranges);
+      module->RestoreOriginalFunctionNames(origNames);
     }
     return num_matches;
   }
   return 0;
 }
 
 static size_t LookupTypeInModule(Target *target,
                                  CommandInterpreter &interpreter, Stream &strm,

lldb/source/Core/Module.cpp

 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
void Module::FindFunctions(ConstString name,
   FindFunctions(lookup_info, parent_decl_ctx, options, sc_list);
   if (name_type_mask & eFunctionNameTypeAuto) {
     const size_t new_size = sc_list.GetSize();
     if (old_size < new_size)
       lookup_info.Prune(sc_list, old_size);
   }
 }
 
+bool Module::isColor(size_t pos,
+                     llvm::SmallVector<std::pair<size_t, size_t>> &positions) {
+  for (size_t i = 0; i < positions.size(); ++i) {
+    if (pos >= positions[i].first && pos <= positions[i].second) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void Module::RestoreOriginalFunctionNames(
+    llvm::SmallVector<std::pair<int, llvm::StringRef>> &origNames) {
+  if (SymbolFile *symbols = GetSymbolFile()) {
+    Symtab *symtab = symbols->GetSymtab();
+    if (symtab) {
+      for (size_t i = 0; i < origNames.size(); ++i) {
+        symtab->SymbolAtIndex(origNames[i].first)->SetName(origNames[i].second);
+      }
+    }
+  }
+}
+
+void Module::FindFunctionsAndSaveNames(
+    const RegularExpression &regex, const ModuleFunctionSearchOptions &options,
+    SymbolContextList &sc_list,
+    llvm::SmallVector<std::pair<int, llvm::StringRef>> &origNames) {
+  const size_t start_size = sc_list.GetSize();
+
+  if (SymbolFile *symbols = GetSymbolFile()) {
+    symbols->FindFunctions(regex, options.include_inlines, sc_list);
+
+    // Now check our symbol table for symbols that are code symbols if
+    // requested
+    if (options.include_symbols) {
+      Symtab *symtab = symbols->GetSymtab();
+      if (symtab) {
+        std::vector<uint32_t> symbol_indexes;
+        llvm::SmallVector<
+            std::pair<const char *, llvm::SmallVector<llvm::StringRef>>>
+            allMatches;
+        symtab->AppendSymbolIndexesMatchingRegExWithMatchesAndType(
+            regex, eSymbolTypeAny, Symtab::eDebugAny, Symtab::eVisibilityAny,
+            symbol_indexes, allMatches);
+        const size_t num_matches = symbol_indexes.size();
+        if (num_matches) {
+          for (uint32_t i = 0; i < num_matches; ++i) {
+            Symbol *symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
+            // save original symbol name
+            origNames.push_back(std::make_pair(
+                symbol_indexes[i], symbol->GetDisplayName().GetStringRef()));
+
+            // find the positions of substring matches in symbol name
+            llvm::SmallVector<std::pair<size_t, size_t>> positions;
+            for (size_t j = 0; j < allMatches[i].second.size(); ++j) {
+              size_t pos = symbol->GetDisplayName().GetStringRef().find(
+                  allMatches[i].second[j]);
+              if (pos != std::string::npos) {
+                positions.push_back(std::make_pair(
+                    pos, pos + allMatches[i].second[j].size() - 1));
+              }
+            }
+
+            llvm::StringRef displayName = symbol->GetDisplayName().GetCString();
+            std::string coloredName;
+            for (size_t j = 0;
+                 j < symbol->GetDisplayName().GetStringRef().size(); ++j) {
+              if (isColor(j, positions)) {
+                coloredName += ANSI_ESCAPE1(ANSI_FG_COLOR_RED);
+                coloredName += displayName[j];
+                coloredName += ANSI_ESCAPE1(ANSI_CTRL_NORMAL);
+              } else
+                coloredName += displayName[j];
+            }
+            // set colored name
+            symbol->SetName(llvm::StringRef(coloredName));
+          }
+        }
+        if (num_matches) {
+          SymbolContext sc(this);
+          const size_t end_functions_added_index = sc_list.GetSize();
+          size_t num_functions_added_to_sc_list =
+              end_functions_added_index - start_size;
+          if (num_functions_added_to_sc_list == 0) {
+            // No functions were added, just symbols, so we can just append
+            // them
+            for (size_t i = 0; i < num_matches; ++i) {
+              sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
+              SymbolType sym_type = sc.symbol->GetType();
+              if (sc.symbol && (sym_type == eSymbolTypeCode ||
+                                sym_type == eSymbolTypeResolver))
+                sc_list.Append(sc);
+            }
+          } else {
+            typedef std::map<lldb::addr_t, uint32_t> FileAddrToIndexMap;
+            FileAddrToIndexMap file_addr_to_index;
+            for (size_t i = start_size; i < end_functions_added_index; ++i) {
+              const SymbolContext &sc = sc_list[i];
+              if (sc.block)
+                continue;
+              file_addr_to_index[sc.function->GetAddressRange()
+                                     .GetBaseAddress()
+                                     .GetFileAddress()] = i;
+            }
+
+            FileAddrToIndexMap::const_iterator end = file_addr_to_index.end();
+            // Functions were added so we need to merge symbols into any
+            // existing function symbol contexts
+            for (size_t i = start_size; i < num_matches; ++i) {
+              sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
+              SymbolType sym_type = sc.symbol->GetType();
+              if (sc.symbol && sc.symbol->ValueIsAddress() &&
+                  (sym_type == eSymbolTypeCode ||
+                   sym_type == eSymbolTypeResolver)) {
+                FileAddrToIndexMap::const_iterator pos =
+                    file_addr_to_index.find(
+                        sc.symbol->GetAddressRef().GetFileAddress());
+                if (pos == end)
+                  sc_list.Append(sc);
+                else
+                  sc_list[pos->second].symbol = sc.symbol;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
 void Module::FindFunctions(const RegularExpression &regex,
                            const ModuleFunctionSearchOptions &options,
                            SymbolContextList &sc_list) {
   const size_t start_size = sc_list.GetSize();
 
   if (SymbolFile *symbols = GetSymbolFile()) {
     symbols->FindFunctions(regex, options.include_inlines, sc_list);
 

lldb/source/Symbol/Symbol.cpp

 bool Symbol::ValueIsAddress() const {
   return (bool)m_addr_range.GetBaseAddress().GetSection();
 }
 
 ConstString Symbol::GetDisplayName() const {
   return GetMangled().GetDisplayDemangledName();
 }
 
+void Symbol::SetName(llvm::StringRef name) {
+  m_mangled.SetDemangledName(ConstString(name));
+}
+
 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();
     if (str_ptr != 0)
       return ConstString((const char *)str_ptr);

lldb/source/Symbol/Symtab.cpp

while (pos != indexes.end()) {
         ++pos;
       else
         pos = indexes.erase(pos);
     }
   }
   return indexes.size();
 }
 
+uint32_t Symtab::AppendSymbolIndexesMatchingRegExWithMatchesAndType(
+    Stream &strm, const RegularExpression &regexp, SymbolType symbol_type,
+    std::vector<uint32_t> &indexes,
+    llvm::SmallVector<
+        std::pair<const char *, llvm::SmallVector<llvm::StringRef>>>
+        &allMatches,
+    Mangled::NamePreference name_preference) const {
+  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++) {
+    llvm::SmallVector<llvm::StringRef> matches;
+    if (symbol_type == eSymbolTypeAny ||
+        m_symbols[i].GetType() == symbol_type) {
+      const char *name =
+          m_symbols[i].GetMangled().GetName(name_preference).AsCString();
+      if (name) {
+        if (regexp.Execute(name, &matches)) {
+          allMatches.push_back(std::make_pair(name, matches));
+          indexes.push_back(i);
+        }
+      }
+    }
+  }
+  return indexes.size() - prev_size;
+}
+
 uint32_t Symtab::AppendSymbolIndexesMatchingRegExAndType(
     const RegularExpression &regexp, SymbolType symbol_type,
     std::vector<uint32_t> &indexes, Mangled::NamePreference name_preference) {
   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].GetMangled().GetName(name_preference).AsCString();
       if (name) {
         if (regexp.Execute(name))
           indexes.push_back(i);
       }
     }
   }
   return indexes.size() - prev_size;
 }
 
+uint32_t Symtab::AppendSymbolIndexesMatchingRegExWithMatchesAndType(
+    const RegularExpression &regexp, SymbolType symbol_type,
+    Debug symbol_debug_type, Visibility symbol_visibility,
+    std::vector<uint32_t> &indexes,
+    llvm::SmallVector<
+        std::pair<const char *, llvm::SmallVector<llvm::StringRef>>>
+        &allMatches,
+    Mangled::NamePreference name_preference) {
+  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++) {
+    llvm::SmallVector<llvm::StringRef> matches;
+    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].GetMangled().GetName(name_preference).AsCString();
+      if (name) {
+        if (regexp.Execute(name, &matches)) {
+          indexes.push_back(i);
+          allMatches.push_back(std::make_pair(name, matches));
+        }
+      }
+    }
+  }
+  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, Mangled::NamePreference name_preference) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   uint32_t prev_size = indexes.size();
   uint32_t sym_end = m_symbols.size();