Debugger.hpp

#pragma once

#ifndef CHI_DEBUGGER_DEBUGGER_HPP
#define CHI_DEBUGGER_DEBUGGER_HPP

#include <lldb/API/SBBreakpoint.h>
#include <lldb/API/SBDebugger.h>
#include <lldb/API/SBListener.h>
#include <lldb/API/SBProcess.h>
#include <lldb/API/SBTarget.h>

#include <chi/GraphFunction.hpp>
#include <chi/GraphModule.hpp>

namespace chi {

class Debugger {
public:
    Debugger(const char* pathToChig, GraphModule& mod);

    // no copy or move, doesn't really make sense
    Debugger(const Debugger& other) = delete;
    Debugger(Debugger&& other)      = delete;

    ~Debugger();

    Debugger& operator=(const Debugger&) = delete;
    Debugger& operator=(Debugger&&) = delete;

    Result start(
        const char** argv = nullptr, const char** envp = nullptr,
        const boost::filesystem::path& workingDirectory = boost::filesystem::current_path());

    Result terminate();

    bool isAttached() const { return mProcess.IsValid(); }

    bool running() const {
        if (!isAttached()) { return false; }
        return lldbProcess().GetState() == lldb::eStateRunning;
    }

    Result processContinue();

    Result pause();

    Result setBreakpoint(NodeInstance& node, lldb::SBBreakpoint* bp = nullptr);

    bool removeBreakpoint(NodeInstance& node);

    std::vector<const NodeInstance*> listBreakpoints() const;

    lldb::SBValue inspectNodeOutput(const NodeInstance& inst, size_t id, lldb::SBFrame frame = {});

    lldb::SBValue inspectLocalVariable(boost::string_view name);

    NodeInstance* nodeFromFrame(lldb::SBFrame frame = {});

    GraphModule& module() const { return *mModule; }

    lldb::SBTarget lldbTarget() const { return mTarget; }

    lldb::SBProcess lldbProcess() const { return mProcess; }

    lldb::SBDebugger lldbDebugger() const { return mDebugger; }

private:
    lldb::SBDebugger mDebugger;
    lldb::SBTarget   mTarget;
    lldb::SBProcess  mProcess;

    GraphModule* mModule = nullptr;

    std::unordered_map<const NodeInstance*, lldb::SBBreakpoint> mBreakpoints;
};

unsigned lineNumberFromNode(NodeInstance& inst);

}  // namespace chi

#endif  // CHI_DEBUGGER_DEBUGGER_HPP