Mangled class additions for handling language dependent demangling cases

[KLapshin]

Summary

This patch includes following changes:

•Add Language member to Mangled class with corresponding constructor. Minor refactoring in places where Mangled instances used.
•Function name demangling depending on its compile unit actual language - for example taking Pascal and Java namespace separator into account.
•Enable demangling for case if function/sym language still unknown at moment when demangling requested.
•Flag indicating known language was set added. Demangler now is able to re-demangle given sym name if it language was actualized since Mangled object creation. Demangling against unknown language is allowed because in lldb unknown language means C++/ObjC in most cases implicitly.

[clayborg]

As I stated in another change that was submitted, nothing can be added to the Mangled class. It is used in lldb_private::Symbol and this is one of the largest contributor to memory in LLDB.

The language should be able to be calculated on the fly using the mangled name. We already have an accessor that can get the language from a mangled name and that should be made to work.

To be very clear: no new members in the Mangled class.

[KLapshin]

Hello Greg,

Thank you so much for review, I got your main points regarding how language should be taken into account in demangling - your proposal is do demangling upon mangled string prefixes stored in mangled string by itself, not on additional members (flags and Language) in Mangled class.

So my patch should be redesigned from scratch.

Thank you.

[KLapshin]

Patch recalled due to concept was not accepted as good enough to apply.

include/lldb/Core/Mangled.h

 
 #include "lldb/lldb-private.h"
 #include "lldb/Core/ConstString.h"
+#include "lldb/Core/Language.h"
 #include <vector>
 
 namespace lldb_private {

     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

 
     //----------------------------------------------------------------------
     /// 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

     ///     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_language_was_set;    ///< Flag, means known language was set explicitly
 };
 
 

source/Core/Mangled.cpp

 //----------------------------------------------------------------------
 Mangled::Mangled (const ConstString &s, bool mangled) :
     m_mangled(),
-    m_demangled()
+    m_demangled(),
+    m_language(lldb::eLanguageTypeUnknown),
+    m_language_was_set(false)
 {
     if (s)
         SetValue(s, mangled);

 
 Mangled::Mangled (const ConstString &s) :
     m_mangled(),
-    m_demangled()
+    m_demangled(),
+    m_language(lldb::eLanguageTypeUnknown),
+    m_language_was_set(false)
 {
     if (s)
         SetValue(s);
 }
 
 //----------------------------------------------------------------------
+// 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_language_was_set(false)
+{
+    if (s)
+        SetValue(s, mangled);
+}
+
+//----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 Mangled::~Mangled ()

 {
     m_mangled.Clear();
     m_demangled.Clear();
+    m_language_was_set = false;
 }
 
 

 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_language_was_set)
     {
         // We need to generate and cache the demangled name.
         Timer scoped_timer (__PRETTY_FUNCTION__,

         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_language_was_set)
             {
                 // We didn't already mangle this name, demangle it and if all goes well
                 // add it to our map.

 
                 if (demangled_name)
                 {
-                    m_demangled.SetCStringWithMangledCounterpart(demangled_name, m_mangled);
+                    std::string temp_demangled_name(demangled_name);
+
+                    switch(m_language.GetLanguage())
+                    {
+                        case lldb::eLanguageTypePascal83:
+                        case lldb::eLanguageTypeJava:
+                            {
+                                const std::string cplusplus_sep("::");
+                                const std::string pascaljava_sep(".");
+                                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);
                 }
             }

             m_demangled.SetCString("");
         }
     }
-
+    m_language_was_set = false;
     return m_demangled;
 }
 

 {
     if (m_mangled && regex.Execute (m_mangled.AsCString()))
         return true;
-    
     if (GetDemangledName() && regex.Execute (m_demangled.AsCString()))
         return true;
     return false;

 }
 
 //----------------------------------------------------------------------
+// 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_language_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).
 //----------------------------------------------------------------------

     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.
 //----------------------------------------------------------------------

source/Expression/ClangExpressionDeclMap.cpp

     {
         // 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());
         

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

                     // 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());

                     // 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());

                 // 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());

source/Symbol/Function.cpp

     const Declaration *call_decl_ptr
 ) :
     FunctionInfo(name, decl_ptr),
-    m_mangled(ConstString(mangled), true),
+    // TODO: use function CompUnit language
+    m_mangled(ConstString(mangled), true, eLanguageTypeUnknown),
     m_call_decl (call_decl_ptr)
 {
 }

 {
     m_block.SetParentScope(this);
     assert(comp_unit != nullptr);
+    m_mangled.SetLanguage(comp_unit->GetLanguage());
 }
 
 Function::Function

     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 (),

 {
     m_block.SetParentScope(this);
     assert(comp_unit != nullptr);
+    m_mangled.SetLanguage(comp_unit->GetLanguage());
 }
 
 

source/Symbol/Symbol.cpp

     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)
 {

     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)
 {

source/Symbol/Variable.cpp

 ) :
     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),