Add convenience methods to convert LLDB to LLVM data structures.

[JDevlieghere]

Summary

This adds two convenience methods named GetAsLLVM to the LLDB versions of the DWARF DataExtractor and the DWARF context.

[clayborg]

Just wondering if we want to cache the llvm::DWARFContext in the LLDB DWARFContext. See inline comments.

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

69 ↗

(On Diff #209072)

Should we cache this lldb's DWARFContext and just hand out a pointer or reference that is owned by this class? Or are we ok creating temp llvm::DWARFContext objects that we will throw away? Is there any state in llvm::DWARFContext that we wouldn't want to re-create or parse is my main concern.

[JDevlieghere]

Cache the LLVM DWARF context.

[JDevlieghere]

Update use in debug names.

lldb/trunk/include/lldb/Core/Section.h

 class Target;
 
 class SectionList {
 public:
   typedef std::vector<lldb::SectionSP> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
+  const_iterator begin() const { return m_sections.begin(); }
+  const_iterator end() const { return m_sections.end(); }
+  const_iterator begin() { return m_sections.begin(); }
+  const_iterator end() { return m_sections.end(); }
+
   SectionList();
 
   ~SectionList();
 
   SectionList &operator=(const SectionList &rhs);
 
   size_t AddSection(const lldb::SectionSP &section_sp);
 

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

 //===-- DWARFContext.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_PLUGINS_SYMBOLFILE_DWARF_DWARFCONTEXT_H
 #define LLDB_PLUGINS_SYMBOLFILE_DWARF_DWARFCONTEXT_H
 
 #include "DWARFDataExtractor.h"
 #include "lldb/Core/Section.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/Support/Threading.h"
 #include <memory>
 
 namespace lldb_private {
 class DWARFContext {
 private:
   SectionList *m_main_section_list;
   SectionList *m_dwo_section_list;
+  mutable std::unique_ptr<llvm::DWARFContext> m_llvm_context;
 
   struct SectionData {
     llvm::once_flag flag;
     DWARFDataExtractor data;
   };
 
   SectionData m_data_debug_abbrev;
   SectionData m_data_debug_addr;
public:
   const DWARFDataExtractor &getOrLoadLineData();
   const DWARFDataExtractor &getOrLoadLineStrData();
   const DWARFDataExtractor &getOrLoadMacroData();
   const DWARFDataExtractor &getOrLoadRangesData();
   const DWARFDataExtractor &getOrLoadRngListsData();
   const DWARFDataExtractor &getOrLoadStrData();
   const DWARFDataExtractor &getOrLoadStrOffsetsData();
   const DWARFDataExtractor &getOrLoadDebugTypesData();
+
+  llvm::DWARFContext &GetAsLLVM();
 };
 } // namespace lldb_private
 
 #endif

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

return LoadOrGetSection(eSectionTypeDWARFDebugStrOffsets,
                           eSectionTypeDWARFDebugStrOffsetsDwo,
                           m_data_debug_str_offsets);
 }
 
 const DWARFDataExtractor &DWARFContext::getOrLoadDebugTypesData() {
   return LoadOrGetSection(eSectionTypeDWARFDebugTypes,
                           eSectionTypeDWARFDebugTypesDwo, m_data_debug_types);
 }
+
+llvm::DWARFContext &DWARFContext::GetAsLLVM() {
+  if (!m_llvm_context) {
+    llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> section_map;
+    uint8_t addr_size = 0;
+
+    auto AddSection = [&](Section &section) {
+      DataExtractor section_data;
+      section.GetSectionData(section_data);
+
+      // Set the address size the first time we see it.
+      if (addr_size == 0)
+        addr_size = section_data.GetByteSize();
+
+      llvm::StringRef data = llvm::toStringRef(section_data.GetData());
+      llvm::StringRef name = section.GetName().GetStringRef();
+      section_map.try_emplace(
+          name, llvm::MemoryBuffer::getMemBuffer(data, name, false));
+    };
+
+    if (m_main_section_list) {
+      for (auto &section : *m_main_section_list)
+        AddSection(*section);
+    }
+
+    if (m_dwo_section_list) {
+      for (auto &section : *m_dwo_section_list)
+        AddSection(*section);
+    }
+
+    m_llvm_context = llvm::DWARFContext::create(section_map, addr_size);
+  }
+  return *m_llvm_context;
+}

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

 //===-- DWARFDataExtractor.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_DWARFDataExtractor_h_
 #define liblldb_DWARFDataExtractor_h_
 
 #include "lldb/Core/dwarf.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 
 namespace lldb_private {
 
 class DWARFDataExtractor : public DataExtractor {
 public:
   DWARFDataExtractor() = default;
 
   DWARFDataExtractor(const DWARFDataExtractor &data, lldb::offset_t offset,
                      lldb::offset_t length)
       : DataExtractor(data, offset, length) {}
 
   uint64_t GetDWARFInitialLength(lldb::offset_t *offset_ptr) const;
 
   dw_offset_t GetDWARFOffset(lldb::offset_t *offset_ptr) const;
 
   size_t GetDWARFSizeofInitialLength() const { return 4; }
   size_t GetDWARFSizeOfOffset() const { return 4; }
+
+  llvm::DWARFDataExtractor GetAsLLVM() const;
 };
 }
 
 #endif // liblldb_DWARFDataExtractor_h_

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

 //===-- DWARFDataExtractor.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFDataExtractor.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace lldb_private {
 
 uint64_t
 DWARFDataExtractor::GetDWARFInitialLength(lldb::offset_t *offset_ptr) const {
   return GetU32(offset_ptr);
 }
 
 dw_offset_t
 DWARFDataExtractor::GetDWARFOffset(lldb::offset_t *offset_ptr) const {
   return GetMaxU64(offset_ptr, GetDWARFSizeOfOffset());
 }
+
+llvm::DWARFDataExtractor DWARFDataExtractor::GetAsLLVM() const {
+  return llvm::DWARFDataExtractor(
+      llvm::StringRef(reinterpret_cast<const char *>(GetDataStart()),
+                      GetByteSize()),
+      GetByteOrder() == lldb::eByteOrderLittle, GetAddressByteSize());
 }
+} // namespace lldb_private

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

 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.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) {
   if (!debug_info) {
     return llvm::make_error<llvm::StringError>("debug info null",
                                                llvm::inconvertibleErrorCode());
   }
-  auto index_up =
-      llvm::make_unique<DebugNames>(ToLLVM(debug_names), ToLLVM(debug_str));
+  auto index_up = llvm::make_unique<DebugNames>(debug_names.GetAsLLVM(),
+                                                debug_str.GetAsLLVM());
   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));
 }
 
 llvm::DenseSet<dw_offset_t>

lldb/trunk/tools/lldb-test/lldb-test.cpp

for (size_t I = 0; I < Count; ++I) {
     Printer.formatLine("Type: {0}", S->GetTypeAsCString());
     Printer.formatLine("Permissions: {0}", GetPermissionsAsCString(S->GetPermissions()));
     Printer.formatLine("Thread specific: {0:y}", S->IsThreadSpecific());
     Printer.formatLine("VM address: {0:x}", S->GetFileAddress());
     Printer.formatLine("VM size: {0}", S->GetByteSize());
     Printer.formatLine("File size: {0}", S->GetFileSize());
 
     if (opts::object::SectionContents) {
-      DataExtractor Data;
+      lldb_private::DataExtractor Data;
       S->GetSectionData(Data);
       ArrayRef<uint8_t> Bytes = {Data.GetDataStart(), Data.GetDataEnd()};
       Printer.formatBinary("Data: ", Bytes, 0);
     }
 
     if (S->GetType() == eSectionTypeContainer)
       dumpSectionList(Printer, S->GetChildren(), true);
     Printer.NewLine();