| //===-- Mangled.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 "lldb/Core/Mangled.h" | |
| #include "lldb/Core/DataFileCache.h" | |
| #include "lldb/Core/DemangledNameInfo.h" | |
| #include "lldb/Target/Language.h" | |
| #include "lldb/Utility/ConstString.h" | |
| #include "lldb/Utility/DataEncoder.h" | |
| #include "lldb/Utility/RegularExpression.h" | |
| #include "lldb/Utility/Stream.h" | |
| #include "lldb/lldb-enumerations.h" | |
| #include "llvm/ADT/STLExtras.h" | |
| #include "llvm/ADT/SmallString.h" | |
| #include "llvm/ADT/SmallVector.h" | |
| #include "llvm/ADT/StringRef.h" | |
| #include <mutex> | |
| #include <optional> | |
| #include <vector> | |
| using namespace lldb_private; | |
| #pragma mark Mangled | |
| namespace { | |
| struct RegisteredManglingScheme { | |
| llvm::SmallVector<llvm::SmallString<16>, 12> prefixes; | |
| /// If set, a name that starts with one of the prefixes must also match. | |
| Mangled::ManglingSchemeMatcher matches = nullptr; | |
| lldb::LanguageType language = lldb::eLanguageTypeUnknown; | |
| bool active = false; | |
| }; | |
| class ManglingSchemeRegistry { | |
| public: | |
| Mangled::ManglingScheme Register(llvm::ArrayRef<llvm::StringRef> prefixes, | |
| lldb::LanguageType language, | |
| Mangled::ManglingSchemeMatcher matches); | |
| void Unregister(Mangled::ManglingScheme scheme); | |
| lldb::LanguageType GetLanguage(Mangled::ManglingScheme scheme) const; | |
| Mangled::ManglingScheme Find(llvm::StringRef name) const; | |
| private: | |
| /// Returns the index of \p scheme in m_schemes, if it was registered. | |
| /// Requires m_mutex. | |
| std::optional<size_t> GetIndex(Mangled::ManglingScheme scheme) const; | |
| mutable std::mutex m_mutex; | |
| /// Indexed by scheme - eFirstRegisteredManglingScheme. Unregistered schemes | |
| /// are kept, so that registering them again returns the same scheme. | |
| std::vector<RegisteredManglingScheme> m_schemes; | |
| }; | |
| } // namespace | |
| static ManglingSchemeRegistry &GetManglingSchemeRegistry() { | |
| // Never destroyed, since other threads may still look up mangling schemes | |
| // while static destructors run at exit. | |
| static ManglingSchemeRegistry *g_registry = new ManglingSchemeRegistry(); | |
| return *g_registry; | |
| } | |
| static Mangled::ManglingScheme SchemeForIndex(size_t index) { | |
| return static_cast<Mangled::ManglingScheme>( | |
| Mangled::eFirstRegisteredManglingScheme + index); | |
| } | |
| /// Returns true if a name could start with both one of \p prefixes and a | |
| /// prefix of one of the active \p schemes. | |
| [[maybe_unused]] static bool | |
| OverlapsActiveScheme(llvm::ArrayRef<llvm::StringRef> prefixes, | |
| llvm::ArrayRef<RegisteredManglingScheme> schemes) { | |
| for (const RegisteredManglingScheme &scheme : schemes) { | |
| if (!scheme.active) | |
| continue; | |
| for (llvm::StringRef prefix : prefixes) | |
| for (llvm::StringRef other : scheme.prefixes) | |
| if (prefix.starts_with(other) || other.starts_with(prefix)) | |
| return true; | |
| } | |
| return false; | |
| } | |
| Mangled::ManglingScheme | |
| ManglingSchemeRegistry::Register(llvm::ArrayRef<llvm::StringRef> prefixes, | |
| lldb::LanguageType language, | |
| Mangled::ManglingSchemeMatcher matches) { | |
| std::lock_guard<std::mutex> guard(m_mutex); | |
| auto it = | |
| llvm::find_if(m_schemes, [&](const RegisteredManglingScheme &scheme) { | |
| return scheme.language == language && scheme.matches == matches && | |
| llvm::equal(scheme.prefixes, prefixes); | |
| }); | |
| const size_t index = std::distance(m_schemes.begin(), it); | |
| if (it == m_schemes.end()) { | |
| const bool full = Mangled::eFirstRegisteredManglingScheme + index >= | |
| Mangled::g_num_mangling_schemes; | |
| assert(!full && "too many mangling schemes"); | |
| if (full) | |
| return Mangled::eManglingSchemeNone; | |
| assert(!OverlapsActiveScheme(prefixes, m_schemes) && | |
| "mangling scheme prefixes overlap"); | |
| RegisteredManglingScheme &scheme = m_schemes.emplace_back(); | |
| scheme.prefixes.assign(prefixes.begin(), prefixes.end()); | |
| scheme.matches = matches; | |
| scheme.language = language; | |
| } | |
| m_schemes[index].active = true; | |
| return SchemeForIndex(index); | |
| } | |
| std::optional<size_t> | |
| ManglingSchemeRegistry::GetIndex(Mangled::ManglingScheme scheme) const { | |
| if (scheme < Mangled::eFirstRegisteredManglingScheme) | |
| return std::nullopt; | |
| size_t index = scheme - Mangled::eFirstRegisteredManglingScheme; | |
| if (index >= m_schemes.size()) | |
| return std::nullopt; | |
| return index; | |
| } | |
| void ManglingSchemeRegistry::Unregister(Mangled::ManglingScheme scheme) { | |
| std::lock_guard<std::mutex> guard(m_mutex); | |
| if (std::optional<size_t> index = GetIndex(scheme)) | |
| m_schemes[*index].active = false; | |
| } | |
| lldb::LanguageType | |
| ManglingSchemeRegistry::GetLanguage(Mangled::ManglingScheme scheme) const { | |
| std::lock_guard<std::mutex> guard(m_mutex); | |
| if (std::optional<size_t> index = GetIndex(scheme)) | |
| return m_schemes[*index].language; | |
| return lldb::eLanguageTypeUnknown; | |
| } | |
| Mangled::ManglingScheme | |
| ManglingSchemeRegistry::Find(llvm::StringRef name) const { | |
| std::lock_guard<std::mutex> guard(m_mutex); | |
| for (auto [index, scheme] : llvm::enumerate(m_schemes)) { | |
| if (!scheme.active || | |
| !llvm::any_of(scheme.prefixes, [&](llvm::StringRef prefix) { | |
| return name.starts_with(prefix); | |
| })) | |
| continue; | |
| // Prefixes don't overlap, so no other scheme can match the name. The | |
| // matcher runs under the lock, so it must not use the registry. | |
| if (scheme.matches && !scheme.matches(name)) | |
| return Mangled::eManglingSchemeNone; | |
| return SchemeForIndex(index); | |
| } | |
| return Mangled::eManglingSchemeNone; | |
| } | |
| Mangled::ManglingScheme | |
| Mangled::RegisterManglingScheme(llvm::ArrayRef<llvm::StringRef> prefixes, | |
| lldb::LanguageType language, | |
| ManglingSchemeMatcher matches) { | |
| return GetManglingSchemeRegistry().Register(prefixes, language, matches); | |
| } | |
| void Mangled::UnregisterManglingScheme(ManglingScheme scheme) { | |
| GetManglingSchemeRegistry().Unregister(scheme); | |
| } | |
| lldb::LanguageType | |
| Mangled::GetLanguageForManglingScheme(ManglingScheme scheme) { | |
| return GetManglingSchemeRegistry().GetLanguage(scheme); | |
| } | |
| bool Mangled::IsMangledName(llvm::StringRef name) { | |
| return Mangled::GetManglingScheme(name) != Mangled::eManglingSchemeNone; | |
| } | |
| Mangled::ManglingScheme Mangled::GetManglingScheme(llvm::StringRef name) { | |
| if (name.empty()) | |
| return Mangled::eManglingSchemeNone; | |
| return GetManglingSchemeRegistry().Find(name); | |
| } | |
| Mangled::Mangled(ConstString s) : m_mangled(), m_demangled() { | |
| if (s) | |
| SetValue(s); | |
| } | |
| Mangled::Mangled(llvm::StringRef name) { | |
| if (!name.empty()) | |
| SetValue(ConstString(name)); | |
| } | |
| // Convert to bool operator. This allows code to check any Mangled objects | |
| // to see if they contain anything valid using code such as: | |
| // | |
| // Mangled mangled(...); | |
| // if (mangled) | |
| // { ... | |
| Mangled::operator bool() const { return m_mangled || m_demangled; } | |
| // Clear the mangled and demangled values. | |
| void Mangled::Clear() { | |
| m_mangled.Clear(); | |
| m_demangled.Clear(); | |
| } | |
| // Compare the string values. | |
| int Mangled::Compare(const Mangled &a, const Mangled &b) { | |
| return ConstString::Compare(a.GetName(ePreferMangled), | |
| b.GetName(ePreferMangled)); | |
| } | |
| void Mangled::SetValue(ConstString name) { | |
| if (name) { | |
| if (IsMangledName(name.GetStringRef())) { | |
| m_demangled.Clear(); | |
| m_mangled = name; | |
| } else { | |
| m_demangled = name; | |
| m_mangled.Clear(); | |
| } | |
| } else { | |
| m_demangled.Clear(); | |
| m_mangled.Clear(); | |
| } | |
| } | |
| // Generate the demangled name on demand using this accessor. Code in this | |
| // class will need to use this accessor if it wishes to decode the demangled | |
| // name. The result is cached and will be kept until a new string value is | |
| // supplied to this object, or until the end of the object's lifetime. | |
| ConstString Mangled::GetDemangledName() const { | |
| if (!m_mangled) | |
| return m_demangled; | |
| // Re-use previously demangled names. | |
| if (!m_demangled.IsNull()) | |
| return m_demangled; | |
| if (m_mangled.GetMangledCounterpart(m_demangled) && !m_demangled.IsNull()) | |
| return m_demangled; | |
| // We didn't already demangle this name, demangle it and if all goes well | |
| // add it to our map. | |
| ManglingScheme scheme = GetManglingScheme(m_mangled.GetStringRef()); | |
| if (Language *lang = Language::FindPluginForManglingScheme(scheme)) { | |
| Language::DemangledName demangled = | |
| lang->DemangleSymbol(m_mangled, scheme, Language::DemangleOptions()); | |
| if (!demangled.name.empty()) | |
| m_demangled.SetStringWithMangledCounterpart(demangled.name, m_mangled); | |
| } | |
| if (m_demangled.IsNull()) { | |
| // Set the demangled string to the empty string to indicate we tried to | |
| // parse it once and failed. | |
| m_demangled.SetCString(""); | |
| } | |
| return m_demangled; | |
| } | |
| std::optional<DemangledNameInfo> Mangled::ComputeDemangledInfo() const { | |
| if (!m_mangled) | |
| return std::nullopt; | |
| ManglingScheme scheme = GetManglingScheme(m_mangled.GetStringRef()); | |
| Language *lang = Language::FindPluginForManglingScheme(scheme); | |
| if (!lang) | |
| return std::nullopt; | |
| Language::DemangleOptions options; | |
| options.want_info = true; | |
| return lang->DemangleSymbol(m_mangled, scheme, options).info; | |
| } | |
| ConstString Mangled::GetDisplayDemangledName() const { | |
| if (Language *lang = Language::FindPlugin(GuessLanguage())) | |
| return lang->GetDisplayDemangledName(*this); | |
| return GetDemangledName(); | |
| } | |
| bool Mangled::NameMatches(const RegularExpression ®ex) const { | |
| if (m_mangled && regex.Execute(m_mangled.GetStringRef())) | |
| return true; | |
| ConstString demangled = GetDemangledName(); | |
| return demangled && regex.Execute(demangled.GetStringRef()); | |
| } | |
| // Get the demangled name if there is one, else return the mangled name. | |
| ConstString Mangled::GetName(Mangled::NamePreference preference) const { | |
| if (preference == ePreferMangled && m_mangled) | |
| return m_mangled; | |
| // Call the accessor to make sure we get a demangled name in case it hasn't | |
| // been demangled yet... | |
| ConstString demangled = GetDemangledName(); | |
| if (preference == ePreferDemangledWithoutArguments) { | |
| if (Language *lang = Language::FindPlugin(GuessLanguage())) { | |
| return lang->GetDemangledFunctionNameWithoutArguments(*this); | |
| } | |
| } | |
| if (preference == ePreferDemangled) { | |
| if (demangled) | |
| return demangled; | |
| return m_mangled; | |
| } | |
| return demangled; | |
| } | |
| // Dump a Mangled object to stream "s". We don't force our demangled name to be | |
| // computed currently (we don't use the accessor). | |
| void Mangled::Dump(Stream *s) const { | |
| if (m_mangled) { | |
| *s << ", mangled = " << m_mangled; | |
| } | |
| if (m_demangled) | |
| s->Format(", demangled = {0}", m_demangled.GetStringRef()); | |
| } | |
| // Dumps a debug version of this string with extra object and state information | |
| // to stream "s". | |
| void Mangled::DumpDebug(Stream *s) const { | |
| s->Printf("%*p: Mangled mangled = ", static_cast<int>(sizeof(void *) * 2), | |
| static_cast<const void *>(this)); | |
| m_mangled.DumpDebug(s); | |
| s->PutCString(", demangled = "); | |
| m_demangled.DumpDebug(s); | |
| } | |
| // We "guess" the language because we can't determine a symbol's language from | |
| // it's name. For example, a Pascal symbol can be mangled using the C++ | |
| // Itanium scheme, and defined in a compilation unit within the same module as | |
| // other C++ units. In addition, different targets could have different ways | |
| // of mangling names from a given language, likewise the compilation units | |
| // within those targets. | |
| lldb::LanguageType Mangled::GuessLanguage() const { | |
| // The language that registered the mangling scheme knows the name best. | |
| if (m_mangled) { | |
| lldb::LanguageType language = GetLanguageForManglingScheme( | |
| GetManglingScheme(m_mangled.GetStringRef())); | |
| if (language != lldb::eLanguageTypeUnknown) | |
| return language; | |
| } | |
| lldb::LanguageType result = lldb::eLanguageTypeUnknown; | |
| // Ask each language plugin to check if the mangled name belongs to it. | |
| Language::ForEach([this, &result](Language *l) { | |
| if (l->SymbolNameFitsToLanguage(*this)) { | |
| result = l->GetLanguageType(); | |
| return IterationAction::Stop; | |
| } | |
| return IterationAction::Continue; | |
| }); | |
| return result; | |
| } | |
| // Dump OBJ to the supplied stream S. | |
| Stream &operator<<(Stream &s, const Mangled &obj) { | |
| if (obj.GetMangledName()) | |
| s << "mangled = '" << obj.GetMangledName() << "'"; | |
| ConstString demangled = obj.GetDemangledName(); | |
| if (demangled) | |
| s << ", demangled = '" << demangled << '\''; | |
| else | |
| s << ", demangled = <error>"; | |
| return s; | |
| } | |
| // When encoding Mangled objects we can get away with encoding as little | |
| // information as is required. The enumeration below helps us to efficiently | |
| // encode Mangled objects. | |
| enum MangledEncoding { | |
| /// If the Mangled object has neither a mangled name or demangled name we can | |
| /// encode the object with one zero byte using the Empty enumeration. | |
| Empty = 0u, | |
| /// If the Mangled object has only a demangled name and no mangled named, we | |
| /// can encode only the demangled name. | |
| DemangledOnly = 1u, | |
| /// If the mangle name can calculate the demangled name (it is the | |
| /// mangled/demangled counterpart), then we only need to encode the mangled | |
| /// name as the demangled name can be recomputed. | |
| MangledOnly = 2u, | |
| /// If we have a Mangled object with two different names that are not related | |
| /// then we need to save both strings. This can happen if we have a name that | |
| /// isn't a true mangled name, but we want to be able to lookup a symbol by | |
| /// name and type in the symbol table. We do this for Objective C symbols like | |
| /// "OBJC_CLASS_$_NSValue" where the mangled named will be set to | |
| /// "OBJC_CLASS_$_NSValue" and the demangled name will be manually set to | |
| /// "NSValue". If we tried to demangled the name "OBJC_CLASS_$_NSValue" it | |
| /// would fail, but in these cases we want these unrelated names to be | |
| /// preserved. | |
| MangledAndDemangled = 3u | |
| }; | |
| bool Mangled::Decode(const DataExtractor &data, lldb::offset_t *offset_ptr, | |
| const StringTableReader &strtab) { | |
| m_mangled.Clear(); | |
| m_demangled.Clear(); | |
| MangledEncoding encoding = (MangledEncoding)data.GetU8(offset_ptr); | |
| switch (encoding) { | |
| case Empty: | |
| return true; | |
| case DemangledOnly: | |
| m_demangled.SetString(strtab.Get(data.GetU32(offset_ptr))); | |
| return true; | |
| case MangledOnly: | |
| m_mangled.SetString(strtab.Get(data.GetU32(offset_ptr))); | |
| return true; | |
| case MangledAndDemangled: | |
| m_mangled.SetString(strtab.Get(data.GetU32(offset_ptr))); | |
| m_demangled.SetString(strtab.Get(data.GetU32(offset_ptr))); | |
| return true; | |
| } | |
| return false; | |
| } | |
| /// The encoding format for the Mangled object is as follows: | |
| /// | |
| /// uint8_t encoding; | |
| /// char str1[]; (only if DemangledOnly, MangledOnly) | |
| /// char str2[]; (only if MangledAndDemangled) | |
| /// | |
| /// The strings are stored as null-terminated UTF8 strings and str1 and str2 | |
| /// are only saved if we need them based on the encoding. | |
| /// | |
| /// Some mangled names have a mangled name that can be demangled by a | |
| /// plugin. These kinds of mangled objects know when the mangled and | |
| /// demangled names are the counterparts for each other. This is done | |
| /// because demangling is very expensive and avoiding demangling the | |
| /// same name twice saves us a lot of compute time. For these kinds of | |
| /// names we only need to save the mangled name and have the encoding | |
| /// set to "MangledOnly". | |
| /// | |
| /// If a mangled object has only a demangled name, then we save only that string | |
| /// and have the encoding set to "DemangledOnly". | |
| /// | |
| /// Some mangled objects have both mangled and demangled names, but the | |
| /// demangled name can not be computed from the mangled name. This is often used | |
| /// for runtime named, like Objective C runtime V2 and V3 names. Both these | |
| /// names must be saved and the encoding is set to "MangledAndDemangled". | |
| /// | |
| /// For a Mangled object with no names, we only need to set the encoding to | |
| /// "Empty" and not store any string values. | |
| void Mangled::Encode(DataEncoder &file, ConstStringTable &strtab) const { | |
| MangledEncoding encoding = Empty; | |
| if (m_mangled) { | |
| encoding = MangledOnly; | |
| if (m_demangled) { | |
| // We have both mangled and demangled names. If the demangled name is the | |
| // counterpart of the mangled name, then we only need to save the mangled | |
| // name. If they are different, we need to save both. | |
| ConstString s; | |
| if (!(m_mangled.GetMangledCounterpart(s) && s == m_demangled)) | |
| encoding = MangledAndDemangled; | |
| } | |
| } else if (m_demangled) { | |
| encoding = DemangledOnly; | |
| } | |
| file.AppendU8(encoding); | |
| switch (encoding) { | |
| case Empty: | |
| break; | |
| case DemangledOnly: | |
| file.AppendU32(strtab.Add(m_demangled)); | |
| break; | |
| case MangledOnly: | |
| file.AppendU32(strtab.Add(m_mangled)); | |
| break; | |
| case MangledAndDemangled: | |
| file.AppendU32(strtab.Add(m_mangled)); | |
| file.AppendU32(strtab.Add(m_demangled)); | |
| break; | |
| } | |
| } | |
| ConstString Mangled::GetBaseName() const { | |
| std::optional<DemangledNameInfo> demangled_info = ComputeDemangledInfo(); | |
| if (!demangled_info) | |
| return {}; | |
| ConstString demangled_name = GetDemangledName(); | |
| if (!demangled_name) | |
| return {}; | |
| const auto &range = demangled_info->BasenameRange; | |
| return ConstString( | |
| demangled_name.GetStringRef().slice(range.first, range.second)); | |
| } |