[IRForTarget] Strenghten handling of alternate mangling.

[sivachandra]

Summary

This fixes an issue with GCC generated binaries wherein an expression
with method invocations on std::string variables was failing. Such use
cases are tested in TestSTL (albeit, in a test marked with
@unittest2.expectedFailure because of other reasons).

The reason for this particular failure with GCC is that the generated
DWARF for std::basic_string<...> is incomplete, which makes clang not
to use the alternate mangling scheme. GCC correctly generates the name
of basic_string<...>:

DW_AT_name "basic_string<char, std::char_traits<char>, std::allocator<char> >"

It also lists the template parameters of basic_string correctly:

DW_TAG_template_type_parameter

DW_AT_name                  "_CharT"
DW_AT_type                  <0x0000009c>

DW_TAG_template_type_parameter

DW_AT_name                  "_Traits"
DW_AT_type                  <0x00000609>

DW_TAG_template_type_parameter

DW_AT_name                  "_Alloc"
DW_AT_type                  <0x000007fb>

However, it does not list the template parameters of std::char_traits<>.
This makes Clang feel (while parsing the expression) that the string
variable is not actually a basic_string instance, and consequently does
not use the alternate mangling scheme.

[clayborg]

I'll OK this on the condition that Sean Callanan OKs this. Sean?

[zturner]

Is it possible to do away with the hardcoded mangled name? I really
dislike seeing this kind of thing. Not only because it doesn't work with
all ABIs, but just in general it's very gross for the debugger to have
exceptions for specific mangled names. Why is this necessary, and is there
any way to get rid of it?

If it is necessary, can we at least move it to somewhere more appropriate
like the Mangled class and provide some kind of generic method like
Mangled::GetAlternateMangling()?

[sivachandra]

On Mon, Apr 6, 2015 at 3:32 PM, Sean Callanan <[e-mail]> wrote:

I like this; we could have the CXXLanguageRuntime return a list of
“candidate” remangled names if you can’t find a given one, and then try
those.
The function would have the signature

size_t
CXXLanguageRuntime::GetAlternateManglings(ConstString mangled_name,
std::vector<ConstString> &alternate_names);

What do you folks think?

This sounds good. I will move the meat of this change into CPPLanguageRuntime.

A question: why would there be more than one alternate candidate for a given mangled name? There would either be a full mangling (the original) or a compressed mangling (the alternate).

[There could be a case where the compressed name is the original and the full name is the alternate. But, this case would mean that the clang generated name (compressed name) was not found in the target. That is scary because it could mean that clang compiled code cannot be linked with code generated by other compilers.]

[sivachandra]

Sorry for the follow up. Is it more meaningful this way:

class CPPLanguageRuntime 
{
public:
    ...
    virtual size_t GetAlternateManglings(const ConstString mangled, std::vector<ConstString> alternates) = 0;
    ...
};

class ItaniumABILanguageRuntime : public lldb_private::CPPLanguageRuntime
{
public:
    ...
    virtual size_t GetAlternateManglings(const ConstString mangled, std::vector<ConstString> alternates);
    ...
};

[zturner]

+blaikie

[spyffe]

Yes, I think that’s the right way to do it.

Sean

[spyffe]

Siva,

two things:

the reason I prefer to have it return a vector is that we could have a variety of problems, e.g. missing “const” in the debug info, and I don’t want to have special-casing everywhere for each one.
I just noticed that in your suggestion ("Is it more meaningful this way”) you dropped the reference off the std::vector<ConstString> – it should definitely be passed in by reference.

Sean

[sivachandra]

Modify according to suggestions from spyffe.

[sivachandra]

ping?

[tberghammer]

Can you check that this change fix TestCallStdStringFunction with g++ on Linux x86_64? I think it is failing with this or with a closely related issue.

[zturner]

By the way, seems this only fixes the case of std::string even though it
will continue to exist for any type with an unnamed template parameter..
Certainly std::string is the most important example, but I just want to
mention that the issue isn't that gcc produces alternate manglings, it's
that we build a clang AST out of incomplete DWARF (since gcc doesn't
produce complete debug info for unnamed template parameters) and the clang
AST resolves to a different mangling.

The hack seems ok to get the important case of std::string working, but
eventually maybe we should look for a real fix (perhaps asking clang to
parse the expression in the DW_AT_name)

[sivachandra]

On Thu, Apr 9, 2015 at 3:03 AM, Zachary Turner <[e-mail]> wrote:

By the way, seems this only fixes the case of std::string even though it
will continue to exist for any type with an unnamed template parameter..
Certainly std::string is the most important example, but I just want to
mention that the issue isn't that gcc produces alternate manglings, it's
that we build a clang AST out of incomplete DWARF (since gcc doesn't produce
complete debug info for unnamed template parameters) and the clang AST
resolves to a different mangling.

Agreed. This was a low hanging fruit for me as the "work around" for std::basic_string was already in place. I only made the matching prefix complete.

Even things like invocation of std::map<std::string, int>::size are still broken as clang tries to demangle std::map<std::basic_string<...>, int, ...>::size and since the debug info for some of the template params is missing, it ends up with the uncompressed mangling. A point to note here is that GCC emits the compressed mangled name in the DWARF, but that is not read at all by LLDB. May be we can make clang use that name instead of generating a mangled name itself. Just a may be; I will look into fixing this thoroughly next.

[sivachandra]

On Thu, Apr 9, 2015 at 2:35 AM, Tamas Berghammer <[e-mail]> wrote:

Can you check that this change fix TestCallStdStringFunction with g++ on Linux x86_64? I think it is failing with this or with a closely related issue.

Yes. This fixes that test as well.

[spyffe]

This patch looks good to me, thanks Siva!

[sivachandra]

Rebase.

include/lldb/Target/CPPLanguageRuntime.h

public:
     // in some cases, compilers will output different names for one same type. when that happens, it might be impossible
     // to construct SBType objects for a valid type, because the name that is available is not the same as the name that
     // can be used as a search key in FindTypes(). the equivalents map here is meant to return possible alternative names
     // for a type through which a search can be conducted. Currently, this is only enabled for C++ but can be extended
     // to ObjC or other languages if necessary
     static uint32_t
     FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents);
 
+    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/Expression/IRForTarget.cpp

 #include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Expression/ClangExpressionDeclMap.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTType.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,
     // Find the address of the function.
 
     clang::NamedDecl *fun_decl = DeclForGlobal (fun);
 
     if (fun_decl)
     {
         if (!m_decl_map->GetFunctionInfo (fun_decl, fun_addr))
         {
-            lldb_private::ConstString altnernate_name;
+            std::vector<lldb_private::ConstString> alternates;
             bool found_it = m_decl_map->GetFunctionAddress (name, fun_addr);
             if (!found_it)
             {
-                // Check for an alternate mangling for "std::basic_string<char>"
-                // that is part of the itanium C++ name mangling scheme
-                const char *name_cstr = name.GetCString();
-                if (name_cstr && strncmp(name_cstr, "_ZNKSbIcE", strlen("_ZNKSbIcE")) == 0)
-                {
-                    std::string alternate_mangling("_ZNKSs");
-                    alternate_mangling.append (name_cstr + strlen("_ZNKSbIcE"));
-                    altnernate_name.SetCString(alternate_mangling.c_str());
-                    found_it = m_decl_map->GetFunctionAddress (altnernate_name, fun_addr);
+                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();
+                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);
-                lldb_private::Mangled alt_mangled_name(altnernate_name);
-                if (log)
-                {
-                    if (alt_mangled_name)
-                        log->Printf("Function \"%s\" (alternate name \"%s\") has no address",
-                                    mangled_name.GetName().GetCString(),
-                                    alt_mangled_name.GetName().GetCString());
-                    else
-                        log->Printf("Function \"%s\" had no address",
-                                    mangled_name.GetName().GetCString());
-                }
-
                 if (m_error_stream)
                 {
-                    if (alt_mangled_name)
-                        m_error_stream->Printf("error: call to a function '%s' (alternate name '%s') that is not present in the target\n",
-                                               mangled_name.GetName().GetCString(),
-                                               alt_mangled_name.GetName().GetCString());
-                    else if (mangled_name.GetMangledName())
+                    if (mangled_name.GetMangledName())
                         m_error_stream->Printf("error: call to a function '%s' ('%s') that is not present in the target\n",
                                                mangled_name.GetName().GetCString(),
                                                mangled_name.GetMangledName().GetCString());
                     else
                         m_error_stream->Printf("error: call to a function '%s' that is not present in the target\n",
                                                mangled_name.GetName().GetCString());
                 }
                 return LookupResult::Fail;

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

 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Core/Value.h"
 
+#include <map>
+#include <vector>
+
 namespace lldb_private {
     
     class ItaniumABILanguageRuntime :
     public lldb_private::CPPLanguageRuntime
     {
     public:
         ~ItaniumABILanguageRuntime() { }
         
public:
         ExceptionBreakpointsExplainStop (lldb::StopInfoSP stop_reason);
 
         virtual lldb::BreakpointResolverSP
         CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp);
         
         virtual lldb::SearchFilterSP
         CreateExceptionSearchFilter ();
 
+        virtual size_t
+        GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates);
+
     protected:
 
         lldb::BreakpointResolverSP
         CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp, bool for_expressions);
 
         lldb::BreakpointSP
         CreateExceptionBreakpoint(bool catch_bp,
                                   bool throw_bp,
                                   bool for_expressions,
                                   bool is_internal);
         
     private:
         ItaniumABILanguageRuntime(Process *process) : lldb_private::CPPLanguageRuntime(process) { } // Call CreateInstance instead.
         
         lldb::BreakpointSP                              m_cxx_exception_bp_sp;
+
+        static std::map<ConstString, std::vector<ConstString> > s_alternate_mangling_prefixes;
     };
     
 } // namespace lldb_private
 
 #endif  // liblldb_ItaniumABILanguageRuntime_h_

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;
 }
 
+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();
+    for (typename std::map<ConstString, std::vector<ConstString> >::iterator it = s_alternate_mangling_prefixes.begin();
+         it != s_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
 //------------------------------------------------------------------
+
+std::map<ConstString, std::vector<ConstString> > ItaniumABILanguageRuntime::s_alternate_mangling_prefixes;
+
 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"));
+    s_alternate_mangling_prefixes[ConstString("_ZNSbIcSt17char_traits<char>St15allocator<char>E")] =
+        basic_string_alternates;
+    s_alternate_mangling_prefixes[ConstString("_ZNKSbIcSt17char_traits<char>St15allocator<char>E")] =
+        basic_string_alternates;
 }
 
 void
 ItaniumABILanguageRuntime::Terminate()
 {
     PluginManager::UnregisterPlugin (CreateInstance);
 }