[nfc] [lldb] DWZ 07/17: Use DIERef for DIEToVariableSP m_die_to_variable_sp and GetDIEToVariable()

[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/SymbolFileDWARF.h

public:
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
   static lldb::LanguageType GetLanguage(DWARFUnit &unit);
   /// Same as GetLanguage() but reports all C++ versions as C++ (no version).
   static lldb::LanguageType GetLanguageFamily(DWARFUnit &unit);
 
 protected:
   typedef llvm::DenseMap<DIERef, lldb_private::Type *> DIERefToTypePtr;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
-      DIEToVariableSP;
+  typedef llvm::DenseMap<DIERef, lldb::VariableSP> DIERefToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
   typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
 
   SymbolFileDWARF(const SymbolFileDWARF &) = delete;
   const SymbolFileDWARF &operator=(const SymbolFileDWARF &) = delete;
 
typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t,
       GlobalVariableMap;
 
   GlobalVariableMap &GetGlobalAranges();
 
   void UpdateExternalModuleListIfNeeded();
 
   virtual DIERefToTypePtr &GetDIERefToType() { return m_dieref_to_type; }
 
-  virtual DIEToVariableSP &GetDIEToVariable() { return m_die_to_variable_sp; }
+  virtual DIERefToVariableSP &GetDIERefToVariable() {
+    return m_dieref_to_variable_sp;
+  }
 
   virtual DIEToClangType &GetForwardDeclDieToClangType() {
     return m_forward_decl_die_to_clang_type;
   }
 
   virtual ClangTypeToDIE &GetForwardDeclClangTypeToDie() {
     return m_forward_decl_clang_type_to_die;
   }
protected:
   lldb_private::LazyBool m_supports_DW_AT_APPLE_objc_complete_type;
 
   typedef std::set<DIERef> DIERefSet;
   typedef llvm::StringMap<DIERefSet> NameToOffsetMap;
   NameToOffsetMap m_function_scope_qualified_name_map;
   std::unique_ptr<DWARFDebugRanges> m_ranges;
   UniqueDWARFASTTypeMap m_unique_ast_type_map;
   DIERefToTypePtr m_dieref_to_type;
-  DIEToVariableSP m_die_to_variable_sp;
+  DIERefToVariableSP m_dieref_to_variable_sp;
   DIEToClangType m_forward_decl_die_to_clang_type;
   ClangTypeToDIE m_forward_decl_clang_type_to_die;
   llvm::DenseMap<dw_offset_t, lldb_private::FileSpecList>
       m_type_unit_support_files;
   std::vector<uint32_t> m_lldb_cu_to_dwarf_unit;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARF_H

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

VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
                                              const DWARFDIE &die,
                                              const lldb::addr_t func_low_pc) {
   if (die.GetDWARF() != this)
     return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);
 
   if (!die)
     return nullptr;
 
-  if (VariableSP var_sp = GetDIEToVariable()[die.GetDIE()])
+  if (VariableSP var_sp = GetDIERefToVariable()[*die.GetDIERef()])
     return var_sp; // Already been parsed!
 
   const dw_tag_t tag = die.Tag();
   ModuleSP module = GetObjectFile()->GetModule();
 
   if (tag != DW_TAG_variable && tag != DW_TAG_constant &&
       (tag != DW_TAG_formal_parameter || !sc.function))
     return nullptr;
if (symbol_context_scope) {
     // variable that is in a function scope and the function in the symbol
     // context wasn't filled in yet
     return var_sp;
   }
   // Cache var_sp even if NULL (the variable was just a specification or was
   // missing vital information to be able to be displayed in the debugger
   // (missing location due to optimization, etc)) so we don't re-parse this
   // DIE over and over later...
-  GetDIEToVariable()[die.GetDIE()] = var_sp;
+  GetDIERefToVariable()[*die.GetDIERef()] = var_sp;
   if (spec_die)
-    GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
+    GetDIERefToVariable()[*spec_die.GetDIERef()] = var_sp;
 
   return var_sp;
 }
 
 DWARFDIE
 SymbolFileDWARF::FindBlockContainingSpecification(
     const DIERef &func_die_ref, dw_offset_t spec_block_die_offset) {
   // Give the concrete function die specified by "func_die_offset", find the
size_t SymbolFileDWARF::ParseVariables(const SymbolContext &sc,
   VariableListSP variable_list_sp;
 
   size_t vars_added = 0;
   DWARFDIE die = orig_die;
   while (die) {
     dw_tag_t tag = die.Tag();
 
     // Check to see if we have already parsed this variable or constant?
-    VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
+    VariableSP var_sp = GetDIERefToVariable()[*die.GetDIERef()];
     if (var_sp) {
       if (cc_variable_list)
         cc_variable_list->AddVariableIfUnique(var_sp);
     } else {
       // We haven't already parsed it, lets do that now.
       if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
           (tag == DW_TAG_formal_parameter && sc.function)) {
         if (variable_list_sp.get() == nullptr) {

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

public:
   DWARFDIE
   GetDIE(const DIERef &die_ref) override;
 
   llvm::Optional<uint32_t> GetDwoNum() override { return GetID() >> 32; }
 
 protected:
   DIERefToTypePtr &GetDIERefToType() override;
 
-  DIEToVariableSP &GetDIEToVariable() override;
+  DIERefToVariableSP &GetDIERefToVariable() override;
 
   DIEToClangType &GetForwardDeclDieToClangType() override;
 
   ClangTypeToDIE &GetForwardDeclClangTypeToDie() override;
 
   UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() override;
 
   lldb::TypeSP FindDefinitionTypeForDWARFDeclContext(

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

DWARFCompileUnit *SymbolFileDWARFDwo::FindSingleCompileUnit() {
   }
   return cu;
 }
 
 SymbolFileDWARF::DIERefToTypePtr &SymbolFileDWARFDwo::GetDIERefToType() {
   return GetBaseSymbolFile().GetDIERefToType();
 }
 
-SymbolFileDWARF::DIEToVariableSP &SymbolFileDWARFDwo::GetDIEToVariable() {
-  return GetBaseSymbolFile().GetDIEToVariable();
+SymbolFileDWARF::DIERefToVariableSP &SymbolFileDWARFDwo::GetDIERefToVariable() {
+  return GetBaseSymbolFile().GetDIERefToVariable();
 }
 
 SymbolFileDWARF::DIEToClangType &
 SymbolFileDWARFDwo::GetForwardDeclDieToClangType() {
   return GetBaseSymbolFile().GetForwardDeclDieToClangType();
 }
 
 SymbolFileDWARF::ClangTypeToDIE &