Summary: This option was added downstream in swift-lldb. This upstreams this option as it seems useful and also adds the missing tests.
Reviewers: #lldb, kwk, labath
Reviewed By: kwk, labath
Subscribers: labath, kwk, abidh, JDevlieghere, lldb-commits
Tags: #lldb, #upstreaming_lldb_s_downstream_patches
Differential Revision: https://reviews.llvm.org/D69944
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;
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;
--- /dev/null
+"""
+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"])
--- /dev/null
+--- !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
+...
}
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,
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,
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_sort_order = eSortOrderNone;
+ m_prefer_mangled.Clear();
}
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
}
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);
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");
break;
num_dumped++;
DumpModuleSymtab(m_interpreter, result.GetOutputStream(), module,
- m_options.m_sort_order);
+ m_options.m_sort_order, name_preference);
}
}
} else
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 {
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))
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);
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;
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;
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;
}
}
}
-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();
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);
}
}
}