1/2: [nfc] [lldb] Introduce DWARF callbacks

[jankratochvil]

Summary

As requested by @labath in https://reviews.llvm.org/D73206#1949516 (D73206) providing DWARF index callbacks refactorization.

[jankratochvil]

lldb/include/lldb/Core/UniqueCStringMap.h

134

Semantics of the callback is apparent - return true if the caller no longer needs any more data. Not sure where to document that, maybe it is simple enough in the code.

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

68–69

DIEInfoArray is not callback-optimized in this patch. That could be done as an add-on patch.

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

84

The meaning of return_implementation_only_if_available has changed here. The only caller was using it with true so now the only existing caller calls it twice - first with true and then with false as we can no longer do the original die_offsets.clear();.

[jankratochvil]

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

2387

This is not NFC but it is required by the refactorization. I have posted this bugfix separately as D77336.

[jankratochvil]

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

2387

It has been now fixed by checked-in D77336.

[labath]

Thanks for doing this. This looks more-or-less like what I was expecting. The need for the "bool" return value from the index functions is unfortunate (I did not anticipate that), but it does seem unavoidable.

Since none of these functions (I guess) are storing the callback function, could you replace std::function with llvm::function_ref ?

lldb/include/lldb/Core/UniqueCStringMap.h

130–163

I'm not sure these functions are really needed. They have just one caller, and they'd be trivial if this class provided appropriate abstractions. Maybe just add begin/end/equal_range methods, so that one can write:

for (value: map / map.equal_range(str))
  stuff

?

(ideally, I'd like to have iterators instead of callbacks for the index classes too, but iterators and class hierarchies don't mix very well)

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

79–80

Maybe rename this to ProcessEntry or something?

[jankratochvil]

lldb/include/lldb/Core/UniqueCStringMap.h

130–163

Do you mean the standard iteration:

for (std::pair<ConstString, DIERef> pair : map)
  stuff;

or really

for (DIERef ref : map)
  stuff;

?

[jankratochvil]

lldb/include/lldb/Core/UniqueCStringMap.h

130–163

Implemented. IIUC for regexes it should be matched in a caller - or to make also an iterator for regexes?

for (const auto &entry : m_map.equal_range(name))
  if (callback(entry.value))

for (const auto &entry : m_map)
  if (regex.Execute(entry.cstring.GetCString())) {
    if (callback(entry.value))

[aprantl]

lldb/include/lldb/Core/UniqueCStringMap.h

101

///

[shafik]

lldb/include/lldb/Core/UniqueCStringMap.h

102

CStringIterator?

133

It feels like this should be a pointer, m_entry_ptr is a pointer already and most uses in the class use the pointer value already.

[labath]

I can't say I have tried this, but ummm.. why is there a need for a separate iterator class for this equal_range stuff? Couldn't this be implemented via an iterator_pair of the iterators of the underlying container (found via lower/upper_bound) ?

lldb/include/lldb/Core/UniqueCStringMap.h

130–163

Yes, that is correct.

[jankratochvil]

In D77327#1967060, @labath wrote:

I can't say I have tried this, but ummm.. why is there a need for a separate iterator class for this equal_range stuff? Couldn't this be implemented via an iterator_pair of the iterators of the underlying container (found via lower/upper_bound) ?

OK, true, I will rework it.

[jankratochvil]

lldb/include/lldb/Core/UniqueCStringMap.h

101

I am sorry but all comments in this file are // . I can make a conversion of the file to Doxygen in a separate file if you wish but I am not sure how much is Doxygen widespread in LLDB etc.

102

This custom iterator has been now dropped upon advice by @labath the standard iterator is enough.

133

This custom iterator has been now dropped upon advice by @labath the standard iterator is enough.
BTW I have seen patches all pointers which cannot be nullptr to be converted to references which is why I used the reference here. But it is gone now anyway.

[labath]

lldb/include/lldb/Core/UniqueCStringMap.h

208–213

Looks better, but I have a feeling it could be simplified even further. Wouldn't a plain return llvm::make_range(std::equal_range(m_map.begin(), m_map.end(), Compare()); work just as well? (Sorry for taking you down the wrong path with the lower/upper_bound comment -- equal_range is basically a combination of lower_bound and upper_bound calls.)

[jankratochvil]

lldb/include/lldb/Core/UniqueCStringMap.h

208–213

Yes, sorry, I was never using these functions before.

[labath]

I just had one more idea. The bool return value on all of these methods, is that here just to implement the fallback mechanism in DebugNamesDWARFIndex? Could it be avoided if debug_names index calls the "fallback" *after* it has done its own processing?

[jankratochvil]

In D77327#1971435, @labath wrote:

The bool return value on all of these methods, is that here just to implement the fallback mechanism in DebugNamesDWARFIndex?

Most of them yes. There are still some functions needing to return bool to benefit from the early returns from callbacks. I hope I found the minimal set of such bool functions (none of those are in DWARFIndex).

Could it be avoided if debug_names index calls the "fallback" *after* it has done its own processing?

Yes. Done so now. I still do not understand what is DebugNamesDWARFIndex good for when it always calls ManualDWARFIndex anyway.

[labath]

In D77327#1971794, @jankratochvil wrote:

In D77327#1971435, @labath wrote:

The bool return value on all of these methods, is that here just to implement the fallback mechanism in DebugNamesDWARFIndex?

Most of them yes. There are still some functions needing to return bool to benefit from the early returns from callbacks. I hope I found the minimal set of such bool functions (none of those are in DWARFIndex).

Cool. I am very sorry about the back-and-forth but I just noticed another issue. The normal semantics of callbacks like these is to return true when one wants to continue iterating (e.g. [[ https://github.com/llvm/llvm-project/blob/cdc514e4c67f268b07863bbac3d8d7e0d088186c/lldb/include/lldb/Core/MappedHash.h#L293 | here ]). This patch has the meanings reversed. I think it would be good to maintain the current convention.

Otherwise this looks good, and I really hope this will be the last iteration.

Could it be avoided if debug_names index calls the "fallback" *after* it has done its own processing?

Yes. Done so now. I still do not understand what is DebugNamesDWARFIndex good for when it always calls ManualDWARFIndex anyway.

One cannot guarantee that the debug_names section will cover all compilation units in a given file. So we still need to call the manual index to index the rest. However we pass it a list of units it should avoid (see DebugNamesDWARFIndex constructor), so we don't index everything twice.

Theoretically the calls to the fallback index could be guarded by an if (debug_names_really_covers_everything) check, but that wouldn't really help anything -- in that case the manual index would index an empty set of units and so all calls to it would be a quick no-op anyway.

[jankratochvil]

In D77327#1980079, @labath wrote:

The normal semantics of callbacks like these is to return true when one wants to continue iterating

OK, fixed, thanks for catching it.

One cannot guarantee that the debug_names section will cover all compilation units in a given file. So we still need to call the manual index to index the rest. However we pass it a list of units it should avoid (see DebugNamesDWARFIndex constructor), so we don't index everything twice.

OK, that llvm::DenseSet<dw_offset_t> units_to_avoid. Thanks for the explanation, it makes sense now.

[labath]

Cool.

[jankratochvil]

I had to revert it: rG9289f34390da
It has caused a regression: lang/cpp/accelerator-table/TestCPPAccelerator.py

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/15323/consoleFull

[jankratochvil]

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

140

I have found a bug/regression here, during the last check-in there was:

if (!m_apple_types_up->FindByName(context[1].name,

Just I cannot test it now myself without OSX.

[mib]

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

140

Just tried that change on macOS, and this indeed fixes the regression. Just waiting for the test suite run to finish to make sure it didn't break something else.

[mib]

It looks like there's no more regression. LGTM, thanks!

lldb/include/lldb/Core/UniqueCStringMap.h

public:
   // during while using the returned pointer.
   const Entry *FindFirstValueForName(ConstString unique_cstr) const {
     auto pos = llvm::lower_bound(m_map, unique_cstr, Compare());
     if (pos != m_map.end() && pos->cstring == unique_cstr)
       return &(*pos);
     return nullptr;
   }
 
   // Get a pointer to the next entry that matches "name" from a previously
   // returned Entry pointer. nullptr will be returned if there is no subsequent
   // entry that matches "name".
   //
   // The caller is responsible for ensuring that the collection does not change
   // during while using the returned pointer.
   const Entry *FindNextValueForName(const Entry *entry_ptr) const {
     if (!m_map.empty()) {
       const Entry *first_entry = &m_map[0];
       const Entry *after_last_entry = first_entry + m_map.size();
size_t GetValues(ConstString unique_cstr, std::vector<T> &values) const {
 
     for (const Entry &entry : llvm::make_range(std::equal_range(
              m_map.begin(), m_map.end(), unique_cstr, Compare())))
       values.push_back(entry.value);
 
     return values.size() - start_size;
   }
 
+  bool GetValues(ConstString unique_cstr,
+                 std::function<bool(T value)> callback) const {
+    for (const Entry &entry : llvm::make_range(std::equal_range(
+             m_map.begin(), m_map.end(), unique_cstr, Compare())))
+      if (callback(entry.value))
+        return true;
+
+    return false;
+  }
+
   size_t GetValues(const RegularExpression &regex,
                    std::vector<T> &values) const {
     const size_t start_size = values.size();
 
     const_iterator pos, end = m_map.end();
     for (pos = m_map.begin(); pos != end; ++pos) {
       if (regex.Execute(pos->cstring.GetCString()))
         values.push_back(pos->value);
     }
 
     return values.size() - start_size;
   }
 
+  bool GetValues(const RegularExpression &regex,
+                 std::function<bool(T value)> callback) const {
+    const_iterator pos, end = m_map.end();
+    for (pos = m_map.begin(); pos != end; ++pos)
+      if (regex.Execute(pos->cstring.GetCString())) {
+        if (callback(pos->value))
+          return true;
+      }
+
+    return false;
+  }
+
   // Get the total number of entries in this map.
   size_t GetSize() const { return m_map.size(); }
 
   // Returns true if this map is empty.
   bool IsEmpty() const { return m_map.empty(); }
 
   // Reserve memory for at least "n" entries in the map. This is useful to call
   // when you know you will be adding a lot of entries using

 protected:
   struct Compare {
     bool operator()(const Entry &lhs, const Entry &rhs) {
       return operator()(lhs.cstring, rhs.cstring);
     }
 
     bool operator()(const Entry &lhs, ConstString rhs) {
       return operator()(lhs.cstring, rhs);
     }
 
     bool operator()(ConstString lhs, const Entry &rhs) {
       return operator()(lhs, rhs.cstring);
     }
 
     // This is only for uniqueness, not lexicographical ordering, so we can
     // just compare pointers. *However*, comparing pointers from different
     // allocations is UB, so we need compare their integral values instead.
     bool operator()(ConstString lhs, ConstString rhs) {
       return uintptr_t(lhs.GetCString()) < uintptr_t(rhs.GetCString());
     }
   };
   typedef std::vector<Entry> collection;
   typedef typename collection::iterator iterator;
   typedef typename collection::const_iterator const_iterator;
   collection m_map;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_UNIQUECSTRINGMAP_H

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

AppleDWARFIndex(
       std::unique_ptr<DWARFMappedHash::MemoryTable> apple_objc)
       : DWARFIndex(module), m_apple_names_up(std::move(apple_names)),
         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, DIEArray &offsets) override;
-  void GetGlobalVariables(const RegularExpression &regex,
-                          DIEArray &offsets) override;
-  void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) override;
-  void GetObjCMethods(ConstString class_name, DIEArray &offsets) override;
-  void GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                            DIEArray &offsets) override;
-  void GetTypes(ConstString name, DIEArray &offsets) override;
-  void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) override;
-  void GetNamespaces(ConstString name, DIEArray &offsets) override;
-  void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
+  bool GetGlobalVariables(ConstString basename,
+                          std::function<bool(DIERef ref)> callback) override;
+  bool GetGlobalVariables(const RegularExpression &regex,
+                          std::function<bool(DIERef ref)> callback) override;
+  bool GetGlobalVariables(const DWARFUnit &cu,
+                          std::function<bool(DIERef ref)> callback) override;
+  bool GetObjCMethods(ConstString class_name,
+                      std::function<bool(DIERef ref)> callback) override;
+  bool GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
+                            std::function<bool(DIERef ref)> callback) override;
+  bool GetTypes(ConstString name,
+                std::function<bool(DIERef ref)> callback) override;
+  bool GetTypes(const DWARFDeclContext &context,
+                std::function<bool(DIERef ref)> callback) override;
+  bool GetNamespaces(ConstString name,
+                     std::function<bool(DIERef ref)> callback) override;
+  bool GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
-                    std::vector<DWARFDIE> &dies) override;
-  void GetFunctions(const RegularExpression &regex, DIEArray &offsets) override;
+                    std::function<bool(DWARFDIE die)> callback) override;
+  bool GetFunctions(const RegularExpression &regex,
+                    std::function<bool(DIERef ref)> 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

if (apple_names_table_up || apple_names_table_up || apple_types_table_up ||
     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, DIEArray &offsets) {
+bool AppleDWARFIndex::GetGlobalVariables(
+    ConstString basename, std::function<bool(DIERef ref)> callback) {
   if (!m_apple_names_up)
-    return;
-  m_apple_names_up->FindByName(basename.GetStringRef(), offsets);
+    return false;
+  return m_apple_names_up->FindByName(basename.GetStringRef(), callback);
 }
 
-void AppleDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
-                                         DIEArray &offsets) {
+bool AppleDWARFIndex::GetGlobalVariables(
+    const RegularExpression &regex, std::function<bool(DIERef ref)> callback) {
   if (!m_apple_names_up)
-    return;
+    return false;
 
   DWARFMappedHash::DIEInfoArray hash_data;
-  if (m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data))
-    DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
+  m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data);
+  return DWARFMappedHash::ExtractDIEArray(hash_data, callback);
 }
 
-void AppleDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
-                                         DIEArray &offsets) {
+bool AppleDWARFIndex::GetGlobalVariables(
+    const DWARFUnit &cu, std::function<bool(DIERef ref)> callback) {
   if (!m_apple_names_up)
-    return;
+    return false;
 
   DWARFMappedHash::DIEInfoArray hash_data;
-  if (m_apple_names_up->AppendAllDIEsInRange(cu.GetOffset(),
-                                             cu.GetNextUnitOffset(), hash_data))
-    DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
+  m_apple_names_up->AppendAllDIEsInRange(cu.GetOffset(), cu.GetNextUnitOffset(),
+                                         hash_data);
+  return DWARFMappedHash::ExtractDIEArray(hash_data, callback);
 }
 
-void AppleDWARFIndex::GetObjCMethods(ConstString class_name,
-                                     DIEArray &offsets) {
+bool AppleDWARFIndex::GetObjCMethods(ConstString class_name,
+                                     std::function<bool(DIERef ref)> callback) {
   if (!m_apple_objc_up)
-    return;
-  m_apple_objc_up->FindByName(class_name.GetStringRef(), offsets);
+    return false;
+  return m_apple_objc_up->FindByName(class_name.GetStringRef(), callback);
 }
 
-void AppleDWARFIndex::GetCompleteObjCClass(ConstString class_name,
-                                           bool must_be_implementation,
-                                           DIEArray &offsets) {
+bool AppleDWARFIndex::GetCompleteObjCClass(
+    ConstString class_name, bool must_be_implementation,
+    std::function<bool(DIERef ref)> callback) {
   if (!m_apple_types_up)
-    return;
-  m_apple_types_up->FindCompleteObjCClassByName(
-      class_name.GetStringRef(), offsets, must_be_implementation);
+    return false;
+  return m_apple_types_up->FindCompleteObjCClassByName(
+      class_name.GetStringRef(), callback, must_be_implementation);
 }
 
-void AppleDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
+bool AppleDWARFIndex::GetTypes(ConstString name,
+                               std::function<bool(DIERef ref)> callback) {
   if (!m_apple_types_up)
-    return;
-  m_apple_types_up->FindByName(name.GetStringRef(), offsets);
+    return false;
+  return m_apple_types_up->FindByName(name.GetStringRef(), callback);
 }
 
-void AppleDWARFIndex::GetTypes(const DWARFDeclContext &context,
-                               DIEArray &offsets) {
+bool AppleDWARFIndex::GetTypes(const DWARFDeclContext &context,
+                               std::function<bool(DIERef ref)> callback) {
   if (!m_apple_types_up)
-    return;
+    return false;
 
   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, offsets);
-    return;
+    return m_apple_types_up->FindByNameAndTagAndQualifiedNameHash(
+        type_name.GetStringRef(), tag, qualified_name_hash, callback);
   }
 
   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)) {
-      DIEArray class_matches;
-      m_apple_types_up->FindByName(context[1].name, class_matches);
-      if (class_matches.empty())
-        return;
+      if (!m_apple_types_up->FindByName(context[1].name,
+                                        [&](DIERef ref) { return true; }))
+        return false;
     }
 
     if (log)
       m_module.LogMessage(log, "FindByNameAndTag()");
-    m_apple_types_up->FindByNameAndTag(type_name.GetStringRef(), tag, offsets);
-    return;
+    return m_apple_types_up->FindByNameAndTag(type_name.GetStringRef(), tag,
+                                              callback);
   }
 
-  m_apple_types_up->FindByName(type_name.GetStringRef(), offsets);
+  return m_apple_types_up->FindByName(type_name.GetStringRef(), callback);
 }
 
-void AppleDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
+bool AppleDWARFIndex::GetNamespaces(ConstString name,
+                                    std::function<bool(DIERef ref)> callback) {
   if (!m_apple_namespaces_up)
-    return;
-  m_apple_namespaces_up->FindByName(name.GetStringRef(), offsets);
+    return false;
+  return m_apple_namespaces_up->FindByName(name.GetStringRef(), callback);
 }
 
-void AppleDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
+bool AppleDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                                    const CompilerDeclContext &parent_decl_ctx,
                                    uint32_t name_type_mask,
-                                   std::vector<DWARFDIE> &dies) {
-  DIEArray offsets;
-  m_apple_names_up->FindByName(name.GetStringRef(), offsets);
-  for (const DIERef &die_ref : offsets) {
-    ProcessFunctionDIE(name.GetStringRef(), die_ref, dwarf, parent_decl_ctx,
-                       name_type_mask, dies);
-  }
+                                   std::function<bool(DWARFDIE die)> callback) {
+  return 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,
-                                   DIEArray &offsets) {
+bool AppleDWARFIndex::GetFunctions(const RegularExpression &regex,
+                                   std::function<bool(DIERef ref)> callback) {
   if (!m_apple_names_up)
-    return;
+    return false;
 
   DWARFMappedHash::DIEInfoArray hash_data;
-  if (m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data))
-    DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
+  m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data);
+  return 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());

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) {
-        DIEArray method_die_offsets;
-        dwarf->GetObjCMethodDIEOffsets(class_name, method_die_offsets);
-
         DWARFDebugInfo *debug_infop = nullptr;
-
-        const size_t num_matches = method_die_offsets.size();
-        for (size_t i = 0; i < num_matches; ++i) {
-          const DIERef &die_ref = method_die_offsets[i];
+        dwarf->GetObjCMethods(class_name, [&](DIERef die_ref) {
           if (!debug_infop)
             debug_infop = &dwarf->DebugInfo();
           DWARFDIE method_die = debug_infop->GetDIE(die_ref);
 
           if (method_die)
             method_die.ResolveType();
-        }
+          return false;
+        });
 
         for (DelayedPropertyList::iterator pi = delayed_properties.begin(),
                                            pe = delayed_properties.end();
              pi != pe; ++pi)
           pi->Finalize();
       }
     }
 

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

public:
   DWARFIndex(Module &module) : m_module(module) {}
   virtual ~DWARFIndex();
 
   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, DIEArray &offsets) = 0;
+  virtual bool GetGlobalVariables(ConstString basename,
+                                  std::function<bool(DIERef ref)> callback) = 0;
 
-  virtual void GetGlobalVariables(const RegularExpression &regex,
-                                  DIEArray &offsets) = 0;
-  virtual void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) = 0;
-  virtual void GetObjCMethods(ConstString class_name, DIEArray &offsets) = 0;
-  virtual void GetCompleteObjCClass(ConstString class_name,
-                                    bool must_be_implementation,
-                                    DIEArray &offsets) = 0;
-  virtual void GetTypes(ConstString name, DIEArray &offsets) = 0;
-  virtual void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) = 0;
-  virtual void GetNamespaces(ConstString name, DIEArray &offsets) = 0;
-  virtual void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
+  virtual bool GetGlobalVariables(const RegularExpression &regex,
+                                  std::function<bool(DIERef ref)> callback) = 0;
+  virtual bool GetGlobalVariables(const DWARFUnit &cu,
+                                  std::function<bool(DIERef ref)> callback) = 0;
+  virtual bool GetObjCMethods(ConstString class_name,
+                              std::function<bool(DIERef ref)> callback) = 0;
+  virtual bool
+  GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
+                       std::function<bool(DIERef ref)> callback) = 0;
+  virtual bool GetTypes(ConstString name,
+                        std::function<bool(DIERef ref)> callback) = 0;
+  virtual bool GetTypes(const DWARFDeclContext &context,
+                        std::function<bool(DIERef ref)> callback) = 0;
+  virtual bool GetNamespaces(ConstString name,
+                             std::function<bool(DIERef ref)> callback) = 0;
+  virtual bool GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                             const CompilerDeclContext &parent_decl_ctx,
                             uint32_t name_type_mask,
-                            std::vector<DWARFDIE> &dies) = 0;
-  virtual void GetFunctions(const RegularExpression &regex,
-                            DIEArray &offsets) = 0;
+                            std::function<bool(DWARFDIE die)> callback) = 0;
+  virtual bool GetFunctions(const RegularExpression &regex,
+                            std::function<bool(DIERef ref)> 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.
-  void ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
+  bool ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
                           SymbolFileDWARF &dwarf,
                           const CompilerDeclContext &parent_decl_ctx,
-                          uint32_t name_type_mask, std::vector<DWARFDIE> &dies);
+                          uint32_t name_type_mask,
+                          std::function<bool(DWARFDIE die)> callback);
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H

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

 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 DWARFIndex::~DWARFIndex() = default;
 
-void DWARFIndex::ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
-                                    SymbolFileDWARF &dwarf,
-                                    const CompilerDeclContext &parent_decl_ctx,
-                                    uint32_t name_type_mask,
-                                    std::vector<DWARFDIE> &dies) {
+bool DWARFIndex::ProcessFunctionDIE(
+    llvm::StringRef name, DIERef ref, SymbolFileDWARF &dwarf,
+    const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
+    std::function<bool(DWARFDIE die)> callback) {
   DWARFDIE die = dwarf.GetDIE(ref);
   if (!die) {
     ReportInvalidDIERef(ref, name);
-    return;
+    return false;
   }
 
   // Exit early if we're searching exclusively for methods or selectors and
   // we have a context specified (no methods in namespaces).
   uint32_t looking_for_nonmethods =
       name_type_mask & ~(eFunctionNameTypeMethod | eFunctionNameTypeSelector);
   if (!looking_for_nonmethods && parent_decl_ctx.IsValid())
-    return;
+    return false;
 
   // Otherwise, we need to also check that the context matches. If it does not
   // match, we do nothing.
   if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-    return;
+    return false;
 
   // In case of a full match, we just insert everything we find.
-  if (name_type_mask & eFunctionNameTypeFull) {
-    dies.push_back(die);
-    return;
-  }
+  if (name_type_mask & eFunctionNameTypeFull)
+    return callback(die);
 
   // If looking for ObjC selectors, we need to also check if the name is a
   // possible selector.
   if (name_type_mask & eFunctionNameTypeSelector &&
-      ObjCLanguage::IsPossibleObjCMethodName(die.GetName())) {
-    dies.push_back(die);
-    return;
-  }
+      ObjCLanguage::IsPossibleObjCMethodName(die.GetName()))
+    return callback(die);
 
   bool looking_for_methods = name_type_mask & lldb::eFunctionNameTypeMethod;
   bool looking_for_functions = name_type_mask & lldb::eFunctionNameTypeBase;
   if (looking_for_methods || looking_for_functions) {
     // If we're looking for either methods or functions, we definitely want this
     // die. Otherwise, only keep it if the die type matches what we are
     // searching for.
     if ((looking_for_methods && looking_for_functions) ||
         looking_for_methods == die.IsMethod())
-      dies.push_back(die);
+      return callback(die);
   }
+
+  return false;
 }

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

 class DebugNamesDWARFIndex : public DWARFIndex {
 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, DIEArray &offsets) override;
-  void GetGlobalVariables(const RegularExpression &regex,
-                          DIEArray &offsets) override;
-  void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) override;
-  void GetObjCMethods(ConstString class_name, DIEArray &offsets) override {}
-  void GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                            DIEArray &offsets) override;
-  void GetTypes(ConstString name, DIEArray &offsets) override;
-  void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) override;
-  void GetNamespaces(ConstString name, DIEArray &offsets) override;
-  void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
+  bool GetGlobalVariables(ConstString basename,
+                          std::function<bool(DIERef ref)> callback) override;
+  bool GetGlobalVariables(const RegularExpression &regex,
+                          std::function<bool(DIERef ref)> callback) override;
+  bool GetGlobalVariables(const DWARFUnit &cu,
+                          std::function<bool(DIERef ref)> callback) override;
+  bool GetObjCMethods(ConstString class_name,
+                      std::function<bool(DIERef ref)> callback) override {
+    return false;
+  }
+  bool GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
+                            std::function<bool(DIERef ref)> callback) override;
+  bool GetTypes(ConstString name,
+                std::function<bool(DIERef ref)> callback) override;
+  bool GetTypes(const DWARFDeclContext &context,
+                std::function<bool(DIERef ref)> callback) override;
+  bool GetNamespaces(ConstString name,
+                     std::function<bool(DIERef ref)> callback) override;
+  bool GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
-                    std::vector<DWARFDIE> &dies) override;
-  void GetFunctions(const RegularExpression &regex,
-                    DIEArray &offsets) override;
+                    std::function<bool(DWARFDIE die)> callback) override;
+  bool GetFunctions(const RegularExpression &regex,
+                    std::function<bool(DIERef ref)> 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,
private:
   DWARFDataExtractor m_debug_names_data;
   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);
-  void Append(const DebugNames::Entry &entry, DIEArray &offsets);
+  bool Append(const DebugNames::Entry &entry,
+              std::function<bool(DIERef ref)> callback);
 
   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::ToDIERef(const DebugNames::Entry &entry) {
   cu = &cu->GetNonSkeletonUnit();
   if (llvm::Optional<uint64_t> die_offset = entry.getDIEUnitOffset())
     return DIERef(cu->GetSymbolFileDWARF().GetDwoNum(),
                   DIERef::Section::DebugInfo, cu->GetOffset() + *die_offset);
 
   return llvm::None;
 }
 
-void DebugNamesDWARFIndex::Append(const DebugNames::Entry &entry,
-                                  DIEArray &offsets) {
+bool DebugNamesDWARFIndex::Append(const DebugNames::Entry &entry,
+                                  std::function<bool(DIERef ref)> callback) {
   if (llvm::Optional<DIERef> ref = ToDIERef(entry))
-    offsets.push_back(*ref);
+    return callback(*ref);
+  return false;
 }
 
 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,
-                                              DIEArray &offsets) {
-  m_fallback.GetGlobalVariables(basename, offsets);
+bool DebugNamesDWARFIndex::GetGlobalVariables(
+    ConstString basename, std::function<bool(DIERef ref)> callback) {
+  if (m_fallback.GetGlobalVariables(basename, callback))
+    return true;
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(basename.GetStringRef())) {
     if (entry.tag() != DW_TAG_variable)
       continue;
 
-    Append(entry, offsets);
+    if (Append(entry, callback))
+      return true;
   }
+  return false;
 }
 
-void DebugNamesDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
-                                              DIEArray &offsets) {
-  m_fallback.GetGlobalVariables(regex, offsets);
+bool DebugNamesDWARFIndex::GetGlobalVariables(
+    const RegularExpression &regex, std::function<bool(DIERef ref)> callback) {
+  if (m_fallback.GetGlobalVariables(regex, callback))
+    return true;
 
   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;
 
-        Append(*entry_or, offsets);
+        if (Append(*entry_or, callback))
+          return true;
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
+
+  return false;
 }
 
-void DebugNamesDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
-                                              DIEArray &offsets) {
-  m_fallback.GetGlobalVariables(cu, offsets);
+bool DebugNamesDWARFIndex::GetGlobalVariables(
+    const DWARFUnit &cu, std::function<bool(DIERef ref)> callback) {
+  if (m_fallback.GetGlobalVariables(cu, callback))
+    return true;
 
   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;
 
-        Append(*entry_or, offsets);
+        if (Append(*entry_or, callback))
+          return true;
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
+
+  return false;
 }
 
-void DebugNamesDWARFIndex::GetCompleteObjCClass(ConstString class_name,
-                                                bool must_be_implementation,
-                                                DIEArray &offsets) {
-  m_fallback.GetCompleteObjCClass(class_name, must_be_implementation, offsets);
+bool DebugNamesDWARFIndex::GetCompleteObjCClass(
+    ConstString class_name, bool must_be_implementation,
+    std::function<bool(DIERef ref)> callback) {
+  if (m_fallback.GetCompleteObjCClass(class_name, must_be_implementation,
+                                      callback))
+    return true;
 
   // 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 &&
for (const DebugNames::Entry &entry :
 
     // FIXME: We should return DWARFDIEs so we don't have to resolve it twice.
     DWARFDIE die = m_debug_info.GetDIE(*ref);
     if (!die)
       continue;
 
     if (die.GetAttributeValueAsUnsigned(DW_AT_APPLE_objc_complete_type, 0)) {
       // If we find the complete version we're done.
-      offsets.push_back(*ref);
-      return;
+      return callback(*ref);
     }
     incomplete_types.push_back(*ref);
   }
 
-  offsets.insert(offsets.end(), incomplete_types.begin(),
-                 incomplete_types.end());
+  for (DIERef ref : incomplete_types)
+    if (callback(ref))
+      return true;
+  return false;
 }
 
-void DebugNamesDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
-  m_fallback.GetTypes(name, offsets);
+bool DebugNamesDWARFIndex::GetTypes(ConstString name,
+                                    std::function<bool(DIERef ref)> callback) {
+  if (m_fallback.GetTypes(name, callback))
+    return true;
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
-    if (isType(entry.tag()))
-      Append(entry, offsets);
+    if (isType(entry.tag())) {
+      if (Append(entry, callback))
+        return true;
     }
   }
 
-void DebugNamesDWARFIndex::GetTypes(const DWARFDeclContext &context,
-                                    DIEArray &offsets) {
-  m_fallback.GetTypes(context, offsets);
+  return false;
+}
+
+bool DebugNamesDWARFIndex::GetTypes(const DWARFDeclContext &context,
+                                    std::function<bool(DIERef ref)> callback) {
+  if (m_fallback.GetTypes(context, callback))
+    return true;
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(context[0].name)) {
-    if (entry.tag() == context[0].tag)
-      Append(entry, offsets);
+    if (entry.tag() == context[0].tag) {
+      if (Append(entry, callback))
+        return true;
     }
   }
 
-void DebugNamesDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
-  m_fallback.GetNamespaces(name, offsets);
+  return false;
+}
+
+bool DebugNamesDWARFIndex::GetNamespaces(
+    ConstString name, std::function<bool(DIERef ref)> callback) {
+  if (m_fallback.GetNamespaces(name, callback))
+    return true;
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
-    if (entry.tag() == DW_TAG_namespace)
-      Append(entry, offsets);
+    if (entry.tag() == DW_TAG_namespace) {
+      if (Append(entry, callback))
+        return true;
     }
   }
 
-void DebugNamesDWARFIndex::GetFunctions(
+  return false;
+}
+
+bool DebugNamesDWARFIndex::GetFunctions(
     ConstString name, SymbolFileDWARF &dwarf,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
-    std::vector<DWARFDIE> &dies) {
+    std::function<bool(DWARFDIE die)> callback) {
 
-  std::vector<DWARFDIE> v;
-  m_fallback.GetFunctions(name, dwarf, parent_decl_ctx, name_type_mask, v);
+  if (m_fallback.GetFunctions(name, dwarf, parent_decl_ctx, name_type_mask,
+                              callback))
+    return true;
 
+  std::set<DWARFDebugInfoEntry *> seen;
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     Tag tag = entry.tag();
     if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine)
       continue;
 
-    if (llvm::Optional<DIERef> ref = ToDIERef(entry))
-      ProcessFunctionDIE(name.GetStringRef(), *ref, dwarf, parent_decl_ctx,
-                         name_type_mask, v);
-  }
-
-  std::set<DWARFDebugInfoEntry *> seen;
-  for (DWARFDIE die : v)
-    if (seen.insert(die.GetDIE()).second)
-      dies.push_back(die);
+    if (llvm::Optional<DIERef> ref = ToDIERef(entry)) {
+      if (ProcessFunctionDIE(name.GetStringRef(), *ref, dwarf, parent_decl_ctx,
+                             name_type_mask, [&](DWARFDIE die) {
+                               if (!seen.insert(die.GetDIE()).second)
+                                 return false;
+                               return callback(die);
+                             }))
+        return true;
+    }
   }
-
-void DebugNamesDWARFIndex::GetFunctions(const RegularExpression &regex,
-                                        DIEArray &offsets) {
-  m_fallback.GetFunctions(regex, offsets);
+  return false;
+}
+
+bool DebugNamesDWARFIndex::GetFunctions(
+    const RegularExpression &regex, std::function<bool(DIERef ref)> callback) {
+  if (m_fallback.GetFunctions(regex, callback))
+    return true;
 
   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;
 
-        Append(*entry_or, offsets);
+        if (Append(*entry_or, callback))
+          return true;
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
+
+  return false;
 }
 
 void DebugNamesDWARFIndex::Dump(Stream &s) {
   m_fallback.Dump(s);
 
   std::string data;
   llvm::raw_string_ostream os(data);
   m_debug_names_up->dump(os);
   s.PutCString(os.str());
 }

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

MemoryTable(lldb_private::DWARFDataExtractor &table_data,
                 const lldb_private::DWARFDataExtractor &string_table,
                 const char *name);
 
     const char *GetStringForKeyType(KeyType key) const override;
 
     bool ReadHashData(uint32_t hash_data_offset,
                       HashData &hash_data) const override;
 
-    size_t
+    void
     AppendAllDIEsThatMatchingRegex(const lldb_private::RegularExpression &regex,
                                    DIEInfoArray &die_info_array) const;
 
-    size_t AppendAllDIEsInRange(const uint32_t die_offset_start,
-                                const uint32_t die_offset_end,
-                                DIEInfoArray &die_info_array) const;
+    void AppendAllDIEsInRange(const uint32_t die_offset_start,
 
-    size_t FindByName(llvm::StringRef name, DIEArray &die_offsets);
+    bool FindByName(llvm::StringRef name,
+                    std::function<bool(DIERef ref)> callback);
 
-    size_t FindByNameAndTag(llvm::StringRef name, const dw_tag_t tag,
-                            DIEArray &die_offsets);
+    bool FindByNameAndTag(llvm::StringRef name, const dw_tag_t tag,
+                          std::function<bool(DIERef ref)> callback);
 
-    size_t FindByNameAndTagAndQualifiedNameHash(
+    bool FindByNameAndTagAndQualifiedNameHash(
         llvm::StringRef name, const dw_tag_t tag,
-        const uint32_t qualified_name_hash, DIEArray &die_offsets);
+        const uint32_t qualified_name_hash,
+        std::function<bool(DIERef ref)> callback);
 
-    size_t FindCompleteObjCClassByName(llvm::StringRef name,
-                                       DIEArray &die_offsets,
-                                       bool must_be_implementation);
+    bool FindCompleteObjCClassByName(llvm::StringRef name,
+                                     std::function<bool(DIERef ref)> callback,
 
   protected:
     Result AppendHashDataForRegularExpression(
         const lldb_private::RegularExpression &regex,
         lldb::offset_t *hash_data_offset_ptr, Pair &pair) const;
 
-    size_t FindByName(llvm::StringRef name, DIEInfoArray &die_info_array);
+    void FindByName(llvm::StringRef name, DIEInfoArray &die_info_array);
 
     Result GetHashDataForName(llvm::StringRef name,
                               lldb::offset_t *hash_data_offset_ptr,
                               Pair &pair) const override;
 
     lldb_private::DWARFDataExtractor m_data;
     lldb_private::DWARFDataExtractor m_string_table;
     std::string m_name;
   };
 
-  static void ExtractDIEArray(const DIEInfoArray &die_info_array,
-                              DIEArray &die_offsets);
+  static bool ExtractDIEArray(const DIEInfoArray &die_info_array,
+                              std::function<bool(DIERef ref)> callback);
 
 protected:
-  static void ExtractDIEArray(const DIEInfoArray &die_info_array,
-                              const dw_tag_t tag, DIEArray &die_offsets);
+  static bool ExtractDIEArray(const DIEInfoArray &die_info_array,
+                              const dw_tag_t tag,
+                              std::function<bool(DIERef ref)> callback);
 
-  static void ExtractDIEArray(const DIEInfoArray &die_info_array,
+  static bool ExtractDIEArray(const DIEInfoArray &die_info_array,
                               const dw_tag_t tag,
                               const uint32_t qualified_name_hash,
-                              DIEArray &die_offsets);
+                              std::function<bool(DIERef ref)> callback);
 
-  static void
+  static bool
   ExtractClassOrStructDIEArray(const DIEInfoArray &die_info_array,
                                bool return_implementation_only_if_available,
-                               DIEArray &die_offsets);
+                               std::function<bool(DIERef ref)> callback);
 
-  static void ExtractTypesFromDIEArray(const DIEInfoArray &die_info_array,
-                                       uint32_t type_flag_mask,
-                                       uint32_t type_flag_value,
-                                       DIEArray &die_offsets);
+  static bool
+  ExtractTypesFromDIEArray(const DIEInfoArray &die_info_array,
+                           uint32_t type_flag_mask, uint32_t type_flag_value,
+                           std::function<bool(DIERef ref)> callback);
 
   static const char *GetAtomTypeName(uint16_t atom);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_HASHEDNAMETODIE_H

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

 //===-- HashedNameToDIE.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 "HashedNameToDIE.h"
 #include "llvm/ADT/StringRef.h"
 
-void DWARFMappedHash::ExtractDIEArray(const DIEInfoArray &die_info_array,
-                                      DIEArray &die_offsets) {
+bool DWARFMappedHash::ExtractDIEArray(
+    const DIEInfoArray &die_info_array,
+    std::function<bool(DIERef ref)> callback) {
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i)
-    die_offsets.emplace_back(die_info_array[i]);
+    if (callback(DIERef(die_info_array[i])))
+      return true;
+  return false;
 }
 
-void DWARFMappedHash::ExtractDIEArray(const DIEInfoArray &die_info_array,
-                                      const dw_tag_t tag,
-                                      DIEArray &die_offsets) {
-  if (tag == 0) {
-    ExtractDIEArray(die_info_array, die_offsets);
-    return;
-  }
+bool DWARFMappedHash::ExtractDIEArray(
+    const DIEInfoArray &die_info_array, const dw_tag_t tag,
+    std::function<bool(DIERef ref)> callback) {
+  if (tag == 0)
+    return ExtractDIEArray(die_info_array, callback);
 
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i) {
     const dw_tag_t die_tag = die_info_array[i].tag;
     bool tag_matches = die_tag == 0 || tag == die_tag;
     if (!tag_matches) {
       if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
         tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
     }
-    if (tag_matches)
-      die_offsets.emplace_back(die_info_array[i]);
+    if (tag_matches) {
+      if (callback(DIERef(die_info_array[i])))
+        return false;
     }
   }
 
-void DWARFMappedHash::ExtractDIEArray(const DIEInfoArray &die_info_array,
-                                      const dw_tag_t tag,
-                                      const uint32_t qualified_name_hash,
-                                      DIEArray &die_offsets) {
-  if (tag == 0) {
-    ExtractDIEArray(die_info_array, die_offsets);
-    return;
-  }
+  return false;
 
+bool DWARFMappedHash::ExtractDIEArray(
+    const DIEInfoArray &die_info_array, const dw_tag_t tag,
+    const uint32_t qualified_name_hash,
+    std::function<bool(DIERef ref)> callback) {
+  if (tag == 0)
+    return ExtractDIEArray(die_info_array, callback);
+
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i) {
     if (qualified_name_hash != die_info_array[i].qualified_name_hash)
       continue;
     const dw_tag_t die_tag = die_info_array[i].tag;
     bool tag_matches = die_tag == 0 || tag == die_tag;
     if (!tag_matches) {
       if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
         tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
     }
-    if (tag_matches)
-      die_offsets.emplace_back(die_info_array[i]);
+    if (tag_matches) {
+      if (callback(DIERef(die_info_array[i])))
+        return true;
+    }
   }
+
+  return false;
 }
 
-void DWARFMappedHash::ExtractClassOrStructDIEArray(
+bool DWARFMappedHash::ExtractClassOrStructDIEArray(
     const DIEInfoArray &die_info_array,
-    bool return_implementation_only_if_available, DIEArray &die_offsets) {
+    bool return_implementation_only_if_available,
+    std::function<bool(DIERef ref)> callback) {
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i) {
     const dw_tag_t die_tag = die_info_array[i].tag;
     if (die_tag != 0 && die_tag != DW_TAG_class_type &&
         die_tag != DW_TAG_structure_type)
       continue;
-    if (die_info_array[i].type_flags & eTypeFlagClassIsImplementation) {
-      if (return_implementation_only_if_available) {
-        // We found the one true definition for this class, so only return
-        // that
-        die_offsets.clear();
-        die_offsets.emplace_back(die_info_array[i]);
-        return;
-      } else {
-        // Put the one true definition as the first entry so it matches first
-        die_offsets.emplace(die_offsets.begin(), die_info_array[i]);
-      }
-    } else {
-      die_offsets.emplace_back(die_info_array[i]);
+    bool is_implementation =
+        (die_info_array[i].type_flags & eTypeFlagClassIsImplementation) != 0;
+    if (is_implementation != return_implementation_only_if_available)
+      continue;
+      return callback(DIERef(die_info_array[i]));
     }
+    if (callback(DIERef(die_info_array[i])))
+      return true;
   }
+  return false;
 }
 
-void DWARFMappedHash::ExtractTypesFromDIEArray(
+bool DWARFMappedHash::ExtractTypesFromDIEArray(
     const DIEInfoArray &die_info_array, uint32_t type_flag_mask,
-    uint32_t type_flag_value, DIEArray &die_offsets) {
+    uint32_t type_flag_value, std::function<bool(DIERef ref)> callback) {
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i) {
-    if ((die_info_array[i].type_flags & type_flag_mask) == type_flag_value)
-      die_offsets.emplace_back(die_info_array[i]);
+    if ((die_info_array[i].type_flags & type_flag_mask) == type_flag_value) {
+      if (callback(DIERef(die_info_array[i])))
+        return true;
+    }
   }
+  return false;
 }
 
 const char *DWARFMappedHash::GetAtomTypeName(uint16_t atom) {
   switch (atom) {
   case eAtomTypeNULL:
     return "NULL";
   case eAtomTypeDIEOffset:
     return "die-offset";
if (match) {
       return eResultKeyMismatch;
     }
   } else {
     *hash_data_offset_ptr = UINT32_MAX;
     return eResultError;
   }
 }
 
-size_t DWARFMappedHash::MemoryTable::AppendAllDIEsThatMatchingRegex(
+void DWARFMappedHash::MemoryTable::AppendAllDIEsThatMatchingRegex(
     const lldb_private::RegularExpression &regex,
     DIEInfoArray &die_info_array) const {
   const uint32_t hash_count = m_header.hashes_count;
   Pair pair;
   for (uint32_t offset_idx = 0; offset_idx < hash_count; ++offset_idx) {
     lldb::offset_t hash_data_offset = GetHashDataOffset(offset_idx);
     while (hash_data_offset != UINT32_MAX) {
       const lldb::offset_t prev_hash_data_offset = hash_data_offset;
while (hash_data_offset != UINT32_MAX) {
       case eResultEndOfHashData:
       case eResultError:
         hash_data_offset = UINT32_MAX;
         break;
       }
     }
   }
   die_info_array.swap(pair.value);
-  return die_info_array.size();
 }
 
-size_t DWARFMappedHash::MemoryTable::AppendAllDIEsInRange(
+void DWARFMappedHash::MemoryTable::AppendAllDIEsInRange(
     const uint32_t die_offset_start, const uint32_t die_offset_end,
     DIEInfoArray &die_info_array) const {
   const uint32_t hash_count = m_header.hashes_count;
   for (uint32_t offset_idx = 0; offset_idx < hash_count; ++offset_idx) {
     bool done = false;
     lldb::offset_t hash_data_offset = GetHashDataOffset(offset_idx);
     while (!done && hash_data_offset != UINT32_MAX) {
       KeyType key = m_data.GetU32(&hash_data_offset);
while (!done && hash_data_offset != UINT32_MAX) {
             done = true;
           if (die_offset_start <= die_info.die_offset &&
               die_info.die_offset < die_offset_end)
             die_info_array.push_back(die_info);
         }
       }
     }
   }
-  return die_info_array.size();
 }
 
-size_t DWARFMappedHash::MemoryTable::FindByName(llvm::StringRef name,
-                                                DIEArray &die_offsets) {
+bool DWARFMappedHash::MemoryTable::FindByName(
+    llvm::StringRef name, std::function<bool(DIERef ref)> callback) {
   if (name.empty())
-    return 0;
+    return false;
 
   DIEInfoArray die_info_array;
-  if (FindByName(name, die_info_array))
-    DWARFMappedHash::ExtractDIEArray(die_info_array, die_offsets);
-  return die_info_array.size();
+  FindByName(name, die_info_array);
+  return DWARFMappedHash::ExtractDIEArray(die_info_array, callback);
 }
 
-size_t DWARFMappedHash::MemoryTable::FindByNameAndTag(llvm::StringRef name,
-                                                      const dw_tag_t tag,
-                                                      DIEArray &die_offsets) {
+bool DWARFMappedHash::MemoryTable::FindByNameAndTag(
+    llvm::StringRef name, const dw_tag_t tag,
+    std::function<bool(DIERef ref)> callback) {
   DIEInfoArray die_info_array;
-  if (FindByName(name, die_info_array))
-    DWARFMappedHash::ExtractDIEArray(die_info_array, tag, die_offsets);
-  return die_info_array.size();
+  FindByName(name, die_info_array);
+  return DWARFMappedHash::ExtractDIEArray(die_info_array, tag, callback);
 }
 
-size_t DWARFMappedHash::MemoryTable::FindByNameAndTagAndQualifiedNameHash(
+bool DWARFMappedHash::MemoryTable::FindByNameAndTagAndQualifiedNameHash(
     llvm::StringRef name, const dw_tag_t tag,
-    const uint32_t qualified_name_hash, DIEArray &die_offsets) {
+    const uint32_t qualified_name_hash,
+    std::function<bool(DIERef ref)> callback) {
   DIEInfoArray die_info_array;
-  if (FindByName(name, die_info_array))
-    DWARFMappedHash::ExtractDIEArray(die_info_array, tag, qualified_name_hash,
-                                     die_offsets);
-  return die_info_array.size();
+  FindByName(name, die_info_array);
+  return DWARFMappedHash::ExtractDIEArray(die_info_array, tag,
+                                          qualified_name_hash, callback);
 }
 
-size_t DWARFMappedHash::MemoryTable::FindCompleteObjCClassByName(
-    llvm::StringRef name, DIEArray &die_offsets, bool must_be_implementation) {
+bool DWARFMappedHash::MemoryTable::FindCompleteObjCClassByName(
+    llvm::StringRef name, std::function<bool(DIERef ref)> callback,
+    bool must_be_implementation) {
   DIEInfoArray die_info_array;
-  if (!FindByName(name, die_info_array))
-    return 0;
+  FindByName(name, die_info_array);
   if (must_be_implementation &&
       GetHeader().header_data.ContainsAtom(eAtomTypeTypeFlags)) {
     // If we have two atoms, then we have the DIE offset and the type flags
     // so we can find the objective C class efficiently.
-    DWARFMappedHash::ExtractTypesFromDIEArray(die_info_array, UINT32_MAX,
-                                              eTypeFlagClassIsImplementation,
-                                              die_offsets);
-    return die_offsets.size();
+    return DWARFMappedHash::ExtractTypesFromDIEArray(
+        die_info_array, UINT32_MAX, eTypeFlagClassIsImplementation, callback);
   }
   // We don't only want the one true definition, so try and see what we can
   // find, and only return class or struct DIEs. If we do have the full
   // implementation, then return it alone, else return all possible
   // matches.
-  const bool return_implementation_only_if_available = true;
-  DWARFMappedHash::ExtractClassOrStructDIEArray(
-      die_info_array, return_implementation_only_if_available, die_offsets);
-  return die_offsets.size();
+  bool found_implementation = false;
+  if (DWARFMappedHash::ExtractClassOrStructDIEArray(
+          die_info_array, true /*return_implementation_only_if_available*/,
+          [&](DIERef ref) {
+            found_implementation = true;
+            return callback(ref);
+          }))
+    return true;
+  if (found_implementation)
+    return false;
+  return DWARFMappedHash::ExtractClassOrStructDIEArray(
+      die_info_array, false /*return_implementation_only_if_available*/,
+      callback);
 }
 
-size_t DWARFMappedHash::MemoryTable::FindByName(llvm::StringRef name,
-                                                DIEInfoArray &die_info_array) {
+void DWARFMappedHash::MemoryTable::FindByName(llvm::StringRef name,
   if (name.empty())
-    return 0;
+    return;
 
   Pair kv_pair;
-  size_t old_size = die_info_array.size();
-  if (Find(name, kv_pair)) {
+  if (Find(name, kv_pair))
     die_info_array.swap(kv_pair.value);
-    return die_info_array.size() - old_size;
-  }
-  return 0;
 }

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

 public:
   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, DIEArray &offsets) override;
-  void GetGlobalVariables(const RegularExpression &regex,
-                          DIEArray &offsets) override;
-  void GetGlobalVariables(const DWARFUnit &unit, DIEArray &offsets) override;
-  void GetObjCMethods(ConstString class_name, DIEArray &offsets) override;
-  void GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                            DIEArray &offsets) override;
-  void GetTypes(ConstString name, DIEArray &offsets) override;
-  void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) override;
-  void GetNamespaces(ConstString name, DIEArray &offsets) override;
-  void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
+  bool GetGlobalVariables(ConstString basename,
+                          std::function<bool(DIERef ref)> callback) override;
+  bool GetGlobalVariables(const RegularExpression &regex,
+                          std::function<bool(DIERef ref)> callback) override;
+  bool GetGlobalVariables(const DWARFUnit &unit,
+                          std::function<bool(DIERef ref)> callback) override;
+  bool GetObjCMethods(ConstString class_name,
+                      std::function<bool(DIERef ref)> callback) override;
+  bool GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
+                            std::function<bool(DIERef ref)> callback) override;
+  bool GetTypes(ConstString name,
+                std::function<bool(DIERef ref)> callback) override;
+  bool GetTypes(const DWARFDeclContext &context,
+                std::function<bool(DIERef ref)> callback) override;
+  bool GetNamespaces(ConstString name,
+                     std::function<bool(DIERef ref)> callback) override;
+  bool GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
-                    std::vector<DWARFDIE> &dies) override;
-  void GetFunctions(const RegularExpression &regex, DIEArray &offsets) override;
+                    std::function<bool(DWARFDIE die)> callback) override;
+  bool GetFunctions(const RegularExpression &regex,
+                    std::function<bool(DIERef ref)> 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;

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

case DW_TAG_variable:
       break;
 
     default:
       continue;
     }
   }
 }
 
-void ManualDWARFIndex::GetGlobalVariables(ConstString basename, DIEArray &offsets) {
+bool ManualDWARFIndex::GetGlobalVariables(
+    ConstString basename, std::function<bool(DIERef ref)> callback) {
   Index();
-  m_set.globals.Find(basename, offsets);
+  return m_set.globals.Find(basename, callback);
 }
 
-void ManualDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
-                                          DIEArray &offsets) {
+bool ManualDWARFIndex::GetGlobalVariables(
+    const RegularExpression &regex, std::function<bool(DIERef ref)> callback) {
   Index();
-  m_set.globals.Find(regex, offsets);
+  return m_set.globals.Find(regex, callback);
 }
 
-void ManualDWARFIndex::GetGlobalVariables(const DWARFUnit &unit,
-                                          DIEArray &offsets) {
+bool ManualDWARFIndex::GetGlobalVariables(
+    const DWARFUnit &unit, std::function<bool(DIERef ref)> callback) {
   Index();
-  m_set.globals.FindAllEntriesForUnit(unit, offsets);
+  return m_set.globals.FindAllEntriesForUnit(unit, callback);
 }
 
-void ManualDWARFIndex::GetObjCMethods(ConstString class_name,
-                                      DIEArray &offsets) {
+bool ManualDWARFIndex::GetObjCMethods(
+    ConstString class_name, std::function<bool(DIERef ref)> callback) {
   Index();
-  m_set.objc_class_selectors.Find(class_name, offsets);
+  return m_set.objc_class_selectors.Find(class_name, callback);
 }
 
-void ManualDWARFIndex::GetCompleteObjCClass(ConstString class_name,
-                                            bool must_be_implementation,
-                                            DIEArray &offsets) {
+bool ManualDWARFIndex::GetCompleteObjCClass(
+    ConstString class_name, bool must_be_implementation,
+    std::function<bool(DIERef ref)> callback) {
   Index();
-  m_set.types.Find(class_name, offsets);
+  return m_set.types.Find(class_name, callback);
 }
 
-void ManualDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
+bool ManualDWARFIndex::GetTypes(ConstString name,
+                                std::function<bool(DIERef ref)> callback) {
   Index();
-  m_set.types.Find(name, offsets);
+  return m_set.types.Find(name, callback);
 }
 
-void ManualDWARFIndex::GetTypes(const DWARFDeclContext &context,
-                                DIEArray &offsets) {
+bool ManualDWARFIndex::GetTypes(const DWARFDeclContext &context,
+                                std::function<bool(DIERef ref)> callback) {
   Index();
-  m_set.types.Find(ConstString(context[0].name), offsets);
+  return m_set.types.Find(ConstString(context[0].name), callback);
 }
 
-void ManualDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
+bool ManualDWARFIndex::GetNamespaces(ConstString name,
+                                     std::function<bool(DIERef ref)> callback) {
   Index();
-  m_set.namespaces.Find(name, offsets);
+  return m_set.namespaces.Find(name, callback);
 }
 
-void ManualDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
-                                    const CompilerDeclContext &parent_decl_ctx,
-                                    uint32_t name_type_mask,
-                                    std::vector<DWARFDIE> &dies) {
+bool ManualDWARFIndex::GetFunctions(
+    ConstString name, SymbolFileDWARF &dwarf,
+    const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
+    std::function<bool(DWARFDIE die)> callback) {
   Index();
 
   if (name_type_mask & eFunctionNameTypeFull) {
-    DIEArray offsets;
-    m_set.function_fullnames.Find(name, offsets);
-    for (const DIERef &die_ref: offsets) {
+    if (m_set.function_fullnames.Find(name, [&](DIERef die_ref) {
           DWARFDIE die = dwarf.GetDIE(die_ref);
           if (!die)
-        continue;
+            return false;
           if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-        continue;
-      dies.push_back(die);
-    }
+            return false;
+          return callback(die);
+        }))
+      return true;
   }
   if (name_type_mask & eFunctionNameTypeBase) {
-    DIEArray offsets;
-    m_set.function_basenames.Find(name, offsets);
-    for (const DIERef &die_ref: offsets) {
+    if (m_set.function_basenames.Find(name, [&](DIERef die_ref) {
           DWARFDIE die = dwarf.GetDIE(die_ref);
           if (!die)
-        continue;
+            return false;
           if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-        continue;
-      dies.push_back(die);
-    }
+            return false;
+          return callback(die);
+        }))
+      return true;
   }
 
   if (name_type_mask & eFunctionNameTypeMethod && !parent_decl_ctx.IsValid()) {
-    DIEArray offsets;
-    m_set.function_methods.Find(name, offsets);
-    for (const DIERef &die_ref: offsets) {
+    if (m_set.function_methods.Find(name, [&](DIERef die_ref) {
           DWARFDIE die = dwarf.GetDIE(die_ref);
           if (!die)
-        continue;
-      dies.push_back(die);
-    }
+            return false;
+          return callback(die);
+        }))
+      return true;
   }
 
   if (name_type_mask & eFunctionNameTypeSelector &&
       !parent_decl_ctx.IsValid()) {
-    DIEArray offsets;
-    m_set.function_selectors.Find(name, offsets);
-    for (const DIERef &die_ref: offsets) {
+    if (m_set.function_selectors.Find(name, [&](DIERef die_ref) {
           DWARFDIE die = dwarf.GetDIE(die_ref);
           if (!die)
-        continue;
-      dies.push_back(die);
-    }
+            return false;
+          return callback(die);
+        }))
+      return true;
   }
+  return false;
 }
 
-void ManualDWARFIndex::GetFunctions(const RegularExpression &regex,
-                                    DIEArray &offsets) {
+bool ManualDWARFIndex::GetFunctions(const RegularExpression &regex,
+                                    std::function<bool(DIERef ref)> callback) {
   Index();
 
-  m_set.function_basenames.Find(regex, offsets);
-  m_set.function_fullnames.Find(regex, offsets);
+  if (m_set.function_basenames.Find(regex, callback))
+    return true;
+  if (m_set.function_fullnames.Find(regex, callback))
+    return true;
+  return false;
 }
 
 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");
   m_set.function_basenames.Dump(&s);

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

public:
   void Dump(lldb_private::Stream *s);
 
   void Insert(lldb_private::ConstString name, const DIERef &die_ref);
 
   void Append(const NameToDIE &other);
 
   void Finalize();
 
-  size_t Find(lldb_private::ConstString name,
-              DIEArray &info_array) const;
+  bool Find(lldb_private::ConstString name,
+            std::function<bool(DIERef ref)> callback) const;
 
-  size_t Find(const lldb_private::RegularExpression &regex,
-              DIEArray &info_array) const;
+  bool Find(const lldb_private::RegularExpression &regex,
+            std::function<bool(DIERef ref)> callback) const;
 
-  size_t FindAllEntriesForUnit(const DWARFUnit &unit,
-                               DIEArray &info_array) const;
+  bool FindAllEntriesForUnit(const DWARFUnit &unit,
+                             std::function<bool(DIERef ref)> callback) const;
 
   void
   ForEach(std::function<bool(lldb_private::ConstString name,
                              const DIERef &die_ref)> const
               &callback) const;
 
 protected:
   lldb_private::UniqueCStringMap<DIERef> m_map;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_NAMETODIE_H

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

void NameToDIE::Finalize() {
   m_map.Sort();
   m_map.SizeToFit();
 }
 
 void NameToDIE::Insert(ConstString name, const DIERef &die_ref) {
   m_map.Append(name, die_ref);
 }
 
-size_t NameToDIE::Find(ConstString name, DIEArray &info_array) const {
-  return m_map.GetValues(name, info_array);
+bool NameToDIE::Find(ConstString name,
+                     std::function<bool(DIERef ref)> callback) const {
+  return m_map.GetValues(name, callback);
 }
 
-size_t NameToDIE::Find(const RegularExpression &regex,
-                       DIEArray &info_array) const {
-  return m_map.GetValues(regex, info_array);
+bool NameToDIE::Find(const RegularExpression &regex,
+                     std::function<bool(DIERef ref)> callback) const {
+  return m_map.GetValues(regex, callback);
 }
 
-size_t NameToDIE::FindAllEntriesForUnit(const DWARFUnit &unit,
-                                        DIEArray &info_array) const {
-  const size_t initial_size = info_array.size();
+bool NameToDIE::FindAllEntriesForUnit(
+    const DWARFUnit &unit, std::function<bool(DIERef ref)> callback) const {
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
     const DIERef &die_ref = m_map.GetValueAtIndexUnchecked(i);
     if (unit.GetSymbolFileDWARF().GetDwoNum() == die_ref.dwo_num() &&
         unit.GetDebugSection() == die_ref.section() &&
         unit.GetOffset() <= die_ref.die_offset() &&
-        die_ref.die_offset() < unit.GetNextUnitOffset())
-      info_array.push_back(die_ref);
+        die_ref.die_offset() < unit.GetNextUnitOffset()) {
+      if (callback(die_ref))
+        return true;
     }
-  return info_array.size() - initial_size;
+  }
+  return false;
 }
 
 void NameToDIE::Dump(Stream *s) {
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
     s->Format("{0} \"{1}\"\n", m_map.GetValueAtIndexUnchecked(i),
               m_map.GetCStringAtIndexUnchecked(i));
   }

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

public:
   GetDeclContextDIEContainingDIE(const DWARFDIE &die);
 
   bool
   HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type);
 
   lldb_private::CompileUnit *
   GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu);
 
-  virtual size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
-                                         DIEArray &method_die_offsets);
+  virtual bool GetObjCMethods(lldb_private::ConstString class_name,
+                              std::function<bool(DIERef ref)> 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

SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu) {
   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());
 }
 
-size_t SymbolFileDWARF::GetObjCMethodDIEOffsets(ConstString class_name,
-                                                DIEArray &method_die_offsets) {
-  method_die_offsets.clear();
-  m_index->GetObjCMethods(class_name, method_die_offsets);
-  return method_die_offsets.size();
+bool SymbolFileDWARF::GetObjCMethods(ConstString class_name,
+                                     std::function<bool(DIERef ref)> callback) {
+  return 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?
     sc.comp_unit =
void SymbolFileDWARF::FindGlobalVariables(
   llvm::StringRef basename;
   llvm::StringRef context;
   bool name_is_mangled = (bool)Mangled(name);
 
   if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name.GetCString(),
                                                       context, basename))
     basename = name.GetStringRef();
 
-  DIEArray die_offsets;
-  m_index->GetGlobalVariables(ConstString(basename), die_offsets);
-  const size_t num_die_matches = die_offsets.size();
+  // 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) {
+    if (!sc.module_sp)
       sc.module_sp = m_objfile_sp->GetModule();
     assert(sc.module_sp);
 
-  // Loop invariant: Variables up to this index have been checked for context
-  // matches.
-  uint32_t pruned_idx = original_size;
-
-  for (size_t i = 0; i < num_die_matches; ++i) {
-    const DIERef &die_ref = die_offsets[i];
     DWARFDIE die = GetDIE(die_ref);
     if (!die) {
       m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      continue;
+      return false;
     }
 
     switch (die.Tag()) {
     default:
     case DW_TAG_subprogram:
     case DW_TAG_inlined_subroutine:
     case DW_TAG_try_block:
     case DW_TAG_catch_block:
-      continue;
+      return false;
 
     case DW_TAG_variable:
       break;
     }
     auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
     if (!dwarf_cu)
-      continue;
+      return false;
     sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
     if (parent_decl_ctx) {
       if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
         CompilerDeclContext actual_parent_decl_ctx =
             dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
         if (!actual_parent_decl_ctx ||
             actual_parent_decl_ctx != parent_decl_ctx)
-          continue;
+          return false;
       }
     }
 
     ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
     while (pruned_idx < variables.GetSize()) {
       VariableSP var_sp = variables.GetVariableAtIndex(pruned_idx);
       if (name_is_mangled ||
           var_sp->GetName().GetStringRef().contains(name.GetStringRef()))
         ++pruned_idx;
       else
         variables.RemoveVariableAtIndex(pruned_idx);
     }
 
-    if (variables.GetSize() - original_size >= max_matches)
-      break;
-  }
+    return variables.GetSize() - original_size >= max_matches;
+  });
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = variables.GetSize() - original_size;
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
         "parent_decl_ctx=%p, max_matches=%u, variables) => %u",
GetObjectFile()->GetModule()->LogMessage(
         "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", "
         "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();
 
-  DIEArray die_offsets;
-  m_index->GetGlobalVariables(regex, die_offsets);
-
   SymbolContext sc;
+  m_index->GetGlobalVariables(regex, [&](DIERef die_ref) {
+    if (!sc.module_sp)
       sc.module_sp = m_objfile_sp->GetModule();
     assert(sc.module_sp);
 
-  const size_t num_matches = die_offsets.size();
-  for (size_t i = 0; i < num_matches; ++i) {
-    const DIERef &die_ref = die_offsets[i];
     DWARFDIE die = GetDIE(die_ref);
     if (!die) {
       m_index->ReportInvalidDIERef(die_ref, regex.GetText());
-      continue;
+      return false;
     }
 
     DWARFCompileUnit *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
     if (!dwarf_cu)
-      continue;
+      return false;
     sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
     ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
 
-    if (variables.GetSize() - original_size >= max_matches)
-      break;
-  }
+    return variables.GetSize() - original_size >= max_matches;
+  });
 }
 
 bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
                                       bool include_inlines,
                                       SymbolContextList &sc_list) {
   SymbolContext sc;
 
   if (!orig_die)
void SymbolFileDWARF::FindFunctions(ConstString name,
 
   // Remember how many sc_list are in the list before we search in case we are
   // appending the results to a variable list.
 
   const uint32_t original_size = sc_list.GetSize();
 
   llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
 
-  std::vector<DWARFDIE> dies;
-  m_index->GetFunctions(name, *this, parent_decl_ctx, name_type_mask, dies);
-  for (const DWARFDIE &die : dies) {
+  m_index->GetFunctions(name, *this, parent_decl_ctx, name_type_mask,
+                        [&](DWARFDIE die) {
                           if (resolved_dies.insert(die.GetDIE()).second)
                             ResolveFunction(die, include_inlines, sc_list);
-  }
+                          return false;
+                        });
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = sc_list.GetSize() - original_size;
 
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindFunctions (name=\"%s\", "
void SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log, "SymbolFileDWARF::FindFunctions (regex=\"%s\", sc_list)",
         regex.GetText().str().c_str());
   }
 
   DWARFDebugInfo &info = DebugInfo();
-  DIEArray offsets;
-  m_index->GetFunctions(regex, offsets);
-
   llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
-  for (DIERef ref : offsets) {
+  m_index->GetFunctions(regex, [&](DIERef ref) {
     DWARFDIE die = info.GetDIE(ref);
     if (!die) {
       m_index->ReportInvalidDIERef(ref, regex.GetText());
-      continue;
+      return false;
     }
     if (resolved_dies.insert(die.GetDIE()).second)
       ResolveFunction(die, include_inlines, sc_list);
-  }
+    return false;
+  });
 }
 
 void SymbolFileDWARF::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
     std::vector<ConstString> &mangled_names) {
   DWARFDebugInfo &info = DebugInfo();
   uint32_t num_comp_units = info.GetNumUnits();
   for (uint32_t i = 0; i < num_comp_units; i++) {
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;
 
-  DIEArray die_offsets;
-  m_index->GetTypes(name, die_offsets);
-  const size_t num_die_matches = die_offsets.size();
-
-  for (size_t i = 0; i < num_die_matches; ++i) {
-    const DIERef &die_ref = die_offsets[i];
+  m_index->GetTypes(name, [&](DIERef die_ref) {
     DWARFDIE die = GetDIE(die_ref);
     if (!die) {
       m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      continue;
+      return false;
     }
 
     if (!DIEInDeclContext(parent_decl_ctx, die))
-      continue; // The containing decl contexts don't match
+      return false; // The containing decl contexts don't match
 
     Type *matching_type = ResolveType(die, true, true);
     if (!matching_type)
-      continue;
+      return false;
 
     // We found a type pointer, now find the shared pointer form our type
     // list
     types.InsertUnique(matching_type->shared_from_this());
-    if (types.GetSize() >= max_matches)
-      break;
-  }
+    return types.GetSize() >= max_matches;
+  });
 
   // Next search through the reachable Clang modules. This only applies for
   // DWARF objects compiled with -gmodules that haven't been processed by
   // dsymutil.
-  if (num_die_matches < max_matches) {
+  if (types.GetSize() < max_matches) {
     UpdateExternalModuleListIfNeeded();
 
     for (const auto &pair : m_external_type_modules)
       if (ModuleSP external_module_sp = pair.second) 
         if (SymbolFile *sym_file = external_module_sp->GetSymbolFile())
           sym_file->FindTypes(name, parent_decl_ctx, max_matches,
                               searched_symbol_files, types);
   }
void SymbolFileDWARF::FindTypes(
   if (pattern.empty())
     return;
 
   ConstString name = pattern.back().name;
 
   if (!name)
     return;
 
-  DIEArray die_offsets;
-  m_index->GetTypes(name, die_offsets);
-  const size_t num_die_matches = die_offsets.size();
-
-  for (size_t i = 0; i < num_die_matches; ++i) {
-    const DIERef &die_ref = die_offsets[i];
+  m_index->GetTypes(name, [&](DIERef die_ref) {
     DWARFDIE die = GetDIE(die_ref);
     if (!die) {
       m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      continue;
+      return false;
     }
 
     if (!languages[GetLanguage(*die.GetCU())])
-      continue;
+      return false;
 
     llvm::SmallVector<CompilerContext, 4> die_context;
     die.GetDeclContext(die_context);
     if (!contextMatches(die_context, pattern))
-      continue;
+      return false;
 
     if (Type *matching_type = ResolveType(die, true, true)) {
       // We found a type pointer, now find the shared pointer form our type
       // list.
       types.InsertUnique(matching_type->shared_from_this());
     }
-  }
+    return false;
+  });
 
   // Next search through the reachable Clang modules. This only applies for
   // DWARF objects compiled with -gmodules that haven't been processed by
   // dsymutil.
   UpdateExternalModuleListIfNeeded();
 
   for (const auto &pair : m_external_type_modules)
     if (ModuleSP external_module_sp = pair.second)
GetObjectFile()->GetModule()->LogMessage(
         name.GetCString());
   }
 
   CompilerDeclContext namespace_decl_ctx;
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return namespace_decl_ctx;
 
-  DIEArray die_offsets;
-  m_index->GetNamespaces(name, die_offsets);
-  const size_t num_matches = die_offsets.size();
-  for (size_t i = 0; i < num_matches; ++i) {
-    const DIERef &die_ref = die_offsets[i];
+  m_index->GetNamespaces(name, [&](DIERef die_ref) {
     DWARFDIE die = GetDIE(die_ref);
     if (!die) {
       m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      continue;
+      return false;
     }
 
     if (!DIEInDeclContext(parent_decl_ctx, die))
-      continue; // The containing decl contexts don't match
+      return false; // The containing decl contexts don't match
 
     DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
     if (!dwarf_ast)
-      continue;
+      return false;
 
     namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
-    if (namespace_decl_ctx)
-      break;
-  }
+    return namespace_decl_ctx.IsValid();
+  });
+
   if (log && namespace_decl_ctx) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
         "CompilerDeclContext(%p/%p) \"%s\"",
         name.GetCString(),
         static_cast<const void *>(namespace_decl_ctx.GetTypeSystem()),
         static_cast<const void *>(namespace_decl_ctx.GetOpaqueDeclContext()),

 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;
 
-  DIEArray die_offsets;
-  m_index->GetCompleteObjCClass(type_name, must_be_implementation, die_offsets);
-
-  const size_t num_matches = die_offsets.size();
-
-  for (size_t i = 0; i < num_matches; ++i) {
-    const DIERef &die_ref = die_offsets[i];
+  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());
-      continue;
+          return false;
         }
 
         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:
             try_resolving_type = true;
             break;
           default:
             break;
           }
         }
         if (!try_resolving_type)
-      continue;
+          return false;
 
         if (must_be_implementation &&
             type_die.Supports_DW_AT_APPLE_objc_complete_type())
           try_resolving_type = type_die.GetAttributeValueAsUnsigned(
               DW_AT_APPLE_objc_complete_type, 0);
         if (!try_resolving_type)
-      continue;
+          return false;
 
         Type *resolved_type = ResolveType(type_die, false, true);
         if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
-      continue;
+          return false;
 
         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;
         type_sp = resolved_type->shared_from_this();
-    break;
-  }
+        return true;
+      });
   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
 // declaration of a type (the equivalent of "struct my_struct;". There will
 // often be a declaration of that type elsewhere that has the full definition.
 // When we go looking for the full type "my_struct", we will find one or more
if (type_name) {
         GetObjectFile()->GetModule()->LogMessage(
             log,
             "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%"
             "s, qualified-name='%s')",
             DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
             dwarf_decl_ctx.GetQualifiedName());
       }
 
-      DIEArray die_offsets;
-      m_index->GetTypes(dwarf_decl_ctx, die_offsets);
-      const size_t num_matches = die_offsets.size();
-
       // Get the type system that we are looking to find a type for. We will
       // use this to ensure any matches we find are in a language that this
       // type system supports
       const LanguageType language = dwarf_decl_ctx.GetLanguage();
       TypeSystem *type_system = nullptr;
       if (language != eLanguageTypeUnknown) {
         auto type_system_or_err = GetTypeSystemForLanguage(language);
         if (auto err = type_system_or_err.takeError()) {
           LLDB_LOG_ERROR(
               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();
         }
       }
-      for (size_t i = 0; i < num_matches; ++i) {
-        const DIERef &die_ref = die_offsets[i];
+
+      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());
-          continue;
+          return false;
         }
 
         // 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())))
-          continue;
+          return false;
         bool try_resolving_type = false;
 
         // Don't try and resolve the DIE we are looking for with the DIE
         // itself!
         const dw_tag_t type_tag = type_die.Tag();
         // Make sure the tags match
         if (type_tag == tag) {
           // The tags match, lets try resolving this type
if (type_name) {
             // Tags don't match, don't event try to resolve using this type
             // whose name matches....
             break;
           }
         }
 
         if (!try_resolving_type) {
           if (!log)
-            continue;
+            return false;
           std::string qualified_name;
           type_die.GetQualifiedName(qualified_name);
           GetObjectFile()->GetModule()->LogMessage(
               log,
               "SymbolFileDWARF::"
               "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
               "qualified-name='%s') ignoring die=0x%8.8x (%s)",
               DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
               dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
               qualified_name.c_str());
-          continue;
+          return false;
         }
 
         DWARFDeclContext type_dwarf_decl_ctx = GetDWARFDeclContext(type_die);
 
         if (log) {
           GetObjectFile()->GetModule()->LogMessage(
               log,
               "SymbolFileDWARF::"
               "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
               "qualified-name='%s') trying die=0x%8.8x (%s)",
               DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
               dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
               type_dwarf_decl_ctx.GetQualifiedName());
         }
 
         // Make sure the decl contexts match all the way up
         if (dwarf_decl_ctx != type_dwarf_decl_ctx)
-          continue;
+          return false;
 
         Type *resolved_type = ResolveType(type_die, false);
         if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
-          continue;
+          return false;
 
         type_sp = resolved_type->shared_from_this();
-        break;
-      }
+        return true;
+      });
     }
   }
   return type_sp;
 }
 
 TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
                                   bool *type_is_new_ptr) {
   if (!die)
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);
 
-        DIEArray die_offsets;
-        m_index->GetGlobalVariables(dwarf_cu->GetNonSkeletonUnit(),
-                                    die_offsets);
-        const size_t num_matches = die_offsets.size();
-        for (size_t i = 0; i < num_matches; ++i) {
-          const DIERef &die_ref = die_offsets[i];
+        m_index->GetGlobalVariables(
+            dwarf_cu->GetNonSkeletonUnit(), [&](DIERef die_ref) {
               DWARFDIE die = GetDIE(die_ref);
               if (!die) {
                 m_index->ReportInvalidDIERef(die_ref, "");
-            continue;
+                return false;
               }
-
-          VariableSP var_sp(ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
+              VariableSP var_sp(
+                  ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
               if (var_sp) {
                 variables->AddVariableIfUnique(var_sp);
                 ++vars_added;
               }
-        }
+              return false;
+            });
       }
       return vars_added;
     }
   }
   return 0;
 }
 
 VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,

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);
 
-  size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
-                                 DIEArray &method_die_offsets) override;
+  bool GetObjCMethods(lldb_private::ConstString class_name,
+                      std::function<bool(DIERef ref)> 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

SymbolFileDWARFDwo::GetForwardDeclDieToClangType() {
   return GetBaseSymbolFile().GetForwardDeclDieToClangType();
 }
 
 SymbolFileDWARF::ClangTypeToDIE &
 SymbolFileDWARFDwo::GetForwardDeclClangTypeToDie() {
   return GetBaseSymbolFile().GetForwardDeclClangTypeToDie();
 }
 
-size_t SymbolFileDWARFDwo::GetObjCMethodDIEOffsets(
-    lldb_private::ConstString class_name, DIEArray &method_die_offsets) {
-  return GetBaseSymbolFile().GetObjCMethodDIEOffsets(class_name,
-                                                     method_die_offsets);
+bool SymbolFileDWARFDwo::GetObjCMethods(
+    lldb_private::ConstString class_name,
+    std::function<bool(DIERef ref)> callback) {
+  return GetBaseSymbolFile().GetObjCMethods(class_name, callback);
 }
 
 UniqueDWARFASTTypeMap &SymbolFileDWARFDwo::GetUniqueDWARFASTTypeMap() {
   return GetBaseSymbolFile().GetUniqueDWARFASTTypeMap();
 }
 
 lldb::TypeSP SymbolFileDWARFDwo::FindDefinitionTypeForDWARFDeclContext(
     const DWARFDeclContext &die_decl_ctx) {