[DWARF] If linkages names are missing, use decl context to get qualified names.

[sivachandra]

Summary

This commit adds this alternate route only when parsing variable dies
corresponding to global or static variables. The motivation for this is that GCC
does not emit linkage names for functions and variables declared/defined in
anonymous namespaces. Having this alternate route fixes one part of
TestNamespace which fails when the test case is compiled with GCC.

An alternate route to get fully qualified names of functions whose linkage names
are missing will be added with a followup change. With that, the other failing
part of TestNamespace will also be fixed.

[sivachandra]

I could have combined the fix for function names as well in this change. However, before I went that full a distance, I wanted to get early feedback on the general direction of this change. One would require to generate a name with the param types included to affect a similar change for functions (which would then fix TestNamespace completely when the test case is compiled with GCC).

[clayborg]

Just fix the language compare so we aren't looking for a string "c++" and use the enum and this should be good.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

7407

We should add a function that can ask the language enums if they are C++ or not and use that instead of making a string.

7416

Make a function that lives somewhere that is something like:

static bool
LanguageIsCPlusPlus (LanguageType language);

[sivachandra]

Add a static method LanguageRuntime::LanguageIsCPlusPlus and use it.

[clayborg]

Looks good.

include/lldb/Symbol/Variable.h

 class Variable : public UserID
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     Variable (lldb::user_id_t uid,
               const char *name, 
-              const char *mangled,   // The mangled variable name for variables in namespaces
+              const char *mangled,  // The mangled or fully qualified name of the variable.
               const lldb::SymbolFileTypeSP &symfile_type_sp,
               lldb::ValueType scope,
               SymbolContextScope *owner_scope,
               Declaration* decl,
               const DWARFExpression& location,
               bool external,
               bool artificial);
 

include/lldb/Target/LanguageRuntime.h

CreateExceptionBreakpoint (Target &target,
                                bool throw_bp, 
                                bool is_internal = false);
                             
     static lldb::LanguageType
     GetLanguageTypeFromString (const char *string);
     
     static const char *
     GetNameForLanguageType (lldb::LanguageType language);
-    
+    static bool
+    LanguageIsCPlusPlus (lldb::LanguageType language);
+    
     Process *
     GetProcess()
     {
         return m_process;
     }
 
     virtual lldb::BreakpointResolverSP
     CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp) = 0;

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

 //===-- DWARFCompileUnit.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFCompileUnit_h_
 #define SymbolFileDWARF_DWARFCompileUnit_h_
 
+#include "lldb/lldb-enumerations.h"
 #include "DWARFDebugInfoEntry.h"
 #include "SymbolFileDWARF.h"
 
 class NameToDIE;
 
 class DWARFCompileUnit
 {
 public:
//
     GetProducerVersionMajor();
 
     uint32_t
     GetProducerVersionMinor();
     
     uint32_t
     GetProducerVersionUpdate();
 
+    lldb::LanguageType
+    GetLanguageType();
+
     bool
     IsDWARF64() const;
 
 protected:
     SymbolFileDWARF*    m_dwarf2Data;
     const DWARFAbbreviationDeclarationSet *m_abbrevs;
     void *              m_user_data;
     DWARFDebugInfoEntry::collection m_die_array;    // The compile unit debug information entry item
     std::unique_ptr<DWARFDebugAranges> m_func_aranges_ap;   // A table similar to the .debug_aranges table, but this one points to the exact DW_TAG_subprogram DIEs
     dw_addr_t           m_base_addr;
     dw_offset_t         m_offset;
     dw_offset_t         m_length;
     uint16_t            m_version;
     uint8_t             m_addr_size;
     Producer            m_producer;
     uint32_t            m_producer_version_major;
     uint32_t            m_producer_version_minor;
     uint32_t            m_producer_version_update;
+    lldb::LanguageType  m_language_type;
     bool                m_is_dwarf64;
     
     void
     ParseProducerInfo ();
 private:
     DISALLOW_COPY_AND_ASSIGN (DWARFCompileUnit);
 };
 
 #endif  // SymbolFileDWARF_DWARFCompileUnit_h_

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF* dwarf2Data) :
     m_offset        (DW_INVALID_OFFSET),
     m_length        (0),
     m_version       (0),
     m_addr_size     (DWARFCompileUnit::GetDefaultAddressSize()),
     m_producer      (eProducerInvalid),
     m_producer_version_major (0),
     m_producer_version_minor (0),
     m_producer_version_update (0),
+    m_language_type (eLanguageTypeUnknown),
     m_is_dwarf64    (false)
 {
 }
 
 void
 DWARFCompileUnit::Clear()
 {
     m_offset        = DW_INVALID_OFFSET;
     m_length        = 0;
     m_version       = 0;
     m_abbrevs       = NULL;
     m_addr_size     = DWARFCompileUnit::GetDefaultAddressSize();
     m_base_addr     = 0;
     m_die_array.clear();
     m_func_aranges_ap.reset();
     m_user_data     = NULL;
     m_producer      = eProducerInvalid;
+    m_language_type = eLanguageTypeUnknown;
     m_is_dwarf64    = false;
 }
 
 bool
 DWARFCompileUnit::Extract(const DWARFDataExtractor &debug_info, lldb::offset_t *offset_ptr)
 {
     Clear();
 

 uint32_t
 DWARFCompileUnit::GetProducerVersionUpdate()
 {
     if (m_producer_version_update == 0)
         ParseProducerInfo ();
     return m_producer_version_update;
 }
 
+LanguageType
+DWARFCompileUnit::GetLanguageType()
+{
+    if (m_language_type != eLanguageTypeUnknown)
+        return m_language_type;
+
+    const DWARFDebugInfoEntry *die = GetCompileUnitDIEOnly();
+    if (die)
+        m_language_type = static_cast<LanguageType>(
+            die->GetAttributeValueAsUnsigned(m_dwarf2Data, this, DW_AT_language, eLanguageTypeUnknown));
+    return m_language_type;
+}
+
 bool
 DWARFCompileUnit::IsDWARF64() const
 {
     return m_is_dwarf64;
 }
 

source/Plugins/SymbolFile/DWARF/DWARFDeclContext.h

public:
     {
         // "idx" must be valid
         return m_entries[idx];
     }
 
     const char *
     GetQualifiedName () const;
 
+    // Same as GetQaulifiedName, but the life time of the returned string will
+    // be that of the LLDB session.
+    lldb_private::ConstString
+    GetQualifiedNameAsConstString () const
+    {
+        return lldb_private::ConstString (GetQualifiedName ());
+    }
+
 protected:
     typedef std::vector<Entry> collection;
     collection m_entries;
     mutable std::string m_qualified_name;
 };
 
 #endif  // SymbolFileDWARF_DWARFDeclContext_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if ((tag == DW_TAG_variable) ||
             }
 
             ValueType scope = eValueTypeInvalid;
 
             const DWARFDebugInfoEntry *sc_parent_die = GetParentSymbolContextDIE(die);
             dw_tag_t parent_tag = sc_parent_die ? sc_parent_die->Tag() : 0;
             SymbolContextScope * symbol_context_scope = NULL;
 
+            if (!mangled)
+            {
+                // LLDB relies on the mangled name (DW_TAG_linkage_name or DW_AT_MIPS_linkage_name) to
+                // generate fully qualified names of global variables with commands like "frame var j".
+                // For example, if j were an int variable holding a value 4 and declared in a namespace
+                // B which in turn is contained in a namespace A, the command "frame var j" returns
+                // "(int) A::B::j = 4". If the compiler does not emit a linkage name, we should be able
+                // to generate a fully qualified name from the declaration context.
+                if (die->GetParent()->Tag() == DW_TAG_compile_unit &&
+                    LanguageRuntime::LanguageIsCPlusPlus(dwarf_cu->GetLanguageType()))
+                {
+                    DWARFDeclContext decl_ctx;
+
+                    die->GetDWARFDeclContext(this, dwarf_cu, decl_ctx);
+                    mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString();
+                }
+            }
+
             // DWARF doesn't specify if a DW_TAG_variable is a local, global
             // or static variable, so we have to do a little digging by
             // looking at the location of a variable to see if it contains
             // a DW_OP_addr opcode _somewhere_ in the definition. I say
             // somewhere because clang likes to combine small global variables
             // into the same symbol and have locations like:
             // DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus
             // So if we don't have a DW_TAG_formal_parameter, we can look at

source/Symbol/Variable.cpp

 
 //----------------------------------------------------------------------
 // Variable constructor
 //----------------------------------------------------------------------
 Variable::Variable 
 (
     lldb::user_id_t uid,
     const char *name, 
-    const char *mangled,   // The mangled variable name for variables in namespaces
+    const char *mangled,  // The mangled or fully qualified name of the variable.
     const lldb::SymbolFileTypeSP &symfile_type_sp,
     ValueType scope,
     SymbolContextScope *context,
     Declaration* decl_ptr,
     const DWARFExpression& location,
     bool external,
     bool artificial
 ) :
     UserID(uid),
     m_name(name),
-    m_mangled (ConstString(mangled), true),
+    m_mangled (ConstString(mangled)),
     m_symfile_type_sp(symfile_type_sp),
     m_scope(scope),
     m_owner_scope(context),
     m_declaration(decl_ptr),
     m_location(location),
     m_external(external),
     m_artificial(artificial)
 {
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 Variable::~Variable()
 {
 }
 
 
 const ConstString&
 Variable::GetName() const
 {
-    if (m_mangled)
-        return m_mangled.GetName();
+    const ConstString &name = m_mangled.GetName();
+    if (name)
+        return name;
     return m_name;
 }
 
 bool
 Variable::NameMatches (const RegularExpression& regex) const
 {
     if (regex.Execute (m_name.AsCString()))
         return true;

source/Target/LanguageRuntime.cpp

 LanguageRuntime::GetNameForLanguageType (LanguageType language)
 {
     if (language < num_languages)
         return language_names[language].name;
     else
         return language_names[eLanguageTypeUnknown].name;
 }
 
+bool
+LanguageRuntime::LanguageIsCPlusPlus (LanguageType language)
+{
+    switch (language)
+    {
+        case eLanguageTypeC_plus_plus:
+        case eLanguageTypeC_plus_plus_03:
+        case eLanguageTypeC_plus_plus_11:
+        case eLanguageTypeC_plus_plus_14:
+            return true;
+        default:
+            return false;
+    }
+}
+
 lldb::SearchFilterSP
 LanguageRuntime::CreateExceptionSearchFilter ()
 {
     return m_process->GetTarget().GetSearchFilterForModule(NULL);
 }