[lldb/test] Simplify/generalize YAMLModuleTester

[labath]

Summary

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.

[JDevlieghere]

LGTM

lldb/unittests/Expression/DWARFExpressionTest.cpp

default:
     return status.ToError();
   }
 }
 
 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);
   }
 };
 
 /// Unfortunately Scalar's operator==() is really picky.
 static Scalar GetScalar(unsigned bits, uint64_t value, bool sign) {
   Scalar scalar(value);
   scalar.TruncOrExtendTo(bits, sign);
   return scalar;
 }
 
 TEST(DWARFExpression, DW_OP_pick) {
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 0}),
                        llvm::HasValue(0));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 1}),
                        llvm::HasValue(1));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 2}),
                        llvm::Failed());
 }
 
 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.
   bool is_signed = true;
   bool not_signed = false;
 
   //
   // Positive tests.
EXPECT_THAT_EXPECTED(
       llvm::HasValue(GetScalar(8, 'A', is_signed)));
 
   //
   // Errors.
   //
 
   // No Module.
   EXPECT_THAT_ERROR(Evaluate({DW_OP_const1s, 'X', DW_OP_convert, 0x00}, nullptr,
-                             t.GetDwarfUnit().get())
+                             t.GetDwarfUnit())
                         .takeError(),
                     llvm::Failed());
 
   // No DIE.
   EXPECT_THAT_ERROR(
       t.Eval({DW_OP_const1s, 'X', DW_OP_convert, 0x01}).takeError(),
       llvm::Failed());
 

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

 } // namespace
 
 // If your implementation needs to dereference the dummy pointers we are
 // defining here, causing this test to fail, feel free to delete it.
 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();
   const DWARFDebugInfoEntry *die_child2 = die_child1->GetSibling();
   const DWARFDebugInfoEntry *die_child3 = die_child2->GetSibling();
   std::vector<DWARFDIE> dies = {
       DWARFDIE(unit, die_child0), DWARFDIE(unit, die_child1),
       DWARFDIE(unit, die_child2), DWARFDIE(unit, die_child3)};

lldb/unittests/TestingSupport/Symbol/CMakeLists.txt

 set_property(DIRECTORY PROPERTY EXCLUDE_FROM_ALL ON)
 add_lldb_library(lldbSymbolHelpers
   YAMLModuleTester.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbPluginExpressionParserClang
+    lldbPluginObjectFileELF
     lldbPluginSymbolFileDWARF
     lldbPluginTypeSystemClang
     lldbUtilityHelpers
+    LLVMTestingSupport
 
   LINK_COMPONENTS
     ObjectYAML
   )

lldb/unittests/TestingSupport/Symbol/YAMLModuleTester.h

 //===- YAMLModuleTester.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_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"
 #include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Host/HostInfo.h"
 
 namespace lldb_private {
 
 /// Helper class that can construct a module from YAML and evaluate
 /// 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; }
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UNITTESTS_TESTINGSUPPORT_SYMBOL_YAMLMODULETESTER_H

lldb/unittests/TestingSupport/Symbol/YAMLModuleTester.cpp

 //===-- YAMLModuleTester.cpp ----------------------------------------------===//
 //
 // 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 "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);
 }