[DWARF] Add (empty) DebugNamesDWARFIndex class and a setting to control its use

[labath]

Summary

This patch is pretty much a big noop. It adds the ability to create a
DebugNamesDWARFIndex class, but the class itself is not implemented in
any useful way. The I am putting it up this way is because of the
setting to control whether it gets used. My idea for it was the
following:

• while the feature is under development (which hopefully won't take much longer), it will default to off. Tests will override it to true.
• once the feature is complete and we are reasonably certain it works, we flip the switch to "on" while keeping the ability to turn it off for troubleshooting purposes.
• after it has been on for a release or two and it hasn't blown up into anyone's face, we remove the setting altogether.

[clayborg]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

131

Would it be better to use an inverse setting like "always-manually-index"? That way if there is something wrong with any of the indexes that are generated, then we can fall back to manually indexing? Otherwise we will need to remove this later.

[labath]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

131

In the interests of non-proliferation of settings I have deliberately chosen a path that does not make the setting permanent. However, this does sound like a thing that could conceivably be useful as a setting in general, so I can do that too if you think it's better.

Would you then also make the setting non-experimental?

[labath]

This makes the setting non-experimental and renames it to "ignore-file-indexes".
I've also wired up the index dump methods to Module::Dump so that I could write
a test that apple indexes are indeed being used after this.

[clayborg]

I like this new setting much better. Looks good.

include/lldb/Symbol/SymbolFile.h

public:
   const ObjectFile *GetObjectFile() const { return m_obj_file; }
 
   //------------------------------------------------------------------
   /// Notify the SymbolFile that the file addresses in the Sections
   /// for this module have been changed.
   //------------------------------------------------------------------
   virtual void SectionFileAddressesChanged() {}
 
+  virtual void Dump(Stream &s) {}
+
 protected:
   ObjectFile *m_obj_file; // The object file that symbols can be extracted from.
   uint32_t m_abilities;
   bool m_calculated_abilities;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(SymbolFile);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_SymbolFile_h_

lit/SymbolFile/DWARF/apple-index-is-used.cpp

+// Test that we use the apple indexes.
+// RUN: clang %s -g -c -o %t --target=x86_64-apple-macosx
+// RUN: lldb-test symbols %t | FileCheck %s
+
+// CHECK: .apple_names index present
+// CHECK: .apple_types index present
+
+int foo;

source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

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.
+  if (m_apple_names_up)
+    s.PutCString(".apple_names index present\n");
+  if (m_apple_namespaces_up)
+    s.PutCString(".apple_namespaces index present\n");
+  if (m_apple_types_up)
+    s.PutCString(".apple_types index present\n");
+  if (m_apple_objc_up)
+    s.PutCString(".apple_objc index present\n");
+  // TODO: Dump index contents
 }

source/Plugins/SymbolFile/DWARF/CMakeLists.txt

 add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
   AppleDWARFIndex.cpp
+  DebugNamesDWARFIndex.cpp
   DIERef.cpp
   DWARFAbbreviationDeclaration.cpp
   DWARFASTParserClang.cpp
   DWARFASTParserGo.cpp
   DWARFASTParserJava.cpp
   DWARFASTParserOCaml.cpp
   DWARFAttribute.cpp
   DWARFBaseDIE.cpp

source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.h

+//===-- DebugNamesDWARFIndex.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_DEBUGNAMESDWARFINDEX_H
+#define LLDB_DEBUGNAMESDWARFINDEX_H
+
+#include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
+#include "lldb/Utility/ConstString.h"
+#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
+
+namespace lldb_private {
+class DebugNamesDWARFIndex : public DWARFIndex {
+public:
+  static llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>>
+  Create(Module &module, DWARFDataExtractor debug_names,
+         DWARFDataExtractor debug_str, DWARFDebugInfo *debug_info);
+
+  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,
+                    const CompilerDeclContext &parent_decl_ctx,
+                    uint32_t name_type_mask,
+                    std::vector<DWARFDIE> &dies) override {}
+  void GetFunctions(const RegularExpression &regex,
+                    DIEArray &offsets) override {}
+
+  void ReportInvalidDIEOffset(dw_offset_t offset,
+                              llvm::StringRef name) override {}
+  void Dump(Stream &s) override {}
+
+private:
+  DebugNamesDWARFIndex(Module &module,
+                       std::unique_ptr<llvm::DWARFDebugNames> debug_names_up,
+                       DWARFDataExtractor debug_names_data,
+                       DWARFDataExtractor debug_str_data,
+                       DWARFDebugInfo *debug_info)
+      : DWARFIndex(module), m_debug_names_up(std::move(debug_names_up)) {}
+
+  // LLVM DWARFDebugNames will hold a non-owning reference to this data, so keep
+  // track of the ownership here.
+  DWARFDataExtractor m_debug_names_data;
+  DWARFDataExtractor m_debug_str_data;
+
+  std::unique_ptr<llvm::DWARFDebugNames> m_debug_names_up;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_DEBUGNAMESDWARFINDEX_H

source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

+//===-- DebugNamesDWARFIndex.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/DebugNamesDWARFIndex.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+static llvm::DWARFDataExtractor ToLLVM(const DWARFDataExtractor &data) {
+  return llvm::DWARFDataExtractor(
+      llvm::StringRef(reinterpret_cast<const char *>(data.GetDataStart()),
+                      data.GetByteSize()),
+      data.GetByteOrder() == eByteOrderLittle, data.GetAddressByteSize());
+}
+
+llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>>
+DebugNamesDWARFIndex::Create(Module &module, DWARFDataExtractor debug_names,
+                             DWARFDataExtractor debug_str,
+                             DWARFDebugInfo *debug_info) {
+  auto index_up = llvm::make_unique<llvm::DWARFDebugNames>(ToLLVM(debug_names),
+                                                           ToLLVM(debug_str));
+  if (llvm::Error E = index_up->extract())
+    return std::move(E);
+
+  return std::unique_ptr<DebugNamesDWARFIndex>(new DebugNamesDWARFIndex(
+      module, std::move(index_up), debug_names, debug_str, debug_info));
+}

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

void ManualDWARFIndex::GetFunctions(const RegularExpression &regex,
                                     DIEArray &offsets) {
   Index();
 
   m_set.function_basenames.Find(regex, offsets);
   m_set.function_fullnames.Find(regex, offsets);
 }
 
 void ManualDWARFIndex::Dump(Stream &s) {
-  s.Format("DWARF index for ({0}) '{1:F}':",
+  s.Format("Manual DWARF index for ({0}) '{1:F}':",
            m_module.GetArchitecture().GetArchitectureName(),
            m_module.GetObjectFile()->GetFileSpec());
   s.Printf("\nFunction basenames:\n");
   m_set.function_basenames.Dump(&s);
   s.Printf("\nFunction fullnames:\n");
   m_set.function_fullnames.Dump(&s);
   s.Printf("\nFunction methods:\n");
   m_set.function_methods.Dump(&s);

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   // 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);
 
+  void Dump(lldb_private::Stream &s) override;
+
 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;
virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       bool must_be_implementation);
 
   lldb_private::Symbol *
   GetObjCClassSymbol(const lldb_private::ConstString &objc_class_name);
 
   lldb::TypeSP GetTypeForDIE(const DWARFDIE &die,
                              bool resolve_function_context = false);
 
-  void DumpIndexes();
-
   void SetDebugMapModule(const lldb::ModuleSP &module_sp) {
     m_debug_map_module_wp = module_sp;
   }
 
   SymbolFileDWARFDebugMap *GetDebugMapSymfile();
 
   DWARFDIE
   FindBlockContainingSpecification(const DIERef &func_die_ref,

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #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 "DebugNamesDWARFIndex.h"
 #include "LogChannelDWARF.h"
 #include "ManualDWARFIndex.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDwp.h"
 
 #include "llvm/Support/FileSystem.h"
 

 //    return false;
 //}
 //
 
 namespace {
 
 PropertyDefinition g_properties[] = {
     {"comp-dir-symlink-paths", OptionValue::eTypeFileSpecList, true, 0, nullptr,
-     nullptr, "If the DW_AT_comp_dir matches any of these paths the symbolic "
-              "links will be resolved at DWARF parse time."},
-    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, nullptr, nullptr}};
+     nullptr,
+     "If the DW_AT_comp_dir matches any of these paths the symbolic "
+    {"ignore-file-indexes", OptionValue::eTypeBoolean, true, 0, nullptr,
+     nullptr,
+     "Ignore indexes present in the object files and always index DWARF "
+     "manually."},
+    {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, nullptr, nullptr},
+};
 
-enum { ePropertySymLinkPaths };
+enum {
+  ePropertySymLinkPaths,
+  ePropertyIgnoreIndexes,
+};
 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return SymbolFileDWARF::GetPluginNameStatic();
   }
 
   PluginProperties() {
     m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
     m_collection_sp->Initialize(g_properties);
   }
 
   FileSpecList &GetSymLinkPaths() {
     OptionValueFileSpecList *option_value =
         m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(
             nullptr, true, ePropertySymLinkPaths);
     assert(option_value);
     return option_value->GetCurrentValue();
   }
+
+  bool IgnoreFileIndexes() const {
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(
+        nullptr, ePropertyIgnoreIndexes, false);
+  }
 };
 
 typedef std::shared_ptr<PluginProperties> SymbolFileDWARFPropertiesSP;
 
 static const SymbolFileDWARFPropertiesSP &GetGlobalPluginProperties() {
   static const auto g_settings_sp(std::make_shared<PluginProperties>());
   return g_settings_sp;
 }
if (debug_map_symfile) {
     type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
     if (type_system)
       type_system->SetSymbolFile(this);
   }
   return type_system;
 }
 
 void SymbolFileDWARF::InitializeObject() {
+  Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
   ModuleSP module_sp(m_obj_file->GetModule());
   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);
   }
 
+  if (!GetGlobalPluginProperties()->IgnoreFileIndexes()) {
     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());
+    m_index = AppleDWARFIndex::Create(
+        *GetObjectFile()->GetModule(), apple_names, apple_namespaces,
+        apple_types, apple_objc, get_debug_str_data());
+
+    if (m_index)
+      return;
+
+    DWARFDataExtractor debug_names;
+    LoadSectionData(eSectionTypeDWARFDebugNames, debug_names);
+    if (debug_names.GetByteSize() > 0) {
+      llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>> index_or =
+          DebugNamesDWARFIndex::Create(*GetObjectFile()->GetModule(),
+                                       debug_names, get_debug_str_data(),
+                                       DebugInfo());
+      if (index_or) {
+        m_index = std::move(*index_or);
+        return;
+      }
+      LLDB_LOG_ERROR(log, index_or.takeError(),
+                     "Unable to read .debug_names data: {0}");
+    }
+  }
 
-  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;

 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 ConstString SymbolFileDWARF::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t SymbolFileDWARF::GetPluginVersion() { return 1; }
 
-void SymbolFileDWARF::DumpIndexes() {
-  StreamFile s(stdout, false);
-  m_index->Dump(s);
-}
+void SymbolFileDWARF::Dump(lldb_private::Stream &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)
         m_debug_map_symfile =

source/Symbol/SymbolVendor.cpp

if (m_sym_file_ap.get()) {
         if (objfile_file_spec) {
           s->PutCString(" (");
           objfile_file_spec.Dump(s);
           s->PutChar(')');
         }
       }
     }
     s->EOL();
+    if (m_sym_file_ap)
+      m_sym_file_ap->Dump(*s);
     s->IndentMore();
     m_type_list.Dump(s, show_context);
 
     CompileUnitConstIter cu_pos, cu_end;
     cu_end = m_compile_units.end();
     for (cu_pos = m_compile_units.begin(); cu_pos != cu_end; ++cu_pos) {
       // We currently only dump the compile units that have been parsed
       if (cu_pos->get())