Newer
Older
/***************************************************************************
* Copyright (C) 2005 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *

ntfreak
committed
* Copyright (C) 2007,2008 yvind Harboe *

oharboe
committed
* oyvind.harboe@zylin.com *
* *

ntfreak
committed
* Copyright (C) 2008 by Spencer Oliver *
* spen@spen-soft.co.uk *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gdb_server.h"
#include "target_request.h"
#include "register.h"
#include "server.h"
#include "flash.h"
#include "image.h"
#include "jtag.h"
#if 0
#define _DEBUG_GDB_IO_
#endif
static int gdb_breakpoint_override;
static enum breakpoint_type gdb_breakpoint_override_type;
extern int gdb_error(connection_t *connection, int retval);
static const char *DIGITS = "0123456789abcdef";
static void gdb_log_callback(void *priv, const char *file, int line,
const char *function, const char *string);
enum gdb_detach_mode
{
GDB_DETACH_RESUME,
GDB_DETACH_RESET,
GDB_DETACH_HALT,
GDB_DETACH_NOTHING
};
/* target behaviour on gdb detach */
enum gdb_detach_mode detach_mode = GDB_DETACH_RESUME;
/* number of gdb connections, mainly to supress gdb related debugging spam
* in helper/log.c when no gdb connections are actually active */
int gdb_actual_connections;
/* set if we are sending a memory map to gdb
* via qXfer:memory-map:read packet */
/* enabled by default*/
int gdb_use_memory_map = 1;
/* enabled by default*/
int gdb_flash_program = 1;
/* if set, data aborts cause an error to be reported in memory read packets
* see the code in gdb_read_memory_packet() for further explanations */
int gdb_report_data_abort = 0;
int gdb_last_signal(target_t *target)
{
switch (target->debug_reason)
{
case DBG_REASON_DBGRQ:
return 0x2; /* SIGINT */
case DBG_REASON_BREAKPOINT:
case DBG_REASON_WATCHPOINT:
case DBG_REASON_WPTANDBKPT:
return 0x05; /* SIGTRAP */
case DBG_REASON_SINGLESTEP:
return 0x05; /* SIGTRAP */
case DBG_REASON_NOTHALTED:
return 0x0; /* no signal... shouldn't happen */
default:
LOG_USER("undefined debug reason %d - target needs reset", target->debug_reason);
return 0x0;
}
}
int check_pending(connection_t *connection, int timeout_s, int *got_data)
{
/* a non-blocking socket will block if there is 0 bytes available on the socket,
* but return with as many bytes as are available immediately
*/
struct timeval tv;
fd_set read_fds;
gdb_connection_t *gdb_con = connection->priv;
int t;
{
*got_data = 1;
return ERROR_OK;
}
FD_ZERO(&read_fds);
FD_SET(connection->fd, &read_fds);
tv.tv_sec = timeout_s;
tv.tv_usec = 0;
if (socket_select(connection->fd + 1, &read_fds, NULL, NULL, &tv) == 0)
{
/* This can typically be because a "monitor" command took too long
* before printing any progress messages
*/
{
return ERROR_GDB_TIMEOUT;
} else
{
return ERROR_OK;
}
}
int gdb_get_char(connection_t *connection, int* next_char)
{
gdb_connection_t *gdb_con = connection->priv;
#ifdef _DEBUG_GDB_IO_
char *debug_buffer;
#endif
if (gdb_con->buf_cnt-- > 0)
{
*next_char = *(gdb_con->buf_p++);
if (gdb_con->buf_cnt > 0)
connection->input_pending = 1;
else
connection->input_pending = 0;
#ifdef _DEBUG_GDB_IO_
LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);
#endif
return ERROR_OK;
}
for (;;)
{
if (connection->service->type == CONNECTION_PIPE)
{
gdb_con->buf_cnt = read(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE);
}
else
{
retval = check_pending(connection, 1, NULL);
if (retval != ERROR_OK)
return retval;
gdb_con->buf_cnt = read_socket(connection->fd, gdb_con->buffer, GDB_BUFFER_SIZE);
}
if (gdb_con->buf_cnt > 0)
{
break;
}
if (gdb_con->buf_cnt == 0)
{
gdb_con->closed = 1;
return ERROR_SERVER_REMOTE_CLOSED;
}
#ifdef _WIN32
errno = WSAGetLastError();
{
case WSAEWOULDBLOCK:
usleep(1000);
break;
case WSAECONNABORTED:
return ERROR_SERVER_REMOTE_CLOSED;
case WSAECONNRESET:
return ERROR_SERVER_REMOTE_CLOSED;
default:
LOG_ERROR("read: %d", errno);
{
case EAGAIN:
usleep(1000);
break;
case ECONNABORTED:
return ERROR_SERVER_REMOTE_CLOSED;
case ECONNRESET:
return ERROR_SERVER_REMOTE_CLOSED;
default:
LOG_ERROR("read: %s", strerror(errno));
return ERROR_SERVER_REMOTE_CLOSED;
}
#endif
}
#ifdef _DEBUG_GDB_IO_
debug_buffer = malloc(gdb_con->buf_cnt + 1);
memcpy(debug_buffer, gdb_con->buffer, gdb_con->buf_cnt);
debug_buffer[gdb_con->buf_cnt] = 0;
LOG_DEBUG("received '%s'", debug_buffer);
free(debug_buffer);
#endif
gdb_con->buf_p = gdb_con->buffer;
gdb_con->buf_cnt--;
*next_char = *(gdb_con->buf_p++);
if (gdb_con->buf_cnt > 0)
connection->input_pending = 1;
else
LOG_DEBUG("returned char '%c' (0x%2.2x)", *next_char, *next_char);
}
int gdb_putback_char(connection_t *connection, int last_char)
{
gdb_connection_t *gdb_con = connection->priv;
if (gdb_con->buf_p > gdb_con->buffer)
{
*(--gdb_con->buf_p) = last_char;
gdb_con->buf_cnt++;
}
else
{
LOG_ERROR("BUG: couldn't put character back");
}
return ERROR_OK;
}
/* The only way we can detect that the socket is closed is the first time
* we write to it, we will fail. Subsequent write operations will
* succeed. Shudder! */
int gdb_write(connection_t *connection, void *data, int len)
{
gdb_connection_t *gdb_con = connection->priv;
if (gdb_con->closed)
return ERROR_SERVER_REMOTE_CLOSED;
if (connection->service->type == CONNECTION_PIPE)
/* write to stdout */
if (write(STDOUT_FILENO, data, len) == len)
{
return ERROR_OK;
}
}
else
{
if (write_socket(connection->fd, data, len) == len)
{
return ERROR_OK;
}
}
gdb_con->closed = 1;
return ERROR_SERVER_REMOTE_CLOSED;
}
int gdb_put_packet_inner(connection_t *connection, char *buffer, int len)
{
int i;
unsigned char my_checksum = 0;
#ifdef _DEBUG_GDB_IO_
char *debug_buffer;
#endif
int reply;
int retval;
gdb_connection_t *gdb_con = connection->priv;
for (i = 0; i < len; i++)
my_checksum += buffer[i];
* At this point we should have nothing in the input queue from GDB,
* however sometimes '-' is sent even though we've already received
* an ACK (+) for everything we've sent off.
*/
int gotdata;
for (;;)
{
if ((retval = check_pending(connection, 0, &gotdata)) != ERROR_OK)
return retval;
if (!gotdata)
break;
if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK)
return retval;
/* fix a problem with some IAR tools */
gdb_putback_char( connection, reply );
LOG_DEBUG("Unexpected start of new packet");
break;
}
LOG_WARNING("Discard unexpected char %c", reply);
while (1)
{
#ifdef _DEBUG_GDB_IO_
debug_buffer = malloc(len + 1);
memcpy(debug_buffer, buffer, len);
debug_buffer[len] = 0;
LOG_DEBUG("sending packet '$%s#%2.2x'", debug_buffer, my_checksum);
char local_buffer[1024];
local_buffer[0] = '$';
if ((size_t)len + 4 <= sizeof(local_buffer))
/* performance gain on smaller packets by only a single call to gdb_write() */
local_buffer[len++] = '#';
local_buffer[len++] = DIGITS[(my_checksum >> 4) & 0xf];
local_buffer[len++] = DIGITS[my_checksum & 0xf];
if ((retval = gdb_write(connection, local_buffer, len)) != ERROR_OK)
else
/* larger packets are transmitted directly from caller supplied buffer
by several calls to gdb_write() to avoid dynamic allocation */
local_buffer[1] = '#';
local_buffer[2] = DIGITS[(my_checksum >> 4) & 0xf];
local_buffer[3] = DIGITS[my_checksum & 0xf];
if ((retval = gdb_write(connection, local_buffer, 1)) != ERROR_OK)
if ((retval = gdb_write(connection, buffer, len)) != ERROR_OK)
if ((retval = gdb_write(connection, local_buffer + 1, 3)) != ERROR_OK)

ntfreak
committed
if (gdb_con->noack_mode)
break;
if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK)
return retval;
if (reply == '+')
break;
else if (reply == '-')
{
/* Stop sending output packets for now */
log_remove_callback(gdb_log_callback, connection);
LOG_WARNING("negative reply, retrying");
}
else if (reply == 0x3)
{
gdb_con->ctrl_c = 1;
if ((retval = gdb_get_char(connection, &reply)) != ERROR_OK)
return retval;
if (reply == '+')
break;
else if (reply == '-')
{
/* Stop sending output packets for now */
log_remove_callback(gdb_log_callback, connection);
LOG_WARNING("negative reply, retrying");
LOG_ERROR("GDB missing ack(1) - assumed good");
gdb_putback_char( connection, reply );
return ERROR_OK;
} else {
LOG_ERROR("unknown character(1) 0x%2.2x in reply, dropping connection", reply);
return ERROR_SERVER_REMOTE_CLOSED;
}
LOG_ERROR("GDB missing ack(2) - assumed good");
gdb_putback_char( connection, reply );
return ERROR_OK;
LOG_ERROR("unknown character(2) 0x%2.2x in reply, dropping connection", reply);
return ERROR_SERVER_REMOTE_CLOSED;
}
}
if (gdb_con->closed)
return ERROR_SERVER_REMOTE_CLOSED;
return ERROR_OK;
}
int gdb_put_packet(connection_t *connection, char *buffer, int len)
{
gdb_connection_t *gdb_con = connection->priv;
gdb_con->busy = 1;
int retval = gdb_put_packet_inner(connection, buffer, len);
gdb_con->busy = 0;
/* we sent some data, reset timer for keep alive messages */
kept_alive();
static __inline__ int fetch_packet(connection_t *connection, int *checksum_ok, int noack, int *len, char *buffer)
unsigned char my_checksum = 0;
char checksum[3];
gdb_connection_t *gdb_con = connection->priv;
my_checksum = 0;
count = 0;
for (;;)
{
/* The common case is that we have an entire packet with no escape chars.
* We need to leave at least 2 bytes in the buffer to have
* gdb_get_char() update various bits and bobs correctly.
*/
if ((gdb_con->buf_cnt > 2) && ((gdb_con->buf_cnt + count) < *len))
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
{
/* The compiler will struggle a bit with constant propagation and
* aliasing, so we help it by showing that these values do not
* change inside the loop
*/
int i;
char *buf = gdb_con->buf_p;
int run = gdb_con->buf_cnt - 2;
i = 0;
int done = 0;
while (i < run)
{
character = *buf++;
i++;
if (character == '#')
{
/* Danger! character can be '#' when esc is
* used so we need an explicit boolean for done here.
*/
done = 1;
break;
}
if (character == '}')
{
/* data transmitted in binary mode (X packet)
* uses 0x7d as escape character */
my_checksum += character & 0xff;
character = *buf++;
i++;
my_checksum += character & 0xff;
buffer[count++] = (character ^ 0x20) & 0xff;
}
else
{
my_checksum += character & 0xff;
buffer[count++] = character & 0xff;
}
}
gdb_con->buf_p += i;
gdb_con->buf_cnt -= i;
if (done)
break;
}
if (count > *len)
{
LOG_ERROR("packet buffer too small");
return ERROR_GDB_BUFFER_TOO_SMALL;
}
if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
return retval;
if (character == '#')
break;
if (character == '}')
{
/* data transmitted in binary mode (X packet)
* uses 0x7d as escape character */
my_checksum += character & 0xff;
if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
return retval;
my_checksum += character & 0xff;
buffer[count++] = (character ^ 0x20) & 0xff;
}
else
{
my_checksum += character & 0xff;
buffer[count++] = character & 0xff;
}
}
*len = count;
if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
return retval;
checksum[0] = character;
if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
return retval;
checksum[1] = character;
checksum[2] = 0;
*checksum_ok = (my_checksum == strtoul(checksum, NULL, 16));
return ERROR_OK;
}
int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len)
{
int character;
int retval;
gdb_connection_t *gdb_con = connection->priv;
while (1)
{
do
{
if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
return retval;
#ifdef _DEBUG_GDB_IO_
LOG_DEBUG("character: '%c'", character);
#endif
switch (character)
{
case '$':
break;
case '+':
/* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c)
* incase anyone tries to debug why they receive this warning every time */
LOG_WARNING("acknowledgment received, but no packet pending");
LOG_WARNING("negative acknowledgment, but no packet pending");
break;
case 0x3:
gdb_con->ctrl_c = 1;
*len = 0;
return ERROR_OK;
default:
LOG_WARNING("ignoring character 0x%x", character);
break;
}
} while (character != '$');
int checksum_ok = 0;
/* explicit code expansion here to get faster inlined code in -O3 by not
* calculating checksum
*/
if (gdb_con->noack_mode)
{
if ((retval = fetch_packet(connection, &checksum_ok, 1, len, buffer)) != ERROR_OK)
if ((retval = fetch_packet(connection, &checksum_ok, 0, len, buffer)) != ERROR_OK)

ntfreak
committed
{
/* checksum is not checked in noack mode */
break;

ntfreak
committed
}

ntfreak
committed
{
if ((retval = gdb_write(connection, "+", 1)) != ERROR_OK)
{
return retval;
}

ntfreak
committed
break;
}
}
if (gdb_con->closed)
return ERROR_SERVER_REMOTE_CLOSED;
return ERROR_OK;
}
int gdb_get_packet(connection_t *connection, char *buffer, int *len)
{
gdb_connection_t *gdb_con = connection->priv;
gdb_con->busy = 1;
int retval = gdb_get_packet_inner(connection, buffer, len);
gdb_con->busy = 0;
return retval;
}
int gdb_output_con(connection_t *connection, const char* line)
{
char *hex_buffer;
int i, bin_size;
bin_size = strlen(line);
hex_buffer = malloc(bin_size*2 + 2);
if (hex_buffer == NULL)
return ERROR_GDB_BUFFER_TOO_SMALL;
snprintf(hex_buffer + 1 + i*2, 3, "%2.2x", line[i]);
int retval = gdb_put_packet(connection, hex_buffer, bin_size*2 + 1);
int gdb_output(struct command_context_s *context, const char* line)
{
/* this will be dumped to the log and also sent as an O packet if possible */
LOG_USER_N("%s", line);
static void gdb_frontend_halted(struct target_s *target, connection_t *connection)
{
gdb_connection_t *gdb_connection = connection->priv;
/* In the GDB protocol when we are stepping or coninuing execution,
* we have a lingering reply. Upon receiving a halted event
* when we have that lingering packet, we reply to the original
* step or continue packet.
*
* Executing monitor commands can bring the target in and
* out of the running state so we'll see lots of TARGET_EVENT_XXX
* that are to be ignored.
*/
if (gdb_connection->frontend_state == TARGET_RUNNING)
{
char sig_reply[4];
int signal;

oharboe
committed
/* stop forwarding log packets! */
log_remove_callback(gdb_log_callback, connection);
if (gdb_connection->ctrl_c)
{
signal = 0x2;
gdb_connection->ctrl_c = 0;
}
else
{
signal = gdb_last_signal(target);
}
snprintf(sig_reply, 4, "T%2.2x", signal);
gdb_put_packet(connection, sig_reply, 3);
gdb_connection->frontend_state = TARGET_HALTED;
}
}
int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
{
target_handle_event( target, event );
case TARGET_EVENT_EARLY_HALTED:
gdb_frontend_halted(target, connection);

oharboe
committed
case TARGET_EVENT_HALTED:
target_call_event_callbacks(target, TARGET_EVENT_GDB_END);
break;
case TARGET_EVENT_GDB_FLASH_ERASE_START:
target_handle_event( target, TARGET_EVENT_OLD_gdb_program_config );
break;
default:
break;
}
return ERROR_OK;
}
int gdb_new_connection(connection_t *connection)
{
gdb_connection_t *gdb_connection = malloc(sizeof(gdb_connection_t));
gdb_service_t *gdb_service = connection->service->priv;
int retval;
int initial_ack;
connection->priv = gdb_connection;
/* initialize gdb connection information */
gdb_connection->buf_p = gdb_connection->buffer;
gdb_connection->buf_cnt = 0;
gdb_connection->ctrl_c = 0;
gdb_connection->frontend_state = TARGET_HALTED;
gdb_connection->vflash_image = NULL;
gdb_connection->closed = 0;
gdb_connection->busy = 0;

ntfreak
committed
gdb_connection->noack_mode = 0;
/* send ACK to GDB for debug request */
gdb_write(connection, "+", 1);
/* output goes through gdb connection */
command_set_output_handler(connection->cmd_ctx, gdb_output, connection);
/* we must remove all breakpoints registered to the target as a previous
* GDB session could leave dangling breakpoints if e.g. communication
* timed out.
*/
breakpoint_clear_target(gdb_service->target);
watchpoint_clear_target(gdb_service->target);
/* register callback to be informed about target events */
target_register_event_callback(gdb_target_callback_event_handler, connection);
/* a gdb session just attached, try to put the target in halt mode.
*
* DANGER!!!!
*
* If the halt fails(e.g. target needs a reset, JTAG communication not
* working, etc.), then the GDB connect will succeed as
* the get_gdb_reg_list() will lie and return a register list with
* dummy values.
* This allows GDB monitor commands to be run from a GDB init script to
* initialize the target
* Also, since the halt() is asynchronous target connect will be
* instantaneous and thus avoiding annoying timeout problems during
*/
target_halt(gdb_service->target);
/* FIX!!!! could extended-remote work better here?
* wait a tiny bit for halted state or we just continue. The
* GDB register packet will then contain garbage
*/
target_wait_state(gdb_service->target, TARGET_HALTED, 500);
/* remove the initial ACK from the incoming buffer */
if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK)
return retval;
/* FIX!!!??? would we actually ever receive a + here???
if (initial_ack != '+')
gdb_putback_char(connection, initial_ack);
target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_ATTACH );
{
gdb_service_t *gdb_service = connection->service->priv;
gdb_connection_t *gdb_connection = connection->priv;
/* see if an image built with vFlash commands is left */
if (gdb_connection->vflash_image)
{
image_close(gdb_connection->vflash_image);
free(gdb_connection->vflash_image);
gdb_connection->vflash_image = NULL;
}
/* if this connection registered a debug-message receiver delete it */
delete_debug_msg_receiver(connection->cmd_ctx, gdb_service->target);
if (connection->priv)
{
free(connection->priv);
connection->priv = NULL;
}
else
{
LOG_ERROR("BUG: connection->priv == NULL");
}
target_unregister_event_callback(gdb_target_callback_event_handler, connection);

oharboe
committed
target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_END);
log_remove_callback(gdb_log_callback, connection);
target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH );
void gdb_send_error(connection_t *connection, uint8_t the_error)
{
char err[4];
snprintf(err, 4, "E%2.2X", the_error );
gdb_put_packet(connection, err, 3);
}
int gdb_last_signal_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
{
char sig_reply[4];
int signal;
signal = gdb_last_signal(target);
snprintf(sig_reply, 4, "S%2.2x", signal);
gdb_put_packet(connection, sig_reply, 3);
return ERROR_OK;
}
static int gdb_reg_pos(target_t *target, int pos, int len)
{
if (target->endianness == TARGET_LITTLE_ENDIAN)
return pos;
else
return len - 1 - pos;
}
/* Convert register to string of bytes. NB! The # of bits in the
* register might be non-divisible by 8(a byte), in which
* case an entire byte is shown.
*
* NB! the format on the wire is the target endianess
*
* The format of reg->value is little endian
*
*/
void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg)
{
int i;
int j = gdb_reg_pos(target, i, buf_len);
tstr[i*2] = DIGITS[(buf[j]>>4) & 0xf];
static int hextoint(char c)
if (c>='0'&&c<='9')
{
return c-'0';
}
if (c>='A'&&c<='F')
{
return c-'A'+10;
}
LOG_ERROR("BUG: invalid register value %08x", c);
return 0;
}
/* copy over in register buffer */
void gdb_target_to_reg(target_t *target, char *tstr, int str_len, uint8_t *bin)
{
LOG_ERROR("BUG: gdb value with uneven number of characters encountered");
int i;
int j = gdb_reg_pos(target, i/2, str_len/2);
bin[j] = t;
}
int gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
{
reg_t **reg_list;
int reg_list_size;
int retval;
int reg_packet_size = 0;
char *reg_packet;
char *reg_packet_p;
int i;
#ifdef _DEBUG_GDB_IO_
if ((retval = target_get_gdb_reg_list(target, ®_list, ®_list_size)) != ERROR_OK)
return gdb_error(connection, retval);
}
for (i = 0; i < reg_list_size; i++)
{
reg_packet_size += reg_list[i]->size;
}
reg_packet = malloc(CEIL(reg_packet_size, 8) * 2);
reg_packet_p = reg_packet;
for (i = 0; i < reg_list_size; i++)
{
gdb_str_to_target(target, reg_packet_p, reg_list[i]);
reg_packet_p += CEIL(reg_list[i]->size, 8) * 2;
}
#ifdef _DEBUG_GDB_IO_
{
char *reg_packet_p;
reg_packet_p = strndup(reg_packet, CEIL(reg_packet_size, 8) * 2);
LOG_DEBUG("reg_packet: %s", reg_packet_p);
free(reg_packet_p);
}
#endif
gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);
free(reg_packet);
free(reg_list);
return ERROR_OK;
}
int gdb_set_registers_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
int i;
reg_t **reg_list;
int reg_list_size;
int retval;
char *packet_p;
#ifdef _DEBUG_GDB_IO_