[lldb/test] Simplify/generalize YAMLModuleTester

The class only supports a single DWARF unit (needed for my new test), and it
reimplements chunks of object and symbol file classes. We can just make it use
the real thing, save some LOC and get the full feature set.

Differential Revision: https://reviews.llvm.org/D90393

lldb/unittests/Expression/DWARFExpressionTest.cpp

@@ -55,7 +55,7 @@ class DWARFExpressionTester : public YAMLModuleTester {
 public:
   using YAMLModuleTester::YAMLModuleTester;
   llvm::Expected<Scalar> Eval(llvm::ArrayRef<uint8_t> expr) {
-    return ::Evaluate(expr, m_module_sp, m_dwarf_unit.get());
+    return ::Evaluate(expr, m_module_sp, m_dwarf_unit);
   }
 };
 
@@ -77,68 +77,76 @@ TEST(DWARFExpression, DW_OP_pick) {
 
 TEST(DWARFExpression, DW_OP_convert) {
   /// Auxiliary debug info.
-  const char *yamldata =
-      "debug_abbrev:\n"
-      "  - Table:\n"
-      "      - Code:            0x00000001\n"
-      "        Tag:             DW_TAG_compile_unit\n"
-      "        Children:        DW_CHILDREN_yes\n"
-      "        Attributes:\n"
-      "          - Attribute:       DW_AT_language\n"
-      "            Form:            DW_FORM_data2\n"
-      "      - Code:            0x00000002\n"
-      "        Tag:             DW_TAG_base_type\n"
-      "        Children:        DW_CHILDREN_no\n"
-      "        Attributes:\n"
-      "          - Attribute:       DW_AT_encoding\n"
-      "            Form:            DW_FORM_data1\n"
-      "          - Attribute:       DW_AT_byte_size\n"
-      "            Form:            DW_FORM_data1\n"
-      "debug_info:\n"
-      "  - Version:         4\n"
-      "    AddrSize:        8\n"
-      "    Entries:\n"
-      "      - AbbrCode:        0x00000001\n"
-      "        Values:\n"
-      "          - Value:           0x000000000000000C\n"
-      // 0x0000000e:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x0000000000000007\n" // DW_ATE_unsigned
-      "          - Value:           0x0000000000000004\n"
-      // 0x00000011:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x0000000000000007\n" // DW_ATE_unsigned
-      "          - Value:           0x0000000000000008\n"
-      // 0x00000014:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x0000000000000005\n" // DW_ATE_signed
-      "          - Value:           0x0000000000000008\n"
-      // 0x00000017:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x0000000000000008\n" // DW_ATE_unsigned_char
-      "          - Value:           0x0000000000000001\n"
-      // 0x0000001a:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x0000000000000006\n" // DW_ATE_signed_char
-      "          - Value:           0x0000000000000001\n"
-      // 0x0000001d:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x000000000000000b\n" // DW_ATE_numeric_string
-      "          - Value:           0x0000000000000001\n"
-      "      - AbbrCode:        0x00000000\n";
+  const char *yamldata = R"(
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_386
+DWARF:
+  debug_abbrev:
+    - Table:
+        - Code:            0x00000001
+          Tag:             DW_TAG_compile_unit
+          Children:        DW_CHILDREN_yes
+          Attributes:
+            - Attribute:       DW_AT_language
+              Form:            DW_FORM_data2
+        - Code:            0x00000002
+          Tag:             DW_TAG_base_type
+          Children:        DW_CHILDREN_no
+          Attributes:
+            - Attribute:       DW_AT_encoding
+              Form:            DW_FORM_data1
+            - Attribute:       DW_AT_byte_size
+              Form:            DW_FORM_data1
+  debug_info:
+    - Version:         4
+      AddrSize:        8
+      Entries:
+        - AbbrCode:        0x00000001
+          Values:
+            - Value:           0x000000000000000C
+        # 0x0000000e:
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000007 # DW_ATE_unsigned
+            - Value:           0x0000000000000004
+        # 0x00000011:
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000007 # DW_ATE_unsigned
+            - Value:           0x0000000000000008
+        # 0x00000014:
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000005 # DW_ATE_signed
+            - Value:           0x0000000000000008
+        # 0x00000017:
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000008 # DW_ATE_unsigned_char
+            - Value:           0x0000000000000001
+        # 0x0000001a:
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000006 # DW_ATE_signed_char
+            - Value:           0x0000000000000001
+        # 0x0000001d:
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x000000000000000b # DW_ATE_numeric_string
+            - Value:           0x0000000000000001
+        - AbbrCode:        0x00000000
+)";
   uint8_t offs_uint32_t = 0x0000000e;
   uint8_t offs_uint64_t = 0x00000011;
   uint8_t offs_sint64_t = 0x00000014;
   uint8_t offs_uchar = 0x00000017;
   uint8_t offs_schar = 0x0000001a;
 
-  DWARFExpressionTester t(yamldata, "i386-unknown-linux");
+  DWARFExpressionTester t(yamldata);
   ASSERT_TRUE((bool)t.GetDwarfUnit());
 
   // Constant is given as little-endian.
@@ -188,7 +196,7 @@ TEST(DWARFExpression, DW_OP_convert) {
 
   // No Module.
   EXPECT_THAT_ERROR(Evaluate({DW_OP_const1s, 'X', DW_OP_convert, 0x00}, nullptr,
-                             t.GetDwarfUnit().get())
+                             t.GetDwarfUnit())
                         .takeError(),
                     llvm::Failed());
 

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

@@ -39,59 +39,63 @@ TEST_F(DWARFASTParserClangTests,
        EnsureAllDIEsInDeclContextHaveBeenParsedParsesOnlyMatchingEntries) {
 
   /// Auxiliary debug info.
-  const char *yamldata =
-      "debug_abbrev:\n"
-      "  - Table:\n"
-      "      - Code:            0x00000001\n"
-      "        Tag:             DW_TAG_compile_unit\n"
-      "        Children:        DW_CHILDREN_yes\n"
-      "        Attributes:\n"
-      "          - Attribute:       DW_AT_language\n"
-      "            Form:            DW_FORM_data2\n"
-      "      - Code:            0x00000002\n"
-      "        Tag:             DW_TAG_base_type\n"
-      "        Children:        DW_CHILDREN_no\n"
-      "        Attributes:\n"
-      "          - Attribute:       DW_AT_encoding\n"
-      "            Form:            DW_FORM_data1\n"
-      "          - Attribute:       DW_AT_byte_size\n"
-      "            Form:            DW_FORM_data1\n"
-      "debug_info:\n"
-      "  - Version:         4\n"
-      "    AddrSize:        8\n"
-      "    Entries:\n"
-      "      - AbbrCode:        0x00000001\n"
-      "        Values:\n"
-      "          - Value:           0x000000000000000C\n"
-      // 0x0000000e:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x0000000000000007\n" // DW_ATE_unsigned
-      "          - Value:           0x0000000000000004\n"
-      // 0x00000011:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x0000000000000007\n" // DW_ATE_unsigned
-      "          - Value:           0x0000000000000008\n"
-      // 0x00000014:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x0000000000000005\n" // DW_ATE_signed
-      "          - Value:           0x0000000000000008\n"
-      // 0x00000017:
-      "      - AbbrCode:        0x00000002\n"
-      "        Values:\n"
-      "          - Value:           0x0000000000000008\n" // DW_ATE_unsigned_char
-      "          - Value:           0x0000000000000001\n"
-      "      - AbbrCode:        0x00000000\n";
+  const char *yamldata = R"(
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_386
+DWARF:
+  debug_abbrev:
+    - Table:
+        - Code:            0x00000001
+          Tag:             DW_TAG_compile_unit
+          Children:        DW_CHILDREN_yes
+          Attributes:
+            - Attribute:       DW_AT_language
+              Form:            DW_FORM_data2
+        - Code:            0x00000002
+          Tag:             DW_TAG_base_type
+          Children:        DW_CHILDREN_no
+          Attributes:
+            - Attribute:       DW_AT_encoding
+              Form:            DW_FORM_data1
+            - Attribute:       DW_AT_byte_size
+              Form:            DW_FORM_data1
+  debug_info:
+    - Version:         4
+      AddrSize:        8
+      Entries:
+        - AbbrCode:        0x00000001
+          Values:
+            - Value:           0x000000000000000C
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000007 # DW_ATE_unsigned
+            - Value:           0x0000000000000004
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000007 # DW_ATE_unsigned
+            - Value:           0x0000000000000008
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000005 # DW_ATE_signed
+            - Value:           0x0000000000000008
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000008 # DW_ATE_unsigned_char
+            - Value:           0x0000000000000001
+        - AbbrCode:        0x00000000
+)";
 
-  YAMLModuleTester t(yamldata, "i386-unknown-linux");
+  YAMLModuleTester t(yamldata);
   ASSERT_TRUE((bool)t.GetDwarfUnit());
 
   TypeSystemClang ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple());
   DWARFASTParserClangStub ast_parser(ast_ctx);
 
-  DWARFUnit *unit = t.GetDwarfUnit().get();
+  DWARFUnit *unit = t.GetDwarfUnit();
   const DWARFDebugInfoEntry *die_first = unit->DIE().GetDIE();
   const DWARFDebugInfoEntry *die_child0 = die_first->GetFirstChild();
   const DWARFDebugInfoEntry *die_child1 = die_child0->GetSibling();

lldb/unittests/TestingSupport/Symbol/CMakeLists.txt

@@ -6,9 +6,11 @@ add_lldb_library(lldbSymbolHelpers
     lldbCore
     lldbHost
     lldbPluginExpressionParserClang
+    lldbPluginObjectFileELF
     lldbPluginSymbolFileDWARF
     lldbPluginTypeSystemClang
     lldbUtilityHelpers
+    LLVMTestingSupport
 
   LINK_COMPONENTS
     ObjectYAML

lldb/unittests/TestingSupport/Symbol/YAMLModuleTester.cpp

@@ -7,112 +7,20 @@
 //===----------------------------------------------------------------------===//
 
 #include "TestingSupport/Symbol/YAMLModuleTester.h"
+#include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+#include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Section.h"
 #include "llvm/ObjectYAML/DWARFEmitter.h"
 
 using namespace lldb_private;
 
-/// A mock module holding an object file parsed from YAML.
-class YAMLModule : public lldb_private::Module {
-public:
-  YAMLModule(ArchSpec &arch) : Module(FileSpec("test"), arch) {}
-  void SetObjectFile(lldb::ObjectFileSP obj_file) { m_objfile_sp = obj_file; }
-  ObjectFile *GetObjectFile() override { return m_objfile_sp.get(); }
-};
+YAMLModuleTester::YAMLModuleTester(llvm::StringRef yaml_data) {
+  llvm::Expected<TestFile> File = TestFile::fromYaml(yaml_data);
+  EXPECT_THAT_EXPECTED(File, llvm::Succeeded());
 
-/// A mock object file that can be parsed from YAML.
-class YAMLObjectFile : public lldb_private::ObjectFile {
-  const lldb::ModuleSP m_module_sp;
-  llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> &m_section_map;
-  /// Because there is only one DataExtractor in the ObjectFile
-  /// interface, all sections are copied into a contiguous buffer.
-  std::vector<char> m_buffer;
+  m_module_sp = std::make_shared<Module>(File->moduleSpec());
+  auto &symfile = *llvm::cast<SymbolFileDWARF>(m_module_sp->GetSymbolFile());
 
-public:
-  YAMLObjectFile(const lldb::ModuleSP &module_sp,
-                 llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> &map)
-      : ObjectFile(module_sp, &module_sp->GetFileSpec(), /*file_offset*/ 0,
-                   /*length*/ 0, /*data_sp*/ nullptr, /*data_offset*/ 0),
-        m_module_sp(module_sp), m_section_map(map) {}
-
-  /// Callback for initializing the module's list of sections.
-  void CreateSections(SectionList &unified_section_list) override {
-    lldb::offset_t total_bytes = 0;
-    for (auto &entry : m_section_map)
-      total_bytes += entry.getValue()->getBufferSize();
-    m_buffer.reserve(total_bytes);
-    m_data =
-        DataExtractor(m_buffer.data(), total_bytes, lldb::eByteOrderLittle, 4);
-
-    lldb::user_id_t sect_id = 1;
-    for (auto &entry : m_section_map) {
-      llvm::StringRef name = entry.getKey();
-      lldb::SectionType sect_type =
-          llvm::StringSwitch<lldb::SectionType>(name)
-              .Case("debug_info", lldb::eSectionTypeDWARFDebugInfo)
-              .Case("debug_abbrev", lldb::eSectionTypeDWARFDebugAbbrev)
-              .Case("debug_str", lldb::eSectionTypeDWARFDebugStr);
-      auto &membuf = entry.getValue();
-      lldb::addr_t file_vm_addr = 0;
-      lldb::addr_t vm_size = 0;
-      lldb::offset_t file_offset = m_buffer.size();
-      lldb::offset_t file_size = membuf->getBufferSize();
-      m_buffer.resize(file_offset + file_size);
-      memcpy(m_buffer.data() + file_offset, membuf->getBufferStart(),
-             file_size);
-      uint32_t log2align = 0;
-      uint32_t flags = 0;
-      auto section_sp = std::make_shared<lldb_private::Section>(
-          m_module_sp, this, sect_id++, ConstString(name), sect_type,
-          file_vm_addr, vm_size, file_offset, file_size, log2align, flags);
-      unified_section_list.AddSection(section_sp);
-    }
-  }
-
-  /// \{
-  /// Stub methods that aren't needed here.
-  ConstString GetPluginName() override { return ConstString("YAMLObjectFile"); }
-  uint32_t GetPluginVersion() override { return 0; }
-  void Dump(Stream *s) override {}
-  uint32_t GetAddressByteSize() const override { return 8; }
-  uint32_t GetDependentModules(FileSpecList &file_list) override { return 0; }
-  bool IsExecutable() const override { return 0; }
-  ArchSpec GetArchitecture() override { return {}; }
-  Symtab *GetSymtab() override { return nullptr; }
-  bool IsStripped() override { return false; }
-  UUID GetUUID() override { return {}; }
-  lldb::ByteOrder GetByteOrder() const override {
-    return lldb::eByteOrderLittle;
-  }
-  bool ParseHeader() override { return false; }
-  Type CalculateType() override { return {}; }
-  Strata CalculateStrata() override { return {}; }
-  /// \}
-};
-
-YAMLModuleTester::YAMLModuleTester(llvm::StringRef yaml_data,
-                                   llvm::StringRef triple) {
-  auto sections_map = llvm::DWARFYAML::emitDebugSections(yaml_data);
-  if (!sections_map)
-    return;
-  m_sections_map = std::move(*sections_map);
-  ArchSpec arch(triple);
-  m_module_sp = std::make_shared<YAMLModule>(arch);
-  m_objfile_sp = std::make_shared<YAMLObjectFile>(m_module_sp, m_sections_map);
-  static_cast<YAMLModule *>(m_module_sp.get())->SetObjectFile(m_objfile_sp);
-
-  lldb::user_id_t uid = 0;
-  llvm::StringRef raw_debug_info = m_sections_map["debug_info"]->getBuffer();
-  lldb_private::DataExtractor debug_info(
-      raw_debug_info.data(), raw_debug_info.size(),
-      m_objfile_sp->GetByteOrder(), m_objfile_sp->GetAddressByteSize());
-  lldb::offset_t offset_ptr = 0;
-  m_symfile_dwarf = std::make_unique<SymbolFileDWARF>(m_objfile_sp, nullptr);
-  llvm::Expected<DWARFUnitSP> dwarf_unit = DWARFUnit::extract(
-      *m_symfile_dwarf, uid,
-      *static_cast<lldb_private::DWARFDataExtractor *>(&debug_info),
-      DIERef::DebugInfo, &offset_ptr, nullptr);
-  if (dwarf_unit)
-    m_dwarf_unit = dwarf_unit.get();
+  m_dwarf_unit = symfile.DebugInfo().GetUnitAtIndex(0);
 }

lldb/unittests/TestingSupport/Symbol/YAMLModuleTester.h

@@ -9,6 +9,7 @@
 #ifndef LLDB_UNITTESTS_TESTINGSUPPORT_SYMBOL_YAMLMODULETESTER_H
 #define LLDB_UNITTESTS_TESTINGSUPPORT_SYMBOL_YAMLMODULETESTER_H
 
+#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
@@ -22,17 +23,16 @@ namespace lldb_private {
 /// DWARF expressions on it.
 class YAMLModuleTester {
 protected:
-  SubsystemRAII<FileSystem, HostInfo, TypeSystemClang> subsystems;
-  llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> m_sections_map;
+  SubsystemRAII<FileSystem, HostInfo, TypeSystemClang, ObjectFileELF,
+                SymbolFileDWARF>
+      subsystems;
   lldb::ModuleSP m_module_sp;
-  lldb::ObjectFileSP m_objfile_sp;
-  DWARFUnitSP m_dwarf_unit;
-  std::unique_ptr<SymbolFileDWARF> m_symfile_dwarf;
+  DWARFUnit *m_dwarf_unit;
 
 public:
   /// Parse the debug info sections from the YAML description.
-  YAMLModuleTester(llvm::StringRef yaml_data, llvm::StringRef triple);
-  DWARFUnitSP GetDwarfUnit() const { return m_dwarf_unit; }
+  YAMLModuleTester(llvm::StringRef yaml_data);
+  DWARFUnit *GetDwarfUnit() const { return m_dwarf_unit; }
   lldb::ModuleSP GetModule() const { return m_module_sp; }
 };