Index: include/lldb/Core/Mangled.h =================================================================== --- include/lldb/Core/Mangled.h +++ include/lldb/Core/Mangled.h @@ -14,6 +14,7 @@ #include "lldb/lldb-private.h" #include "lldb/Core/ConstString.h" +#include "lldb/Core/Language.h" #include namespace lldb_private { @@ -77,6 +78,22 @@ Mangled (const ConstString &name); //---------------------------------------------------------------------- + /// Construct with name and language. + /// + /// Constructor with an optional string, a boolean indicating if it is the + /// mangled version, and the preferred language. + /// + /// @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. + //---------------------------------------------------------------------- + explicit + Mangled (const ConstString &name, bool is_mangled, lldb::LanguageType language); + + //---------------------------------------------------------------------- /// Destructor /// /// Releases its ref counts on the mangled and demangled strings that @@ -292,7 +309,7 @@ //---------------------------------------------------------------------- /// Get the language only if it is definitive what the language is from - /// the mangling. + /// the mangling (or unless set via SetLanguage). /// /// For a mangled name to have a language it must have both a mangled /// and a demangled name and it must be definitive from the mangling @@ -307,14 +324,27 @@ /// if there is no mangled or demangled counterpart. //---------------------------------------------------------------------- lldb::LanguageType - GetLanguage (); + GetLanguage () const; + //---------------------------------------------------------------------- + /// Set accessor for the language object, associated with Mangled + /// instance. + /// + /// @param[in] language + /// The new enumeration value that describes the programming + /// language that a Mangled is associated with. + //------------------------------------------------------------------ + void + SetLanguage (lldb::LanguageType language); + private: //---------------------------------------------------------------------- /// Mangled member variables. //---------------------------------------------------------------------- ConstString m_mangled; ///< The mangled version of the name mutable ConstString m_demangled; ///< Mutable so we can get it on demand with a const version of this object + Language m_language; ///< Language, used for taking into account language differences in demangling + mutable bool m_bLanguage_was_set; ///< Flag, means known language was set explicitly }; Index: source/Core/Mangled.cpp =================================================================== --- source/Core/Mangled.cpp +++ source/Core/Mangled.cpp @@ -5089,6 +5089,20 @@ } //---------------------------------------------------------------------- +// Constructor with an optional string, a boolean indicating if it is the +// mangled version, and the preferred language. +//---------------------------------------------------------------------- +Mangled::Mangled (const ConstString &s, bool mangled, lldb::LanguageType language) : + m_mangled(), + m_demangled(), + m_language(language), + m_bLanguage_was_set(false) +{ + if (s) + SetValue(s, mangled); +} + +//---------------------------------------------------------------------- // Destructor //---------------------------------------------------------------------- Mangled::~Mangled () @@ -5130,6 +5144,7 @@ { m_mangled.Clear(); m_demangled.Clear(); + m_bLanguage_was_set = false; } @@ -5206,8 +5221,9 @@ Mangled::GetDemangledName () const { // Check to make sure we have a valid mangled name and that we - // haven't already decoded our mangled name. - if (m_mangled && !m_demangled) + // haven't already decoded our mangled name or language was re-set since object created. + if ((m_mangled && !m_demangled) + || m_bLanguage_was_set) { // We need to generate and cache the demangled name. Timer scoped_timer (__PRETTY_FUNCTION__, @@ -5218,7 +5234,8 @@ const char *mangled_cstr = m_mangled.GetCString(); if (cstring_is_mangled(mangled_cstr)) { - if (!m_mangled.GetMangledCounterpart(m_demangled)) + if (!m_mangled.GetMangledCounterpart(m_demangled) + || m_bLanguage_was_set) { // We didn't already mangle this name, demangle it and if all goes well // add it to our map. @@ -5251,7 +5268,25 @@ if (demangled_name) { - m_demangled.SetCStringWithMangledCounterpart(demangled_name, m_mangled); + std::string temp_demangled_name(demangled_name); + std::string cplusplus_sep("::"); + std::string pascaljava_sep("."); + + switch(m_language.GetLanguage()) + { + case lldb::eLanguageTypePascal83: + case lldb::eLanguageTypeJava: + { + size_t start_pos = temp_demangled_name.find(cplusplus_sep, 0); + while(start_pos != std::string::npos) + { + temp_demangled_name.replace(start_pos, cplusplus_sep.length(), pascaljava_sep); + start_pos = temp_demangled_name.find(cplusplus_sep, start_pos); + } + } + default : + m_demangled.SetCStringWithMangledCounterpart(temp_demangled_name.c_str(), m_mangled); + } free (demangled_name); } } @@ -5263,7 +5298,7 @@ m_demangled.SetCString(""); } } - + m_bLanguage_was_set = false; return m_demangled; } @@ -5310,6 +5345,26 @@ } //---------------------------------------------------------------------- +// Get current language. +//---------------------------------------------------------------------- +lldb::LanguageType +Mangled::GetLanguage () const +{ + return m_language.GetLanguage(); +} + +//---------------------------------------------------------------------- +// Set current language. +//---------------------------------------------------------------------- +void +Mangled::SetLanguage (lldb::LanguageType language) +{ + m_language.SetLanguage(language); + if (m_language.GetLanguage() != lldb::eLanguageTypeUnknown) + m_bLanguage_was_set = true; +} + +//---------------------------------------------------------------------- // Dump a Mangled object to stream "s". We don't force our // demangled name to be computed currently (we don't use the accessor). //---------------------------------------------------------------------- @@ -5352,21 +5407,6 @@ return m_mangled.MemorySize() + m_demangled.MemorySize(); } -lldb::LanguageType -Mangled::GetLanguage () -{ - ConstString mangled = GetMangledName(); - if (mangled) - { - if (GetDemangledName()) - { - if (cstring_is_mangled(mangled.GetCString())) - return lldb::eLanguageTypeC_plus_plus; - } - } - return lldb::eLanguageTypeUnknown; -} - //---------------------------------------------------------------------- // Dump OBJ to the supplied stream S. //---------------------------------------------------------------------- Index: source/Expression/ClangExpressionDeclMap.cpp =================================================================== --- source/Expression/ClangExpressionDeclMap.cpp +++ source/Expression/ClangExpressionDeclMap.cpp @@ -569,9 +569,11 @@ { // Sometimes we get a mangled name for a global function that actually should be "extern C." // This is a hack to compensate. - + const bool is_mangled = true; - Mangled mangled(name, is_mangled); + LanguageType language = m_parser_vars->m_sym_ctx.comp_unit ? m_parser_vars->m_sym_ctx.comp_unit->GetLanguage() : eLanguageTypeUnknown; + + Mangled mangled(name, is_mangled, language); CPPLanguageRuntime::MethodName method_name(mangled.GetDemangledName()); Index: source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp =================================================================== --- source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp +++ source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp @@ -853,7 +853,8 @@ // with duplicate entries if (name != mangled_cstr && ((mangled_cstr[0] == '_') || (name && ::strcmp(name, mangled_cstr) != 0))) { - Mangled mangled (ConstString(mangled_cstr), true); + LanguageType cu_language = (LanguageType)die.GetAttributeValueAsUnsigned(m_dwarf2Data, this, DW_AT_language, 0); + Mangled mangled (ConstString(mangled_cstr), true, cu_language); func_fullnames.Insert (mangled.GetMangledName(), die.GetOffset()); if (mangled.GetDemangledName()) func_fullnames.Insert (mangled.GetDemangledName(), die.GetOffset()); @@ -875,7 +876,8 @@ // with duplicate entries if (name != mangled_cstr && ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) { - Mangled mangled (ConstString(mangled_cstr), true); + LanguageType cu_language = (LanguageType)die.GetAttributeValueAsUnsigned(m_dwarf2Data, this, DW_AT_language, 0); + Mangled mangled (ConstString(mangled_cstr), true, cu_language); func_fullnames.Insert (mangled.GetMangledName(), die.GetOffset()); if (mangled.GetDemangledName()) func_fullnames.Insert (mangled.GetDemangledName(), die.GetOffset()); @@ -922,7 +924,8 @@ // with duplicate entries if (mangled_cstr && name != mangled_cstr && ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) { - Mangled mangled (ConstString(mangled_cstr), true); + LanguageType cu_language = (LanguageType)die.GetAttributeValueAsUnsigned(m_dwarf2Data, this, DW_AT_language, 0); + Mangled mangled (ConstString(mangled_cstr), true, cu_language); globals.Insert (mangled.GetMangledName(), die.GetOffset()); if (mangled.GetDemangledName()) globals.Insert (mangled.GetDemangledName(), die.GetOffset()); Index: source/Symbol/Function.cpp =================================================================== --- source/Symbol/Function.cpp +++ source/Symbol/Function.cpp @@ -216,6 +216,7 @@ { m_block.SetParentScope(this); assert(comp_unit != nullptr); + m_mangled.SetLanguage(comp_unit->GetLanguage()); } Function::Function @@ -231,7 +232,7 @@ m_comp_unit (comp_unit), m_type_uid (type_uid), m_type (type), - m_mangled (ConstString(mangled), true), + m_mangled (ConstString(mangled), true, eLanguageTypeUnknown), m_block (func_uid), m_range (range), m_frame_base (), @@ -240,6 +241,7 @@ { m_block.SetParentScope(this); assert(comp_unit != nullptr); + m_mangled.SetLanguage(comp_unit->GetLanguage()); } Index: source/Symbol/Symbol.cpp =================================================================== --- source/Symbol/Symbol.cpp +++ source/Symbol/Symbol.cpp @@ -71,7 +71,8 @@ m_size_is_valid (size_is_valid || size > 0), m_demangled_is_synthesized (false), m_type (type), - m_mangled (ConstString(name), name_is_mangled), + // TODO: use context language + m_mangled(ConstString(name), name_is_mangled, eLanguageTypeUnknown), m_addr_range (section_sp, offset, size), m_flags (flags) { @@ -103,7 +104,8 @@ m_size_is_valid (size_is_valid || range.GetByteSize() > 0), m_demangled_is_synthesized (false), m_type (type), - m_mangled (ConstString(name), name_is_mangled), + // TODO: use context language + m_mangled(ConstString(name), name_is_mangled, eLanguageTypeUnknown), m_addr_range (range), m_flags (flags) { Index: source/Symbol/Variable.cpp =================================================================== --- source/Symbol/Variable.cpp +++ source/Symbol/Variable.cpp @@ -47,7 +47,8 @@ ) : UserID(uid), m_name(name), - m_mangled (ConstString(mangled), true), + // TODO: language + m_mangled(ConstString(mangled), true, eLanguageTypeUnknown), m_symfile_type_sp(symfile_type_sp), m_scope(scope), m_owner_scope(context),