[lldb] Filter DIEs based on qualified name when possible

[bulbazord]

Summary

Context:
When setting a breakpoint by name, we invoke Module::FindFunctions to find the function(s) in question. However, we use a Module::LookupInfo to first process the user-provided name and figure out exactly what we're looking for. When we actually perform the function lookup, we search for the basename. After performing the search, we then filter out the results using Module::LookupInfo::Prune. For example, given a::b::foo we would first search for all instances of foo and then filter out the results to just names that have a::b::foo in them. As one can imagine, this involves a lot of debug info processing that we do not necessarily need to be doing.

Some numbers:
Debugging LLDB and placing a breakpoint on llvm::itanium_demangle::StringView::begin without this change takes approximately 70 seconds and resolves 31,920 DIEs. With this change, placing the breakpoint takes around 30 seconds and resolves 8 DIEs.

[labath]

Well.. first of let me say that the performance gain is impressive. I wouldn't have expected to gain that much with a relatively simple change.

Now, as for the implementation, I have two main questions:

• Do we really need the GetQualifiedNameWithParams function? My impression was that we've been moving towards ignoring function arguments for name matching, and CPlusPlusLanguage::DemangledNameContainsPath does not look like it is making use of that. Note that I don't think that switching to GetQualifiedName is the right approach either. I think we should use the mangled name (GetMangledName) first, and only fall back to GetQualifiedName if that is unavailable (you can look up how it works during SymbolContext construction, but I believe it is roughly like that. (Incidentally, that will bring in the function arguments through the back door for some/most functions, but that isn't my motivation.)
• This patch is duplicating some of the logic inside Module::LookupInfo::Prune. I get that we can't reuse it as-is (because we'd need a SymbolContext object), but it seems like that function only cares about the GetFunctionName portion of the object, so it seems like it should be possible to refactor it such that one can reuse it from within this new context (just pass in a name instead of a full SymbolContext). (I guess this part could be a separate patch)

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

819–822

This is an interesting approach, but I'd just use llvm::ListSeparator for that.

[bulbazord]

In D129682#3651175, @labath wrote:

Well.. first of let me say that the performance gain is impressive. I wouldn't have expected to gain that much with a relatively simple change.

Thank you! I am also very surprised, it turned out to be a worthwhile time investment.

• Do we really need the GetQualifiedNameWithParams function? My impression was that we've been moving towards ignoring function arguments for name matching, and CPlusPlusLanguage::DemangledNameContainsPath does not look like it is making use of that. Note that I don't think that switching to GetQualifiedName is the right approach either. I think we should use the mangled name (GetMangledName) first, and only fall back to GetQualifiedName if that is unavailable (you can look up how it works during SymbolContext construction, but I believe it is roughly like that. (Incidentally, that will bring in the function arguments through the back door for some/most functions, but that isn't my motivation.)

My reasoning for writing GetQualifiedNameWithParams instead of just using GetQualifiedName is because of matching overloaded names. It's valid for a user to set a breakpoint like b a_function(int) to disambiguate any other functions named a_function. Without the parameter list, we would be setting a breakpoint on every a_function which is not correct if you specify the argument list. I originally used GetQualifiedName but TestBreakOnOverload failed...
That being said, I'm not sure how we would use a mangled name to perform the match. We're specifically matching on user input for breakpoints, so if a user inputs something like StringView::begin, how would we match that against mangled names? We would need some way to partially mangle StringView::begin and match that against the mangled name from the DIE, right? It would probably be faster to match against a mangled name though, so if there is a way to make that work that would be perfect.

• This patch is duplicating some of the logic inside Module::LookupInfo::Prune. I get that we can't reuse it as-is (because we'd need a SymbolContext object), but it seems like that function only cares about the GetFunctionName portion of the object, so it seems like it should be possible to refactor it such that one can reuse it from within this new context (just pass in a name instead of a full SymbolContext). (I guess this part could be a separate patch)

Specifically you're suggesting a refactor of Module::LookupInfo::Prune so that we can deduplicate the logic right? I'd actually like to see if we can get rid of Module::LookupInfo::Prune altogether so we don't have to post-process search results but instead filter them as we find them. I hope I've accomplished at least some of that with this change, but getting rid of it entirely would require a few more changes in Symtab and in the other SymbolFile implementations (I think...).

[jingham]

It always bugged me that break set -n some::long::path::a_common_word was going to realize all the debug info for functions called "a_common_word". In large projects there can be a lot of those. So I'm not 100% surprised that this gives us a good speedup (but happy!)

I certainly don't want us to give up on setting breakpoints by overload as well as function name. This is currently inconvenient because we don't have a "fuzzy argument matcher", instead you have to type the arguments exactly as the demangler would. That shouldn't be all that hard to implement, and even without that it's a fairly useful feature when you've got lots of overloads. The alternative, setting the breakpoint on the name and then disabling the overloads you don't want, is tedious and makes us look a little weak...

I'm not familiar enough with the DWARF parser to make useful comments on that part of the change, but the rest looks fine, and this is a great idea.

[jingham]

BTW, this is a side comment, but given that it's fairly common in the STL at least to have functions with a bevy of defaulted arguments that very few people specify or even really know are part of the function signature, it would be neat to do things like:

(lldb) break set -n foo::bar::baz(int, *)

or something, meaning, first argument is an int, I don't care about the others.

[labath]

In D129682#3653049, @bulbazord wrote:

In D129682#3651175, @labath wrote:

Well.. first of let me say that the performance gain is impressive. I wouldn't have expected to gain that much with a relatively simple change.

Thank you! I am also very surprised, it turned out to be a worthwhile time investment.

• Do we really need the GetQualifiedNameWithParams function? My impression was that we've been moving towards ignoring function arguments for name matching, and CPlusPlusLanguage::DemangledNameContainsPath does not look like it is making use of that. Note that I don't think that switching to GetQualifiedName is the right approach either. I think we should use the mangled name (GetMangledName) first, and only fall back to GetQualifiedName if that is unavailable (you can look up how it works during SymbolContext construction, but I believe it is roughly like that. (Incidentally, that will bring in the function arguments through the back door for some/most functions, but that isn't my motivation.)

My reasoning for writing GetQualifiedNameWithParams instead of just using GetQualifiedName is because of matching overloaded names. It's valid for a user to set a breakpoint like b a_function(int) to disambiguate any other functions named a_function. Without the parameter list, we would be setting a breakpoint on every a_function which is not correct if you specify the argument list. I originally used GetQualifiedName but TestBreakOnOverload failed...
That being said, I'm not sure how we would use a mangled name to perform the match. We're specifically matching on user input for breakpoints, so if a user inputs something like StringView::begin, how would we match that against mangled names? We would need some way to partially mangle StringView::begin and match that against the mangled name from the DIE, right? It would probably be faster to match against a mangled name though, so if there is a way to make that work that would be perfect.

I'm sorry, that wasn't fully clear. What I meant to say was to take the *mangled* name, then *demangle* it, and perform the matching that way. This would ensure that we are matching against the name that we are eventually going to use. This is particularly important if we're going to be matching function arguments (where, it seems, I have misunderstood what we are doing). Matching full function signatures is hard enough, so we should at least be consistent so that if the user copies a name from some lldb output into a breakpoint command, then it will match. Right now, GetQualifiedNameWithParams ignores template arguments so it will produce something like llvm::find(std::vector<llvm::PassRegistrationListener*, std::allocator<llvm::PassRegistrationListener*>>&, llvm::PassRegistrationListener* const&) instead of auto llvm::find<std::vector<llvm::PassRegistrationListener*, std::allocator<llvm::PassRegistrationListener*>>&, llvm::PassRegistrationListener*>(std::vector<llvm::PassRegistrationListener*, std::allocator<llvm::PassRegistrationListener*>>&, llvm::PassRegistrationListener* const&) -- although, ironically, the user might actually prefer matching the first one.

In order to avoid mismatches like this, I think we should merge this name-producing code with the code which computes the "real" function names.

• This patch is duplicating some of the logic inside Module::LookupInfo::Prune. I get that we can't reuse it as-is (because we'd need a SymbolContext object), but it seems like that function only cares about the GetFunctionName portion of the object, so it seems like it should be possible to refactor it such that one can reuse it from within this new context (just pass in a name instead of a full SymbolContext). (I guess this part could be a separate patch)

Specifically you're suggesting a refactor of Module::LookupInfo::Prune so that we can deduplicate the logic right? I'd actually like to see if we can get rid of Module::LookupInfo::Prune altogether so we don't have to post-process search results but instead filter them as we find them. I hope I've accomplished at least some of that with this change, but getting rid of it entirely would require a few more changes in Symtab and in the other SymbolFile implementations (I think...).

Well.. my main point was to centralize the code doing the filtering. Whether that code lives in Module::LookupInfo::Prune or somewhere else is not particularly important, but I would like to avoid having multiple copies of the logic, as that is bound to create inconsistencies. Obvously the way we *derive* the name will be different for DWARF vs. PDB vs. symtab, but I'd hope that the actual matching part can stay the same.

[bulbazord]

I have factored out part of Module::LookupInfo::Prune into its own method Module::LookupInfo::NameMatchesLookupInfo which I re-use in ProcessFunctionDIE instead of copying code.

I also have switched to taking the mangled name of a DIE and demangled it to get the fully qualified name. This doesn't seem to have regressed performance at all, so I'm happy to go with this moving forward. I've deleted the GetQualifiedNameWithParams I had written previously since it shouldn't be needed anymore.

[bulbazord]

Friendly ping :)

[clayborg]

lldb/source/Core/Module.cpp

730

So this function can end up being called with an empty function_name when there is no mangled name (see comment in DWARFIndex.cpp). If there is no language then we return true, but what does a language plug-in do in DemangledNameContainsPath? The same thing?

I guess this means if you lookup "foo::erase" and you get a DIE that has "erase" as its DW_AT_name, but the DIE has no DW_AT_mangled (yes, some C++ debug info is emitted without a mangled name), that it will match any DIE that has a DW_AT_name that matches "erase" regardless of the actual decl context?

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

37

So this looks like this can be called with an empty named since not all DIEs have mangled names. Do we not want to try and calculate the demangled name here if the mangled name is empty?

[bulbazord]

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

37

Yes, we probably do want to calculate the demangled name here. The previous version of this patch had a function GetQualifiedNameWithParams that tried to calculate the fully qualified demangled name but I think it probably needed a little more work. I can bring that back unless you can think of a different way to do it.

[clayborg]

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

37

You can avoid doing this demangling or calculating the demangled name if the name in the lookup_info is already mangled? Like if the name lookup is "_Z3foo", there is no need to demangle and see if that matches, so there could be some good efficiency gains by trying not to always demangle (expensive) or calculate the demangled named (even more expensive) if we are looking for a mangled name in lookup_info

[labath]

Sorry for dropping off.

Using the mangled name helped, but I am still moderately worried about that the name that's going to be matched here is different from the "real" name that gets computed later. I think it's important to avoid subtle variations in the names computed in two places, and that's only possible with a single copy of the code (*that* was my biggest issue with the GetQualifiedNameWithParams function). Functions without a mangled name are relatively common (all extern "C" functions, and *all* functions if compiled with -gsce) and I think it'd be confusing if we used one name for matching, and then displayed another one.

The exact string is probably not as important as consistency so I think we could replace the code I linked to with whatever can be produced with the information you have available here.

[bulbazord]

• Expanded on NameMatchesLookupInfo to handle different scenarios when names we are comparing are mangled/demangled.
• Extracted functionality from DWARFASTParserClang to construct a demangled name from the DIE's context. This is now exposed through SymbolFileDWARF so that we can get a demangled name of a DIE consistently with one piece of code.

[bulbazord]

lldb/source/Core/Module.cpp

730

I moved the empty check to the top since we always want to keep unnamed symbols.

[labath]

I like how you've extracted the name construction functionality. Just one (inline) comment about the filtering.

lldb/source/Core/Module.cpp

740

I think this is overly aggressive. _Z3foov could be a method name in some particularly sadistic class. I think you can do this optimization only in one direction: if the names match, then return true without consulting the language plugin. At that point, I don't think you even need to check whether the names are mangled.

[labath]

lldb/source/Core/Module.cpp

740

Actually, this could go wrong even for names like _Zonk, since GetManglingScheme does not check that the string is an actually valid mangled name -- just that it looks like one from very far away.

[bulbazord]

lldb/source/Core/Module.cpp

740

Then in that case, perhaps this method should always take a demangled name? If it can take mangled names, it seems like a giant pain and potentially pretty expensive to figure out if it's mangled or not, especially given that in the sadistic case a name could look mangled but actually be the demangled name. Am I following your thought correctly?

[labath]

lldb/source/Core/Module.cpp

740

Not exactly. The way that lookup works in lldb (or at least, how I understand it) is that the user gives you a "name" and then you go on to match that name against various "things". Those things include stuff like the mangled name, full demangled name, basename, etc. The set of things to match can be constrained by through extra arguments (e.g. br set --fullname vs. br set --basename), but I don't think we have a way to say "match against mangled names _only_" -- things like br set --fullname _Z3foov will both match the function whose mangled name is that string (i.e. foo()) and the function which has that as its demangled name (_Z3foov() aka. _Z7_Z3foovv).

So I'd say this should just match both names without trying to be particularly efficient about it (obviously it can skip the demangle step if the mangled name already matches).

I'd also say it's possible I don't understand the context in which this function is invoked...

[bulbazord]

Simplify Module::LookupInfo::NameMatchesLookupInfo. Perform an initial check to see if the name matches, and if not, do the more expensive demangling operation.

lldb/include/lldb/Core/Module.h

 /// the Module::GetObjectFile() is called. The debug symbols will only be
 /// parsed if the symbol file (SymbolFile) is requested using the
 /// Module::GetSymbolFile() method.
 ///
 /// The module will parse more detailed information as more queries are made.
 class Module : public std::enable_shared_from_this<Module>,
                public SymbolContextScope {
 public:
+  class LookupInfo;
   // Static functions that can track the lifetime of module objects. This is
   // handy because we might have Module objects that are in shared pointers
   // that aren't in the global module list (from ModuleList). If this is the
   // case we need to know about it. The modules in the global list maintained
   // by these functions can be viewed using the "target modules list" command
   // using the "--global" (-g for short).
   static size_t GetNumberAllocatedModules();
 
public:
   /// \param[in] path
   ///     The name of the function we are looking for.
   ///
   /// \param[out] sc_list
   ///     A symbol context list that gets filled in with all of the
   ///     matches.
   void FindCompileUnits(const FileSpec &path, SymbolContextList &sc_list);
 
+  /// Find functions by lookup info.
+  ///
+  /// 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] lookup_info
+  ///     The lookup info of the function we are looking for.
+  ///
+  /// \param[out] sc_list
+  ///     A symbol context list that gets filled in with all of the
+  ///     matches.
+  void FindFunctions(const LookupInfo &lookup_info,
+                     const CompilerDeclContext &parent_decl_ctx,
+                     const ModuleFunctionSearchOptions &options,
+                     SymbolContextList &sc_list);
+
   /// Find functions by name.
   ///
   /// 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] name
   ///     The name of the function we are looking for.
public:
     void SetLookupName(ConstString name) { m_lookup_name = name; }
 
     lldb::FunctionNameType GetNameTypeMask() const { return m_name_type_mask; }
 
     void SetNameTypeMask(lldb::FunctionNameType mask) {
       m_name_type_mask = mask;
     }
 
+    lldb::LanguageType GetLanguageType() const { return m_language; }
+
+    bool NameMatchesLookupInfo(
+        ConstString function_name,
+        lldb::LanguageType language_type = lldb::eLanguageTypeUnknown) const;
+
     void Prune(SymbolContextList &sc_list, size_t start_idx) const;
 
   protected:
     /// What the user originally typed
     ConstString m_name;
 
     /// The actual name will lookup when calling in the object or symbol file
     ConstString m_lookup_name;

lldb/include/lldb/Symbol/SymbolFile.h

 //===-- SymbolFile.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_SYMBOLFILE_H
 #define LLDB_SYMBOL_SYMBOLFILE_H
 
+#include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SourceLocationSpec.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SourceModule.h"
public:
   virtual void DumpClangAST(Stream &s) {}
   virtual void FindGlobalVariables(ConstString name,
                                    const CompilerDeclContext &parent_decl_ctx,
                                    uint32_t max_matches,
                                    VariableList &variables);
   virtual void FindGlobalVariables(const RegularExpression &regex,
                                    uint32_t max_matches,
                                    VariableList &variables);
-  virtual void FindFunctions(ConstString name,
+  virtual void FindFunctions(const Module::LookupInfo &lookup_info,
                              const CompilerDeclContext &parent_decl_ctx,
-                             lldb::FunctionNameType name_type_mask,
                              bool include_inlines, SymbolContextList &sc_list);
   virtual void FindFunctions(const RegularExpression &regex,
                              bool include_inlines, SymbolContextList &sc_list);
   virtual void
   FindTypes(ConstString name, const CompilerDeclContext &parent_decl_ctx,
             uint32_t max_matches,
             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
             TypeMap &types);

lldb/include/lldb/Symbol/SymbolFileOnDemand.h

FindGlobalVariables(lldb_private::ConstString name,
                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
                            uint32_t max_matches,
                            lldb_private::VariableList &variables) override;
 
-  void FindFunctions(lldb_private::ConstString name,
+  void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info,
                      const lldb_private::CompilerDeclContext &parent_decl_ctx,
-                     lldb::FunctionNameType name_type_mask,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void FindFunctions(const lldb_private::RegularExpression &regex,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void GetMangledNamesForFunction(

lldb/source/Breakpoint/BreakpointResolverName.cpp

BreakpointResolverName::SearchCallback(SearchFilter &filter,
   function_options.include_symbols = !filter_by_cu;
   function_options.include_inlines = true;
 
   switch (m_match_type) {
   case Breakpoint::Exact:
     if (context.module_sp) {
       for (const auto &lookup : m_lookups) {
         const size_t start_func_idx = func_list.GetSize();
-        context.module_sp->FindFunctions(
-            lookup.GetLookupName(), CompilerDeclContext(),
-            lookup.GetNameTypeMask(), function_options, func_list);
+        context.module_sp->FindFunctions(lookup, CompilerDeclContext(),
+                                         function_options, func_list);
 
         const size_t end_func_idx = func_list.GetSize();
 
         if (start_func_idx < end_func_idx)
           lookup.Prune(func_list, start_func_idx);
       }
     }
     break;

lldb/source/Core/Module.cpp

Module::LookupInfo::LookupInfo(ConstString name,
   } else {
     // The name is already correct, just use the exact name as supplied, and we
     // won't need to check if any matches contain "name"
     m_lookup_name = name;
     m_match_name_after_lookup = false;
   }
 }
 
+bool Module::LookupInfo::NameMatchesLookupInfo(
+    ConstString function_name, LanguageType language_type) const {
+  // We always keep unnamed symbols
+  if (!function_name)
+    return true;
+
+  // If we match exactly, we can return early
+  if (m_name == function_name)
+    return true;
+
+  // If function_name is mangled, we'll need to demangle it.
+  // In the pathologial case where the function name "looks" mangled but is
+  // actually demangled (e.g. a method named _Zonk), this operation should be
+  // relatively inexpensive since no demangling is actually occuring. See
+  // Mangled::SetValue for more context.
+  const bool function_name_may_be_mangled =
+      Mangled::GetManglingScheme(function_name.GetStringRef()) !=
+      Mangled::eManglingSchemeNone;
+  ConstString demangled_function_name = function_name;
+  if (function_name_may_be_mangled) {
+    Mangled mangled_function_name(function_name);
+    demangled_function_name = mangled_function_name.GetDemangledName();
+  }
+
+  // If the symbol has a language, then let the language make the match.
+  // Otherwise just check that the demangled function name contains the
+  // demangled user-provided name.
+  if (Language *language = Language::FindPlugin(language_type))
+    return language->DemangledNameContainsPath(m_name.GetStringRef(),
+                                               demangled_function_name);
+
+  llvm::StringRef function_name_ref = demangled_function_name.GetStringRef();
+  return function_name_ref.contains(m_name.GetStringRef());
+}
+
 void Module::LookupInfo::Prune(SymbolContextList &sc_list,
                                size_t start_idx) const {
   if (m_match_name_after_lookup && m_name) {
     SymbolContext sc;
     size_t i = start_idx;
     while (i < sc_list.GetSize()) {
       if (!sc_list.GetContextAtIndex(i, sc))
         break;
       
-      llvm::StringRef user_name = m_name.GetStringRef();
-      bool keep_it = true;
-      Language *language = Language::FindPlugin(sc.GetLanguage());
-      // If the symbol has a language, then let the language make the match.
-      // Otherwise just check that the demangled name contains the user name.
-      if (language)
-        keep_it = language->DemangledNameContainsPath(m_name.GetStringRef(),
-                sc.GetFunctionName());
-      else {
-        llvm::StringRef full_name = sc.GetFunctionName().GetStringRef();
-        // We always keep unnamed symbols:
-        if (!full_name.empty())
-          keep_it = full_name.contains(user_name);
-      }
+      bool keep_it =
+          NameMatchesLookupInfo(sc.GetFunctionName(), sc.GetLanguage());
       if (keep_it)
         ++i;
       else
         sc_list.RemoveContextAtIndex(i);
     }
   }
 
   // If we have only full name matches we might have tried to set breakpoint on
while (i < sc_list.GetSize()) {
           }
         }
       }
       ++i;
     }
   }
 }
 
-void Module::FindFunctions(ConstString name,
+void Module::FindFunctions(const Module::LookupInfo &lookup_info,
                            const CompilerDeclContext &parent_decl_ctx,
-                           FunctionNameType name_type_mask,
                            const ModuleFunctionSearchOptions &options,
                            SymbolContextList &sc_list) {
-  const size_t old_size = sc_list.GetSize();
-
   // Find all the functions (not symbols, but debug information functions...
-  SymbolFile *symbols = GetSymbolFile();
-
-  if (name_type_mask & eFunctionNameTypeAuto) {
-    LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
-
-    if (symbols) {
-      symbols->FindFunctions(lookup_info.GetLookupName(), parent_decl_ctx,
-                             lookup_info.GetNameTypeMask(),
-                             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)
-          symtab->FindFunctionSymbols(lookup_info.GetLookupName(),
-                                      lookup_info.GetNameTypeMask(), sc_list);
+  if (SymbolFile *symbols = GetSymbolFile()) {
+    symbols->FindFunctions(lookup_info, parent_decl_ctx,
+      if (Symtab *symtab = symbols->GetSymtab()) {
       }
     }
+  }
+}
 
+void Module::FindFunctions(ConstString name,
+                           const CompilerDeclContext &parent_decl_ctx,
+                           FunctionNameType name_type_mask,
+                           const ModuleFunctionSearchOptions &options,
+                           SymbolContextList &sc_list) {
+  const size_t old_size = sc_list.GetSize();
+  LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
+  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);
-  } else {
-    if (symbols) {
-      symbols->FindFunctions(name, parent_decl_ctx, name_type_mask,
-                             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)
-          symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
-      }
-    }
   }
 }
 
 void Module::FindFunctions(const RegularExpression &regex,
                            const ModuleFunctionSearchOptions &options,
                            SymbolContextList &sc_list) {
   const size_t start_size = sc_list.GetSize();
 

lldb/source/Core/ModuleList.cpp

void ModuleList::FindFunctions(ConstString name,
                                SymbolContextList &sc_list) const {
   const size_t old_size = sc_list.GetSize();
 
   if (name_type_mask & eFunctionNameTypeAuto) {
     Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
 
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     for (const ModuleSP &module_sp : m_modules) {
-      module_sp->FindFunctions(lookup_info.GetLookupName(),
-                               CompilerDeclContext(),
-                               lookup_info.GetNameTypeMask(), options, sc_list);
+      module_sp->FindFunctions(lookup_info, CompilerDeclContext(), options,
+                               sc_list);
     }
 
     const size_t new_size = sc_list.GetSize();
 
     if (old_size < new_size)
       lookup_info.Prune(sc_list, old_size);
   } else {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

public:
 
   uint32_t ResolveSymbolContext(const SourceLocationSpec &src_location_spec,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContextList &sc_list) override;
 
   void GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
                 TypeList &type_list) override {}
 
-  void FindFunctions(ConstString name,
+  void FindFunctions(const Module::LookupInfo &lookup_info,
                      const CompilerDeclContext &parent_decl_ctx,
-                     lldb::FunctionNameType name_type_mask,
                      bool include_inlines, SymbolContextList &sc_list) override;
 
   void FindFunctions(const RegularExpression &regex, bool include_inlines,
                      SymbolContextList &sc_list) override;
 
   void FindTypes(ConstString name, const CompilerDeclContext &parent_decl_ctx,
                  uint32_t max_matches,
                  llvm::DenseSet<SymbolFile *> &searched_symbol_files,

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

uint32_t SymbolFileBreakpad::ResolveSymbolContext(
   for (size_t i = 0, size = GetNumCompileUnits(); i < size; ++i) {
     CompileUnit &cu = *GetCompileUnitAtIndex(i);
     cu.ResolveSymbolContext(src_location_spec, resolve_scope, sc_list);
   }
   return sc_list.GetSize() - old_size;
 }
 
 void SymbolFileBreakpad::FindFunctions(
-    ConstString name, const CompilerDeclContext &parent_decl_ctx,
-    FunctionNameType name_type_mask, bool include_inlines,
+    const Module::LookupInfo &lookup_info,
+    const CompilerDeclContext &parent_decl_ctx, bool include_inlines,
     SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // TODO: Implement this with supported FunctionNameType.
 
+  ConstString name = lookup_info.GetLookupName();
   for (uint32_t i = 0; i < GetNumCompileUnits(); ++i) {
     CompUnitSP cu_sp = GetCompileUnitAtIndex(i);
     FunctionSP func_sp = GetOrCreateFunction(*cu_sp);
     if (func_sp && name == func_sp->GetNameNoArguments()) {
       SymbolContext sc;
       sc.comp_unit = cu_sp.get();
       sc.function = func_sp.get();
       sc.module_sp = func_sp->CalculateSymbolContextModule();

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.h

void GetCompleteObjCClass(
       ConstString class_name, bool must_be_implementation,
       llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(ConstString name,
                 llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(const DWARFDeclContext &context,
                 llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetNamespaces(ConstString name,
                      llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
+  void GetFunctions(const Module::LookupInfo &lookup_info,
+                    SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
-                    uint32_t name_type_mask,
                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetFunctions(const RegularExpression &regex,
                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
 
   void Dump(Stream &s) override;
 
 private:
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_names_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_namespaces_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_types_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_objc_up;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_APPLEDWARFINDEX_H

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

void AppleDWARFIndex::GetNamespaces(
     ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_namespaces_up)
     return;
   m_apple_namespaces_up->FindByName(
       name.GetStringRef(), DIERefCallback(callback, name.GetStringRef()));
 }
 
 void AppleDWARFIndex::GetFunctions(
-    ConstString name, SymbolFileDWARF &dwarf,
-    const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
+    const Module::LookupInfo &lookup_info, SymbolFileDWARF &dwarf,
+    const CompilerDeclContext &parent_decl_ctx,
     llvm::function_ref<bool(DWARFDIE die)> callback) {
+  ConstString name = lookup_info.GetLookupName();
   m_apple_names_up->FindByName(name.GetStringRef(), [&](DIERef die_ref) {
-    return ProcessFunctionDIE(name.GetStringRef(), die_ref, dwarf,
-                              parent_decl_ctx, name_type_mask, callback);
+    return ProcessFunctionDIE(lookup_info, die_ref, dwarf, parent_decl_ctx,
+                              callback);
   });
 }
 
 void AppleDWARFIndex::GetFunctions(
     const RegularExpression &regex,
     llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_names_up)
     return;

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

 class DWARFASTParser {
 public:
   virtual ~DWARFASTParser() = default;
 
   virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                           const DWARFDIE &die,
                                           bool *type_is_new_ptr) = 0;
 
+  virtual lldb_private::ConstString
+  ConstructDemangledNameFromDWARF(const DWARFDIE &die) = 0;
+
   virtual lldb_private::Function *
   ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die,
                          const lldb_private::AddressRange &range) = 0;
 
   virtual bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) = 0;

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

public:
 
   ~DWARFASTParserClang() override;
 
   // DWARFASTParser interface.
   lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                   const DWARFDIE &die,
                                   bool *type_is_new_ptr) override;
 
+  lldb_private::ConstString
+  ConstructDemangledNameFromDWARF(const DWARFDIE &die) override;
+
   lldb_private::Function *
   ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die,
                          const lldb_private::AddressRange &func_range) override;
 
   bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) override;

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (tag == DW_TAG_enumerator) {
           ++enumerators_added;
         }
       }
     }
   }
   return enumerators_added;
 }
 
+ConstString
+DWARFASTParserClang::ConstructDemangledNameFromDWARF(const DWARFDIE &die) {
+  bool is_static = false;
+  bool is_variadic = false;
+  bool has_template_params = false;
+  unsigned type_quals = 0;
+  std::vector<CompilerType> param_types;
+  std::vector<clang::ParmVarDecl *> param_decls;
+  StreamString sstr;
+
+  DWARFDeclContext decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
+  sstr << decl_ctx.GetQualifiedName();
+
+  clang::DeclContext *containing_decl_ctx =
+      GetClangDeclContextContainingDIE(die, nullptr);
+  ParseChildParameters(containing_decl_ctx, die, true, is_static, is_variadic,
+                       has_template_params, param_types, param_decls,
+                       type_quals);
+  sstr << "(";
+  for (size_t i = 0; i < param_types.size(); i++) {
+    if (i > 0)
+      sstr << ", ";
+    sstr << param_types[i].GetTypeName();
+  }
+  if (is_variadic)
+    sstr << ", ...";
+  sstr << ")";
+  if (type_quals & clang::Qualifiers::Const)
+    sstr << " const";
+
+  return ConstString(sstr.GetString());
+}
+
 Function *
 DWARFASTParserClang::ParseFunctionFromDWARF(CompileUnit &comp_unit,
                                             const DWARFDIE &die,
                                             const AddressRange &func_range) {
   assert(func_range.GetBaseAddress().IsValid());
   DWARFRangeList func_ranges;
   const char *name = nullptr;
   const char *mangled = nullptr;
else if ((die.GetParent().Tag() == DW_TAG_compile_unit ||
              Language::LanguageIsCPlusPlus(
                  SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
              !Language::LanguageIsObjC(
                  SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
              name && strcmp(name, "main") != 0) {
       // If the mangled name is not present in the DWARF, generate the
       // demangled name using the decl context. We skip if the function is
       // "main" as its name is never mangled.
-      bool is_static = false;
-      bool is_variadic = false;
-      bool has_template_params = false;
-      unsigned type_quals = 0;
-      std::vector<CompilerType> param_types;
-      std::vector<clang::ParmVarDecl *> param_decls;
-      StreamString sstr;
-
-      DWARFDeclContext decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
-      sstr << decl_ctx.GetQualifiedName();
-
-      clang::DeclContext *containing_decl_ctx =
-          GetClangDeclContextContainingDIE(die, nullptr);
-      ParseChildParameters(containing_decl_ctx, die, true, is_static,
-                           is_variadic, has_template_params, param_types,
-                           param_decls, type_quals);
-      sstr << "(";
-      for (size_t i = 0; i < param_types.size(); i++) {
-        if (i > 0)
-          sstr << ", ";
-        sstr << param_types[i].GetTypeName();
-      }
-      if (is_variadic)
-        sstr << ", ...";
-      sstr << ")";
-      if (type_quals & clang::Qualifiers::Const)
-        sstr << " const";
-
-      func_name.SetValue(ConstString(sstr.GetString()), false);
+      func_name.SetValue(ConstructDemangledNameFromDWARF(die), false);
     } else
       func_name.SetValue(ConstString(name), false);
 
     FunctionSP func_sp;
     std::unique_ptr<Declaration> decl_up;
     if (decl_file != 0 || decl_line != 0 || decl_column != 0)
       decl_up = std::make_unique<Declaration>(die.GetCU()->GetFile(decl_file),
                                               decl_line, decl_column);

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 #include <algorithm>
 
 #include "llvm/Support/LEB128.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StreamString.h"
 
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
while (parent_decl_ctx_die) {
       case DW_TAG_namespace: {
         const char *namespace_name = parent_decl_ctx_die.GetName();
         if (namespace_name) {
           storage.insert(0, "::");
           storage.insert(0, namespace_name);
         } else {
           storage.insert(0, "(anonymous namespace)::");
         }
         parent_decl_ctx_die = parent_decl_ctx_die.GetParentDeclContextDIE();
       } break;
 
       case DW_TAG_class_type:
       case DW_TAG_structure_type:
       case DW_TAG_union_type: {
         const char *class_union_struct_name = parent_decl_ctx_die.GetName();
 
         if (class_union_struct_name) {
           storage.insert(0, "::");
           storage.insert(0, class_union_struct_name);
         }

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.h

 //===-- DWARFIndex.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_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DIERef.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/DWARFFormValue.h"
 
+#include "lldb/Core/Module.h"
 #include "lldb/Target/Statistics.h"
 
 class DWARFDeclContext;
 class DWARFDIE;
 
 namespace lldb_private {
 class DWARFIndex {
 public:
public:
   virtual void GetTypes(ConstString name,
                         llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void GetTypes(const DWARFDeclContext &context,
                         llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void
   GetNamespaces(ConstString name,
                 llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void
-  GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
+  GetFunctions(const Module::LookupInfo &lookup_info, SymbolFileDWARF &dwarf,
                const CompilerDeclContext &parent_decl_ctx,
-               uint32_t name_type_mask,
                llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void
   GetFunctions(const RegularExpression &regex,
                llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
 
   virtual void Dump(Stream &s) = 0;
 
   StatsDuration::Duration GetIndexTime() { return m_index_time; }
 
 protected:
   Module &m_module;
   StatsDuration m_index_time;
 
   /// Helper function implementing common logic for processing function dies. If
   /// the function given by "ref" matches search criteria given by
   /// "parent_decl_ctx" and "name_type_mask", it is inserted into the "dies"
   /// vector.
-  bool ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
+  bool ProcessFunctionDIE(const Module::LookupInfo &lookup_info, DIERef ref,
                           SymbolFileDWARF &dwarf,
                           const CompilerDeclContext &parent_decl_ctx,
-                          uint32_t name_type_mask,
                           llvm::function_ref<bool(DWARFDIE die)> callback);
 
   class DIERefCallbackImpl {
   public:
     DIERefCallbackImpl(const DWARFIndex &index,
                        llvm::function_ref<bool(DWARFDIE die)> callback,
                        llvm::StringRef name);
     bool operator()(DIERef ref) const;

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

 //===-- DWARFIndex.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 "Plugins/SymbolFile/DWARF/DWARFIndex.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 
+#include "lldb/Core/Mangled.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Target/Language.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 DWARFIndex::~DWARFIndex() = default;
 
 bool DWARFIndex::ProcessFunctionDIE(
-    llvm::StringRef name, DIERef ref, SymbolFileDWARF &dwarf,
-    const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
+    const Module::LookupInfo &lookup_info, DIERef ref, SymbolFileDWARF &dwarf,
+    const CompilerDeclContext &parent_decl_ctx,
     llvm::function_ref<bool(DWARFDIE die)> callback) {
+  llvm::StringRef name = lookup_info.GetLookupName().GetStringRef();
+  FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
   DWARFDIE die = dwarf.GetDIE(ref);
   if (!die) {
     ReportInvalidDIERef(ref, name);
     return true;
   }
 
+  if (!(name_type_mask & eFunctionNameTypeFull)) {
+    ConstString name_to_match_against;
+    if (const char *mangled_die_name = die.GetMangledName()) {
+      name_to_match_against = ConstString(mangled_die_name);
+    } else {
+      SymbolFileDWARF *symbols = die.GetDWARF();
+      if (ConstString demangled_die_name =
+              symbols->ConstructFunctionDemangledName(die))
+        name_to_match_against = demangled_die_name;
+    }
+
+    if (!lookup_info.NameMatchesLookupInfo(name_to_match_against,
+                                           lookup_info.GetLanguageType()))
+      return true;
+  }
+
   // Exit early if we're searching exclusively for methods or selectors and
   // we have a context specified (no methods in namespaces).
   uint32_t looking_for_nonmethods =
       name_type_mask & ~(eFunctionNameTypeMethod | eFunctionNameTypeSelector);
   if (!looking_for_nonmethods && parent_decl_ctx.IsValid())
     return true;
 
   // Otherwise, we need to also check that the context matches. If it does not

lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.h

void GetCompleteObjCClass(
       ConstString class_name, bool must_be_implementation,
       llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(ConstString name,
                 llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(const DWARFDeclContext &context,
                 llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetNamespaces(ConstString name,
                      llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
+  void GetFunctions(const Module::LookupInfo &lookup_info,
+                    SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
-                    uint32_t name_type_mask,
                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetFunctions(const RegularExpression &regex,
                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
 
   void Dump(Stream &s) override;
 
 private:
   DebugNamesDWARFIndex(Module &module,

lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

if (entry.tag() == DW_TAG_namespace) {
         return;
     }
   }
 
   m_fallback.GetNamespaces(name, callback);
 }
 
 void DebugNamesDWARFIndex::GetFunctions(
-    ConstString name, SymbolFileDWARF &dwarf,
-    const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
+    const Module::LookupInfo &lookup_info, SymbolFileDWARF &dwarf,
+    const CompilerDeclContext &parent_decl_ctx,
     llvm::function_ref<bool(DWARFDIE die)> callback) {
-
+  ConstString name = lookup_info.GetLookupName();
   std::set<DWARFDebugInfoEntry *> seen;
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     Tag tag = entry.tag();
     if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine)
       continue;
 
     if (llvm::Optional<DIERef> ref = ToDIERef(entry)) {
-      if (!ProcessFunctionDIE(name.GetStringRef(), *ref, dwarf, parent_decl_ctx,
-                              name_type_mask, [&](DWARFDIE die) {
+      if (!ProcessFunctionDIE(lookup_info, *ref, dwarf, parent_decl_ctx,
+                              [&](DWARFDIE die) {
                                 if (!seen.insert(die.GetDIE()).second)
                                   return true;
                                 return callback(die);
                               }))
         return;
     }
   }
 
-  m_fallback.GetFunctions(name, dwarf, parent_decl_ctx, name_type_mask,
-                          callback);
+  m_fallback.GetFunctions(lookup_info, dwarf, parent_decl_ctx, callback);
 }
 
 void DebugNamesDWARFIndex::GetFunctions(
     const RegularExpression &regex,
     llvm::function_ref<bool(DWARFDIE die)> callback) {
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       if (!regex.Execute(nte.getString()))

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h

void GetCompleteObjCClass(
       ConstString class_name, bool must_be_implementation,
       llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(ConstString name,
                 llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(const DWARFDeclContext &context,
                 llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetNamespaces(ConstString name,
                      llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
+  void GetFunctions(const Module::LookupInfo &lookup_info,
+                    SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
-                    uint32_t name_type_mask,
                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetFunctions(const RegularExpression &regex,
                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
 
   void Dump(Stream &s) override;
 
   // Make IndexSet public so we can unit test the encoding and decoding logic.
   struct IndexSet {

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

 
 void ManualDWARFIndex::GetNamespaces(
     ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
   m_set.namespaces.Find(name, DIERefCallback(callback, name.GetStringRef()));
 }
 
 void ManualDWARFIndex::GetFunctions(
-    ConstString name, SymbolFileDWARF &dwarf,
-    const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
+    const Module::LookupInfo &lookup_info, SymbolFileDWARF &dwarf,
+    const CompilerDeclContext &parent_decl_ctx,
     llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
+  ConstString name = lookup_info.GetLookupName();
+  FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
 
   if (name_type_mask & eFunctionNameTypeFull) {
     if (!m_set.function_fullnames.Find(
             name, DIERefCallback(
                       [&](DWARFDIE die) {
                         if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx,
                                                                die))
                           return true;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

FindGlobalVariables(lldb_private::ConstString name,
                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
                            uint32_t max_matches,
                            lldb_private::VariableList &variables) override;
 
-  void FindFunctions(lldb_private::ConstString name,
+  void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info,
                      const lldb_private::CompilerDeclContext &parent_decl_ctx,
-                     lldb::FunctionNameType name_type_mask,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void FindFunctions(const lldb_private::RegularExpression &regex,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void GetMangledNamesForFunction(
lldb_private::StatsDuration::Duration GetDebugInfoParseTime() override {
     return m_parse_time;
   }
   lldb_private::StatsDuration::Duration GetDebugInfoIndexTime() override;
 
   lldb_private::StatsDuration &GetDebugInfoParseTimeRef() {
     return m_parse_time;
   }
 
+  lldb_private::ConstString ConstructFunctionDemangledName(const DWARFDIE &die);
+
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
 
   func_range.SetByteSize(highest_func_addr - lowest_func_addr);
   if (!FixupAddress(func_range.GetBaseAddress()))
     return nullptr;
 
   return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die, func_range);
 }
 
+ConstString
+SymbolFileDWARF::ConstructFunctionDemangledName(const DWARFDIE &die) {
+  ASSERT_MODULE_LOCK(this);
+  if (!die.IsValid()) {
+    return ConstString();
+  }
+
+  auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
+                   "Unable to construct demangled name for function");
+    return ConstString();
+  }
+
+  DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
+  if (!dwarf_ast)
+    return ConstString();
+
+  return dwarf_ast->ConstructDemangledNameFromDWARF(die);
+}
+
 lldb::addr_t SymbolFileDWARF::FixupAddress(lldb::addr_t file_addr) {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile)
     return debug_map_symfile->LinkOSOFileAddress(this, file_addr);
   return file_addr;
 }
 
 bool SymbolFileDWARF::FixupAddress(Address &addr) {
if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
       if (CompilerDeclContext actual_decl_ctx =
               dwarf_ast->GetDeclContextContainingUIDFromDWARF(die))
         return decl_ctx.IsContainedInLookup(actual_decl_ctx);
     }
   }
   return false;
 }
 
-void SymbolFileDWARF::FindFunctions(ConstString name,
+void SymbolFileDWARF::FindFunctions(const Module::LookupInfo &lookup_info,
                                     const CompilerDeclContext &parent_decl_ctx,
-                                    FunctionNameType name_type_mask,
                                     bool include_inlines,
                                     SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+  ConstString name = lookup_info.GetLookupName();
+  FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
   LLDB_SCOPED_TIMERF("SymbolFileDWARF::FindFunctions (name = '%s')",
                      name.AsCString());
 
   // eFunctionNameTypeAuto should be pre-resolved by a call to
   // Module::LookupInfo::LookupInfo()
   assert((name_type_mask & eFunctionNameTypeAuto) == 0);
 
   Log *log = GetLog(DWARFLog::Lookups);
void SymbolFileDWARF::FindFunctions(const Module::LookupInfo &lookup_info,
 
   // Remember how many sc_list are in the list before we search in case we are
   // appending the results to a variable list.
 
   const uint32_t original_size = sc_list.GetSize();
 
   llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
 
-  m_index->GetFunctions(name, *this, parent_decl_ctx, name_type_mask,
-                        [&](DWARFDIE die) {
-                          if (resolved_dies.insert(die.GetDIE()).second)
-                            ResolveFunction(die, include_inlines, sc_list);
-                          return true;
-                        });
+  m_index->GetFunctions(lookup_info, *this, parent_decl_ctx, [&](DWARFDIE die) {
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = sc_list.GetSize() - original_size;
 
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindFunctions (name=\"%s\", "

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
   void
   FindGlobalVariables(lldb_private::ConstString name,
                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
                            uint32_t max_matches,
                            lldb_private::VariableList &variables) override;
-  void FindFunctions(lldb_private::ConstString name,
+  void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info,
                      const lldb_private::CompilerDeclContext &parent_decl_ctx,
-                     lldb::FunctionNameType name_type_mask,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
   void FindFunctions(const lldb_private::RegularExpression &regex,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
   void
   FindTypes(lldb_private::ConstString name,
             const lldb_private::CompilerDeclContext &parent_decl_ctx,

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (sc.function) {
         continue;
       }
     }
     ++i;
   }
 }
 
 void SymbolFileDWARFDebugMap::FindFunctions(
-    ConstString name, const CompilerDeclContext &parent_decl_ctx,
-    FunctionNameType name_type_mask, bool include_inlines,
+    const Module::LookupInfo &lookup_info,
+    const CompilerDeclContext &parent_decl_ctx, bool include_inlines,
     SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   LLDB_SCOPED_TIMERF("SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
-                     name.GetCString());
+                     lookup_info.GetLookupName().GetCString());
 
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     uint32_t sc_idx = sc_list.GetSize();
-    oso_dwarf->FindFunctions(name, parent_decl_ctx, name_type_mask,
-                             include_inlines, sc_list);
+    oso_dwarf->FindFunctions(lookup_info, parent_decl_ctx, include_inlines,
+                             sc_list);
     if (!sc_list.IsEmpty()) {
       RemoveFunctionsWithModuleNotEqualTo(m_objfile_sp->GetModule(), sc_list,
                                           sc_idx);
     }
     return false;
   });
 }
 

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

uint32_t ResolveSymbolContext(const Address &so_addr,
                                 SymbolContext &sc) override;
   uint32_t ResolveSymbolContext(const SourceLocationSpec &src_location_spec,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContextList &sc_list) override;
 
   void GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
                 TypeList &type_list) override;
 
-  void FindFunctions(ConstString name,
+  void FindFunctions(const Module::LookupInfo &lookup_info,
                      const CompilerDeclContext &parent_decl_ctx,
-                     lldb::FunctionNameType name_type_mask,
                      bool include_inlines, SymbolContextList &sc_list) override;
 
   void FindFunctions(const RegularExpression &regex, bool include_inlines,
                      SymbolContextList &sc_list) override;
 
   void FindTypes(ConstString name, const CompilerDeclContext &parent_decl_ctx,
                  uint32_t max_matches,
                  llvm::DenseSet<SymbolFile *> &searched_symbol_files,

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

for (const SymbolAndOffset &result : results) {
     }
     default:
       continue;
     }
   }
 }
 
 void SymbolFileNativePDB::FindFunctions(
-    ConstString name, const CompilerDeclContext &parent_decl_ctx,
-    FunctionNameType name_type_mask, bool include_inlines,
+    const Module::LookupInfo &lookup_info,
+    const CompilerDeclContext &parent_decl_ctx, bool include_inlines,
     SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+  ConstString name = lookup_info.GetLookupName();
+  FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
   // For now we only support lookup by method name or full name.
   if (!(name_type_mask & eFunctionNameTypeFull ||
         name_type_mask & eFunctionNameTypeMethod))
     return;
 
   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
 
   std::vector<SymbolAndOffset> matches = m_index->globals().findRecordsByName(

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

FindGlobalVariables(lldb_private::ConstString name,
                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
                            uint32_t max_matches,
                            lldb_private::VariableList &variables) override;
 
-  void FindFunctions(lldb_private::ConstString name,
+  void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info,
                      const lldb_private::CompilerDeclContext &parent_decl_ctx,
-                     lldb::FunctionNameType name_type_mask,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void FindFunctions(const lldb_private::RegularExpression &regex,
                      bool include_inlines,
                      lldb_private::SymbolContextList &sc_list) override;
 
   void GetMangledNamesForFunction(

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

void SymbolFilePDB::CacheFunctionNames() {
   m_func_full_names.SizeToFit();
   m_func_method_names.Sort();
   m_func_method_names.SizeToFit();
   m_func_base_names.Sort();
   m_func_base_names.SizeToFit();
 }
 
 void SymbolFilePDB::FindFunctions(
-    lldb_private::ConstString name,
+    const lldb_private::Module::LookupInfo &lookup_info,
     const lldb_private::CompilerDeclContext &parent_decl_ctx,
-    FunctionNameType name_type_mask, bool include_inlines,
+    bool include_inlines,
     lldb_private::SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+  ConstString name = lookup_info.GetLookupName();
+  FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
   lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0);
 
   if (name_type_mask == eFunctionNameTypeNone)
     return;
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
   if (name.IsEmpty())
     return;

lldb/source/Symbol/SymbolFile.cpp

void SymbolFile::FindGlobalVariables(ConstString name,
                                      const CompilerDeclContext &parent_decl_ctx,
                                      uint32_t max_matches,
                                      VariableList &variables) {}
 
 void SymbolFile::FindGlobalVariables(const RegularExpression &regex,
                                      uint32_t max_matches,
                                      VariableList &variables) {}
 
-void SymbolFile::FindFunctions(ConstString name,
+void SymbolFile::FindFunctions(const Module::LookupInfo &lookup_info,
                                const CompilerDeclContext &parent_decl_ctx,
-                               lldb::FunctionNameType name_type_mask,
                                bool include_inlines,
                                SymbolContextList &sc_list) {}
 
 void SymbolFile::FindFunctions(const RegularExpression &regex,
                                bool include_inlines,
                                SymbolContextList &sc_list) {}
 
 void SymbolFile::GetMangledNamesForFunction(

lldb/source/Symbol/SymbolFileOnDemand.cpp

if (!m_debug_info_enabled) {
     // Found match in symbol table hydrate debug info and
     // allow the FindFucntions to go through.
     SetLoadDebugInfoEnabled();
   }
   return m_sym_file_impl->FindFunctions(regex, include_inlines, sc_list);
 }
 
 void SymbolFileOnDemand::FindFunctions(
-    ConstString name, const CompilerDeclContext &parent_decl_ctx,
-    FunctionNameType name_type_mask, bool include_inlines,
+    const Module::LookupInfo &lookup_info,
+    const CompilerDeclContext &parent_decl_ctx, bool include_inlines,
     SymbolContextList &sc_list) {
+  ConstString name = lookup_info.GetLookupName();
+  FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
   if (!m_debug_info_enabled) {
     Log *log = GetLog();
 
     Symtab *symtab = GetSymtab();
     if (!symtab) {
       LLDB_LOG(log, "[{0}] {1}({2}) is skipped  - fail to get symtab",
                GetSymbolFileName(), __FUNCTION__, name);
       return;
     }
 
     SymbolContextList sc_list_helper;
     symtab->FindFunctionSymbols(name, name_type_mask, sc_list_helper);
     if (sc_list_helper.GetSize() == 0) {
       LLDB_LOG(log, "[{0}] {1}({2}) is skipped - fail to find match in symtab",
                GetSymbolFileName(), __FUNCTION__, name);
       return;
     }
     LLDB_LOG(log, "[{0}] {1}({2}) is NOT skipped - found match in symtab",
              GetSymbolFileName(), __FUNCTION__, name);
 
     // Found match in symbol table hydrate debug info and
     // allow the FindFucntions to go through.
     SetLoadDebugInfoEnabled();
   }
-  return m_sym_file_impl->FindFunctions(name, parent_decl_ctx, name_type_mask,
+  return m_sym_file_impl->FindFunctions(lookup_info, parent_decl_ctx,
                                         include_inlines, sc_list);
 }
 
 void SymbolFileOnDemand::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
     std::vector<ConstString> &mangled_names) {
   if (!m_debug_info_enabled) {
     Log *log = GetLog();

lldb/tools/lldb-test/lldb-test.cpp

Error opts::symbols::findFunctions(lldb_private::Module &Module) {
   } else {
     Expected<CompilerDeclContext> ContextOr = getDeclContext(Symfile);
     if (!ContextOr)
       return ContextOr.takeError();
     const CompilerDeclContext &ContextPtr =
         ContextOr->IsValid() ? *ContextOr : CompilerDeclContext();
 
     List.Clear();
-    Symfile.FindFunctions(ConstString(Name), ContextPtr, getFunctionNameFlags(),
-                         true, List);
+    Module::LookupInfo lookup_info(ConstString(Name), getFunctionNameFlags(),
+                                   eLanguageTypeUnknown);
+    Symfile.FindFunctions(lookup_info, ContextPtr, true, List);
   }
   outs() << formatv("Found {0} functions:\n", List.GetSize());
   StreamString Stream;
   List.Dump(&Stream, nullptr);
   outs() << Stream.GetData() << "\n";
   return Error::success();
 }