DWARFIndex: Reduce duplication in the GetFunctions methods

[labath]

Summary

This extracts the common bits out of the two implementations back into
the SymbolFileDWARF class. The goal was to make the function as similar
as possible to the other DWARFIndex methods (i.e, to restrict the work
of the index classes to DIE offset manipulation only, and leave the
offset interpretation to the caller).

To achieve this, i've split the function into three functions, for
looking up:

• full names
• objc methods
• methods and functions

The first two are trivial, and they just extract DIE offsets into an
array. The last one needed a slightly more complex interface, because of
the differences in how the two indexes operate -- manual index is able
to differentiate between methods and non-methods, while the apple table
is not. For this reason, the function returns three offset arrays
instead of just one. The first two are for DIEs which we know are/are
not methods, and the third one is for those we are unsure. In this case,
the caller needs to do extra work to tell them apart.

[clayborg]

Before I look too closely, we can probably add a DWARFDIE accessor function like:

bool DWARFDIE::IsClassMethod() const;

Then this would allow each DWARFIndex to just check and we might be able to get rid of the 3 lists in GetFunctionsByBaseOrMethodName? Seems like it shouldn't be hard for the index to weed these things out. Or we can add a generic layer into the DWARFIndex base class that the different indexes can call to weed out the things that aren't wanted. The earlier we can weed things out the better. so the index might return 20 matches, but it would be nice to weed out any mismatches as soon as possible so we can avoid creating any clang AST types for the functions/methods if we don't need do.

The example I am thinking of is "search for all methods called 'erase'" where the index might just be able to lookup "erase" and get 20 matches, but then before we realize/make any clang AST types, we would quickly call "DWARFDIE::IsClassMethod()" on it to weed out any mismatches before we hand them back. Let me know if that makes sense or if I am missing anything. I would like the DWARFIndex class to be as dead simple as possible.

[labath]

Changing the code to filter based on the dwarf information instead of the going through CompilerDeclContexts sounds like a good idea. I've been wondering why we are doing it this way -- the explanation I gave to myself was that this would allow the individual language plugins to decide what represents a "class" instead of just searching for DW_TAG_structure_type and similar. However, it's very likely that this is extra flexibility we don't need (and indeed, the manual index just checks the dwarf tags while building the index).

Unfortunately, something's come up, so I wasn't able to look into this closer today. Hopefully, I'll be able to get back to this patch later this week.

[labath]

This is a rewrite of the original patch with the same idea but different
approach. Now that Apple index determines method-ness straight from the debug
info, we don't need to resolve the functions into SymbolContexts. This removes
the need for the bunch of callback arguments and allows us to pull the common
part out of the two implementations of these functions back into the
SymbolFileDWARF class.

[clayborg]

Some if statements simplifications if you want to, but looks good.

source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

151–153

if (ObjCLanguage::IsPossibleObjCMethodName(die_name))
  dies.push_back(die);

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

169–172

if (SymbolFileDWARF::DIEInDeclContext(&parent_decl_ctx, die))
  dies.push_back(die);

182

if (die)
  dies.push_back(die);

185–188

if (die)
  dies.push_back(die);

source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.h

AppleDWARFIndex(
         m_apple_objc_up(std::move(apple_objc)) {}
 
   void Preload() override {}
 
   void GetGlobalVariables(ConstString name, 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 GetObjCMethodsForClass(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, DWARFDebugInfo &info,
-      llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
-                              lldb_private::SymbolContextList &sc_list)>
-          resolve_function,
-      llvm::function_ref<CompilerDeclContext(lldb::user_id_t type_uid)>
-          get_decl_context_containing_uid,
-      const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask,
-      bool include_inlines, SymbolContextList &sc_list) override;
+  void GetFunctionsByFullName(ConstString name, DIEArray &offsets) override;
+  void GetObjCMethodsByName(ConstString name, DIEArray &offsets) override;
+  void GetFunctionsByBaseOrMethodName(ConstString name,
+                                      lldb::FunctionNameType flags,
+                                      DIEArray &base_offsets,
+                                      DIEArray &method_offsets,
+                                      DIEArray &unknown_offsets) override;
   void GetFunctions(
       const RegularExpression &regex, DWARFDebugInfo &info,
       llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
                               lldb_private::SymbolContextList &sc_list)>
           resolve_function,
       bool include_inlines, SymbolContextList &sc_list) override;
 
   void ReportInvalidDIEOffset(dw_offset_t offset,

source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

 //===-- AppleDWARFIndex.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/AppleDWARFIndex.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
 #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
-#include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 std::unique_ptr<AppleDWARFIndex> AppleDWARFIndex::Create(
     Module &module, DWARFDataExtractor apple_names,
if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
   if (m_apple_names_up->AppendAllDIEsInRange(
           cu.GetOffset(), cu.GetNextCompileUnitOffset(), hash_data))
     DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
 }
 
-void AppleDWARFIndex::GetObjCMethods(ConstString class_name,
+void AppleDWARFIndex::GetObjCMethodsForClass(ConstString class_name,
                                      DIEArray &offsets) {
   if (m_apple_objc_up)
     m_apple_objc_up->FindByName(class_name.GetStringRef(), offsets);
 }
 
 void AppleDWARFIndex::GetCompleteObjCClass(ConstString class_name,
                                            bool must_be_implementation,
                                            DIEArray &offsets) {
if (has_tag && has_qualified_name_hash) {
     m_apple_types_up->FindByName(type_name.GetStringRef(), offsets);
 }
 
 void AppleDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
   if (m_apple_namespaces_up)
     m_apple_namespaces_up->FindByName(name.GetStringRef(), offsets);
 }
 
-void AppleDWARFIndex::GetFunctions(
-    ConstString name, DWARFDebugInfo &info,
-    llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
-                            lldb_private::SymbolContextList &sc_list)>
-        resolve_function,
-    llvm::function_ref<CompilerDeclContext(lldb::user_id_t type_uid)>
-        get_decl_context_containing_uid,
-    const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask,
-    bool include_inlines, SymbolContextList &sc_list) {
-  if (!m_apple_names_up)
-    return;
-
-  std::set<const DWARFDebugInfoEntry *> resolved_dies;
-  DIEArray offsets;
-
-  uint32_t num_matches = 0;
-
-  if (name_type_mask & eFunctionNameTypeFull) {
-    // If they asked for the full name, match what they typed.  At some
-    // point we may want to canonicalize this (strip double spaces, etc.
-    // For now, we just add all the dies that we find by exact match.
-    num_matches = m_apple_names_up->FindByName(name.GetStringRef(), offsets);
-    for (uint32_t i = 0; i < num_matches; i++) {
-      const DIERef &die_ref = offsets[i];
-      DWARFDIE die = info.GetDIE(die_ref);
-      if (die) {
-        if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-          continue; // The containing decl contexts don't match
-
-        if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
-          if (resolve_function(die, include_inlines, sc_list))
-            resolved_dies.insert(die.GetDIE());
-        }
-      } else
-        ReportInvalidDIEOffset(die_ref.die_offset, name.GetStringRef());
-    }
-  }
+void AppleDWARFIndex::GetFunctionsByFullName(ConstString name,
+                                             DIEArray &offsets) {
+  // If they asked for the full name, match what they typed.  At some point we
+  // may want to canonicalize this (strip double spaces, etc.  For now, we just
+  // add all the dies that we find by exact match.
+  if (m_apple_names_up)
+    m_apple_names_up->FindByName(name.GetStringRef(), offsets);
 
-  if (name_type_mask & eFunctionNameTypeSelector) {
-    if (parent_decl_ctx && parent_decl_ctx->IsValid())
-      return; // no selectors in namespaces
-
-    num_matches = m_apple_names_up->FindByName(name.GetStringRef(), offsets);
-    // Now make sure these are actually ObjC methods.  In this case we can
-    // simply look up the name, and if it is an ObjC method name, we're
-    // good.
-
-    for (uint32_t i = 0; i < num_matches; i++) {
-      const DIERef &die_ref = offsets[i];
-      DWARFDIE die = info.GetDIE(die_ref);
-      if (die) {
-        const char *die_name = die.GetName();
-        if (ObjCLanguage::IsPossibleObjCMethodName(die_name)) {
-          if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
-            if (resolve_function(die, include_inlines, sc_list))
-              resolved_dies.insert(die.GetDIE());
-          }
-        }
-      } else
-        ReportInvalidDIEOffset(die_ref.die_offset, name.GetStringRef());
-    }
-    offsets.clear();
-  }
+void AppleDWARFIndex::GetObjCMethodsByName(ConstString name,
+                                           DIEArray &offsets) {
+  if (m_apple_names_up)
+    m_apple_names_up->FindByName(name.GetStringRef(), offsets);
 
-  if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) ||
-      name_type_mask & eFunctionNameTypeBase) {
-    // The apple_names table stores just the "base name" of C++ methods in
-    // the table.  So we have to extract the base name, look that up, and
-    // if there is any other information in the name we were passed in we
-    // have to post-filter based on that.
-
-    // FIXME: Arrange the logic above so that we don't calculate the base
-    // name twice:
-    num_matches = m_apple_names_up->FindByName(name.GetStringRef(), offsets);
-
-    for (uint32_t i = 0; i < num_matches; i++) {
-      const DIERef &die_ref = offsets[i];
-      DWARFDIE die = info.GetDIE(die_ref);
-      if (die) {
-        if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-          continue; // The containing decl contexts don't match
-
-        // If we get to here, the die is good, and we should add it:
-        if (resolved_dies.find(die.GetDIE()) == resolved_dies.end() &&
-            resolve_function(die, include_inlines, sc_list)) {
-          bool keep_die = true;
-          if ((name_type_mask &
-               (eFunctionNameTypeBase | eFunctionNameTypeMethod)) !=
-              (eFunctionNameTypeBase | eFunctionNameTypeMethod)) {
-            // We are looking for either basenames or methods, so we need
-            // to trim out the ones we won't want by looking at the type
-            SymbolContext sc;
-            if (sc_list.GetLastContext(sc)) {
-              if (sc.block) {
-                // We have an inlined function
-              } else if (sc.function) {
-                Type *type = sc.function->GetType();
-
-                if (type) {
-                  CompilerDeclContext decl_ctx =
-                      get_decl_context_containing_uid(type->GetID());
-                  if (decl_ctx.IsStructUnionOrClass()) {
-                    if (name_type_mask & eFunctionNameTypeBase) {
-                      sc_list.RemoveContextAtIndex(sc_list.GetSize() - 1);
-                      keep_die = false;
-                    }
-                  } else {
-                    if (name_type_mask & eFunctionNameTypeMethod) {
-                      sc_list.RemoveContextAtIndex(sc_list.GetSize() - 1);
-                      keep_die = false;
-                    }
-                  }
-                } else {
-                  m_module.ReportWarning(
-                      "function at die offset 0x%8.8x had no function type",
-                      die_ref.die_offset);
-                }
-              }
-            }
-          }
-          if (keep_die)
-            resolved_dies.insert(die.GetDIE());
-        }
-      } else
-        ReportInvalidDIEOffset(die_ref.die_offset, name.GetStringRef());
-    }
-    offsets.clear();
-  }
+void AppleDWARFIndex::GetFunctionsByBaseOrMethodName(
+    ConstString name, lldb::FunctionNameType flags, DIEArray &base_offsets,
+    DIEArray &method_offsets, DIEArray &unknown_offsets) {
+  // It's impossible to tell functions and methods apart from the apple_names
+  // contents alone.  So, we just extract the data into the unknown_offsets and
+  // let the caller filter that.
+  if (m_apple_names_up)
+    m_apple_names_up->FindByName(name.GetStringRef(), unknown_offsets);
 }
 
 void AppleDWARFIndex::GetFunctions(
     const RegularExpression &regex, DWARFDebugInfo &info,
     llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
                             lldb_private::SymbolContextList &sc_list)>
         resolve_function,
     bool include_inlines, SymbolContextList &sc_list) {

source/Plugins/SymbolFile/DWARF/DWARFIndex.h

public:
   virtual ~DWARFIndex();
 
   virtual void Preload() = 0;
 
   virtual void GetGlobalVariables(ConstString name, DIEArray &offsets) = 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 GetObjCMethodsForClass(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, DWARFDebugInfo &info,
-      llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
-                              lldb_private::SymbolContextList &sc_list)>
-          resolve_function,
-      llvm::function_ref<CompilerDeclContext(lldb::user_id_t type_uid)>
-          get_decl_context_containing_uid,
-      const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask,
-      bool include_inlines, SymbolContextList &sc_list) = 0;
+  virtual void GetFunctionsByFullName(ConstString name, DIEArray &offsets) = 0;
+  virtual void GetObjCMethodsByName(ConstString name, DIEArray &offsets) = 0;
+
+  /// Find functions or methods with the given name. Only the
+  /// eFunctionNameTypeMethod and eFunctionNameTypeBase bits in the input flags
+  /// are inspected. If the implementation is certain a given DIE represents a
+  /// (non-member) function, it should put it in the base_offsets array. Method
+  /// DIEs should go into the method_offsets array. An implementation can put a
+  /// DIE into the unknown_offsets array if it cannot determine its type. It is up
+  /// to the caller to correctly classify these.
+  virtual void GetFunctionsByBaseOrMethodName(ConstString name,
+                                              lldb::FunctionNameType flags,
+                                              DIEArray &base_offsets,
+                                              DIEArray &method_offsets,
+                                              DIEArray &unknown_offsets) = 0;
   virtual void GetFunctions(
       const RegularExpression &regex, DWARFDebugInfo &info,
       llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
                               lldb_private::SymbolContextList &sc_list)>
           resolve_function,
       bool include_inlines, SymbolContextList &sc_list) = 0;
 
   virtual void ReportInvalidDIEOffset(dw_offset_t offset,

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h

ManualDWARFIndex(Module &module, DWARFDebugInfo *debug_info)
       : DWARFIndex(module), m_debug_info(debug_info) {}
 
   void Preload() override { Index(); }
 
   void GetGlobalVariables(ConstString name, 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 GetObjCMethodsForClass(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, DWARFDebugInfo &info,
-      llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
-                              lldb_private::SymbolContextList &sc_list)>
-          resolve_function,
-      llvm::function_ref<CompilerDeclContext(lldb::user_id_t type_uid)>
-          get_decl_context_containing_uid,
-      const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask,
-      bool include_inlines, SymbolContextList &sc_list) override;
+  void GetFunctionsByFullName(ConstString name, DIEArray &offsets) override;
+  void GetObjCMethodsByName(ConstString name, DIEArray &offsets) override;
+  void GetFunctionsByBaseOrMethodName(ConstString name,
+                                      lldb::FunctionNameType flags,
+                                      DIEArray &base_offsets,
+                                      DIEArray &method_offsets,
+                                      DIEArray &unknown_offsets) override;
   void GetFunctions(
       const RegularExpression &regex, DWARFDebugInfo &info,
       llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
                               lldb_private::SymbolContextList &sc_list)>
           resolve_function,
       bool include_inlines, SymbolContextList &sc_list) override;
 
   void ReportInvalidDIEOffset(dw_offset_t offset,

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

 }
 
 void ManualDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
                                           DIEArray &offsets) {
   Index();
   m_globals.FindAllEntriesForCompileUnit(cu.GetOffset(), offsets);
 }
 
-void ManualDWARFIndex::GetObjCMethods(ConstString class_name,
+void ManualDWARFIndex::GetObjCMethodsForClass(ConstString class_name,
                                       DIEArray &offsets) {
   Index();
   m_objc_class_selectors.Find(class_name, offsets);
 }
 
 void ManualDWARFIndex::GetCompleteObjCClass(ConstString class_name,
                                             bool must_be_implementation,
                                             DIEArray &offsets) {
void ManualDWARFIndex::GetTypes(const DWARFDeclContext &context,
   m_types.Find(ConstString(context[0].name), offsets);
 }
 
 void ManualDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
   Index();
   m_namespaces.Find(name, offsets);
 }
 
-void ManualDWARFIndex::GetFunctions(
-    ConstString name, DWARFDebugInfo &info,
-    llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
-                            lldb_private::SymbolContextList &sc_list)>
-        resolve_function,
-    llvm::function_ref<CompilerDeclContext(lldb::user_id_t type_uid)>
-        get_decl_context_containing_uid,
-    const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask,
-    bool include_inlines, SymbolContextList &sc_list) {
-
+void ManualDWARFIndex::GetFunctionsByFullName(ConstString name, DIEArray &offsets) {
   Index();
-
-  std::set<const DWARFDebugInfoEntry *> resolved_dies;
-  DIEArray offsets;
-  if (name_type_mask & eFunctionNameTypeFull) {
-    uint32_t num_matches = m_function_basenames.Find(name, offsets);
-    num_matches += m_function_methods.Find(name, offsets);
-    num_matches += m_function_fullnames.Find(name, offsets);
-    for (uint32_t i = 0; i < num_matches; i++) {
-      const DIERef &die_ref = offsets[i];
-      DWARFDIE die = info.GetDIE(die_ref);
-      if (die) {
-        if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-          continue; // The containing decl contexts don't match
-
-        if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
-          if (resolve_function(die, include_inlines, sc_list))
-            resolved_dies.insert(die.GetDIE());
-        }
-      }
-    }
-    offsets.clear();
-  }
-  if (name_type_mask & eFunctionNameTypeBase) {
-    uint32_t num_base = m_function_basenames.Find(name, offsets);
-    for (uint32_t i = 0; i < num_base; i++) {
-      DWARFDIE die = info.GetDIE(offsets[i]);
-      if (die) {
-        if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-          continue; // The containing decl contexts don't match
+  m_function_basenames.Find(name, offsets);
+  m_function_methods.Find(name, offsets);
+  m_function_fullnames.Find(name, offsets);
 
-        // If we get to here, the die is good, and we should add it:
-        if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
-          if (resolve_function(die, include_inlines, sc_list))
-            resolved_dies.insert(die.GetDIE());
-        }
-      }
-    }
-    offsets.clear();
-  }
+void ManualDWARFIndex::GetObjCMethodsByName(ConstString name,
+                                            DIEArray &offsets) {
+  Index();
+  m_function_selectors.Find(name, offsets);
 
-  if (name_type_mask & eFunctionNameTypeMethod) {
-    if (parent_decl_ctx && parent_decl_ctx->IsValid())
-      return; // no methods in namespaces
+void ManualDWARFIndex::GetFunctionsByBaseOrMethodName(
+    ConstString name, lldb::FunctionNameType flags, DIEArray &base_offsets,
+    DIEArray &method_offsets, DIEArray &unknown_offsets) {
+  Index();
 
-    uint32_t num_base = m_function_methods.Find(name, offsets);
-    {
-      for (uint32_t i = 0; i < num_base; i++) {
-        DWARFDIE die = info.GetDIE(offsets[i]);
-        if (die) {
-          // If we get to here, the die is good, and we should add it:
-          if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
-            if (resolve_function(die, include_inlines, sc_list))
-              resolved_dies.insert(die.GetDIE());
-          }
-        }
-      }
-    }
-    offsets.clear();
-  }
+  // We have checked the type of DIEs while building the index, so we can give
+  // exact answers here.
+  if (flags & eFunctionNameTypeBase)
+    m_function_basenames.Find(name, base_offsets);
 
-  if ((name_type_mask & eFunctionNameTypeSelector) &&
-      (!parent_decl_ctx || !parent_decl_ctx->IsValid())) {
-    uint32_t num_selectors = m_function_selectors.Find(name, offsets);
-    for (uint32_t i = 0; i < num_selectors; i++) {
-      DWARFDIE die = info.GetDIE(offsets[i]);
-      if (die) {
-        // If we get to here, the die is good, and we should add it:
-        if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
-          if (resolve_function(die, include_inlines, sc_list))
-            resolved_dies.insert(die.GetDIE());
-        }
-      }
-    }
-  }
+  if (flags & eFunctionNameTypeMethod)
+    m_function_methods.Find(name, method_offsets);
 }
 
 void ManualDWARFIndex::GetFunctions(
     const RegularExpression &regex, DWARFDebugInfo &info,
     llvm::function_ref<bool(const DWARFDIE &die, bool include_inlines,
                             lldb_private::SymbolContextList &sc_list)>
         resolve_function,
     bool include_inlines, SymbolContextList &sc_list) {
   Index();
 
   DIEArray offsets;
   m_function_basenames.Find(regex, offsets);
   m_function_fullnames.Find(regex, offsets);
   ParseFunctions(offsets, info, resolve_function, include_inlines, sc_list);
 }

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
+#include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Symbols.h"
 
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 
if (dwarf_cu->GetUserData() == NULL) {
     return ParseCompileUnit(dwarf_cu, cu_idx).get();
   }
   return (CompileUnit *)dwarf_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);
+  m_index->GetObjCMethodsForClass(class_name, method_die_offsets);
   return method_die_offsets.size();
 }
 
 bool SymbolFileDWARF::GetFunction(const DWARFDIE &die, SymbolContext &sc) {
   sc.Clear(false);
 
   if (die) {
     // Check if the symbol vendor already knows about this compile unit?
GetObjectFile()->GetModule()->LogMessage(
              "name_type_mask=0x%x, append=%u, sc_list)",
         name.GetCString(), name_type_mask, append);
   }
 
   // If we aren't appending the results to this list, then clear the list
   if (!append)
     sc_list.Clear();
 
+  if (parent_decl_ctx && !parent_decl_ctx->IsValid())
+    parent_decl_ctx = nullptr;
+
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
 
   // If name is empty then we won't find anything.
   if (name.IsEmpty())
     return 0;
 
   // 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();
 
   DWARFDebugInfo *info = DebugInfo();
   if (info == NULL)
     return 0;
 
-  m_index->GetFunctions(name, *info,
-                        [this](const DWARFDIE &die, bool include_inlines,
-                               lldb_private::SymbolContextList &sc_list) {
-                          return ResolveFunction(die, include_inlines, sc_list);
-                        },
-                        [this](lldb::user_id_t type_uid) {
-                          return GetDeclContextContainingUID(type_uid);
-                        },
-                        parent_decl_ctx, name_type_mask, include_inlines,
-                        sc_list);
+  llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
+  if (name_type_mask & eFunctionNameTypeFull) {
+    DIEArray offsets;
+    m_index->GetFunctionsByFullName(name, offsets);
+    for (const DIERef &ref : offsets) {
+      DWARFDIE die = info->GetDIE(ref);
+      if (!die) {
+        m_index->ReportInvalidDIEOffset(ref.die_offset, name.GetStringRef());
+        continue;
+      }
+      if (!DIEInDeclContext(parent_decl_ctx, die))
+        continue; // The containing decl contexts don't match
+
+      if (resolved_dies.insert(die.GetDIE()).second)
+        ResolveFunction(die, include_inlines, sc_list);
+    }
+  }
+  if (name_type_mask & eFunctionNameTypeSelector && !parent_decl_ctx) {
+    DIEArray offsets;
+    m_index->GetObjCMethodsByName(name, offsets);
+
+    // Now make sure these are actually ObjC methods.  In this case we can
+    // simply look up the name, and if it is an ObjC method name, we're
+    // good.
+    for (const DIERef &ref : offsets) {
+      DWARFDIE die = info->GetDIE(ref);
+      if (!die) {
+        m_index->ReportInvalidDIEOffset(ref.die_offset, name.GetStringRef());
+        continue;
+      }
+      if (!ObjCLanguage::IsPossibleObjCMethodName(die.GetName()))
+        continue;
+      if (resolved_dies.insert(die.GetDIE()).second)
+        ResolveFunction(die, include_inlines, sc_list);
+    }
+  }
+  if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) ||
+      name_type_mask & eFunctionNameTypeBase) {
+    DIEArray base_offsets, method_offsets, unknown_offsets;
+    m_index->GetFunctionsByBaseOrMethodName(
+        name, FunctionNameType(name_type_mask), base_offsets, method_offsets,
+        unknown_offsets);
+
+    for (const DIERef &ref : base_offsets) {
+      DWARFDIE die = info->GetDIE(ref);
+      if (!die) {
+        m_index->ReportInvalidDIEOffset(ref.die_offset, name.GetStringRef());
+        continue;
+      }
+      if (!DIEInDeclContext(parent_decl_ctx, die))
+        continue; // The containing decl contexts don't match
+
+      if (resolved_dies.insert(die.GetDIE()).second)
+        ResolveFunction(die, include_inlines, sc_list);
+    }
+
+    if (!parent_decl_ctx) {
+      for (const DIERef &ref : method_offsets) {
+        DWARFDIE die = info->GetDIE(ref);
+        if (!die) {
+          m_index->ReportInvalidDIEOffset(ref.die_offset, name.GetStringRef());
+          continue;
+        }
+        if (resolved_dies.insert(die.GetDIE()).second)
+          ResolveFunction(die, include_inlines, sc_list);
+      }
+    }
+
+    for (const DIERef &ref : unknown_offsets) {
+      DWARFDIE die = info->GetDIE(ref);
+      if (!die) {
+        m_index->ReportInvalidDIEOffset(ref.die_offset, name.GetStringRef());
+        continue;
+      }
+      if (!DIEInDeclContext(parent_decl_ctx, die))
+        continue; // The containing decl contexts don't match
+
+      // If we get to here, the die is good, so add it to our list
+      // provisionally.
+      if (resolved_dies.insert(die.GetDIE()).second &&
+          ResolveFunction(die, include_inlines, sc_list)) {
+        if (name_type_mask & eFunctionNameTypeBase &&
+            name_type_mask & eFunctionNameTypeMethod)
+          continue;
+
+        // We are looking for either basenames or methods, so we need to trim
+        // out the ones we won't want by looking at the type
+        const bool looking_for_methods =
+            name_type_mask & eFunctionNameTypeMethod;
+
+        SymbolContext sc;
+        sc_list.GetLastContext(sc);
+        if (sc.block)
+          continue; // We have an inlined function
+        if (!sc.function)
+          continue;
+
+        Type *type = sc.function->GetType();
+        if (!type) {
+          GetObjectFile()->GetModule()->ReportWarning(
+              "function at die offset 0x%8.8x had no function type",
+              ref.die_offset);
+          continue;
+        }
+
+        CompilerDeclContext decl_ctx =
+            GetDeclContextContainingUID(type->GetID());
+        if (decl_ctx.IsStructUnionOrClass() != looking_for_methods) {
+          // We have a mismatch, remove our function from the list.
+          sc_list.RemoveContextAtIndex(sc_list.GetSize() - 1);
+          resolved_dies.erase(die.GetDIE());
+        }
+      }
+    }
+  }
 
   // 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\", "
              "name_type_mask=0x%x, include_inlines=%d, append=%u, sc_list) => "