2/2: [nfc] [lldb] DWARF callbacks: DIERef -> DWARFDIE

[jankratochvil]

Summary

@labath was saying in D73206:

And /I think/ we could make it interface returns DWARFDies directly

[jankratochvil]

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

82

This calling with curly brackets is a bit tricky but I found it the least worst option.

93

Invalid DIERef is now reported for all Indexes, not just AppleDWARFIndex.

[labath]

Looks pretty good, I just think the std::function solution is too smart for its own good.

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

82

I think it would be much simpler to make this a callable object instead (though I'm not sure we need to worry about optimizing to this level of detail):

class ResultProcessor (?) {
  ResultProcessor(callback, name);
  bool operator()(DIERef ref);
};

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

186

dangling DIERefCallbackArgs here.

[jankratochvil]

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

82

Wow, that solved everything, thanks. No more mallocs, no more stale references, the most simple calling syntax. No compromises.
I did not know llvm::function_ref<> does not need any std::function, it is fine with a callable object.

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

186

oops, I even did not handle the usage in a patch of mine. But the stale references are no longer possible with the callable object now.

[labath]

Looks good, just please write more explanatory commit message than what's present in this patch description.

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

75–80

reverse the if condition

if (DWARFDIE die = m_dwarf.GETDIE(ref))
  return m_callback(die);
...

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

93

That's fine. The error message that produces is really geared towards accelerator tables, but the manual index should not produce such an error anyway (I would have put an assert there it was convenient (but it isn't)). And I think I'm going to change the debug_names index to not use DIERefs once this lands.

[jankratochvil]

Thanks for the review and I have learned a new use case for llvm::function_ref.

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

AppleDWARFIndex(
         m_apple_namespaces_up(std::move(apple_namespaces)),
         m_apple_types_up(std::move(apple_types)),
         m_apple_objc_up(std::move(apple_objc)) {}
 
   void Preload() override {}
 
   void
   GetGlobalVariables(ConstString basename,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void
   GetGlobalVariables(const RegularExpression &regex,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void
   GetGlobalVariables(const DWARFUnit &cu,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetObjCMethods(ConstString class_name,
-                      llvm::function_ref<bool(DIERef ref)> callback) override;
-  void
-  GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                       llvm::function_ref<bool(DIERef ref)> callback) override;
+                      llvm::function_ref<bool(DWARFDIE die)> callback) override;
+  void GetCompleteObjCClass(
+      ConstString class_name, bool must_be_implementation,
+      llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(ConstString name,
-                llvm::function_ref<bool(DIERef ref)> callback) override;
+                llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(const DWARFDeclContext &context,
-                llvm::function_ref<bool(DIERef ref)> callback) override;
+                llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetNamespaces(ConstString name,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetFunctions(const RegularExpression &regex,
-                    llvm::function_ref<bool(DIERef ref)> callback) override;
+                    llvm::function_ref<bool(DWARFDIE die)> callback) override;
 
-  void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) override;
   void Dump(Stream &s) override;
 
 private:
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_names_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_namespaces_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_types_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_objc_up;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_APPLEDWARFINDEX_H

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

return std::make_unique<AppleDWARFIndex>(
         module, std::move(apple_names_table_up),
         std::move(apple_namespaces_table_up), std::move(apple_types_table_up),
         std::move(apple_objc_table_up));
 
   return nullptr;
 }
 
 void AppleDWARFIndex::GetGlobalVariables(
-    ConstString basename, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_names_up)
     return;
-  m_apple_names_up->FindByName(basename.GetStringRef(), callback);
+  m_apple_names_up->FindByName(
+      basename.GetStringRef(),
+      DIERefCallback({callback, basename.GetStringRef()}));
 }
 
 void AppleDWARFIndex::GetGlobalVariables(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
   m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data);
-  DWARFMappedHash::ExtractDIEArray(hash_data, callback);
+  // This is not really the DIE name.
+  DWARFMappedHash::ExtractDIEArray(hash_data,
+                                   DIERefCallback({callback, regex.GetText()}));
 }
 
 void AppleDWARFIndex::GetGlobalVariables(
-    const DWARFUnit &cu, llvm::function_ref<bool(DIERef ref)> callback) {
+    const DWARFUnit &cu, llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
   m_apple_names_up->AppendAllDIEsInRange(cu.GetOffset(), cu.GetNextUnitOffset(),
                                          hash_data);
-  DWARFMappedHash::ExtractDIEArray(hash_data, callback);
+  DWARFMappedHash::ExtractDIEArray(hash_data, DIERefCallback({callback}));
 }
 
 void AppleDWARFIndex::GetObjCMethods(
-    ConstString class_name, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString class_name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_objc_up)
     return;
-  m_apple_objc_up->FindByName(class_name.GetStringRef(), callback);
+  m_apple_objc_up->FindByName(
+      class_name.GetStringRef(),
+      DIERefCallback({callback, class_name.GetStringRef()}));
 }
 
 void AppleDWARFIndex::GetCompleteObjCClass(
     ConstString class_name, bool must_be_implementation,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_types_up)
     return;
   m_apple_types_up->FindCompleteObjCClassByName(
-      class_name.GetStringRef(), callback, must_be_implementation);
+      class_name.GetStringRef(),
+      DIERefCallback({callback, class_name.GetStringRef()}),
+      must_be_implementation);
 }
 
-void AppleDWARFIndex::GetTypes(ConstString name,
-                               llvm::function_ref<bool(DIERef ref)> callback) {
+void AppleDWARFIndex::GetTypes(
+    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_types_up)
     return;
-  m_apple_types_up->FindByName(name.GetStringRef(), callback);
+  m_apple_types_up->FindByName(name.GetStringRef(),
+                               DIERefCallback({callback, name.GetStringRef()}));
 }
 
-void AppleDWARFIndex::GetTypes(const DWARFDeclContext &context,
-                               llvm::function_ref<bool(DIERef ref)> callback) {
+void AppleDWARFIndex::GetTypes(
+    const DWARFDeclContext &context,
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_types_up)
     return;
 
   Log *log = LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                           DWARF_LOG_LOOKUPS);
   const bool has_tag = m_apple_types_up->GetHeader().header_data.ContainsAtom(
       DWARFMappedHash::eAtomTypeTag);
   const bool has_qualified_name_hash =
       m_apple_types_up->GetHeader().header_data.ContainsAtom(
           DWARFMappedHash::eAtomTypeQualNameHash);
 
   const ConstString type_name(context[0].name);
   const dw_tag_t tag = context[0].tag;
   if (has_tag && has_qualified_name_hash) {
     const char *qualified_name = context.GetQualifiedName();
     const uint32_t qualified_name_hash = llvm::djbHash(qualified_name);
     if (log)
       m_module.LogMessage(log, "FindByNameAndTagAndQualifiedNameHash()");
     m_apple_types_up->FindByNameAndTagAndQualifiedNameHash(
-        type_name.GetStringRef(), tag, qualified_name_hash, callback);
+        type_name.GetStringRef(), tag, qualified_name_hash,
+        DIERefCallback({callback, type_name.GetStringRef()}));
     return;
   }
 
   if (has_tag) {
     // When searching for a scoped type (for example,
     // "std::vector<int>::const_iterator") searching for the innermost
     // name alone ("const_iterator") could yield many false
     // positives. By searching for the parent type ("vector<int>")
     // first we can avoid extracting type DIEs from object files that
     // would fail the filter anyway.
     if (!has_qualified_name_hash && (context.GetSize() > 1) &&
         (context[1].tag == DW_TAG_class_type ||
          context[1].tag == DW_TAG_structure_type)) {
       if (!m_apple_types_up->FindByName(context[1].name,
                                         [&](DIERef ref) { return false; }))
         return;
     }
 
     if (log)
       m_module.LogMessage(log, "FindByNameAndTag()");
-    m_apple_types_up->FindByNameAndTag(type_name.GetStringRef(), tag, callback);
+    m_apple_types_up->FindByNameAndTag(
+        type_name.GetStringRef(), tag,
+        DIERefCallback({callback, type_name.GetStringRef()}));
     return;
   }
 
-  m_apple_types_up->FindByName(type_name.GetStringRef(), callback);
+  m_apple_types_up->FindByName(
+      type_name.GetStringRef(),
+      DIERefCallback({callback, type_name.GetStringRef()}));
 }
 
 void AppleDWARFIndex::GetNamespaces(
-    ConstString name, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_namespaces_up)
     return;
-  m_apple_namespaces_up->FindByName(name.GetStringRef(), callback);
+  m_apple_namespaces_up->FindByName(
+      name.GetStringRef(), DIERefCallback({callback, name.GetStringRef()}));
 }
 
 void AppleDWARFIndex::GetFunctions(
     ConstString name, SymbolFileDWARF &dwarf,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
     llvm::function_ref<bool(DWARFDIE die)> callback) {
   m_apple_names_up->FindByName(name.GetStringRef(), [&](DIERef die_ref) {
     return ProcessFunctionDIE(name.GetStringRef(), die_ref, dwarf,
                               parent_decl_ctx, name_type_mask, callback);
   });
 }
 
 void AppleDWARFIndex::GetFunctions(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
   m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data);
-  DWARFMappedHash::ExtractDIEArray(hash_data, callback);
-}
-
-void AppleDWARFIndex::ReportInvalidDIERef(const DIERef &ref,
-                                          llvm::StringRef name) {
-  m_module.ReportErrorIfModifyDetected(
-      "the DWARF debug information has been modified (accelerator table had "
-      "bad die 0x%8.8x for '%s')\n",
-      ref.die_offset(), name.str().c_str());
+  DWARFMappedHash::ExtractDIEArray(hash_data,
+                                   DIERefCallback({callback, regex.GetText()}));
 }
 
 void AppleDWARFIndex::Dump(Stream &s) {
   if (m_apple_names_up)
     s.PutCString(".apple_names index present\n");
   if (m_apple_namespaces_up)
     s.PutCString(".apple_namespaces index present\n");
   if (m_apple_types_up)
     s.PutCString(".apple_types index present\n");
   if (m_apple_objc_up)
     s.PutCString(".apple_objc index present\n");
   // TODO: Dump index contents
 }

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

if (die.HasChildren()) {
 
     // Now parse any methods if there were any...
     for (const DWARFDIE &die : member_function_dies)
       dwarf->ResolveType(die);
 
     if (class_language == eLanguageTypeObjC) {
       ConstString class_name(clang_type.GetTypeName());
       if (class_name) {
-        dwarf->GetObjCMethods(class_name, [&](DIERef die_ref) {
-          DWARFDebugInfo &debug_info = dwarf->DebugInfo();
-          DWARFDIE method_die = debug_info.GetDIE(die_ref);
-          if (method_die)
-            method_die.ResolveType();
+        dwarf->GetObjCMethods(class_name, [&](DWARFDIE method_die) {
           return true;
         });
 
         for (DelayedPropertyList::iterator pi = delayed_properties.begin(),
                                            pe = delayed_properties.end();
              pi != pe; ++pi)
           pi->Finalize();
       }

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

public:
 
   virtual void Preload() = 0;
 
   /// Finds global variables with the given base name. Any additional filtering
   /// (e.g., to only retrieve variables from a given context) should be done by
   /// the consumer.
   virtual void
   GetGlobalVariables(ConstString basename,
-                     llvm::function_ref<bool(DIERef ref)> callback) = 0;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
 
   virtual void
   GetGlobalVariables(const RegularExpression &regex,
-                     llvm::function_ref<bool(DIERef ref)> callback) = 0;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void
   GetGlobalVariables(const DWARFUnit &cu,
-                     llvm::function_ref<bool(DIERef ref)> callback) = 0;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void
   GetObjCMethods(ConstString class_name,
-                 llvm::function_ref<bool(DIERef ref)> callback) = 0;
+                 llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void
   GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                       llvm::function_ref<bool(DIERef ref)> callback) = 0;
+                       llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void GetTypes(ConstString name,
-                        llvm::function_ref<bool(DIERef ref)> callback) = 0;
+                        llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void GetTypes(const DWARFDeclContext &context,
-                        llvm::function_ref<bool(DIERef ref)> callback) = 0;
-  virtual void GetNamespaces(ConstString name,
-                             llvm::function_ref<bool(DIERef ref)> callback) = 0;
+                        llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
+  virtual void
+  GetNamespaces(ConstString name,
+                llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void
   GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                const CompilerDeclContext &parent_decl_ctx,
                uint32_t name_type_mask,
                llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
-  virtual void GetFunctions(const RegularExpression &regex,
-                            llvm::function_ref<bool(DIERef ref)> callback) = 0;
+  virtual void
+  GetFunctions(const RegularExpression &regex,
+               llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
 
-  virtual void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) = 0;
   virtual void Dump(Stream &s) = 0;
 
 protected:
   Module &m_module;
 
   /// Helper function implementing common logic for processing function dies. If
   /// the function given by "ref" matches search criteria given by
   /// "parent_decl_ctx" and "name_type_mask", it is inserted into the "dies"
   /// vector.
   bool ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
                           SymbolFileDWARF &dwarf,
                           const CompilerDeclContext &parent_decl_ctx,
                           uint32_t name_type_mask,
                           llvm::function_ref<bool(DWARFDIE die)> callback);
+
+  /// std::function can capture at most X pointers from DIERefCallback's lambda
+  /// function, otherwise it will allocate memory during each call.
+  /// libstdc++9 can capture at most 2 pointers, libcxx9 can capture 3 pointers.
+  /// DIERefCallbackArgs does reduce the capture size to prevent allocations.
+  /// The object will remain valid during the whole call statement:
+  /// Function(name, DIERefCallback({callback, name}));
+  struct DIERefCallbackArgs {
+    const llvm::function_ref<bool(DWARFDIE die)> callback;
+    const llvm::StringRef name;
+    DIERefCallbackArgs(llvm::function_ref<bool(DWARFDIE die)> callback,
+                       llvm::StringRef name = {})
+        : callback(callback), name(name) {}
+  };
+  std::function<bool(DIERef ref)>
+  DIERefCallback(const DIERefCallbackArgs &args) const;
+
+  void ReportInvalidDIERef(DIERef ref, llvm::StringRef name) const;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H

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

 //===-- DWARFIndex.cpp ----------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 
+#include "lldb/Core/Module.h"
+
 using namespace lldb_private;
 using namespace lldb;
 
 DWARFIndex::~DWARFIndex() = default;
 
 bool DWARFIndex::ProcessFunctionDIE(
     llvm::StringRef name, DIERef ref, SymbolFileDWARF &dwarf,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
if (looking_for_methods || looking_for_functions) {
     // searching for.
     if ((looking_for_methods && looking_for_functions) ||
         looking_for_methods == die.IsMethod())
       return callback(die);
   }
 
   return true;
 }
+
+std::function<bool(DIERef ref)>
+DWARFIndex::DIERefCallback(const DIERefCallbackArgs &args) const {
+  return [this, &args](DIERef ref) {
+    SymbolFileDWARF &dwarf =
+        *llvm::cast<SymbolFileDWARF>(m_module.GetSymbolFile());
+    DWARFDIE die = dwarf.GetDIE(ref);
+    if (!die) {
+      ReportInvalidDIERef(ref, args.name);
+      return false;
+    }
+    return args.callback(die);
+  };
+}
+
+void DWARFIndex::ReportInvalidDIERef(DIERef ref, llvm::StringRef name) const {
+  m_module.ReportErrorIfModifyDetected(
+      "the DWARF debug information has been modified (accelerator table had "
+      "bad die 0x%8.8x for '%s')\n",
+      ref.die_offset(), name.str().c_str());
+}

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

public:
   static llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>>
   Create(Module &module, DWARFDataExtractor debug_names,
          DWARFDataExtractor debug_str, SymbolFileDWARF &dwarf);
 
   void Preload() override { m_fallback.Preload(); }
 
   void
   GetGlobalVariables(ConstString basename,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void
   GetGlobalVariables(const RegularExpression &regex,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void
   GetGlobalVariables(const DWARFUnit &cu,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
-  void GetObjCMethods(ConstString class_name,
-                      llvm::function_ref<bool(DIERef ref)> callback) override {}
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void
-  GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                       llvm::function_ref<bool(DIERef ref)> callback) override;
+  GetObjCMethods(ConstString class_name,
+                 llvm::function_ref<bool(DWARFDIE die)> callback) override {}
+  void GetCompleteObjCClass(
+      ConstString class_name, bool must_be_implementation,
+      llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(ConstString name,
-                llvm::function_ref<bool(DIERef ref)> callback) override;
+                llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(const DWARFDeclContext &context,
-                llvm::function_ref<bool(DIERef ref)> callback) override;
+                llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetNamespaces(ConstString name,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetFunctions(const RegularExpression &regex,
-                    llvm::function_ref<bool(DIERef ref)> callback) override;
+                    llvm::function_ref<bool(DWARFDIE die)> callback) override;
 
-  void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) override {}
   void Dump(Stream &s) override;
 
 private:
   DebugNamesDWARFIndex(Module &module,
                        std::unique_ptr<llvm::DWARFDebugNames> debug_names_up,
                        DWARFDataExtractor debug_names_data,
                        DWARFDataExtractor debug_str_data,
                        SymbolFileDWARF &dwarf)
private:
   DWARFDataExtractor m_debug_str_data;
 
   using DebugNames = llvm::DWARFDebugNames;
   std::unique_ptr<DebugNames> m_debug_names_up;
   ManualDWARFIndex m_fallback;
 
   llvm::Optional<DIERef> ToDIERef(const DebugNames::Entry &entry);
   bool ProcessEntry(const DebugNames::Entry &entry,
-                    llvm::function_ref<bool(DIERef ref)> callback);
+                    llvm::function_ref<bool(DWARFDIE die)> callback,
+                    llvm::StringRef name);
 
   static void MaybeLogLookupError(llvm::Error error,
                                   const DebugNames::NameIndex &ni,
                                   llvm::StringRef name);
 
   static llvm::DenseSet<dw_offset_t> GetUnits(const DebugNames &debug_names);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DEBUGNAMESDWARFINDEX_H

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

 //===-- DebugNamesDWARFIndex.cpp ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
+#include "lldb/Core/Module.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>>
 DebugNamesDWARFIndex::Create(Module &module, DWARFDataExtractor debug_names,
if (llvm::Optional<uint64_t> die_offset = entry.getDIEUnitOffset())
     return DIERef(cu->GetSymbolFileDWARF().GetDwoNum(),
                   DIERef::Section::DebugInfo, cu->GetOffset() + *die_offset);
 
   return llvm::None;
 }
 
 bool DebugNamesDWARFIndex::ProcessEntry(
     const DebugNames::Entry &entry,
-    llvm::function_ref<bool(DIERef ref)> callback) {
-  if (llvm::Optional<DIERef> ref = ToDIERef(entry))
-    return callback(*ref);
+    llvm::function_ref<bool(DWARFDIE die)> callback, llvm::StringRef name) {
+  llvm::Optional<DIERef> ref = ToDIERef(entry);
+  if (!ref)
+    return true;
+  SymbolFileDWARF &dwarf =
+      *llvm::cast<SymbolFileDWARF>(m_module.GetSymbolFile());
+  DWARFDIE die = dwarf.GetDIE(*ref);
+  if (!die)
     return true;
+  return callback(die);
 }
 
 void DebugNamesDWARFIndex::MaybeLogLookupError(llvm::Error error,
                                                const DebugNames::NameIndex &ni,
                                                llvm::StringRef name) {
   // Ignore SentinelErrors, log everything else.
   LLDB_LOG_ERROR(
       LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS),
       handleErrors(std::move(error), [](const DebugNames::SentinelError &) {}),
       "Failed to parse index entries for index at {1:x}, name {2}: {0}",
       ni.getUnitOffset(), name);
 }
 
 void DebugNamesDWARFIndex::GetGlobalVariables(
-    ConstString basename, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) {
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(basename.GetStringRef())) {
     if (entry.tag() != DW_TAG_variable)
       continue;
 
-    if (!ProcessEntry(entry, callback))
+    if (!ProcessEntry(entry, callback, basename.GetStringRef()))
       return;
   }
 
   m_fallback.GetGlobalVariables(basename, callback);
 }
 
 void DebugNamesDWARFIndex::GetGlobalVariables(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       if (!regex.Execute(nte.getString()))
         continue;
 
       uint64_t entry_offset = nte.getEntryOffset();
       llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
       for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
         if (entry_or->tag() != DW_TAG_variable)
           continue;
 
-        if (!ProcessEntry(*entry_or, callback))
+        if (!ProcessEntry(*entry_or, callback,
+                          llvm::StringRef(nte.getString())))
           return;
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
 
   m_fallback.GetGlobalVariables(regex, callback);
 }
 
 void DebugNamesDWARFIndex::GetGlobalVariables(
-    const DWARFUnit &cu, llvm::function_ref<bool(DIERef ref)> callback) {
+    const DWARFUnit &cu, llvm::function_ref<bool(DWARFDIE die)> callback) {
   uint64_t cu_offset = cu.GetOffset();
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       uint64_t entry_offset = nte.getEntryOffset();
       llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
       for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
         if (entry_or->tag() != DW_TAG_variable)
           continue;
         if (entry_or->getCUOffset() != cu_offset)
           continue;
 
-        if (!ProcessEntry(*entry_or, callback))
+        if (!ProcessEntry(*entry_or, callback,
+                          llvm::StringRef(nte.getString())))
           return;
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
 
   m_fallback.GetGlobalVariables(cu, callback);
 }
 
 void DebugNamesDWARFIndex::GetCompleteObjCClass(
     ConstString class_name, bool must_be_implementation,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   // Keep a list of incomplete types as fallback for when we don't find the
   // complete type.
   DIEArray incomplete_types;
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(class_name.GetStringRef())) {
     if (entry.tag() != DW_TAG_structure_type &&
         entry.tag() != DW_TAG_class_type)
       continue;
 
     llvm::Optional<DIERef> ref = ToDIERef(entry);
     if (!ref)
       continue;
 
     DWARFUnit *cu = m_debug_info.GetUnit(*ref);
     if (!cu || !cu->Supports_DW_AT_APPLE_objc_complete_type()) {
       incomplete_types.push_back(*ref);
       continue;
     }
 
-    // FIXME: We should return DWARFDIEs so we don't have to resolve it twice.
     DWARFDIE die = m_debug_info.GetDIE(*ref);
-    if (!die)
+    if (!die) {
+      ReportInvalidDIERef(*ref, class_name.GetStringRef());
       continue;
+    }
 
     if (die.GetAttributeValueAsUnsigned(DW_AT_APPLE_objc_complete_type, 0)) {
       // If we find the complete version we're done.
-      callback(*ref);
+      callback(die);
       return;
     }
     incomplete_types.push_back(*ref);
   }
 
+  auto dierefcallback = DIERefCallback({callback, class_name.GetStringRef()});
   for (DIERef ref : incomplete_types)
-    if (!callback(ref))
+    if (!dierefcallback(ref))
       return;
 
   m_fallback.GetCompleteObjCClass(class_name, must_be_implementation, callback);
 }
 
 void DebugNamesDWARFIndex::GetTypes(
-    ConstString name, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     if (isType(entry.tag())) {
-      if (!ProcessEntry(entry, callback))
+      if (!ProcessEntry(entry, callback, name.GetStringRef()))
         return;
     }
   }
 
   m_fallback.GetTypes(name, callback);
 }
 
 void DebugNamesDWARFIndex::GetTypes(
     const DWARFDeclContext &context,
-    llvm::function_ref<bool(DIERef ref)> callback) {
-  for (const DebugNames::Entry &entry :
-       m_debug_names_up->equal_range(context[0].name)) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
+  auto name = context[0].name;
+  for (const DebugNames::Entry &entry : m_debug_names_up->equal_range(name)) {
     if (entry.tag() == context[0].tag) {
-      if (!ProcessEntry(entry, callback))
+      if (!ProcessEntry(entry, callback, name))
         return;
     }
   }
 
   m_fallback.GetTypes(context, callback);
 }
 
 void DebugNamesDWARFIndex::GetNamespaces(
-    ConstString name, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     if (entry.tag() == DW_TAG_namespace) {
-      if (!ProcessEntry(entry, callback))
+      if (!ProcessEntry(entry, callback, name.GetStringRef()))
         return;
     }
   }
 
   m_fallback.GetNamespaces(name, callback);
 }
 
 void DebugNamesDWARFIndex::GetFunctions(
void DebugNamesDWARFIndex::GetFunctions(
   }
 
   m_fallback.GetFunctions(name, dwarf, parent_decl_ctx, name_type_mask,
                           callback);
 }
 
 void DebugNamesDWARFIndex::GetFunctions(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       if (!regex.Execute(nte.getString()))
         continue;
 
       uint64_t entry_offset = nte.getEntryOffset();
       llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
       for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
         Tag tag = entry_or->tag();
         if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine)
           continue;
 
-        if (!ProcessEntry(*entry_or, callback))
+        if (!ProcessEntry(*entry_or, callback,
+                          llvm::StringRef(nte.getString())))
           return;
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
 
   m_fallback.GetFunctions(regex, callback);
 }

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

ManualDWARFIndex(Module &module, SymbolFileDWARF &dwarf,
                    llvm::DenseSet<dw_offset_t> units_to_avoid = {})
       : DWARFIndex(module), m_dwarf(&dwarf),
         m_units_to_avoid(std::move(units_to_avoid)) {}
 
   void Preload() override { Index(); }
 
   void
   GetGlobalVariables(ConstString basename,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void
   GetGlobalVariables(const RegularExpression &regex,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void
   GetGlobalVariables(const DWARFUnit &unit,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetObjCMethods(ConstString class_name,
-                      llvm::function_ref<bool(DIERef ref)> callback) override;
-  void
-  GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                       llvm::function_ref<bool(DIERef ref)> callback) override;
+                      llvm::function_ref<bool(DWARFDIE die)> callback) override;
+  void GetCompleteObjCClass(
+      ConstString class_name, bool must_be_implementation,
+      llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(ConstString name,
-                llvm::function_ref<bool(DIERef ref)> callback) override;
+                llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetTypes(const DWARFDeclContext &context,
-                llvm::function_ref<bool(DIERef ref)> callback) override;
+                llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetNamespaces(ConstString name,
-                     llvm::function_ref<bool(DIERef ref)> callback) override;
+                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
   void GetFunctions(const RegularExpression &regex,
-                    llvm::function_ref<bool(DIERef ref)> callback) override;
+                    llvm::function_ref<bool(DWARFDIE die)> callback) override;
 
-  void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) override {}
   void Dump(Stream &s) override;
 
 private:
   struct IndexSet {
     NameToDIE function_basenames;
     NameToDIE function_fullnames;
     NameToDIE function_methods;
     NameToDIE function_selectors;

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

for (const DWARFDebugInfoEntry &die : unit.dies()) {
 
     default:
       continue;
     }
   }
 }
 
 void ManualDWARFIndex::GetGlobalVariables(
-    ConstString basename, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
-  m_set.globals.Find(basename, callback);
+  m_set.globals.Find(basename,
+                     DIERefCallback({callback, basename.GetStringRef()}));
 }
 
 void ManualDWARFIndex::GetGlobalVariables(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
-  m_set.globals.Find(regex, callback);
+  m_set.globals.Find(regex, DIERefCallback({callback, regex.GetText()}));
 }
 
 void ManualDWARFIndex::GetGlobalVariables(
-    const DWARFUnit &unit, llvm::function_ref<bool(DIERef ref)> callback) {
+    const DWARFUnit &unit, llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
-  m_set.globals.FindAllEntriesForUnit(unit, callback);
+  m_set.globals.FindAllEntriesForUnit(unit, DIERefCallback({callback}));
 }
 
 void ManualDWARFIndex::GetObjCMethods(
-    ConstString class_name, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString class_name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
-  m_set.objc_class_selectors.Find(class_name, callback);
+  SymbolFileDWARF &dwarf =
+      *llvm::cast<SymbolFileDWARF>(m_module.GetSymbolFile());
+  m_set.objc_class_selectors.Find(class_name, [&](DIERef ref) {
+    DWARFDIE die = dwarf.GetDIE(ref);
+    if (!die)
+      return false;
+    return callback(die);
+  });
 }
 
 void ManualDWARFIndex::GetCompleteObjCClass(
     ConstString class_name, bool must_be_implementation,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
-  m_set.types.Find(class_name, callback);
+  m_set.types.Find(class_name,
+                   DIERefCallback({callback, class_name.GetStringRef()}));
 }
 
-void ManualDWARFIndex::GetTypes(ConstString name,
-                                llvm::function_ref<bool(DIERef ref)> callback) {
+void ManualDWARFIndex::GetTypes(
+    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
-  m_set.types.Find(name, callback);
+  m_set.types.Find(name, DIERefCallback({callback, name.GetStringRef()}));
 }
 
-void ManualDWARFIndex::GetTypes(const DWARFDeclContext &context,
-                                llvm::function_ref<bool(DIERef ref)> callback) {
+void ManualDWARFIndex::GetTypes(
+    const DWARFDeclContext &context,
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
-  m_set.types.Find(ConstString(context[0].name), callback);
+  auto name = context[0].name;
+  m_set.types.Find(ConstString(name),
+                   DIERefCallback({callback, llvm::StringRef(name)}));
 }
 
 void ManualDWARFIndex::GetNamespaces(
-    ConstString name, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
-  m_set.namespaces.Find(name, callback);
+  m_set.namespaces.Find(name, DIERefCallback({callback, name.GetStringRef()}));
 }
 
 void ManualDWARFIndex::GetFunctions(
     ConstString name, SymbolFileDWARF &dwarf,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
     llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
 
   if (name_type_mask & eFunctionNameTypeFull) {
-    if (!m_set.function_fullnames.Find(name, [&](DIERef die_ref) {
-          DWARFDIE die = dwarf.GetDIE(die_ref);
-          if (!die)
-            return true;
-          if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
+    if (!m_set.function_fullnames.Find(
+            name, DIERefCallback({[&](DWARFDIE die) {
+                                    if (!SymbolFileDWARF::DIEInDeclContext(
+                                            parent_decl_ctx, die))
                                       return true;
                                     return callback(die);
-        }))
+                                  },
+                                  name.GetStringRef()})))
       return;
   }
   if (name_type_mask & eFunctionNameTypeBase) {
-    if (!m_set.function_basenames.Find(name, [&](DIERef die_ref) {
-          DWARFDIE die = dwarf.GetDIE(die_ref);
-          if (!die)
-            return true;
-          if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
+    if (!m_set.function_basenames.Find(
+            name, DIERefCallback({[&](DWARFDIE die) {
+                                    if (!SymbolFileDWARF::DIEInDeclContext(
+                                            parent_decl_ctx, die))
                                       return true;
                                     return callback(die);
-        }))
+                                  },
+                                  name.GetStringRef()})))
       return;
   }
 
   if (name_type_mask & eFunctionNameTypeMethod && !parent_decl_ctx.IsValid()) {
-    if (!m_set.function_methods.Find(name, [&](DIERef die_ref) {
-          DWARFDIE die = dwarf.GetDIE(die_ref);
-          if (!die)
-            return true;
-          return callback(die);
-        }))
+    if (!m_set.function_methods.Find(
+            name, DIERefCallback({callback, name.GetStringRef()})))
       return;
   }
 
   if (name_type_mask & eFunctionNameTypeSelector &&
       !parent_decl_ctx.IsValid()) {
-    if (!m_set.function_selectors.Find(name, [&](DIERef die_ref) {
-          DWARFDIE die = dwarf.GetDIE(die_ref);
-          if (!die)
-            return true;
-          return callback(die);
-        }))
+    if (!m_set.function_selectors.Find(
+            name, DIERefCallback({callback, name.GetStringRef()})))
       return;
   }
 }
 
 void ManualDWARFIndex::GetFunctions(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   Index();
 
-  if (!m_set.function_basenames.Find(regex, callback))
+  if (!m_set.function_basenames.Find(
+          regex, DIERefCallback({callback, regex.GetText()})))
     return;
-  if (!m_set.function_fullnames.Find(regex, callback))
+  if (!m_set.function_fullnames.Find(
+          regex, DIERefCallback({callback, regex.GetText()})))
     return;
 }
 
 void ManualDWARFIndex::Dump(Stream &s) {
   s.Format("Manual DWARF index for ({0}) '{1:F}':",
            m_module.GetArchitecture().GetArchitectureName(),
            m_module.GetObjectFile()->GetFileSpec());
   s.Printf("\nFunction basenames:\n");

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

public:
 
   bool
   HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type);
 
   lldb_private::CompileUnit *
   GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu);
 
   virtual void GetObjCMethods(lldb_private::ConstString class_name,
-                              llvm::function_ref<bool(DIERef ref)> callback);
+                              llvm::function_ref<bool(DWARFDIE die)> callback);
 
   bool Supports_DW_AT_APPLE_objc_complete_type(DWARFUnit *cu);
 
   lldb_private::DebugMacrosSP ParseDebugMacros(lldb::offset_t *offset);
 
   static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die);
 
   lldb::ModuleSP GetExternalModule(lldb_private::ConstString name);

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

if (non_dwo_cu->GetUserData() == nullptr) {
     // The symbol vendor doesn't know about this compile unit, we need to parse
     // and add it to the symbol vendor object.
     return ParseCompileUnit(*non_dwo_cu).get();
   }
   return static_cast<CompileUnit *>(non_dwo_cu->GetUserData());
 }
 
 void SymbolFileDWARF::GetObjCMethods(
-    ConstString class_name, llvm::function_ref<bool(DIERef ref)> callback) {
+    ConstString class_name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   m_index->GetObjCMethods(class_name, callback);
 }
 
 bool SymbolFileDWARF::GetFunction(const DWARFDIE &die, SymbolContext &sc) {
   sc.Clear(false);
 
   if (die && llvm::isa<DWARFCompileUnit>(die.GetCU())) {
     // Check if the symbol vendor already knows about this compile unit?
if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name.GetCString(),
                                                       context, basename))
     basename = name.GetStringRef();
 
   // Loop invariant: Variables up to this index have been checked for context
   // matches.
   uint32_t pruned_idx = original_size;
 
   SymbolContext sc;
-  m_index->GetGlobalVariables(ConstString(basename), [&](DIERef die_ref) {
+  m_index->GetGlobalVariables(ConstString(basename), [&](DWARFDIE die) {
     if (!sc.module_sp)
       sc.module_sp = m_objfile_sp->GetModule();
     assert(sc.module_sp);
 
-    DWARFDIE die = GetDIE(die_ref);
-    if (!die) {
-      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      return true;
-    }
-
     if (die.Tag() != DW_TAG_variable)
       return true;
 
     auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
     if (!dwarf_cu)
       return true;
     sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
GetObjectFile()->GetModule()->LogMessage(
         "max_matches=%u, variables)",
         regex.GetText().str().c_str(), max_matches);
   }
 
   // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
 
   SymbolContext sc;
-  m_index->GetGlobalVariables(regex, [&](DIERef die_ref) {
+  m_index->GetGlobalVariables(regex, [&](DWARFDIE die) {
     if (!sc.module_sp)
       sc.module_sp = m_objfile_sp->GetModule();
     assert(sc.module_sp);
 
-    DWARFDIE die = GetDIE(die_ref);
-    if (!die) {
-      m_index->ReportInvalidDIERef(die_ref, regex.GetText());
-      return true;
-    }
-
     DWARFCompileUnit *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
     if (!dwarf_cu)
       return true;
     sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
     ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
 
     return variables.GetSize() - original_size < max_matches;
void SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log, "SymbolFileDWARF::FindFunctions (regex=\"%s\", sc_list)",
         regex.GetText().str().c_str());
   }
 
-  DWARFDebugInfo &info = DebugInfo();
   llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
-  m_index->GetFunctions(regex, [&](DIERef ref) {
-    DWARFDIE die = info.GetDIE(ref);
-    if (!die) {
-      m_index->ReportInvalidDIERef(ref, regex.GetText());
-      return true;
-    }
+  m_index->GetFunctions(regex, [&](DWARFDIE die) {
     if (resolved_dies.insert(die.GetDIE()).second)
       ResolveFunction(die, include_inlines, sc_list);
     return true;
   });
 }
 
 void SymbolFileDWARF::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
else
           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
           "NULL, max_matches=%u, type_list)",
           name.GetCString(), max_matches);
   }
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
 
-  m_index->GetTypes(name, [&](DIERef die_ref) {
-    DWARFDIE die = GetDIE(die_ref);
-    if (!die) {
-      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      return true;
-    }
-
+  m_index->GetTypes(name, [&](DWARFDIE die) {
     if (!DIEInDeclContext(parent_decl_ctx, die))
       return true; // The containing decl contexts don't match
 
     Type *matching_type = ResolveType(die, true, true);
     if (!matching_type)
       return true;
 
     // We found a type pointer, now find the shared pointer form our type
void SymbolFileDWARF::FindTypes(
   if (pattern.empty())
     return;
 
   ConstString name = pattern.back().name;
 
   if (!name)
     return;
 
-  m_index->GetTypes(name, [&](DIERef die_ref) {
-    DWARFDIE die = GetDIE(die_ref);
-    if (!die) {
-      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      return true;
-    }
-
+  m_index->GetTypes(name, [&](DWARFDIE die) {
     if (!languages[GetLanguage(*die.GetCU())])
       return true;
 
     llvm::SmallVector<CompilerContext, 4> die_context;
     die.GetDeclContext(die_context);
     if (!contextMatches(die_context, pattern))
       return true;
 
GetObjectFile()->GetModule()->LogMessage(
         name.GetCString());
   }
 
   CompilerDeclContext namespace_decl_ctx;
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return namespace_decl_ctx;
 
-  m_index->GetNamespaces(name, [&](DIERef die_ref) {
-    DWARFDIE die = GetDIE(die_ref);
-    if (!die) {
-      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      return true;
-    }
-
+  m_index->GetNamespaces(name, [&](DWARFDIE die) {
     if (!DIEInDeclContext(parent_decl_ctx, die))
       return true; // The containing decl contexts don't match
 
     DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
     if (!dwarf_ast)
       return true;
 
     namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
     const DWARFDIE &die, ConstString type_name, bool must_be_implementation) {
 
   TypeSP type_sp;
 
   if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
     return type_sp;
 
   m_index->GetCompleteObjCClass(
-      type_name, must_be_implementation, [&](DIERef die_ref) {
-        DWARFDIE type_die = GetDIE(die_ref);
-        if (!type_die) {
-          m_index->ReportInvalidDIERef(die_ref, type_name.GetStringRef());
-          return true;
-        }
-
+      type_name, must_be_implementation, [&](DWARFDIE type_die) {
         bool try_resolving_type = false;
 
         // Don't try and resolve the DIE we are looking for with the DIE
         // itself!
         if (type_die != die) {
           switch (type_die.Tag()) {
           case DW_TAG_class_type:
           case DW_TAG_structure_type:
if (type_name) {
               lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
               std::move(err), "Cannot get TypeSystem for language {}",
               Language::GetNameForLanguageType(language));
         } else {
           type_system = &type_system_or_err.get();
         }
       }
 
-      m_index->GetTypes(dwarf_decl_ctx, [&](DIERef die_ref) {
-        DWARFDIE type_die = GetDIE(die_ref);
-        if (!type_die) {
-          m_index->ReportInvalidDIERef(die_ref, type_name.GetStringRef());
-          return true;
-        }
-
+      m_index->GetTypes(dwarf_decl_ctx, [&](DWARFDIE type_die) {
         // Make sure type_die's langauge matches the type system we are
         // looking for. We don't want to find a "Foo" type from Java if we
         // are looking for a "Foo" type for C, C++, ObjC, or ObjC++.
         if (type_system &&
             !type_system->SupportsLanguage(GetLanguage(*type_die.GetCU())))
           return true;
         bool try_resolving_type = false;
 
if (sc.function) {
       uint32_t vars_added = 0;
       VariableListSP variables(sc.comp_unit->GetVariableList(false));
 
       if (variables.get() == nullptr) {
         variables = std::make_shared<VariableList>();
         sc.comp_unit->SetVariableList(variables);
 
         m_index->GetGlobalVariables(
-            dwarf_cu->GetNonSkeletonUnit(), [&](DIERef die_ref) {
-              DWARFDIE die = GetDIE(die_ref);
-              if (!die) {
-                m_index->ReportInvalidDIERef(die_ref, "");
-                return true;
-              }
+            dwarf_cu->GetNonSkeletonUnit(), [&](DWARFDIE die) {
               VariableSP var_sp(
                   ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
               if (var_sp) {
                 variables->AddVariableIfUnique(var_sp);
                 ++vars_added;
               }
               return true;
             });

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

public:
   SymbolFileDWARFDwo(SymbolFileDWARF &m_base_symbol_file,
                      lldb::ObjectFileSP objfile, uint32_t id);
 
   ~SymbolFileDWARFDwo() override = default;
 
   DWARFCompileUnit *GetDWOCompileUnitForHash(uint64_t hash);
 
   void GetObjCMethods(lldb_private::ConstString class_name,
-                      llvm::function_ref<bool(DIERef ref)> callback) override;
+                      llvm::function_ref<bool(DWARFDIE die)> callback) override;
 
   llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   DWARFDIE
   GetDIE(const DIERef &die_ref) override;
 
   llvm::Optional<uint32_t> GetDwoNum() override { return GetID() >> 32; }

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

 
 SymbolFileDWARF::ClangTypeToDIE &
 SymbolFileDWARFDwo::GetForwardDeclClangTypeToDie() {
   return GetBaseSymbolFile().GetForwardDeclClangTypeToDie();
 }
 
 void SymbolFileDWARFDwo::GetObjCMethods(
     lldb_private::ConstString class_name,
-    llvm::function_ref<bool(DIERef ref)> callback) {
+    llvm::function_ref<bool(DWARFDIE die)> callback) {
   GetBaseSymbolFile().GetObjCMethods(class_name, callback);
 }
 
 UniqueDWARFASTTypeMap &SymbolFileDWARFDwo::GetUniqueDWARFASTTypeMap() {
   return GetBaseSymbolFile().GetUniqueDWARFASTTypeMap();
 }
 
 lldb::TypeSP SymbolFileDWARFDwo::FindDefinitionTypeForDWARFDeclContext(