Debugger/Base.h

#ifndef ROSE_BinaryAnalysis_Debugger_Base_H
#define ROSE_BinaryAnalysis_Debugger_Base_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Debugger/BasicTypes.h>

#include <Rose/BinaryAnalysis/Debugger/ThreadId.h>

#include <Sawyer/BitVector.h>
#include <Sawyer/SharedObject.h>
#include <Sawyer/Trace.h>

namespace Rose {
namespace BinaryAnalysis {
namespace Debugger {

class Base: public Sawyer::SharedObject {
public:
    using Ptr = Debugger::Ptr;

protected:
    Disassembler::BasePtr disassembler_;                // how to disassemble instructions

protected:
    Base();

    // Debuggers are not copyable
    Base(const Base&) = delete;
    Base(Base&&) = delete;
    Base& operator=(const Base&) = delete;
    Base& operator=(Base&&) = delete;

public:
    virtual ~Base();

    // Properties
public:

    virtual Disassembler::BasePtr disassembler();

    // Process state
public:

    virtual bool isAttached() = 0;

    virtual void detach() = 0;

    virtual void terminate() = 0;

    virtual bool isTerminated() = 0;

    virtual std::string howTerminated() = 0;

    // Threads
public:

    virtual std::vector<ThreadId> threadIds() = 0;

    // Break points
public:

    virtual void setBreakPoint(const AddressInterval&) = 0;

    virtual void clearBreakPoint(const AddressInterval&) = 0;

    virtual void clearBreakPoints() = 0;

    // Execution
public:

    virtual void executionAddress(ThreadId, rose_addr_t);
    virtual rose_addr_t executionAddress(ThreadId);
    virtual void singleStep(ThreadId) = 0;

    virtual void runToBreakPoint(ThreadId) = 0;

    virtual Sawyer::Container::Trace<rose_addr_t> trace();

    template<class Filter>
    Sawyer::Container::Trace<rose_addr_t> trace(ThreadId tid, Filter &filter) {
        Sawyer::Container::Trace<rose_addr_t> retval;
        while (!isTerminated()) {
            rose_addr_t va = executionAddress(tid);
            FilterAction action = filter(va);
            if (action.isClear(FilterActionFlag::REJECT))
                retval.append(va);
            if (action.isSet(FilterActionFlag::STOP))
                return retval;
            singleStep(tid);
        }
        return retval;
    }

    // Registers
public:

    virtual RegisterDictionaryPtr registerDictionary();

    virtual std::string registerName(RegisterDescriptor);

    virtual Sawyer::Container::BitVector readRegister(ThreadId, RegisterDescriptor) = 0;

    virtual void writeRegister(ThreadId, RegisterDescriptor, const Sawyer::Container::BitVector&) = 0;
    virtual void writeRegister(ThreadId, RegisterDescriptor, uint64_t value) = 0;
    virtual std::vector<RegisterDescriptor> availableRegisters() = 0;

    virtual Sawyer::Container::BitVector readAllRegisters(ThreadId) = 0;

    virtual void writeAllRegisters(ThreadId, const Sawyer::Container::BitVector&) = 0;

    // Memory
public:

    virtual size_t readMemory(rose_addr_t va, size_t nBytes, uint8_t *buffer) = 0;

    virtual std::vector<uint8_t> readMemory(rose_addr_t va, size_t nBytes) = 0;

    virtual Sawyer::Container::BitVector readMemory(rose_addr_t va, size_t nBytes, ByteOrder::Endianness order) = 0;

    virtual size_t writeMemory(rose_addr_t va, size_t nBytes, const uint8_t *bytes) = 0;

    template<typename T>
    void writeMemory(rose_addr_t va, const T &value) {
        size_t n = writeMemory(va, sizeof(T), (const uint8_t*)&value);
        ASSERT_always_require(n == sizeof(T));
    }

    virtual std::string readCString(rose_addr_t va, size_t maxBytes = UNLIMITED);




};

} // namespace
} // namespace
} // namespace

#endif
#endif