Better scheme to lookup alternate mangled name when looking up function address.

[sivachandra]

Summary

This change is relevant for inferiors compiled with GCC. GCC does not
emit complete debug info for std::basic_string<...>, and consequently, Clang
(the LLDB compiler) does not generate correct mangled names for certain
functions.

This change removes the hard-coded alternate names in
ItaniumABILanguageRuntime.cpp.

Before the hard-coded names were put in ItaniumABILanguageRuntime.cpp, one could
not evaluate std::string methods (ex. std::string::length). After putting in
the hard-coded names, one could evaluate them. However, it did not still
enable one to call methods on, say for example, std::vector<string>.
This change makes that possible.

There is some amount of incompleteness in this change. Consider the
following example:

std::string hello("hello"), world("world");
std::map<std::string, std::string> m;
m[hello] = world;

One can still not evaluate the expression "m[hello]" in LLDB. Will
address this issue in another pass.

[sivachandra]

Just a mention: This change does have an impact on expression evaluation performance and memory utilization.

[clayborg]

So let me try to understand. When we are asked during expressions to lookup some mangled named for "std::string::length()", it doesn't exist in GCC binaries. So we want to then find any alternate manglings and we do this by asking the symbol file to find alternate manglings for "std::string::length"? I.E. we remove the parens and any arguments and lookup just the fully qualified function name?

If so, we should just lookup functions using:

size_t
Module::FindFunctions (const ConstString &name,
               const CompilerDeclContext *parent_decl_ctx,
               uint32_t name_type_mask, 
               bool symbols_ok,
               bool inlines_ok,
               bool append, 
               SymbolContextList& sc_list);

And then look at all of the symbol contexts in sc_list and find a function that we want? I don't really see the need for any of the new SymbolFile::GetMangledNamesForFunction() functions.

[sivachandra]

I could very well be missing something obvious. However, let me explain what I am trying to solve here. Lets take the example of std::vector<string>::size method. The DWARF we get when compiled with GCC is as follows:

< 3><0x000020a3>        DW_TAG_subprogram
                          DW_AT_external              yes(1)
                          DW_AT_name                  "size"
                          DW_AT_decl_file             0x00000003 /usr/include/c++/4.8/bits/stl_vector.h
                          DW_AT_decl_line             0x00000285
                          DW_AT_linkage_name          "_ZNKSt6vectorISsSaISsEE4sizeEv"
                          DW_AT_type                  <0x00001eb1>
                          DW_AT_accessibility         DW_ACCESS_public
                          DW_AT_declaration           yes(1)
                          DW_AT_object_pointer        <0x000020bc>
                          DW_AT_sibling               <0x000020c2>

If we demangle the linkage name from here, we get "std::vector<std::string, std::allocator<std::string> >::size() const". So, the m_function_fullname_index of SymbolFileDWARF will have entry for this function with this full name.

However, due to missing debug info elsewhere, the IR generated by clang (the LLDB compiler), generates a mangled name like this:
"_ZNKSt6vectorISbIcSt17char_traits<char>St15allocator<char>ESt82allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >E4sizeEv"

This demangles to
"std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >::size() const"

Since neither the clang generated mangled name is present in the ELF symtab, and nor its corresponding demangled name is not present in any of the DWARF indices, the existing FindFunctions will not be helpful. Also, only functions with debug info (those which have an address specified in the DWARF) are indexed.

What I am doing in my change is to use the fact that all methods (and their types) are grokked while creating the AST for clang (the LLDB compiler). So, when a method is grokked, store a map from its scoped name to its DIE. Even if there were any discrepancies in the mangled name in the debug info versus that generated by the LLDB compiler, the fully scoped names should be the same. In which case, use the fully scoped name to get to the DIE and retrieve its "actual" mangled name.

[spyffe]

I LOVE the idea of getting rid of those horrid "alternate manglings." We knew what the mangling was during name lookup, we should be able to recognize them later!
As listed in my inline comments, I have some concerns about the scope. This knowledge is built up during expression parsing and used during expression parsing – we're done.
Thanks for working on this, Siva.

source/Expression/ClangExpressionDeclMap.cpp

661 ↗

(On Diff #34565)

This should definitely only be done if we can't find the name the original way. I'm always happy to pay extra runtime to fix an expression that would otherwise not work – but expressions that would work (the >90% case) shouldn't be paying for this.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

211

Why is this attached to the DWARF? I would want to attach this to the ClangExpressionDeclMap because we identify these alternate names during function name lookup, and we just need to remember them when resolving the references in IR. After that, they are no longer needed.

[sivachandra]

source/Expression/ClangExpressionDeclMap.cpp

661 ↗

(On Diff #34565)

The "original" way is still attempted first at line 643 above. Lines 669 to 674 below take care of another problem: http://reviews.llvm.org/D12613. Since that problem is much more a rare case than that solved in this change, I chose to keep this "try" before that "try".

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

211

My thinking was, DWARF is the only thing which knows about the correct mangled name, so keep it close to the code dealing with DWARF. Your suggestion also makes sense, but might (I have not yet thought enough about it) require us to expose DIE info into ClangExpressionDeclMap. I will think more about this approach and get back to you.

[sivachandra]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

211

I spent some time thinking about this. ClandExpressionDeclMap doesn't really explicitly lookup method names. If we have an expression like "v.size()", we lookup what "v" is, and that conveys to Clang about the existence of a method "size" in its class. The requirement for alternate names kicks in (so to say) when we are looking for the address of the method. I am not very clear on how we can cleanly keep track of all the methods parsed, while looking up variables, in ClangExpressionDeclMap and use that knowledge while looking up addresses. Do you have any suggestions?

I agree that it is indeed odd to have a method GetMangledNamesForFunction in SymbolFile which is useful only for expression evaluation. How about having a temp object that ClangExpressionDeclMap registers with SymbolFile, and cleans it up after expression evaluation is done? SymbolFile stuffs in to the object all info that ClangExpressionDeclMap could potentially use while parsing the DIEs. ExpressionEvaluationIndex?

[sivachandra]

Ping. Any suggestion on how to take this forward?

[clayborg]

Sean is the best person to answer your questions. I will ping him and have him comment.

[sivachandra]

Ping.
The patch in its current state will require a rebase. However, any suggestions on how to take this forward would be great. I can rebase and make modifications together.

[sivachandra]

Friendly periodic ping. Let me know if once in 2 days is too frequent.

[sivachandra]

Rebase.

[sivachandra]

Another friendly ping.

[sivachandra]

Ping. I have few follow up changes over whatever goes in here. Would greatly appreciate if someone can make a decision on this, or advice on how to take this forward.

[clayborg]

I will get Sean to take a look.

[dawn]

Eugene has been doing some work in this area - perhaps he can accept this patch for you.

[dawn]

1. Please rebase again - this patch no longer applies cleanly, and fails to build after fixing merge conflicts.
2. Please add tests.

[sivachandra]

Rebased and updated to take in DWO changes.

[sivachandra]

PTaL
I finally got time to work on this. I have now rebased it and updated it take in DWO changes.

I understand this change only enhances debug experience when GCC is used as the DWARF producer (the targeted functionality already works as expected when the producer is clang). However, GCC is still very important for Android development and hence this fix is very useful for us.

[sivachandra]

A test for this already exists: TestCallStdStringFunction.py

[dawn]

lgtm. Patch was applied locally and tested with no regressions. Thanks for fixing the patch.

[sivachandra]

@dawn: Thanks for accepting the patch. I guess I still need to wait for sign-off/comments from a CODE_OWNER.

[dawn]

In D12809#301752, @sivachandra wrote:

@dawn: Thanks for accepting the patch. I guess I still need to wait for sign-off/comments from a CODE_OWNER.

Yeah. Maybe add more proactive reviewers? And definitely be a squeaky wheel about it. Keep adding reviewers and spamming them until someone gets irritated enough to have a look :)

[dawn]

Can a "code owner" please review this patch? Thanks, -Dawn

[dawn]

@spyffe I think this review is waiting on you since you had previously rejected it. Can you please have a look? It continues to show up on my "Blocking Others" list and there's nothing more I can do on my side. Please review or resign out of curtesy to sivachandra??? Thanks in advance.

@sivachandra If spyffe (or anyone for that matter) doesn't respond in a reasonable time frame, I would say it's safe to assume he is inactive and you can go ahead and commit based on my acceptance. This patch has been on review for months - you've given folks more than enough time to voice any objections. That said, it would be nice to get at least one other person's eyes on this.

[dawn]

Adding Greg - he is an excellent reviewer and quite responsive (poor guy - ends up with way more than his fair share of reviews as a result :( ).

@clayborg would you be willing to be a 2nd pair of eyes here?

[clayborg]

I looked at this before, and resigned to let Sean Callanan comment on the fix since this is in his area of expertise: the expression parser.

[spyffe]

The expression parser side fixes look fine to me, and they remove some hacks and make things slightly more elegant.
Obviously the ideal would be to have GCC generate full debug info, but to me this patch looks like a fine next-best thing.

[sivachandra]

Thanks a lot Dwan Perchik, for persisting on my behalf.

And thanks to Sean and Greg for taking a look.

I second Dwan's earlier comment about Greg's code reviews. He has been the best reviewer I have worked with, internally and externally.

Will commit this change shortly after rebasing.

[sivachandra]

Rebase

include/lldb/Symbol/ClangASTContext.h

public:
     DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name) override;
 
     bool
     DeclContextIsStructUnionOrClass (void *opaque_decl_ctx) override;
 
     ConstString
     DeclContextGetName (void *opaque_decl_ctx) override;
 
+    ConstString
+    DeclContextGetScopeQualifiedName (void *opaque_decl_ctx) override;
+
     bool
     DeclContextIsClassMethod (void *opaque_decl_ctx,
                               lldb::LanguageType *language_ptr,
                               bool *is_instance_method_ptr,
                               ConstString *language_object_name_ptr) override;
 
     //----------------------------------------------------------------------
     // Clang specific CompilerType predicates

include/lldb/Symbol/CompilerDeclContext.h

public:
     {
         m_type_system = nullptr;
         m_opaque_decl_ctx = nullptr;
     }
 
     ConstString
     GetName () const;
 
+    ConstString
+    GetScopeQualifiedName() const;
+
     bool
     IsStructUnionOrClass () const;
 
 private:
     TypeSystem *m_type_system;
     void *m_opaque_decl_ctx;
     
 };
     
 bool operator == (const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);
 bool operator != (const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);
 
     
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_CompilerDeclContext_h_

include/lldb/Symbol/GoASTContext.h

public:
     }
 
     ConstString
     DeclContextGetName(void *opaque_decl_ctx) override
     {
         return ConstString();
     }
 
+    ConstString
+    DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override
+    {
+        return ConstString();
+    }
+
     bool
     DeclContextIsClassMethod(void *opaque_decl_ctx, lldb::LanguageType *language_ptr, bool *is_instance_method_ptr,
                              ConstString *language_object_name_ptr) override
     {
         return false;
     }
 
     //----------------------------------------------------------------------

include/lldb/Symbol/SymbolFile.h

public:
     virtual uint32_t        ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list);
     virtual uint32_t        FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, VariableList& variables);
     virtual uint32_t        FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables);
     virtual uint32_t        FindFunctions (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list);
     virtual uint32_t        FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list);
     virtual uint32_t        FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeMap& types);
     virtual size_t          FindTypes (const std::vector<CompilerContext> &context, bool append, TypeMap& types);
 
+    virtual void            GetMangledNamesForFunction(const std::string &scope_qualified_name, std::vector<ConstString> &mangled_names);
 //  virtual uint32_t        FindTypes (const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, TypeList& types) = 0;
     virtual TypeList *      GetTypeList ();
     virtual size_t          GetTypes (lldb_private::SymbolContextScope *sc_scope,
                                       uint32_t type_mask,
                                       lldb_private::TypeList &type_list) = 0;
 
     virtual lldb_private::TypeSystem *
                             GetTypeSystemForLanguage (lldb::LanguageType language);

include/lldb/Symbol/TypeSystem.h

public:
     DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name);
 
     virtual bool
     DeclContextIsStructUnionOrClass (void *opaque_decl_ctx) = 0;
 
     virtual ConstString
     DeclContextGetName (void *opaque_decl_ctx) = 0;
 
+    virtual ConstString
+    DeclContextGetScopeQualifiedName (void *opaque_decl_ctx) = 0;
+
     virtual bool
     DeclContextIsClassMethod (void *opaque_decl_ctx,
                               lldb::LanguageType *language_ptr,
                               bool *is_instance_method_ptr,
                               ConstString *language_object_name_ptr) = 0;
 
     //----------------------------------------------------------------------
     // Tests

include/lldb/Target/CPPLanguageRuntime.h

public:
     IsVTableName (const char *name) = 0;
     
     bool
     GetObjectDescription(Stream &str, ValueObject &object) override;
     
     bool
     GetObjectDescription(Stream &str, Value &value, ExecutionContextScope *exe_scope) override;
     
-    virtual size_t
-    GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) = 0;
-
 protected:
 
     //------------------------------------------------------------------
     // Classes that inherit from CPPLanguageRuntime can see and modify these
     //------------------------------------------------------------------
     CPPLanguageRuntime(Process *process);
 
 private:
 
     DISALLOW_COPY_AND_ASSIGN (CPPLanguageRuntime);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_CPPLanguageRuntime_h_

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
)
     // If we had internal symbols and we didn't find any external symbols or
     // functions in debug info, then fallback to the internal symbols
     if (sc_list.GetSize() == 0 && internal_symbol_sc_list.GetSize())
     {
         sc_list = internal_symbol_sc_list;
     }
 }
 
+ConstString
+FindBestAlternateMangledName
+(
+    const ConstString &demangled,
+    const LanguageType &lang_type,
+    SymbolContext &sym_ctx
+)
+{
+    CPlusPlusLanguage::MethodName cpp_name(demangled);
+    std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
+
+    if (!scope_qualified_name.size())
+        return ConstString();
+
+    if (!sym_ctx.module_sp)
+        return ConstString();
+
+    SymbolVendor *sym_vendor = sym_ctx.module_sp->GetSymbolVendor();
+    if (!sym_vendor)
+        return ConstString();
+
+    lldb_private::SymbolFile *sym_file = sym_vendor->GetSymbolFile();
+    if (!sym_file)
+        return ConstString();
+
+    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);
+        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())
+                param_and_qual_matches.push_back(alternate_mangled_name);
+            else
+                param_matches.push_back(alternate_mangled_name);
+        }
+    }
+
+    if (param_and_qual_matches.size())
+        return param_and_qual_matches[0]; // It is assumed that there will be only one!
+    else if (param_matches.size())
+        return param_matches[0]; // Return one of them as a best match
+    else
+        return ConstString();
+}
+
 bool
 ClangExpressionDeclMap::GetFunctionAddress
 (
     const ConstString &name,
     uint64_t &func_addr
 )
 {
     assert (m_parser_vars.get());
)
     {
         SymbolContext &sc = m_parser_vars->m_sym_ctx;
         if (sc.comp_unit)
         {
             LanguageType lang_type = sc.comp_unit->GetLanguage();
             if (Language::LanguageIsCPlusPlus(lang_type) &&
                 CPlusPlusLanguage::IsCPPMangledName(name.AsCString()))
             {
-                // 1. Demangle the name
                 Mangled mangled(name, true);
                 ConstString demangled = mangled.GetDemangledName(lang_type);
 
                 if (demangled)
                 {
+                    ConstString best_alternate_mangled_name = FindBestAlternateMangledName(demangled, lang_type, sc);
+                    if (best_alternate_mangled_name)
+                    {
+                        FindCodeSymbolInContext(
+                            best_alternate_mangled_name, m_parser_vars->m_sym_ctx, eFunctionNameTypeAuto, sc_list);
+                        sc_list_size = sc_list.GetSize();
+                    }
+
+                    if (sc_list_size == 0)
+                    {
                         FindCodeSymbolInContext(
                             demangled, m_parser_vars->m_sym_ctx, eFunctionNameTypeFull, sc_list);
                         sc_list_size = sc_list.GetSize();
                     }
                 }
             }
         }
+    }
 
     if (sc_list_size == 0)
     {
         // We occasionally get debug information in which a const function is reported
         // as non-const, so the mangled name is wrong.  This is a hack to compensate.
 
         if (!strncmp(name.GetCString(), "_ZN", 3) &&
             strncmp(name.GetCString(), "_ZNK", 4))

source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

 #include "lldb/Core/Log.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompilerType.h"
-#include "lldb/Target/CPPLanguageRuntime.h"
 
 #include <map>
 
 using namespace llvm;
 
 static char ID;
 
 IRForTarget::StaticDataAllocator::StaticDataAllocator(lldb_private::IRExecutionUnit &execution_unit) :
IRForTarget::GetFunctionAddress (llvm::Function *fun,
     clang::NamedDecl *fun_decl = DeclForGlobal (fun);
 
     if (fun_decl)
     {
         if (!m_decl_map->GetFunctionInfo (fun_decl, fun_addr))
         {
             std::vector<lldb_private::ConstString> alternates;
             bool found_it = m_decl_map->GetFunctionAddress (name, fun_addr);
-            if (!found_it)
-            {
-                if (log)
-                    log->Printf("Address of function \"%s\" not found.\n", name.GetCString());
-                // Check for an alternate mangling for names from the standard library.
-                // For example, "std::basic_string<...>" has an alternate mangling scheme per
-                // the Itanium C++ ABI.
-                lldb::ProcessSP process_sp = m_data_allocator.GetTarget()->GetProcessSP();
-                if (process_sp)
-                {
-                    lldb_private::CPPLanguageRuntime *cpp_runtime = process_sp->GetCPPLanguageRuntime();
-                    if (cpp_runtime && cpp_runtime->GetAlternateManglings(name, alternates))
-                    {
-                        for (size_t i = 0; i < alternates.size(); ++i)
-                        {
-                            const lldb_private::ConstString &alternate_name = alternates[i];
-                            if (log)
-                                log->Printf("Looking up address of function \"%s\" with alternate name \"%s\"",
-                                            name.GetCString(), alternate_name.GetCString());
-                            if ((found_it = m_decl_map->GetFunctionAddress (alternate_name, fun_addr)))
-                            {
-                                if (log)
-                                    log->Printf("Found address of function \"%s\" with alternate name \"%s\"",
-                                                name.GetCString(), alternate_name.GetCString());
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
 
             if (!found_it)
             {
                 lldb_private::Mangled mangled_name(name);
                 if (m_error_stream)
                 {
                     if (mangled_name.GetMangledName())
                         m_error_stream->Printf("error: call to a function '%s' ('%s') that is not present in the target\n",

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

public:
             return m_type;
         }
         
         const ConstString &
         GetFullName () const
         {
             return m_full;
         }
-        
+        std::string
+        GetScopeQualifiedName ();
+        
         llvm::StringRef
         GetBasename ();
 
         llvm::StringRef
         GetContext ();
         
         llvm::StringRef
         GetArguments ();

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

 llvm::StringRef
 CPlusPlusLanguage::MethodName::GetQualifiers ()
 {
     if (!m_parsed)
         Parse();
     return m_qualifiers;
 }
 
+std::string
+CPlusPlusLanguage::MethodName::GetScopeQualifiedName ()
+{
+    if (!m_parsed)
+        Parse();
+    if (m_basename.empty() || m_context.empty())
+        return std::string();
+
+    std::string res;
+    res += m_context;
+    res += "::";
+    res += m_basename;
+
+    return res;
+}
+
 bool
 CPlusPlusLanguage::IsCPPMangledName (const char *name)
 {
     // FIXME, we should really run through all the known C++ Language plugins and ask each one if
     // this is a C++ mangled name, but we can put that off till there is actually more than one
     // we care about.
     
     if (name && name[0] == '_' && name[1] == 'Z')

source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h

public:
         ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) override;
 
         lldb::BreakpointResolverSP
         CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override;
         
         lldb::SearchFilterSP
         CreateExceptionSearchFilter() override;
 
-        size_t
-        GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) override;
-
         //------------------------------------------------------------------
         // PluginInterface protocol
         //------------------------------------------------------------------
         lldb_private::ConstString
         GetPluginName() override;
         
         uint32_t
         GetPluginVersion() override;

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

ItaniumABILanguageRuntime::IsVTableName (const char *name)
         
     // Can we maybe ask Clang about this?
     if (strstr (name, "_vptr$") == name)
         return true;
     else
         return false;
 }
 
-static std::map<ConstString, std::vector<ConstString> >&
-GetAlternateManglingPrefixes()
-{
-    static std::map<ConstString, std::vector<ConstString> > g_alternate_mangling_prefixes;
-    return g_alternate_mangling_prefixes;
-}
-
-
-size_t
-ItaniumABILanguageRuntime::GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates)
-{
-    if (!mangled)
-        return static_cast<size_t>(0);
-
-    alternates.clear();
-    const char *mangled_cstr = mangled.AsCString();
-    std::map<ConstString, std::vector<ConstString> >& alternate_mangling_prefixes = GetAlternateManglingPrefixes();
-    for (std::map<ConstString, std::vector<ConstString> >::iterator it = alternate_mangling_prefixes.begin();
-         it != alternate_mangling_prefixes.end();
-         ++it)
-    {
-        const char *prefix_cstr = it->first.AsCString();
-        if (strncmp(mangled_cstr, prefix_cstr, strlen(prefix_cstr)) == 0)
-        {
-            const std::vector<ConstString> &alternate_prefixes = it->second;
-            for (size_t i = 0; i < alternate_prefixes.size(); ++i)
-            {
-                std::string alternate_mangling(alternate_prefixes[i].AsCString());
-                alternate_mangling.append(mangled_cstr + strlen(prefix_cstr));
-
-                alternates.push_back(ConstString(alternate_mangling.c_str()));
-            }
-
-            return alternates.size();
-        }
-    }
-
-    return static_cast<size_t>(0);
-}
-
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------
 LanguageRuntime *
 ItaniumABILanguageRuntime::CreateInstance (Process *process, lldb::LanguageType language)
 {
     // FIXME: We have to check the process and make sure we actually know that this process supports
     // the Itanium ABI.
     if (language == eLanguageTypeC_plus_plus ||
         language == eLanguageTypeC_plus_plus_03 ||
         language == eLanguageTypeC_plus_plus_11 ||
         language == eLanguageTypeC_plus_plus_14)
         return new ItaniumABILanguageRuntime (process);
     else
         return NULL;
 }
 
 void
 ItaniumABILanguageRuntime::Initialize()
 {
     PluginManager::RegisterPlugin (GetPluginNameStatic(),
                                    "Itanium ABI for the C++ language",
                                    CreateInstance);    
-
-    // Alternate manglings for std::basic_string<...>
-    std::vector<ConstString> basic_string_alternates;
-    basic_string_alternates.push_back(ConstString("_ZNSs"));
-    basic_string_alternates.push_back(ConstString("_ZNKSs"));
-    std::map<ConstString, std::vector<ConstString> >& alternate_mangling_prefixes = GetAlternateManglingPrefixes();
-
-    alternate_mangling_prefixes[ConstString("_ZNSbIcSt17char_traits<char>St15allocator<char>E")] =
-        basic_string_alternates;
-    alternate_mangling_prefixes[ConstString("_ZNKSbIcSt17char_traits<char>St15allocator<char>E")] =
-        basic_string_alternates;
 }
 
 void
 ItaniumABILanguageRuntime::Terminate()
 {
     PluginManager::UnregisterPlugin (CreateInstance);
 }
 

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

public:
 
     void PlaceBreakpointOnKernel(Stream &strm, const char *name, const std::array<int,3> coords,
                                  Error &error, lldb::TargetSP target);
 
     void SetBreakAllKernels(bool do_break, lldb::TargetSP target);
 
     void Status(Stream &strm) const;
 
-    size_t GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) override {
-        return static_cast<size_t>(0);
-    }
-
     void ModulesDidLoad(const ModuleList &module_list) override;
 
     bool LoadAllocation(Stream &strm, const uint32_t alloc_id, const char* filename, StackFrame* frame_ptr);
 
     bool SaveAllocation(Stream &strm, const uint32_t alloc_id, const char* filename, StackFrame* frame_ptr);
 
     void Update();
 

source/Plugins/SymbolFile/DWARF/DIERef.h

struct DIERef
     DIERef(lldb::user_id_t uid);
 
     explicit
     DIERef(const DWARFFormValue& form_value);
 
     lldb::user_id_t
     GetUID() const;
 
+    bool
+    operator< (const DIERef &ref) const
+    {
+        return die_offset < ref.die_offset;
+    }
+
+    bool
+    operator< (const DIERef &ref)
+    {
+        return die_offset < ref.die_offset;
+    }
+
     dw_offset_t cu_offset;
     dw_offset_t die_offset;
 };
 
 typedef std::vector<DIERef> DIEArray;
 
 #endif  // SymbolFileDWARF_DIERef_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

FindFunctions (const lldb_private::ConstString &name,
                    lldb_private::SymbolContextList& sc_list) override;
 
     uint32_t
     FindFunctions (const lldb_private::RegularExpression& regex,
                    bool include_inlines,
                    bool append,
                    lldb_private::SymbolContextList& sc_list) override;
 
+    void
+    GetMangledNamesForFunction (const std::string &scope_qualified_name,
+                                std::vector<lldb_private::ConstString> &mangled_names) override;
+
     uint32_t
     FindTypes (const lldb_private::SymbolContext& sc,
                const lldb_private::ConstString &name,
                const lldb_private::CompilerDeclContext *parent_decl_ctx,
                bool append,
                uint32_t max_matches,
                lldb_private::TypeMap& types) override;
 
protected:
     NameToDIE                           m_global_index;             // Global and static variables
     NameToDIE                           m_type_index;               // All type DIE offsets
     NameToDIE                           m_namespace_index;          // All type DIE offsets
     bool                                m_indexed:1,
                                         m_using_apple_tables:1,
                                         m_fetched_external_modules:1;
     lldb_private::LazyBool              m_supports_DW_AT_APPLE_objc_complete_type;
 
+    typedef std::shared_ptr<std::set<DIERef> > DIERefSetSP;
+    typedef std::unordered_map<std::string, DIERefSetSP> NameToOffsetMap;
+    NameToOffsetMap m_function_scope_qualified_name_map;
     std::unique_ptr<DWARFDebugRanges>     m_ranges;
     UniqueDWARFASTTypeMap m_unique_ast_type_map;
     DIEToTypePtr m_die_to_type;
     DIEToVariableSP m_die_to_variable_sp;
     DIEToClangType m_forward_decl_die_to_clang_type;
     ClangTypeToDIE m_forward_decl_clang_type_to_die;
 };
 
 #endif  // SymbolFileDWARF_SymbolFileDWARF_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

else
 
         FindFunctions (regex, m_function_fullname_index, include_inlines, sc_list);
     }
 
     // Return the number of variable that were appended to the list
     return sc_list.GetSize() - original_size;
 }
 
+void
+SymbolFileDWARF::GetMangledNamesForFunction (const std::string &scope_qualified_name,
+                                             std::vector<ConstString> &mangled_names)
+{
+    DWARFDebugInfo* info = DebugInfo();
+    uint32_t num_comp_units = 0;
+    if (info)
+        num_comp_units = info->GetNumCompileUnits();
+
+    for (uint32_t i = 0; i < num_comp_units; i++)
+    {
+        DWARFCompileUnit *cu = info->GetCompileUnitAtIndex(i);
+        if (cu == nullptr)
+            continue;
+
+        SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile();
+        if (dwo)
+            dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names);
+    }
+
+    NameToOffsetMap::iterator iter = m_function_scope_qualified_name_map.find(scope_qualified_name);
+    if (iter == m_function_scope_qualified_name_map.end())
+        return;
+
+    DIERefSetSP set_sp = (*iter).second;
+    std::set<DIERef>::iterator set_iter;
+    for (set_iter = set_sp->begin(); set_iter != set_sp->end(); set_iter++)
+    {
+        DWARFDIE die = DebugInfo()->GetDIE (*set_iter);
+        mangled_names.push_back(ConstString(die.GetMangledName()));
+    }
+}
+
+
 uint32_t
 SymbolFileDWARF::FindTypes (const SymbolContext& sc, 
                             const ConstString &name, 
                             const CompilerDeclContext *parent_decl_ctx, 
                             bool append, 
                             uint32_t max_matches, 
                             TypeMap& types)
 {
if (die)
             {
                 Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
                 type_sp = dwarf_ast->ParseTypeFromDWARF (sc, die, log, type_is_new_ptr);
                 if (type_sp)
                 {
                     TypeList* type_list = GetTypeList();
                     if (type_list)
                         type_list->Insert(type_sp);
+
+                    if (die.Tag() == DW_TAG_subprogram)
+                    {
+                        DIERef die_ref = die.GetDIERef();
+                        std::string scope_qualified_name(GetDeclContextForUID(die.GetID()).GetScopeQualifiedName().AsCString(""));
+                        if (scope_qualified_name.size())
+                        {
+                            NameToOffsetMap::iterator iter = m_function_scope_qualified_name_map.find(scope_qualified_name);
+                            if (iter != m_function_scope_qualified_name_map.end())
+                                (*iter).second->insert(die_ref);
+                            else
+                            {
+                                DIERefSetSP new_set(new std::set<DIERef>);
+                                new_set->insert(die_ref);
+                                m_function_scope_qualified_name_map.emplace(std::make_pair(scope_qualified_name, new_set));
+                            }
+                        }
+                    }
                 }
             }
         }
     }
     
     return type_sp;
 }
 

source/Symbol/ClangASTContext.cpp

ClangASTContext::DeclContextGetName (void *opaque_decl_ctx)
     {
         clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx);
         if (named_decl)
             return ConstString(named_decl->getName());
     }
     return ConstString();
 }
 
+ConstString
+ClangASTContext::DeclContextGetScopeQualifiedName (void *opaque_decl_ctx)
+{
+    if (opaque_decl_ctx)
+    {
+        clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx);
+        if (named_decl)
+            return ConstString(llvm::StringRef(named_decl->getQualifiedNameAsString()));
+    }
+    return ConstString();
+}
+
 bool
 ClangASTContext::DeclContextIsClassMethod (void *opaque_decl_ctx,
                                            lldb::LanguageType *language_ptr,
                                            bool *is_instance_method_ptr,
                                            ConstString *language_object_name_ptr)
 {
     if (opaque_decl_ctx)
     {

source/Symbol/CompilerDeclContext.cpp

 CompilerDeclContext::GetName () const
 {
     if (IsValid())
         return m_type_system->DeclContextGetName(m_opaque_decl_ctx);
     else
         return ConstString();
 }
 
+ConstString
+CompilerDeclContext::GetScopeQualifiedName () const
+{
+    if (IsValid())
+        return m_type_system->DeclContextGetScopeQualifiedName(m_opaque_decl_ctx);
+    else
+        return ConstString();
+}
+
 bool
 CompilerDeclContext::IsStructUnionOrClass () const
 {
     if (IsValid())
         return m_type_system->DeclContextIsStructUnionOrClass(m_opaque_decl_ctx);
     else
         return false;
 }

source/Symbol/SymbolFile.cpp

 uint32_t
 SymbolFile::FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
 {
     if (!append)
         sc_list.Clear();
     return 0;
 }
 
+void
+SymbolFile::GetMangledNamesForFunction(const std::string &scope_qualified_name, std::vector<ConstString> &mangled_names)
+{
+    return;
+}
+
 uint32_t
 SymbolFile::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeMap& types)
 {
     if (!append)
         types.Clear();
     return 0;
 }
 
 
 size_t
 SymbolFile::FindTypes (const std::vector<CompilerContext> &context, bool append, TypeMap& types)
 {
     if (!append)
         types.Clear();
     return 0;
 }