DWARFDeclContext: Don't add '::' in front of symbol names

[labath]

Summary

I believe the symbol names more consistent.

In case a symbol has DW_AT_linkage_name (e.g. clang puts it everywhere), we print the demangled
linkage name, which does not contain the '::'. If it does not have the attribute (gcc does not
put it for symbols with internal linkage) then we used to prefix it with '::'. Now we don't.

Also, we used to put the '::' only in front of names which are not in a namespace ('::foo' vs 'A::foo'). Now we are consistent and don't put the leading :: anywhere.

[labath]

Greg, what do you think about this?

[clayborg]

We can't currently do this because we have a dependency on having this be there for existing customers. The problem is that the debug info always has the base names of types in the tables: "pointer_type", "reference_type", etc. The problem arises when we say 'I want only matches to the full qualified name of "size_type"'. We will pick up many many matches if we don't look up "::size_type" because every STL class has things like:

template <class _Tp, class _Allocator = allocator<_Tp> >
class vector : private __vector_base<_Tp, _Allocator>
{
private:
    typedef __vector_base<_Tp, _Allocator>           __base;
    typedef allocator<_Tp>                           __default_allocator_type;
public:
    typedef vector                                   __self;
    typedef _Tp                                      value_type;
    typedef _Allocator                               allocator_type;
    typedef typename __base::__alloc_traits          __alloc_traits;
    typedef typename __base::reference               reference;
    typedef typename __base::const_reference         const_reference;
    typedef typename __base::size_type               size_type;
    typedef typename __base::difference_type         difference_type;

So having the extra "::" on the name for things that are top level helps us avoid pulling in many mega bytes of DWARF every time do this. So we can't make these changes without affecting type lookups. The DWARFDDeclContext class is used to get fully qualified names during SymbolFileDWARF::FindTypes(...) to avoid pulling in all DWARF for any type whose basename matches, but this only happens when using the Apple accelerator tables. For a type like like:

typedef unsigned long size_type;

The Apple accelerator tables will have an entry for "size_type", and this table entry includes a fully qualified name hash. So we will hash up "::size_type" and include that in the type accelerator table entry so we can omit any non matching entries (all "size_type" values in all STL classes will have "std::vector::size_type" hashed up in their "size_type" accelerator table entry and we can avoid parsing all of the DWARF for std::vector and all other STL classes when).

So I can't condone this patch without further modifications.

[labath]

Ok, thanks for the explanation. It'll take some time for me to parse all the information there, but this is not a priority for us now. Maybe I'll come back to this later, but I'm fine with leaving it like this for now.

packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py

def test_stop_hook_multiple_threads(self):
         child.expect_exact("Process")   # 'Process 2415 launched', 'Process 2415 stopped'
         child.expect_exact(prompt)
         child.sendline('target stop-hook add -o "frame variable --show-globals g_val"')
         child.expect_exact("Stop hook") # 'Stop hook #1 added.'
         child.expect_exact(prompt)
 
         # Continue and expect to find the output emitted by the firing of our stop hook.
         child.sendline('continue')
-        child.expect_exact('(uint32_t) ::g_val = ')
+        child.expect_exact('(uint32_t) g_val = ')

packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class NamespaceBreakpointTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureAll(bugnumber="llvm.org/pr28548", compiler="gcc")
     def test_breakpoints_func_auto(self):
         """Test that we can set breakpoints correctly by basename to find all functions whose basename is "func"."""
         self.build()
 
         names = [ "func()", "func(int)", "A::B::func()", "A::func()", "A::func(int)"]
 
         # Create a target by the debugger.
         exe = os.path.join(os.getcwd(), "a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         module_list = lldb.SBFileSpecList()
         module_list.Append(lldb.SBFileSpec(exe, False))
         cu_list = lldb.SBFileSpecList()
         # Set a breakpoint by name "func" which should pick up all functions whose basename is "func"
         bp = target.BreakpointCreateByName ("func", lldb.eFunctionNameTypeAuto, module_list, cu_list);
         for bp_loc in bp:
             name = bp_loc.GetAddress().GetFunction().GetName()
             self.assertTrue(name in names, "make sure breakpoint locations are correct for 'func' with eFunctionNameTypeAuto")        
 
-    @expectedFailureAll(bugnumber="llvm.org/pr28548", compiler="gcc")
     def test_breakpoints_func_full(self):
         """Test that we can set breakpoints correctly by fullname to find all functions whose fully qualified name is "func"
            (no namespaces)."""
         self.build()
 
         names = [ "func()", "func(int)"]
 
         # Create a target by the debugger.

packages/Python/lldbsuite/test/lang/mixed/TestMixedLanguages.py

def test_language_of_frame(self):
         # Make sure evaluation of C++11 fails.
         self.expect("expr foo != nullptr", error=True,
             startstr = "error")
 
         # Run to BP at foo (in foo.cpp) and test that the language is C++.
         self.runCmd("breakpoint set -n foo")
         self.runCmd("continue")
         self.expect("thread backtrace",
-            substrs = ["`::foo()", "lang=c++"])
+            substrs = ["`foo()", "lang=c++"])
         # Make sure we can evaluate an expression requiring C++11
         # (note: C++11 is enabled by default for C++).
         self.expect("expr foo != nullptr",
             patterns = ["true"])

source/Plugins/SymbolFile/DWARF/DWARFDeclContext.cpp

if (m_qualified_name.empty())
         //  [2] DW_TAG_namespace "b"
         //  [3] DW_TAG_namespace "a"
         if (!m_entries.empty())
         {
             if (m_entries.size() == 1)
             {
                 if (m_entries[0].name)
                 {
-                    m_qualified_name.append("::");
                     m_qualified_name.append(m_entries[0].name);
                 }
             }
             else
             {
                 collection::const_reverse_iterator pos;
                 collection::const_reverse_iterator begin = m_entries.rbegin();
                 collection::const_reverse_iterator end = m_entries.rend();