[nfc] [lldb] DWZ 03/17: Use DIERef for DIEToDeclContextMap m_die_to_decl_ctx

[jankratochvil]

Summary

After D96236 using just DWARFDebugInfoEntry * is ambiguous as it does not contain MainCU. DIERef (after D96239) does contain it and it has the same sizeof as DWARFDebugInfoEntry *. This replacement should have no real performance disadvantage.

My question about upstreaming of this patchset.

[jankratochvil]

I will be no longer involved with this patchset.

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

 //===-- DIERef.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DIEREF_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DIEREF_H
 
 #include "lldb/Core/dwarf.h"
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/FormatProviders.h"
 #include <cassert>
 #include <vector>
 
 /// Identifies a DWARF debug info entry within a given Module. It contains three
 /// "coordinates":
 /// - dwo_num: identifies the dwo file in the Module. If this field is not set,
bool operator==(DIERef other) const {
     if (m_u.s.dwo_num != other.m_u.s.dwo_num)
       return m_u.s.dwo_num == other.m_u.s.dwo_num;
     if (m_u.s.section != other.m_u.s.section)
       return m_u.s.section == other.m_u.s.section;
     return m_die_offset == other.m_die_offset;
   }
 
 private:
+  friend struct llvm::DenseMapInfo<DIERef>;
+  DIERef(unsigned unique) : m_u(llvm::None, DebugInfo), m_die_offset(0) {
+    m_u.s.dwo_num = unique;
+  }
   uint32_t get_hash_value() const {
     return llvm::detail::combineHashValue(m_u.hash_bits, m_die_offset);
   }
 
   union U {
     struct S {
       uint32_t dwo_num : 30;
       uint32_t dwo_num_valid : 1;

 static_assert(sizeof(DIERef) == 8, "");
 
 typedef std::vector<DIERef> DIEArray;
 
 namespace llvm {
 template<> struct format_provider<DIERef> {
   static void format(const DIERef &ref, raw_ostream &OS, StringRef Style);
 };
+
+/// DenseMapInfo implementation.
+/// \{
+template <> struct DenseMapInfo<DIERef> {
+  static inline DIERef getEmptyKey() { return DIERef(1); }
+  static inline DIERef getTombstoneKey() { return DIERef(2); }
+  static unsigned getHashValue(DIERef val) { return val.get_hash_value(); }
+  static bool isEqual(DIERef LHS, DIERef RHS) { return LHS == RHS; }
+};
+/// \}
 } // namespace llvm
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DIEREF_H

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

public:
   lldb_private::ClangASTImporter &GetClangASTImporter();
 
 protected:
   /// Protected typedefs and members.
   /// @{
   class DelayedAddObjCClassProperty;
   typedef std::vector<DelayedAddObjCClassProperty> DelayedPropertyList;
 
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
-      DIEToDeclContextMap;
+  typedef llvm::DenseMap<DIERef, clang::DeclContext *> DIERefToDeclContextMap;
   typedef std::multimap<const clang::DeclContext *,
                         std::pair<SymbolFileDWARF *, DIERef>>
       DeclContextToFileDIERefMap;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb_private::OptionalClangModuleID>
       DIEToModuleMap;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
       DIEToDeclMap;
 
   lldb_private::TypeSystemClang &m_ast;
   DIEToDeclMap m_die_to_decl;
-  DIEToDeclContextMap m_die_to_decl_ctx;
+  DIERefToDeclContextMap m_dieref_to_decl_ctx;
   DeclContextToFileDIERefMap m_decl_ctx_to_filedieref;
   DIEToModuleMap m_die_to_module;
   std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up;
   /// @}
 
   clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die);
 
   clang::BlockDecl *ResolveBlockDIE(const DWARFDIE &die);

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

 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast)
-    : m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_filedieref() {}
+    : m_ast(ast), m_dieref_to_decl_ctx(), m_decl_ctx_to_filedieref() {}
 
 DWARFASTParserClang::~DWARFASTParserClang() = default;
 
 static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) {
   switch (dwarf_accessibility) {
   case DW_ACCESS_public:
     return eAccessPublic;
   case DW_ACCESS_private:
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                 return type_ptr->shared_from_this();
               }
             }
           }
 
           if (attrs.specification.IsValid()) {
             // We have a specification which we are going to base our
             // function prototype off of, so we need this type to be
-            // completed so that the m_die_to_decl_ctx for the method in
+            // completed so that the m_dieref_to_decl_ctx for the method in
             // the specification has a valid clang decl context.
             class_type->GetForwardCompilerType();
             // If we have a specification, then the function type should
             // have been made with the specification and not with this
             // die.
             DWARFDIE spec_die = attrs.specification.Reference();
             clang::DeclContext *spec_clang_decl_ctx =
                 GetClangDeclContextForDIE(spec_die);
             if (spec_clang_decl_ctx) {
               LinkDeclContextToDIE(spec_clang_decl_ctx, die);
             } else {
               dwarf->GetObjectFile()->GetModule()->ReportWarning(
                   "0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8x"
                   ") has no decl\n",
                   die.GetID(), spec_die.GetOffset());
             }
             type_handled = true;
           } else if (attrs.abstract_origin.IsValid()) {
             // We have a specification which we are going to base our
             // function prototype off of, so we need this type to be
-            // completed so that the m_die_to_decl_ctx for the method in
+            // completed so that the m_dieref_to_decl_ctx for the method in
             // the abstract origin has a valid clang decl context.
             class_type->GetForwardCompilerType();
 
             DWARFDIE abs_die = attrs.abstract_origin.Reference();
             clang::DeclContext *abs_clang_decl_ctx =
                 GetClangDeclContextForDIE(abs_die);
             if (abs_clang_decl_ctx) {
               LinkDeclContextToDIE(abs_clang_decl_ctx, die);
DWARFDIE child = FindFirstChildWithAbstractOrigin(
       die, containing_function_with_abstract_origin);
   CompilerDeclContext decl_context =
       GetDeclContextContainingUIDFromDWARF(child);
   return (clang::DeclContext *)decl_context.GetOpaqueDeclContext();
 }
 
 clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die) {
   if (die && die.Tag() == DW_TAG_lexical_block) {
-    clang::BlockDecl *decl =
-        llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]);
+    clang::BlockDecl *decl = llvm::cast_or_null<clang::BlockDecl>(
+        m_dieref_to_decl_ctx[*die.GetDIERef()]);
 
     if (!decl) {
       DWARFDIE decl_context_die;
       clang::DeclContext *decl_context =
           GetClangDeclContextContainingDIE(die, &decl_context_die);
       decl =
           m_ast.CreateBlockDeclaration(decl_context, GetOwningClangModule(die));
 
       if (decl)
         LinkDeclContextToDIE((clang::DeclContext *)decl, die);
     }
 
     return decl;
   }
   return nullptr;
 }
 
 clang::NamespaceDecl *
 DWARFASTParserClang::ResolveNamespaceDIE(const DWARFDIE &die) {
   if (die && die.Tag() == DW_TAG_namespace) {
     // See if we already parsed this namespace DIE and associated it with a
     // uniqued namespace declaration
-    clang::NamespaceDecl *namespace_decl =
-        static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]);
+    clang::NamespaceDecl *namespace_decl = static_cast<clang::NamespaceDecl *>(
+        m_dieref_to_decl_ctx[*die.GetDIERef()]);
     if (namespace_decl)
       return namespace_decl;
     else {
       const char *namespace_name = die.GetName();
       clang::DeclContext *containing_decl_ctx =
           GetClangDeclContextContainingDIE(die, nullptr);
       bool is_inline =
           die.GetAttributeValueAsUnsigned(DW_AT_export_symbols, 0) != 0;
if (clang_decl_ctx)
       return clang_decl_ctx;
   }
   return m_ast.GetTranslationUnitDecl();
 }
 
 clang::DeclContext *
 DWARFASTParserClang::GetCachedClangDeclContextForDIE(const DWARFDIE &die) {
   if (die) {
-    DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find(die.GetDIE());
-    if (pos != m_die_to_decl_ctx.end())
+    DIERefToDeclContextMap::iterator pos =
+        m_dieref_to_decl_ctx.find(*die.GetDIERef());
+    if (pos != m_dieref_to_decl_ctx.end())
       return pos->second;
   }
   return nullptr;
 }
 
 void DWARFASTParserClang::LinkDeclContextToDIE(clang::DeclContext *decl_ctx,
                                                const DWARFDIE &die) {
-  m_die_to_decl_ctx[die.GetDIE()] = decl_ctx;
-  SymbolFileDWARF *sym_file = &die.GetCU()->GetSymbolFileDWARF();
   DIERef ref = *die.GetDIERef();
+  m_dieref_to_decl_ctx[ref] = decl_ctx;
+  SymbolFileDWARF *sym_file = &die.GetCU()->GetSymbolFileDWARF();
   // There can be many DIEs for a single decl context
   // m_decl_ctx_to_filedieref[decl_ctx].insert(...);
   m_decl_ctx_to_filedieref.insert(
       std::make_pair(decl_ctx, std::make_pair(sym_file, ref)));
 }
 
 bool DWARFASTParserClang::CopyUniqueClassMethodTypes(
     const DWARFDIE &src_class_die, const DWARFDIE &dst_class_die,
bool DWARFASTParserClang::CopyUniqueClassMethodTypes(
   if (fast_path) {
     // We can do this quickly.  Just run across the tables index-for-index
     // since we know each node has matching names and tags.
     for (idx = 0; idx < src_size; ++idx) {
       src_die = src_name_to_die.GetValueAtIndexUnchecked(idx);
       dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx);
 
       clang::DeclContext *src_decl_ctx =
-          src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
+          src_dwarf_ast_parser->m_dieref_to_decl_ctx[*src_die.GetDIERef()];
       if (src_decl_ctx) {
         LLDB_LOGF(log, "uniquing decl context %p from 0x%8.8x for 0x%8.8x",
                   static_cast<void *>(src_decl_ctx), src_die.GetOffset(),
                   dst_die.GetOffset());
         dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, dst_die);
       } else {
         LLDB_LOGF(log,
                   "warning: tried to unique decl context from 0x%8.8x for "
if (!src_name_to_die.IsEmpty() && !dst_name_to_die.IsEmpty()) {
 
       for (idx = 0; idx < dst_size; ++idx) {
         ConstString dst_name = dst_name_to_die.GetCStringAtIndex(idx);
         dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx);
         src_die = src_name_to_die.Find(dst_name, DWARFDIE());
 
         if (src_die && (src_die.Tag() == dst_die.Tag())) {
           clang::DeclContext *src_decl_ctx =
-              src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
+              src_dwarf_ast_parser->m_dieref_to_decl_ctx[*src_die.GetDIERef()];
           if (src_decl_ctx) {
             LLDB_LOGF(log, "uniquing decl context %p from 0x%8.8x for 0x%8.8x",
                       static_cast<void *>(src_decl_ctx), src_die.GetOffset(),
                       dst_die.GetOffset());
             dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, dst_die);
           } else {
             LLDB_LOGF(log,
                       "warning: tried to unique decl context from 0x%8.8x "
for (idx = 0; idx < src_size_artificial; ++idx) {
           src_name_to_die_artificial.GetCStringAtIndex(idx);
       src_die = src_name_to_die_artificial.GetValueAtIndexUnchecked(idx);
       dst_die =
           dst_name_to_die_artificial.Find(src_name_artificial, DWARFDIE());
 
       if (dst_die) {
         // Both classes have the artificial types, link them
         clang::DeclContext *src_decl_ctx =
-            src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
+            src_dwarf_ast_parser->m_dieref_to_decl_ctx[*src_die.GetDIERef()];
         if (src_decl_ctx) {
           LLDB_LOGF(log, "uniquing decl context %p from 0x%8.8x for 0x%8.8x",
                     static_cast<void *>(src_decl_ctx), src_die.GetOffset(),
                     dst_die.GetOffset());
           dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, dst_die);
         } else {
           LLDB_LOGF(log,
                     "warning: tried to unique decl context from 0x%8.8x "