[lldb] abi_tag support 2/3 - Make FindBestAlternateFunctionMangledName local to the C++ language plugin

[Michael137]

Summary

This patch makes CPlusPlusLanguage::FindBestAlternateFunctionMangledName local
to CPlusPlusLanguage. We do so by creating a new API CollectAlternateFunctionNames.
Both APIs are called only by IRExecutionUnit. However, by having
FindBestAlternateFunctionMangledName local to the C++ plugin we can
change its implementation in C++-specific ways, which we plan to do
in follow-up commits that add Itanium mangle tree API support to
FindBestAlternateFunctionMangledName.

Testing

• API tests still pass

[Michael137]

• Rebase

[aprantl]

lldb/include/lldb/Target/Language.h

315

Why not return results? Are we expecting to add more results to an existing vector regularly?

[Michael137]

• Reword commit message

[Michael137]

lldb/include/lldb/Target/Language.h

315

No reason in particular. Just tried to keep it consistent with the other related APIs. Mainly to cause less confusion for reviewers. If we wanted to return the vector we'd have to at least change IRExecutionUnit::CollectCandidateCPlusPlusNames also.

[JDevlieghere]

lldb/include/lldb/Target/Language.h

317

I was wondering the same. I think it's worth the churn.

[aprantl]

lldb/include/lldb/Target/Language.h

317

Let's do it then (but this can be a follow-up NFC patch if that makes things easier).

[Michael137]

• Return std::vector instead of using an output argument

[Michael137]

lldb/include/lldb/Target/Language.h

317

Just did it in this patch. Made some questions in the third part of this patchset easier to answer

lldb/include/lldb/Target/Language.h

public:
 
   // Given a mangled function name, calculates some alternative manglings since
   // the compiler mangling may not line up with the symbol we are expecting.
   virtual std::vector<ConstString>
   GenerateAlternateFunctionManglings(const ConstString mangled) const {
     return std::vector<ConstString>();
   }
 
-  virtual ConstString
-  FindBestAlternateFunctionMangledName(const Mangled mangled,
-                                       const SymbolContext &sym_ctx) const {
-    return ConstString();
-  }
+  /// Generates a list of mangled function name alternatives
+  ///
+  /// \param[out] results Will contain alternative mangled
+  ///                     function names.
+  ///
+  /// \param[in] mangled_names List of mangled names to generate
+  ///                          alternatives for.
+  ///
+  /// \param[in] sc SymbolContext used to find approximately matching
+  ///               mangled function names.
+  virtual void
+  CollectAlternateFunctionNames(std::vector<ConstString> &results,
+                                const std::vector<ConstString> &mangled_names,
+                                const SymbolContext &sc) const {}
 
 protected:
   // Classes that inherit from Language can see and modify these
 
   Language();
 
 private:
   Language(const Language &) = delete;
   const Language &operator=(const Language &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_LANGUAGE_H

lldb/source/Expression/IRExecutionUnit.cpp

if (m_strip_underscore && name.AsCString()[0] == '_')
     C_names.insert(C_names.begin(), ConstString(&name.AsCString()[1]));
   C_names.push_back(name);
 }
 
 void IRExecutionUnit::CollectCandidateCPlusPlusNames(
     std::vector<ConstString> &CPP_names,
     const std::vector<ConstString> &C_names, const SymbolContext &sc) {
   if (auto *cpp_lang = Language::FindPlugin(lldb::eLanguageTypeC_plus_plus)) {
-    for (const ConstString &name : C_names) {
-      Mangled mangled(name);
-      if (cpp_lang->SymbolNameFitsToLanguage(mangled)) {
-        if (ConstString best_alternate =
-                cpp_lang->FindBestAlternateFunctionMangledName(mangled, sc)) {
-          CPP_names.push_back(best_alternate);
-        }
-      }
-
-      std::vector<ConstString> alternates =
-          cpp_lang->GenerateAlternateFunctionManglings(name);
-      CPP_names.insert(CPP_names.end(), alternates.begin(), alternates.end());
-
-      // As a last-ditch fallback, try the base name for C++ names.  It's
-      // terrible, but the DWARF doesn't always encode "extern C" correctly.
-      ConstString basename =
-          cpp_lang->GetDemangledFunctionNameWithoutArguments(mangled);
-      CPP_names.push_back(basename);
-    }
+    cpp_lang->CollectAlternateFunctionNames(CPP_names, C_names, sc);
   }
 }
 
 class LoadAddressResolver {
 public:
   LoadAddressResolver(Target *target, bool &symbol_was_missing_weak)
       : m_target(target), m_symbol_was_missing_weak(symbol_was_missing_weak) {}
 

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

public:
 
   static bool ExtractContextAndIdentifier(const char *name,
                                           llvm::StringRef &context,
                                           llvm::StringRef &identifier);
 
   std::vector<ConstString>
   GenerateAlternateFunctionManglings(const ConstString mangled) const override;
 
-  ConstString FindBestAlternateFunctionMangledName(
-      const Mangled mangled, const SymbolContext &sym_ctx) const override;
+  void
+  CollectAlternateFunctionNames(std::vector<ConstString> &results,
+                                const std::vector<ConstString> &mangled_names,
+                                const SymbolContext &sc) const override;
 
   // PluginInterface protocol
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_CPLUSPLUSLANGUAGE_H

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

std::vector<ConstString> CPlusPlusLanguage::GenerateAlternateFunctionManglings(
 
   if (ConstString ctor_fixup =
           CtorDtorSubstitutor().substitute(mangled_name.GetStringRef()))
     alternates.push_back(ctor_fixup);
 
   return alternates;
 }
 
-ConstString CPlusPlusLanguage::FindBestAlternateFunctionMangledName(
-    const Mangled mangled, const SymbolContext &sym_ctx) const {
+static ConstString FindBestAlternateFunctionMangledName(
+    const Mangled mangled, const SymbolContext &sym_ctx) {
   ConstString demangled = mangled.GetDemangledName();
   if (!demangled)
     return ConstString();
 
   CPlusPlusLanguage::MethodName cpp_name(demangled);
   std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
 
   if (!scope_qualified_name.size())
if (param_and_qual_matches.size())
     return param_and_qual_matches[0]; // It is assumed that there will be only
                                       // one!
   else if (param_matches.size())
     return param_matches[0]; // Return one of them as a best match
   else
     return ConstString();
 }
 
+
 static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
   if (!cpp_category_sp)
     return;
 
   TypeSummaryImpl::Flags stl_summary_flags;
   stl_summary_flags.SetCascades(true)
       .SetSkipPointers(false)
       .SetSkipReferences(false)
for (auto suffix : suffixes) {
     if (file_path.endswith_insensitive(suffix))
       return true;
   }
 
   // Check if we're in a STL path (where the files usually have no extension
   // that we could check for.
   return file_path.contains("/usr/include/c++/");
 }
+
+void CPlusPlusLanguage::CollectAlternateFunctionNames(
+    std::vector<ConstString> &results,
+    const std::vector<ConstString> &mangled_names,
+    const SymbolContext &sc) const {
+  for (const ConstString &name : mangled_names) {
+    Mangled mangled(name);
+    if (SymbolNameFitsToLanguage(mangled)) {
+      if (ConstString best_alternate =
+              FindBestAlternateFunctionMangledName(mangled, sc)) {
+        results.push_back(best_alternate);
+      }
+    }
+
+    std::vector<ConstString> alternates =
+        GenerateAlternateFunctionManglings(name);
+    results.insert(results.end(), alternates.begin(), alternates.end());
+
+    // As a last-ditch fallback, try the base name for C++ names.  It's
+    // terrible, but the DWARF doesn't always encode "extern C" correctly.
+    ConstString basename =
+        GetDemangledFunctionNameWithoutArguments(mangled);
+    results.push_back(basename);
+  }
+}