Lookup function using full name if one with mangled name is not found.

[sivachandra]

Summary

Remove expected failure decorators from tests which now should start
passing.

[clayborg]

I worry a bit about performance here, but we should find any regressions and address them if we run into any.

[spyffe]

What is up with the name such that we have to look for its demangled version? Can you provide an example where this search would be required?

[sivachandra]

About performance regression, I am not sure if it really does cause any; For those cases where looking up a function with mangled name actually works, the new lookup should not trigger. For those where it does not work, additional lookup could now make it work.

About cases where in looking up with full (demangled) name helps, the two test cases from which the expectedFailure decorators were removed are examples. Essentially, the issue is that the mangled name used by the inferior compiler is different from the mangled name as generated by LLDB (via Clang). However, since both the manglings resolve to the same demangled name, looking up a function using the demangled name works. Another example is std::vector<int>::size(); GCC does not generate complete DWARF for the this method, and hence LLDB (via Clang) generates a different mangled name as compared to what is present in the SymTab.

source/Expression/ClangExpressionDeclMap.cpp

 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
+#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace clang;
 
 ClangExpressionDeclMap::ClangExpressionDeclMap (bool keep_result_in_memory, ExecutionContext &exe_ctx) :
     ClangASTSource (exe_ctx.GetTargetSP()),
     m_found_entities (),
     m_struct_members (),
)
     return true;
 }
 
 static void
 FindCodeSymbolInContext
 (
     const ConstString &name,
     SymbolContext &sym_ctx,
+    uint32_t name_type_mask,
     SymbolContextList &sc_list
 )
 {
     sc_list.Clear();
     SymbolContextList temp_sc_list;
     if (sym_ctx.module_sp)
         sym_ctx.module_sp->FindFunctions(name,
                                          NULL,
-                                         eFunctionNameTypeAuto,
+                                         name_type_mask,
                                          true,  // include_symbols
                                          false, // include_inlines
                                          true,  // append
                                          temp_sc_list);
     if (temp_sc_list.GetSize() == 0)
     {
         if (sym_ctx.target_sp)
             sym_ctx.target_sp->GetImages().FindFunctions(name,
-                                                         eFunctionNameTypeAuto,
+                                                         name_type_mask,
                                                          true,  // include_symbols
                                                          false, // include_inlines
                                                          true,  // append
                                                          temp_sc_list);
     }
 
     SymbolContextList internal_symbol_sc_list;
     unsigned temp_sc_list_size = temp_sc_list.GetSize();
)
     // Back out in all cases where we're not fully initialized
     if (target == NULL)
         return false;
     if (!m_parser_vars->m_sym_ctx.target_sp)
         return false;
 
     SymbolContextList sc_list;
 
-    FindCodeSymbolInContext(name, m_parser_vars->m_sym_ctx, sc_list);
+    FindCodeSymbolInContext(name, m_parser_vars->m_sym_ctx, eFunctionNameTypeAuto, sc_list);
 
     uint32_t sc_list_size = sc_list.GetSize();
-    
     if (sc_list_size == 0)
     {
+        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)
+                {
+                    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))
         {
             std::string fixed_scratch("_ZNK");
             fixed_scratch.append(name.GetCString() + 3);
             ConstString fixed_name(fixed_scratch.c_str());
 
             if (log)
                 log->Printf("Failed to find symbols given non-const name %s; trying %s", name.GetCString(), fixed_name.GetCString());
 
-            FindCodeSymbolInContext(fixed_name, m_parser_vars->m_sym_ctx, sc_list);
+            FindCodeSymbolInContext(
+                fixed_name, m_parser_vars->m_sym_ctx, eFunctionNameTypeAuto, sc_list);
             sc_list_size = sc_list.GetSize();
         }
     }
 
     lldb::addr_t intern_callable_load_addr = LLDB_INVALID_ADDRESS;
 
     for (uint32_t i=0; i<sc_list_size; ++i)
     {

test/expression_command/formatters/TestFormatters.py

class ExprFormattersTestCase(TestBase):
     @skipUnlessDarwin
     @dsym_test
     def test_with_dsym(self):
         """Test expr + formatters for good interoperability."""
         self.buildDsym()
         self.do_my_test()
 
     @expectedFailureFreeBSD('llvm.org/pr19011') # Newer Clang omits C1 complete object constructor
-    @expectedFailureLinux('llvm.org/pr19011', ['clang'])
     @expectedFailureWindows("llvm.org/pr21765")
     @skipIfTargetAndroid() # skipping to avoid crashing the test runner
     @expectedFailureAndroid('llvm.org/pr24691') # we hit an assertion in clang
     @dwarf_test
     def test_with_dwarf(self):
         """Test expr + formatters for good interoperability."""
         self.buildDwarf()
         self.do_my_test()

test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py

class DataFormatterSynthValueTestCase(TestBase):
     def test_with_dsym_and_run_command(self):
         """Test using Python synthetic children provider to provide a value."""
         self.buildDsym()
         self.data_formatter_commands()
 
     @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
     @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
     @dwarf_test
-    @expectedFailureLinux('llvm.org/pr19011', ['clang'])
     def test_with_dwarf_and_run_command(self):
         """Test using Python synthetic children provider to provide a value."""
         self.buildDwarf()
         self.data_formatter_commands()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)