// Copyright 2023 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef EXTENSIONS_CXX_DEBUGGING_WASMVENDORPLUGINS_H_
#define EXTENSIONS_CXX_DEBUGGING_WASMVENDORPLUGINS_H_
#include "ApiContext.h"
#include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Unwind.h"
#include "llvm/BinaryFormat/Dwarf.h"

class SymbolVendorWASM;
class SymbolFileDWARF;

namespace lldb_private {
class FileSystem;
class CPlusPlusLanguage;
class ClangASTContext;
namespace wasm {
class ObjectFileWasm;
class SymbolVendorWasm;
}  // namespace wasm
}  // namespace lldb_private

namespace symbols_backend {

template <typename T>
static void initialize() {  // NOLINT
  T::Initialize();
}
template <typename T>
static void terminate() {  // NOLINT
  T::Terminate();
}
template <typename T, typename FirstT, typename... MoreT>
static void initialize() {  // NOLINT
  T::Initialize();
  initialize<FirstT, MoreT...>();
}
template <typename T, typename FirstT, typename... MoreT>
static void terminate() {  // NOLINT
  terminate<FirstT, MoreT...>();
  T::Terminate();
}

template <typename... SystemT>
struct PluginRegistryContext {
  PluginRegistryContext() { initialize<SystemT...>(); }
  ~PluginRegistryContext() { terminate<SystemT...>(); }
};

class WasmPlatform : public lldb_private::Platform {
 public:
  using lldb_private::Platform::Platform;

  static void Initialize();

  static void Terminate();

  class Resolver : public lldb_private::UserIDResolver {
    llvm::Optional<std::string> DoGetUserName(id_t uid) final { return {}; }
    llvm::Optional<std::string> DoGetGroupName(id_t gid) final { return {}; }
  };
  Resolver resolver_;

  llvm::StringRef GetPluginName() final { return "wasm32"; }

  llvm::StringRef GetDescription() final { return "wasm32"; }

  lldb_private::UserIDResolver& GetUserIDResolver() final { return resolver_; }

  std::vector<lldb_private::ArchSpec> GetSupportedArchitectures(
      const lldb_private::ArchSpec& process_host_arch) final {
    return {{lldb_private::ArchSpec("wasm32-unknown-unknown")}};
  }

  void CalculateTrapHandlerSymbolNames() final {}

  lldb::ProcessSP Attach(lldb_private::ProcessAttachInfo& attach_info,
                         lldb_private::Debugger& debugger,
                         lldb_private::Target* target,
                         lldb_private::Status& error) final {
    error.SetErrorString("Cannot attach to processes");
    return {};
  }
};

class WasmRegisters : public lldb_private::RegisterContext {
  using lldb_private::RegisterContext::RegisterContext;
  lldb_private::RegisterInfo fake_pc_register_ = {"PC",
                                                  nullptr,
                                                  4,
                                                  0,
                                                  lldb::Encoding::eEncodingUint,
                                                  lldb::Format::eFormatDefault,
                                                  {0},
                                                  nullptr,
                                                  nullptr};
  size_t frame_offset_;

 public:
  WasmRegisters(lldb_private::Thread& thread, size_t frame_offset);

  void InvalidateAllRegisters() override{};

  size_t GetRegisterCount() override { return 1; }

  const lldb_private::RegisterInfo* GetRegisterInfoAtIndex(size_t reg) override;

  size_t GetRegisterSetCount() override { return 0; }

  const lldb_private::RegisterSet* GetRegisterSet(size_t reg_set) override {
    return nullptr;
  }

  lldb::ByteOrder GetByteOrder() override { return lldb::eByteOrderLittle; }

  bool ReadRegister(const lldb_private::RegisterInfo* reg_info,
                    lldb_private::RegisterValue& reg_value) override;

  bool WriteRegister(const lldb_private::RegisterInfo* reg_info,
                     const lldb_private::RegisterValue& reg_value) override {
    return false;
  }

  friend class WasmThread;
};

class WasmUnwind : public lldb_private::Unwind {
  size_t frame_offset_;

 public:
  explicit WasmUnwind(lldb_private::Thread& thread, size_t frame_offset)
      : Unwind(thread), frame_offset_(frame_offset) {}
  void DoClear() final{};
  uint32_t DoGetFrameCount() final { return 1; }

  bool DoGetFrameInfoAtIndex(uint32_t frame_idx,
                             lldb::addr_t& cfa,
                             lldb::addr_t& pc,
                             bool& behaves_like_zeroth_frame) final;

  lldb::RegisterContextSP DoCreateRegisterContextForFrame(
      lldb_private::StackFrame* frame) final {
    return GetRegisterContext();
  }
  lldb::RegisterContextSP GetRegisterContext() {
    return lldb::RegisterContextSP{
        new WasmRegisters(GetThread(), frame_offset_)};
  }
};

class WasmThread : public lldb_private::Thread {
  friend class WasmUnwind;
  lldb::StackFrameSP stack_frame_;
  WasmUnwind unwind_;

 public:
  WasmThread(lldb_private::Process& process, size_t frame_offset)
      : Thread(process, 0), unwind_(*this, frame_offset) {}

  void RefreshStateAfterStop() override {}
  bool CalculateStopInfo() override { return false; }

  WasmUnwind& GetUnwinder() final { return unwind_; }

  lldb::RegisterContextSP CreateRegisterContextForFrame(
      lldb_private::StackFrame* frame) override;

  lldb::RegisterContextSP GetRegisterContext() override;

  lldb::StackFrameSP GetFrame();
};

class WasmProcess : public lldb_private::Process {
  using lldb_private::Process::Process;
  const api::DebuggerProxy* proxy_ = nullptr;
  size_t frame_offset_ = 0;

 public:
  static void Initialize();

  static void Terminate();

  static lldb::ProcessSP CreateInstance(
      lldb::TargetSP target_sp,
      lldb::ListenerSP listener_sp,
      const lldb_private::FileSpec* crash_file_path,
      bool can_connect);

  static llvm::StringRef GetPluginDescriptionStatic() {
    return "wasm32 proces";
  }

  static llvm::StringRef GetPluginNameStatic() { return "wasm32"; }

  void SetProxyAndFrameOffset(const api::DebuggerProxy& proxy,
                              size_t frame_offset);
  bool CanDebug(lldb::TargetSP target, bool plugin_specified_by_name) override;
  lldb_private::Status DoDestroy() override { return {}; }
  void RefreshStateAfterStop() override {}
  bool DoUpdateThreadList(lldb_private::ThreadList& old_thread_list,
                          lldb_private::ThreadList& new_thread_list) override;

  size_t DoReadMemory(lldb::addr_t vm_addr,
                      void* buf,
                      size_t size,
                      lldb_private::Status& error) override;

  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
};

class SymbolFileWasmDWARF : public ::SymbolFileDWARF {
  static char ID;

 public:
  using SymbolFileDWARF::SymbolFileDWARF;

  bool isA(const void* ClassID) const override {
    return ClassID == &ID || SymbolFileDWARF::isA(ClassID);
  }
  static bool classof(const SymbolFile* obj) { return obj->isA(&ID); }

  static void Initialize();

  static void Terminate();

  static llvm::StringRef GetPluginNameStatic() { return "wasm_dwarf"; }
  llvm::StringRef GetPluginName() final { return GetPluginNameStatic(); }

  static llvm::StringRef GetPluginDescriptionStatic();

  static lldb_private::SymbolFile* CreateInstance(
      lldb::ObjectFileSP objfile_sp);

  struct WasmValueLoader {
    SymbolFileWasmDWARF& symbol_file;
    explicit WasmValueLoader(SymbolFileWasmDWARF& symbol_file)
        : symbol_file(symbol_file) {
      assert(!symbol_file.current_value_loader_ &&
             "Cannot nest wasm eval contexts");
      symbol_file.current_value_loader_ = this;
    }
    ~WasmValueLoader() { symbol_file.current_value_loader_ = nullptr; }

    virtual llvm::Expected<api::DebuggerProxy::WasmValue> LoadWASMValue(
        uint8_t storage_type,
        const lldb_private::DataExtractor& data,
        lldb::offset_t& offset) = 0;
  };

  lldb::offset_t GetVendorDWARFOpcodeSize(
      const lldb_private::DataExtractor& data,
      const lldb::offset_t data_offset,
      const uint8_t op) const final {
    return LLDB_INVALID_OFFSET;
  }

  bool ParseVendorDWARFOpcode(
      uint8_t op,
      const lldb_private::DataExtractor& opcodes,
      lldb::offset_t& offset,
      std::vector<lldb_private::Value>& stack) const final {
    if (!current_value_loader_) {
      return false;
    }
    switch (op) {
      case llvm::dwarf::DW_OP_WASM_location_int:
      case llvm::dwarf::DW_OP_WASM_location: {
        uint8_t storage_type = opcodes.GetU8(&offset);
        auto value =
            current_value_loader_->LoadWASMValue(storage_type, opcodes, offset);
        if (!value) {
          llvm::errs() << llvm::toString(value.takeError());
          return false;
        }
        auto stack_value = std::visit(
            [](auto v) { return lldb_private::Scalar(v); }, value->value);
        stack.push_back(stack_value);
        stack.back().SetValueType(lldb_private::Value::ValueType::Scalar);
        return true;
      }
    }

    return false;
  }

  std::shared_ptr<lldb_private::Type> externref_type_sp;

  lldb::TypeSP FindDefinitionTypeForDWARFDeclContext(
      const DWARFDeclContext& dwarf_decl_ctx) override {
    // We define type externref_t as a 32-bit integer, so as to be
    // able to transfer some information through the interpreter
    const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize();
    if (dwarf_decl_ctx_count > 0) {
      const lldb_private::ConstString type_name(dwarf_decl_ctx[0].name);
      if (type_name == "externref_t") {
        if (!externref_type_sp) {
          const lldb::LanguageType language = dwarf_decl_ctx.GetLanguage();
          auto type_system = GetTypeSystemForLanguage(language);
          bool ok = !type_system.takeError();
          assert(ok);
          auto ast = clang::dyn_cast<lldb_private::TypeSystemClang>(
              type_system->get());
          lldb_private::CompilerType clang_type =
              ast->GetBasicType(lldb::eBasicTypeUnsignedLongLong);
          externref_type_sp = std::make_shared<lldb_private::Type>(
              lldb::user_id_t(0), this, type_name, 4, nullptr, LLDB_INVALID_UID,
              lldb_private::Type::eEncodingIsUID, lldb_private::Declaration(),
              clang_type, lldb_private::Type::ResolveState::Forward);
        }
        return externref_type_sp;
      }
    }
    return SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(
        dwarf_decl_ctx);
  }

 private:
  WasmValueLoader* current_value_loader_ = nullptr;
};

}  // namespace symbols_backend

#endif  // EXTENSIONS_CXX_DEBUGGING_WASMVENDORPLUGINS_H_