1 #ifndef _RISCV_GDBSERVER_H
2 #define _RISCV_GDBSERVER_H
9 class circular_buffer_t
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
; }
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
; }
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
);
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
36 void consume(unsigned int bytes
);
40 T
operator[](unsigned int i
) const { return data
[(start
+ i
) % capacity
]; }
42 void append(const T
*src
, unsigned int count
);
45 // Class to track software breakpoints that we set.
46 class software_breakpoint_t
53 void insert(mmu_t
* mmu
);
54 void remove(mmu_t
* mmu
);
60 // Create a new server, listening for connections from localhost on the given
62 gdbserver_t(uint16_t port
, sim_t
*sim
);
64 // Process all pending messages from a client.
67 void handle_packet(const std::vector
<uint8_t> &packet
);
68 void handle_interrupt();
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_step(const std::vector
<uint8_t> &packet
);
86 circular_buffer_t
<uint8_t> recv_buf
;
87 circular_buffer_t
<uint8_t> send_buf
;
91 // Used to track whether we think the target is running. If we think it is
92 // but it isn't, we need to tell gdb about it.
95 std::map
<reg_t
, software_breakpoint_t
> breakpoints
;
97 // Read pending data from the client.
100 // Accept a new client if there isn't one already connected.
102 // Process all complete requests in recv_buf.
103 void process_requests();
104 // Add the given message to send_buf.
105 void send(const char* msg
);
106 // Hex-encode a 64-bit value, and send it to gcc in target byte order (little
108 void send(uint64_t value
);
109 // Hex-encode a 32-bit value, and send it to gcc in target byte order (little
111 void send(uint32_t value
);
112 void send_packet(const char* data
);
113 uint8_t running_checksum
;
114 void send_running_checksum();