6 #include <sys/socket.h>
17 #include "gdbserver.h"
20 #define C_EBREAK 0x9002
21 #define EBREAK 0x00100073
23 // Functions to generate RISC-V opcodes.
24 // TODO: Does this already exist somewhere?
27 static uint32_t bits(uint32_t value
, unsigned int hi
, unsigned int lo
) {
28 return (value
>> lo
) & ((1 << (hi
+1-lo
)) - 1);
31 static uint32_t bit(uint32_t value
, unsigned int b
) {
32 return (value
>> b
) & 1;
35 static uint32_t jal(unsigned int rd
, uint32_t imm
) {
36 return (bit(imm
, 20) << 31) |
37 (bits(imm
, 10, 1) << 21) |
38 (bit(imm
, 11) << 20) |
39 (bits(imm
, 19, 12) << 12) |
44 static uint32_t csrsi(unsigned int csr
, uint8_t imm
) {
46 (bits(imm
, 4, 0) << 15) |
50 static uint32_t csrr(unsigned int rd
, unsigned int csr
) {
51 return (csr
<< 20) | (rd
<< 15) | MATCH_CSRRS
;
54 static uint32_t sw(unsigned int src
, unsigned int base
, uint16_t offset
)
56 return (bits(offset
, 11, 5) << 25) |
59 (bits(offset
, 4, 0) << 7) |
64 unsigned int circular_buffer_t
<T
>::size() const
69 return end
+ capacity
- start
;
73 void circular_buffer_t
<T
>::consume(unsigned int bytes
)
75 start
= (start
+ bytes
) % capacity
;
79 unsigned int circular_buffer_t
<T
>::contiguous_empty_size() const
83 return capacity
- end
- 1;
85 return capacity
- end
;
87 return start
- end
- 1;
91 unsigned int circular_buffer_t
<T
>::contiguous_data_size() const
96 return capacity
- start
;
100 void circular_buffer_t
<T
>::data_added(unsigned int bytes
)
103 assert(end
<= capacity
);
108 template <typename T
>
109 void circular_buffer_t
<T
>::reset()
115 template <typename T
>
116 void circular_buffer_t
<T
>::append(const T
*src
, unsigned int count
)
118 unsigned int copy
= std::min(count
, contiguous_empty_size());
119 memcpy(contiguous_empty(), src
, copy
* sizeof(T
));
123 assert(count
< contiguous_empty_size());
124 memcpy(contiguous_empty(), src
, count
* sizeof(T
));
129 gdbserver_t::gdbserver_t(uint16_t port
, sim_t
*sim
) :
132 recv_buf(64 * 1024), send_buf(64 * 1024)
134 socket_fd
= socket(AF_INET
, SOCK_STREAM
, 0);
135 if (socket_fd
== -1) {
136 fprintf(stderr
, "failed to make socket: %s (%d)\n", strerror(errno
), errno
);
140 fcntl(socket_fd
, F_SETFL
, O_NONBLOCK
);
142 if (setsockopt(socket_fd
, SOL_SOCKET
, SO_REUSEADDR
, &reuseaddr
,
143 sizeof(int)) == -1) {
144 fprintf(stderr
, "failed setsockopt: %s (%d)\n", strerror(errno
), errno
);
148 struct sockaddr_in addr
;
149 memset(&addr
, 0, sizeof(addr
));
150 addr
.sin_family
= AF_INET
;
151 addr
.sin_addr
.s_addr
= INADDR_ANY
;
152 addr
.sin_port
= htons(port
);
154 if (bind(socket_fd
, (struct sockaddr
*) &addr
, sizeof(addr
)) == -1) {
155 fprintf(stderr
, "failed to bind socket: %s (%d)\n", strerror(errno
), errno
);
159 if (listen(socket_fd
, 1) == -1) {
160 fprintf(stderr
, "failed to listen on socket: %s (%d)\n", strerror(errno
), errno
);
165 void gdbserver_t::write_debug_ram(unsigned int index
, uint32_t value
)
167 sim
->debug_module
.ram_write32(index
, value
);
170 uint32_t gdbserver_t::read_debug_ram(unsigned int index
)
172 return sim
->debug_module
.ram_read32(index
);
175 void gdbserver_t::halt()
177 processor_t
*p
= sim
->get_core(0);
178 write_debug_ram(0, csrsi(DCSR_ADDRESS
, DCSR_HALT_OFFSET
));
179 write_debug_ram(1, csrr(S1
, DPC_ADDRESS
));
180 write_debug_ram(2, sw(S1
, 0, (uint16_t) DEBUG_RAM_START
));
181 write_debug_ram(3, csrr(S1
, DCSR_ADDRESS
));
182 write_debug_ram(4, sw(S1
, 0, (uint16_t) DEBUG_RAM_START
+ 8));
183 write_debug_ram(5, jal(0, (uint32_t) (DEBUG_ROM_RESUME
- (DEBUG_RAM_START
+ 4*5))));
184 sim
->debug_module
.set_interrupt(p
->id
);
185 state
= STATE_HALTING
;
188 void gdbserver_t::accept()
190 client_fd
= ::accept(socket_fd
, NULL
, NULL
);
191 if (client_fd
== -1) {
192 if (errno
== EAGAIN
) {
193 // No client waiting to connect right now.
195 fprintf(stderr
, "failed to accept on socket: %s (%d)\n", strerror(errno
),
200 fcntl(client_fd
, F_SETFL
, O_NONBLOCK
);
203 extended_mode
= false;
205 // gdb wants the core to be halted when it attaches.
210 void gdbserver_t::read()
212 // Reading from a non-blocking socket still blocks if there is no data
215 size_t count
= recv_buf
.contiguous_empty_size();
217 ssize_t bytes
= ::read(client_fd
, recv_buf
.contiguous_empty(), count
);
219 if (errno
== EAGAIN
) {
220 // We'll try again the next call.
222 fprintf(stderr
, "failed to read on socket: %s (%d)\n", strerror(errno
), errno
);
225 } else if (bytes
== 0) {
226 // The remote disconnected.
228 processor_t
*p
= sim
->get_core(0);
229 // TODO p->set_halted(false, HR_NONE);
233 recv_buf
.data_added(bytes
);
237 void gdbserver_t::write()
239 if (send_buf
.empty())
242 while (!send_buf
.empty()) {
243 unsigned int count
= send_buf
.contiguous_data_size();
245 ssize_t bytes
= ::write(client_fd
, send_buf
.contiguous_data(), count
);
247 fprintf(stderr
, "failed to write to socket: %s (%d)\n", strerror(errno
), errno
);
249 } else if (bytes
== 0) {
250 // Client can't take any more data right now.
253 fprintf(stderr
, "wrote %ld bytes: ", bytes
);
254 for (unsigned int i
= 0; i
< bytes
; i
++) {
255 fprintf(stderr
, "%c", send_buf
[i
]);
257 fprintf(stderr
, "\n");
258 send_buf
.consume(bytes
);
263 void print_packet(const std::vector
<uint8_t> &packet
)
265 for (uint8_t c
: packet
) {
266 if (c
>= ' ' and c
<= '~')
267 fprintf(stderr
, "%c", c
);
269 fprintf(stderr
, "\\x%x", c
);
271 fprintf(stderr
, "\n");
274 uint8_t compute_checksum(const std::vector
<uint8_t> &packet
)
276 uint8_t checksum
= 0;
277 for (auto i
= packet
.begin() + 1; i
!= packet
.end() - 3; i
++ ) {
283 uint8_t character_hex_value(uint8_t character
)
285 if (character
>= '0' && character
<= '9')
286 return character
- '0';
287 if (character
>= 'a' && character
<= 'f')
288 return 10 + character
- 'a';
289 if (character
>= 'A' && character
<= 'F')
290 return 10 + character
- 'A';
294 uint8_t extract_checksum(const std::vector
<uint8_t> &packet
)
296 return character_hex_value(*(packet
.end() - 1)) +
297 16 * character_hex_value(*(packet
.end() - 2));
300 void gdbserver_t::process_requests()
302 // See https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
304 while (!recv_buf
.empty()) {
305 std::vector
<uint8_t> packet
;
306 for (unsigned int i
= 0; i
< recv_buf
.size(); i
++) {
307 uint8_t b
= recv_buf
[i
];
309 if (packet
.empty() && expect_ack
&& b
== '+') {
314 if (packet
.empty() && b
== 3) {
315 fprintf(stderr
, "Received interrupt\n");
322 // Start of new packet.
323 if (!packet
.empty()) {
324 fprintf(stderr
, "Received malformed %ld-byte packet from debug client: ",
326 print_packet(packet
);
334 // Packets consist of $<packet-data>#<checksum>
335 // where <checksum> is
336 if (packet
.size() >= 4 &&
337 packet
[packet
.size()-3] == '#') {
338 handle_packet(packet
);
339 recv_buf
.consume(i
+1);
343 // There's a partial packet in the buffer. Wait until we get more data to
351 void gdbserver_t::handle_halt_reason(const std::vector
<uint8_t> &packet
)
356 void gdbserver_t::handle_general_registers_read(const std::vector
<uint8_t> &packet
)
358 // Register order that gdb expects is:
359 // "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
360 // "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
361 // "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
362 // "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
364 // Each byte of register data is described by two hex digits. The bytes with
365 // the register are transmitted in target byte order. The size of each
366 // register and their position within the ‘g’ packet are determined by the
367 // gdb internal gdbarch functions DEPRECATED_REGISTER_RAW_SIZE and
368 // gdbarch_register_name.
371 running_checksum
= 0;
372 processor_t
*p
= sim
->get_core(0);
373 for (int r
= 0; r
< 32; r
++) {
374 send(p
->state
.XPR
[r
]);
376 send_running_checksum();
380 // First byte is the most-significant one.
381 // Eg. "08675309" becomes 0x08675309.
382 uint64_t consume_hex_number(std::vector
<uint8_t>::const_iterator
&iter
,
383 std::vector
<uint8_t>::const_iterator end
)
387 while (iter
!= end
) {
389 uint64_t c_value
= character_hex_value(c
);
399 // First byte is the least-significant one.
400 // Eg. "08675309" becomes 0x09536708
401 uint64_t consume_hex_number_le(std::vector
<uint8_t>::const_iterator
&iter
,
402 std::vector
<uint8_t>::const_iterator end
)
405 unsigned int shift
= 4;
407 while (iter
!= end
) {
409 uint64_t c_value
= character_hex_value(c
);
413 value
|= c_value
<< shift
;
414 if ((shift
% 8) == 0)
422 void consume_string(std::string
&str
, std::vector
<uint8_t>::const_iterator
&iter
,
423 std::vector
<uint8_t>::const_iterator end
, uint8_t separator
)
425 while (iter
!= end
&& *iter
!= separator
) {
426 str
.append(1, (char) *iter
);
431 // gdb's register list is defined in riscv_gdb_reg_names gdb/riscv-tdep.c in
432 // its source tree. We must interpret the numbers the same here.
444 void gdbserver_t::handle_register_read(const std::vector
<uint8_t> &packet
)
448 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
449 unsigned int n
= consume_hex_number(iter
, packet
.end());
451 return send_packet("E01");
453 processor_t
*p
= sim
->get_core(0);
455 running_checksum
= 0;
457 if (n
>= REG_XPR0
&& n
<= REG_XPR31
) {
458 send(p
->state
.XPR
[n
- REG_XPR0
]);
459 } else if (n
== REG_PC
) {
461 } else if (n
>= REG_FPR0
&& n
<= REG_FPR31
) {
462 send(p
->state
.FPR
[n
- REG_FPR0
]);
463 } else if (n
>= REG_CSR0
&& n
<= REG_CSR4095
) {
465 send(p
->get_csr(n
- REG_CSR0
));
467 // It would be nicer to return an error here, but if you do that then gdb
468 // exits out of 'info registers all' as soon as it encounters a register
469 // that can't be read.
473 return send_packet("E02");
476 send_running_checksum();
480 void gdbserver_t::handle_register_write(const std::vector
<uint8_t> &packet
)
484 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
485 unsigned int n
= consume_hex_number(iter
, packet
.end());
487 return send_packet("E05");
490 reg_t value
= consume_hex_number_le(iter
, packet
.end());
492 return send_packet("E06");
494 processor_t
*p
= sim
->get_core(0);
496 if (n
>= REG_XPR0
&& n
<= REG_XPR31
) {
497 p
->state
.XPR
.write(n
- REG_XPR0
, value
);
498 } else if (n
== REG_PC
) {
500 } else if (n
>= REG_FPR0
&& n
<= REG_FPR31
) {
501 p
->state
.FPR
.write(n
- REG_FPR0
, value
);
502 } else if (n
>= REG_CSR0
&& n
<= REG_CSR4095
) {
504 p
->set_csr(n
- REG_CSR0
, value
);
506 return send_packet("EFF");
509 return send_packet("E07");
512 return send_packet("OK");
515 void gdbserver_t::handle_memory_read(const std::vector
<uint8_t> &packet
)
518 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
519 reg_t address
= consume_hex_number(iter
, packet
.end());
521 return send_packet("E10");
523 reg_t length
= consume_hex_number(iter
, packet
.end());
525 return send_packet("E11");
528 running_checksum
= 0;
530 processor_t
*p
= sim
->get_core(0);
531 mmu_t
* mmu
= sim
->debug_mmu
;
533 for (reg_t i
= 0; i
< length
; i
++) {
534 sprintf(buffer
, "%02x", mmu
->load_uint8(address
+ i
));
537 send_running_checksum();
540 void gdbserver_t::handle_memory_binary_write(const std::vector
<uint8_t> &packet
)
542 // X addr,length:XX...
543 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
544 reg_t address
= consume_hex_number(iter
, packet
.end());
546 return send_packet("E20");
548 reg_t length
= consume_hex_number(iter
, packet
.end());
550 return send_packet("E21");
553 processor_t
*p
= sim
->get_core(0);
554 mmu_t
* mmu
= sim
->debug_mmu
;
555 for (unsigned int i
= 0; i
< length
; i
++) {
556 if (iter
== packet
.end()) {
557 return send_packet("E22");
559 mmu
->store_uint8(address
+ i
, *iter
);
563 return send_packet("E4b"); // EOVERFLOW
568 void gdbserver_t::handle_continue(const std::vector
<uint8_t> &packet
)
571 processor_t
*p
= sim
->get_core(0);
572 if (packet
[2] != '#') {
573 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
574 p
->state
.pc
= consume_hex_number(iter
, packet
.end());
576 return send_packet("E30");
579 // TODO p->set_halted(false, HR_NONE);
580 // TODO running = true;
583 void gdbserver_t::handle_step(const std::vector
<uint8_t> &packet
)
586 processor_t
*p
= sim
->get_core(0);
587 if (packet
[2] != '#') {
588 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
589 p
->state
.pc
= consume_hex_number(iter
, packet
.end());
591 return send_packet("E40");
594 // TODO: p->set_single_step(true);
595 // TODO running = true;
598 void gdbserver_t::handle_kill(const std::vector
<uint8_t> &packet
)
601 // The exact effect of this packet is not specified.
602 // Looks like OpenOCD disconnects?
606 void gdbserver_t::handle_extended(const std::vector
<uint8_t> &packet
)
608 // Enable extended mode. In extended mode, the remote server is made
609 // persistent. The ‘R’ packet is used to restart the program being debugged.
611 extended_mode
= true;
614 void software_breakpoint_t::insert(mmu_t
* mmu
)
617 instruction
= mmu
->load_uint16(address
);
618 mmu
->store_uint16(address
, C_EBREAK
);
620 instruction
= mmu
->load_uint32(address
);
621 mmu
->store_uint32(address
, EBREAK
);
623 fprintf(stderr
, ">>> Read %x from %lx\n", instruction
, address
);
626 void software_breakpoint_t::remove(mmu_t
* mmu
)
628 fprintf(stderr
, ">>> write %x to %lx\n", instruction
, address
);
630 mmu
->store_uint16(address
, instruction
);
632 mmu
->store_uint32(address
, instruction
);
636 void gdbserver_t::handle_breakpoint(const std::vector
<uint8_t> &packet
)
638 // insert: Z type,addr,kind
639 // remove: z type,addr,kind
641 software_breakpoint_t bp
;
642 bool insert
= (packet
[1] == 'Z');
643 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
644 int type
= consume_hex_number(iter
, packet
.end());
646 return send_packet("E50");
648 bp
.address
= consume_hex_number(iter
, packet
.end());
650 return send_packet("E51");
652 bp
.size
= consume_hex_number(iter
, packet
.end());
653 // There may be more options after a ; here, but we don't support that.
655 return send_packet("E52");
657 if (bp
.size
!= 2 && bp
.size
!= 4) {
658 return send_packet("E53");
661 processor_t
*p
= sim
->get_core(0);
665 breakpoints
[bp
.address
] = bp
;
668 bp
= breakpoints
[bp
.address
];
670 breakpoints
.erase(bp
.address
);
673 sim
->debug_mmu
->flush_icache();
674 return send_packet("OK");
677 void gdbserver_t::handle_query(const std::vector
<uint8_t> &packet
)
680 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
682 consume_string(name
, iter
, packet
.end(), ':');
683 if (iter
!= packet
.end())
685 if (name
== "Supported") {
687 running_checksum
= 0;
688 while (iter
!= packet
.end()) {
690 consume_string(feature
, iter
, packet
.end(), ';');
691 if (iter
!= packet
.end())
693 if (feature
== "swbreak+") {
697 return send_running_checksum();
700 fprintf(stderr
, "Unsupported query %s\n", name
.c_str());
701 return send_packet("");
704 void gdbserver_t::handle_packet(const std::vector
<uint8_t> &packet
)
706 if (compute_checksum(packet
) != extract_checksum(packet
)) {
707 fprintf(stderr
, "Received %ld-byte packet with invalid checksum\n", packet
.size());
708 fprintf(stderr
, "Computed checksum: %x\n", compute_checksum(packet
));
709 print_packet(packet
);
714 fprintf(stderr
, "Received %ld-byte packet from debug client: ", packet
.size());
715 print_packet(packet
);
720 return handle_extended(packet
);
722 return handle_halt_reason(packet
);
724 return handle_general_registers_read(packet
);
726 return handle_kill(packet
);
728 return handle_memory_read(packet
);
730 // return handle_memory_write(packet);
732 return handle_memory_binary_write(packet
);
734 return handle_register_read(packet
);
736 return handle_register_write(packet
);
738 return handle_continue(packet
);
740 return handle_step(packet
);
743 return handle_breakpoint(packet
);
746 return handle_query(packet
);
750 fprintf(stderr
, "** Unsupported packet: ");
751 print_packet(packet
);
755 void gdbserver_t::handle_interrupt()
757 processor_t
*p
= sim
->get_core(0);
758 // TODO p->set_halted(true, HR_INTERRUPT);
759 send_packet("S02"); // Pretend program received SIGINT.
760 // TODO running = false;
763 void gdbserver_t::handle()
766 processor_t
*p
= sim
->get_core(0);
768 if (state
== STATE_HALTING
&& sim
->debug_module
.get_interrupt(p
->id
) == 0) {
769 // gdb requested a halt and now it's done.
771 fprintf(stderr
, "DPC: 0x%x\n", read_debug_ram(0));
772 fprintf(stderr
, "DCSR: 0x%x\n", read_debug_ram(2));
773 state
= STATE_HALTED
;
777 if (running && p->halted) {
778 // The core was running, but now it's halted. Better tell gdb.
779 switch (p->halt_reason) {
781 fprintf(stderr, "Internal error. Processor halted without reason.\n");
787 // There's no gdb code for this.
791 send_packet("T05swbreak:;");
795 // TODO: Actually include register values here
807 this->process_requests();
810 void gdbserver_t::send(const char* msg
)
812 unsigned int length
= strlen(msg
);
813 for (const char *c
= msg
; *c
; c
++)
814 running_checksum
+= *c
;
815 send_buf
.append((const uint8_t *) msg
, length
);
818 void gdbserver_t::send(uint64_t value
)
821 for (unsigned int i
= 0; i
< 8; i
++) {
822 sprintf(buffer
, "%02x", (int) (value
& 0xff));
828 void gdbserver_t::send(uint32_t value
)
831 for (unsigned int i
= 0; i
< 4; i
++) {
832 sprintf(buffer
, "%02x", (int) (value
& 0xff));
838 void gdbserver_t::send_packet(const char* data
)
841 running_checksum
= 0;
843 send_running_checksum();
847 void gdbserver_t::send_running_checksum()
849 char checksum_string
[4];
850 sprintf(checksum_string
, "#%02x", running_checksum
);
851 send(checksum_string
);