From: Alex Langford Date: Tue, 14 Sep 2021 20:31:35 +0000 (-0700) Subject: [lldb] Refactor and rename CPlusPlusLanguage::FindAlternateFunctionManglings X-Git-Tag: upstream/15.0.7~31297 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a65f6aafe2d357cd83de62832a2bdae49a2d6749;p=platform%2Fupstream%2Fllvm.git [lldb] Refactor and rename CPlusPlusLanguage::FindAlternateFunctionManglings I have 2 goals with this change: 1. Disambiguate between CPlusPlus::FindAlternateFunctionManglings and IRExecutionUnit::FindBestAlternateMangledName. These are named very similar things, they try to do very similar things, but their approaches are different. This change should make it clear that one is generating possible alternate manglings (through some heuristics-based approach) and the other is finding alternate manglings (through searching the SymbolFile for potential matches). 2. Change GenerateAlternateFunctionManglings from a static method in CPlusPlusLanguage to a virtual method in Language. This will allow us to remove a direct use of CPlusPlusLanguage in IRExecutionUnit, further pushing it to be more general. This change doesn't meet this goal completely but allows for it to happen later. Though this doesn't remove IRExecutionUnit's dependency on CPlusPlusLanguage, it does bring us closer to that goal. Differential Revision: https://reviews.llvm.org/D109785 --- diff --git a/lldb/include/lldb/Target/Language.h b/lldb/include/lldb/Target/Language.h index 2ad9677..41a0a5e 100644 --- a/lldb/include/lldb/Target/Language.h +++ b/lldb/include/lldb/Target/Language.h @@ -293,6 +293,13 @@ public: static LanguageSet GetLanguagesSupportingTypeSystemsForExpressions(); static LanguageSet GetLanguagesSupportingREPLs(); + // 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 + GenerateAlternateFunctionManglings(const ConstString mangled) const { + return std::vector(); + } + protected: // Classes that inherit from Language can see and modify these diff --git a/lldb/source/Expression/IRExecutionUnit.cpp b/lldb/source/Expression/IRExecutionUnit.cpp index 5c58ee6..4306a9c 100644 --- a/lldb/source/Expression/IRExecutionUnit.cpp +++ b/lldb/source/Expression/IRExecutionUnit.cpp @@ -723,9 +723,11 @@ void IRExecutionUnit::CollectCandidateCPlusPlusNames( } } - std::set alternates; - CPlusPlusLanguage::FindAlternateFunctionManglings(name, alternates); - CPP_names.insert(CPP_names.end(), alternates.begin(), alternates.end()); + if (auto *cpp_lang = Language::FindPlugin(lldb::eLanguageTypeC_plus_plus)) { + std::vector alternates = + cpp_lang->GenerateAlternateFunctionManglings(name); + CPP_names.insert(CPP_names.end(), alternates.begin(), alternates.end()); + } } } diff --git a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp index 0a4d4fb..c839a3d 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp @@ -424,9 +424,10 @@ public: }; } // namespace -uint32_t CPlusPlusLanguage::FindAlternateFunctionManglings( - const ConstString mangled_name, std::set &alternates) { - const auto start_size = alternates.size(); +std::vector CPlusPlusLanguage::GenerateAlternateFunctionManglings( + const ConstString mangled_name) const { + std::vector alternates; + /// Get a basic set of alternative manglings for the given symbol `name`, by /// making a few basic possible substitutions on basic types, storage duration /// and `const`ness for the given symbol. The output parameter `alternates` @@ -439,7 +440,7 @@ uint32_t CPlusPlusLanguage::FindAlternateFunctionManglings( strncmp(mangled_name.GetCString(), "_ZNK", 4)) { std::string fixed_scratch("_ZNK"); fixed_scratch.append(mangled_name.GetCString() + 3); - alternates.insert(ConstString(fixed_scratch)); + alternates.push_back(ConstString(fixed_scratch)); } // Maybe we're looking for a static symbol but we thought it was global... @@ -447,7 +448,7 @@ uint32_t CPlusPlusLanguage::FindAlternateFunctionManglings( strncmp(mangled_name.GetCString(), "_ZL", 3)) { std::string fixed_scratch("_ZL"); fixed_scratch.append(mangled_name.GetCString() + 2); - alternates.insert(ConstString(fixed_scratch)); + alternates.push_back(ConstString(fixed_scratch)); } TypeSubstitutor TS; @@ -457,24 +458,24 @@ uint32_t CPlusPlusLanguage::FindAlternateFunctionManglings( // parameter, try finding matches which have the general case 'c'. if (ConstString char_fixup = TS.substitute(mangled_name.GetStringRef(), "a", "c")) - alternates.insert(char_fixup); + alternates.push_back(char_fixup); // long long parameter mangling 'x', may actually just be a long 'l' argument if (ConstString long_fixup = TS.substitute(mangled_name.GetStringRef(), "x", "l")) - alternates.insert(long_fixup); + alternates.push_back(long_fixup); // unsigned long long parameter mangling 'y', may actually just be unsigned // long 'm' argument if (ConstString ulong_fixup = TS.substitute(mangled_name.GetStringRef(), "y", "m")) - alternates.insert(ulong_fixup); + alternates.push_back(ulong_fixup); if (ConstString ctor_fixup = CtorDtorSubstitutor().substitute(mangled_name.GetStringRef())) - alternates.insert(ctor_fixup); + alternates.push_back(ctor_fixup); - return alternates.size() - start_size; + return alternates; } static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { diff --git a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h index 1939f43..df8172a 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h +++ b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h @@ -127,11 +127,8 @@ public: llvm::StringRef &context, llvm::StringRef &identifier); - // Given a mangled function name, calculates some alternative manglings since - // the compiler mangling may not line up with the symbol we are expecting - static uint32_t - FindAlternateFunctionManglings(const ConstString mangled, - std::set &candidates); + std::vector + GenerateAlternateFunctionManglings(const ConstString mangled) const override; // PluginInterface protocol ConstString GetPluginName() override; diff --git a/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp b/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp index e8e6a4c..20abd5a 100644 --- a/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp +++ b/lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp @@ -7,6 +7,8 @@ //===----------------------------------------------------------------------===// #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" #include "Plugins/Language/CPlusPlus/CPlusPlusNameParser.h" +#include "TestingSupport/SubsystemRAII.h" +#include "lldb/lldb-enumerations.h" #include "gmock/gmock.h" #include "gtest/gtest.h" @@ -185,29 +187,32 @@ TEST(CPlusPlusLanguage, ExtractContextAndIdentifier) { "operator<=>", context, basename)); } -static std::set FindAlternate(llvm::StringRef Name) { - std::set Results; - uint32_t Count = CPlusPlusLanguage::FindAlternateFunctionManglings( - ConstString(Name), Results); - EXPECT_EQ(Count, Results.size()); - std::set Strings; - for (ConstString Str : Results) - Strings.insert(std::string(Str.GetStringRef())); +static std::vector GenerateAlternate(llvm::StringRef Name) { + std::vector Strings; + if (Language *CPlusPlusLang = + Language::FindPlugin(lldb::eLanguageTypeC_plus_plus)) { + std::vector Results = + CPlusPlusLang->GenerateAlternateFunctionManglings(ConstString(Name)); + for (ConstString Str : Results) + Strings.push_back(std::string(Str.GetStringRef())); + } return Strings; } -TEST(CPlusPlusLanguage, FindAlternateFunctionManglings) { +TEST(CPlusPlusLanguage, GenerateAlternateFunctionManglings) { using namespace testing; - EXPECT_THAT(FindAlternate("_ZN1A1fEv"), + SubsystemRAII lang; + + EXPECT_THAT(GenerateAlternate("_ZN1A1fEv"), UnorderedElementsAre("_ZNK1A1fEv", "_ZLN1A1fEv")); - EXPECT_THAT(FindAlternate("_ZN1A1fEa"), Contains("_ZN1A1fEc")); - EXPECT_THAT(FindAlternate("_ZN1A1fEx"), Contains("_ZN1A1fEl")); - EXPECT_THAT(FindAlternate("_ZN1A1fEy"), Contains("_ZN1A1fEm")); - EXPECT_THAT(FindAlternate("_ZN1A1fEai"), Contains("_ZN1A1fEci")); - EXPECT_THAT(FindAlternate("_ZN1AC1Ev"), Contains("_ZN1AC2Ev")); - EXPECT_THAT(FindAlternate("_ZN1AD1Ev"), Contains("_ZN1AD2Ev")); - EXPECT_THAT(FindAlternate("_bogus"), IsEmpty()); + EXPECT_THAT(GenerateAlternate("_ZN1A1fEa"), Contains("_ZN1A1fEc")); + EXPECT_THAT(GenerateAlternate("_ZN1A1fEx"), Contains("_ZN1A1fEl")); + EXPECT_THAT(GenerateAlternate("_ZN1A1fEy"), Contains("_ZN1A1fEm")); + EXPECT_THAT(GenerateAlternate("_ZN1A1fEai"), Contains("_ZN1A1fEci")); + EXPECT_THAT(GenerateAlternate("_ZN1AC1Ev"), Contains("_ZN1AC2Ev")); + EXPECT_THAT(GenerateAlternate("_ZN1AD1Ev"), Contains("_ZN1AD2Ev")); + EXPECT_THAT(GenerateAlternate("_bogus"), IsEmpty()); } TEST(CPlusPlusLanguage, CPlusPlusNameParser) {