IGDBTarget.h

Go to the documentation of this file.

#pragma once
#include <bzscore/string.h>
#include "signals.h"
#include "GDBRegisters.h"
#include <vector>
#include <string>

namespace GDBServerFoundation
{
    enum GDBStatus
    {
        kGDBSuccess,
        kGDBUnknownError,
        kGDBNotSupported = 0x1000,
    };

    enum DebugThreadMode
    {
        dtmProbe,
        dtmSingleStep,
        dtmSuspend,
        dtmRestore,
    };

    enum BreakpointType
    {
        bptSoftwareBreakpoint,
        bptHardwareBreakpoint,
        bptWriteWatchpoint,
        bptReadWatchpoint,
        bptAccessWatchpoint,
    };

    enum EmbeddedMemoryType
    {
        mtRAM,
        mtROM,
        mtFLASH,
    };

    struct DynamicLibraryRecord
    {
        std::string FullPath;
        /*
            \attention For Windows DLLs this should be the actual base address + 0x1000
        */
        ULONGLONG LoadAddress;
    };

    struct ThreadRecord
    {
        int ThreadID;
        std::string UserFriendlyName;
    };

    struct EmbeddedMemoryRegion
    {
        EmbeddedMemoryType Type;
        ULONGLONG Start;
        ULONGLONG Length;

        unsigned ErasureBlockSize;

        EmbeddedMemoryRegion()
        {
        }

        EmbeddedMemoryRegion(EmbeddedMemoryType type, ULONGLONG start, ULONGLONG length, unsigned erasureBlockSize = 0)
            : Type(type)
            , Start(start)
            , Length(length)
            , ErasureBlockSize(erasureBlockSize)
        {
        }
    };


    class IFLASHProgrammer
    {
    public:
        virtual GDBStatus GetEmbeddedMemoryRegions(std::vector<EmbeddedMemoryRegion> &regions)=0;

        virtual GDBStatus EraseFLASH(ULONGLONG Address, size_t length)=0;

        virtual GDBStatus WriteFLASH(ULONGLONG Address, const void *pBuffer, size_t length)=0;

        virtual GDBStatus CommitFLASHWrite()=0;
    };


    class IStoppedGDBTarget
    {
    public: //General target info

        virtual const PlatformRegisterList *GetRegisterList()=0;

    public: //Register accessing API

        virtual GDBStatus ReadFrameRelatedRegisters(int threadID, RegisterSetContainer &registers)=0;


        virtual GDBStatus ReadTargetRegisters(int threadID, RegisterSetContainer &registers)=0;


        virtual GDBStatus WriteTargetRegisters(int threadID, const RegisterSetContainer &registers)=0;

    public: //Memory accessing API
        virtual GDBStatus ReadTargetMemory(ULONGLONG Address, void *pBuffer, size_t *pSizeInBytes)=0;
        virtual GDBStatus WriteTargetMemory(ULONGLONG Address, const void *pBuffer, size_t sizeInBytes)=0;

    public: //Optional methods, return kGDBNotSupported if not implemented

        virtual GDBStatus GetDynamicLibraryList(std::vector<DynamicLibraryRecord> &libraries)=0;
        

        virtual GDBStatus GetThreadList(std::vector<ThreadRecord> &threads)=0;


        virtual GDBStatus SetThreadModeForNextCont(int threadID, DebugThreadMode mode, OUT bool *pNeedRestoreCall, IN OUT INT_PTR *pRestoreCookie)=0;

        virtual GDBStatus Terminate()=0;


        virtual GDBStatus CreateBreakpoint(BreakpointType type, ULONGLONG Address, unsigned kind, OUT INT_PTR *pCookie)=0;


        virtual GDBStatus RemoveBreakpoint(BreakpointType type, ULONGLONG Address, INT_PTR Cookie)=0;

        virtual GDBStatus ExecuteRemoteCommand(const std::string &command, std::string &output)=0;

        virtual IFLASHProgrammer *GetFLASHProgrammer()=0;
        virtual ~IStoppedGDBTarget(){}
    };

    enum TargetStopReason
    {
        kUnspecified,
        kSignalReceived,
        kProcessExited,
        kLibraryEvent,
    };


    struct TargetStopRecord
    {
        TargetStopReason Reason;

        int ProcessID;
        int ThreadID;

        union
        {
            UnixSignal SignalNumber;
            int ExitCode;
        } Extension;
    };


    class ISyncGDBTarget : public IStoppedGDBTarget
    {
    public:

        virtual GDBStatus GetLastStopRecord(TargetStopRecord *pRec)=0;


        virtual GDBStatus ResumeAndWait(int threadID)=0;


        virtual GDBStatus Step(int threadID)=0;


        virtual GDBStatus SendBreakInRequestAsync()=0;
    };

    class MinimalTargetBase : public ISyncGDBTarget
    {
    public:
        virtual GDBStatus ReadFrameRelatedRegisters(int threadID, RegisterSetContainer &registers)
        {
            return kGDBNotSupported;
        }

        virtual GDBStatus GetDynamicLibraryList(std::vector<DynamicLibraryRecord> &libraries)
        {
            return kGDBNotSupported;
        }

        virtual GDBStatus GetThreadList(std::vector<ThreadRecord> &threads)
        {
            return kGDBNotSupported;
        }

        virtual GDBStatus SetThreadModeForNextCont(int threadID, DebugThreadMode mode, OUT bool *pNeedRestoreCall, IN OUT INT_PTR *pRestoreCookie)
        {
            return kGDBNotSupported;
        }

        virtual GDBStatus Terminate()
        {
            return kGDBNotSupported;
        }

        virtual GDBStatus CreateBreakpoint(BreakpointType type, ULONGLONG Address, unsigned kind, OUT INT_PTR *pCookie)
        {
            return kGDBNotSupported;
        }

        virtual GDBStatus RemoveBreakpoint(BreakpointType type, ULONGLONG Address, INT_PTR Cookie)
        {
            return kGDBNotSupported;
        }

        virtual GDBStatus ExecuteRemoteCommand(const std::string &command, std::string &output)
        {
            return kGDBNotSupported;
        }

        virtual IFLASHProgrammer *GetFLASHProgrammer()
        {
            return NULL;
        }
    };

}