1 #ifndef _RISCV_GDBSERVER_H
2 #define _RISCV_GDBSERVER_H
12 class circular_buffer_t
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
; }
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
; }
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
);
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
39 void consume(unsigned int bytes
);
43 T
operator[](unsigned int i
) const { return data
[(start
+ i
) % capacity
]; }
45 void append(const T
*src
, unsigned int count
);
48 // Class to track software breakpoints that we set.
49 class software_breakpoint_t
54 unsigned char instruction
[4];
62 operation_t(gdbserver_t
& gdbserver
) : gs(gdbserver
), current_step(0) {}
63 virtual ~operation_t() {}
66 bool result
= perform_step(current_step
);
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
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;
81 unsigned int current_step
;
87 // Create a new server, listening for connections from localhost on the given
89 gdbserver_t(uint16_t port
, sim_t
*sim
);
91 // Process all pending messages from a client.
94 void handle_packet(const std::vector
<uint8_t> &packet
);
95 void handle_interrupt();
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
);
112 bool connected() const { return client_fd
> 0; }
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
119 void send(uint64_t value
);
120 // Hex-encode a 32-bit value, and send it to gcc in target byte order (little
122 void send(uint32_t value
);
123 void send_packet(const char* data
);
124 uint8_t running_checksum
;
125 // Send "$" and clear running checksum.
127 // Send "#" and checksum.
128 void end_packet(const char* data
=NULL
);
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
);
134 void set_interrupt(uint32_t hartid
);
136 // Members that ought to be privated, but that we'd really like to access
137 // from operation classes.
139 reg_t saved_mbadaddr
;
146 std::map
<reg_t
, reg_t
> pte_cache
;
148 reg_t
translate(reg_t vaddr
);
149 // Return the PRV_x that is used when the code under debug performs a memory
151 unsigned int privilege_mode();
152 // Return the VM_x that is used when the code under debug performs a memory
154 unsigned int virtual_memory();
160 circular_buffer_t
<uint8_t> recv_buf
;
161 circular_buffer_t
<uint8_t> send_buf
;
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.
169 std::map
<reg_t
, software_breakpoint_t
*> breakpoints
;
171 // Read pending data from the client.
174 // Accept a new client if there isn't one already connected.
176 // Process all complete requests in recv_buf.
177 void process_requests();
179 std::queue
<operation_t
*> operation_queue
;
180 void add_operation(operation_t
* operation
);