[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

329

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

329

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

331

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

[aprantl]

lldb/include/lldb/Target/Language.h

331

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

331

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

lldb/include/lldb/Expression/IRExecutionUnit.h

private:
   ///     True <=> all allocations were performed successfully.
   bool WriteData(lldb::ProcessSP &process_sp);
 
   Status DisassembleFunction(Stream &stream, lldb::ProcessSP &process_sp);
 
   void CollectCandidateCNames(std::vector<ConstString> &C_names,
                               ConstString name);
 
-  void CollectCandidateCPlusPlusNames(std::vector<ConstString> &CPP_names,
-                                      const std::vector<ConstString> &C_names,
-                                      const SymbolContext &sc);
+  /// Generates a list of mangled function names from a list of
+  /// of similar mangled function names.
+  ///
+  /// \param[in] C_names List of mangled names to generate
+  ///                    alternatives for.
+  ///
+  /// \param[in] sc SymbolContext used to find approximately matching
+  ///               mangled function names.
+  ///
+  /// \returns List of mangled function names that are similar to
+  ///          the names in 'C_names'.
+  std::vector<ConstString>
+  CollectCandidateCPlusPlusNames(const std::vector<ConstString> &C_names,
 
   lldb::addr_t FindInSymbols(const std::vector<ConstString> &names,
                              const lldb_private::SymbolContext &sc,
                              bool &symbol_was_missing_weak);
 
   lldb::addr_t FindInRuntimes(const std::vector<ConstString> &names,
                               const lldb_private::SymbolContext &sc);
 

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[in] mangled_names List of mangled names to generate
+  ///                          alternatives for.
+  ///
+  /// \param[in] sc SymbolContext used to find approximately matching
+  ///               mangled function names.
+  ///
+  /// \returns List of mangled function names that are similar to
+  ///          the names in 'mangled_names'.
+  virtual std::vector<ConstString>
+  CollectAlternateFunctionNames(const std::vector<ConstString> &mangled_names,
+                                const SymbolContext &sc) const {
+    return {};
   }
 
 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

 
 void IRExecutionUnit::CollectCandidateCNames(std::vector<ConstString> &C_names,
                                              ConstString name) {
   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,
+std::vector<ConstString> IRExecutionUnit::CollectCandidateCPlusPlusNames(
     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);
-        }
-      }
+    return cpp_lang->CollectAlternateFunctionNames(C_names, sc);
 
-      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);
-    }
-  }
+  return {};
 }
 
 class LoadAddressResolver {
 public:
   LoadAddressResolver(Target *target, bool &symbol_was_missing_weak)
       : m_target(target), m_symbol_was_missing_weak(symbol_was_missing_weak) {}
 
   llvm::Optional<lldb::addr_t> Resolve(SymbolContextList &sc_list) {
lldb::addr_t IRExecutionUnit::FindInUserDefinedSymbols(
   }
 
   return LLDB_INVALID_ADDRESS;
 }
 
 lldb::addr_t IRExecutionUnit::FindSymbol(lldb_private::ConstString name,
                                          bool &missing_weak) {
   std::vector<ConstString> candidate_C_names;
-  std::vector<ConstString> candidate_CPlusPlus_names;
 
   CollectCandidateCNames(candidate_C_names, name);
 
   lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx, missing_weak);
   if (ret != LLDB_INVALID_ADDRESS)
     return ret;
 
   // If we find the symbol in runtimes or user defined symbols it can't be
   // a missing weak symbol.
   missing_weak = false;
   ret = FindInRuntimes(candidate_C_names, m_sym_ctx);
   if (ret != LLDB_INVALID_ADDRESS)
     return ret;
 
   ret = FindInUserDefinedSymbols(candidate_C_names, m_sym_ctx);
   if (ret != LLDB_INVALID_ADDRESS)
     return ret;
 
-  CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names,
-                                 m_sym_ctx);
-  ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx, missing_weak);
+  ret = FindInSymbols(
+      CollectCandidateCPlusPlusNames(candidate_C_names, m_sym_ctx), m_sym_ctx,
+      missing_weak);
   return ret;
 }
 
 void IRExecutionUnit::GetStaticInitializers(
     std::vector<lldb::addr_t> &static_initializers) {
   Log *log = GetLog(LLDBLog::Expressions);
 
   llvm::GlobalVariable *global_ctors =

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;
+  std::vector<ConstString>
+  CollectAlternateFunctionNames(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())
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++/");
 }
+
+std::vector<ConstString> CPlusPlusLanguage::CollectAlternateFunctionNames(
+    const std::vector<ConstString> &mangled_names,
+    const SymbolContext &sc) const {
+  std::vector<ConstString> results;
+  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);
+  }
+
+  return results;
+}