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?
26 // Using regnames.cc as source. The RVG Calling Convention of the 2.0 RISC-V
27 // spec says it should be 2 and 3.
30 static uint32_t bits(uint32_t value
, unsigned int hi
, unsigned int lo
) {
31 return (value
>> lo
) & ((1 << (hi
+1-lo
)) - 1);
34 static uint32_t bit(uint32_t value
, unsigned int b
) {
35 return (value
>> b
) & 1;
38 static uint32_t jal(unsigned int rd
, uint32_t imm
) {
39 return (bit(imm
, 20) << 31) |
40 (bits(imm
, 10, 1) << 21) |
41 (bit(imm
, 11) << 20) |
42 (bits(imm
, 19, 12) << 12) |
47 static uint32_t csrsi(unsigned int csr
, uint8_t imm
) {
49 (bits(imm
, 4, 0) << 15) |
53 static uint32_t csrr(unsigned int rd
, unsigned int csr
) {
54 return (csr
<< 20) | (rd
<< 7) | MATCH_CSRRS
;
57 static uint32_t sw(unsigned int src
, unsigned int base
, uint16_t offset
)
59 return (bits(offset
, 11, 5) << 25) |
62 (bits(offset
, 4, 0) << 7) |
67 unsigned int circular_buffer_t
<T
>::size() const
72 return end
+ capacity
- start
;
76 void circular_buffer_t
<T
>::consume(unsigned int bytes
)
78 start
= (start
+ bytes
) % capacity
;
82 unsigned int circular_buffer_t
<T
>::contiguous_empty_size() const
86 return capacity
- end
- 1;
88 return capacity
- end
;
90 return start
- end
- 1;
94 unsigned int circular_buffer_t
<T
>::contiguous_data_size() const
99 return capacity
- start
;
102 template <typename T
>
103 void circular_buffer_t
<T
>::data_added(unsigned int bytes
)
106 assert(end
<= capacity
);
111 template <typename T
>
112 void circular_buffer_t
<T
>::reset()
118 template <typename T
>
119 void circular_buffer_t
<T
>::append(const T
*src
, unsigned int count
)
121 unsigned int copy
= std::min(count
, contiguous_empty_size());
122 memcpy(contiguous_empty(), src
, copy
* sizeof(T
));
126 assert(count
< contiguous_empty_size());
127 memcpy(contiguous_empty(), src
, count
* sizeof(T
));
132 gdbserver_t::gdbserver_t(uint16_t port
, sim_t
*sim
) :
135 recv_buf(64 * 1024), send_buf(64 * 1024)
137 socket_fd
= socket(AF_INET
, SOCK_STREAM
, 0);
138 if (socket_fd
== -1) {
139 fprintf(stderr
, "failed to make socket: %s (%d)\n", strerror(errno
), errno
);
143 fcntl(socket_fd
, F_SETFL
, O_NONBLOCK
);
145 if (setsockopt(socket_fd
, SOL_SOCKET
, SO_REUSEADDR
, &reuseaddr
,
146 sizeof(int)) == -1) {
147 fprintf(stderr
, "failed setsockopt: %s (%d)\n", strerror(errno
), errno
);
151 struct sockaddr_in addr
;
152 memset(&addr
, 0, sizeof(addr
));
153 addr
.sin_family
= AF_INET
;
154 addr
.sin_addr
.s_addr
= INADDR_ANY
;
155 addr
.sin_port
= htons(port
);
157 if (bind(socket_fd
, (struct sockaddr
*) &addr
, sizeof(addr
)) == -1) {
158 fprintf(stderr
, "failed to bind socket: %s (%d)\n", strerror(errno
), errno
);
162 if (listen(socket_fd
, 1) == -1) {
163 fprintf(stderr
, "failed to listen on socket: %s (%d)\n", strerror(errno
), errno
);
168 void gdbserver_t::write_debug_ram(unsigned int index
, uint32_t value
)
170 sim
->debug_module
.ram_write32(index
, value
);
173 uint32_t gdbserver_t::read_debug_ram(unsigned int index
)
175 return sim
->debug_module
.ram_read32(index
);
178 void gdbserver_t::halt()
180 processor_t
*p
= sim
->get_core(0);
181 write_debug_ram(0, csrsi(DCSR_ADDRESS
, DCSR_HALT_OFFSET
));
182 write_debug_ram(1, csrr(S0
, DPC_ADDRESS
));
183 write_debug_ram(2, sw(S0
, 0, (uint16_t) DEBUG_RAM_START
));
184 write_debug_ram(3, csrr(S0
, DCSR_ADDRESS
));
185 write_debug_ram(4, sw(S0
, 0, (uint16_t) DEBUG_RAM_START
+ 8));
186 write_debug_ram(5, jal(0, (uint32_t) (DEBUG_ROM_RESUME
- (DEBUG_RAM_START
+ 4*5))));
187 sim
->debug_module
.set_interrupt(p
->id
);
188 state
= STATE_HALTING
;
191 void gdbserver_t::accept()
193 client_fd
= ::accept(socket_fd
, NULL
, NULL
);
194 if (client_fd
== -1) {
195 if (errno
== EAGAIN
) {
196 // No client waiting to connect right now.
198 fprintf(stderr
, "failed to accept on socket: %s (%d)\n", strerror(errno
),
203 fcntl(client_fd
, F_SETFL
, O_NONBLOCK
);
206 extended_mode
= false;
208 // gdb wants the core to be halted when it attaches.
213 void gdbserver_t::read()
215 // Reading from a non-blocking socket still blocks if there is no data
218 size_t count
= recv_buf
.contiguous_empty_size();
220 ssize_t bytes
= ::read(client_fd
, recv_buf
.contiguous_empty(), count
);
222 if (errno
== EAGAIN
) {
223 // We'll try again the next call.
225 fprintf(stderr
, "failed to read on socket: %s (%d)\n", strerror(errno
), errno
);
228 } else if (bytes
== 0) {
229 // The remote disconnected.
231 processor_t
*p
= sim
->get_core(0);
232 // TODO p->set_halted(false, HR_NONE);
236 recv_buf
.data_added(bytes
);
240 void gdbserver_t::write()
242 if (send_buf
.empty())
245 while (!send_buf
.empty()) {
246 unsigned int count
= send_buf
.contiguous_data_size();
248 ssize_t bytes
= ::write(client_fd
, send_buf
.contiguous_data(), count
);
250 fprintf(stderr
, "failed to write to socket: %s (%d)\n", strerror(errno
), errno
);
252 } else if (bytes
== 0) {
253 // Client can't take any more data right now.
256 fprintf(stderr
, "wrote %ld bytes: ", bytes
);
257 for (unsigned int i
= 0; i
< bytes
; i
++) {
258 fprintf(stderr
, "%c", send_buf
[i
]);
260 fprintf(stderr
, "\n");
261 send_buf
.consume(bytes
);
266 void print_packet(const std::vector
<uint8_t> &packet
)
268 for (uint8_t c
: packet
) {
269 if (c
>= ' ' and c
<= '~')
270 fprintf(stderr
, "%c", c
);
272 fprintf(stderr
, "\\x%x", c
);
274 fprintf(stderr
, "\n");
277 uint8_t compute_checksum(const std::vector
<uint8_t> &packet
)
279 uint8_t checksum
= 0;
280 for (auto i
= packet
.begin() + 1; i
!= packet
.end() - 3; i
++ ) {
286 uint8_t character_hex_value(uint8_t character
)
288 if (character
>= '0' && character
<= '9')
289 return character
- '0';
290 if (character
>= 'a' && character
<= 'f')
291 return 10 + character
- 'a';
292 if (character
>= 'A' && character
<= 'F')
293 return 10 + character
- 'A';
297 uint8_t extract_checksum(const std::vector
<uint8_t> &packet
)
299 return character_hex_value(*(packet
.end() - 1)) +
300 16 * character_hex_value(*(packet
.end() - 2));
303 void gdbserver_t::process_requests()
305 // See https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
307 while (!recv_buf
.empty()) {
308 std::vector
<uint8_t> packet
;
309 for (unsigned int i
= 0; i
< recv_buf
.size(); i
++) {
310 uint8_t b
= recv_buf
[i
];
312 if (packet
.empty() && expect_ack
&& b
== '+') {
317 if (packet
.empty() && b
== 3) {
318 fprintf(stderr
, "Received interrupt\n");
325 // Start of new packet.
326 if (!packet
.empty()) {
327 fprintf(stderr
, "Received malformed %ld-byte packet from debug client: ",
329 print_packet(packet
);
337 // Packets consist of $<packet-data>#<checksum>
338 // where <checksum> is
339 if (packet
.size() >= 4 &&
340 packet
[packet
.size()-3] == '#') {
341 handle_packet(packet
);
342 recv_buf
.consume(i
+1);
346 // There's a partial packet in the buffer. Wait until we get more data to
354 void gdbserver_t::handle_halt_reason(const std::vector
<uint8_t> &packet
)
359 void gdbserver_t::handle_general_registers_read(const std::vector
<uint8_t> &packet
)
361 // Register order that gdb expects is:
362 // "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
363 // "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
364 // "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
365 // "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
367 // Each byte of register data is described by two hex digits. The bytes with
368 // the register are transmitted in target byte order. The size of each
369 // register and their position within the ‘g’ packet are determined by the
370 // gdb internal gdbarch functions DEPRECATED_REGISTER_RAW_SIZE and
371 // gdbarch_register_name.
374 running_checksum
= 0;
375 processor_t
*p
= sim
->get_core(0);
376 for (int r
= 0; r
< 32; r
++) {
377 send(p
->state
.XPR
[r
]);
379 send_running_checksum();
383 // First byte is the most-significant one.
384 // Eg. "08675309" becomes 0x08675309.
385 uint64_t consume_hex_number(std::vector
<uint8_t>::const_iterator
&iter
,
386 std::vector
<uint8_t>::const_iterator end
)
390 while (iter
!= end
) {
392 uint64_t c_value
= character_hex_value(c
);
402 // First byte is the least-significant one.
403 // Eg. "08675309" becomes 0x09536708
404 uint64_t consume_hex_number_le(std::vector
<uint8_t>::const_iterator
&iter
,
405 std::vector
<uint8_t>::const_iterator end
)
408 unsigned int shift
= 4;
410 while (iter
!= end
) {
412 uint64_t c_value
= character_hex_value(c
);
416 value
|= c_value
<< shift
;
417 if ((shift
% 8) == 0)
425 void consume_string(std::string
&str
, std::vector
<uint8_t>::const_iterator
&iter
,
426 std::vector
<uint8_t>::const_iterator end
, uint8_t separator
)
428 while (iter
!= end
&& *iter
!= separator
) {
429 str
.append(1, (char) *iter
);
434 // gdb's register list is defined in riscv_gdb_reg_names gdb/riscv-tdep.c in
435 // its source tree. We must interpret the numbers the same here.
447 void gdbserver_t::handle_register_read(const std::vector
<uint8_t> &packet
)
451 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
452 unsigned int n
= consume_hex_number(iter
, packet
.end());
454 return send_packet("E01");
456 processor_t
*p
= sim
->get_core(0);
458 running_checksum
= 0;
460 if (n
>= REG_XPR0
&& n
<= REG_XPR31
) {
461 send(p
->state
.XPR
[n
- REG_XPR0
]);
462 } else if (n
== REG_PC
) {
464 } else if (n
>= REG_FPR0
&& n
<= REG_FPR31
) {
465 send(p
->state
.FPR
[n
- REG_FPR0
]);
466 } else if (n
>= REG_CSR0
&& n
<= REG_CSR4095
) {
468 send(p
->get_csr(n
- REG_CSR0
));
470 // It would be nicer to return an error here, but if you do that then gdb
471 // exits out of 'info registers all' as soon as it encounters a register
472 // that can't be read.
476 return send_packet("E02");
479 send_running_checksum();
483 void gdbserver_t::handle_register_write(const std::vector
<uint8_t> &packet
)
487 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
488 unsigned int n
= consume_hex_number(iter
, packet
.end());
490 return send_packet("E05");
493 reg_t value
= consume_hex_number_le(iter
, packet
.end());
495 return send_packet("E06");
497 processor_t
*p
= sim
->get_core(0);
499 if (n
>= REG_XPR0
&& n
<= REG_XPR31
) {
500 p
->state
.XPR
.write(n
- REG_XPR0
, value
);
501 } else if (n
== REG_PC
) {
503 } else if (n
>= REG_FPR0
&& n
<= REG_FPR31
) {
504 p
->state
.FPR
.write(n
- REG_FPR0
, value
);
505 } else if (n
>= REG_CSR0
&& n
<= REG_CSR4095
) {
507 p
->set_csr(n
- REG_CSR0
, value
);
509 return send_packet("EFF");
512 return send_packet("E07");
515 return send_packet("OK");
518 void gdbserver_t::handle_memory_read(const std::vector
<uint8_t> &packet
)
521 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
522 reg_t address
= consume_hex_number(iter
, packet
.end());
524 return send_packet("E10");
526 reg_t length
= consume_hex_number(iter
, packet
.end());
528 return send_packet("E11");
531 running_checksum
= 0;
533 processor_t
*p
= sim
->get_core(0);
534 mmu_t
* mmu
= sim
->debug_mmu
;
536 for (reg_t i
= 0; i
< length
; i
++) {
537 sprintf(buffer
, "%02x", mmu
->load_uint8(address
+ i
));
540 send_running_checksum();
543 void gdbserver_t::handle_memory_binary_write(const std::vector
<uint8_t> &packet
)
545 // X addr,length:XX...
546 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
547 reg_t address
= consume_hex_number(iter
, packet
.end());
549 return send_packet("E20");
551 reg_t length
= consume_hex_number(iter
, packet
.end());
553 return send_packet("E21");
556 processor_t
*p
= sim
->get_core(0);
557 mmu_t
* mmu
= sim
->debug_mmu
;
558 for (unsigned int i
= 0; i
< length
; i
++) {
559 if (iter
== packet
.end()) {
560 return send_packet("E22");
562 mmu
->store_uint8(address
+ i
, *iter
);
566 return send_packet("E4b"); // EOVERFLOW
571 void gdbserver_t::handle_continue(const std::vector
<uint8_t> &packet
)
574 processor_t
*p
= sim
->get_core(0);
575 if (packet
[2] != '#') {
576 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
577 p
->state
.pc
= consume_hex_number(iter
, packet
.end());
579 return send_packet("E30");
582 // TODO p->set_halted(false, HR_NONE);
583 // TODO running = true;
586 void gdbserver_t::handle_step(const std::vector
<uint8_t> &packet
)
589 processor_t
*p
= sim
->get_core(0);
590 if (packet
[2] != '#') {
591 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
592 p
->state
.pc
= consume_hex_number(iter
, packet
.end());
594 return send_packet("E40");
597 // TODO: p->set_single_step(true);
598 // TODO running = true;
601 void gdbserver_t::handle_kill(const std::vector
<uint8_t> &packet
)
604 // The exact effect of this packet is not specified.
605 // Looks like OpenOCD disconnects?
609 void gdbserver_t::handle_extended(const std::vector
<uint8_t> &packet
)
611 // Enable extended mode. In extended mode, the remote server is made
612 // persistent. The ‘R’ packet is used to restart the program being debugged.
614 extended_mode
= true;
617 void software_breakpoint_t::insert(mmu_t
* mmu
)
620 instruction
= mmu
->load_uint16(address
);
621 mmu
->store_uint16(address
, C_EBREAK
);
623 instruction
= mmu
->load_uint32(address
);
624 mmu
->store_uint32(address
, EBREAK
);
626 fprintf(stderr
, ">>> Read %x from %lx\n", instruction
, address
);
629 void software_breakpoint_t::remove(mmu_t
* mmu
)
631 fprintf(stderr
, ">>> write %x to %lx\n", instruction
, address
);
633 mmu
->store_uint16(address
, instruction
);
635 mmu
->store_uint32(address
, instruction
);
639 void gdbserver_t::handle_breakpoint(const std::vector
<uint8_t> &packet
)
641 // insert: Z type,addr,kind
642 // remove: z type,addr,kind
644 software_breakpoint_t bp
;
645 bool insert
= (packet
[1] == 'Z');
646 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
647 int type
= consume_hex_number(iter
, packet
.end());
649 return send_packet("E50");
651 bp
.address
= consume_hex_number(iter
, packet
.end());
653 return send_packet("E51");
655 bp
.size
= consume_hex_number(iter
, packet
.end());
656 // There may be more options after a ; here, but we don't support that.
658 return send_packet("E52");
660 if (bp
.size
!= 2 && bp
.size
!= 4) {
661 return send_packet("E53");
664 processor_t
*p
= sim
->get_core(0);
668 breakpoints
[bp
.address
] = bp
;
671 bp
= breakpoints
[bp
.address
];
673 breakpoints
.erase(bp
.address
);
676 sim
->debug_mmu
->flush_icache();
677 return send_packet("OK");
680 void gdbserver_t::handle_query(const std::vector
<uint8_t> &packet
)
683 std::vector
<uint8_t>::const_iterator iter
= packet
.begin() + 2;
685 consume_string(name
, iter
, packet
.end(), ':');
686 if (iter
!= packet
.end())
688 if (name
== "Supported") {
690 running_checksum
= 0;
691 while (iter
!= packet
.end()) {
693 consume_string(feature
, iter
, packet
.end(), ';');
694 if (iter
!= packet
.end())
696 if (feature
== "swbreak+") {
700 return send_running_checksum();
703 fprintf(stderr
, "Unsupported query %s\n", name
.c_str());
704 return send_packet("");
707 void gdbserver_t::handle_packet(const std::vector
<uint8_t> &packet
)
709 if (compute_checksum(packet
) != extract_checksum(packet
)) {
710 fprintf(stderr
, "Received %ld-byte packet with invalid checksum\n", packet
.size());
711 fprintf(stderr
, "Computed checksum: %x\n", compute_checksum(packet
));
712 print_packet(packet
);
717 fprintf(stderr
, "Received %ld-byte packet from debug client: ", packet
.size());
718 print_packet(packet
);
723 return handle_extended(packet
);
725 return handle_halt_reason(packet
);
727 return handle_general_registers_read(packet
);
729 return handle_kill(packet
);
731 return handle_memory_read(packet
);
733 // return handle_memory_write(packet);
735 return handle_memory_binary_write(packet
);
737 return handle_register_read(packet
);
739 return handle_register_write(packet
);
741 return handle_continue(packet
);
743 return handle_step(packet
);
746 return handle_breakpoint(packet
);
749 return handle_query(packet
);
753 fprintf(stderr
, "** Unsupported packet: ");
754 print_packet(packet
);
758 void gdbserver_t::handle_interrupt()
760 processor_t
*p
= sim
->get_core(0);
761 // TODO p->set_halted(true, HR_INTERRUPT);
762 send_packet("S02"); // Pretend program received SIGINT.
763 // TODO running = false;
766 void gdbserver_t::handle()
769 processor_t
*p
= sim
->get_core(0);
771 if (state
== STATE_HALTING
&& sim
->debug_module
.get_interrupt(p
->id
) == 0) {
772 // gdb requested a halt and now it's done.
774 fprintf(stderr
, "DPC: 0x%x\n", read_debug_ram(0));
775 fprintf(stderr
, "DCSR: 0x%x\n", read_debug_ram(2));
776 state
= STATE_HALTED
;
780 if (running && p->halted) {
781 // The core was running, but now it's halted. Better tell gdb.
782 switch (p->halt_reason) {
784 fprintf(stderr, "Internal error. Processor halted without reason.\n");
790 // There's no gdb code for this.
794 send_packet("T05swbreak:;");
798 // TODO: Actually include register values here
810 this->process_requests();
813 void gdbserver_t::send(const char* msg
)
815 unsigned int length
= strlen(msg
);
816 for (const char *c
= msg
; *c
; c
++)
817 running_checksum
+= *c
;
818 send_buf
.append((const uint8_t *) msg
, length
);
821 void gdbserver_t::send(uint64_t value
)
824 for (unsigned int i
= 0; i
< 8; i
++) {
825 sprintf(buffer
, "%02x", (int) (value
& 0xff));
831 void gdbserver_t::send(uint32_t value
)
834 for (unsigned int i
= 0; i
< 4; i
++) {
835 sprintf(buffer
, "%02x", (int) (value
& 0xff));
841 void gdbserver_t::send_packet(const char* data
)
844 running_checksum
= 0;
846 send_running_checksum();
850 void gdbserver_t::send_running_checksum()
852 char checksum_string
[4];
853 sprintf(checksum_string
, "#%02x", running_checksum
);
854 send(checksum_string
);