riscv/gdbserver.h

   1 #ifndef _RISCV_GDBSERVER_H
   2 #define _RISCV_GDBSERVER_H
   3
   4 #include <stdint.h>
   5
   6 class sim_t;
   7
   8 template <typename T>
   9 class circular_buffer_t
  10 {
  11 public:
  12   // The buffer can store capacity-1 data elements.
  13   circular_buffer_t(unsigned int capacity) : data(new T[capacity]),
  14       start(0), end(0), capacity(capacity) {}
  15   circular_buffer_t() : start(0), end(0), capacity(0) {}
  16   ~circular_buffer_t() { delete data; }
  17
  18   T *data;
  19   unsigned int start;   // Data start, inclusive.
  20   unsigned int end;     // Data end, exclusive.
  21   unsigned int capacity;    // Size of the buffer.
  22   unsigned int size() const;
  23   bool empty() const { return start == end; }
  24   bool full() const { return ((end+1) % capacity) == start; }
  25
  26   // Return size and address of the block of RAM where more data can be copied
  27   // to be added to the buffer.
  28   unsigned int contiguous_empty_size() const;
  29   T *contiguous_empty() { return data + end; }
  30   void data_added(unsigned int bytes);
  31
  32   unsigned int contiguous_data_size() const;
  33   T *contiguous_data() { return data + start; }
  34   // Tell the buffer that some bytes were consumed from the start of the
  35   // buffer.
  36   void consume(unsigned int bytes);
  37
  38   void reset();
  39
  40   T operator[](unsigned int i) const { return data[(start + i) % capacity]; }
  41
  42   void append(const T *src, unsigned int count);
  43 };
  44
  45 // Class to track software breakpoints that we set.
  46 class software_breakpoint_t
  47 {
  48 public:
  49   reg_t address;
  50   unsigned int size;
  51   uint32_t instruction;
  52
  53   void insert(mmu_t* mmu);
  54   void remove(mmu_t* mmu);
  55 };
  56
  57 class gdbserver_t
  58 {
  59 public:
  60   // Create a new server, listening for connections from localhost on the given
  61   // port.
  62   gdbserver_t(uint16_t port, sim_t *sim);
  63
  64   // Process all pending messages from a client.
  65   void handle();
  66
  67   void handle_packet(const std::vector<uint8_t> &packet);
  68   void handle_interrupt();
  69
  70   void handle_breakpoint(const std::vector<uint8_t> &packet);
  71   void handle_continue(const std::vector<uint8_t> &packet);
  72   void handle_extended(const std::vector<uint8_t> &packet);
  73   void handle_general_registers_read(const std::vector<uint8_t> &packet);
  74   void handle_halt_reason(const std::vector<uint8_t> &packet);
  75   void handle_kill(const std::vector<uint8_t> &packet);
  76   void handle_memory_binary_write(const std::vector<uint8_t> &packet);
  77   void handle_memory_read(const std::vector<uint8_t> &packet);
  78   void handle_query(const std::vector<uint8_t> &packet);
  79   void handle_register_read(const std::vector<uint8_t> &packet);
  80   void handle_register_write(const std::vector<uint8_t> &packet);
  81   void handle_step(const std::vector<uint8_t> &packet);
  82
  83 private:
  84   sim_t *sim;
  85   int socket_fd;
  86   int client_fd;
  87   circular_buffer_t<uint8_t> recv_buf;
  88   circular_buffer_t<uint8_t> send_buf;
  89
  90   bool expect_ack;
  91   bool extended_mode;
  92   // Used to track whether we think the target is running. If we think it is
  93   // but it isn't, we need to tell gdb about it.
  94   bool running;
  95
  96   std::map <reg_t, software_breakpoint_t> breakpoints;
  97
  98   // Read pending data from the client.
  99   void read();
 100   void write();
 101   // Accept a new client if there isn't one already connected.
 102   void accept();
 103   // Process all complete requests in recv_buf.
 104   void process_requests();
 105   // Add the given message to send_buf.
 106   void send(const char* msg);
 107   // Hex-encode a 64-bit value, and send it to gcc in target byte order (little
 108   // endian).
 109   void send(uint64_t value);
 110   // Hex-encode a 32-bit value, and send it to gcc in target byte order (little
 111   // endian).
 112   void send(uint32_t value);
 113   void send_packet(const char* data);
 114   uint8_t running_checksum;
 115   void send_running_checksum();
 116 };
 117
 118 #endif