//===-- DWARFExpressionTest.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 "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 "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"

using namespace lldb_private;

static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr,
                                       lldb::ModuleSP module_sp = {},
                                       DWARFUnit *unit = nullptr) {
  DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle,
                          /*addr_size*/ 4);
  Value result;
  Status status;
  if (!DWARFExpression::Evaluate(
          /*exe_ctx*/ nullptr, /*reg_ctx*/ nullptr, module_sp, extractor, unit,
          lldb::eRegisterKindLLDB,
          /*initial_value_ptr*/ nullptr,
          /*object_address_ptr*/ nullptr, result, &status))
    return status.ToError();

  switch (result.GetValueType()) {
  case Value::eValueTypeScalar:
    return result.GetScalar();
  case Value::eValueTypeHostAddress: {
    // Convert small buffers to scalars to simplify the tests.
    DataBufferHeap &buf = result.GetBuffer();
    if (buf.GetByteSize() <= 8) {
      uint64_t val = 0;
      memcpy(&val, buf.GetBytes(), buf.GetByteSize());
      return Scalar(llvm::APInt(buf.GetByteSize()*8, val, false));
    }
  }
    LLVM_FALLTHROUGH;
  default:
    return status.ToError();
  }
}

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

/// 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.
  llvm::Expected<Scalar> Eval(llvm::ArrayRef<uint8_t> expr) {
    return ::Evaluate(expr, m_module_sp, m_dwarf_unit.get());
  }
};

/// Unfortunately Scalar's operator==() is really picky.
static Scalar GetScalar(unsigned bits, uint64_t value, bool sign) {
  Scalar scalar;
  auto type = Scalar::GetBestTypeForBitSize(bits, sign);
  switch (type) {
  case Scalar::e_sint:
    scalar = Scalar((int)value);
    break;
  case Scalar::e_slong:
    scalar = Scalar((long)value);
    break;
  case Scalar::e_slonglong:
    scalar = Scalar((long long)value);
    break;
  case Scalar::e_uint:
    scalar = Scalar((unsigned int)value);
    break;
  case Scalar::e_ulong:
    scalar = Scalar((unsigned long)value);
    break;
  case Scalar::e_ulonglong:
    scalar = Scalar((unsigned long long)value);
    break;
  default:
    llvm_unreachable("not implemented");
  }
  scalar.TruncOrExtendTo(type, bits);
  if (sign)
    scalar.MakeSigned();
  else
    scalar.MakeUnsigned();
  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"
      "  - 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"
      // 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"
      "        Values:          []\n";
  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;

  YAMLModuleTester t(yamldata, "i386-unknown-linux");
  ASSERT_TRUE((bool)t.GetDwarfUnit());

  // Constant is given as little-endian.
  bool is_signed = true;
  bool not_signed = false;

  //
  // Positive tests.
  //

  // Truncate to default unspecified (pointer-sized) type.
  EXPECT_THAT_EXPECTED(
      t.Eval({DW_OP_const8u, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, //
              DW_OP_convert, 0x00}),
      llvm::HasValue(GetScalar(32, 0x44332211, not_signed)));
  // Truncate to 32 bits.
  EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const8u, //
                               0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,//
                               DW_OP_convert, offs_uint32_t}),
                       llvm::HasValue(GetScalar(32, 0x44332211, not_signed)));

  // Leave as is.
  EXPECT_THAT_EXPECTED(
      t.Eval({DW_OP_const8u, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, //
              DW_OP_convert, offs_uint64_t}),
      llvm::HasValue(GetScalar(64, 0x8877665544332211, not_signed)));

  // Sign-extend to 64 bits.
  EXPECT_THAT_EXPECTED(
      t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, //
              DW_OP_convert, offs_sint64_t}),
      llvm::HasValue(GetScalar(64, 0xffffffffffeeddcc, is_signed)));

  // Truncate to 8 bits.
  EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', 0xee, 0xff, //
                               DW_OP_convert, offs_uchar}),
                       llvm::HasValue(GetScalar(8, 'A', not_signed)));

  // Also truncate to 8 bits.
  EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', 0xee, 0xff, //
                               DW_OP_convert, offs_schar}),
                       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())
                        .takeError(),
                    llvm::Failed());

  // No DIE.
  EXPECT_THAT_ERROR(
      t.Eval({DW_OP_const1s, 'X', DW_OP_convert, 0x01}).takeError(),
      llvm::Failed());

  // Unsupported.
  EXPECT_THAT_ERROR(
      t.Eval({DW_OP_const1s, 'X', DW_OP_convert, 0x1d}).takeError(),
      llvm::Failed());
}

TEST(DWARFExpression, DW_OP_piece) {
  EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x11, 0x22, DW_OP_piece, 2,
                                 DW_OP_const2u, 0x33, 0x44, DW_OP_piece, 2}),
                       llvm::HasValue(GetScalar(32, 0x44332211, true)));
  EXPECT_THAT_EXPECTED(
      Evaluate({DW_OP_piece, 1, DW_OP_const1u, 0xff, DW_OP_piece, 1}),
      // Note that the "00" should really be "undef", but we can't
      // represent that yet.
      llvm::HasValue(GetScalar(16, 0xff00, true)));
}