[lldb][DWARFASTParserClang] Correctly resolve imported namespaces during expression evaluation

[Michael137]

Summary

Summary

This patch makes the expression evaluator understand
namespace aliases.

This will become important once std::ranges become
more widespread since std::views is defined as:

namespace std {
namespace ranges::views {}

namespace views = ranges::views;
}

Testing

• Added API test

[Michael137]

• Reword commit message

[aprantl]

SGTM.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

3523

The common pattern in LLVM (and thinking of it, I'm surprised we don't have some kind of helper template for it) is to use find() since operator[] inserts a default-constructed element into the list, which will screw with anyone who concurrently searches using find().

[Michael137]

• use find() instead of operator[]

[Michael137]

• Reduce scope of variable

[aprantl]

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

3523

I think this is a bit too clever for my personal taste :-)

I would go with the namespace-polluting

auto it = m_die_to_decl_ctx.find(die.GetDIE());
if (it != m_die_to_decl_ctx.end())

instead.

[Michael137]

• Minor: simplify condition

[Michael137]

Broke linux buildbot, investigating...

[Michael137]

Will reland once https://reviews.llvm.org/D143458 relands

[Michael137]

Reopening to Ireland slightly adjusted patch.
New patch makes sure we populate the ManualDWARFIndex with DW_TAG_imported_declaration.

[Michael137]

• Populate ManualDWARFIndex

[Michael137]

• Remove redundant header

[aprantl]

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

359

SGTM.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

protected:
   /// @}
 
   clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die);
 
   clang::BlockDecl *ResolveBlockDIE(const DWARFDIE &die);
 
   clang::NamespaceDecl *ResolveNamespaceDIE(const DWARFDIE &die);
 
+  /// Returns the namespace decl that a DW_TAG_imported_declaration imports.
+  ///
+  /// \param[in] die The import declaration to resolve. If the DIE is not a
+  ///                DW_TAG_imported_declaration the behaviour is undefined.
+  ///
+  /// \returns The decl corresponding to the namespace that the specified
+  ///          'die' imports. If the imported entity is not a namespace
+  ///          or another import declaration, returns nullptr. If an error
+  ///          occurs, returns nullptr.
+  clang::NamespaceDecl *ResolveImportedDeclarationDIE(const DWARFDIE &die);
+
   bool ParseTemplateDIE(const DWARFDIE &die,
                         lldb_private::TypeSystemClang::TemplateParameterInfos
                             &template_param_infos);
 
   bool ParseTemplateParameterInfos(
       const DWARFDIE &parent_die,
       lldb_private::TypeSystemClang::TemplateParameterInfos
           &template_param_infos);

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

case DW_TAG_partial_unit:
       try_parsing_type = false;
       break;
 
     case DW_TAG_namespace:
       decl_ctx = ResolveNamespaceDIE(die);
       try_parsing_type = false;
       break;
 
+    case DW_TAG_imported_declaration:
+      decl_ctx = ResolveImportedDeclarationDIE(die);
+      try_parsing_type = false;
+      break;
+
     case DW_TAG_lexical_block:
       decl_ctx = GetDeclContextForBlock(die);
       try_parsing_type = false;
       break;
 
     default:
       break;
     }
else {
       if (namespace_decl)
         LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, die);
       return namespace_decl;
     }
   }
   return nullptr;
 }
 
+clang::NamespaceDecl *
+DWARFASTParserClang::ResolveImportedDeclarationDIE(const DWARFDIE &die) {
+  assert(die && die.Tag() == DW_TAG_imported_declaration);
+
+  // See if we cached a NamespaceDecl for this imported declaration
+  // already
+  auto it = m_die_to_decl_ctx.find(die.GetDIE());
+  if (it != m_die_to_decl_ctx.end())
+    return static_cast<clang::NamespaceDecl *>(it->getSecond());
+
+  clang::NamespaceDecl *namespace_decl = nullptr;
+
+  const DWARFDIE imported_uid =
+      die.GetAttributeValueAsReferenceDIE(DW_AT_import);
+  if (!imported_uid)
+    return nullptr;
+
+  switch (imported_uid.Tag()) {
+  case DW_TAG_imported_declaration:
+    namespace_decl = ResolveImportedDeclarationDIE(imported_uid);
+    break;
+  case DW_TAG_namespace:
+    namespace_decl = ResolveNamespaceDIE(imported_uid);
+    break;
+  default:
+    return nullptr;
+  }
+
+  if (!namespace_decl)
+    return nullptr;
+
+  LinkDeclContextToDIE(namespace_decl, die);
+
+  return namespace_decl;
+}
+
 clang::DeclContext *DWARFASTParserClang::GetClangDeclContextContainingDIE(
     const DWARFDIE &die, DWARFDIE *decl_ctx_die_copy) {
   SymbolFileDWARF *dwarf = die.GetDWARF();
 
   DWARFDIE decl_ctx_die = dwarf->GetDeclContextDIEContainingDIE(die);
 
   if (decl_ctx_die_copy)
     *decl_ctx_die_copy = decl_ctx_die;

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Progress.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/DataEncoder.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
+#include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ThreadPool.h"
 #include <optional>
 
 using namespace lldb_private;
 using namespace lldb;
 using namespace lldb_private::dwarf;
 
for (const DWARFDebugInfoEntry &die : unit.dies()) {
     switch (tag) {
     case DW_TAG_array_type:
     case DW_TAG_base_type:
     case DW_TAG_class_type:
     case DW_TAG_constant:
     case DW_TAG_enumeration_type:
     case DW_TAG_inlined_subroutine:
     case DW_TAG_namespace:
+    case DW_TAG_imported_declaration:
     case DW_TAG_string_type:
     case DW_TAG_structure_type:
     case DW_TAG_subprogram:
     case DW_TAG_subroutine_type:
     case DW_TAG_typedef:
     case DW_TAG_union_type:
     case DW_TAG_unspecified_type:
     case DW_TAG_variable:
for (const DWARFDebugInfoEntry &die : unit.dies()) {
     case DW_TAG_unspecified_type:
       if (name && !is_declaration)
         set.types.Insert(ConstString(name), ref);
       if (mangled_cstr && !is_declaration)
         set.types.Insert(ConstString(mangled_cstr), ref);
       break;
 
     case DW_TAG_namespace:
+    case DW_TAG_imported_declaration:
       if (name)
         set.namespaces.Insert(ConstString(name), ref);
       break;
 
     case DW_TAG_variable:
       if (name && has_location_or_const_value && is_global_or_static_variable) {
         set.globals.Insert(ConstString(name), ref);
         // Be sure to include variables by their mangled and demangled names if

lldb/test/API/commands/expression/namespace-alias/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/commands/expression/namespace-alias/TestInlineNamespaceAlias.py

+"""
+Test that we correctly handle namespace
+expression evaluation through namespace
+aliases.
+"""
+
+import lldb
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestInlineNamespace(TestBase):
+    def do_test(self, params):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self,
+                                          "return A::B::C::a", lldb.SBFileSpec("main.cpp"))
+
+        self.expect_expr("A::C::a", result_type="int", result_value="-1")
+        self.expect_expr("A::D::a", result_type="int", result_value="-1")
+
+        self.expect_expr("A::C::func()", result_type="int", result_value="0")
+        self.expect_expr("A::D::func()", result_type="int", result_value="0")
+
+        self.expect_expr("E::C::a", result_type="int", result_value="-1")
+        self.expect_expr("E::D::a", result_type="int", result_value="-1")
+        self.expect_expr("F::a", result_type="int", result_value="-1")
+        self.expect_expr("G::a", result_type="int", result_value="-1")
+
+    @skipIf(debug_info=no_match(["dsym"]))
+    def test_dsym(self):
+        self.do_test({})
+
+    @skipIf(debug_info="dsym")
+    def test_dwarf(self):
+        self.do_test(dict(CFLAGS_EXTRAS="-gdwarf-5 -gpubnames"))

lldb/test/API/commands/expression/namespace-alias/main.cpp

+namespace A {
+inline namespace _A {
+namespace B {
+namespace C {
+int a = -1;
+
+int func() { return 0; }
+} // namespace C
+} // namespace B
+
+namespace C = B::C;
+namespace D = B::C;
+
+} // namespace _A
+} // namespace A
+
+namespace E = A;
+namespace F = E::C;
+namespace G = F;
+
+int main(int argc, char **argv) { return A::B::C::a; }