src/debugger/debugger_gdb.c

/*
 *  Copyright (C) 2006  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: debugger_gdb.c,v 1.12 2006/06/24 19:52:28 debug Exp $
 *
 *  Routines used for communicating with the GNU debugger, using the GDB
 *  remote serial protocol.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>

#include "cpu.h"
#include "debugger.h"
#include "debugger_gdb.h"
#include "machine.h"
#include "memory.h"


extern int single_step;
extern int exit_debugger;


/*
 *  debugger_gdb_listen():
 *
 *  Set up a GDB remote listening port for a specific emulated machine.
 */
static void debugger_gdb_listen(struct machine *machine)
{
        int listen_socket, res;
        struct sockaddr_in si;
        struct sockaddr_in incoming;
        socklen_t incoming_len;

        printf("----------------------------------------------------------"
            "---------------------\nWaiting for incoming remote GDB connection"
            " on port %i...\n", machine->gdb.port);

        listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (listen_socket < 0) {
                perror("socket");
                exit(1);
        }

        memset((char *)&si, sizeof(si), 0);
        si.sin_family = AF_INET;
        si.sin_port = htons(machine->gdb.port);
        si.sin_addr.s_addr = htonl(INADDR_ANY);
        if (bind(listen_socket, (struct sockaddr *)&si, sizeof(si)) < 0) {
                perror("bind");
                exit(1);
        }

        if (listen(listen_socket, 1) != 0) {
                perror("listen");
        }

        machine->gdb.socket = accept(listen_socket,
            (struct sockaddr *)&incoming, &incoming_len);
        printf("Connected; GDB socket = %i\n", machine->gdb.socket);

        /*  Set the socket to non-blocking:  */
        res = fcntl(machine->gdb.socket, F_GETFL);
        fcntl(machine->gdb.socket, F_SETFL, res | O_NONBLOCK);
}


/*
 *  send_packet():
 *
 *  Sends a packet with the correct checksum.
 */
static void send_packet(struct machine *machine, char *msg)
{
        unsigned char hex[17] = "0123456789abcdef";
        unsigned char checksum = 0x00;
        int i = 0;
        unsigned char ch;

        while (msg[i]) {
                checksum += (unsigned char) msg[i];
                i ++;
        }

        ch = '$'; write(machine->gdb.socket, &ch, 1);
        write(machine->gdb.socket, msg, i);
        ch = '#'; write(machine->gdb.socket, &ch, 1);
        ch = hex[checksum >> 4]; write(machine->gdb.socket, &ch, 1);
        ch = hex[checksum & 15]; write(machine->gdb.socket, &ch, 1);
}


/*
 *  debugger_gdb__execute_command():
 *
 *  Execute the command in the machine's receive buffer.
 */
void debugger_gdb__execute_command(struct machine *machine)
{
        char *cmd = (char *) machine->gdb.rx_buf;

        fatal("[ Remote GDB command: '%s' ]\n", machine->gdb.rx_buf);

        if (strcmp(cmd, "?") == 0) {
                send_packet(machine, "S00");
        } else if (strcmp(cmd, "g") == 0 || strncmp(cmd, "p", 1) == 0) {
                char *reply = cpu_gdb_stub(machine->cpus[0], cmd);
                if (reply != NULL) {
                        send_packet(machine, reply);
                        free(reply);
                }
        } else if (strcmp(cmd, "c") == 0) {
                send_packet(machine, "OK");
                exit_debugger = 1;
        } else if (strncmp(cmd, "Hc", 2) == 0) {
                fatal("[ TODO: GDB SET THREAD ]\n");
                send_packet(machine, "OK");
        } else if (strncmp(cmd, "m", 1) == 0) {
                /*  Memory read  */
                char *p = strchr(cmd, ',');
                if (p == NULL) {
                        send_packet(machine, "E00");
                } else {
                        uint64_t addr = strtoull(cmd + 1, NULL, 16);
                        uint64_t len = strtoull(p + 1, NULL, 16);
                        char *reply = malloc(len * 2 + 1);
                        size_t i;

                        reply[0] = '\0';
                        for (i=0; i<len; i++) {
                                unsigned char ch;
                                machine->cpus[0]->memory_rw(machine->cpus[0],
                                    machine->cpus[0]->mem, addr+i, &ch,
                                    sizeof(ch), MEM_READ, CACHE_NONE
                                    | NO_EXCEPTIONS);
                                snprintf(reply + strlen(reply),
                                    len*2, "%02x", ch);
                        }

                        send_packet(machine, reply);
                        free(reply);
                }
        } else if (strcmp(cmd, "s") == 0) {
                unsigned char ch = '+';
                write(machine->gdb.socket, &ch, 1);
                exit_debugger = -1;
        } else {
                fatal("[ (UNKNOWN COMMAND) ]\n");
                send_packet(machine, "");
        }
}


/*
 *  debugger_gdb__check_incoming_char():
 *
 *  Handle each incoming character.
 */
int debugger_gdb__check_incoming_char(struct machine *machine)
{
        /*  int old_state = machine->gdb.rx_state;  */
        unsigned char ch, ch1;
        ssize_t len = read(machine->gdb.socket, &ch, 1);

        if (len == 0) {
                perror("GDB socket read");
                fprintf(stderr, "Connection closed. Exiting.\n");
                exit(1);
        }

        /*  EAGAIN, and similar:  */
        if (len < 0)
                return 0;

        /*  debug("[ debugger_gdb: received char ");
        if (ch >= ' ')
                debug("'%c' ]\n", ch);
        else
                debug("0x%02x ]\n", ch);  */

        switch (machine->gdb.rx_state) {

        case RXSTATE_WAITING_FOR_DOLLAR:
                if (ch == '$') {
                        machine->gdb.rx_state = RXSTATE_WAITING_FOR_HASH;
                        if (machine->gdb.rx_buf != NULL)
                                free(machine->gdb.rx_buf);
                        machine->gdb.rx_buf_size = 200;
                        machine->gdb.rx_buf = malloc(
                            machine->gdb.rx_buf_size + 1);
                        machine->gdb.rx_buf_curlen = 0;
                        machine->gdb.rx_buf_checksum = 0x00;
                } else if (ch == 0x03) {
                        fatal("[ GDB break ]\n");
                        single_step = ENTER_SINGLE_STEPPING;
                        ch = '+';
                        write(machine->gdb.socket, &ch, 1);
                        send_packet(machine, "S02");
                        machine->gdb.rx_state = RXSTATE_WAITING_FOR_DOLLAR;
                } else {
                        if (ch != '+')
                                debug("[ debugger_gdb: ignoring char '"
                                    "%c' ]\n", ch);
                }
                break;

        case RXSTATE_WAITING_FOR_HASH:
                if (ch == '#') {
                        machine->gdb.rx_state = RXSTATE_WAITING_FOR_CHECKSUM1;

                        machine->gdb.rx_buf[machine->gdb.rx_buf_curlen] = '\0';
                } else {
                        if (machine->gdb.rx_buf_curlen >=
                            machine->gdb.rx_buf_size) {
                                machine->gdb.rx_buf_size *= 2;
                                machine->gdb.rx_buf = realloc(
                                    machine->gdb.rx_buf,
                                    machine->gdb.rx_buf_size + 1);
                        }

                        machine->gdb.rx_buf[
                            machine->gdb.rx_buf_curlen ++] = ch;

                        machine->gdb.rx_buf_checksum += ch;

                        /*  debug("[ debugger_gdb: current checksum = "
                            "0x%02x ]\n", machine->gdb.rx_buf_checksum);  */
                }
                break;

        case RXSTATE_WAITING_FOR_CHECKSUM1:
                machine->gdb.rx_checksum1 = ch;
                machine->gdb.rx_state = RXSTATE_WAITING_FOR_CHECKSUM2;
                break;

        case RXSTATE_WAITING_FOR_CHECKSUM2:
                ch1 = machine->gdb.rx_checksum1;

                if (ch1 >= '0' && ch1 <= '9')
                        ch1 = ch1 - '0';
                else if (ch1 >= 'a' && ch1 <= 'f')
                        ch1 = 10 + ch1 - 'a';
                else if (ch1 >= 'A' && ch1 <= 'F')
                        ch1 = 10 + ch1 - 'A';

                if (ch >= '0' && ch <= '9')
                        ch = ch - '0';
                else if (ch >= 'a' && ch <= 'f')
                        ch = 10 + ch - 'a';
                else if (ch >= 'A' && ch <= 'F')
                        ch = 10 + ch - 'A';

                if (machine->gdb.rx_buf_checksum != ch1 * 16 + ch) {
                        /*  Checksum mismatch!  */

                        fatal("[ debugger_gdb: CHECKSUM MISMATCH! (0x%02x, "
                            " calculated is 0x%02x ]\n", ch1 * 16 + ch,
                            machine->gdb.rx_buf_checksum);

                        /*  Send a NACK message:  */
                        ch = '-';
                        write(machine->gdb.socket, &ch, 1);
                } else {
                        /*  Checksum is ok. Send an ACK message...  */
                        ch = '+';
                        write(machine->gdb.socket, &ch, 1);

                        /*  ... and execute the command:  */
                        debugger_gdb__execute_command(machine);
                }

                machine->gdb.rx_state = RXSTATE_WAITING_FOR_DOLLAR;
                break;

        default:fatal("debugger_gdb_check_incoming(): internal error "
                    "(state %i unknown)\n", machine->gdb.rx_state);
                exit(1);
        }

        /*  if (machine->gdb.rx_state != old_state)
                debug("[ debugger_gdb: state %i -> %i ]\n",
                    old_state, machine->gdb.rx_state);  */

        return 1;
}


/*
 *  debugger_gdb_check_incoming():
 *
 *  This function should be called regularly, to check for incoming data on
 *  the remote GDB socket.
 */
void debugger_gdb_check_incoming(struct machine *machine)
{
        while (debugger_gdb__check_incoming_char(machine))
                ;
}


/*
 *  debugger_gdb_after_singlestep():
 *
 *  Single-step works like this:
 *
 *      GDB to GXemul:          s
 *      GXemul to GDB:          +
 *      (GXemul single-steps one instruction)
 *      GXemul to GDB:          T00
 *
 *  This function should be called after the instruction has been executed.
 */
void debugger_gdb_after_singlestep(struct machine *machine)
{
        send_packet(machine, "T00");
}


/*
 *  debugger_gdb_init():
 *
 *  Initialize stuff needed for a GDB remote connection.
 */
void debugger_gdb_init(struct machine *machine)
{
        if (machine->gdb.port < 1)
                return;

        debugger_gdb_listen(machine);
}

1	/*
2	* Copyright (C) 2006 Anders Gavare. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions are met:
6	*
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	* 3. The name of the author may not be used to endorse or promote products
13	* derived from this software without specific prior written permission.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25	* SUCH DAMAGE.
26	*
27	*
28	* $Id: debugger_gdb.c,v 1.12 2006/06/24 19:52:28 debug Exp $
29	*
30	* Routines used for communicating with the GNU debugger, using the GDB
31	* remote serial protocol.
32	*/
33
34	#include <stdio.h>
35	#include <stdlib.h>
36	#include <string.h>
37	#include <sys/types.h>
38	#include <sys/socket.h>
39	#include <netinet/in.h>
40	#include <fcntl.h>
41	#include <unistd.h>
42
43	#include "cpu.h"
44	#include "debugger.h"
45	#include "debugger_gdb.h"
46	#include "machine.h"
47	#include "memory.h"
48
49
50	extern int single_step;
51	extern int exit_debugger;
52
53
54	/*
55	* debugger_gdb_listen():
56	*
57	* Set up a GDB remote listening port for a specific emulated machine.
58	*/
59	static void debugger_gdb_listen(struct machine *machine)
60	{
61	int listen_socket, res;
62	struct sockaddr_in si;
63	struct sockaddr_in incoming;
64	socklen_t incoming_len;
65
66	printf("----------------------------------------------------------"
67	"---------------------\nWaiting for incoming remote GDB connection"
68	" on port %i...\n", machine->gdb.port);
69
70	listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
71	if (listen_socket < 0) {
72	perror("socket");
73	exit(1);
74	}
75
76	memset((char *)&si, sizeof(si), 0);
77	si.sin_family = AF_INET;
78	si.sin_port = htons(machine->gdb.port);
79	si.sin_addr.s_addr = htonl(INADDR_ANY);
80	if (bind(listen_socket, (struct sockaddr *)&si, sizeof(si)) < 0) {
81	perror("bind");
82	exit(1);
83	}
84
85	if (listen(listen_socket, 1) != 0) {
86	perror("listen");
87	}
88
89	machine->gdb.socket = accept(listen_socket,
90	(struct sockaddr *)&incoming, &incoming_len);
91	printf("Connected; GDB socket = %i\n", machine->gdb.socket);
92
93	/* Set the socket to non-blocking: */
94	res = fcntl(machine->gdb.socket, F_GETFL);
95	fcntl(machine->gdb.socket, F_SETFL, res \| O_NONBLOCK);
96	}
97
98
99	/*
100	* send_packet():
101	*
102	* Sends a packet with the correct checksum.
103	*/
104	static void send_packet(struct machine machine, char msg)
105	{
106	unsigned char hex[17] = "0123456789abcdef";
107	unsigned char checksum = 0x00;
108	int i = 0;
109	unsigned char ch;
110
111	while (msg[i]) {
112	checksum += (unsigned char) msg[i];
113	i ++;
114	}
115
116	ch = '$'; write(machine->gdb.socket, &ch, 1);
117	write(machine->gdb.socket, msg, i);
118	ch = '#'; write(machine->gdb.socket, &ch, 1);
119	ch = hex[checksum >> 4]; write(machine->gdb.socket, &ch, 1);
120	ch = hex[checksum & 15]; write(machine->gdb.socket, &ch, 1);
121	}
122
123
124	/*
125	* debugger_gdb__execute_command():
126	*
127	* Execute the command in the machine's receive buffer.
128	*/
129	void debugger_gdb__execute_command(struct machine *machine)
130	{
131	char cmd = (char ) machine->gdb.rx_buf;
132
133	fatal("[ Remote GDB command: '%s' ]\n", machine->gdb.rx_buf);
134
135	if (strcmp(cmd, "?") == 0) {
136	send_packet(machine, "S00");
137	} else if (strcmp(cmd, "g") == 0 \|\| strncmp(cmd, "p", 1) == 0) {
138	char *reply = cpu_gdb_stub(machine->cpus[0], cmd);
139	if (reply != NULL) {
140	send_packet(machine, reply);
141	free(reply);
142	}
143	} else if (strcmp(cmd, "c") == 0) {
144	send_packet(machine, "OK");
145	exit_debugger = 1;
146	} else if (strncmp(cmd, "Hc", 2) == 0) {
147	fatal("[ TODO: GDB SET THREAD ]\n");
148	send_packet(machine, "OK");
149	} else if (strncmp(cmd, "m", 1) == 0) {
150	/* Memory read */
151	char *p = strchr(cmd, ',');
152	if (p == NULL) {
153	send_packet(machine, "E00");
154	} else {
155	uint64_t addr = strtoull(cmd + 1, NULL, 16);
156	uint64_t len = strtoull(p + 1, NULL, 16);
157	char reply = malloc(len 2 + 1);
158	size_t i;
159
160	reply[0] = '\0';
161	for (i=0; i<len; i++) {
162	unsigned char ch;
163	machine->cpus[0]->memory_rw(machine->cpus[0],
164	machine->cpus[0]->mem, addr+i, &ch,
165	sizeof(ch), MEM_READ, CACHE_NONE
166	\| NO_EXCEPTIONS);
167	snprintf(reply + strlen(reply),
168	len*2, "%02x", ch);
169	}
170
171	send_packet(machine, reply);
172	free(reply);
173	}
174	} else if (strcmp(cmd, "s") == 0) {
175	unsigned char ch = '+';
176	write(machine->gdb.socket, &ch, 1);
177	exit_debugger = -1;
178	} else {
179	fatal("[ (UNKNOWN COMMAND) ]\n");
180	send_packet(machine, "");
181	}
182	}
183
184
185	/*
186	* debugger_gdb__check_incoming_char():
187	*
188	* Handle each incoming character.
189	*/
190	int debugger_gdb__check_incoming_char(struct machine *machine)
191	{
192	/* int old_state = machine->gdb.rx_state; */
193	unsigned char ch, ch1;
194	ssize_t len = read(machine->gdb.socket, &ch, 1);
195
196	if (len == 0) {
197	perror("GDB socket read");
198	fprintf(stderr, "Connection closed. Exiting.\n");
199	exit(1);
200	}
201
202	/* EAGAIN, and similar: */
203	if (len < 0)
204	return 0;
205
206	/* debug("[ debugger_gdb: received char ");
207	if (ch >= ' ')
208	debug("'%c' ]\n", ch);
209	else
210	debug("0x%02x ]\n", ch); */
211
212	switch (machine->gdb.rx_state) {
213
214	case RXSTATE_WAITING_FOR_DOLLAR:
215	if (ch == '$') {
216	machine->gdb.rx_state = RXSTATE_WAITING_FOR_HASH;
217	if (machine->gdb.rx_buf != NULL)
218	free(machine->gdb.rx_buf);
219	machine->gdb.rx_buf_size = 200;
220	machine->gdb.rx_buf = malloc(
221	machine->gdb.rx_buf_size + 1);
222	machine->gdb.rx_buf_curlen = 0;
223	machine->gdb.rx_buf_checksum = 0x00;
224	} else if (ch == 0x03) {
225	fatal("[ GDB break ]\n");
226	single_step = ENTER_SINGLE_STEPPING;
227	ch = '+';
228	write(machine->gdb.socket, &ch, 1);
229	send_packet(machine, "S02");
230	machine->gdb.rx_state = RXSTATE_WAITING_FOR_DOLLAR;
231	} else {
232	if (ch != '+')
233	debug("[ debugger_gdb: ignoring char '"
234	"%c' ]\n", ch);
235	}
236	break;
237
238	case RXSTATE_WAITING_FOR_HASH:
239	if (ch == '#') {
240	machine->gdb.rx_state = RXSTATE_WAITING_FOR_CHECKSUM1;
241
242	machine->gdb.rx_buf[machine->gdb.rx_buf_curlen] = '\0';
243	} else {
244	if (machine->gdb.rx_buf_curlen >=
245	machine->gdb.rx_buf_size) {
246	machine->gdb.rx_buf_size *= 2;
247	machine->gdb.rx_buf = realloc(
248	machine->gdb.rx_buf,
249	machine->gdb.rx_buf_size + 1);
250	}
251
252	machine->gdb.rx_buf[
253	machine->gdb.rx_buf_curlen ++] = ch;
254
255	machine->gdb.rx_buf_checksum += ch;
256
257	/* debug("[ debugger_gdb: current checksum = "
258	"0x%02x ]\n", machine->gdb.rx_buf_checksum); */
259	}
260	break;
261
262	case RXSTATE_WAITING_FOR_CHECKSUM1:
263	machine->gdb.rx_checksum1 = ch;
264	machine->gdb.rx_state = RXSTATE_WAITING_FOR_CHECKSUM2;
265	break;
266
267	case RXSTATE_WAITING_FOR_CHECKSUM2:
268	ch1 = machine->gdb.rx_checksum1;
269
270	if (ch1 >= '0' && ch1 <= '9')
271	ch1 = ch1 - '0';
272	else if (ch1 >= 'a' && ch1 <= 'f')
273	ch1 = 10 + ch1 - 'a';
274	else if (ch1 >= 'A' && ch1 <= 'F')
275	ch1 = 10 + ch1 - 'A';
276
277	if (ch >= '0' && ch <= '9')
278	ch = ch - '0';
279	else if (ch >= 'a' && ch <= 'f')
280	ch = 10 + ch - 'a';
281	else if (ch >= 'A' && ch <= 'F')
282	ch = 10 + ch - 'A';
283
284	if (machine->gdb.rx_buf_checksum != ch1 * 16 + ch) {
285	/* Checksum mismatch! */
286
287	fatal("[ debugger_gdb: CHECKSUM MISMATCH! (0x%02x, "
288	" calculated is 0x%02x ]\n", ch1 * 16 + ch,
289	machine->gdb.rx_buf_checksum);
290
291	/* Send a NACK message: */
292	ch = '-';
293	write(machine->gdb.socket, &ch, 1);
294	} else {
295	/* Checksum is ok. Send an ACK message... */
296	ch = '+';
297	write(machine->gdb.socket, &ch, 1);
298
299	/* ... and execute the command: */
300	debugger_gdb__execute_command(machine);
301	}
302
303	machine->gdb.rx_state = RXSTATE_WAITING_FOR_DOLLAR;
304	break;
305
306	default:fatal("debugger_gdb_check_incoming(): internal error "
307	"(state %i unknown)\n", machine->gdb.rx_state);
308	exit(1);
309	}
310
311	/* if (machine->gdb.rx_state != old_state)
312	debug("[ debugger_gdb: state %i -> %i ]\n",
313	old_state, machine->gdb.rx_state); */
314
315	return 1;
316	}
317
318
319	/*
320	* debugger_gdb_check_incoming():
321	*
322	* This function should be called regularly, to check for incoming data on
323	* the remote GDB socket.
324	*/
325	void debugger_gdb_check_incoming(struct machine *machine)
326	{
327	while (debugger_gdb__check_incoming_char(machine))
328	;
329	}
330
331
332	/*
333	* debugger_gdb_after_singlestep():
334	*
335	* Single-step works like this:
336	*
337	* GDB to GXemul: s
338	* GXemul to GDB: +
339	* (GXemul single-steps one instruction)
340	* GXemul to GDB: T00
341	*
342	* This function should be called after the instruction has been executed.
343	*/
344	void debugger_gdb_after_singlestep(struct machine *machine)
345	{
346	send_packet(machine, "T00");
347	}
348
349
350	/*
351	* debugger_gdb_init():
352	*
353	* Initialize stuff needed for a GDB remote connection.
354	*/
355	void debugger_gdb_init(struct machine *machine)
356	{
357	if (machine->gdb.port < 1)
358	return;
359
360	debugger_gdb_listen(machine);
361	}
362