[nfc] [lldb] DWZ 06/17: Use DIERef for DIEToTypePtr m_die_to_type and GetDIEToType()

[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/DWARFASTParserClang.cpp

TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc,
   TypeSP type_sp(new Type(die.GetID(), dwarf, pcm_type_sp->GetName(),
                           pcm_type_sp->GetByteSize(nullptr), nullptr,
                           LLDB_INVALID_UID, Type::eEncodingInvalid,
                           &pcm_type_sp->GetDeclaration(), type,
                           Type::ResolveState::Forward,
                           TypePayloadClang(GetOwningClangModule(die))));
 
   dwarf->GetTypeList().Insert(type_sp);
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIERefToType()[*die.GetDIERef()] = type_sp.get();
   clang::TagDecl *tag_decl = TypeSystemClang::GetAsTagDecl(type);
   if (tag_decl) {
     LinkDeclContextToDIE(tag_decl, die);
   } else {
     clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die);
     if (defn_decl_ctx)
       LinkDeclContextToDIE(defn_decl_ctx, die);
   }
if (log) {
     dwarf->GetObjectFile()->GetModule()->LogMessage(
         log,
         "DWARFASTParserClang::ParseTypeFromDWARF "
         "(die = 0x%8.8x, decl_ctx = %p (die 0x%8.8x)) %s name = '%s')",
         die.GetOffset(), static_cast<void *>(context), context_die.GetOffset(),
         die.GetTagAsCString(), die.GetName());
   }
 
-  Type *type_ptr = dwarf->GetDIEToType().lookup(die.GetDIE());
+  DIERef dieref = *die.GetDIERef();
+  Type *type_ptr = dwarf->GetDIERefToType().lookup(dieref);
   if (type_ptr == DIE_IS_BEING_PARSED)
     return nullptr;
   if (type_ptr)
     return type_ptr->shared_from_this();
   // Set a bit that lets us know that we are currently parsing this
-  dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
+  dwarf->GetDIERefToType()[dieref] = DIE_IS_BEING_PARSED;
 
   ParsedDWARFTypeAttributes attrs(die);
 
   if (DWARFDIE signature_die = attrs.signature.Reference()) {
     if (TypeSP type_sp =
             ParseTypeFromDWARF(sc, signature_die, type_is_new_ptr)) {
-      dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+      dwarf->GetDIERefToType()[dieref] = type_sp.get();
       if (clang::DeclContext *decl_ctx =
               GetCachedClangDeclContextForDIE(signature_die))
         LinkDeclContextToDIE(decl_ctx, die);
       return type_sp;
     }
     return nullptr;
   }
 
if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID ||
     }
   }
 
   type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
       dwarf->GetUID(attrs.type.Reference()), encoding_data_type, &attrs.decl,
       clang_type, resolve_state, TypePayloadClang(GetOwningClangModule(die)));
 
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIERefToType()[*die.GetDIERef()] = type_sp.get();
   return type_sp;
 }
 
 TypeSP DWARFASTParserClang::ParseEnum(const SymbolContext &sc,
                                       const DWARFDIE &die,
                                       ParsedDWARFTypeAttributes &attrs) {
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
if (type_sp) {
             static_cast<void *>(this), die.GetOffset(),
             DW_TAG_value_to_name(tag), attrs.name.GetCString(),
             type_sp->GetID());
       }
 
       // We found a real definition for this type elsewhere so lets use
       // it and cache the fact that we found a complete type for this
       // die
-      dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+      dwarf->GetDIERefToType()[*die.GetDIERef()] = type_sp.get();
       clang::DeclContext *defn_decl_ctx =
           GetCachedClangDeclContextForDIE(dwarf->GetDIE(type_sp->GetID()));
       if (defn_decl_ctx)
         LinkDeclContextToDIE(defn_decl_ctx, die);
       return type_sp;
     }
   }
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
               CopyUniqueClassMethodTypes(decl_ctx_die, class_type_die,
                                          class_type, failures);
 
               // FIXME do something with these failures that's
               // smarter than just dropping them on the ground.
               // Unfortunately classes don't like having stuff added
               // to them after their definitions are complete...
 
-              Type *type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
+              Type *type_ptr = dwarf->GetDIERefToType()[*die.GetDIERef()];
               if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
                 return type_ptr->shared_from_this();
               }
             }
           }
 
           if (attrs.specification.IsValid()) {
             // We have a specification which we are going to base our
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                 }
               } else {
                 // We were asked to parse the type for a method in a
                 // class, yet the class hasn't been asked to complete
                 // itself through the clang::ExternalASTSource protocol,
                 // so we need to just have the class complete itself and
                 // do things the right way, then our
                 // DIE should then have an entry in the
-                // dwarf->GetDIEToType() map. First
-                // we need to modify the dwarf->GetDIEToType() so it
+                // dwarf->GetDIERefToType() map. First
+                // we need to modify the dwarf->GetDIERefToType() so it
                 // doesn't think we are trying to parse this DIE
                 // anymore...
-                dwarf->GetDIEToType()[die.GetDIE()] = NULL;
+                DIERef dieref = *die.GetDIERef();
+                dwarf->GetDIERefToType()[dieref] = NULL;
 
                 // Now we get the full type to force our class type to
                 // complete itself using the clang::ExternalASTSource
                 // protocol which will parse all base classes and all
                 // methods (including the method for this DIE).
                 class_type->GetFullCompilerType();
 
                 // The type for this DIE should have been filled in the
                 // function call above
-                Type *type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
+                Type *type_ptr = dwarf->GetDIERefToType()[dieref];
                 if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
                   return type_ptr->shared_from_this();
                 }
 
                 // FIXME This is fixing some even uglier behavior but we
                 // really need to
                 // uniq the methods of each class as well as the class
                 // itself. <rdar://problem/11240464>
TypeSP DWARFASTParserClang::UpdateSymbolContextScopeForType(
 
   if (symbol_context_scope != nullptr)
     type_sp->SetSymbolContextScope(symbol_context_scope);
 
   // We are ready to put this type into the uniqued list up at the module
   // level.
   type_list.Insert(type_sp);
 
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIERefToType()[*die.GetDIERef()] = type_sp.get();
   return type_sp;
 }
 
 TypeSP
 DWARFASTParserClang::ParseStructureLikeDIE(const SymbolContext &sc,
                                            const DWARFDIE &die,
                                            ParsedDWARFTypeAttributes &attrs) {
   TypeSP type_sp;
if (Language::LanguageIsCPlusPlus(cu_language)) {
       unique_decl.Clear();
     }
 
     if (dwarf->GetUniqueDWARFASTTypeMap().Find(
             unique_typename, die, unique_decl, attrs.byte_size.getValueOr(-1),
             *unique_ast_entry_up)) {
       type_sp = unique_ast_entry_up->m_type_sp;
       if (type_sp) {
-        dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+        dwarf->GetDIERefToType()[*die.GetDIERef()] = type_sp.get();
         LinkDeclContextToDIE(
             GetCachedClangDeclContextForDIE(unique_ast_entry_up->m_die), die);
         return type_sp;
       }
     }
   }
 
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
if (!attrs.is_complete_objc_class &&
               static_cast<void *>(this), die.GetOffset(),
               DW_TAG_value_to_name(tag), attrs.name.GetCString(),
               type_sp->GetID());
         }
 
         // We found a real definition for this type elsewhere so lets use
         // it and cache the fact that we found a complete type for this
         // die
-        dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+        dwarf->GetDIERefToType()[*die.GetDIERef()] = type_sp.get();
         return type_sp;
       }
     }
   }
 
   if (attrs.is_forward_declaration) {
     // We have a forward declaration to a type and we need to try and
     // find a full declaration. We look in the current type index just in
if (type_sp) {
             "forward declaration, complete type is 0x%8.8" PRIx64,
             static_cast<void *>(this), die.GetOffset(),
             DW_TAG_value_to_name(tag), attrs.name.GetCString(),
             type_sp->GetID());
       }
 
       // We found a real definition for this type elsewhere so lets use
       // it and cache the fact that we found a complete type for this die
-      dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+      dwarf->GetDIERefToType()[*die.GetDIERef()] = type_sp.get();
       clang::DeclContext *defn_decl_ctx =
           GetCachedClangDeclContextForDIE(dwarf->GetDIE(type_sp->GetID()));
       if (defn_decl_ctx)
         LinkDeclContextToDIE(defn_decl_ctx, die);
       return type_sp;
     }
   }
   assert(tag_decl_kind != -1);
if (func_range.GetBaseAddress().IsValid()) {
       FunctionSP func_sp;
       std::unique_ptr<Declaration> decl_up;
       if (decl_file != 0 || decl_line != 0 || decl_column != 0)
         decl_up = std::make_unique<Declaration>(die.GetCU()->GetFile(decl_file),
                                                 decl_line, decl_column);
 
       SymbolFileDWARF *dwarf = die.GetDWARF();
       // Supply the type _only_ if it has already been parsed
-      Type *func_type = dwarf->GetDIEToType().lookup(die.GetDIE());
+      Type *func_type = dwarf->GetDIERefToType().lookup(*die.GetDIERef());
 
       assert(func_type == nullptr || func_type != DIE_IS_BEING_PARSED);
 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
         const user_id_t func_user_id = die.GetID();
         func_sp =
             std::make_shared<Function>(&comp_unit,
                                    func_user_id, // UserID is the DIE offset
for (idx = 0; idx < src_size; ++idx) {
       } else {
         LLDB_LOGF(log,
                   "warning: tried to unique decl context from 0x%8.8x for "
                   "0x%8.8x, but none was found",
                   src_die.GetOffset(), dst_die.GetOffset());
       }
 
       Type *src_child_type =
-          dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
+          dst_die.GetDWARF()->GetDIERefToType()[*src_die.GetDIERef()];
       if (src_child_type) {
         LLDB_LOGF(log,
                   "uniquing type %p (uid=0x%" PRIx64
                   ") from 0x%8.8x for 0x%8.8x",
                   static_cast<void *>(src_child_type), src_child_type->GetID(),
                   src_die.GetOffset(), dst_die.GetOffset());
-        dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
+        dst_die.GetDWARF()->GetDIERefToType()[*dst_die.GetDIERef()] =
+            src_child_type;
       } else {
         LLDB_LOGF(log,
                   "warning: tried to unique lldb_private::Type from "
                   "0x%8.8x for 0x%8.8x, but none was found",
                   src_die.GetOffset(), dst_die.GetOffset());
       }
     }
   } else {
if (!src_name_to_die.IsEmpty() && !dst_name_to_die.IsEmpty()) {
           } else {
             LLDB_LOGF(log,
                       "warning: tried to unique decl context from 0x%8.8x "
                       "for 0x%8.8x, but none was found",
                       src_die.GetOffset(), dst_die.GetOffset());
           }
 
           Type *src_child_type =
-              dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
+              dst_die.GetDWARF()->GetDIERefToType()[*src_die.GetDIERef()];
           if (src_child_type) {
             LLDB_LOGF(
                 log,
                 "uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
                 static_cast<void *>(src_child_type), src_child_type->GetID(),
                 src_die.GetOffset(), dst_die.GetOffset());
-            dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] =
+            dst_die.GetDWARF()->GetDIERefToType()[*dst_die.GetDIERef()] =
                 src_child_type;
           } else {
             LLDB_LOGF(log,
                       "warning: tried to unique lldb_private::Type from "
                       "0x%8.8x for 0x%8.8x, but none was found",
                       src_die.GetOffset(), dst_die.GetOffset());
           }
         } else {
for (idx = 0; idx < src_size_artificial; ++idx) {
         } else {
           LLDB_LOGF(log,
                     "warning: tried to unique decl context from 0x%8.8x "
                     "for 0x%8.8x, but none was found",
                     src_die.GetOffset(), dst_die.GetOffset());
         }
 
         Type *src_child_type =
-            dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
+            dst_die.GetDWARF()->GetDIERefToType()[*src_die.GetDIERef()];
         if (src_child_type) {
           LLDB_LOGF(
               log,
               "uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
               static_cast<void *>(src_child_type), src_child_type->GetID(),
               src_die.GetOffset(), dst_die.GetOffset());
-          dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
+          dst_die.GetDWARF()->GetDIERefToType()[*dst_die.GetDIERef()] =
+              src_child_type;
         } else {
           LLDB_LOGF(log,
                     "warning: tried to unique lldb_private::Type from "
                     "0x%8.8x for 0x%8.8x, but none was found",
                     src_die.GetOffset(), dst_die.GetOffset());
         }
       }
     }

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<const DWARFDebugInfoEntry *, lldb_private::Type *>
-      DIEToTypePtr;
+  typedef llvm::DenseMap<DIERef, lldb_private::Type *> DIERefToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   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;
protected:
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t,
                                         lldb_private::Variable *>
       GlobalVariableMap;
 
   GlobalVariableMap &GetGlobalAranges();
 
   void UpdateExternalModuleListIfNeeded();
 
-  virtual DIEToTypePtr &GetDIEToType() { return m_die_to_type; }
+  virtual DIERefToTypePtr &GetDIERefToType() { return m_dieref_to_type; }
 
   virtual DIEToVariableSP &GetDIEToVariable() { return m_die_to_variable_sp; }
 
   virtual DIEToClangType &GetForwardDeclDieToClangType() {
     return m_forward_decl_die_to_clang_type;
   }
 
   virtual ClangTypeToDIE &GetForwardDeclClangTypeToDie() {
protected:
   bool m_fetched_external_modules : 1;
   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;
-  DIEToTypePtr m_die_to_type;
+  DIERefToTypePtr m_dieref_to_type;
   DIEToVariableSP m_die_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

bool SymbolFileDWARF::CompleteType(CompilerType &compiler_type) {
   DWARFDIE dwarf_die = GetDIE(die_it->getSecond());
   if (dwarf_die) {
     // Once we start resolving this type, remove it from the forward
     // declaration map in case anyone child members or other types require this
     // type to get resolved. The type will get resolved when all of the calls
     // to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition are done.
     GetForwardDeclClangTypeToDie().erase(die_it);
 
-    Type *type = GetDIEToType().lookup(dwarf_die.GetDIE());
+    Type *type = GetDIERefToType().lookup(*dwarf_die.GetDIERef());
 
     Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO |
                                           DWARF_LOG_TYPE_COMPLETION));
     if (log)
       GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
           log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
           dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
           type->GetName().AsCString());
SymbolFileDWARF::FindNamespace(ConstString name,
 
   return namespace_decl_ctx;
 }
 
 TypeSP SymbolFileDWARF::GetTypeForDIE(const DWARFDIE &die,
                                       bool resolve_function_context) {
   TypeSP type_sp;
   if (die) {
-    Type *type_ptr = GetDIEToType().lookup(die.GetDIE());
+    Type *type_ptr = GetDIERefToType().lookup(*die.GetDIERef());
     if (type_ptr == nullptr) {
       SymbolContextScope *scope;
       if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU()))
         scope = GetCompUnitForDWARFCompUnit(*dwarf_cu);
       else
         scope = GetObjectFile()->GetModule().get();
       assert(scope);
       SymbolContext sc(scope);
m_index->GetCompleteObjCClass(
         DEBUG_PRINTF(
             "resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
             " (cu 0x%8.8" PRIx64 ")\n",
             die.GetID(),
             m_objfile_sp->GetFileSpec().GetFilename().AsCString("<Unknown>"),
             type_die.GetID(), type_cu->GetID());
 
         if (die)
-          GetDIEToType()[die.GetDIE()] = resolved_type;
+          GetDIERefToType()[*die.GetDIERef()] = resolved_type;
         type_sp = resolved_type->shared_from_this();
         return false;
       });
   return type_sp;
 }
 
 // This function helps to ensure that the declaration contexts match for two
 // different DIEs. Often times debug information will refer to a forward

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

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

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

if (auto *candidate =
       if (cu)
         return nullptr; // More that one CU found.
       cu = candidate;
     }
   }
   return cu;
 }
 
-SymbolFileDWARF::DIEToTypePtr &SymbolFileDWARFDwo::GetDIEToType() {
-  return GetBaseSymbolFile().GetDIEToType();
+SymbolFileDWARF::DIERefToTypePtr &SymbolFileDWARFDwo::GetDIERefToType() {
+  return GetBaseSymbolFile().GetDIERefToType();
 }
 
 SymbolFileDWARF::DIEToVariableSP &SymbolFileDWARFDwo::GetDIEToVariable() {
   return GetBaseSymbolFile().GetDIEToVariable();
 }
 
 SymbolFileDWARF::DIEToClangType &
 SymbolFileDWARFDwo::GetForwardDeclDieToClangType() {