[lldb] Add -m option to 'target modules dump symtab' to disable demangling

[teemperor]

Summary

This option was added downstream in swift-lldb. This upstreams this option as it seems useful and also adds the missing tests.

[teemperor]

I'll add a Windows-specific test as a follow-up (because that test will probably involve fixing the Windows bot and I don't want this reverted).

[kwk]

LGTM with the exception of a local variable name.

lldb/source/Commands/CommandObjectTarget.cpp

2008

How about calling this variable name_preference?

[labath]

You could just make a YAML file with some symbols inside. That would isolate you from any host mangling specifics (which I think is a good thing, as this test is really about the command line option, and not mangling).

[kwk]

lldb/source/Commands/Options.td

8

Does it make sense to tell what the default is here?

[teemperor]

• Renamed variable.
• Now using yaml2obj

[teemperor]

lldb/source/Commands/Options.td

8

It seems to me this is implied because this option is only offering to turn it off.

[labath]

BTW, is it possible to prune the yaml to remove the stuff irrelevant for the test? I'm not that familiar with how macho2yaml works, but the equivalent elf representation of this can be as short as:

--- !ELF
FileHeader:
  Class:           ELFCLASS64
  Data:            ELFDATA2LSB
  Type:            ET_REL
  Machine:         EM_X86_64
Sections:
  - Name:            .text
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
    AddressAlign:    0x0000000000000010
    Content:         554889E5897DFC5DC3
Symbols:
  - Name:            _ZN3foo3barEi
    Type:            STT_FUNC
    Section:         .text
    Size:            0x0000000000000009
...

[teemperor]

• Blatantly steal Pavel's yaml file as MachO seems very verbose.

lldb/include/lldb/Symbol/Symbol.h

public:
   Symbol(const Symbol &rhs);
 
   const Symbol &operator=(const Symbol &rhs);
 
   void Clear();
 
   bool Compare(ConstString name, lldb::SymbolType type) const;
 
-  void Dump(Stream *s, Target *target, uint32_t index) const;
+  void Dump(Stream *s, Target *target, uint32_t index,
+            Mangled::NamePreference name_preference =
+                Mangled::ePreferDemangled) const;
 
   bool ValueIsAddress() const;
 
   // The GetAddressRef() accessor functions should only be called if you
   // previously call ValueIsAddress() otherwise you might get an reference to
   // an Address object that contains an constant integer value in
   // m_addr_range.m_base_addr.m_offset which could be incorrectly used to
   // represent an absolute address since it has no section.

lldb/include/lldb/Symbol/Symtab.h

public:
   ~Symtab();
 
   void PreloadSymbols();
   void Reserve(size_t count);
   Symbol *Resize(size_t count);
   uint32_t AddSymbol(const Symbol &symbol);
   size_t GetNumSymbols() const;
   void SectionFileAddressesChanged();
-  void Dump(Stream *s, Target *target, SortOrder sort_type);
-  void Dump(Stream *s, Target *target, std::vector<uint32_t> &indexes) const;
+  void
+  Dump(Stream *s, Target *target, SortOrder sort_type,
+       Mangled::NamePreference name_preference = Mangled::ePreferDemangled);
+  void Dump(Stream *s, Target *target, std::vector<uint32_t> &indexes,
+            Mangled::NamePreference name_preference =
+                Mangled::ePreferDemangled) const;
   uint32_t GetIndexForSymbol(const Symbol *symbol) const;
   std::recursive_mutex &GetMutex() { return m_mutex; }
   Symbol *FindSymbolByID(lldb::user_id_t uid) const;
   Symbol *SymbolAtIndex(size_t idx);
   const Symbol *SymbolAtIndex(size_t idx) const;
   Symbol *FindSymbolWithType(lldb::SymbolType symbol_type,
                              Debug symbol_debug_type,
                              Visibility symbol_visibility, uint32_t &start_idx);

lldb/packages/Python/lldbsuite/test/commands/target/dump-symtab-demangle/TestDumpSymtabDemangle.py

+"""
+Test 'target modules dump symtab -m' doesn't demangle symbols.
+"""
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test(self):
+        src_dir = self.getSourceDir()
+        yaml_path = os.path.join(src_dir, "a.yaml")
+        yaml_base, ext = os.path.splitext(yaml_path)
+        obj_path = self.getBuildArtifact("main.o")
+        self.yaml2obj(yaml_path, obj_path)
+
+        # Create a target with the object file we just created from YAML
+        target = self.dbg.CreateTarget(obj_path)
+        self.assertTrue(target, VALID_TARGET)
+
+        # First test that we demangle by default and our mangled symbol isn't in the output.
+        self.expect("target modules dump symtab", substrs=["foo::bar(int)"])
+        self.expect("target modules dump symtab", matching=False, substrs=["_ZN3foo3barEi"])
+
+        # Turn off demangling and make sure that we now see the mangled name in the output.
+        self.expect("target modules dump symtab -m", substrs=["_ZN3foo3barEi"])

lldb/packages/Python/lldbsuite/test/commands/target/dump-symtab-demangle/a.yaml

+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000010
+    Content:         554889E5897DFC5DC3
+Symbols:
+  - Name:            _ZN3foo3barEi
+    Type:            STT_FUNC
+    Section:         .text
+    Size:            0x0000000000000009
+...

lldb/source/Commands/CommandObjectTarget.cpp

for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
       }
     }
     strm.IndentLess();
   }
   return num_dumped;
 }
 
 static void DumpModuleSymtab(CommandInterpreter &interpreter, Stream &strm,
-                             Module *module, SortOrder sort_order) {
+                             Module *module, SortOrder sort_order,
+                             Mangled::NamePreference name_preference) {
   if (!module)
     return;
   if (Symtab *symtab = module->GetSymtab())
     symtab->Dump(&strm, interpreter.GetExecutionContext().GetTargetPtr(),
-                 sort_order);
+                 sort_order, name_preference);
 }
 
 static void DumpModuleSections(CommandInterpreter &interpreter, Stream &strm,
                                Module *module) {
   if (module) {
     SectionList *section_list = module->GetSectionList();
     if (section_list) {
       strm.Printf("Sections for '%s' (%s):\n",
public:
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
+      case 'm':
+        m_prefer_mangled.SetCurrentValue(true);
+        m_prefer_mangled.SetOptionWasSet();
+        break;
+
       case 's':
         m_sort_order = (SortOrder)OptionArgParser::ToOptionEnum(
             option_arg, GetDefinitions()[option_idx].enum_values,
             eSortOrderNone, error);
         break;
 
       default:
         llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_sort_order = eSortOrderNone;
+      m_prefer_mangled.Clear();
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_target_modules_dump_symtab_options);
     }
 
     SortOrder m_sort_order;
+    OptionValueBoolean m_prefer_mangled = {false, false};
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();
     uint32_t num_dumped = 0;
+    Mangled::NamePreference name_preference =
+        (m_options.m_prefer_mangled ? Mangled::ePreferMangled
+                                    : Mangled::ePreferDemangled);
 
     uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
     result.GetOutputStream().SetAddressByteSize(addr_byte_size);
     result.GetErrorStream().SetAddressByteSize(addr_byte_size);
 
     if (command.GetArgumentCount() == 0) {
       // Dump all sections for all modules images
       std::lock_guard<std::recursive_mutex> guard(
if (command.GetArgumentCount() == 0) {
             result.GetOutputStream().EOL();
           }
           if (m_interpreter.WasInterrupted())
             break;
           num_dumped++;
           DumpModuleSymtab(
               m_interpreter, result.GetOutputStream(),
               target->GetImages().GetModulePointerAtIndexUnlocked(image_idx),
-              m_options.m_sort_order);
+              m_options.m_sort_order, name_preference);
         }
       } else {
         result.AppendError("the target has no associated executable images");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     } else {
       // Dump specified images (by basename or fullpath)
if (command.GetArgumentCount() == 0) {
               if (num_dumped > 0) {
                 result.GetOutputStream().EOL();
                 result.GetOutputStream().EOL();
               }
               if (m_interpreter.WasInterrupted())
                 break;
               num_dumped++;
               DumpModuleSymtab(m_interpreter, result.GetOutputStream(), module,
-                               m_options.m_sort_order);
+                               m_options.m_sort_order, name_preference);
             }
           }
         } else
           result.AppendWarningWithFormat(
               "Unable to find an image that matches '%s'.\n", arg_cstr);
       }
     }
 

lldb/source/Commands/Options.td

 include "OptionsBase.td"
 
 let Command = "target modules dump symtab" in {
   def tm_sort : Option<"sort", "s">, Group<1>,
     Desc<"Supply a sort order when dumping the symbol table.">,
     EnumArg<"SortOrder", "OptionEnumValues(g_sort_option_enumeration)">;
+  def tm_smn : Option<"show-mangled-names", "m">, Group<1>,
+    Desc<"Do not demangle symbol names before showing them.">;
 }
 
 let Command = "help" in {
   def help_hide_aliases : Option<"hide-aliases", "a">,
     Desc<"Hide aliases in the command list.">;
   def help_hide_user : Option<"hide-user-commands", "u">,
     Desc<"Hide user-defined commands from the list.">;
   def help_show_hidden : Option<"show-hidden-commands", "h">,

lldb/source/Symbol/Symbol.cpp

void Symbol::GetDescription(Stream *s, lldb::DescriptionLevel level,
   }
   ConstString demangled = m_mangled.GetDemangledName(GetLanguage());
   if (demangled)
     s->Printf(", name=\"%s\"", demangled.AsCString());
   if (m_mangled.GetMangledName())
     s->Printf(", mangled=\"%s\"", m_mangled.GetMangledName().AsCString());
 }
 
-void Symbol::Dump(Stream *s, Target *target, uint32_t index) const {
+void Symbol::Dump(Stream *s, Target *target, uint32_t index,
+                  Mangled::NamePreference name_preference) const {
   s->Printf("[%5u] %6u %c%c%c %-15s ", index, GetID(), m_is_debug ? 'D' : ' ',
             m_is_synthetic ? 'S' : ' ', m_is_external ? 'X' : ' ',
             GetTypeAsString());
 
   // Make sure the size of the symbol is up to date before dumping
   GetByteSize();
 
-  ConstString name = m_mangled.GetName(GetLanguage());
+  ConstString name = m_mangled.GetName(GetLanguage(), name_preference);
   if (ValueIsAddress()) {
     if (!m_addr_range.GetBaseAddress().Dump(s, nullptr,
                                             Address::DumpStyleFileAddress))
       s->Printf("%*s", 18, "");
 
     s->PutChar(' ');
 
     if (!m_addr_range.GetBaseAddress().Dump(s, target,

lldb/source/Symbol/Symtab.cpp

size_t Symtab::GetNumSymbols() const {
   return m_symbols.size();
 }
 
 void Symtab::SectionFileAddressesChanged() {
   m_name_to_index.Clear();
   m_file_addr_to_index_computed = false;
 }
 
-void Symtab::Dump(Stream *s, Target *target, SortOrder sort_order) {
+void Symtab::Dump(Stream *s, Target *target, SortOrder sort_order,
+                  Mangled::NamePreference name_preference) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   //    s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
   s->Indent();
   const FileSpec &file_spec = m_objfile->GetFileSpec();
   const char *object_name = nullptr;
   if (m_objfile->GetModule())
     object_name = m_objfile->GetModule()->GetObjectName().GetCString();
if (!m_symbols.empty()) {
     switch (sort_order) {
     case eSortOrderNone: {
       s->PutCString(":\n");
       DumpSymbolHeader(s);
       const_iterator begin = m_symbols.begin();
       const_iterator end = m_symbols.end();
       for (const_iterator pos = m_symbols.begin(); pos != end; ++pos) {
         s->Indent();
-        pos->Dump(s, target, std::distance(begin, pos));
+        pos->Dump(s, target, std::distance(begin, pos), name_preference);
       }
     } break;
 
     case eSortOrderByName: {
       // Although we maintain a lookup by exact name map, the table isn't
       // sorted by name. So we must make the ordered symbol list up ourselves.
       s->PutCString(" (sorted by name):\n");
       DumpSymbolHeader(s);
       typedef std::multimap<const char *, const Symbol *,
                             CStringCompareFunctionObject>
           CStringToSymbol;
       CStringToSymbol name_map;
       for (const_iterator pos = m_symbols.begin(), end = m_symbols.end();
            pos != end; ++pos) {
         const char *name = pos->GetName().AsCString();
         if (name && name[0])
           name_map.insert(std::make_pair(name, &(*pos)));
       }
 
       for (CStringToSymbol::const_iterator pos = name_map.begin(),
                                            end = name_map.end();
            pos != end; ++pos) {
         s->Indent();
-        pos->second->Dump(s, target, pos->second - &m_symbols[0]);
+        pos->second->Dump(s, target, pos->second - &m_symbols[0],
+                          name_preference);
       }
     } break;
 
     case eSortOrderByAddress:
       s->PutCString(" (sorted by address):\n");
       DumpSymbolHeader(s);
       if (!m_file_addr_to_index_computed)
         InitAddressIndexes();
       const size_t num_entries = m_file_addr_to_index.GetSize();
       for (size_t i = 0; i < num_entries; ++i) {
         s->Indent();
         const uint32_t symbol_idx = m_file_addr_to_index.GetEntryRef(i).data;
-        m_symbols[symbol_idx].Dump(s, target, symbol_idx);
+        m_symbols[symbol_idx].Dump(s, target, symbol_idx, name_preference);
       }
       break;
     }
   } else {
     s->PutCString("\n");
   }
 }
 
-void Symtab::Dump(Stream *s, Target *target,
-                  std::vector<uint32_t> &indexes) const {
+void Symtab::Dump(Stream *s, Target *target, std::vector<uint32_t> &indexes,
+                  Mangled::NamePreference name_preference) const {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   const size_t num_symbols = GetNumSymbols();
   // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
   s->Indent();
   s->Printf("Symtab %" PRIu64 " symbol indexes (%" PRIu64 " symbols total):\n",
             (uint64_t)indexes.size(), (uint64_t)m_symbols.size());
   s->IndentMore();
 
   if (!indexes.empty()) {
     std::vector<uint32_t>::const_iterator pos;
     std::vector<uint32_t>::const_iterator end = indexes.end();
     DumpSymbolHeader(s);
     for (pos = indexes.begin(); pos != end; ++pos) {
       size_t idx = *pos;
       if (idx < num_symbols) {
         s->Indent();
-        m_symbols[idx].Dump(s, target, idx);
+        m_symbols[idx].Dump(s, target, idx, name_preference);
       }
     }
   }
   s->IndentLess();
 }
 
 void Symtab::DumpSymbolHeader(Stream *s) {
   s->Indent("               Debug symbol\n");