riscv/gdbserver.h

   1 #ifndef _RISCV_GDBSERVER_H
   2 #define _RISCV_GDBSERVER_H
   3
   4 #include <map>
   5 #include <queue>
   6
   7 #include <stdint.h>
   8
   9 class sim_t;
  10
  11 template <typename T>
  12 class circular_buffer_t
  13 {
  14 public:
  15   // The buffer can store capacity-1 data elements.
  16   circular_buffer_t(unsigned int capacity) : data(new T[capacity]),
  17       start(0), end(0), capacity(capacity) {}
  18   circular_buffer_t() : start(0), end(0), capacity(0) {}
  19   ~circular_buffer_t() { delete[] data; }
  20
  21   T *data;
  22   unsigned int start;   // Data start, inclusive.
  23   unsigned int end;     // Data end, exclusive.
  24   unsigned int capacity;    // Size of the buffer.
  25   unsigned int size() const;
  26   bool empty() const { return start == end; }
  27   bool full() const { return ((end+1) % capacity) == start; }
  28
  29   // Return size and address of the block of RAM where more data can be copied
  30   // to be added to the buffer.
  31   unsigned int contiguous_empty_size() const;
  32   T *contiguous_empty() { return data + end; }
  33   void data_added(unsigned int bytes);
  34
  35   unsigned int contiguous_data_size() const;
  36   T *contiguous_data() { return data + start; }
  37   // Tell the buffer that some bytes were consumed from the start of the
  38   // buffer.
  39   void consume(unsigned int bytes);
  40
  41   void reset();
  42
  43   T operator[](unsigned int i) const { return data[(start + i) % capacity]; }
  44
  45   void append(const T *src, unsigned int count);
  46 };
  47
  48 // Class to track software breakpoints that we set.
  49 class software_breakpoint_t
  50 {
  51 public:
  52   reg_t address;
  53   unsigned int size;
  54   unsigned char instruction[4];
  55 };
  56
  57 class gdbserver_t;
  58
  59 class operation_t
  60 {
  61   public:
  62     operation_t(gdbserver_t& gdbserver) : gs(gdbserver), current_step(0) {}
  63     virtual ~operation_t() {}
  64
  65     bool step() {
  66       bool result = perform_step(current_step);
  67       current_step++;
  68       return result;
  69     }
  70
  71     // Perform the next step of this operation (which is probably to write to
  72     // Debug RAM and assert the debug interrupt).
  73     // Return true if this operation is complete. In that case the object will
  74     // be deleted.
  75     // Return false if more steps are required the next time the debug
  76     // interrupt is clear.
  77     virtual bool perform_step(unsigned int step) = 0;
  78
  79   protected:
  80     gdbserver_t& gs;
  81     unsigned int current_step;
  82 };
  83
  84 class gdbserver_t
  85 {
  86 public:
  87   // Create a new server, listening for connections from localhost on the given
  88   // port.
  89   gdbserver_t(uint16_t port, sim_t *sim);
  90
  91   // Process all pending messages from a client.
  92   void handle();
  93
  94   void handle_packet(const std::vector<uint8_t> &packet);
  95   void handle_interrupt();
  96
  97   void handle_breakpoint(const std::vector<uint8_t> &packet);
  98   void handle_continue(const std::vector<uint8_t> &packet);
  99   void handle_extended(const std::vector<uint8_t> &packet);
 100   void handle_general_registers_read(const std::vector<uint8_t> &packet);
 101   void continue_general_registers_read();
 102   void handle_halt_reason(const std::vector<uint8_t> &packet);
 103   void handle_kill(const std::vector<uint8_t> &packet);
 104   void handle_memory_binary_write(const std::vector<uint8_t> &packet);
 105   void handle_memory_read(const std::vector<uint8_t> &packet);
 106   void handle_query(const std::vector<uint8_t> &packet);
 107   void handle_register_read(const std::vector<uint8_t> &packet);
 108   void continue_register_read();
 109   void handle_register_write(const std::vector<uint8_t> &packet);
 110   void handle_step(const std::vector<uint8_t> &packet);
 111
 112   bool connected() const { return client_fd > 0; }
 113
 114   // TODO: Move this into its own packet sending class?
 115   // Add the given message to send_buf.
 116   void send(const char* msg);
 117   // Hex-encode a 64-bit value, and send it to gcc in target byte order (little
 118   // endian).
 119   void send(uint64_t value);
 120   // Hex-encode a 32-bit value, and send it to gcc in target byte order (little
 121   // endian).
 122   void send(uint32_t value);
 123   void send_packet(const char* data);
 124   uint8_t running_checksum;
 125   // Send "$" and clear running checksum.
 126   void start_packet();
 127   // Send "#" and checksum.
 128   void end_packet(const char* data=NULL);
 129
 130   // Write value to the index'th word in Debug RAM.
 131   void write_debug_ram(unsigned int index, uint32_t value);
 132   uint32_t read_debug_ram(unsigned int index);
 133
 134   void set_interrupt(uint32_t hartid);
 135
 136   // Members that ought to be privated, but that we'd really like to access
 137   // from operation classes.
 138   reg_t saved_dpc;
 139   reg_t saved_mbadaddr;
 140   reg_t saved_mcause;
 141   reg_t saved_mstatus;
 142   reg_t dcsr;
 143   reg_t sptbr;
 144   bool sptbr_valid;
 145
 146   std::map<reg_t, reg_t> pte_cache;
 147
 148   reg_t translate(reg_t vaddr);
 149   // Return the PRV_x that is used when the code under debug performs a memory
 150   // access.
 151   unsigned int privilege_mode();
 152   // Return the VM_x that is used when the code under debug performs a memory
 153   // access.
 154   unsigned int virtual_memory();
 155
 156 private:
 157   sim_t *sim;
 158   int socket_fd;
 159   int client_fd;
 160   circular_buffer_t<uint8_t> recv_buf;
 161   circular_buffer_t<uint8_t> send_buf;
 162
 163   bool expect_ack;
 164   bool extended_mode;
 165   // Used to track whether we think the target is running. If we think it is
 166   // but it isn't, we need to tell gdb about it.
 167   bool running;
 168
 169   std::map <reg_t, software_breakpoint_t> breakpoints;
 170
 171   // Read pending data from the client.
 172   void read();
 173   void write();
 174   // Accept a new client if there isn't one already connected.
 175   void accept();
 176   // Process all complete requests in recv_buf.
 177   void process_requests();
 178
 179   std::queue<operation_t*> operation_queue;
 180   void add_operation(operation_t* operation);
 181 };
 182
 183 #endif