Commit 2926a651 authored by Jan Kratochvil's avatar Jan Kratochvil
Browse files

[lldb] [testsuite] generalize `DWARFASTParserClangTests` based on `DWARFExpressionTest`'s YAML 

YAMLModuleTester from DWARFExpressionTest can be reused for more
testcases.

Differential Revision: https://reviews.llvm.org/D73279
parent 88cd49e9

lldb/unittests/Expression/DWARFExpressionTest.cpp

+4 −122
Original line number Diff line number Diff line
@@ -7,17 +7,12 @@ 
//===----------------------------------------------------------------------===//



#include "lldb/Expression/DWARFExpression.h"

#include "../../source/Plugins/SymbolFile/DWARF/DWARFUnit.h"

#include "../../source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"

#include "TestingSupport/SubsystemRAII.h"

#include "lldb/Core/Module.h"

#include "lldb/Core/Section.h"

#include "TestingSupport/Symbol/YAMLModuleTester.h"

#include "lldb/Core/Value.h"

#include "lldb/Core/dwarf.h"

#include "lldb/Symbol/ObjectFile.h"

#include "lldb/Utility/StreamString.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/ObjectYAML/DWARFEmitter.h"

#include "llvm/Testing/Support/Error.h"

#include "gtest/gtest.h"
@@ -55,122 +50,9 @@ static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr, 
  }

}



/// A mock module holding an object file parsed from YAML.

class YAMLModule : public lldb_private::Module {

class DWARFExpressionTester : public YAMLModuleTester {

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(); }

};



/// 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;



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);

      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 {}; }

  /// \}

};



/// Helper class that can construct a module from YAML and evaluate

/// DWARF expressions on it.

class YAMLModuleTester {

  SubsystemRAII<FileSystem> subsystems;

  llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> m_sections_map;

  lldb::ModuleSP m_module_sp;

  lldb::ObjectFileSP m_objfile_sp;

  DWARFUnitSP m_dwarf_unit;

  std::unique_ptr<SymbolFileDWARF> m_symfile_dwarf;



public:

  /// Parse the debug info sections from the YAML description.

  YAMLModuleTester(llvm::StringRef yaml_data, llvm::StringRef triple) {

    auto sections_map = llvm::DWARFYAML::EmitDebugSections(yaml_data, true);

    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);

    if (dwarf_unit)

      m_dwarf_unit = dwarf_unit.get();

  }

  DWARFUnitSP GetDwarfUnit() { return m_dwarf_unit; }



  // Evaluate a raw DWARF expression.

  using YAMLModuleTester::YAMLModuleTester;

  llvm::Expected<Scalar> Eval(llvm::ArrayRef<uint8_t> expr) {

    return ::Evaluate(expr, m_module_sp, m_dwarf_unit.get());

  }
@@ -286,7 +168,7 @@ TEST(DWARFExpression, DW_OP_convert) { 
  uint8_t offs_uchar = 0x00000017;

  uint8_t offs_schar = 0x0000001a;



  YAMLModuleTester t(yamldata, "i386-unknown-linux");

  DWARFExpressionTester t(yamldata, "i386-unknown-linux");

  ASSERT_TRUE((bool)t.GetDwarfUnit());



  // Constant is given as little-endian.

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

+67 −11
Original line number Diff line number Diff line
@@ -8,19 +8,16 @@ 


#include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"

#include "Plugins/SymbolFile/DWARF/DWARFDIE.h"

#include "TestingSupport/SubsystemRAII.h"

#include "lldb/Host/HostInfo.h"

#include "TestingSupport/Symbol/YAMLModuleTester.h"

#include "gmock/gmock.h"

#include "gtest/gtest.h"



using namespace lldb;

using namespace lldb_private;



class DWARFASTParserClangTests : public testing::Test {

  SubsystemRAII<FileSystem, HostInfo, TypeSystemClang> subsystems;

};



namespace {

class DWARFASTParserClangTests : public testing::Test {};



class DWARFASTParserClangStub : public DWARFASTParserClang {

public:

  using DWARFASTParserClang::DWARFASTParserClang;
@@ -39,14 +36,73 @@ public: 
// 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"

      "  - 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"

      "  - Length:\n"

      "      TotalLength:     0\n"

      "    Version:         4\n"

      "    AbbrOffset:      0\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"

      "        Values:          []\n";



  YAMLModuleTester t(yamldata, "i386-unknown-linux");

  ASSERT_TRUE((bool)t.GetDwarfUnit());



  TypeSystemClang ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple());

  DWARFASTParserClangStub ast_parser(ast_ctx);



  DWARFUnit *unit = nullptr;

  std::vector<DWARFDIE> dies = {DWARFDIE(unit, (DWARFDebugInfoEntry *)1LL),

                                DWARFDIE(unit, (DWARFDebugInfoEntry *)2LL),

                                DWARFDIE(unit, (DWARFDebugInfoEntry *)3LL),

                                DWARFDIE(unit, (DWARFDebugInfoEntry *)4LL)};

  DWARFUnit *unit = t.GetDwarfUnit().get();

  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)};

  std::vector<clang::DeclContext *> decl_ctxs = {

      (clang::DeclContext *)1LL, (clang::DeclContext *)2LL,

      (clang::DeclContext *)2LL, (clang::DeclContext *)3LL};

lldb/unittests/TestingSupport/CMakeLists.txt

+3 −0
Original line number Diff line number Diff line
@@ -5,9 +5,12 @@ add_lldb_library(lldbUtilityHelpers 


  LINK_LIBS

    lldbUtility

    lldbSymbolHelpers



  LINK_COMPONENTS

    Support

    ObjectYAML

  )

include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include)



add_subdirectory(Symbol)

lldb/unittests/TestingSupport/Symbol/CMakeLists.txt

0 → 100644
+13 −0
Original line number Diff line number Diff line 
set_property(DIRECTORY PROPERTY EXCLUDE_FROM_ALL ON)

add_lldb_library(lldbSymbolHelpers

  YAMLModuleTester.cpp

  )



# Our current version of gtest does not properly recognize C++11 support

# with MSVC, so it falls back to tr1 / experimental classes.  Since LLVM

# itself requires C++11, we can safely force it on unconditionally so that

# we don't have to fight with the buggy gtest check.

add_definitions(-DGTEST_LANG_CXX11=1)

add_definitions(-DGTEST_HAS_TR1_TUPLE=0)

include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include)

include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googlemock/include)

lldb/unittests/TestingSupport/Symbol/YAMLModuleTester.cpp

0 → 100644
+116 −0
Original line number Diff line number Diff line 
//===-- 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 "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(); }

};



/// 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;



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);

      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, true);

  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);

  if (dwarf_unit)

    m_dwarf_unit = dwarf_unit.get();

}