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/AddressInterval.h>
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/BinaryAnalysis/Debugger/ThreadId.h>
#include <Rose/Constants.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