[DWARF] Extract indexing code into a separate class hierarchy

[labath]

Summary

This places the if(m_using_apple_tables) branches inside the
SymbolFileDWARF class behind an abstract DWARFIndex class. The class
currently has two implementations:

• AppleIndex, which searches using .apple_names and friends
• ManualIndex, which searches using a manually built index

Most of the methods of the class are very simple, and simply extract the
list of DIEs for the given name from the appropriate sub-table. The main
exception are the two GetFunctions overloads, which take a couple of
extra paramenters, including some callbacks. It was not possible to
split these up the same way as other methods, as here we were doing a
lot of post-processing on the results. The post-processing is similar
for the two cases, but not identical. I hope to factor these further in
separate patches.

Other interesting methods are:

• Preload(): do any preprocessing to make lookups faster (noop for AppleIndex, forces a build of the lookup tables for ManualIndex).
• ReportInvalidDIEOffset(): Used to notify the users of an invalid index (prints a message for AppleIndex, noop for ManualIndex).
• Dump(): dumps the index state (noop for AppleIndex, prints the lookup tables for ManualIndex).

[JDevlieghere]

Looks good to me, but I'll defer to Greg as I've never actually touched this code myself.

[clayborg]

Looks fine. Just one question on keeping the DWARFIndex::Create() functions so they all have the same signature.

source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

40 ↗

(On Diff #146853)

Move all AppleIndex stuff to a dedicated .cpp file?

321 ↗

(On Diff #146853)

Move all ManualIndex stuff to a dedicated .cpp file?

source/Plugins/SymbolFile/DWARF/DWARFIndex.h

71 ↗

(On Diff #146853)

Rename to AppleDWARFIndex and move to AppleDWARFIndex.h?

127 ↗

(On Diff #146853)

Rename to ManualDWARFIndex and move to ManualDWARFIndex.h?

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

40 ↗

(On Diff #146853)

Do we want all DWARFIndex::Create(...) signatures to take a SymbolFileDWARF only? Then module can be extracted from that and all sections can be fetched as well?

[labath]

Thank you for the review. I'll have the updated diff shortly. In the mean time, here are my responses.

source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

40 ↗

(On Diff #146853)

SymbolFileDWARF does not provide public accessors for individual sections. I would have to make LoadSectionData or some other get-me-a-section api available. I like how this is explicit about what kind of data a particular accelerator table depends on.

source/Plugins/SymbolFile/DWARF/DWARFIndex.h

71 ↗

(On Diff #146853)

The classes seemed small enough to keep in one file, but that works for me too. A more canonical name here would be DWARFAppleIndex.h, but i hate how everything in this folder begins with DWARF, so this is a place I'll happily diverge from the norm. :P

[labath]

• s/AppleIndex/AppleDWARFIndex
• move things to separate files

[clayborg]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

1984 ↗

(On Diff #147326)

Yikes, who was calling PreloadSymbols before? Was this causing all Apple systems to manually index the DWARF as well??? That is bad. Fix now with you changes to the right, but scary.

[aemerson]

This caused a failure in green dragon: http://green.lab.llvm.org/green/job/lldb-xcode/6644

Can you please fix or revert this change, thanks.

[aemerson]

Hi Pavel,

I reverted this in r332730 due to the bot breaking. Please have a look and commit again when ready.

Thanks,
Amara

[aprantl]

Thanks for jumping on this Amara — I just wanted to point out that we ususally don't revert lldb changes that only break the lldb-xcode bot if they pass on the lldb-cmake bot at the same time. When this happens it usually means that the lldb Xcode project must be updated and it's too much to ask from all open source contributors to get access to a machine running Xcode to do this. Instead one of the Apple LLDB developers usually goes in and updates the Xcode project for them.

• adrian

[aemerson]

In D46889#1104823, @aprantl wrote:

Thanks for jumping on this Amara — I just wanted to point out that we ususally don't revert lldb changes that only break the lldb-xcode bot if they pass on the lldb-cmake bot at the same time. When this happens it usually means that the lldb Xcode project must be updated and it's too much to ask from all open source contributors to get access to a machine running Xcode to do this. Instead one of the Apple LLDB developers usually goes in and updates the Xcode project for them.

• adrian

Ah ok. Does that include cases like this one with the link error:

Undefined symbols for architecture x86_64:
  "lldb_private::AppleDWARFIndex::Create(lldb_private::Module&, lldb_private::DWARFDataExtractor, lldb_private::DWARFDataExtractor, lldb_private::DWARFDataExtractor, lldb_private::DWARFDataExtractor, lldb_private::DWARFDataExtractor)", referenced from:
      SymbolFileDWARF::InitializeObject() in liblldb-core.a(SymbolFileDWARF.o)
  "vtable for lldb_private::ManualDWARFIndex", referenced from:
      SymbolFileDWARF::InitializeObject() in liblldb-core.a(SymbolFileDWARF.o)
  NOTE: a missing vtable usually means the first non-inline virtual member function has no definition.

[labath]

In D46889#1104882, @aemerson wrote:

In D46889#1104823, @aprantl wrote:

Thanks for jumping on this Amara — I just wanted to point out that we ususally don't revert lldb changes that only break the lldb-xcode bot if they pass on the lldb-cmake bot at the same time. When this happens it usually means that the lldb Xcode project must be updated and it's too much to ask from all open source contributors to get access to a machine running Xcode to do this. Instead one of the Apple LLDB developers usually goes in and updates the Xcode project for them.

• adrian

Ah ok. Does that include cases like this one with the link error:

Undefined symbols for architecture x86_64:
  "lldb_private::AppleDWARFIndex::Create(lldb_private::Module&, lldb_private::DWARFDataExtractor, lldb_private::DWARFDataExtractor, lldb_private::DWARFDataExtractor, lldb_private::DWARFDataExtractor, lldb_private::DWARFDataExtractor)", referenced from:
      SymbolFileDWARF::InitializeObject() in liblldb-core.a(SymbolFileDWARF.o)
  "vtable for lldb_private::ManualDWARFIndex", referenced from:
      SymbolFileDWARF::InitializeObject() in liblldb-core.a(SymbolFileDWARF.o)
  NOTE: a missing vtable usually means the first non-inline virtual member function has no definition.

A link error is the most common manifestation of a file not being added to the xcode project. the vtable in question would have been emitted if ManualDWARFIndex.cpp (created by this CL) was built with everything else.

I did verify that this patch builds (with cmake) and all tests pass on darwin, so I don't expect there to be any other problems.

I am going to try relanding this when I'm back at work on Monday, but until then, if someone knows how to add these files to the project, I'd appreciate it if he can submit those changes together with this patch, and we can avoid having the bot go red again.

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

+//===-- AppleDWARFIndex.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_APPLEDWARFINDEX_H
+#define LLDB_APPLEDWARFINDEX_H
+
+#include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
+#include "Plugins/SymbolFile/DWARF/HashedNameToDIE.h"
+
+namespace lldb_private {
+class AppleDWARFIndex : public DWARFIndex {
+public:
+  static std::unique_ptr<AppleDWARFIndex>
+  Create(Module &module, DWARFDataExtractor apple_names,
+         DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
+         DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str);
+
+  AppleDWARFIndex(
+      Module &module, std::unique_ptr<DWARFMappedHash::MemoryTable> apple_names,
+      std::unique_ptr<DWARFMappedHash::MemoryTable> apple_namespaces,
+      std::unique_ptr<DWARFMappedHash::MemoryTable> apple_types,
+      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 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 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 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,
+                              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_APPLEDWARFINDEX_H

lldb/trunk/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,
+    DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
+    DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str) {
+  auto apple_names_table_up = llvm::make_unique<DWARFMappedHash::MemoryTable>(
+      apple_names, debug_str, ".apple_names");
+  if (!apple_names_table_up->IsValid())
+    apple_names_table_up.reset();
+
+  auto apple_namespaces_table_up =
+      llvm::make_unique<DWARFMappedHash::MemoryTable>(
+          apple_namespaces, debug_str, ".apple_namespaces");
+  if (!apple_namespaces_table_up->IsValid())
+    apple_namespaces_table_up.reset();
+
+  auto apple_types_table_up = llvm::make_unique<DWARFMappedHash::MemoryTable>(
+      apple_types, debug_str, ".apple_types");
+  if (!apple_types_table_up->IsValid())
+    apple_types_table_up.reset();
+
+  auto apple_objc_table_up = llvm::make_unique<DWARFMappedHash::MemoryTable>(
+      apple_objc, debug_str, ".apple_objc");
+  if (!apple_objc_table_up->IsValid())
+    apple_objc_table_up.reset();
+
+  if (apple_names_table_up || apple_names_table_up || apple_types_table_up ||
+      apple_objc_table_up)
+    return llvm::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 name, DIEArray &offsets) {
+  if (!m_apple_names_up)
+    return;
+
+  const char *name_cstr = name.GetCString();
+  llvm::StringRef basename;
+  llvm::StringRef context;
+
+  if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
+                                                      basename))
+    basename = name_cstr;
+
+  m_apple_names_up->FindByName(basename, offsets);
+}
+
+void AppleDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
+                                         DIEArray &offsets) {
+  if (!m_apple_names_up)
+    return;
+
+  DWARFMappedHash::DIEInfoArray hash_data;
+  if (m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data))
+    DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
+}
+
+void AppleDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
+                                         DIEArray &offsets) {
+  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,
+                                     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 (m_apple_types_up) {
+    m_apple_types_up->FindCompleteObjCClassByName(
+        class_name.GetStringRef(), offsets, must_be_implementation);
+  }
+}
+
+void AppleDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
+  if (m_apple_types_up)
+    m_apple_types_up->FindByName(name.GetStringRef(), offsets);
+}
+
+void AppleDWARFIndex::GetTypes(const DWARFDeclContext &context,
+                               DIEArray &offsets) {
+  if (!m_apple_types_up)
+    return;
+
+  Log *log = LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
+                                          DWARF_LOG_LOOKUPS);
+  const bool has_tag = m_apple_types_up->GetHeader().header_data.ContainsAtom(
+      DWARFMappedHash::eAtomTypeTag);
+  const bool has_qualified_name_hash =
+      m_apple_types_up->GetHeader().header_data.ContainsAtom(
+          DWARFMappedHash::eAtomTypeQualNameHash);
+  const ConstString type_name(context[0].name);
+  const dw_tag_t tag = context[0].tag;
+  if (has_tag && has_qualified_name_hash) {
+    const char *qualified_name = context.GetQualifiedName();
+    const uint32_t qualified_name_hash = llvm::djbHash(qualified_name);
+    if (log)
+      m_module.LogMessage(log, "FindByNameAndTagAndQualifiedNameHash()");
+    m_apple_types_up->FindByNameAndTagAndQualifiedNameHash(
+        type_name.GetStringRef(), tag, qualified_name_hash, offsets);
+  } else if (has_tag) {
+    if (log)
+      m_module.LogMessage(log, "FindByNameAndTag()");
+    m_apple_types_up->FindByNameAndTag(type_name.GetStringRef(), tag, offsets);
+  } else
+    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());
+    }
+  }
+
+  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();
+  }
+
+  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::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) {
+  if (!m_apple_names_up)
+    return;
+
+  DIEArray offsets;
+  DWARFMappedHash::DIEInfoArray hash_data;
+  if (m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data)) {
+    DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
+    ParseFunctions(offsets, info, resolve_function, include_inlines, sc_list);
+  }
+}
+
+void AppleDWARFIndex::ReportInvalidDIEOffset(dw_offset_t offset,
+                                             llvm::StringRef name) {
+  m_module.ReportErrorIfModifyDetected(
+      "the DWARF debug information has been modified (accelerator table had "
+      "bad die 0x%8.8x for '%s')\n",
+      offset, name.str().c_str());
+}
+
+void AppleDWARFIndex::Dump(Stream &s) {
+  // TODO: Implement dumping.
+}

lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt

 add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
+  AppleDWARFIndex.cpp
   DIERef.cpp
   DWARFAbbreviationDeclaration.cpp
   DWARFASTParserClang.cpp
   DWARFASTParserGo.cpp
   DWARFASTParserJava.cpp
   DWARFASTParserOCaml.cpp
   DWARFAttribute.cpp
   DWARFCompileUnit.cpp
   DWARFDataExtractor.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugAranges.cpp
   DWARFDebugArangeSet.cpp
   DWARFDebugInfo.cpp
   DWARFDebugInfoEntry.cpp
   DWARFDebugLine.cpp
   DWARFDebugMacro.cpp
   DWARFDebugMacinfo.cpp
   DWARFDebugMacinfoEntry.cpp
   DWARFDebugRanges.cpp
   DWARFDeclContext.cpp
   DWARFDefines.cpp
   DWARFDIE.cpp
   DWARFDIECollection.cpp
   DWARFFormValue.cpp
+  DWARFIndex.cpp
   DWARFUnit.cpp
   HashedNameToDIE.cpp
   LogChannelDWARF.cpp
+  ManualDWARFIndex.cpp
   NameToDIE.cpp
   SymbolFileDWARF.cpp
   SymbolFileDWARFDwo.cpp
   SymbolFileDWARFDwoDwp.cpp
   SymbolFileDWARFDwp.cpp
   SymbolFileDWARFDebugMap.cpp
   UniqueDWARFASTType.cpp
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.cpp

 //===-- DWARFAbbreviationDeclaration.cpp ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFAbbreviationDeclaration.h"
 
 #include "lldb/Core/dwarf.h"
+#include "lldb/Utility/Stream.h"
 
 #include "DWARFFormValue.h"
 
 using namespace lldb_private;
 
 DWARFAbbreviationDeclaration::DWARFAbbreviationDeclaration()
     : m_code(InvalidCode), m_tag(0), m_has_children(0), m_attributes() {}
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 //===-- DWARFCompileUnit.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFCompileUnit.h"
 
 #include "SymbolFileDWARF.h"
+#include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 extern int g_verbose;
 
 DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF *dwarf2Data)
     : DWARFUnit(dwarf2Data) {}

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

+//===-- DWARFIndex.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_DWARFINDEX_H
+#define LLDB_DWARFINDEX_H
+
+#include "Plugins/SymbolFile/DWARF/DIERef.h"
+#include "Plugins/SymbolFile/DWARF/DWARFFormValue.h"
+
+class DWARFDebugInfo;
+class DWARFDeclContext;
+class DWARFDIE;
+
+namespace lldb_private {
+class DWARFIndex {
+public:
+  DWARFIndex(Module &module) : m_module(module) {}
+  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 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 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,
+                                      llvm::StringRef name) = 0;
+  virtual void Dump(Stream &s) = 0;
+
+protected:
+  Module &m_module;
+
+  void ParseFunctions(
+      const DIEArray &offsets, 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);
+};
+} // namespace lldb_private
+
+#endif // LLDB_DWARFINDEX_H

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

+//===-- DWARFIndex.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/DWARFIndex.h"
+#include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
+#include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+DWARFIndex::~DWARFIndex() = default;
+
+void DWARFIndex::ParseFunctions(
+    const DIEArray &offsets, 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) {
+  const size_t num_matches = offsets.size();
+  for (size_t i = 0; i < num_matches; ++i) {
+    DWARFDIE die = info.GetDIE(offsets[i]);
+    if (die)
+      resolve_function(die, include_inlines, sc_list);
+  }
+}

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Timer.h"
 
 #include "DWARFDIECollection.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "LogChannelDWARF.h"
+#include "NameToDIE.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 extern int g_verbose;

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

+//===-- ManulaDWARFIndex.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_MANUALDWARFINDEX_H
+#define LLDB_MANUALDWARFINDEX_H
+
+#include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
+#include "Plugins/SymbolFile/DWARF/NameToDIE.h"
+
+namespace lldb_private {
+class ManualDWARFIndex : public DWARFIndex {
+public:
+  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 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 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,
+                              llvm::StringRef name) override {}
+  void Dump(Stream &s) override;
+
+private:
+  void Index();
+
+  /// Non-null value means we haven't built the index yet.
+  DWARFDebugInfo *m_debug_info;
+
+  NameToDIE m_function_basenames;
+  NameToDIE m_function_fullnames;
+  NameToDIE m_function_methods;
+  NameToDIE m_function_selectors;
+  NameToDIE m_objc_class_selectors;
+  NameToDIE m_globals;
+  NameToDIE m_types;
+  NameToDIE m_namespaces;
+};
+} // namespace lldb_private
+
+#endif // LLDB_MANUALDWARFINDEX_H

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

+//===-- ManualDWARFIndex.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/ManualDWARFIndex.h"
+#include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
+#include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Host/TaskPool.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/Utility/Timer.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+void ManualDWARFIndex::Index() {
+  if (!m_debug_info)
+    return;
+
+  DWARFDebugInfo &debug_info = *m_debug_info;
+  m_debug_info = nullptr;
+
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "%p", static_cast<void *>(&debug_info));
+
+  const uint32_t num_compile_units = debug_info.GetNumCompileUnits();
+  if (num_compile_units == 0)
+    return;
+
+  std::vector<NameToDIE> function_basenames(num_compile_units);
+  std::vector<NameToDIE> function_fullnames(num_compile_units);
+  std::vector<NameToDIE> function_methods(num_compile_units);
+  std::vector<NameToDIE> function_selectors(num_compile_units);
+  std::vector<NameToDIE> objc_class_selectors(num_compile_units);
+  std::vector<NameToDIE> globals(num_compile_units);
+  std::vector<NameToDIE> types(num_compile_units);
+  std::vector<NameToDIE> namespaces(num_compile_units);
+
+  // std::vector<bool> might be implemented using bit test-and-set, so use
+  // uint8_t instead.
+  std::vector<uint8_t> clear_cu_dies(num_compile_units, false);
+  auto parser_fn = [&](size_t cu_idx) {
+    DWARFUnit *dwarf_cu = debug_info.GetCompileUnitAtIndex(cu_idx);
+    if (dwarf_cu) {
+      dwarf_cu->Index(function_basenames[cu_idx], function_fullnames[cu_idx],
+                      function_methods[cu_idx], function_selectors[cu_idx],
+                      objc_class_selectors[cu_idx], globals[cu_idx],
+                      types[cu_idx], namespaces[cu_idx]);
+    }
+  };
+
+  auto extract_fn = [&debug_info, &clear_cu_dies](size_t cu_idx) {
+    DWARFUnit *dwarf_cu = debug_info.GetCompileUnitAtIndex(cu_idx);
+    if (dwarf_cu) {
+      // dwarf_cu->ExtractDIEsIfNeeded(false) will return zero if the DIEs
+      // for a compile unit have already been parsed.
+      if (dwarf_cu->ExtractDIEsIfNeeded(false) > 1)
+        clear_cu_dies[cu_idx] = true;
+    }
+  };
+
+  // Create a task runner that extracts dies for each DWARF compile unit in a
+  // separate thread
+  //----------------------------------------------------------------------
+  // First figure out which compile units didn't have their DIEs already
+  // parsed and remember this.  If no DIEs were parsed prior to this index
+  // function call, we are going to want to clear the CU dies after we are
+  // done indexing to make sure we don't pull in all DWARF dies, but we need
+  // to wait until all compile units have been indexed in case a DIE in one
+  // compile unit refers to another and the indexes accesses those DIEs.
+  //----------------------------------------------------------------------
+  TaskMapOverInt(0, num_compile_units, extract_fn);
+
+  // Now create a task runner that can index each DWARF compile unit in a
+  // separate thread so we can index quickly.
+
+  TaskMapOverInt(0, num_compile_units, parser_fn);
+
+  auto finalize_fn = [](NameToDIE &index, std::vector<NameToDIE> &srcs) {
+    for (auto &src : srcs)
+      index.Append(src);
+    index.Finalize();
+  };
+
+  TaskPool::RunTasks(
+      [&]() { finalize_fn(m_function_basenames, function_basenames); },
+      [&]() { finalize_fn(m_function_fullnames, function_fullnames); },
+      [&]() { finalize_fn(m_function_methods, function_methods); },
+      [&]() { finalize_fn(m_function_selectors, function_selectors); },
+      [&]() { finalize_fn(m_objc_class_selectors, objc_class_selectors); },
+      [&]() { finalize_fn(m_globals, globals); },
+      [&]() { finalize_fn(m_types, types); },
+      [&]() { finalize_fn(m_namespaces, namespaces); });
+
+  //----------------------------------------------------------------------
+  // Keep memory down by clearing DIEs for any compile units if indexing
+  // caused us to load the compile unit's DIEs.
+  //----------------------------------------------------------------------
+  for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
+    if (clear_cu_dies[cu_idx])
+      debug_info.GetCompileUnitAtIndex(cu_idx)->ClearDIEs(true);
+  }
+}
+
+void ManualDWARFIndex::GetGlobalVariables(ConstString name, DIEArray &offsets) {
+  Index();
+  m_globals.Find(name, offsets);
+}
+
+void ManualDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
+                                          DIEArray &offsets) {
+  Index();
+  m_globals.Find(regex, offsets);
+}
+
+void ManualDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
+                                          DIEArray &offsets) {
+  Index();
+  m_globals.FindAllEntriesForCompileUnit(cu.GetOffset(), offsets);
+}
+
+void ManualDWARFIndex::GetObjCMethods(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) {
+  Index();
+  m_types.Find(class_name, offsets);
+}
+
+void ManualDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
+  Index();
+  m_types.Find(name, offsets);
+}
+
+void ManualDWARFIndex::GetTypes(const DWARFDeclContext &context,
+                                DIEArray &offsets) {
+  Index();
+  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) {
+
+  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
+
+        // 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();
+  }
+
+  if (name_type_mask & eFunctionNameTypeMethod) {
+    if (parent_decl_ctx && parent_decl_ctx->IsValid())
+      return; // no methods in namespaces
+
+    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();
+  }
+
+  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());
+        }
+      }
+    }
+  }
+}
+
+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);
+}
+
+void ManualDWARFIndex::Dump(Stream &s) {
+  s.Format("DWARF index for ({0}) '{1:F}':",
+           m_module.GetArchitecture().GetArchitectureName(),
+           m_module.GetObjectFile()->GetFileSpec());
+  s.Printf("\nFunction basenames:\n");
+  m_function_basenames.Dump(&s);
+  s.Printf("\nFunction fullnames:\n");
+  m_function_fullnames.Dump(&s);
+  s.Printf("\nFunction methods:\n");
+  m_function_methods.Dump(&s);
+  s.Printf("\nFunction selectors:\n");
+  m_function_selectors.Dump(&s);
+  s.Printf("\nObjective C class selectors:\n");
+  m_objc_class_selectors.Dump(&s);
+  s.Printf("\nGlobals and statics:\n");
+  m_globals.Dump(&s);
+  s.Printf("\nTypes:\n");
+  m_types.Dump(&s);
+  s.Printf("\nNamespaces:\n");
+  m_namespaces.Dump(&s);
+}

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

 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
 // Project includes
 #include "DWARFDataExtractor.h"
 #include "DWARFDefines.h"
-#include "HashedNameToDIE.h"
-#include "NameToDIE.h"
+#include "DWARFIndex.h"
 #include "UniqueDWARFASTType.h"
 
 //----------------------------------------------------------------------
 // Forward Declarations for this DWARF plugin
 //----------------------------------------------------------------------
 class DebugMapModule;
 class DWARFAbbreviationDeclaration;
 class DWARFAbbreviationDeclarationSet;
public:
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die);
 
   // For regular SymbolFileDWARF instances the method returns nullptr,
   // for the instances of the subclass SymbolFileDWARFDwo
   // the method returns a pointer to the base compile unit.
   virtual DWARFUnit *GetBaseCompileUnit();
 
+  static bool
+  DIEInDeclContext(const lldb_private::CompilerDeclContext *parent_decl_ctx,
+                   const DWARFDIE &die);
+
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
GetCachedSectionData(lldb::SectionType sect_type,
                        DWARFDataSegment &data_segment);
 
   virtual void LoadSectionData(lldb::SectionType sect_type,
                                lldb_private::DWARFDataExtractor &data);
 
   bool DeclContextMatchesThisSymbolFile(
       const lldb_private::CompilerDeclContext *decl_ctx);
 
-  bool
-  DIEInDeclContext(const lldb_private::CompilerDeclContext *parent_decl_ctx,
-                   const DWARFDIE &die);
-
   virtual DWARFUnit *
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
 
   DWARFUnit *GetNextUnparsedDWARFCompileUnit(DWARFUnit *prev_cu);
 
   bool GetFunction(const DWARFDIE &die, lldb_private::SymbolContext &sc);
 
   lldb_private::Function *
protected:
 
   // Given a die_offset, figure out the symbol context representing that die.
   bool ResolveFunction(const DIERef &die_ref, bool include_inlines,
                        lldb_private::SymbolContextList &sc_list);
 
   bool ResolveFunction(const DWARFDIE &die, bool include_inlines,
                        lldb_private::SymbolContextList &sc_list);
 
-  void FindFunctions(const lldb_private::ConstString &name,
-                     const NameToDIE &name_to_die, bool include_inlines,
-                     lldb_private::SymbolContextList &sc_list);
-
-  void FindFunctions(const lldb_private::RegularExpression &regex,
-                     const NameToDIE &name_to_die, bool include_inlines,
-                     lldb_private::SymbolContextList &sc_list);
-
-  void FindFunctions(const lldb_private::RegularExpression &regex,
-                     const DWARFMappedHash::MemoryTable &memory_table,
-                     bool include_inlines,
-                     lldb_private::SymbolContextList &sc_list);
-
   virtual lldb::TypeSP
   FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx);
 
   virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, const lldb_private::ConstString &type_name,
       bool must_be_implementation);
 
   lldb_private::Symbol *
   GetObjCClassSymbol(const lldb_private::ConstString &objc_class_name);
 
-  void ParseFunctions(const DIEArray &die_offsets, bool include_inlines,
-                      lldb_private::SymbolContextList &sc_list);
-
   lldb::TypeSP GetTypeForDIE(const DWARFDIE &die,
                              bool resolve_function_context = false);
 
-  void Index();
-
   void DumpIndexes();
 
   void SetDebugMapModule(const lldb::ModuleSP &module_sp) {
     m_debug_map_module_wp = module_sp;
   }
 
   SymbolFileDWARFDebugMap *GetDebugMapSymfile();
 
protected:
   DWARFDataSegment m_data_gnu_debugaltlink;
 
   // The unique pointer items below are generated on demand if and when someone
   // accesses
   // them through a non const version of this class.
   std::unique_ptr<DWARFDebugAbbrev> m_abbr;
   std::unique_ptr<DWARFDebugInfo> m_info;
   std::unique_ptr<DWARFDebugLine> m_line;
-  std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_names_ap;
-  std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_types_ap;
-  std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_namespaces_ap;
-  std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_objc_ap;
   std::unique_ptr<GlobalVariableMap> m_global_aranges_ap;
 
   typedef std::unordered_map<lldb::offset_t, lldb_private::DebugMacrosSP>
       DebugMacrosMap;
   DebugMacrosMap m_debug_macros_map;
 
   ExternalTypeModuleMap m_external_type_modules;
-  NameToDIE m_function_basename_index; // All concrete functions
-  NameToDIE m_function_fullname_index; // All concrete functions
-  NameToDIE m_function_method_index;   // All inlined functions
-  NameToDIE
-      m_function_selector_index; // All method names for functions of classes
-  NameToDIE m_objc_class_selectors_index; // Given a class name, find all
-                                          // selectors for the class
-  NameToDIE m_global_index;               // Global and static variables
-  NameToDIE m_type_index;                 // All type DIE offsets
-  NameToDIE m_namespace_index;            // All type DIE offsets
-  bool m_indexed : 1, m_using_apple_tables : 1, m_fetched_external_modules : 1;
+  std::unique_ptr<lldb_private::DWARFIndex> m_index;
+  bool m_fetched_external_modules : 1;
   lldb_private::LazyBool m_supports_DW_AT_APPLE_objc_complete_type;
 
   typedef std::shared_ptr<std::set<DIERef>> DIERefSetSP;
   typedef std::unordered_map<std::string, DIERefSetSP> NameToOffsetMap;
   NameToOffsetMap m_function_scope_qualified_name_map;
   std::unique_ptr<DWARFDebugRanges> m_ranges;
   UniqueDWARFASTTypeMap m_unique_ast_type_map;
   DIEToTypePtr m_die_to_type;
   DIEToVariableSP m_die_to_variable_sp;
   DIEToClangType m_forward_decl_die_to_clang_type;
   ClangTypeToDIE m_forward_decl_clang_type_to_die;
 };
 
 #endif // SymbolFileDWARF_SymbolFileDWARF_h_

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

 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 
-#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
-#include "Plugins/Language/ObjC/ObjCLanguage.h"
-
 #include "lldb/Target/Language.h"
 
-#include "lldb/Host/TaskPool.h"
-
+#include "AppleDWARFIndex.h"
 #include "DWARFASTParser.h"
 #include "DWARFASTParserClang.h"
-#include "DWARFUnit.h"
 #include "DWARFDIECollection.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugLine.h"
 #include "DWARFDebugMacro.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
+#include "DWARFUnit.h"
 #include "LogChannelDWARF.h"
+#include "ManualDWARFIndex.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDwp.h"
 
 #include "llvm/Support/FileSystem.h"
 
 #include <map>
 
for (die = child_die.GetParent(); die; die = die.GetParent()) {
     case DW_TAG_lexical_block:
       return die;
     }
   }
   return DWARFDIE();
 }
 
 SymbolFileDWARF::SymbolFileDWARF(ObjectFile *objfile)
-    : SymbolFile(objfile),
-      UserID(uint64_t(DW_INVALID_OFFSET) << 32), // Used by SymbolFileDWARFDebugMap to when
-                                                 // this class parses .o files to contain
-                                                 // the .o file index/ID
+    : SymbolFile(objfile), UserID(uint64_t(DW_INVALID_OFFSET)
+                                  << 32), // Used by SymbolFileDWARFDebugMap to
+                                          // when this class parses .o files to
+                                          // contain the .o file index/ID
       m_debug_map_module_wp(), m_debug_map_symfile(NULL), m_data_debug_abbrev(),
       m_data_debug_aranges(), m_data_debug_frame(), m_data_debug_info(),
       m_data_debug_line(), m_data_debug_macro(), m_data_debug_loc(),
       m_data_debug_ranges(), m_data_debug_str(), m_data_apple_names(),
       m_data_apple_types(), m_data_apple_namespaces(), m_abbr(), m_info(),
-      m_line(), m_apple_names_ap(), m_apple_types_ap(), m_apple_namespaces_ap(),
-      m_apple_objc_ap(), m_function_basename_index(),
-      m_function_fullname_index(), m_function_method_index(),
-      m_function_selector_index(), m_objc_class_selectors_index(),
-      m_global_index(), m_type_index(), m_namespace_index(), m_indexed(false),
-      m_using_apple_tables(false), m_fetched_external_modules(false),
+      m_line(), m_fetched_external_modules(false),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate), m_ranges(),
       m_unique_ast_type_map() {}
 
 SymbolFileDWARF::~SymbolFileDWARF() {}
 
 static const ConstString &GetDWARFMachOSegmentName() {
   static ConstString g_dwarf_section_name("__DWARF");
   return g_dwarf_section_name;
if (module_sp) {
     const SectionList *section_list = module_sp->GetSectionList();
     Section *section =
         section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();
 
     if (section)
       m_obj_file->ReadSectionData(section, m_dwarf_data);
   }
 
-  get_apple_names_data();
-  if (m_data_apple_names.m_data.GetByteSize() > 0) {
-    m_apple_names_ap.reset(new DWARFMappedHash::MemoryTable(
-        m_data_apple_names.m_data, get_debug_str_data(), ".apple_names"));
-    if (m_apple_names_ap->IsValid())
-      m_using_apple_tables = true;
-    else
-      m_apple_names_ap.reset();
-  }
-  get_apple_types_data();
-  if (m_data_apple_types.m_data.GetByteSize() > 0) {
-    m_apple_types_ap.reset(new DWARFMappedHash::MemoryTable(
-        m_data_apple_types.m_data, get_debug_str_data(), ".apple_types"));
-    if (m_apple_types_ap->IsValid())
-      m_using_apple_tables = true;
-    else
-      m_apple_types_ap.reset();
-  }
-
-  get_apple_namespaces_data();
-  if (m_data_apple_namespaces.m_data.GetByteSize() > 0) {
-    m_apple_namespaces_ap.reset(new DWARFMappedHash::MemoryTable(
-        m_data_apple_namespaces.m_data, get_debug_str_data(),
-        ".apple_namespaces"));
-    if (m_apple_namespaces_ap->IsValid())
-      m_using_apple_tables = true;
-    else
-      m_apple_namespaces_ap.reset();
-  }
-
-  get_apple_objc_data();
-  if (m_data_apple_objc.m_data.GetByteSize() > 0) {
-    m_apple_objc_ap.reset(new DWARFMappedHash::MemoryTable(
-        m_data_apple_objc.m_data, get_debug_str_data(), ".apple_objc"));
-    if (m_apple_objc_ap->IsValid())
-      m_using_apple_tables = true;
-    else
-      m_apple_objc_ap.reset();
-  }
+  DWARFDataExtractor apple_names, apple_namespaces, apple_types, apple_objc;
+  LoadSectionData(eSectionTypeDWARFAppleNames, apple_names);
+  LoadSectionData(eSectionTypeDWARFAppleNamespaces, apple_namespaces);
+  LoadSectionData(eSectionTypeDWARFAppleTypes, apple_types);
+  LoadSectionData(eSectionTypeDWARFAppleObjC, apple_objc);
+
+  m_index = AppleDWARFIndex::Create(*GetObjectFile()->GetModule(), apple_names,
+                                    apple_namespaces, apple_types, apple_objc,
+                                    get_debug_str_data());
+
+  if (!m_index)
+    m_index = llvm::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(),
+                                                  DebugInfo());
 }
 
 bool SymbolFileDWARF::SupportedVersion(uint16_t version) {
   return version == 2 || version == 3 || version == 4;
 }
 
 uint32_t SymbolFileDWARF::CalculateAbilities() {
   uint32_t abilities = 0;
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();
-  if (m_using_apple_tables) {
-    if (m_apple_objc_ap.get())
-      m_apple_objc_ap->FindByName(class_name.GetStringRef(),
-                                  method_die_offsets);
-  } else {
-    if (!m_indexed)
-      Index();
-
-    m_objc_class_selectors_index.Find(class_name, method_die_offsets);
-  }
+  m_index->GetObjCMethods(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?
if (resolve_scope & eSymbolContextCompUnit) {
     }
   }
   return sc_list.GetSize() - prev_size;
 }
 
 void SymbolFileDWARF::PreloadSymbols() {
   std::lock_guard<std::recursive_mutex> guard(
       GetObjectFile()->GetModule()->GetMutex());
-  Index();
-}
-
-void SymbolFileDWARF::Index() {
-  if (m_indexed)
-    return;
-  m_indexed = true;
-  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
-  Timer scoped_timer(
-      func_cat, "SymbolFileDWARF::Index (%s)",
-      GetObjectFile()->GetFileSpec().GetFilename().AsCString("<Unknown>"));
-
-  DWARFDebugInfo *debug_info = DebugInfo();
-  if (debug_info) {
-    const uint32_t num_compile_units = GetNumCompileUnits();
-    if (num_compile_units == 0)
-      return;
-
-    std::vector<NameToDIE> function_basename_index(num_compile_units);
-    std::vector<NameToDIE> function_fullname_index(num_compile_units);
-    std::vector<NameToDIE> function_method_index(num_compile_units);
-    std::vector<NameToDIE> function_selector_index(num_compile_units);
-    std::vector<NameToDIE> objc_class_selectors_index(num_compile_units);
-    std::vector<NameToDIE> global_index(num_compile_units);
-    std::vector<NameToDIE> type_index(num_compile_units);
-    std::vector<NameToDIE> namespace_index(num_compile_units);
-
-    // std::vector<bool> might be implemented using bit test-and-set, so use
-    // uint8_t instead.
-    std::vector<uint8_t> clear_cu_dies(num_compile_units, false);
-    auto parser_fn = [debug_info, &function_basename_index,
-                      &function_fullname_index, &function_method_index,
-                      &function_selector_index, &objc_class_selectors_index,
-                      &global_index, &type_index,
-                      &namespace_index](size_t cu_idx) {
-      DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
-      if (dwarf_cu) {
-        dwarf_cu->Index(
-            function_basename_index[cu_idx], function_fullname_index[cu_idx],
-            function_method_index[cu_idx], function_selector_index[cu_idx],
-            objc_class_selectors_index[cu_idx], global_index[cu_idx],
-            type_index[cu_idx], namespace_index[cu_idx]);
-      }
-    };
-
-    auto extract_fn = [debug_info, &clear_cu_dies](size_t cu_idx) {
-      DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
-      if (dwarf_cu) {
-        // dwarf_cu->ExtractDIEsIfNeeded(false) will return zero if the DIEs
-        // for a compile unit have already been parsed.
-        if (dwarf_cu->ExtractDIEsIfNeeded(false) > 1)
-          clear_cu_dies[cu_idx] = true;
-      }
-    };
-
-    // Create a task runner that extracts dies for each DWARF compile unit in a
-    // separate thread
-    //----------------------------------------------------------------------
-    // First figure out which compile units didn't have their DIEs already
-    // parsed and remember this.  If no DIEs were parsed prior to this index
-    // function call, we are going to want to clear the CU dies after we are
-    // done indexing to make sure we don't pull in all DWARF dies, but we need
-    // to wait until all compile units have been indexed in case a DIE in one
-    // compile unit refers to another and the indexes accesses those DIEs.
-    //----------------------------------------------------------------------
-    TaskMapOverInt(0, num_compile_units, extract_fn);
-
-    // Now create a task runner that can index each DWARF compile unit in a
-    // separate thread so we can index quickly.
-
-    TaskMapOverInt(0, num_compile_units, parser_fn);
-
-    auto finalize_fn = [](NameToDIE &index, std::vector<NameToDIE> &srcs) {
-      for (auto &src : srcs)
-        index.Append(src);
-      index.Finalize();
-    };
-
-    TaskPool::RunTasks(
-        [&]() {
-          finalize_fn(m_function_basename_index, function_basename_index);
-        },
-        [&]() {
-          finalize_fn(m_function_fullname_index, function_fullname_index);
-        },
-        [&]() { finalize_fn(m_function_method_index, function_method_index); },
-        [&]() {
-          finalize_fn(m_function_selector_index, function_selector_index);
-        },
-        [&]() {
-          finalize_fn(m_objc_class_selectors_index, objc_class_selectors_index);
-        },
-        [&]() { finalize_fn(m_global_index, global_index); },
-        [&]() { finalize_fn(m_type_index, type_index); },
-        [&]() { finalize_fn(m_namespace_index, namespace_index); });
-
-    //----------------------------------------------------------------------
-    // Keep memory down by clearing DIEs for any compile units if indexing
-    // caused us to load the compile unit's DIEs.
-    //----------------------------------------------------------------------
-    for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
-      if (clear_cu_dies[cu_idx])
-        debug_info->GetCompileUnitAtIndex(cu_idx)->ClearDIEs(true);
-    }
-
-#if defined(ENABLE_DEBUG_PRINTF)
-    StreamFile s(stdout, false);
-    s.Printf("DWARF index for '%s':",
-             GetObjectFile()->GetFileSpec().GetPath().c_str());
-    s.Printf("\nFunction basenames:\n");
-    m_function_basename_index.Dump(&s);
-    s.Printf("\nFunction fullnames:\n");
-    m_function_fullname_index.Dump(&s);
-    s.Printf("\nFunction methods:\n");
-    m_function_method_index.Dump(&s);
-    s.Printf("\nFunction selectors:\n");
-    m_function_selector_index.Dump(&s);
-    s.Printf("\nObjective C class selectors:\n");
-    m_objc_class_selectors_index.Dump(&s);
-    s.Printf("\nGlobals and statics:\n");
-    m_global_index.Dump(&s);
-    s.Printf("\nTypes:\n");
-    m_type_index.Dump(&s);
-    s.Printf("\nNamespaces:\n");
-    m_namespace_index.Dump(&s);
-#endif
-  }
+  m_index->Preload();
 }
 
 bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
     const lldb_private::CompilerDeclContext *decl_ctx) {
   if (decl_ctx == nullptr || !decl_ctx->IsValid()) {
     // Invalid namespace decl which means we aren't matching only things in
     // this symbol file, so return true to indicate it matches this symbol
     // file.
uint32_t SymbolFileDWARF::FindGlobalVariables(
   if (!append)
     variables.Clear();
 
   // Remember how many variables are in the list before we search in case we
   // are appending the results to a variable list.
   const uint32_t original_size = variables.GetSize();
 
   DIEArray die_offsets;
-
-  if (m_using_apple_tables) {
-    if (m_apple_names_ap.get()) {
-      const char *name_cstr = name.GetCString();
-      llvm::StringRef basename;
-      llvm::StringRef context;
-
-      if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
-                                                          basename))
-        basename = name_cstr;
-
-      m_apple_names_ap->FindByName(basename, die_offsets);
-    }
-  } else {
-    // Index the DWARF if we haven't already
-    if (!m_indexed)
-      Index();
-
-    m_global_index.Find(name, die_offsets);
-  }
-
+  m_index->GetGlobalVariables(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
   if (num_die_matches) {
     SymbolContext sc;
     sc.module_sp = m_obj_file->GetModule();
     assert(sc.module_sp);
 
     bool done = false;
     for (size_t i = 0; i < num_die_matches && !done; ++i) {
for (size_t i = 0; i < num_die_matches && !done; ++i) {
           ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false,
                          &variables);
 
           if (variables.GetSize() - original_size >= max_matches)
             done = true;
         } break;
         }
       } else {
-        if (m_using_apple_tables) {
-          GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-              "the DWARF debug information has been modified (.apple_names "
-              "accelerator table had bad die 0x%8.8x for '%s')\n",
-              die_ref.die_offset, name.GetCString());
-        }
+        m_index->ReportInvalidDIEOffset(die_ref.die_offset,
+                                        name.GetStringRef());
       }
     }
   }
 
   // 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(
uint32_t SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
   if (!append)
     variables.Clear();
 
   // Remember how many variables are in the list before we search in case we
   // are appending the results to a variable list.
   const uint32_t original_size = variables.GetSize();
 
   DIEArray die_offsets;
-
-  if (m_using_apple_tables) {
-    if (m_apple_names_ap.get()) {
-      DWARFMappedHash::DIEInfoArray hash_data_array;
-      if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex(regex,
-                                                           hash_data_array))
-        DWARFMappedHash::ExtractDIEArray(hash_data_array, die_offsets);
-    }
-  } else {
-    // Index the DWARF if we haven't already
-    if (!m_indexed)
-      Index();
-
-    m_global_index.Find(regex, die_offsets);
-  }
+  m_index->GetGlobalVariables(regex, die_offsets);
 
   SymbolContext sc;
   sc.module_sp = m_obj_file->GetModule();
   assert(sc.module_sp);
 
   const size_t num_matches = die_offsets.size();
   if (num_matches) {
     for (size_t i = 0; i < num_matches; ++i) {
       const DIERef &die_ref = die_offsets[i];
       DWARFDIE die = GetDIE(die_ref);
 
       if (die) {
         sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX);
 
         ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
 
         if (variables.GetSize() - original_size >= max_matches)
           break;
-      } else {
-        if (m_using_apple_tables) {
-          GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-              "the DWARF debug information has been modified (.apple_names "
-              "accelerator table had bad die 0x%8.8x for regex '%s')\n",
-              die_ref.die_offset, regex.GetText().str().c_str());
-        }
-      }
+      } else
+        m_index->ReportInvalidDIEOffset(die_ref.die_offset, regex.GetText());
     }
   }
 
   // Return the number of variable that were appended to the list
   return variables.GetSize() - original_size;
 }
 
 bool SymbolFileDWARF::ResolveFunction(const DIERef &die_ref,
if (addr.IsValid()) {
       sc_list.Append(sc);
       return true;
     }
   }
 
   return false;
 }
 
-void SymbolFileDWARF::FindFunctions(const ConstString &name,
-                                    const NameToDIE &name_to_die,
-                                    bool include_inlines,
-                                    SymbolContextList &sc_list) {
-  DIEArray die_offsets;
-  if (name_to_die.Find(name, die_offsets)) {
-    ParseFunctions(die_offsets, include_inlines, sc_list);
-  }
-}
-
-void SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
-                                    const NameToDIE &name_to_die,
-                                    bool include_inlines,
-                                    SymbolContextList &sc_list) {
-  DIEArray die_offsets;
-  if (name_to_die.Find(regex, die_offsets)) {
-    ParseFunctions(die_offsets, include_inlines, sc_list);
-  }
-}
-
-void SymbolFileDWARF::FindFunctions(
-    const RegularExpression &regex,
-    const DWARFMappedHash::MemoryTable &memory_table, bool include_inlines,
-    SymbolContextList &sc_list) {
-  DIEArray die_offsets;
-  DWARFMappedHash::DIEInfoArray hash_data_array;
-  if (memory_table.AppendAllDIEsThatMatchingRegex(regex, hash_data_array)) {
-    DWARFMappedHash::ExtractDIEArray(hash_data_array, die_offsets);
-    ParseFunctions(die_offsets, include_inlines, sc_list);
-  }
-}
-
-void SymbolFileDWARF::ParseFunctions(const DIEArray &die_offsets,
-                                     bool include_inlines,
-                                     SymbolContextList &sc_list) {
-  const size_t num_matches = die_offsets.size();
-  if (num_matches) {
-    for (size_t i = 0; i < num_matches; ++i)
-      ResolveFunction(die_offsets[i], include_inlines, sc_list);
-  }
-}
-
 bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *decl_ctx,
                                        const DWARFDIE &die) {
   // If we have no parent decl context to match this DIE matches, and if the
   // parent decl context isn't valid, we aren't trying to look for any
   // particular decl context so any die matches.
   if (decl_ctx == nullptr || !decl_ctx->IsValid())
     return true;
 
SymbolFileDWARF::FindFunctions(const ConstString &name,
   // appending the results to a variable list.
 
   const uint32_t original_size = sc_list.GetSize();
 
   DWARFDebugInfo *info = DebugInfo();
   if (info == NULL)
     return 0;
 
-  std::set<const DWARFDebugInfoEntry *> resolved_dies;
-  if (m_using_apple_tables) {
-    if (m_apple_names_ap.get()) {
-
-      DIEArray die_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_ap->FindByName(name.GetStringRef(), die_offsets);
-        for (uint32_t i = 0; i < num_matches; i++) {
-          const DIERef &die_ref = die_offsets[i];
-          DWARFDIE die = info->GetDIE(die_ref);
-          if (die) {
-            if (!DIEInDeclContext(parent_decl_ctx, die))
-              continue; // The containing decl contexts don't match
-
-            if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
-              if (ResolveFunction(die, include_inlines, sc_list))
-                resolved_dies.insert(die.GetDIE());
-            }
-          } else {
-            GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-                "the DWARF debug information has been modified (.apple_names "
-                "accelerator table had bad die 0x%8.8x for '%s')",
-                die_ref.die_offset, name.GetCString());
-          }
-        }
-      }
-
-      if (name_type_mask & eFunctionNameTypeSelector) {
-        if (parent_decl_ctx && parent_decl_ctx->IsValid())
-          return 0; // no selectors in namespaces
-
-        num_matches =
-            m_apple_names_ap->FindByName(name.GetStringRef(), die_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 = die_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 (ResolveFunction(die, include_inlines, sc_list))
-                  resolved_dies.insert(die.GetDIE());
-              }
-            }
-          } else {
-            GetObjectFile()->GetModule()->ReportError(
-                "the DWARF debug information has been modified (.apple_names "
-                "accelerator table had bad die 0x%8.8x for '%s')",
-                die_ref.die_offset, name.GetCString());
-          }
-        }
-        die_offsets.clear();
-      }
-
-      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_ap->FindByName(name.GetStringRef(), die_offsets);
-
-        for (uint32_t i = 0; i < num_matches; i++) {
-          const DIERef &die_ref = die_offsets[i];
-          DWARFDIE die = info->GetDIE(die_ref);
-          if (die) {
-            if (!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() &&
-                ResolveFunction(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 =
-                          GetDeclContextContainingUID(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 {
-                      GetObjectFile()->GetModule()->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 {
-            GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-                "the DWARF debug information has been modified (.apple_names "
-                "accelerator table had bad die 0x%8.8x for '%s')",
-                die_ref.die_offset, name.GetCString());
-          }
-        }
-        die_offsets.clear();
-      }
-    }
-  } else {
-
-    // Index the DWARF if we haven't already
-    if (!m_indexed)
-      Index();
-
-    DIEArray die_offsets;
-    if (name_type_mask & eFunctionNameTypeFull) {
-      uint32_t num_matches = m_function_basename_index.Find(name, die_offsets);
-      num_matches += m_function_method_index.Find(name, die_offsets);
-      num_matches += m_function_fullname_index.Find(name, die_offsets);
-      for (uint32_t i = 0; i < num_matches; i++) {
-        const DIERef &die_ref = die_offsets[i];
-        DWARFDIE die = info->GetDIE(die_ref);
-        if (die) {
-          if (!DIEInDeclContext(parent_decl_ctx, die))
-            continue; // The containing decl contexts don't match
-
-          if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
-            if (ResolveFunction(die, include_inlines, sc_list))
-              resolved_dies.insert(die.GetDIE());
-          }
-        }
-      }
-      die_offsets.clear();
-    }
-    if (name_type_mask & eFunctionNameTypeBase) {
-      uint32_t num_base = m_function_basename_index.Find(name, die_offsets);
-      for (uint32_t i = 0; i < num_base; i++) {
-        DWARFDIE die = info->GetDIE(die_offsets[i]);
-        if (die) {
-          if (!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()) {
-            if (ResolveFunction(die, include_inlines, sc_list))
-              resolved_dies.insert(die.GetDIE());
-          }
-        }
-      }
-      die_offsets.clear();
-    }
-
-    if (name_type_mask & eFunctionNameTypeMethod) {
-      if (parent_decl_ctx && parent_decl_ctx->IsValid())
-        return 0; // no methods in namespaces
-
-      uint32_t num_base = m_function_method_index.Find(name, die_offsets);
-      {
-        for (uint32_t i = 0; i < num_base; i++) {
-          DWARFDIE die = info->GetDIE(die_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 (ResolveFunction(die, include_inlines, sc_list))
-                resolved_dies.insert(die.GetDIE());
-            }
-          }
-        }
-      }
-      die_offsets.clear();
-    }
-
-    if ((name_type_mask & eFunctionNameTypeSelector) &&
-        (!parent_decl_ctx || !parent_decl_ctx->IsValid())) {
-      FindFunctions(name, m_function_selector_index, include_inlines, sc_list);
-    }
-  }
+  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);
 
   // 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) => "
GetObjectFile()->GetModule()->LogMessage(
         "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)",
         regex.GetText().str().c_str(), append);
   }
 
   // If we aren't appending the results to this list, then clear the list
   if (!append)
     sc_list.Clear();
 
+  DWARFDebugInfo *info = DebugInfo();
+  if (!info)
+    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.
   uint32_t original_size = sc_list.GetSize();
 
-  if (m_using_apple_tables) {
-    if (m_apple_names_ap.get())
-      FindFunctions(regex, *m_apple_names_ap, include_inlines, sc_list);
-  } else {
-    // Index the DWARF if we haven't already
-    if (!m_indexed)
-      Index();
-
-    FindFunctions(regex, m_function_basename_index, include_inlines, sc_list);
-
-    FindFunctions(regex, m_function_fullname_index, include_inlines, sc_list);
-  }
+  m_index->GetFunctions(regex, *info,
+                        [this](const DWARFDIE &die, bool include_inlines,
+                               lldb_private::SymbolContextList &sc_list) {
+                          return ResolveFunction(die, include_inlines, sc_list);
+                        },
+                        include_inlines, sc_list);
 
   // Return the number of variable that were appended to the list
   return sc_list.GetSize() - original_size;
 }
 
 void SymbolFileDWARF::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
     std::vector<ConstString> &mangled_names) {
else
                "NULL, append=%u, max_matches=%u, type_list)",
           name.GetCString(), append, max_matches);
   }
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
 
   DIEArray die_offsets;
-
-  if (m_using_apple_tables) {
-    if (m_apple_types_ap.get()) {
-      m_apple_types_ap->FindByName(name.GetStringRef(), die_offsets);
-    }
-  } else {
-    if (!m_indexed)
-      Index();
-
-    m_type_index.Find(name, die_offsets);
-  }
-
+  m_index->GetTypes(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   if (num_die_matches) {
     const uint32_t initial_types_size = types.GetSize();
     for (size_t i = 0; i < num_die_matches; ++i) {
       const DIERef &die_ref = die_offsets[i];
       DWARFDIE die = GetDIE(die_ref);
 
       if (die) {
         if (!DIEInDeclContext(parent_decl_ctx, die))
           continue; // The containing decl contexts don't match
 
         Type *matching_type = ResolveType(die, true, true);
         if (matching_type) {
           // 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;
         }
       } else {
-        if (m_using_apple_tables) {
-          GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-              "the DWARF debug information has been modified (.apple_types "
-              "accelerator table had bad die 0x%8.8x for '%s')\n",
-              die_ref.die_offset, name.GetCString());
-        }
+        m_index->ReportInvalidDIEOffset(die_ref.die_offset,
+                                        name.GetStringRef());
       }
     }
     const uint32_t num_matches = types.GetSize() - initial_types_size;
     if (log && num_matches) {
       if (parent_decl_ctx) {
         GetObjectFile()->GetModule()->LogMessage(
             log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
                  "= %p (\"%s\"), append=%u, max_matches=%u, type_list) => %u",

 size_t SymbolFileDWARF::FindTypes(const std::vector<CompilerContext> &context,
                                   bool append, TypeMap &types) {
   if (!append)
     types.Clear();
 
   if (context.empty())
     return 0;
 
-  DIEArray die_offsets;
-
   ConstString name = context.back().name;
 
   if (!name)
     return 0;
 
-  if (m_using_apple_tables) {
-    if (m_apple_types_ap.get()) {
-      m_apple_types_ap->FindByName(name.GetStringRef(), die_offsets);
-    }
-  } else {
-    if (!m_indexed)
-      Index();
-
-    m_type_index.Find(name, die_offsets);
-  }
-
+  DIEArray die_offsets;
+  m_index->GetTypes(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   if (num_die_matches) {
     size_t num_matches = 0;
     for (size_t i = 0; i < num_die_matches; ++i) {
       const DIERef &die_ref = die_offsets[i];
       DWARFDIE die = GetDIE(die_ref);
 
       if (die) {
         std::vector<CompilerContext> die_context;
         die.GetDWOContext(die_context);
         if (die_context != context)
           continue;
 
         Type *matching_type = ResolveType(die, true, true);
         if (matching_type) {
           // We found a type pointer, now find the shared pointer form our type
           // list
           types.InsertUnique(matching_type->shared_from_this());
           ++num_matches;
         }
       } else {
-        if (m_using_apple_tables) {
-          GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-              "the DWARF debug information has been modified (.apple_types "
-              "accelerator table had bad die 0x%8.8x for '%s')\n",
-              die_ref.die_offset, name.GetCString());
-        }
+        m_index->ReportInvalidDIEOffset(die_ref.die_offset,
+                                        name.GetStringRef());
       }
     }
     return num_matches;
   }
   return 0;
 }
 
 CompilerDeclContext
SymbolFileDWARF::FindNamespace(const SymbolContext &sc, const ConstString &name,
   CompilerDeclContext namespace_decl_ctx;
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return namespace_decl_ctx;
 
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
     DIEArray die_offsets;
-
-    // Index if we already haven't to make sure the compile units get indexed
-    // and make their global DIE index list
-    if (m_using_apple_tables) {
-      if (m_apple_namespaces_ap.get()) {
-        m_apple_namespaces_ap->FindByName(name.GetStringRef(), die_offsets);
-      }
-    } else {
-      if (!m_indexed)
-        Index();
-
-      m_namespace_index.Find(name, die_offsets);
-    }
-
+    m_index->GetNamespaces(name, die_offsets);
     const size_t num_matches = die_offsets.size();
     if (num_matches) {
       for (size_t i = 0; i < num_matches; ++i) {
         const DIERef &die_ref = die_offsets[i];
         DWARFDIE die = GetDIE(die_ref);
 
         if (die) {
           if (!DIEInDeclContext(parent_decl_ctx, die))
             continue; // The containing decl contexts don't match
 
           DWARFASTParser *dwarf_ast = die.GetDWARFParser();
           if (dwarf_ast) {
             namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
             if (namespace_decl_ctx)
               break;
           }
         } else {
-          if (m_using_apple_tables) {
-            GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-                "the DWARF debug information has been modified "
-                "(.apple_namespaces accelerator table had bad die 0x%8.8x for "
-                "'%s')\n",
-                die_ref.die_offset, name.GetCString());
-          }
+          m_index->ReportInvalidDIEOffset(die_ref.die_offset,
+                                          name.GetStringRef());
         }
       }
     }
   }
   if (log && namespace_decl_ctx) {
     GetObjectFile()->GetModule()->LogMessage(
         log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
              "CompilerDeclContext(%p/%p) \"%s\"",
TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
     bool must_be_implementation) {
 
   TypeSP type_sp;
 
   if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
     return type_sp;
 
   DIEArray die_offsets;
-
-  if (m_using_apple_tables) {
-    if (m_apple_types_ap.get()) {
-      m_apple_types_ap->FindCompleteObjCClassByName(
-          type_name.GetStringRef(), die_offsets, must_be_implementation);
-    }
-  } else {
-    if (!m_indexed)
-      Index();
-
-    m_type_index.Find(type_name, die_offsets);
-  }
+  m_index->GetCompleteObjCClass(type_name, must_be_implementation, die_offsets);
 
   const size_t num_matches = die_offsets.size();
 
   if (num_matches) {
     for (size_t i = 0; i < num_matches; ++i) {
       const DIERef &die_ref = die_offsets[i];
       DWARFDIE type_die = GetDIE(die_ref);
 
for (size_t i = 0; i < num_matches; ++i) {
               if (die)
                 GetDIEToType()[die.GetDIE()] = resolved_type;
               type_sp = resolved_type->shared_from_this();
               break;
             }
           }
         }
       } else {
-        if (m_using_apple_tables) {
-          GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-              "the DWARF debug information has been modified (.apple_types "
-              "accelerator table had bad die 0x%8.8x for '%s')\n",
-              die_ref.die_offset, type_name.GetCString());
-        }
+        m_index->ReportInvalidDIEOffset(die_ref.die_offset,
+                                        type_name.GetStringRef());
       }
     }
   }
   return type_sp;
 }
 
 //----------------------------------------------------------------------
 // This function helps to ensure that the declaration contexts match for two
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;
-
-      if (m_using_apple_tables) {
-        if (m_apple_types_ap.get()) {
-          const bool has_tag =
-              m_apple_types_ap->GetHeader().header_data.ContainsAtom(
-                  DWARFMappedHash::eAtomTypeTag);
-          const bool has_qualified_name_hash =
-              m_apple_types_ap->GetHeader().header_data.ContainsAtom(
-                  DWARFMappedHash::eAtomTypeQualNameHash);
-          if (has_tag && has_qualified_name_hash) {
-            const char *qualified_name = dwarf_decl_ctx.GetQualifiedName();
-            const uint32_t qualified_name_hash = llvm::djbHash(qualified_name);
-            if (log)
-              GetObjectFile()->GetModule()->LogMessage(
-                  log, "FindByNameAndTagAndQualifiedNameHash()");
-            m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash(
-                type_name.GetStringRef(), tag, qualified_name_hash,
-                die_offsets);
-          } else if (has_tag) {
-            if (log)
-              GetObjectFile()->GetModule()->LogMessage(log,
-                                                       "FindByNameAndTag()");
-            m_apple_types_ap->FindByNameAndTag(type_name.GetStringRef(), tag,
-                                               die_offsets);
-          } else {
-            m_apple_types_ap->FindByName(type_name.GetStringRef(), die_offsets);
-          }
-        }
-      } else {
-        if (!m_indexed)
-          Index();
-
-        m_type_index.Find(type_name, 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 = (language == eLanguageTypeUnknown)
                                     ? nullptr
if (type_name) {
                          "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());
               }
             }
           } else {
-            if (m_using_apple_tables) {
-              GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-                  "the DWARF debug information has been modified (.apple_types "
-                  "accelerator table had bad die 0x%8.8x for '%s')\n",
-                  die_ref.die_offset, type_name.GetCString());
-            }
+            m_index->ReportInvalidDIEOffset(die_ref.die_offset,
+                                            type_name.GetStringRef());
           }
         }
       }
     }
   }
   return type_sp;
 }
 
if (sc.function) {
       uint32_t vars_added = 0;
       VariableListSP variables(sc.comp_unit->GetVariableList(false));
 
       if (variables.get() == NULL) {
         variables.reset(new VariableList());
         sc.comp_unit->SetVariableList(variables);
 
         DIEArray die_offsets;
-        if (m_using_apple_tables) {
-          if (m_apple_names_ap.get()) {
-            DWARFMappedHash::DIEInfoArray hash_data_array;
-            if (m_apple_names_ap->AppendAllDIEsInRange(
-                    dwarf_cu->GetOffset(), dwarf_cu->GetNextCompileUnitOffset(),
-                    hash_data_array)) {
-              DWARFMappedHash::ExtractDIEArray(hash_data_array, die_offsets);
-            }
-          }
-        } else {
-          // Index if we already haven't to make sure the compile units get
-          // indexed and make their global DIE index list
-          if (!m_indexed)
-            Index();
-
-          m_global_index.FindAllEntriesForCompileUnit(dwarf_cu->GetOffset(),
-                                                      die_offsets);
-        }
-
+        m_index->GetGlobalVariables(*dwarf_cu, die_offsets);
         const size_t num_matches = die_offsets.size();
         if (num_matches) {
           for (size_t i = 0; i < num_matches; ++i) {
             const DIERef &die_ref = die_offsets[i];
             DWARFDIE die = GetDIE(die_ref);
             if (die) {
               VariableSP var_sp(
                   ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
               if (var_sp) {
                 variables->AddVariableIfUnique(var_sp);
                 ++vars_added;
               }
-            } else {
-              if (m_using_apple_tables) {
-                GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
-                    "the DWARF debug information has been modified "
-                    "(.apple_names accelerator table had bad die 0x%8.8x)\n",
-                    die_ref.die_offset);
-              }
-            }
+            } else
+              m_index->ReportInvalidDIEOffset(die_ref.die_offset, "");
           }
         }
       }
       return vars_added;
     }
   }
   return 0;
 }

 // PluginInterface protocol
 //------------------------------------------------------------------
 ConstString SymbolFileDWARF::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t SymbolFileDWARF::GetPluginVersion() { return 1; }
 
 void SymbolFileDWARF::DumpIndexes() {
   StreamFile s(stdout, false);
-
-  s.Printf(
-      "DWARF index for (%s) '%s':",
-      GetObjectFile()->GetModule()->GetArchitecture().GetArchitectureName(),
-      GetObjectFile()->GetFileSpec().GetPath().c_str());
-  s.Printf("\nFunction basenames:\n");
-  m_function_basename_index.Dump(&s);
-  s.Printf("\nFunction fullnames:\n");
-  m_function_fullname_index.Dump(&s);
-  s.Printf("\nFunction methods:\n");
-  m_function_method_index.Dump(&s);
-  s.Printf("\nFunction selectors:\n");
-  m_function_selector_index.Dump(&s);
-  s.Printf("\nObjective C class selectors:\n");
-  m_objc_class_selectors_index.Dump(&s);
-  s.Printf("\nGlobals and statics:\n");
-  m_global_index.Dump(&s);
-  s.Printf("\nTypes:\n");
-  m_type_index.Dump(&s);
-  s.Printf("\nNamespaces:\n");
-  m_namespace_index.Dump(&s);
+  m_index->Dump(s);
 }
 
 SymbolFileDWARFDebugMap *SymbolFileDWARF::GetDebugMapSymfile() {
   if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired()) {
     lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
     if (module_sp) {
       SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
       if (sym_vendor)