Remove the is_mangled flag from Mangled and Symbol

[aprantl]

Summary

Testing whether a name is mangled or not is extremely cheap and can be done by looking at the first two characters. Mangled knows how to do it. On the flip side, many call sites that currently pass in an is_mangled determination do not know how to correctly do it (for example, they leave out Swift mangling prefixes).

This patch removes this entry point and just forced Mangled to determine the mangledness of a string itself.

[aprantl]

Updated unit test.

[davide]

LGTM

[JDevlieghere]

Neat!

[labath]

Looks like a nice cleanup, if we can get away with that. I tried to come up with a situation where we would have a more authoritative source on whether something is mangled or not than just looking at the string, but I haven't come up with anything, so the answer is hopefully yes.

lldb/include/lldb/Core/Mangled.h

public:
 
   /// Default constructor.
   ///
   /// Initialize with both mangled and demangled names empty.
   Mangled() = default;
 
   /// Construct with name.
   ///
-  /// Constructor with an optional string and a boolean indicating if it is
-  /// the mangled version.
-  ///
-  /// \param[in] name
-  ///     The already const name to copy into this object.
-  ///
-  /// \param[in] is_mangled
-  ///     If \b true then \a name is a mangled name, if \b false then
-  ///     \a name is demangled.
-  Mangled(ConstString name, bool is_mangled);
-  Mangled(llvm::StringRef name, bool is_mangled);
-
-  /// Construct with name.
-  ///
   /// Constructor with an optional string and auto-detect if \a name is
   /// mangled or not.
   ///
   /// \param[in] name
   ///     The already const name to copy into this object.
   explicit Mangled(ConstString name);
 
   explicit Mangled(llvm::StringRef name);
 
-  /// Destructor
-  ///
-  /// Releases its ref counts on the mangled and demangled strings that live
-  /// in the global string pool.
-  ~Mangled();
-
   /// Convert to pointer operator.
   ///
   /// This allows code to check a Mangled object to see if it contains a valid
   /// mangled name using code such as:
   ///
   /// \code
   /// Mangled mangled(...);
   /// if (mangled)

lldb/include/lldb/Symbol/Function.h

public:
   ///
   /// \param[in] decl_ptr
   ///     Optional declaration information that describes where the
   ///     function was declared. This can be NULL.
   ///
   /// \param[in] call_decl_ptr
   ///     Optional calling location declaration information that
   ///     describes from where this inlined function was called.
-  InlineFunctionInfo(const char *name, const char *mangled,
+  InlineFunctionInfo(const char *name, llvm::StringRef mangled,
                      const Declaration *decl_ptr,
                      const Declaration *call_decl_ptr);
 
   /// Construct with the function method name, mangled name, and optional
   /// declaration information.
   ///
   /// \param[in] name
   ///     A name for the method name for this function. This value

lldb/include/lldb/Symbol/Symbol.h

 
 class Symbol : public SymbolContextScope {
 public:
   // ObjectFile readers can classify their symbol table entries and searches
   // can be made on specific types where the symbol values will have
   // drastically different meanings and sorting requirements.
   Symbol();
 
-  Symbol(uint32_t symID, const char *name, bool name_is_mangled,
-         lldb::SymbolType type, bool external, bool is_debug,
-         bool is_trampoline, bool is_artificial,
+  Symbol(uint32_t symID, llvm::StringRef name, lldb::SymbolType type,
+         bool external, bool is_debug, bool is_trampoline, bool is_artificial,
          const lldb::SectionSP &section_sp, lldb::addr_t value,
          lldb::addr_t size, bool size_is_valid,
          bool contains_linker_annotations, uint32_t flags);
 
   Symbol(uint32_t symID, const Mangled &mangled, lldb::SymbolType type,
          bool external, bool is_debug, bool is_trampoline, bool is_artificial,
          const AddressRange &range, bool size_is_valid,
          bool contains_linker_annotations, uint32_t flags);

lldb/source/API/SBType.cpp

 
 const char *SBTypeMemberFunction::GetDemangledName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,
                              GetDemangledName);
 
   if (m_opaque_sp) {
     ConstString mangled_str = m_opaque_sp->GetMangledName();
     if (mangled_str) {
-      Mangled mangled(mangled_str, true);
+      Mangled mangled(mangled_str);
       return mangled.GetDemangledName(mangled.GuessLanguage()).GetCString();
     }
   }
   return nullptr;
 }
 
 const char *SBTypeMemberFunction::GetMangledName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction,

lldb/source/Core/Mangled.cpp

get_demangled_name_without_arguments(ConstString mangled,
 
   if (demangled)
     return g_last_demangled;
   return g_last_mangled;
 }
 
 #pragma mark Mangled
 
-// Constructor with an optional string and a boolean indicating if it is the
-// mangled version.
-Mangled::Mangled(ConstString s, bool mangled)
-    : m_mangled(), m_demangled() {
-  if (s)
-    SetValue(s, mangled);
-}
-
-Mangled::Mangled(llvm::StringRef name, bool is_mangled) {
-  if (!name.empty())
-    SetValue(ConstString(name), is_mangled);
-}
-
 Mangled::Mangled(ConstString s) : m_mangled(), m_demangled() {
   if (s)
     SetValue(s);
 }
 
 Mangled::Mangled(llvm::StringRef name) {
   if (!name.empty())
     SetValue(ConstString(name));
 }
 
-// Destructor
-Mangled::~Mangled() {}
-
 // Convert to pointer 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 void *() const {
   return (m_mangled) ? const_cast<Mangled *>(this) : nullptr;

lldb/source/Expression/IRExecutionUnit.cpp

FindBestAlternateMangledName(ConstString demangled,
 
   std::vector<ConstString> alternates;
   sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates);
 
   std::vector<ConstString> param_and_qual_matches;
   std::vector<ConstString> param_matches;
   for (size_t i = 0; i < alternates.size(); i++) {
     ConstString alternate_mangled_name = alternates[i];
-    Mangled mangled(alternate_mangled_name, true);
+    Mangled mangled(alternate_mangled_name);
     ConstString demangled = mangled.GetDemangledName(lang_type);
 
     CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
     if (!cpp_name.IsValid())
       continue;
 
     if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) {
       if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers())

 
 void IRExecutionUnit::CollectCandidateCPlusPlusNames(
     std::vector<IRExecutionUnit::SearchSpec> &CPP_specs,
     const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) {
   for (const SearchSpec &C_spec : C_specs) {
     ConstString name = C_spec.name;
 
     if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
-      Mangled mangled(name, true);
+      Mangled mangled(name);
       ConstString demangled =
           mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
 
       if (demangled) {
         ConstString best_alternate_mangled_name = FindBestAlternateMangledName(
             demangled, lldb::eLanguageTypeC_plus_plus, sc);
 
         if (best_alternate_mangled_name) {

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

for (auto &entry : command.entries()) {
       // command line if you're copying mangled names out of 'nm' on Darwin,
       // they will come out with an extra underscore - be willing to strip this
       // on behalf of the user.   This is the moral equivalent of the -_/-n
       // options to c++filt
       auto name = entry.ref();
       if (name.startswith("__Z"))
         name = name.drop_front();
 
-      Mangled mangled(name, true);
+      Mangled mangled(name);
       if (mangled.GuessLanguage() == lldb::eLanguageTypeC_plus_plus) {
         ConstString demangled(
             mangled.GetDisplayDemangledName(lldb::eLanguageTypeC_plus_plus));
         demangled_any = true;
         result.AppendMessageWithFormat("%s ---> %s\n", entry.c_str(),
                                        demangled.GetCString());
       } else {
         error_any = true;

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (symbol_section_sp && module_section_list &&
                          module_section_list->FindSectionByName(sect_name))
                 .first;
       if (section_it->second)
         symbol_section_sp = section_it->second;
     }
 
     bool is_global = symbol.getBinding() == STB_GLOBAL;
     uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags;
-    bool is_mangled = (symbol_name[0] == '_' && symbol_name[1] == 'Z');
-
     llvm::StringRef symbol_ref(symbol_name);
 
     // Symbol names may contain @VERSION suffixes. Find those and strip them
     // temporarily.
     size_t version_pos = symbol_ref.find('@');
     bool has_suffix = version_pos != llvm::StringRef::npos;
     llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
-    Mangled mangled(ConstString(symbol_bare), is_mangled);
+    Mangled mangled(symbol_bare);
 
     // Now append the suffix back to mangled and unmangled names. Only do it if
     // the demangling was successful (string is not empty).
     if (has_suffix) {
       llvm::StringRef suffix = symbol_ref.substr(version_pos);
 
       llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef();
       if (!mangled_name.empty())
for (i = 0; i < num_relocations; ++i) {
     if (reloc_type(rel) != slot_type)
       continue;
 
     lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize;
     if (!symbol.Parse(symtab_data, &symbol_offset))
       break;
 
     const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
-    bool is_mangled =
-        symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false;
     uint64_t plt_index = plt_offset + i * plt_entsize;
 
     Symbol jump_symbol(
         i + start_id,          // Symbol table index
         symbol_name,           // symbol name.
-        is_mangled,            // is the symbol name mangled?
         eSymbolTypeTrampoline, // Type of this symbol
         false,                 // Is this globally visible?
         false,                 // Is this symbol debug info?
         true,                  // Is this symbol a trampoline?
         true,                  // Is this symbol artificial?
         plt_section_sp, // Section in which this symbol is defined or null.
         plt_index,      // Offset in section or symbol value.
         plt_entsize,    // Size in bytes of this symbol.
if (symbol) {
           section_list->FindSectionContainingFileAddress(file_addr);
       if (section_sp) {
         addr_t offset = file_addr - section_sp->GetFileAddress();
         const char *symbol_name = GetNextSyntheticSymbolName().GetCString();
         uint64_t symbol_id = symbol_table->GetNumSymbols();
         Symbol eh_symbol(
             symbol_id,       // Symbol table index.
             symbol_name,     // Symbol name.
-            false,           // Is the symbol name mangled?
             eSymbolTypeCode, // Type of this symbol.
             true,            // Is this globally visible?
             false,           // Is this symbol debug info?
             false,           // Is this symbol a trampoline?
             true,            // Is this symbol artificial?
             section_sp,      // Section in which this symbol is defined or null.
             offset,          // Offset in section or symbol value.
             0,     // Size:          Don't specify the size as an FDE can

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

auto add_symbol = [&](addr_t address, llvm::Optional<addr_t> size,
     if (!section_sp) {
       LLDB_LOG(log,
                "Ignoring symbol {0}, whose address ({1}) is outside of the "
                "object file. Mismatched symbol file?",
                name, address);
       return;
     }
     symbols.try_emplace(
-        address, /*symID*/ 0, Mangled(name, /*is_mangled*/ false),
-        eSymbolTypeCode, /*is_global*/ true, /*is_debug*/ false,
+        address, /*symID*/ 0, Mangled(name), eSymbolTypeCode,
+        /*is_global*/ true, /*is_debug*/ false,
         /*is_trampoline*/ false, /*is_artificial*/ false,
         AddressRange(section_sp, address - section_sp->GetFileAddress(),
                      size.getValueOr(0)),
         size.hasValue(), /*contains_linker_annotations*/ false, /*flags*/ 0);
   };
 
   for (llvm::StringRef line : lines(Record::Func)) {
     if (auto record = FuncRecord::parse(line))

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

while (auto pub_symbol = results->getNext()) {
     if (sym_addresses.find(file_addr) != sym_addresses.end())
       continue;
     sym_addresses.insert(file_addr);
 
     auto size = pub_symbol->getLength();
     symtab.AddSymbol(
         Symbol(pub_symbol->getSymIndexId(),   // symID
                pub_symbol->getName().c_str(), // name
-               true,                          // name_is_mangled
                pub_symbol->isCode() ? eSymbolTypeCode : eSymbolTypeData, // type
                true,      // external
                false,     // is_debug
                false,     // is_trampoline
                false,     // is_artificial
                section,   // section_sp
                offset,    // value
                size,      // size

lldb/source/Symbol/Function.cpp

 }
 
 ConstString FunctionInfo::GetName() const { return m_name; }
 
 size_t FunctionInfo::MemorySize() const {
   return m_name.MemorySize() + m_declaration.MemorySize();
 }
 
-InlineFunctionInfo::InlineFunctionInfo(const char *name, const char *mangled,
+InlineFunctionInfo::InlineFunctionInfo(const char *name,
+                                       llvm::StringRef mangled,
                                        const Declaration *decl_ptr,
                                        const Declaration *call_decl_ptr)
-    : FunctionInfo(name, decl_ptr), m_mangled(ConstString(mangled), true),
+    : FunctionInfo(name, decl_ptr), m_mangled(mangled),
       m_call_decl(call_decl_ptr) {}
 
 InlineFunctionInfo::InlineFunctionInfo(ConstString name,
                                        const Mangled &mangled,
                                        const Declaration *decl_ptr,
                                        const Declaration *call_decl_ptr)
     : FunctionInfo(name, decl_ptr), m_mangled(mangled),
       m_call_decl(call_decl_ptr) {}

lldb/source/Symbol/Symbol.cpp

Symbol::Symbol()
     : SymbolContextScope(), m_uid(UINT32_MAX), m_type_data(0),
       m_type_data_resolved(false), m_is_synthetic(false), m_is_debug(false),
       m_is_external(false), m_size_is_sibling(false),
       m_size_is_synthesized(false), m_size_is_valid(false),
       m_demangled_is_synthesized(false), m_contains_linker_annotations(false),
       m_is_weak(false), m_type(eSymbolTypeInvalid), m_mangled(), m_addr_range(),
       m_flags() {}
 
-Symbol::Symbol(uint32_t symID, const char *name, bool name_is_mangled,
-               SymbolType type, bool external, bool is_debug,
-               bool is_trampoline, bool is_artificial,
+Symbol::Symbol(uint32_t symID, llvm::StringRef name, SymbolType type, bool external,
+               bool is_debug, bool is_trampoline, bool is_artificial,
                const lldb::SectionSP &section_sp, addr_t offset, addr_t size,
                bool size_is_valid, bool contains_linker_annotations,
                uint32_t flags)
     : SymbolContextScope(), m_uid(symID), m_type_data(0),
       m_type_data_resolved(false), m_is_synthetic(is_artificial),
       m_is_debug(is_debug), m_is_external(external), m_size_is_sibling(false),
       m_size_is_synthesized(false), m_size_is_valid(size_is_valid || size > 0),
       m_demangled_is_synthesized(false),
-      m_contains_linker_annotations(contains_linker_annotations), 
+      m_contains_linker_annotations(contains_linker_annotations),
       m_is_weak(false), m_type(type),
-      m_mangled(ConstString(name), name_is_mangled),
+      m_mangled(name),
       m_addr_range(section_sp, offset, size), m_flags(flags) {}
 
 Symbol::Symbol(uint32_t symID, const Mangled &mangled, SymbolType type,
                bool external, bool is_debug, bool is_trampoline,
                bool is_artificial, const AddressRange &range,
                bool size_is_valid, bool contains_linker_annotations,
                uint32_t flags)
     : SymbolContextScope(), m_uid(symID), m_type_data(0),

lldb/unittests/Core/MangledTest.cpp

 
 #include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 TEST(MangledTest, ResultForValidName) {
   ConstString MangledName("_ZN1a1b1cIiiiEEvm");
-  bool IsMangled = true;
-
-  Mangled TheMangled(MangledName, IsMangled);
+  Mangled TheMangled(MangledName);
   ConstString TheDemangled =
       TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
 
   ConstString ExpectedResult("void a::b::c<int, int, int>(unsigned long)");
   EXPECT_STREQ(ExpectedResult.GetCString(), TheDemangled.GetCString());
 }
 
 TEST(MangledTest, EmptyForInvalidName) {
   ConstString MangledName("_ZN1a1b1cmxktpEEvm");
-  bool IsMangled = true;
-
-  Mangled TheMangled(MangledName, IsMangled);
+  Mangled TheMangled(MangledName);
   ConstString TheDemangled =
       TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
 
   EXPECT_STREQ("", TheDemangled.GetCString());
 }
 
 TEST(MangledTest, NameIndexes_FindFunctionSymbols) {
   FileSystem::Initialize();