/* rsp-server.c -- Remote Serial Protocol server for GDB
|
/* rsp-server.c -- Remote Serial Protocol server for GDB
|
|
|
Copyright (C) 2008 Embecosm Limited
|
Copyright (C) 2008 Embecosm Limited
|
|
|
Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
|
Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
|
|
|
This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.
|
This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.
|
|
|
This program is free software; you can redistribute it and/or modify it
|
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
|
under the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3 of the License, or (at your option)
|
Software Foundation; either version 3 of the License, or (at your option)
|
any later version.
|
any later version.
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
more details.
|
more details.
|
|
|
You should have received a copy of the GNU General Public License along
|
You should have received a copy of the GNU General Public License along
|
with this program. If not, see <http://www.gnu.org/licenses/>. */
|
with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
/* This program is commented throughout in a fashion suitable for processing
|
/* This program is commented throughout in a fashion suitable for processing
|
with Doxygen. */
|
with Doxygen. */
|
|
|
|
|
/* Autoconf and/or portability configuration */
|
/* Autoconf and/or portability configuration */
|
#include "config.h"
|
#include "config.h"
|
#include "port.h"
|
#include "port.h"
|
|
|
/* System includes */
|
/* System includes */
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#include <unistd.h>
|
#include <unistd.h>
|
#include <netdb.h>
|
#include <netdb.h>
|
#include <stdio.h>
|
#include <stdio.h>
|
#include <errno.h>
|
#include <errno.h>
|
#include <sys/types.h>
|
#include <sys/types.h>
|
#include <sys/socket.h>
|
#include <sys/socket.h>
|
#include <fcntl.h>
|
#include <fcntl.h>
|
#include <arpa/inet.h>
|
#include <arpa/inet.h>
|
#include <poll.h>
|
#include <poll.h>
|
#include <netinet/tcp.h>
|
#include <netinet/tcp.h>
|
#include <signal.h>
|
#include <signal.h>
|
|
|
/* Package includes */
|
/* Package includes */
|
#include "sim-config.h"
|
#include "sim-config.h"
|
#include "except.h"
|
#include "except.h"
|
#include "opcode/or32.h"
|
#include "opcode/or32.h"
|
#include "spr-defs.h"
|
#include "spr-defs.h"
|
#include "execute.h"
|
#include "execute.h"
|
#include "debug-unit.h"
|
#include "debug-unit.h"
|
#include "sprs.h"
|
#include "sprs.h"
|
#include "toplevel-support.h"
|
#include "toplevel-support.h"
|
|
|
|
|
/* Define to log each packet */
|
/* Define to log each packet */
|
/* #define RSP_TRACE 1 */
|
/* #define RSP_TRACE 1 */
|
|
|
/*! Name of the Or1ksim RSP service */
|
/*! Name of the Or1ksim RSP service */
|
#define OR1KSIM_RSP_SERVICE "or1ksim-rsp"
|
#define OR1KSIM_RSP_SERVICE "or1ksim-rsp"
|
|
|
/*! Protocol used by Or1ksim */
|
/*! Protocol used by Or1ksim */
|
#define OR1KSIM_RSP_PROTOCOL "tcp"
|
#define OR1KSIM_RSP_PROTOCOL "tcp"
|
|
|
/*! Thread ID used by Or1ksim */
|
/*! Thread ID used by Or1ksim */
|
#define OR1KSIM_TID 1
|
#define OR1KSIM_TID 1
|
|
|
/* Indices of GDB registers that are not GPRs. Must match GDB settings! */
|
/* Indices of GDB registers that are not GPRs. Must match GDB settings! */
|
#define PPC_REGNUM (MAX_GPRS + 0) /*!< Previous PC */
|
#define PPC_REGNUM (MAX_GPRS + 0) /*!< Previous PC */
|
#define NPC_REGNUM (MAX_GPRS + 1) /*!< Next PC */
|
#define NPC_REGNUM (MAX_GPRS + 1) /*!< Next PC */
|
#define SR_REGNUM (MAX_GPRS + 2) /*!< Supervision Register */
|
#define SR_REGNUM (MAX_GPRS + 2) /*!< Supervision Register */
|
#define NUM_REGS (MAX_GRPS + 3) /*!< Total GDB registers */
|
#define NUM_REGS (MAX_GRPS + 3) /*!< Total GDB registers */
|
|
|
/*! Trap instruction for OR32 */
|
/*! Trap instruction for OR32 */
|
#define OR1K_TRAP_INSTR 0x21000001
|
#define OR1K_TRAP_INSTR 0x21000001
|
|
|
/*! Definition of GDB target signals. Data taken from the GDB 6.8
|
/*! Definition of GDB target signals. Data taken from the GDB 6.8
|
source. Only those we use defined here. */
|
source. Only those we use defined here. */
|
enum target_signal {
|
enum target_signal {
|
TARGET_SIGNAL_NONE = 0,
|
TARGET_SIGNAL_NONE = 0,
|
TARGET_SIGNAL_INT = 2,
|
TARGET_SIGNAL_INT = 2,
|
TARGET_SIGNAL_ILL = 4,
|
TARGET_SIGNAL_ILL = 4,
|
TARGET_SIGNAL_TRAP = 5,
|
TARGET_SIGNAL_TRAP = 5,
|
TARGET_SIGNAL_FPE = 8,
|
TARGET_SIGNAL_FPE = 8,
|
TARGET_SIGNAL_BUS = 10,
|
TARGET_SIGNAL_BUS = 10,
|
TARGET_SIGNAL_SEGV = 11,
|
TARGET_SIGNAL_SEGV = 11,
|
TARGET_SIGNAL_ALRM = 14,
|
TARGET_SIGNAL_ALRM = 14,
|
TARGET_SIGNAL_USR2 = 31,
|
TARGET_SIGNAL_USR2 = 31,
|
TARGET_SIGNAL_PWR = 32
|
TARGET_SIGNAL_PWR = 32
|
};
|
};
|
|
|
/*! The maximum number of characters in inbound/outbound buffers. The largest
|
/*! The maximum number of characters in inbound/outbound buffers. The largest
|
packets are the 'G' packet, which must hold the 'G' and all the registers
|
packets are the 'G' packet, which must hold the 'G' and all the registers
|
with two hex digits per byte and the 'g' reply, which must hold all the
|
with two hex digits per byte and the 'g' reply, which must hold all the
|
registers, and (in our implementation) an end-of-string (0)
|
registers, and (in our implementation) an end-of-string (0)
|
character. Adding the EOS allows us to print out the packet as a
|
character. Adding the EOS allows us to print out the packet as a
|
string. So at least NUMREGBYTES*2 + 1 (for the 'G' or the EOS) are needed
|
string. So at least NUMREGBYTES*2 + 1 (for the 'G' or the EOS) are needed
|
for register packets */
|
for register packets */
|
#define GDB_BUF_MAX ((NUM_REGS) * 8 + 1)
|
#define GDB_BUF_MAX ((NUM_REGS) * 8 + 1)
|
|
|
/*! Size of the matchpoint hash table. Largest prime < 2^10 */
|
/*! Size of the matchpoint hash table. Largest prime < 2^10 */
|
#define MP_HASH_SIZE 1021
|
#define MP_HASH_SIZE 1021
|
|
|
/*! String to map hex digits to chars */
|
/*! String to map hex digits to chars */
|
static const char hexchars[]="0123456789abcdef";
|
static const char hexchars[]="0123456789abcdef";
|
|
|
/*! Data structure for RSP buffers. Can't be null terminated, since it may
|
/*! Data structure for RSP buffers. Can't be null terminated, since it may
|
include zero bytes */
|
include zero bytes */
|
struct rsp_buf
|
struct rsp_buf
|
{
|
{
|
char data[GDB_BUF_MAX];
|
char data[GDB_BUF_MAX];
|
int len;
|
int len;
|
};
|
};
|
|
|
/*! Enumeration of different types of matchpoint. These have explicit values
|
/*! Enumeration of different types of matchpoint. These have explicit values
|
matching the second digit of 'z' and 'Z' packets. */
|
matching the second digit of 'z' and 'Z' packets. */
|
enum mp_type {
|
enum mp_type {
|
BP_MEMORY = 0,
|
BP_MEMORY = 0,
|
BP_HARDWARE = 1,
|
BP_HARDWARE = 1,
|
WP_WRITE = 2,
|
WP_WRITE = 2,
|
WP_READ = 3,
|
WP_READ = 3,
|
WP_ACCESS = 4
|
WP_ACCESS = 4
|
};
|
};
|
|
|
/*! Data structure for a matchpoint hash table entry */
|
/*! Data structure for a matchpoint hash table entry */
|
struct mp_entry
|
struct mp_entry
|
{
|
{
|
enum mp_type type; /*!< Type of matchpoint */
|
enum mp_type type; /*!< Type of matchpoint */
|
unsigned long int addr; /*!< Address with the matchpoint */
|
unsigned long int addr; /*!< Address with the matchpoint */
|
unsigned long int instr; /*!< Substituted instruction */
|
unsigned long int instr; /*!< Substituted instruction */
|
struct mp_entry *next; /*!< Next entry with this hash */
|
struct mp_entry *next; /*!< Next entry with this hash */
|
};
|
};
|
|
|
/*! Central data for the RSP connection */
|
/*! Central data for the RSP connection */
|
static struct
|
static struct
|
{
|
{
|
int client_waiting; /*!< Is client waiting a response? */
|
int client_waiting; /*!< Is client waiting a response? */
|
int proto_num; /*!< Number of the protocol used */
|
int proto_num; /*!< Number of the protocol used */
|
int client_fd; /*!< FD for talking to GDB */
|
int client_fd; /*!< FD for talking to GDB */
|
int sigval; /*!< GDB signal for any exception */
|
int sigval; /*!< GDB signal for any exception */
|
unsigned long int start_addr; /*!< Start of last run */
|
unsigned long int start_addr; /*!< Start of last run */
|
struct mp_entry *mp_hash[MP_HASH_SIZE]; /*!< Matchpoint hash table */
|
struct mp_entry *mp_hash[MP_HASH_SIZE]; /*!< Matchpoint hash table */
|
} rsp;
|
} rsp;
|
|
|
/* Forward declarations of static functions */
|
/* Forward declarations of static functions */
|
static void rsp_get_client ();
|
static void rsp_get_client ();
|
static void rsp_client_request ();
|
static void rsp_client_request ();
|
static void rsp_client_close ();
|
static void rsp_client_close ();
|
static void put_packet (struct rsp_buf *buf);
|
static void put_packet (struct rsp_buf *buf);
|
static void put_str_packet (const char *str);
|
static void put_str_packet (const char *str);
|
static struct rsp_buf *get_packet ();
|
static struct rsp_buf *get_packet ();
|
static void put_rsp_char (char c);
|
static void put_rsp_char (char c);
|
static int get_rsp_char ();
|
static int get_rsp_char ();
|
static int rsp_unescape (char *data,
|
static int rsp_unescape (char *data,
|
int len);
|
int len);
|
static void mp_hash_init ();
|
static void mp_hash_init ();
|
static void mp_hash_add (enum mp_type type,
|
static void mp_hash_add (enum mp_type type,
|
unsigned long int addr,
|
unsigned long int addr,
|
unsigned long int instr);
|
unsigned long int instr);
|
static struct mp_entry *mp_hash_lookup (enum mp_type type,
|
static struct mp_entry *mp_hash_lookup (enum mp_type type,
|
unsigned long int addr);
|
unsigned long int addr);
|
static struct mp_entry *mp_hash_delete (enum mp_type type,
|
static struct mp_entry *mp_hash_delete (enum mp_type type,
|
unsigned long int addr);
|
unsigned long int addr);
|
static int hex (int c);
|
static int hex (int c);
|
static void reg2hex (unsigned long int val,
|
static void reg2hex (unsigned long int val,
|
char *buf);
|
char *buf);
|
static unsigned long int hex2reg (char *buf);
|
static unsigned long int hex2reg (char *buf);
|
static void ascii2hex (char *dest,
|
static void ascii2hex (char *dest,
|
char *src);
|
char *src);
|
static void hex2ascii (char *dest,
|
static void hex2ascii (char *dest,
|
char *src);
|
char *src);
|
static void set_npc (unsigned long int addr);
|
static void set_npc (unsigned long int addr);
|
static void rsp_report_exception ();
|
static void rsp_report_exception ();
|
static void rsp_continue (struct rsp_buf *buf);
|
static void rsp_continue (struct rsp_buf *buf);
|
static void rsp_continue_with_signal (struct rsp_buf *buf);
|
static void rsp_continue_with_signal (struct rsp_buf *buf);
|
static void rsp_continue_generic (unsigned long int addr,
|
static void rsp_continue_generic (unsigned long int addr,
|
unsigned long int except);
|
unsigned long int except);
|
static void rsp_read_all_regs ();
|
static void rsp_read_all_regs ();
|
static void rsp_write_all_regs (struct rsp_buf *buf);
|
static void rsp_write_all_regs (struct rsp_buf *buf);
|
static void rsp_read_mem (struct rsp_buf *buf);
|
static void rsp_read_mem (struct rsp_buf *buf);
|
static void rsp_write_mem (struct rsp_buf *buf);
|
static void rsp_write_mem (struct rsp_buf *buf);
|
static void rsp_read_reg (struct rsp_buf *buf);
|
static void rsp_read_reg (struct rsp_buf *buf);
|
static void rsp_write_reg (struct rsp_buf *buf);
|
static void rsp_write_reg (struct rsp_buf *buf);
|
static void rsp_query (struct rsp_buf *buf);
|
static void rsp_query (struct rsp_buf *buf);
|
static void rsp_command (struct rsp_buf *buf);
|
static void rsp_command (struct rsp_buf *buf);
|
static void rsp_set (struct rsp_buf *buf);
|
static void rsp_set (struct rsp_buf *buf);
|
static void rsp_restart ();
|
static void rsp_restart ();
|
static void rsp_step (struct rsp_buf *buf);
|
static void rsp_step (struct rsp_buf *buf);
|
static void rsp_step_with_signal (struct rsp_buf *buf);
|
static void rsp_step_with_signal (struct rsp_buf *buf);
|
static void rsp_step_generic (unsigned long int addr,
|
static void rsp_step_generic (unsigned long int addr,
|
unsigned long int except);
|
unsigned long int except);
|
static void rsp_vpkt (struct rsp_buf *buf);
|
static void rsp_vpkt (struct rsp_buf *buf);
|
static void rsp_write_mem_bin (struct rsp_buf *buf);
|
static void rsp_write_mem_bin (struct rsp_buf *buf);
|
static void rsp_remove_matchpoint (struct rsp_buf *buf);
|
static void rsp_remove_matchpoint (struct rsp_buf *buf);
|
static void rsp_insert_matchpoint (struct rsp_buf *buf);
|
static void rsp_insert_matchpoint (struct rsp_buf *buf);
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Initialize the Remote Serial Protocol connection
|
/*!Initialize the Remote Serial Protocol connection
|
|
|
Set up the central data structures. */
|
Set up the central data structures. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
void
|
void
|
rsp_init ()
|
rsp_init ()
|
{
|
{
|
/* Clear out the central data structure */
|
/* Clear out the central data structure */
|
rsp.client_waiting = 0; /* GDB client is not waiting for us */
|
rsp.client_waiting = 0; /* GDB client is not waiting for us */
|
rsp.client_fd = -1; /* i.e. invalid */
|
rsp.client_fd = -1; /* i.e. invalid */
|
rsp.sigval = 0; /* No exception */
|
rsp.sigval = 0; /* No exception */
|
rsp.start_addr = EXCEPT_RESET; /* Default restart point */
|
rsp.start_addr = EXCEPT_RESET; /* Default restart point */
|
|
|
/* Set up the matchpoint hash table */
|
/* Set up the matchpoint hash table */
|
mp_hash_init ();
|
mp_hash_init ();
|
|
|
} /* rsp_init () */
|
} /* rsp_init () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Look for action on RSP
|
/*!Look for action on RSP
|
|
|
This function is called when the processor has stalled, which, except for
|
This function is called when the processor has stalled, which, except for
|
initialization, must be due to an interrupt.
|
initialization, must be due to an interrupt.
|
|
|
If we have no RSP client, we get one. We can make no progress until the
|
If we have no RSP client, we get one. We can make no progress until the
|
client is available.
|
client is available.
|
|
|
Then if the cause is an exception following a step or continue command, and
|
Then if the cause is an exception following a step or continue command, and
|
the exception not been notified to GDB, a packet reporting the cause of the
|
the exception not been notified to GDB, a packet reporting the cause of the
|
exception is sent.
|
exception is sent.
|
|
|
The next client request is then processed. */
|
The next client request is then processed. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
void
|
void
|
handle_rsp ()
|
handle_rsp ()
|
{
|
{
|
/* If we have no RSP client, wait until we get one. */
|
/* If we have no RSP client, wait until we get one. */
|
while (-1 == rsp.client_fd)
|
while (-1 == rsp.client_fd)
|
{
|
{
|
rsp_get_client ();
|
rsp_get_client ();
|
rsp.client_waiting = 0; /* No longer waiting */
|
rsp.client_waiting = 0; /* No longer waiting */
|
}
|
}
|
|
|
/* If we have an unacknowledged exception tell the GDB client. If this
|
/* If we have an unacknowledged exception tell the GDB client. If this
|
exception was a trap due to a memory breakpoint, then adjust the NPC. */
|
exception was a trap due to a memory breakpoint, then adjust the NPC. */
|
if (rsp.client_waiting)
|
if (rsp.client_waiting)
|
{
|
{
|
if ((TARGET_SIGNAL_TRAP == rsp.sigval) &&
|
if ((TARGET_SIGNAL_TRAP == rsp.sigval) &&
|
(NULL != mp_hash_lookup (BP_MEMORY, cpu_state.sprs[SPR_PPC])))
|
(NULL != mp_hash_lookup (BP_MEMORY, cpu_state.sprs[SPR_PPC])))
|
{
|
{
|
set_npc (cpu_state.sprs[SPR_PPC]);
|
set_npc (cpu_state.sprs[SPR_PPC]);
|
}
|
}
|
|
|
rsp_report_exception();
|
rsp_report_exception();
|
rsp.client_waiting = 0; /* No longer waiting */
|
rsp.client_waiting = 0; /* No longer waiting */
|
}
|
}
|
|
|
/* Get a RSP client request */
|
/* Get a RSP client request */
|
rsp_client_request ();
|
rsp_client_request ();
|
|
|
} /* handle_rsp () */
|
} /* handle_rsp () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Note an exception for future processing
|
/*!Note an exception for future processing
|
|
|
The simulator has encountered an exception. Record it here, so that a
|
The simulator has encountered an exception. Record it here, so that a
|
future call to handle_exception will report it back to the client. The
|
future call to handle_exception will report it back to the client. The
|
signal is supplied in Or1ksim form and recorded in GDB form.
|
signal is supplied in Or1ksim form and recorded in GDB form.
|
|
|
We flag up a warning if an exception is already pending, and ignore the
|
We flag up a warning if an exception is already pending, and ignore the
|
earlier exception.
|
earlier exception.
|
|
|
@param[in] except The exception (Or1ksim form) */
|
@param[in] except The exception (Or1ksim form) */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
void
|
void
|
rsp_exception (unsigned long int except)
|
rsp_exception (unsigned long int except)
|
{
|
{
|
int sigval; /* GDB signal equivalent to exception */
|
int sigval; /* GDB signal equivalent to exception */
|
|
|
switch (except)
|
switch (except)
|
{
|
{
|
case EXCEPT_RESET: sigval = TARGET_SIGNAL_PWR; break;
|
case EXCEPT_RESET: sigval = TARGET_SIGNAL_PWR; break;
|
case EXCEPT_BUSERR: sigval = TARGET_SIGNAL_BUS; break;
|
case EXCEPT_BUSERR: sigval = TARGET_SIGNAL_BUS; break;
|
case EXCEPT_DPF: sigval = TARGET_SIGNAL_SEGV; break;
|
case EXCEPT_DPF: sigval = TARGET_SIGNAL_SEGV; break;
|
case EXCEPT_IPF: sigval = TARGET_SIGNAL_SEGV; break;
|
case EXCEPT_IPF: sigval = TARGET_SIGNAL_SEGV; break;
|
case EXCEPT_TICK: sigval = TARGET_SIGNAL_ALRM; break;
|
case EXCEPT_TICK: sigval = TARGET_SIGNAL_ALRM; break;
|
case EXCEPT_ALIGN: sigval = TARGET_SIGNAL_BUS; break;
|
case EXCEPT_ALIGN: sigval = TARGET_SIGNAL_BUS; break;
|
case EXCEPT_ILLEGAL: sigval = TARGET_SIGNAL_ILL; break;
|
case EXCEPT_ILLEGAL: sigval = TARGET_SIGNAL_ILL; break;
|
case EXCEPT_INT: sigval = TARGET_SIGNAL_INT; break;
|
case EXCEPT_INT: sigval = TARGET_SIGNAL_INT; break;
|
case EXCEPT_DTLBMISS: sigval = TARGET_SIGNAL_SEGV; break;
|
case EXCEPT_DTLBMISS: sigval = TARGET_SIGNAL_SEGV; break;
|
case EXCEPT_ITLBMISS: sigval = TARGET_SIGNAL_SEGV; break;
|
case EXCEPT_ITLBMISS: sigval = TARGET_SIGNAL_SEGV; break;
|
case EXCEPT_RANGE: sigval = TARGET_SIGNAL_FPE; break;
|
case EXCEPT_RANGE: sigval = TARGET_SIGNAL_FPE; break;
|
case EXCEPT_SYSCALL: sigval = TARGET_SIGNAL_USR2; break;
|
case EXCEPT_SYSCALL: sigval = TARGET_SIGNAL_USR2; break;
|
case EXCEPT_FPE: sigval = TARGET_SIGNAL_FPE; break;
|
case EXCEPT_FPE: sigval = TARGET_SIGNAL_FPE; break;
|
case EXCEPT_TRAP: sigval = TARGET_SIGNAL_TRAP; break;
|
case EXCEPT_TRAP: sigval = TARGET_SIGNAL_TRAP; break;
|
|
|
default:
|
default:
|
fprintf (stderr, "Warning: Unknown RSP exception %lu: Ignored\n", except);
|
fprintf (stderr, "Warning: Unknown RSP exception %lu: Ignored\n", except);
|
return;
|
return;
|
}
|
}
|
|
|
if ((0 != rsp.sigval) && (sigval != rsp.sigval))
|
if ((0 != rsp.sigval) && (sigval != rsp.sigval))
|
{
|
{
|
fprintf (stderr, "Warning: RSP signal %d received while signal "
|
fprintf (stderr, "Warning: RSP signal %d received while signal "
|
"%d pending: Pending exception replaced\n", sigval, rsp.sigval);
|
"%d pending: Pending exception replaced\n", sigval, rsp.sigval);
|
}
|
}
|
|
|
rsp.sigval = sigval; /* Save the signal value */
|
rsp.sigval = sigval; /* Save the signal value */
|
|
|
} /* rsp_exception () */
|
} /* rsp_exception () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Get a new client connection.
|
/*!Get a new client connection.
|
|
|
Blocks until the client connection is available.
|
Blocks until the client connection is available.
|
|
|
A lot of this code is copied from remote_open in gdbserver remote-utils.c.
|
A lot of this code is copied from remote_open in gdbserver remote-utils.c.
|
|
|
This involves setting up a socket to listen on a socket for attempted
|
This involves setting up a socket to listen on a socket for attempted
|
connections from a single GDB instance (we couldn't be talking to multiple
|
connections from a single GDB instance (we couldn't be talking to multiple
|
GDBs at once!).
|
GDBs at once!).
|
|
|
The service is specified either as a port number in the Or1ksim configuration
|
The service is specified either as a port number in the Or1ksim configuration
|
(parameter rsp_port in section debug, default 51000) or as a service name
|
(parameter rsp_port in section debug, default 51000) or as a service name
|
in the constant OR1KSIM_RSP_SERVICE.
|
in the constant OR1KSIM_RSP_SERVICE.
|
|
|
The protocol used for communication is specified in OR1KSIM_RSP_PROTOCOL. */
|
The protocol used for communication is specified in OR1KSIM_RSP_PROTOCOL. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_get_client ()
|
rsp_get_client ()
|
{
|
{
|
int tmp_fd; /* Temporary descriptor for socket */
|
int tmp_fd; /* Temporary descriptor for socket */
|
int optval; /* Socket options */
|
int optval; /* Socket options */
|
struct sockaddr_in sock_addr; /* Socket address */
|
struct sockaddr_in sock_addr; /* Socket address */
|
socklen_t len; /* Size of the socket address */
|
socklen_t len; /* Size of the socket address */
|
|
|
/* 0 is used as the RSP port number to indicate that we should use the
|
/* 0 is used as the RSP port number to indicate that we should use the
|
service name instead. */
|
service name instead. */
|
if (0 == config.debug.rsp_port)
|
if (0 == config.debug.rsp_port)
|
{
|
{
|
struct servent *service =
|
struct servent *service =
|
getservbyname (OR1KSIM_RSP_SERVICE, "tcp");
|
getservbyname (OR1KSIM_RSP_SERVICE, "tcp");
|
|
|
if (NULL == service)
|
if (NULL == service)
|
{
|
{
|
fprintf (stderr, "Warning: RSP unable to find service \"%s\": %s\n",
|
fprintf (stderr, "Warning: RSP unable to find service \"%s\": %s\n",
|
OR1KSIM_RSP_SERVICE, strerror (errno));
|
OR1KSIM_RSP_SERVICE, strerror (errno));
|
return;
|
return;
|
}
|
}
|
|
|
config.debug.rsp_port = ntohs (service->s_port);
|
config.debug.rsp_port = ntohs (service->s_port);
|
}
|
}
|
|
|
/* Open a socket on which we'll listen for clients */
|
/* Open a socket on which we'll listen for clients */
|
tmp_fd = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
|
tmp_fd = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
|
if (tmp_fd < 0)
|
if (tmp_fd < 0)
|
{
|
{
|
fprintf (stderr, "ERROR: Cannot open RSP socket\n");
|
fprintf (stderr, "ERROR: Cannot open RSP socket\n");
|
sim_done ();
|
sim_done ();
|
}
|
}
|
|
|
/* Allow rapid reuse of the port on this socket */
|
/* Allow rapid reuse of the port on this socket */
|
optval = 1;
|
optval = 1;
|
setsockopt (tmp_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&optval,
|
setsockopt (tmp_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&optval,
|
sizeof (optval));
|
sizeof (optval));
|
|
|
/* Bind the port to the socket */
|
/* Bind the port to the socket */
|
sock_addr.sin_family = PF_INET;
|
sock_addr.sin_family = PF_INET;
|
sock_addr.sin_port = htons (config.debug.rsp_port);
|
sock_addr.sin_port = htons (config.debug.rsp_port);
|
sock_addr.sin_addr.s_addr = INADDR_ANY;
|
sock_addr.sin_addr.s_addr = INADDR_ANY;
|
if (bind (tmp_fd, (struct sockaddr *) &sock_addr, sizeof (sock_addr)))
|
if (bind (tmp_fd, (struct sockaddr *) &sock_addr, sizeof (sock_addr)))
|
{
|
{
|
fprintf (stderr, "ERROR: Cannot bind to RSP socket\n");
|
fprintf (stderr, "ERROR: Cannot bind to RSP socket\n");
|
sim_done ();
|
sim_done ();
|
}
|
}
|
|
|
/* Listen for (at most one) client */
|
/* Listen for (at most one) client */
|
if (listen (tmp_fd, 1))
|
if (listen (tmp_fd, 1))
|
{
|
{
|
fprintf (stderr, "ERROR: Cannot listen on RSP socket\n");
|
fprintf (stderr, "ERROR: Cannot listen on RSP socket\n");
|
sim_done ();
|
sim_done ();
|
}
|
}
|
|
|
printf ("Listening for RSP on port %d\n", config.debug.rsp_port);
|
printf ("Listening for RSP on port %d\n", config.debug.rsp_port);
|
fflush (stdout);
|
fflush (stdout);
|
|
|
/* Accept a client which connects */
|
/* Accept a client which connects */
|
|
len = sizeof (socklen_t); /* Bug fix by Julius Baxter */
|
rsp.client_fd = accept (tmp_fd, (struct sockaddr *)&sock_addr, &len);
|
rsp.client_fd = accept (tmp_fd, (struct sockaddr *)&sock_addr, &len);
|
|
|
if (-1 == rsp.client_fd)
|
if (-1 == rsp.client_fd)
|
{
|
{
|
fprintf (stderr, "Warning: Failed to accept RSP client\n");
|
fprintf (stderr, "Warning: Failed to accept RSP client\n");
|
return;
|
return;
|
}
|
}
|
|
|
/* Enable TCP keep alive process */
|
/* Enable TCP keep alive process */
|
optval = 1;
|
optval = 1;
|
setsockopt (rsp.client_fd, SOL_SOCKET, SO_KEEPALIVE, (char *)&optval,
|
setsockopt (rsp.client_fd, SOL_SOCKET, SO_KEEPALIVE, (char *)&optval,
|
sizeof (optval));
|
sizeof (optval));
|
|
|
/* Don't delay small packets, for better interactive response (disable
|
/* Don't delay small packets, for better interactive response (disable
|
Nagel's algorithm) */
|
Nagel's algorithm) */
|
optval = 1;
|
optval = 1;
|
setsockopt (rsp.client_fd, IPPROTO_TCP, TCP_NODELAY, (char *)&optval,
|
setsockopt (rsp.client_fd, IPPROTO_TCP, TCP_NODELAY, (char *)&optval,
|
sizeof (optval));
|
sizeof (optval));
|
|
|
/* Socket is no longer needed */
|
/* Socket is no longer needed */
|
close (tmp_fd); /* No longer need this */
|
close (tmp_fd); /* No longer need this */
|
signal (SIGPIPE, SIG_IGN); /* So we don't exit if client dies */
|
signal (SIGPIPE, SIG_IGN); /* So we don't exit if client dies */
|
|
|
printf ("Remote debugging from host %s\n", inet_ntoa (sock_addr.sin_addr));
|
printf ("Remote debugging from host %s\n", inet_ntoa (sock_addr.sin_addr));
|
|
|
/* If fcntl () is available, use it to enable async I/O
|
/* If fcntl () is available, use it to enable async I/O
|
#if defined(F_SETFL) && defined (FASYNC)
|
#if defined(F_SETFL) && defined (FASYNC)
|
save_fcntl_flags = fcntl (remote_desc, F_GETFL, 0);
|
save_fcntl_flags = fcntl (remote_desc, F_GETFL, 0);
|
fcntl (remote_desc, F_SETFL, save_fcntl_flags | FASYNC);
|
fcntl (remote_desc, F_SETFL, save_fcntl_flags | FASYNC);
|
#if defined (F_SETOWN)
|
#if defined (F_SETOWN)
|
fcntl (remote_desc, F_SETOWN, getpid ());
|
fcntl (remote_desc, F_SETOWN, getpid ());
|
#endif
|
#endif
|
#endif */
|
#endif */
|
|
|
} /* rsp_get_client () */
|
} /* rsp_get_client () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Deal with a request from the GDB client session
|
/*!Deal with a request from the GDB client session
|
|
|
In general, apart from the simplest requests, this function replies on
|
In general, apart from the simplest requests, this function replies on
|
other functions to implement the functionality. */
|
other functions to implement the functionality. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_client_request ()
|
rsp_client_request ()
|
{
|
{
|
struct rsp_buf *buf = get_packet (); /* Message sent to us */
|
struct rsp_buf *buf = get_packet (); /* Message sent to us */
|
|
|
// Null packet means we hit EOF or the link was closed for some other
|
// Null packet means we hit EOF or the link was closed for some other
|
// reason. Close the client and return
|
// reason. Close the client and return
|
if (NULL == buf)
|
if (NULL == buf)
|
{
|
{
|
rsp_client_close ();
|
rsp_client_close ();
|
return;
|
return;
|
}
|
}
|
|
|
#if RSP_TRACE
|
#if RSP_TRACE
|
printf ("Packet received %s: %d chars\n", buf->data, buf->len );
|
printf ("Packet received %s: %d chars\n", buf->data, buf->len );
|
fflush (stdout);
|
fflush (stdout);
|
#endif
|
#endif
|
|
|
switch (buf->data[0])
|
switch (buf->data[0])
|
{
|
{
|
case '!':
|
case '!':
|
/* Request for extended remote mode */
|
/* Request for extended remote mode */
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
return;
|
return;
|
|
|
case '?':
|
case '?':
|
/* Return last signal ID */
|
/* Return last signal ID */
|
rsp_report_exception();
|
rsp_report_exception();
|
return;
|
return;
|
|
|
case 'A':
|
case 'A':
|
/* Initialization of argv not supported */
|
/* Initialization of argv not supported */
|
fprintf (stderr, "Warning: RSP 'A' packet not supported: ignored\n");
|
fprintf (stderr, "Warning: RSP 'A' packet not supported: ignored\n");
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
|
|
case 'b':
|
case 'b':
|
/* Setting baud rate is deprecated */
|
/* Setting baud rate is deprecated */
|
fprintf (stderr, "Warning: RSP 'b' packet is deprecated and not "
|
fprintf (stderr, "Warning: RSP 'b' packet is deprecated and not "
|
"supported: ignored\n");
|
"supported: ignored\n");
|
return;
|
return;
|
|
|
case 'B':
|
case 'B':
|
/* Breakpoints should be set using Z packets */
|
/* Breakpoints should be set using Z packets */
|
fprintf (stderr, "Warning: RSP 'B' packet is deprecated (use 'Z'/'z' "
|
fprintf (stderr, "Warning: RSP 'B' packet is deprecated (use 'Z'/'z' "
|
"packets instead): ignored\n");
|
"packets instead): ignored\n");
|
return;
|
return;
|
|
|
case 'c':
|
case 'c':
|
/* Continue */
|
/* Continue */
|
rsp_continue (buf);
|
rsp_continue (buf);
|
return;
|
return;
|
|
|
case 'C':
|
case 'C':
|
/* Continue with signal */
|
/* Continue with signal */
|
rsp_continue_with_signal (buf);
|
rsp_continue_with_signal (buf);
|
return;
|
return;
|
|
|
case 'd':
|
case 'd':
|
/* Disable debug using a general query */
|
/* Disable debug using a general query */
|
fprintf (stderr, "Warning: RSP 'd' packet is deprecated (define a 'Q' "
|
fprintf (stderr, "Warning: RSP 'd' packet is deprecated (define a 'Q' "
|
"packet instead: ignored\n");
|
"packet instead: ignored\n");
|
return;
|
return;
|
|
|
case 'D':
|
case 'D':
|
/* Detach GDB. Do this by closing the client. The rules say that
|
/* Detach GDB. Do this by closing the client. The rules say that
|
execution should continue. TODO. Is this really then intended
|
execution should continue. TODO. Is this really then intended
|
meaning? Or does it just mean that only vAttach will be recognized
|
meaning? Or does it just mean that only vAttach will be recognized
|
after this? */
|
after this? */
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
rsp_client_close ();
|
rsp_client_close ();
|
set_stall_state (0);
|
set_stall_state (0);
|
rsp.sigval = TARGET_SIGNAL_NONE; /* No signal now */
|
rsp.sigval = TARGET_SIGNAL_NONE; /* No signal now */
|
return;
|
return;
|
|
|
case 'F':
|
case 'F':
|
/* File I/O is not currently supported */
|
/* File I/O is not currently supported */
|
fprintf (stderr, "Warning: RSP file I/O not currently supported: 'F' "
|
fprintf (stderr, "Warning: RSP file I/O not currently supported: 'F' "
|
"packet ignored\n");
|
"packet ignored\n");
|
return;
|
return;
|
|
|
case 'g':
|
case 'g':
|
rsp_read_all_regs ();
|
rsp_read_all_regs ();
|
return;
|
return;
|
|
|
case 'G':
|
case 'G':
|
rsp_write_all_regs (buf);
|
rsp_write_all_regs (buf);
|
return;
|
return;
|
|
|
case 'H':
|
case 'H':
|
/* Set the thread number of subsequent operations. For now ignore
|
/* Set the thread number of subsequent operations. For now ignore
|
silently and just reply "OK" */
|
silently and just reply "OK" */
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
return;
|
return;
|
|
|
case 'i':
|
case 'i':
|
/* Single instruction step */
|
/* Single instruction step */
|
fprintf (stderr, "Warning: RSP cycle stepping not supported: target "
|
fprintf (stderr, "Warning: RSP cycle stepping not supported: target "
|
"stopped immediately\n");
|
"stopped immediately\n");
|
rsp.client_waiting = 1; /* Stop reply will be sent */
|
rsp.client_waiting = 1; /* Stop reply will be sent */
|
return;
|
return;
|
|
|
case 'I':
|
case 'I':
|
/* Single instruction step with signal */
|
/* Single instruction step with signal */
|
fprintf (stderr, "Warning: RSP cycle stepping not supported: target "
|
fprintf (stderr, "Warning: RSP cycle stepping not supported: target "
|
"stopped immediately\n");
|
"stopped immediately\n");
|
rsp.client_waiting = 1; /* Stop reply will be sent */
|
rsp.client_waiting = 1; /* Stop reply will be sent */
|
return;
|
return;
|
|
|
case 'k':
|
case 'k':
|
/* Kill request. Do nothing for now. */
|
/* Kill request. Do nothing for now. */
|
return;
|
return;
|
|
|
case 'm':
|
case 'm':
|
/* Read memory (symbolic) */
|
/* Read memory (symbolic) */
|
rsp_read_mem (buf);
|
rsp_read_mem (buf);
|
return;
|
return;
|
|
|
case 'M':
|
case 'M':
|
/* Write memory (symbolic) */
|
/* Write memory (symbolic) */
|
rsp_write_mem (buf);
|
rsp_write_mem (buf);
|
return;
|
return;
|
|
|
case 'p':
|
case 'p':
|
/* Read a register */
|
/* Read a register */
|
rsp_read_reg (buf);
|
rsp_read_reg (buf);
|
return;
|
return;
|
|
|
case 'P':
|
case 'P':
|
/* Write a register */
|
/* Write a register */
|
rsp_write_reg (buf);
|
rsp_write_reg (buf);
|
return;
|
return;
|
|
|
case 'q':
|
case 'q':
|
/* Any one of a number of query packets */
|
/* Any one of a number of query packets */
|
rsp_query (buf);
|
rsp_query (buf);
|
return;
|
return;
|
|
|
case 'Q':
|
case 'Q':
|
/* Any one of a number of set packets */
|
/* Any one of a number of set packets */
|
rsp_set (buf);
|
rsp_set (buf);
|
return;
|
return;
|
|
|
case 'r':
|
case 'r':
|
/* Reset the system. Deprecated (use 'R' instead) */
|
/* Reset the system. Deprecated (use 'R' instead) */
|
fprintf (stderr, "Warning: RSP 'r' packet is deprecated (use 'R' "
|
fprintf (stderr, "Warning: RSP 'r' packet is deprecated (use 'R' "
|
"packet instead): ignored\n");
|
"packet instead): ignored\n");
|
return;
|
return;
|
|
|
case 'R':
|
case 'R':
|
/* Restart the program being debugged. */
|
/* Restart the program being debugged. */
|
rsp_restart ();
|
rsp_restart ();
|
return;
|
return;
|
|
|
case 's':
|
case 's':
|
/* Single step (one high level instruction). This could be hard without
|
/* Single step (one high level instruction). This could be hard without
|
DWARF2 info */
|
DWARF2 info */
|
rsp_step (buf);
|
rsp_step (buf);
|
return;
|
return;
|
|
|
case 'S':
|
case 'S':
|
/* Single step (one high level instruction) with signal. This could be
|
/* Single step (one high level instruction) with signal. This could be
|
hard without DWARF2 info */
|
hard without DWARF2 info */
|
rsp_step_with_signal (buf);
|
rsp_step_with_signal (buf);
|
return;
|
return;
|
|
|
case 't':
|
case 't':
|
/* Search. This is not well defined in the manual and for now we don't
|
/* Search. This is not well defined in the manual and for now we don't
|
support it. No response is defined. */
|
support it. No response is defined. */
|
fprintf (stderr, "Warning: RSP 't' packet not supported: ignored\n");
|
fprintf (stderr, "Warning: RSP 't' packet not supported: ignored\n");
|
return;
|
return;
|
|
|
case 'T':
|
case 'T':
|
/* Is the thread alive. We are bare metal, so don't have a thread
|
/* Is the thread alive. We are bare metal, so don't have a thread
|
context. The answer is always "OK". */
|
context. The answer is always "OK". */
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
return;
|
return;
|
|
|
case 'v':
|
case 'v':
|
/* Any one of a number of packets to control execution */
|
/* Any one of a number of packets to control execution */
|
rsp_vpkt (buf);
|
rsp_vpkt (buf);
|
return;
|
return;
|
|
|
case 'X':
|
case 'X':
|
/* Write memory (binary) */
|
/* Write memory (binary) */
|
rsp_write_mem_bin (buf);
|
rsp_write_mem_bin (buf);
|
return;
|
return;
|
|
|
case 'z':
|
case 'z':
|
/* Remove a breakpoint/watchpoint. */
|
/* Remove a breakpoint/watchpoint. */
|
rsp_remove_matchpoint (buf);
|
rsp_remove_matchpoint (buf);
|
return;
|
return;
|
|
|
case 'Z':
|
case 'Z':
|
/* Insert a breakpoint/watchpoint. */
|
/* Insert a breakpoint/watchpoint. */
|
rsp_insert_matchpoint (buf);
|
rsp_insert_matchpoint (buf);
|
return;
|
return;
|
|
|
default:
|
default:
|
/* Unknown commands are ignored */
|
/* Unknown commands are ignored */
|
fprintf (stderr, "Warning: Unknown RSP request %s\n", buf->data);
|
fprintf (stderr, "Warning: Unknown RSP request %s\n", buf->data);
|
return;
|
return;
|
}
|
}
|
} /* rsp_client_request () */
|
} /* rsp_client_request () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Close the connection to the client if it is open */
|
/*!Close the connection to the client if it is open */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_client_close ()
|
rsp_client_close ()
|
{
|
{
|
if (-1 != rsp.client_fd)
|
if (-1 != rsp.client_fd)
|
{
|
{
|
close (rsp.client_fd);
|
close (rsp.client_fd);
|
rsp.client_fd = -1;
|
rsp.client_fd = -1;
|
}
|
}
|
} /* rsp_client_close () */
|
} /* rsp_client_close () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Send a packet to the GDB client
|
/*!Send a packet to the GDB client
|
|
|
Modeled on the stub version supplied with GDB. Put out the data preceded by
|
Modeled on the stub version supplied with GDB. Put out the data preceded by
|
a '$', followed by a '#' and a one byte checksum. '$', '#', '*' and '}' are
|
a '$', followed by a '#' and a one byte checksum. '$', '#', '*' and '}' are
|
escaped by preceding them with '}' and then XORing the character with
|
escaped by preceding them with '}' and then XORing the character with
|
0x20.
|
0x20.
|
|
|
@param[in] buf The data to send */
|
@param[in] buf The data to send */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
put_packet (struct rsp_buf *buf)
|
put_packet (struct rsp_buf *buf)
|
{
|
{
|
int ch; /* Ack char */
|
int ch; /* Ack char */
|
|
|
/* Construct $<packet info>#<checksum>. Repeat until the GDB client
|
/* Construct $<packet info>#<checksum>. Repeat until the GDB client
|
acknowledges satisfactory receipt. */
|
acknowledges satisfactory receipt. */
|
do
|
do
|
{
|
{
|
unsigned char checksum = 0; /* Computed checksum */
|
unsigned char checksum = 0; /* Computed checksum */
|
int count = 0; /* Index into the buffer */
|
int count = 0; /* Index into the buffer */
|
|
|
#if RSP_TRACE
|
#if RSP_TRACE
|
printf ("Putting %s\n", buf->data);
|
printf ("Putting %s\n", buf->data);
|
fflush (stdout);
|
fflush (stdout);
|
#endif
|
#endif
|
|
|
put_rsp_char ('$'); /* Start char */
|
put_rsp_char ('$'); /* Start char */
|
|
|
/* Body of the packet */
|
/* Body of the packet */
|
for (count = 0; count < buf->len; count++)
|
for (count = 0; count < buf->len; count++)
|
{
|
{
|
unsigned char ch = buf->data[count];
|
unsigned char ch = buf->data[count];
|
|
|
/* Check for escaped chars */
|
/* Check for escaped chars */
|
if (('$' == ch) || ('#' == ch) || ('*' == ch) || ('}' == ch))
|
if (('$' == ch) || ('#' == ch) || ('*' == ch) || ('}' == ch))
|
{
|
{
|
ch ^= 0x20;
|
ch ^= 0x20;
|
checksum += (unsigned char)'}';
|
checksum += (unsigned char)'}';
|
put_rsp_char ('}');
|
put_rsp_char ('}');
|
}
|
}
|
|
|
checksum += ch;
|
checksum += ch;
|
put_rsp_char (ch);
|
put_rsp_char (ch);
|
}
|
}
|
|
|
put_rsp_char ('#'); /* End char */
|
put_rsp_char ('#'); /* End char */
|
|
|
/* Computed checksum */
|
/* Computed checksum */
|
put_rsp_char (hexchars[checksum >> 4]);
|
put_rsp_char (hexchars[checksum >> 4]);
|
put_rsp_char (hexchars[checksum % 16]);
|
put_rsp_char (hexchars[checksum % 16]);
|
|
|
/* Check for ack of connection failure */
|
/* Check for ack of connection failure */
|
ch = get_rsp_char ();
|
ch = get_rsp_char ();
|
if (-1 == ch)
|
if (-1 == ch)
|
{
|
{
|
return; /* Fail the put silently. */
|
return; /* Fail the put silently. */
|
}
|
}
|
}
|
}
|
while ('+' != ch);
|
while ('+' != ch);
|
|
|
} /* put_packet () */
|
} /* put_packet () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Convenience to put a constant string packet
|
/*!Convenience to put a constant string packet
|
|
|
param[in] str The text of the packet */
|
param[in] str The text of the packet */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
put_str_packet (const char *str)
|
put_str_packet (const char *str)
|
{
|
{
|
struct rsp_buf buf;
|
struct rsp_buf buf;
|
int len = strlen (str);
|
int len = strlen (str);
|
|
|
/* Construct the packet to send, so long as string is not too big,
|
/* Construct the packet to send, so long as string is not too big,
|
otherwise truncate. Add EOS at the end for convenient debug printout */
|
otherwise truncate. Add EOS at the end for convenient debug printout */
|
|
|
if (len >= GDB_BUF_MAX)
|
if (len >= GDB_BUF_MAX)
|
{
|
{
|
fprintf (stderr, "Warning: String %s too large for RSP packet: "
|
fprintf (stderr, "Warning: String %s too large for RSP packet: "
|
"truncated\n", str);
|
"truncated\n", str);
|
len = GDB_BUF_MAX - 1;
|
len = GDB_BUF_MAX - 1;
|
}
|
}
|
|
|
strncpy (buf.data, str, len);
|
strncpy (buf.data, str, len);
|
buf.data[len] = 0;
|
buf.data[len] = 0;
|
buf.len = len;
|
buf.len = len;
|
|
|
put_packet (&buf);
|
put_packet (&buf);
|
|
|
} /* put_str_packet () */
|
} /* put_str_packet () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Get a packet from the GDB client
|
/*!Get a packet from the GDB client
|
|
|
Modeled on the stub version supplied with GDB. The data is in a static
|
Modeled on the stub version supplied with GDB. The data is in a static
|
buffer. The data should be copied elsewhere if it is to be preserved across
|
buffer. The data should be copied elsewhere if it is to be preserved across
|
a subsequent call to get_packet().
|
a subsequent call to get_packet().
|
|
|
Unlike the reference implementation, we don't deal with sequence
|
Unlike the reference implementation, we don't deal with sequence
|
numbers. GDB has never used them, and this implementation is only intended
|
numbers. GDB has never used them, and this implementation is only intended
|
for use with GDB 6.8 or later. Sequence numbers were removed from the RSP
|
for use with GDB 6.8 or later. Sequence numbers were removed from the RSP
|
standard at GDB 5.0.
|
standard at GDB 5.0.
|
|
|
@return A pointer to the static buffer containing the data */
|
@return A pointer to the static buffer containing the data */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static struct rsp_buf *
|
static struct rsp_buf *
|
get_packet ()
|
get_packet ()
|
{
|
{
|
static struct rsp_buf buf; /* Survives the return */
|
static struct rsp_buf buf; /* Survives the return */
|
|
|
/* Keep getting packets, until one is found with a valid checksum */
|
/* Keep getting packets, until one is found with a valid checksum */
|
while (1)
|
while (1)
|
{
|
{
|
unsigned char checksum; /* The checksum we have computed */
|
unsigned char checksum; /* The checksum we have computed */
|
int count; /* Index into the buffer */
|
int count; /* Index into the buffer */
|
int ch; /* Current character */
|
int ch; /* Current character */
|
|
|
/* Wait around for the start character ('$'). Ignore all other
|
/* Wait around for the start character ('$'). Ignore all other
|
characters */
|
characters */
|
ch = get_rsp_char ();
|
ch = get_rsp_char ();
|
while (ch != '$')
|
while (ch != '$')
|
{
|
{
|
if (-1 == ch)
|
if (-1 == ch)
|
{
|
{
|
return NULL; /* Connection failed */
|
return NULL; /* Connection failed */
|
}
|
}
|
|
|
ch = get_rsp_char ();
|
ch = get_rsp_char ();
|
}
|
}
|
|
|
/* Read until a '#' or end of buffer is found */
|
/* Read until a '#' or end of buffer is found */
|
checksum = 0;
|
checksum = 0;
|
count = 0;
|
count = 0;
|
while (count < GDB_BUF_MAX - 1)
|
while (count < GDB_BUF_MAX - 1)
|
{
|
{
|
ch = get_rsp_char ();
|
ch = get_rsp_char ();
|
|
|
/* Check for connection failure */
|
/* Check for connection failure */
|
if (-1 == ch)
|
if (-1 == ch)
|
{
|
{
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* If we hit a start of line char begin all over again */
|
/* If we hit a start of line char begin all over again */
|
if ('$' == ch)
|
if ('$' == ch)
|
{
|
{
|
checksum = 0;
|
checksum = 0;
|
count = 0;
|
count = 0;
|
|
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Break out if we get the end of line char */
|
/* Break out if we get the end of line char */
|
if ('#' == ch)
|
if ('#' == ch)
|
{
|
{
|
break;
|
break;
|
}
|
}
|
|
|
/* Update the checksum and add the char to the buffer */
|
/* Update the checksum and add the char to the buffer */
|
|
|
checksum = checksum + (unsigned char)ch;
|
checksum = checksum + (unsigned char)ch;
|
buf.data[count] = (char)ch;
|
buf.data[count] = (char)ch;
|
count = count + 1;
|
count = count + 1;
|
}
|
}
|
|
|
/* Mark the end of the buffer with EOS - it's convenient for non-binary
|
/* Mark the end of the buffer with EOS - it's convenient for non-binary
|
data to be valid strings. */
|
data to be valid strings. */
|
buf.data[count] = 0;
|
buf.data[count] = 0;
|
buf.len = count;
|
buf.len = count;
|
|
|
/* If we have a valid end of packet char, validate the checksum */
|
/* If we have a valid end of packet char, validate the checksum */
|
if ('#' == ch)
|
if ('#' == ch)
|
{
|
{
|
unsigned char xmitcsum; /* The checksum in the packet */
|
unsigned char xmitcsum; /* The checksum in the packet */
|
|
|
ch = get_rsp_char ();
|
ch = get_rsp_char ();
|
if (-1 == ch)
|
if (-1 == ch)
|
{
|
{
|
return NULL; /* Connection failed */
|
return NULL; /* Connection failed */
|
}
|
}
|
xmitcsum = hex (ch) << 4;
|
xmitcsum = hex (ch) << 4;
|
|
|
ch = get_rsp_char ();
|
ch = get_rsp_char ();
|
if (-1 == ch)
|
if (-1 == ch)
|
{
|
{
|
return NULL; /* Connection failed */
|
return NULL; /* Connection failed */
|
}
|
}
|
|
|
xmitcsum += hex (ch);
|
xmitcsum += hex (ch);
|
|
|
/* If the checksums don't match print a warning, and put the
|
/* If the checksums don't match print a warning, and put the
|
negative ack back to the client. Otherwise put a positive ack. */
|
negative ack back to the client. Otherwise put a positive ack. */
|
if (checksum != xmitcsum)
|
if (checksum != xmitcsum)
|
{
|
{
|
fprintf (stderr, "Warning: Bad RSP checksum: Computed "
|
fprintf (stderr, "Warning: Bad RSP checksum: Computed "
|
"0x%02x, received 0x%02x\n", checksum, xmitcsum);
|
"0x%02x, received 0x%02x\n", checksum, xmitcsum);
|
|
|
put_rsp_char ('-'); /* Failed checksum */
|
put_rsp_char ('-'); /* Failed checksum */
|
}
|
}
|
else
|
else
|
{
|
{
|
put_rsp_char ('+'); /* successful transfer */
|
put_rsp_char ('+'); /* successful transfer */
|
break;
|
break;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (stderr, "Warning: RSP packet overran buffer\n");
|
fprintf (stderr, "Warning: RSP packet overran buffer\n");
|
}
|
}
|
}
|
}
|
|
|
return &buf; /* Success */
|
return &buf; /* Success */
|
|
|
} /* get_packet () */
|
} /* get_packet () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Put a single character out onto the client socket
|
/*!Put a single character out onto the client socket
|
|
|
This should only be called if the client is open, but we check for safety.
|
This should only be called if the client is open, but we check for safety.
|
|
|
@param[in] c The character to put out */
|
@param[in] c The character to put out */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
put_rsp_char (char c)
|
put_rsp_char (char c)
|
{
|
{
|
if (-1 == rsp.client_fd)
|
if (-1 == rsp.client_fd)
|
{
|
{
|
fprintf (stderr, "Warning: Attempt to write '%c' to unopened RSP "
|
fprintf (stderr, "Warning: Attempt to write '%c' to unopened RSP "
|
"client: Ignored\n", c);
|
"client: Ignored\n", c);
|
return;
|
return;
|
}
|
}
|
|
|
/* Write until successful (we retry after interrupts) or catastrophic
|
/* Write until successful (we retry after interrupts) or catastrophic
|
failure. */
|
failure. */
|
while (1)
|
while (1)
|
{
|
{
|
switch (write (rsp.client_fd, &c, sizeof (c)))
|
switch (write (rsp.client_fd, &c, sizeof (c)))
|
{
|
{
|
case -1:
|
case -1:
|
/* Error: only allow interrupts or would block */
|
/* Error: only allow interrupts or would block */
|
if ((EAGAIN != errno) && (EINTR != errno))
|
if ((EAGAIN != errno) && (EINTR != errno))
|
{
|
{
|
fprintf (stderr, "Warning: Failed to write to RSP client: "
|
fprintf (stderr, "Warning: Failed to write to RSP client: "
|
"Closing client connection: %s\n",
|
"Closing client connection: %s\n",
|
strerror (errno));
|
strerror (errno));
|
rsp_client_close ();
|
rsp_client_close ();
|
return;
|
return;
|
}
|
}
|
|
|
break;
|
break;
|
|
|
case 0:
|
case 0:
|
break; /* Nothing written! Try again */
|
break; /* Nothing written! Try again */
|
|
|
default:
|
default:
|
return; /* Success, we can return */
|
return; /* Success, we can return */
|
}
|
}
|
}
|
}
|
} /* put_rsp_char () */
|
} /* put_rsp_char () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Get a single character from the client socket
|
/*!Get a single character from the client socket
|
|
|
This should only be called if the client is open, but we check for safety.
|
This should only be called if the client is open, but we check for safety.
|
|
|
@return The character read, or -1 on failure */
|
@return The character read, or -1 on failure */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static int
|
static int
|
get_rsp_char ()
|
get_rsp_char ()
|
{
|
{
|
if (-1 == rsp.client_fd)
|
if (-1 == rsp.client_fd)
|
{
|
{
|
fprintf (stderr, "Warning: Attempt to read from unopened RSP "
|
fprintf (stderr, "Warning: Attempt to read from unopened RSP "
|
"client: Ignored\n");
|
"client: Ignored\n");
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* Non-blocking read until successful (we retry after interrupts) or
|
/* Non-blocking read until successful (we retry after interrupts) or
|
catastrophic failure. */
|
catastrophic failure. */
|
while (1)
|
while (1)
|
{
|
{
|
unsigned char c;
|
unsigned char c;
|
|
|
switch (read (rsp.client_fd, &c, sizeof (c)))
|
switch (read (rsp.client_fd, &c, sizeof (c)))
|
{
|
{
|
case -1:
|
case -1:
|
/* Error: only allow interrupts */
|
/* Error: only allow interrupts */
|
if ((EAGAIN != errno) && (EINTR != errno))
|
if ((EAGAIN != errno) && (EINTR != errno))
|
{
|
{
|
fprintf (stderr, "Warning: Failed to read from RSP client: "
|
fprintf (stderr, "Warning: Failed to read from RSP client: "
|
"Closing client connection: %s\n",
|
"Closing client connection: %s\n",
|
strerror (errno));
|
strerror (errno));
|
rsp_client_close ();
|
rsp_client_close ();
|
return -1;
|
return -1;
|
}
|
}
|
|
|
break;
|
break;
|
|
|
case 0:
|
case 0:
|
// EOF
|
// EOF
|
rsp_client_close ();
|
rsp_client_close ();
|
return -1;
|
return -1;
|
|
|
default:
|
default:
|
return c & 0xff; /* Success, we can return (no sign extend!) */
|
return c & 0xff; /* Success, we can return (no sign extend!) */
|
}
|
}
|
}
|
}
|
} /* get_rsp_char () */
|
} /* get_rsp_char () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!"Unescape" RSP binary data
|
/*!"Unescape" RSP binary data
|
|
|
'#', '$' and '}' are escaped by preceding them by '}' and oring with 0x20.
|
'#', '$' and '}' are escaped by preceding them by '}' and oring with 0x20.
|
|
|
This function reverses that, modifying the data in place.
|
This function reverses that, modifying the data in place.
|
|
|
@param[in] data The array of bytes to convert
|
@param[in] data The array of bytes to convert
|
@para[in] len The number of bytes to be converted
|
@para[in] len The number of bytes to be converted
|
|
|
@return The number of bytes AFTER conversion */
|
@return The number of bytes AFTER conversion */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static int
|
static int
|
rsp_unescape (char *data,
|
rsp_unescape (char *data,
|
int len)
|
int len)
|
{
|
{
|
int from_off = 0; /* Offset to source char */
|
int from_off = 0; /* Offset to source char */
|
int to_off = 0; /* Offset to dest char */
|
int to_off = 0; /* Offset to dest char */
|
|
|
while (from_off < len)
|
while (from_off < len)
|
{
|
{
|
/* Is it escaped */
|
/* Is it escaped */
|
if ( '}' == data[from_off])
|
if ( '}' == data[from_off])
|
{
|
{
|
from_off++;
|
from_off++;
|
data[to_off] = data[from_off] ^ 0x20;
|
data[to_off] = data[from_off] ^ 0x20;
|
}
|
}
|
else
|
else
|
{
|
{
|
data[to_off] = data[from_off];
|
data[to_off] = data[from_off];
|
}
|
}
|
|
|
from_off++;
|
from_off++;
|
to_off++;
|
to_off++;
|
}
|
}
|
|
|
return to_off;
|
return to_off;
|
|
|
} /* rsp_unescape () */
|
} /* rsp_unescape () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Initialize the matchpoint hash table
|
/*!Initialize the matchpoint hash table
|
|
|
This is an open hash table, so this function clears all the links to
|
This is an open hash table, so this function clears all the links to
|
NULL. */
|
NULL. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
mp_hash_init ()
|
mp_hash_init ()
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < MP_HASH_SIZE; i++)
|
for (i = 0; i < MP_HASH_SIZE; i++)
|
{
|
{
|
rsp.mp_hash[i] = NULL;
|
rsp.mp_hash[i] = NULL;
|
}
|
}
|
} /* mp_hash_init () */
|
} /* mp_hash_init () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Add an entry to the matchpoint hash table
|
/*!Add an entry to the matchpoint hash table
|
|
|
Add the entry if it wasn't already there. If it was there do nothing. The
|
Add the entry if it wasn't already there. If it was there do nothing. The
|
match just be on type and addr. The instr need not match, since if this is
|
match just be on type and addr. The instr need not match, since if this is
|
a duplicate insertion (perhaps due to a lost packet) they will be
|
a duplicate insertion (perhaps due to a lost packet) they will be
|
different.
|
different.
|
|
|
@param[in] type The type of matchpoint
|
@param[in] type The type of matchpoint
|
@param[in] addr The address of the matchpoint
|
@param[in] addr The address of the matchpoint
|
@para[in] instr The instruction to associate with the address */
|
@para[in] instr The instruction to associate with the address */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
mp_hash_add (enum mp_type type,
|
mp_hash_add (enum mp_type type,
|
unsigned long int addr,
|
unsigned long int addr,
|
unsigned long int instr)
|
unsigned long int instr)
|
{
|
{
|
int hv = addr % MP_HASH_SIZE;
|
int hv = addr % MP_HASH_SIZE;
|
struct mp_entry *curr;
|
struct mp_entry *curr;
|
|
|
/* See if we already have the entry */
|
/* See if we already have the entry */
|
for(curr = rsp.mp_hash[hv]; NULL != curr; curr = curr->next)
|
for(curr = rsp.mp_hash[hv]; NULL != curr; curr = curr->next)
|
{
|
{
|
if ((type == curr->type) && (addr == curr->addr))
|
if ((type == curr->type) && (addr == curr->addr))
|
{
|
{
|
return; /* We already have the entry */
|
return; /* We already have the entry */
|
}
|
}
|
}
|
}
|
|
|
/* Insert the new entry at the head of the chain */
|
/* Insert the new entry at the head of the chain */
|
curr = malloc (sizeof (*curr));
|
curr = malloc (sizeof (*curr));
|
|
|
curr->type = type;
|
curr->type = type;
|
curr->addr = addr;
|
curr->addr = addr;
|
curr->instr = instr;
|
curr->instr = instr;
|
curr->next = rsp.mp_hash[hv];
|
curr->next = rsp.mp_hash[hv];
|
|
|
rsp.mp_hash[hv] = curr;
|
rsp.mp_hash[hv] = curr;
|
|
|
} /* mp_hash_add () */
|
} /* mp_hash_add () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Look up an entry in the matchpoint hash table
|
/*!Look up an entry in the matchpoint hash table
|
|
|
The match must be on type AND addr.
|
The match must be on type AND addr.
|
|
|
@param[in] type The type of matchpoint
|
@param[in] type The type of matchpoint
|
@param[in] addr The address of the matchpoint
|
@param[in] addr The address of the matchpoint
|
|
|
@return The entry deleted, or NULL if the entry was not found */
|
@return The entry deleted, or NULL if the entry was not found */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static struct mp_entry *
|
static struct mp_entry *
|
mp_hash_lookup (enum mp_type type,
|
mp_hash_lookup (enum mp_type type,
|
unsigned long int addr)
|
unsigned long int addr)
|
{
|
{
|
int hv = addr % MP_HASH_SIZE;
|
int hv = addr % MP_HASH_SIZE;
|
struct mp_entry *curr;
|
struct mp_entry *curr;
|
|
|
/* Search */
|
/* Search */
|
for (curr = rsp.mp_hash[hv]; NULL != curr; curr = curr->next)
|
for (curr = rsp.mp_hash[hv]; NULL != curr; curr = curr->next)
|
{
|
{
|
if ((type == curr->type) && (addr == curr->addr))
|
if ((type == curr->type) && (addr == curr->addr))
|
{
|
{
|
return curr; /* The entry found */
|
return curr; /* The entry found */
|
}
|
}
|
}
|
}
|
|
|
/* Not found */
|
/* Not found */
|
return NULL;
|
return NULL;
|
|
|
} /* mp_hash_lookup () */
|
} /* mp_hash_lookup () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Delete an entry from the matchpoint hash table
|
/*!Delete an entry from the matchpoint hash table
|
|
|
If it is there the entry is deleted from the hash table. If it is not
|
If it is there the entry is deleted from the hash table. If it is not
|
there, no action is taken. The match must be on type AND addr.
|
there, no action is taken. The match must be on type AND addr.
|
|
|
The usual fun and games tracking the previous entry, so we can delete
|
The usual fun and games tracking the previous entry, so we can delete
|
things.
|
things.
|
|
|
@note The deletion DOES NOT free the memory associated with the entry,
|
@note The deletion DOES NOT free the memory associated with the entry,
|
since that is returned. The caller should free the memory when they
|
since that is returned. The caller should free the memory when they
|
have used the information.
|
have used the information.
|
|
|
@param[in] type The type of matchpoint
|
@param[in] type The type of matchpoint
|
@param[in] addr The address of the matchpoint
|
@param[in] addr The address of the matchpoint
|
|
|
@return The entry deleted, or NULL if the entry was not found */
|
@return The entry deleted, or NULL if the entry was not found */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static struct mp_entry *
|
static struct mp_entry *
|
mp_hash_delete (enum mp_type type,
|
mp_hash_delete (enum mp_type type,
|
unsigned long int addr)
|
unsigned long int addr)
|
{
|
{
|
int hv = addr % MP_HASH_SIZE;
|
int hv = addr % MP_HASH_SIZE;
|
struct mp_entry *prev = NULL;
|
struct mp_entry *prev = NULL;
|
struct mp_entry *curr;
|
struct mp_entry *curr;
|
|
|
/* Search */
|
/* Search */
|
for (curr = rsp.mp_hash[hv]; NULL != curr; curr = curr->next)
|
for (curr = rsp.mp_hash[hv]; NULL != curr; curr = curr->next)
|
{
|
{
|
if ((type == curr->type) && (addr == curr->addr))
|
if ((type == curr->type) && (addr == curr->addr))
|
{
|
{
|
/* Found - delete. Method depends on whether we are the head of
|
/* Found - delete. Method depends on whether we are the head of
|
chain. */
|
chain. */
|
if (NULL == prev)
|
if (NULL == prev)
|
{
|
{
|
rsp.mp_hash[hv] = curr->next;
|
rsp.mp_hash[hv] = curr->next;
|
}
|
}
|
else
|
else
|
{
|
{
|
prev->next = curr->next;
|
prev->next = curr->next;
|
}
|
}
|
|
|
return curr; /* The entry deleted */
|
return curr; /* The entry deleted */
|
}
|
}
|
|
|
prev = curr;
|
prev = curr;
|
}
|
}
|
|
|
/* Not found */
|
/* Not found */
|
return NULL;
|
return NULL;
|
|
|
} /* mp_hash_delete () */
|
} /* mp_hash_delete () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Utility to give the value of a hex char
|
/*!Utility to give the value of a hex char
|
|
|
@param[in] ch A character representing a hexadecimal digit. Done as -1,
|
@param[in] ch A character representing a hexadecimal digit. Done as -1,
|
for consistency with other character routines, which can use
|
for consistency with other character routines, which can use
|
-1 as EOF.
|
-1 as EOF.
|
|
|
@return The value of the hex character, or -1 if the character is
|
@return The value of the hex character, or -1 if the character is
|
invalid. */
|
invalid. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static int
|
static int
|
hex (int c)
|
hex (int c)
|
{
|
{
|
return ((c >= 'a') && (c <= 'f')) ? c - 'a' + 10 :
|
return ((c >= 'a') && (c <= 'f')) ? c - 'a' + 10 :
|
((c >= '0') && (c <= '9')) ? c - '0' :
|
((c >= '0') && (c <= '9')) ? c - '0' :
|
((c >= 'A') && (c <= 'F')) ? c - 'A' + 10 : -1;
|
((c >= 'A') && (c <= 'F')) ? c - 'A' + 10 : -1;
|
|
|
} /* hex () */
|
} /* hex () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Convert a register to a hex digit string
|
/*!Convert a register to a hex digit string
|
|
|
The supplied 32-bit value is converted to an 8 digit hex string according
|
The supplied 32-bit value is converted to an 8 digit hex string according
|
the target endianism. It is null terminated for convenient printing.
|
the target endianism. It is null terminated for convenient printing.
|
|
|
@param[in] val The value to convert
|
@param[in] val The value to convert
|
@param[out] buf The buffer for the text string */
|
@param[out] buf The buffer for the text string */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
reg2hex (unsigned long int val,
|
reg2hex (unsigned long int val,
|
char *buf)
|
char *buf)
|
{
|
{
|
int n; /* Counter for digits */
|
int n; /* Counter for digits */
|
|
|
for (n = 0; n < 8; n++)
|
for (n = 0; n < 8; n++)
|
{
|
{
|
#ifdef WORDSBIGENDIAN
|
#ifdef WORDSBIGENDIAN
|
int nyb_shift = n * 4;
|
int nyb_shift = n * 4;
|
#else
|
#else
|
int nyb_shift = 28 - (n * 4);
|
int nyb_shift = 28 - (n * 4);
|
#endif
|
#endif
|
buf[n] = hexchars[(val >> nyb_shift) & 0xf];
|
buf[n] = hexchars[(val >> nyb_shift) & 0xf];
|
}
|
}
|
|
|
buf[8] = 0; /* Useful to terminate as string */
|
buf[8] = 0; /* Useful to terminate as string */
|
|
|
} /* reg2hex () */
|
} /* reg2hex () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Convert a hex digit string to a register value
|
/*!Convert a hex digit string to a register value
|
|
|
The supplied 8 digit hex string is converted to a 32-bit value according
|
The supplied 8 digit hex string is converted to a 32-bit value according
|
the target endianism
|
the target endianism
|
|
|
@param[in] buf The buffer with the hex string
|
@param[in] buf The buffer with the hex string
|
|
|
@return The value to convert */
|
@return The value to convert */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static unsigned long int
|
static unsigned long int
|
hex2reg (char *buf)
|
hex2reg (char *buf)
|
{
|
{
|
int n; /* Counter for digits */
|
int n; /* Counter for digits */
|
unsigned long int val = 0; /* The result */
|
unsigned long int val = 0; /* The result */
|
|
|
for (n = 0; n < 8; n++)
|
for (n = 0; n < 8; n++)
|
{
|
{
|
#ifdef WORDSBIGENDIAN
|
#ifdef WORDSBIGENDIAN
|
int nyb_shift = n * 4;
|
int nyb_shift = n * 4;
|
#else
|
#else
|
int nyb_shift = 28 - (n * 4);
|
int nyb_shift = 28 - (n * 4);
|
#endif
|
#endif
|
val |= hex (buf[n]) << nyb_shift;
|
val |= hex (buf[n]) << nyb_shift;
|
}
|
}
|
|
|
return val;
|
return val;
|
|
|
} /* hex2reg () */
|
} /* hex2reg () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Convert an ASCII character string to pairs of hex digits
|
/*!Convert an ASCII character string to pairs of hex digits
|
|
|
Both source and destination are null terminated.
|
Both source and destination are null terminated.
|
|
|
@param[out] dest Buffer to store the hex digit pairs (null terminated)
|
@param[out] dest Buffer to store the hex digit pairs (null terminated)
|
@param[in] src The ASCII string (null terminated) */
|
@param[in] src The ASCII string (null terminated) */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void ascii2hex (char *dest,
|
static void ascii2hex (char *dest,
|
char *src)
|
char *src)
|
{
|
{
|
int i;
|
int i;
|
|
|
/* Step through converting the source string */
|
/* Step through converting the source string */
|
for (i = 0; src[i] != '\0'; i++)
|
for (i = 0; src[i] != '\0'; i++)
|
{
|
{
|
char ch = src[i];
|
char ch = src[i];
|
|
|
dest[i * 2] = hexchars[ch >> 4 & 0xf];
|
dest[i * 2] = hexchars[ch >> 4 & 0xf];
|
dest[i * 2 + 1] = hexchars[ch & 0xf];
|
dest[i * 2 + 1] = hexchars[ch & 0xf];
|
}
|
}
|
|
|
dest[i * 2] = '\0';
|
dest[i * 2] = '\0';
|
|
|
} /* ascii2hex () */
|
} /* ascii2hex () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Convert pairs of hex digits to an ASCII character string
|
/*!Convert pairs of hex digits to an ASCII character string
|
|
|
Both source and destination are null terminated.
|
Both source and destination are null terminated.
|
|
|
@param[out] dest The ASCII string (null terminated)
|
@param[out] dest The ASCII string (null terminated)
|
@param[in] src Buffer holding the hex digit pairs (null terminated) */
|
@param[in] src Buffer holding the hex digit pairs (null terminated) */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void hex2ascii (char *dest,
|
static void hex2ascii (char *dest,
|
char *src)
|
char *src)
|
{
|
{
|
int i;
|
int i;
|
|
|
/* Step through convering the source hex digit pairs */
|
/* Step through convering the source hex digit pairs */
|
for (i = 0; src[i * 2] != '\0' && src[i * 2 + 1] != '\0'; i++)
|
for (i = 0; src[i * 2] != '\0' && src[i * 2 + 1] != '\0'; i++)
|
{
|
{
|
dest[i] = ((hex (src[i * 2]) & 0xf) << 4) | (hex (src[i * 2 + 1]) & 0xf);
|
dest[i] = ((hex (src[i * 2]) & 0xf) << 4) | (hex (src[i * 2 + 1]) & 0xf);
|
}
|
}
|
|
|
dest[i] = '\0';
|
dest[i] = '\0';
|
|
|
} /* hex2ascii () */
|
} /* hex2ascii () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Set the program counter
|
/*!Set the program counter
|
|
|
This sets the value in the NPC SPR. Not completely trivial, since this is
|
This sets the value in the NPC SPR. Not completely trivial, since this is
|
actually cached in cpu_state.pc. Any reset of the NPC also involves
|
actually cached in cpu_state.pc. Any reset of the NPC also involves
|
clearing the delay state and setting the pcnext global.
|
clearing the delay state and setting the pcnext global.
|
|
|
Only actually do this if the requested address is different to the current
|
Only actually do this if the requested address is different to the current
|
NPC (avoids clearing the delay pipe).
|
NPC (avoids clearing the delay pipe).
|
|
|
@param[in] addr The address to use */
|
@param[in] addr The address to use */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
set_npc (unsigned long int addr)
|
set_npc (unsigned long int addr)
|
{
|
{
|
if (cpu_state.pc != addr)
|
if (cpu_state.pc != addr)
|
{
|
{
|
cpu_state.pc = addr;
|
cpu_state.pc = addr;
|
cpu_state.delay_insn = 0;
|
cpu_state.delay_insn = 0;
|
pcnext = addr + 4;
|
pcnext = addr + 4;
|
}
|
}
|
} /* set_npc () */
|
} /* set_npc () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Send a packet acknowledging an exception has occurred
|
/*!Send a packet acknowledging an exception has occurred
|
|
|
This is only called if there is a client FD to talk to */
|
This is only called if there is a client FD to talk to */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_report_exception ()
|
rsp_report_exception ()
|
{
|
{
|
struct rsp_buf buf;
|
struct rsp_buf buf;
|
|
|
/* Construct a signal received packet */
|
/* Construct a signal received packet */
|
buf.data[0] = 'S';
|
buf.data[0] = 'S';
|
buf.data[1] = hexchars[rsp.sigval >> 4];
|
buf.data[1] = hexchars[rsp.sigval >> 4];
|
buf.data[2] = hexchars[rsp.sigval % 16];
|
buf.data[2] = hexchars[rsp.sigval % 16];
|
buf.data[3] = 0;
|
buf.data[3] = 0;
|
buf.len = strlen (buf.data);
|
buf.len = strlen (buf.data);
|
|
|
put_packet (&buf);
|
put_packet (&buf);
|
|
|
} /* rsp_report_exception () */
|
} /* rsp_report_exception () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP continue request
|
/*!Handle a RSP continue request
|
|
|
Parse the command to see if there is an address. Uses the underlying
|
Parse the command to see if there is an address. Uses the underlying
|
generic continue function, with EXCEPT_NONE.
|
generic continue function, with EXCEPT_NONE.
|
|
|
@param[in] buf The full continue packet */
|
@param[in] buf The full continue packet */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_continue (struct rsp_buf *buf)
|
rsp_continue (struct rsp_buf *buf)
|
{
|
{
|
unsigned long int addr; /* Address to continue from, if any */
|
unsigned long int addr; /* Address to continue from, if any */
|
|
|
if (0 == strcmp ("c", buf->data))
|
if (0 == strcmp ("c", buf->data))
|
{
|
{
|
addr = cpu_state.pc; /* Default uses current NPC */
|
addr = cpu_state.pc; /* Default uses current NPC */
|
}
|
}
|
else if (1 != sscanf (buf->data, "c%lx", &addr))
|
else if (1 != sscanf (buf->data, "c%lx", &addr))
|
{
|
{
|
fprintf (stderr,
|
fprintf (stderr,
|
"Warning: RSP continue address %s not recognized: ignored\n",
|
"Warning: RSP continue address %s not recognized: ignored\n",
|
buf->data);
|
buf->data);
|
addr = cpu_state.pc; /* Default uses current NPC */
|
addr = cpu_state.pc; /* Default uses current NPC */
|
}
|
}
|
|
|
rsp_continue_generic (addr, EXCEPT_NONE);
|
rsp_continue_generic (addr, EXCEPT_NONE);
|
|
|
} /* rsp_continue () */
|
} /* rsp_continue () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP continue with signal request
|
/*!Handle a RSP continue with signal request
|
|
|
Currently null. Will use the underlying generic continue function.
|
Currently null. Will use the underlying generic continue function.
|
|
|
@param[in] buf The full continue with signal packet */
|
@param[in] buf The full continue with signal packet */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_continue_with_signal (struct rsp_buf *buf)
|
rsp_continue_with_signal (struct rsp_buf *buf)
|
{
|
{
|
printf ("RSP continue with signal '%s' received\n", buf->data);
|
printf ("RSP continue with signal '%s' received\n", buf->data);
|
|
|
} /* rsp_continue_with_signal () */
|
} /* rsp_continue_with_signal () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Generic processing of a continue request
|
/*!Generic processing of a continue request
|
|
|
The signal may be EXCEPT_NONE if there is no exception to be
|
The signal may be EXCEPT_NONE if there is no exception to be
|
handled. Currently the exception is ignored.
|
handled. Currently the exception is ignored.
|
|
|
The single step flag is cleared in the debug registers and then the
|
The single step flag is cleared in the debug registers and then the
|
processor is unstalled.
|
processor is unstalled.
|
|
|
@param[in] addr Address from which to step
|
@param[in] addr Address from which to step
|
@param[in] except The exception to use (if any) */
|
@param[in] except The exception to use (if any) */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_continue_generic (unsigned long int addr,
|
rsp_continue_generic (unsigned long int addr,
|
unsigned long int except)
|
unsigned long int except)
|
{
|
{
|
/* Set the address as the value of the next program counter */
|
/* Set the address as the value of the next program counter */
|
set_npc (addr);
|
set_npc (addr);
|
|
|
/* Clear Debug Reason Register and watchpoint break generation in Debug Mode
|
/* Clear Debug Reason Register and watchpoint break generation in Debug Mode
|
Register 2 */
|
Register 2 */
|
cpu_state.sprs[SPR_DRR] = 0;
|
cpu_state.sprs[SPR_DRR] = 0;
|
cpu_state.sprs[SPR_DMR2] &= ~SPR_DMR2_WGB;
|
cpu_state.sprs[SPR_DMR2] &= ~SPR_DMR2_WGB;
|
|
|
/* Clear the single step trigger in Debug Mode Register 1 and set traps to be
|
/* Clear the single step trigger in Debug Mode Register 1 and set traps to be
|
handled by the debug unit in the Debug Stop Register */
|
handled by the debug unit in the Debug Stop Register */
|
cpu_state.sprs[SPR_DMR1] &= ~SPR_DMR1_ST;
|
cpu_state.sprs[SPR_DMR1] &= ~SPR_DMR1_ST;
|
cpu_state.sprs[SPR_DSR] |= SPR_DSR_TE;
|
cpu_state.sprs[SPR_DSR] |= SPR_DSR_TE;
|
|
|
/* Unstall the processor */
|
/* Unstall the processor */
|
set_stall_state (0);
|
set_stall_state (0);
|
|
|
/* Any signal is cleared. */
|
/* Any signal is cleared. */
|
rsp.sigval = TARGET_SIGNAL_NONE;
|
rsp.sigval = TARGET_SIGNAL_NONE;
|
|
|
/* Note the GDB client is now waiting for a reply. */
|
/* Note the GDB client is now waiting for a reply. */
|
rsp.client_waiting = 1;
|
rsp.client_waiting = 1;
|
|
|
} /* rsp_continue_generic () */
|
} /* rsp_continue_generic () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP read all registers request
|
/*!Handle a RSP read all registers request
|
|
|
The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PPC
|
The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PPC
|
(i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is
|
(i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is
|
returned as a sequence of bytes in target endian order.
|
returned as a sequence of bytes in target endian order.
|
|
|
Each byte is packed as a pair of hex digits. */
|
Each byte is packed as a pair of hex digits. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_read_all_regs ()
|
rsp_read_all_regs ()
|
{
|
{
|
struct rsp_buf buf; /* Buffer for the reply */
|
struct rsp_buf buf; /* Buffer for the reply */
|
int r; /* Register index */
|
int r; /* Register index */
|
|
|
/* The GPRs */
|
/* The GPRs */
|
for (r = 0; r < MAX_GPRS; r++)
|
for (r = 0; r < MAX_GPRS; r++)
|
{
|
{
|
reg2hex (cpu_state.reg[r], &(buf.data[r * 8]));
|
reg2hex (cpu_state.reg[r], &(buf.data[r * 8]));
|
}
|
}
|
|
|
/* PPC, NPC and SR */
|
/* PPC, NPC and SR */
|
reg2hex (cpu_state.sprs[SPR_PPC], &(buf.data[PPC_REGNUM * 8]));
|
reg2hex (cpu_state.sprs[SPR_PPC], &(buf.data[PPC_REGNUM * 8]));
|
reg2hex (cpu_state.pc, &(buf.data[NPC_REGNUM * 8]));
|
reg2hex (cpu_state.pc, &(buf.data[NPC_REGNUM * 8]));
|
reg2hex (cpu_state.sprs[SPR_SR], &(buf.data[SR_REGNUM * 8]));
|
reg2hex (cpu_state.sprs[SPR_SR], &(buf.data[SR_REGNUM * 8]));
|
|
|
/* Finalize the packet and send it */
|
/* Finalize the packet and send it */
|
buf.data[NUM_REGS * 8] = 0;
|
buf.data[NUM_REGS * 8] = 0;
|
buf.len = NUM_REGS * 8;
|
buf.len = NUM_REGS * 8;
|
|
|
put_packet (&buf);
|
put_packet (&buf);
|
|
|
} /* rsp_read_all_regs () */
|
} /* rsp_read_all_regs () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP write all registers request
|
/*!Handle a RSP write all registers request
|
|
|
The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PPC
|
The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PPC
|
(i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is
|
(i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is
|
supplied as a sequence of bytes in target endian order.
|
supplied as a sequence of bytes in target endian order.
|
|
|
Each byte is packed as a pair of hex digits.
|
Each byte is packed as a pair of hex digits.
|
|
|
@todo There is no error checking at present. Non-hex chars will generate a
|
@todo There is no error checking at present. Non-hex chars will generate a
|
warning message, but there is no other check that the right amount
|
warning message, but there is no other check that the right amount
|
of data is present. The result is always "OK".
|
of data is present. The result is always "OK".
|
|
|
@param[in] buf The original packet request. */
|
@param[in] buf The original packet request. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_write_all_regs (struct rsp_buf *buf)
|
rsp_write_all_regs (struct rsp_buf *buf)
|
{
|
{
|
int r; /* Register index */
|
int r; /* Register index */
|
|
|
/* The GPRs */
|
/* The GPRs */
|
for (r = 0; r < MAX_GPRS; r++)
|
for (r = 0; r < MAX_GPRS; r++)
|
{
|
{
|
cpu_state.reg[r] = hex2reg (&(buf->data[r * 8]));
|
cpu_state.reg[r] = hex2reg (&(buf->data[r * 8]));
|
}
|
}
|
|
|
/* PPC, NPC and SR */
|
/* PPC, NPC and SR */
|
cpu_state.sprs[SPR_PPC] = hex2reg (&(buf->data[PPC_REGNUM * 8]));
|
cpu_state.sprs[SPR_PPC] = hex2reg (&(buf->data[PPC_REGNUM * 8]));
|
cpu_state.sprs[SPR_SR] = hex2reg (&(buf->data[SR_REGNUM * 8]));
|
cpu_state.sprs[SPR_SR] = hex2reg (&(buf->data[SR_REGNUM * 8]));
|
set_npc (hex2reg (&(buf->data[NPC_REGNUM * 8])));
|
set_npc (hex2reg (&(buf->data[NPC_REGNUM * 8])));
|
|
|
/* Acknowledge. TODO: We always succeed at present, even if the data was
|
/* Acknowledge. TODO: We always succeed at present, even if the data was
|
defective. */
|
defective. */
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
|
|
} /* rsp_write_all_regs () */
|
} /* rsp_write_all_regs () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP read memory (symbolic) request
|
/*!Handle a RSP read memory (symbolic) request
|
|
|
Syntax is:
|
Syntax is:
|
|
|
m<addr>,<length>:
|
m<addr>,<length>:
|
|
|
The response is the bytes, lowest address first, encoded as pairs of hex
|
The response is the bytes, lowest address first, encoded as pairs of hex
|
digits.
|
digits.
|
|
|
The length given is the number of bytes to be read.
|
The length given is the number of bytes to be read.
|
|
|
@note This function reuses buf, so trashes the original command.
|
@note This function reuses buf, so trashes the original command.
|
|
|
@param[in] buf The command received */
|
@param[in] buf The command received */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_read_mem (struct rsp_buf *buf)
|
rsp_read_mem (struct rsp_buf *buf)
|
{
|
{
|
unsigned int addr; /* Where to read the memory */
|
unsigned int addr; /* Where to read the memory */
|
int len; /* Number of bytes to read */
|
int len; /* Number of bytes to read */
|
int off; /* Offset into the memory */
|
int off; /* Offset into the memory */
|
|
|
if (2 != sscanf (buf->data, "m%x,%x:", &addr, &len))
|
if (2 != sscanf (buf->data, "m%x,%x:", &addr, &len))
|
{
|
{
|
fprintf (stderr, "Warning: Failed to recognize RSP read memory "
|
fprintf (stderr, "Warning: Failed to recognize RSP read memory "
|
"command: %s\n", buf->data);
|
"command: %s\n", buf->data);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Make sure we won't overflow the buffer (2 chars per byte) */
|
/* Make sure we won't overflow the buffer (2 chars per byte) */
|
if ((len * 2) >= GDB_BUF_MAX)
|
if ((len * 2) >= GDB_BUF_MAX)
|
{
|
{
|
fprintf (stderr, "Warning: Memory read %s too large for RSP packet: "
|
fprintf (stderr, "Warning: Memory read %s too large for RSP packet: "
|
"truncated\n", buf->data);
|
"truncated\n", buf->data);
|
len = (GDB_BUF_MAX - 1) / 2;
|
len = (GDB_BUF_MAX - 1) / 2;
|
}
|
}
|
|
|
/* Refill the buffer with the reply */
|
/* Refill the buffer with the reply */
|
for (off = 0; off < len; off++)
|
for (off = 0; off < len; off++)
|
{
|
{
|
unsigned char ch; /* The byte at the address */
|
unsigned char ch; /* The byte at the address */
|
|
|
/* Check memory area is valid */
|
/* Check memory area is valid */
|
if (NULL == verify_memoryarea (addr + off))
|
if (NULL == verify_memoryarea (addr + off))
|
{
|
{
|
/* The error number doesn't matter. The GDB client will substitute
|
/* The error number doesn't matter. The GDB client will substitute
|
its own */
|
its own */
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
// Get the memory direct - no translation.
|
// Get the memory direct - no translation.
|
ch = eval_direct8 (addr + off, 0, 0);
|
ch = eval_direct8 (addr + off, 0, 0);
|
|
|
buf->data[off * 2] = hexchars[ch >> 4];
|
buf->data[off * 2] = hexchars[ch >> 4];
|
buf->data[off * 2 + 1] = hexchars[ch & 0xf];
|
buf->data[off * 2 + 1] = hexchars[ch & 0xf];
|
}
|
}
|
|
|
buf->data[off * 2] = 0; /* End of string */
|
buf->data[off * 2] = 0; /* End of string */
|
buf->len = strlen (buf->data);
|
buf->len = strlen (buf->data);
|
put_packet (buf);
|
put_packet (buf);
|
|
|
} /* rsp_read_mem () */
|
} /* rsp_read_mem () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP write memory (symbolic) request
|
/*!Handle a RSP write memory (symbolic) request
|
|
|
Syntax is:
|
Syntax is:
|
|
|
m<addr>,<length>:<data>
|
m<addr>,<length>:<data>
|
|
|
The data is the bytes, lowest address first, encoded as pairs of hex
|
The data is the bytes, lowest address first, encoded as pairs of hex
|
digits.
|
digits.
|
|
|
The length given is the number of bytes to be written.
|
The length given is the number of bytes to be written.
|
|
|
@note This function reuses buf, so trashes the original command.
|
@note This function reuses buf, so trashes the original command.
|
|
|
@param[in] buf The command received */
|
@param[in] buf The command received */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_write_mem (struct rsp_buf *buf)
|
rsp_write_mem (struct rsp_buf *buf)
|
{
|
{
|
unsigned int addr; /* Where to write the memory */
|
unsigned int addr; /* Where to write the memory */
|
int len; /* Number of bytes to write */
|
int len; /* Number of bytes to write */
|
char *symdat; /* Pointer to the symboli data */
|
char *symdat; /* Pointer to the symboli data */
|
int datlen; /* Number of digits in symbolic data */
|
int datlen; /* Number of digits in symbolic data */
|
int off; /* Offset into the memory */
|
int off; /* Offset into the memory */
|
|
|
if (2 != sscanf (buf->data, "M%x,%x:", &addr, &len))
|
if (2 != sscanf (buf->data, "M%x,%x:", &addr, &len))
|
{
|
{
|
fprintf (stderr, "Warning: Failed to recognize RSP write memory "
|
fprintf (stderr, "Warning: Failed to recognize RSP write memory "
|
"command: %s\n", buf->data);
|
"command: %s\n", buf->data);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Find the start of the data and check there is the amount we expect. */
|
/* Find the start of the data and check there is the amount we expect. */
|
symdat = memchr ((const void *)buf->data, ':', GDB_BUF_MAX) + 1;
|
symdat = memchr ((const void *)buf->data, ':', GDB_BUF_MAX) + 1;
|
datlen = buf->len - (symdat - buf->data);
|
datlen = buf->len - (symdat - buf->data);
|
|
|
/* Sanity check */
|
/* Sanity check */
|
if (len * 2 != datlen)
|
if (len * 2 != datlen)
|
{
|
{
|
fprintf (stderr, "Warning: Write of %d digits requested, but %d digits "
|
fprintf (stderr, "Warning: Write of %d digits requested, but %d digits "
|
"supplied: packet ignored\n", len * 2, datlen );
|
"supplied: packet ignored\n", len * 2, datlen );
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Write the bytes to memory */
|
/* Write the bytes to memory */
|
for (off = 0; off < len; off++)
|
for (off = 0; off < len; off++)
|
{
|
{
|
if (NULL == verify_memoryarea (addr + off))
|
if (NULL == verify_memoryarea (addr + off))
|
{
|
{
|
/* The error number doesn't matter. The GDB client will substitute
|
/* The error number doesn't matter. The GDB client will substitute
|
its own */
|
its own */
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
else
|
else
|
{
|
{
|
unsigned char nyb1 = hex (symdat[off * 2]);
|
unsigned char nyb1 = hex (symdat[off * 2]);
|
unsigned char nyb2 = hex (symdat[off * 2 + 1]);
|
unsigned char nyb2 = hex (symdat[off * 2 + 1]);
|
|
|
// circumvent the read-only check usually done for mem accesses
|
// circumvent the read-only check usually done for mem accesses
|
// data is in host order, because that's what set_direct32 needs
|
// data is in host order, because that's what set_direct32 needs
|
set_program8 (addr + off, (nyb1 << 4) | nyb2);
|
set_program8 (addr + off, (nyb1 << 4) | nyb2);
|
}
|
}
|
}
|
}
|
|
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
|
|
} /* rsp_write_mem () */
|
} /* rsp_write_mem () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Read a single register
|
/*!Read a single register
|
|
|
The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PC
|
The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PC
|
(i.e. SPR NPC) and SR (i.e. SPR SR). The register is returned as a
|
(i.e. SPR NPC) and SR (i.e. SPR SR). The register is returned as a
|
sequence of bytes in target endian order.
|
sequence of bytes in target endian order.
|
|
|
Each byte is packed as a pair of hex digits.
|
Each byte is packed as a pair of hex digits.
|
|
|
@param[in] buf The original packet request. Reused for the reply. */
|
@param[in] buf The original packet request. Reused for the reply. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_read_reg (struct rsp_buf *buf)
|
rsp_read_reg (struct rsp_buf *buf)
|
{
|
{
|
unsigned int regnum;
|
unsigned int regnum;
|
|
|
/* Break out the fields from the data */
|
/* Break out the fields from the data */
|
if (1 != sscanf (buf->data, "p%x", ®num))
|
if (1 != sscanf (buf->data, "p%x", ®num))
|
{
|
{
|
fprintf (stderr, "Warning: Failed to recognize RSP read register "
|
fprintf (stderr, "Warning: Failed to recognize RSP read register "
|
"command: %s\n", buf->data);
|
"command: %s\n", buf->data);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Get the relevant register */
|
/* Get the relevant register */
|
if (regnum < MAX_GPRS)
|
if (regnum < MAX_GPRS)
|
{
|
{
|
reg2hex (cpu_state.reg[regnum], buf->data);
|
reg2hex (cpu_state.reg[regnum], buf->data);
|
}
|
}
|
else if (PPC_REGNUM == regnum)
|
else if (PPC_REGNUM == regnum)
|
{
|
{
|
reg2hex (cpu_state.sprs[SPR_PPC], buf->data);
|
reg2hex (cpu_state.sprs[SPR_PPC], buf->data);
|
}
|
}
|
else if (NPC_REGNUM == regnum)
|
else if (NPC_REGNUM == regnum)
|
{
|
{
|
reg2hex (cpu_state.pc, buf->data);
|
reg2hex (cpu_state.pc, buf->data);
|
}
|
}
|
else if (SR_REGNUM == regnum)
|
else if (SR_REGNUM == regnum)
|
{
|
{
|
reg2hex (cpu_state.sprs[SPR_SR], buf->data);
|
reg2hex (cpu_state.sprs[SPR_SR], buf->data);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Error response if we don't know the register */
|
/* Error response if we don't know the register */
|
fprintf (stderr, "Warning: Attempt to read unknown register 0x%x: "
|
fprintf (stderr, "Warning: Attempt to read unknown register 0x%x: "
|
"ignored\n", regnum);
|
"ignored\n", regnum);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
buf->len = strlen (buf->data);
|
buf->len = strlen (buf->data);
|
put_packet (buf);
|
put_packet (buf);
|
|
|
} /* rsp_write_reg () */
|
} /* rsp_write_reg () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Write a single register
|
/*!Write a single register
|
|
|
The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PC
|
The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PC
|
(i.e. SPR NPC) and SR (i.e. SPR SR). The register is specified as a
|
(i.e. SPR NPC) and SR (i.e. SPR SR). The register is specified as a
|
sequence of bytes in target endian order.
|
sequence of bytes in target endian order.
|
|
|
Each byte is packed as a pair of hex digits.
|
Each byte is packed as a pair of hex digits.
|
|
|
@param[in] buf The original packet request. */
|
@param[in] buf The original packet request. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_write_reg (struct rsp_buf *buf)
|
rsp_write_reg (struct rsp_buf *buf)
|
{
|
{
|
unsigned int regnum;
|
unsigned int regnum;
|
char valstr[9]; /* Allow for EOS on the string */
|
char valstr[9]; /* Allow for EOS on the string */
|
|
|
/* Break out the fields from the data */
|
/* Break out the fields from the data */
|
if (2 != sscanf (buf->data, "P%x=%8s", ®num, valstr))
|
if (2 != sscanf (buf->data, "P%x=%8s", ®num, valstr))
|
{
|
{
|
fprintf (stderr, "Warning: Failed to recognize RSP write register "
|
fprintf (stderr, "Warning: Failed to recognize RSP write register "
|
"command: %s\n", buf->data);
|
"command: %s\n", buf->data);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Set the relevant register */
|
/* Set the relevant register */
|
if (regnum < MAX_GPRS)
|
if (regnum < MAX_GPRS)
|
{
|
{
|
cpu_state.reg[regnum] = hex2reg (valstr);
|
cpu_state.reg[regnum] = hex2reg (valstr);
|
}
|
}
|
else if (PPC_REGNUM == regnum)
|
else if (PPC_REGNUM == regnum)
|
{
|
{
|
cpu_state.sprs[SPR_PPC] = hex2reg (valstr);
|
cpu_state.sprs[SPR_PPC] = hex2reg (valstr);
|
}
|
}
|
else if (NPC_REGNUM == regnum)
|
else if (NPC_REGNUM == regnum)
|
{
|
{
|
set_npc (hex2reg (valstr));
|
set_npc (hex2reg (valstr));
|
}
|
}
|
else if (SR_REGNUM == regnum)
|
else if (SR_REGNUM == regnum)
|
{
|
{
|
cpu_state.sprs[SPR_SR] = hex2reg (valstr);
|
cpu_state.sprs[SPR_SR] = hex2reg (valstr);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Error response if we don't know the register */
|
/* Error response if we don't know the register */
|
fprintf (stderr, "Warning: Attempt to write unknown register 0x%x: "
|
fprintf (stderr, "Warning: Attempt to write unknown register 0x%x: "
|
"ignored\n", regnum);
|
"ignored\n", regnum);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
|
|
} /* rsp_write_reg () */
|
} /* rsp_write_reg () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP query request
|
/*!Handle a RSP query request
|
|
|
@param[in] buf The request. Reused for any packets that need to be sent
|
@param[in] buf The request. Reused for any packets that need to be sent
|
back. */
|
back. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_query (struct rsp_buf *buf)
|
rsp_query (struct rsp_buf *buf)
|
{
|
{
|
if (0 == strcmp ("qC", buf->data))
|
if (0 == strcmp ("qC", buf->data))
|
{
|
{
|
/* Return the current thread ID (unsigned hex). A null response
|
/* Return the current thread ID (unsigned hex). A null response
|
indicates to use the previously selected thread. We use the constant
|
indicates to use the previously selected thread. We use the constant
|
OR1KSIM_TID to represent our single thread of control. */
|
OR1KSIM_TID to represent our single thread of control. */
|
sprintf (buf->data, "QC%x", OR1KSIM_TID);
|
sprintf (buf->data, "QC%x", OR1KSIM_TID);
|
buf->len = strlen (buf->data);
|
buf->len = strlen (buf->data);
|
put_packet (buf);
|
put_packet (buf);
|
}
|
}
|
else if (0 == strncmp ("qCRC", buf->data, strlen ("qCRC")))
|
else if (0 == strncmp ("qCRC", buf->data, strlen ("qCRC")))
|
{
|
{
|
/* Return CRC of memory area */
|
/* Return CRC of memory area */
|
fprintf (stderr, "Warning: RSP CRC query not supported\n");
|
fprintf (stderr, "Warning: RSP CRC query not supported\n");
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
}
|
}
|
else if (0 == strcmp ("qfThreadInfo", buf->data))
|
else if (0 == strcmp ("qfThreadInfo", buf->data))
|
{
|
{
|
/* Return info about active threads. We return just the constant
|
/* Return info about active threads. We return just the constant
|
OR1KSIM_TID to represent our single thread of control. */
|
OR1KSIM_TID to represent our single thread of control. */
|
sprintf (buf->data, "m%x", OR1KSIM_TID);
|
sprintf (buf->data, "m%x", OR1KSIM_TID);
|
buf->len = strlen (buf->data);
|
buf->len = strlen (buf->data);
|
put_packet (buf);
|
put_packet (buf);
|
}
|
}
|
else if (0 == strcmp ("qsThreadInfo", buf->data))
|
else if (0 == strcmp ("qsThreadInfo", buf->data))
|
{
|
{
|
/* Return info about more active threads. We have no more, so return the
|
/* Return info about more active threads. We have no more, so return the
|
end of list marker, 'l' */
|
end of list marker, 'l' */
|
put_str_packet ("l");
|
put_str_packet ("l");
|
}
|
}
|
else if (0 == strncmp ("qGetTLSAddr:", buf->data, strlen ("qGetTLSAddr:")))
|
else if (0 == strncmp ("qGetTLSAddr:", buf->data, strlen ("qGetTLSAddr:")))
|
{
|
{
|
/* We don't support this feature */
|
/* We don't support this feature */
|
put_str_packet ("");
|
put_str_packet ("");
|
}
|
}
|
else if (0 == strncmp ("qL", buf->data, strlen ("qL")))
|
else if (0 == strncmp ("qL", buf->data, strlen ("qL")))
|
{
|
{
|
/* Deprecated and replaced by 'qfThreadInfo' */
|
/* Deprecated and replaced by 'qfThreadInfo' */
|
fprintf (stderr, "Warning: RSP qL deprecated: no info returned\n");
|
fprintf (stderr, "Warning: RSP qL deprecated: no info returned\n");
|
put_str_packet ("qM001");
|
put_str_packet ("qM001");
|
}
|
}
|
else if (0 == strcmp ("qOffsets", buf->data))
|
else if (0 == strcmp ("qOffsets", buf->data))
|
{
|
{
|
/* Report any relocation */
|
/* Report any relocation */
|
put_str_packet ("Text=0;Data=0;Bss=0");
|
put_str_packet ("Text=0;Data=0;Bss=0");
|
}
|
}
|
else if (0 == strncmp ("qP", buf->data, strlen ("qP")))
|
else if (0 == strncmp ("qP", buf->data, strlen ("qP")))
|
{
|
{
|
/* Deprecated and replaced by 'qThreadExtraInfo' */
|
/* Deprecated and replaced by 'qThreadExtraInfo' */
|
fprintf (stderr, "Warning: RSP qP deprecated: no info returned\n");
|
fprintf (stderr, "Warning: RSP qP deprecated: no info returned\n");
|
put_str_packet ("");
|
put_str_packet ("");
|
}
|
}
|
else if (0 == strncmp ("qRcmd,", buf->data, strlen ("qRcmd,")))
|
else if (0 == strncmp ("qRcmd,", buf->data, strlen ("qRcmd,")))
|
{
|
{
|
/* This is used to interface to commands to do "stuff" */
|
/* This is used to interface to commands to do "stuff" */
|
rsp_command (buf);
|
rsp_command (buf);
|
}
|
}
|
else if (0 == strncmp ("qSupported", buf->data, strlen ("qSupported")))
|
else if (0 == strncmp ("qSupported", buf->data, strlen ("qSupported")))
|
{
|
{
|
/* Report a list of the features we support. For now we just ignore any
|
/* Report a list of the features we support. For now we just ignore any
|
supplied specific feature queries, but in the future these may be
|
supplied specific feature queries, but in the future these may be
|
supported as well. Note that the packet size allows for 'G' + all the
|
supported as well. Note that the packet size allows for 'G' + all the
|
registers sent to us, or a reply to 'g' with all the registers and an
|
registers sent to us, or a reply to 'g' with all the registers and an
|
EOS so the buffer is a well formed string. */
|
EOS so the buffer is a well formed string. */
|
|
|
char reply[GDB_BUF_MAX];
|
char reply[GDB_BUF_MAX];
|
|
|
sprintf (reply, "PacketSize=%x", GDB_BUF_MAX);
|
sprintf (reply, "PacketSize=%x", GDB_BUF_MAX);
|
put_str_packet (reply);
|
put_str_packet (reply);
|
}
|
}
|
else if (0 == strncmp ("qSymbol:", buf->data, strlen ("qSymbol:")))
|
else if (0 == strncmp ("qSymbol:", buf->data, strlen ("qSymbol:")))
|
{
|
{
|
/* Offer to look up symbols. Nothing we want (for now). TODO. This just
|
/* Offer to look up symbols. Nothing we want (for now). TODO. This just
|
ignores any replies to symbols we looked up, but we didn't want to
|
ignores any replies to symbols we looked up, but we didn't want to
|
do that anyway! */
|
do that anyway! */
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
}
|
}
|
else if (0 == strncmp ("qThreadExtraInfo,", buf->data,
|
else if (0 == strncmp ("qThreadExtraInfo,", buf->data,
|
strlen ("qThreadExtraInfo,")))
|
strlen ("qThreadExtraInfo,")))
|
{
|
{
|
/* Report that we are runnable, but the text must be hex ASCI
|
/* Report that we are runnable, but the text must be hex ASCI
|
digits. For now do this by steam, reusing the original packet */
|
digits. For now do this by steam, reusing the original packet */
|
sprintf (buf->data, "%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
sprintf (buf->data, "%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
'R', 'u', 'n', 'n', 'a', 'b', 'l', 'e', 0);
|
'R', 'u', 'n', 'n', 'a', 'b', 'l', 'e', 0);
|
buf->len = strlen (buf->data);
|
buf->len = strlen (buf->data);
|
put_packet (buf);
|
put_packet (buf);
|
}
|
}
|
else if (0 == strncmp ("qXfer:", buf->data, strlen ("qXfer:")))
|
else if (0 == strncmp ("qXfer:", buf->data, strlen ("qXfer:")))
|
{
|
{
|
/* For now we support no 'qXfer' requests, but these should not be
|
/* For now we support no 'qXfer' requests, but these should not be
|
expected, since they were not reported by 'qSupported' */
|
expected, since they were not reported by 'qSupported' */
|
fprintf (stderr, "Warning: RSP 'qXfer' not supported: ignored\n");
|
fprintf (stderr, "Warning: RSP 'qXfer' not supported: ignored\n");
|
put_str_packet ("");
|
put_str_packet ("");
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (stderr, "Unrecognized RSP query: ignored\n");
|
fprintf (stderr, "Unrecognized RSP query: ignored\n");
|
}
|
}
|
} /* rsp_query () */
|
} /* rsp_query () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP qRcmd request
|
/*!Handle a RSP qRcmd request
|
|
|
The actual command follows the "qRcmd," in ASCII encoded to hex
|
The actual command follows the "qRcmd," in ASCII encoded to hex
|
|
|
@param[in] buf The request in full */
|
@param[in] buf The request in full */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_command (struct rsp_buf *buf)
|
rsp_command (struct rsp_buf *buf)
|
{
|
{
|
char cmd[GDB_BUF_MAX];
|
char cmd[GDB_BUF_MAX];
|
|
|
hex2ascii (cmd, &(buf->data[strlen ("qRcmd,")]));
|
hex2ascii (cmd, &(buf->data[strlen ("qRcmd,")]));
|
|
|
/* Work out which command it is */
|
/* Work out which command it is */
|
if (0 == strncmp ("readspr ", cmd, strlen ("readspr")))
|
if (0 == strncmp ("readspr ", cmd, strlen ("readspr")))
|
{
|
{
|
unsigned int regno;
|
unsigned int regno;
|
|
|
/* Parse and return error if we fail */
|
/* Parse and return error if we fail */
|
if( 1 != sscanf (cmd, "readspr %4x", ®no))
|
if( 1 != sscanf (cmd, "readspr %4x", ®no))
|
{
|
{
|
fprintf (stderr, "Warning: qRcmd %s not recognized: ignored\n",
|
fprintf (stderr, "Warning: qRcmd %s not recognized: ignored\n",
|
cmd);
|
cmd);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* SPR out of range */
|
/* SPR out of range */
|
if (regno > MAX_SPRS)
|
if (regno > MAX_SPRS)
|
{
|
{
|
fprintf (stderr, "Warning: qRcmd readspr %x too large: ignored\n",
|
fprintf (stderr, "Warning: qRcmd readspr %x too large: ignored\n",
|
regno);
|
regno);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Construct the reply */
|
/* Construct the reply */
|
sprintf (cmd, "%8lx", (unsigned long int)mfspr (regno));
|
sprintf (cmd, "%8lx", (unsigned long int)mfspr (regno));
|
ascii2hex (buf->data, cmd);
|
ascii2hex (buf->data, cmd);
|
buf->len = strlen (buf->data);
|
buf->len = strlen (buf->data);
|
put_packet (buf);
|
put_packet (buf);
|
}
|
}
|
else if (0 == strncmp ("writespr ", cmd, strlen ("writespr")))
|
else if (0 == strncmp ("writespr ", cmd, strlen ("writespr")))
|
{
|
{
|
unsigned int regno;
|
unsigned int regno;
|
unsigned long int val;
|
unsigned long int val;
|
|
|
/* Parse and return error if we fail */
|
/* Parse and return error if we fail */
|
if( 2 != sscanf (cmd, "writespr %4x %8lx", ®no, &val))
|
if( 2 != sscanf (cmd, "writespr %4x %8lx", ®no, &val))
|
{
|
{
|
fprintf (stderr, "Warning: qRcmd %s not recognized: ignored\n",
|
fprintf (stderr, "Warning: qRcmd %s not recognized: ignored\n",
|
cmd);
|
cmd);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* SPR out of range */
|
/* SPR out of range */
|
if (regno > MAX_SPRS)
|
if (regno > MAX_SPRS)
|
{
|
{
|
fprintf (stderr, "Warning: qRcmd writespr %x too large: ignored\n",
|
fprintf (stderr, "Warning: qRcmd writespr %x too large: ignored\n",
|
regno);
|
regno);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Update the SPR and reply "OK" */
|
/* Update the SPR and reply "OK" */
|
mtspr (regno, val);
|
mtspr (regno, val);
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
}
|
}
|
|
|
} /* rsp_command () */
|
} /* rsp_command () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP set request
|
/*!Handle a RSP set request
|
|
|
@param[in] buf The request */
|
@param[in] buf The request */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_set (struct rsp_buf *buf)
|
rsp_set (struct rsp_buf *buf)
|
{
|
{
|
if (0 == strncmp ("QPassSignals:", buf->data, strlen ("QPassSignals:")))
|
if (0 == strncmp ("QPassSignals:", buf->data, strlen ("QPassSignals:")))
|
{
|
{
|
/* Passing signals not supported */
|
/* Passing signals not supported */
|
put_str_packet ("");
|
put_str_packet ("");
|
}
|
}
|
else if ((0 == strncmp ("QTDP", buf->data, strlen ("QTDP"))) ||
|
else if ((0 == strncmp ("QTDP", buf->data, strlen ("QTDP"))) ||
|
(0 == strncmp ("QFrame", buf->data, strlen ("QFrame"))) ||
|
(0 == strncmp ("QFrame", buf->data, strlen ("QFrame"))) ||
|
(0 == strcmp ("QTStart", buf->data)) ||
|
(0 == strcmp ("QTStart", buf->data)) ||
|
(0 == strcmp ("QTStop", buf->data)) ||
|
(0 == strcmp ("QTStop", buf->data)) ||
|
(0 == strcmp ("QTinit", buf->data)) ||
|
(0 == strcmp ("QTinit", buf->data)) ||
|
(0 == strncmp ("QTro", buf->data, strlen ("QTro"))))
|
(0 == strncmp ("QTro", buf->data, strlen ("QTro"))))
|
{
|
{
|
/* All tracepoint features are not supported. This reply is really only
|
/* All tracepoint features are not supported. This reply is really only
|
needed to 'QTDP', since with that the others should not be
|
needed to 'QTDP', since with that the others should not be
|
generated. */
|
generated. */
|
put_str_packet ("");
|
put_str_packet ("");
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (stderr, "Unrecognized RSP set request: ignored\n");
|
fprintf (stderr, "Unrecognized RSP set request: ignored\n");
|
}
|
}
|
} /* rsp_set () */
|
} /* rsp_set () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP restart request
|
/*!Handle a RSP restart request
|
|
|
For now we just put the program counter back to the one used with the last
|
For now we just put the program counter back to the one used with the last
|
vRun request. There is no point in unstalling the processor, since we'll
|
vRun request. There is no point in unstalling the processor, since we'll
|
never get control back. */
|
never get control back. */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_restart ()
|
rsp_restart ()
|
{
|
{
|
set_npc (rsp.start_addr);
|
set_npc (rsp.start_addr);
|
|
|
} /* rsp_restart () */
|
} /* rsp_restart () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP step request
|
/*!Handle a RSP step request
|
|
|
Parse the command to see if there is an address. Uses the underlying
|
Parse the command to see if there is an address. Uses the underlying
|
generic step function, with EXCEPT_NONE.
|
generic step function, with EXCEPT_NONE.
|
|
|
@param[in] buf The full step packet */
|
@param[in] buf The full step packet */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_step (struct rsp_buf *buf)
|
rsp_step (struct rsp_buf *buf)
|
{
|
{
|
unsigned long int addr; /* The address to step from, if any */
|
unsigned long int addr; /* The address to step from, if any */
|
|
|
if (0 == strcmp ("s", buf->data))
|
if (0 == strcmp ("s", buf->data))
|
{
|
{
|
addr = cpu_state.pc; /* Default uses current NPC */
|
addr = cpu_state.pc; /* Default uses current NPC */
|
}
|
}
|
else if (1 != sscanf (buf->data, "s%lx", &addr))
|
else if (1 != sscanf (buf->data, "s%lx", &addr))
|
{
|
{
|
fprintf (stderr,
|
fprintf (stderr,
|
"Warning: RSP step address %s not recognized: ignored\n",
|
"Warning: RSP step address %s not recognized: ignored\n",
|
buf->data);
|
buf->data);
|
addr = cpu_state.pc; /* Default uses current NPC */
|
addr = cpu_state.pc; /* Default uses current NPC */
|
}
|
}
|
|
|
rsp_step_generic (addr, EXCEPT_NONE);
|
rsp_step_generic (addr, EXCEPT_NONE);
|
|
|
} /* rsp_step () */
|
} /* rsp_step () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP step with signal request
|
/*!Handle a RSP step with signal request
|
|
|
Currently null. Will use the underlying generic step function.
|
Currently null. Will use the underlying generic step function.
|
|
|
@param[in] buf The full step with signal packet */
|
@param[in] buf The full step with signal packet */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_step_with_signal (struct rsp_buf *buf)
|
rsp_step_with_signal (struct rsp_buf *buf)
|
{
|
{
|
printf ("RSP step with signal '%s' received\n", buf->data);
|
printf ("RSP step with signal '%s' received\n", buf->data);
|
|
|
} /* rsp_step_with_signal () */
|
} /* rsp_step_with_signal () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Generic processing of a step request
|
/*!Generic processing of a step request
|
|
|
The signal may be EXCEPT_NONE if there is no exception to be
|
The signal may be EXCEPT_NONE if there is no exception to be
|
handled. Currently the exception is ignored.
|
handled. Currently the exception is ignored.
|
|
|
The single step flag is set in the debug registers and then the processor
|
The single step flag is set in the debug registers and then the processor
|
is unstalled.
|
is unstalled.
|
|
|
@param[in] addr Address from which to step
|
@param[in] addr Address from which to step
|
@param[in] except The exception to use (if any) */
|
@param[in] except The exception to use (if any) */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_step_generic (unsigned long int addr,
|
rsp_step_generic (unsigned long int addr,
|
unsigned long int except)
|
unsigned long int except)
|
{
|
{
|
/* Set the address as the value of the next program counter */
|
/* Set the address as the value of the next program counter */
|
set_npc (addr);
|
set_npc (addr);
|
|
|
/* Clear Debug Reason Register and watchpoint break generation in Debug Mode
|
/* Clear Debug Reason Register and watchpoint break generation in Debug Mode
|
Register 2 */
|
Register 2 */
|
cpu_state.sprs[SPR_DRR] = 0;
|
cpu_state.sprs[SPR_DRR] = 0;
|
cpu_state.sprs[SPR_DMR2] &= ~SPR_DMR2_WGB;
|
cpu_state.sprs[SPR_DMR2] &= ~SPR_DMR2_WGB;
|
|
|
/* Set the single step trigger in Debug Mode Register 1 and set traps to be
|
/* Set the single step trigger in Debug Mode Register 1 and set traps to be
|
handled by the debug unit in the Debug Stop Register */
|
handled by the debug unit in the Debug Stop Register */
|
cpu_state.sprs[SPR_DMR1] |= SPR_DMR1_ST;
|
cpu_state.sprs[SPR_DMR1] |= SPR_DMR1_ST;
|
cpu_state.sprs[SPR_DSR] |= SPR_DSR_TE;
|
cpu_state.sprs[SPR_DSR] |= SPR_DSR_TE;
|
|
|
/* Unstall the processor */
|
/* Unstall the processor */
|
set_stall_state (0);
|
set_stall_state (0);
|
|
|
/* Any signal is cleared. */
|
/* Any signal is cleared. */
|
rsp.sigval = TARGET_SIGNAL_NONE;
|
rsp.sigval = TARGET_SIGNAL_NONE;
|
|
|
/* Note the GDB client is now waiting for a reply. */
|
/* Note the GDB client is now waiting for a reply. */
|
rsp.client_waiting = 1;
|
rsp.client_waiting = 1;
|
|
|
} /* rsp_step_generic () */
|
} /* rsp_step_generic () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP 'v' packet
|
/*!Handle a RSP 'v' packet
|
|
|
These are commands associated with executing the code on the target
|
These are commands associated with executing the code on the target
|
|
|
@param[in] buf The request */
|
@param[in] buf The request */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_vpkt (struct rsp_buf *buf)
|
rsp_vpkt (struct rsp_buf *buf)
|
{
|
{
|
if (0 == strncmp ("vAttach;", buf->data, strlen ("vAttach;")))
|
if (0 == strncmp ("vAttach;", buf->data, strlen ("vAttach;")))
|
{
|
{
|
/* Attaching is a null action, since we have no other process. We just
|
/* Attaching is a null action, since we have no other process. We just
|
return a stop packet (using TRAP) to indicate we are stopped. */
|
return a stop packet (using TRAP) to indicate we are stopped. */
|
put_str_packet ("S05");
|
put_str_packet ("S05");
|
return;
|
return;
|
}
|
}
|
else if (0 == strcmp ("vCont?", buf->data))
|
else if (0 == strcmp ("vCont?", buf->data))
|
{
|
{
|
/* For now we don't support this. */
|
/* For now we don't support this. */
|
put_str_packet ("");
|
put_str_packet ("");
|
return;
|
return;
|
}
|
}
|
else if (0 == strncmp ("vCont", buf->data, strlen ("vCont")))
|
else if (0 == strncmp ("vCont", buf->data, strlen ("vCont")))
|
{
|
{
|
/* This shouldn't happen, because we've reported non-support via vCont?
|
/* This shouldn't happen, because we've reported non-support via vCont?
|
above */
|
above */
|
fprintf (stderr, "Warning: RSP vCont not supported: ignored\n" );
|
fprintf (stderr, "Warning: RSP vCont not supported: ignored\n" );
|
return;
|
return;
|
}
|
}
|
else if (0 == strncmp ("vFile:", buf->data, strlen ("vFile:")))
|
else if (0 == strncmp ("vFile:", buf->data, strlen ("vFile:")))
|
{
|
{
|
/* For now we don't support this. */
|
/* For now we don't support this. */
|
fprintf (stderr, "Warning: RSP vFile not supported: ignored\n" );
|
fprintf (stderr, "Warning: RSP vFile not supported: ignored\n" );
|
put_str_packet ("");
|
put_str_packet ("");
|
return;
|
return;
|
}
|
}
|
else if (0 == strncmp ("vFlashErase:", buf->data, strlen ("vFlashErase:")))
|
else if (0 == strncmp ("vFlashErase:", buf->data, strlen ("vFlashErase:")))
|
{
|
{
|
/* For now we don't support this. */
|
/* For now we don't support this. */
|
fprintf (stderr, "Warning: RSP vFlashErase not supported: ignored\n" );
|
fprintf (stderr, "Warning: RSP vFlashErase not supported: ignored\n" );
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
else if (0 == strncmp ("vFlashWrite:", buf->data, strlen ("vFlashWrite:")))
|
else if (0 == strncmp ("vFlashWrite:", buf->data, strlen ("vFlashWrite:")))
|
{
|
{
|
/* For now we don't support this. */
|
/* For now we don't support this. */
|
fprintf (stderr, "Warning: RSP vFlashWrite not supported: ignored\n" );
|
fprintf (stderr, "Warning: RSP vFlashWrite not supported: ignored\n" );
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
else if (0 == strcmp ("vFlashDone", buf->data))
|
else if (0 == strcmp ("vFlashDone", buf->data))
|
{
|
{
|
/* For now we don't support this. */
|
/* For now we don't support this. */
|
fprintf (stderr, "Warning: RSP vFlashDone not supported: ignored\n" );
|
fprintf (stderr, "Warning: RSP vFlashDone not supported: ignored\n" );
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
else if (0 == strncmp ("vRun;", buf->data, strlen ("vRun;")))
|
else if (0 == strncmp ("vRun;", buf->data, strlen ("vRun;")))
|
{
|
{
|
/* We shouldn't be given any args, but check for this */
|
/* We shouldn't be given any args, but check for this */
|
if (buf->len > strlen ("vRun;"))
|
if (buf->len > strlen ("vRun;"))
|
{
|
{
|
fprintf (stderr, "Warning: Unexpected arguments to RSP vRun "
|
fprintf (stderr, "Warning: Unexpected arguments to RSP vRun "
|
"command: ignored\n");
|
"command: ignored\n");
|
}
|
}
|
|
|
/* Restart the current program. However unlike a "R" packet, "vRun"
|
/* Restart the current program. However unlike a "R" packet, "vRun"
|
should behave as though it has just stopped. We use signal
|
should behave as though it has just stopped. We use signal
|
5 (TRAP). */
|
5 (TRAP). */
|
rsp_restart ();
|
rsp_restart ();
|
put_str_packet ("S05");
|
put_str_packet ("S05");
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (stderr, "Warning: Unknown RSP 'v' packet type %s: ignored\n",
|
fprintf (stderr, "Warning: Unknown RSP 'v' packet type %s: ignored\n",
|
buf->data);
|
buf->data);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
} /* rsp_vpkt () */
|
} /* rsp_vpkt () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP write memory (binary) request
|
/*!Handle a RSP write memory (binary) request
|
|
|
Syntax is:
|
Syntax is:
|
|
|
X<addr>,<length>:
|
X<addr>,<length>:
|
|
|
Followed by the specified number of bytes as raw binary. Response should be
|
Followed by the specified number of bytes as raw binary. Response should be
|
"OK" if all copied OK, E<nn> if error <nn> has occurred.
|
"OK" if all copied OK, E<nn> if error <nn> has occurred.
|
|
|
The length given is the number of bytes to be written. However the number
|
The length given is the number of bytes to be written. However the number
|
of data bytes may be greater, since '#', '$' and '}' are escaped by
|
of data bytes may be greater, since '#', '$' and '}' are escaped by
|
preceding them by '}' and oring with 0x20.
|
preceding them by '}' and oring with 0x20.
|
|
|
@param[in] buf The command received */
|
@param[in] buf The command received */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_write_mem_bin (struct rsp_buf *buf)
|
rsp_write_mem_bin (struct rsp_buf *buf)
|
{
|
{
|
unsigned int addr; /* Where to write the memory */
|
unsigned int addr; /* Where to write the memory */
|
int len; /* Number of bytes to write */
|
int len; /* Number of bytes to write */
|
char *bindat; /* Pointer to the binary data */
|
char *bindat; /* Pointer to the binary data */
|
int off; /* Offset to start of binary data */
|
int off; /* Offset to start of binary data */
|
int newlen; /* Number of bytes in bin data */
|
int newlen; /* Number of bytes in bin data */
|
|
|
if (2 != sscanf (buf->data, "X%x,%x:", &addr, &len))
|
if (2 != sscanf (buf->data, "X%x,%x:", &addr, &len))
|
{
|
{
|
fprintf (stderr, "Warning: Failed to recognize RSP write memory "
|
fprintf (stderr, "Warning: Failed to recognize RSP write memory "
|
"command: %s\n", buf->data);
|
"command: %s\n", buf->data);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Find the start of the data and "unescape" it */
|
/* Find the start of the data and "unescape" it */
|
bindat = memchr ((const void *)buf->data, ':', GDB_BUF_MAX) + 1;
|
bindat = memchr ((const void *)buf->data, ':', GDB_BUF_MAX) + 1;
|
off = bindat - buf->data;
|
off = bindat - buf->data;
|
newlen = rsp_unescape (bindat, buf->len - off);
|
newlen = rsp_unescape (bindat, buf->len - off);
|
|
|
/* Sanity check */
|
/* Sanity check */
|
if (newlen != len)
|
if (newlen != len)
|
{
|
{
|
int minlen = len < newlen ? len : newlen;
|
int minlen = len < newlen ? len : newlen;
|
|
|
fprintf (stderr, "Warning: Write of %d bytes requested, but %d bytes "
|
fprintf (stderr, "Warning: Write of %d bytes requested, but %d bytes "
|
"supplied. %d will be written\n", len, newlen, minlen);
|
"supplied. %d will be written\n", len, newlen, minlen);
|
len = minlen;
|
len = minlen;
|
}
|
}
|
|
|
/* Write the bytes to memory */
|
/* Write the bytes to memory */
|
for (off = 0; off < len; off++)
|
for (off = 0; off < len; off++)
|
{
|
{
|
if (NULL == verify_memoryarea (addr + off))
|
if (NULL == verify_memoryarea (addr + off))
|
{
|
{
|
/* The error number doesn't matter. The GDB client will substitute
|
/* The error number doesn't matter. The GDB client will substitute
|
its own */
|
its own */
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
else
|
else
|
{
|
{
|
// Circumvent the read-only check usually done for mem accesses
|
// Circumvent the read-only check usually done for mem accesses
|
set_program8 (addr + off, bindat[off]);
|
set_program8 (addr + off, bindat[off]);
|
}
|
}
|
}
|
}
|
|
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
|
|
} /* rsp_write_mem_bin () */
|
} /* rsp_write_mem_bin () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP remove breakpoint or matchpoint request
|
/*!Handle a RSP remove breakpoint or matchpoint request
|
|
|
For now only memory breakpoints are implemented, which are implemented by
|
For now only memory breakpoints are implemented, which are implemented by
|
substituting a breakpoint at the specified address. The implementation must
|
substituting a breakpoint at the specified address. The implementation must
|
cope with the possibility of duplicate packets.
|
cope with the possibility of duplicate packets.
|
|
|
@todo This doesn't work with icache/immu yet
|
@todo This doesn't work with icache/immu yet
|
|
|
@param[in] buf The command received */
|
@param[in] buf The command received */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_remove_matchpoint (struct rsp_buf *buf)
|
rsp_remove_matchpoint (struct rsp_buf *buf)
|
{
|
{
|
enum mp_type type; /* What sort of matchpoint */
|
enum mp_type type; /* What sort of matchpoint */
|
unsigned long int addr; /* Address specified */
|
unsigned long int addr; /* Address specified */
|
int len; /* Matchpoint length (not used) */
|
int len; /* Matchpoint length (not used) */
|
struct mp_entry *mpe; /* Info about the replaced instr */
|
struct mp_entry *mpe; /* Info about the replaced instr */
|
|
|
/* Break out the instruction */
|
/* Break out the instruction */
|
if (3 != sscanf (buf->data, "z%1d,%lx,%1d", (int *)&type, &addr, &len))
|
if (3 != sscanf (buf->data, "z%1d,%lx,%1d", (int *)&type, &addr, &len))
|
{
|
{
|
fprintf (stderr, "Warning: RSP matchpoint deletion request not "
|
fprintf (stderr, "Warning: RSP matchpoint deletion request not "
|
"recognized: ignored\n");
|
"recognized: ignored\n");
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Sanity check that the length is 4 */
|
/* Sanity check that the length is 4 */
|
if (4 != len)
|
if (4 != len)
|
{
|
{
|
fprintf (stderr, "Warning: RSP matchpoint deletion length %d not "
|
fprintf (stderr, "Warning: RSP matchpoint deletion length %d not "
|
"valid: 4 assumed\n", len);
|
"valid: 4 assumed\n", len);
|
len = 4;
|
len = 4;
|
}
|
}
|
|
|
/* Sort out the type of matchpoint */
|
/* Sort out the type of matchpoint */
|
switch (type)
|
switch (type)
|
{
|
{
|
case BP_MEMORY:
|
case BP_MEMORY:
|
/* Memory breakpoint - replace the original instruction. */
|
/* Memory breakpoint - replace the original instruction. */
|
mpe = mp_hash_delete (type, addr);
|
mpe = mp_hash_delete (type, addr);
|
|
|
/* If the BP hasn't yet been deleted, put the original instruction
|
/* If the BP hasn't yet been deleted, put the original instruction
|
back. Don't forget to free the hash table entry afterwards. */
|
back. Don't forget to free the hash table entry afterwards. */
|
if (NULL != mpe)
|
if (NULL != mpe)
|
{
|
{
|
set_program32 (addr, mpe->instr);
|
set_program32 (addr, mpe->instr);
|
free (mpe);
|
free (mpe);
|
}
|
}
|
|
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
|
|
return;
|
return;
|
|
|
case BP_HARDWARE:
|
case BP_HARDWARE:
|
put_str_packet (""); /* Not supported */
|
put_str_packet (""); /* Not supported */
|
return;
|
return;
|
|
|
case WP_WRITE:
|
case WP_WRITE:
|
put_str_packet (""); /* Not supported */
|
put_str_packet (""); /* Not supported */
|
return;
|
return;
|
|
|
case WP_READ:
|
case WP_READ:
|
put_str_packet (""); /* Not supported */
|
put_str_packet (""); /* Not supported */
|
return;
|
return;
|
|
|
case WP_ACCESS:
|
case WP_ACCESS:
|
put_str_packet (""); /* Not supported */
|
put_str_packet (""); /* Not supported */
|
return;
|
return;
|
|
|
default:
|
default:
|
fprintf (stderr, "Warning: RSP matchpoint type %d not "
|
fprintf (stderr, "Warning: RSP matchpoint type %d not "
|
"recognized: ignored\n", type);
|
"recognized: ignored\n", type);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
|
|
}
|
}
|
} /* rsp_remove_matchpoint () */
|
} /* rsp_remove_matchpoint () */
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*!Handle a RSP insert breakpoint or matchpoint request
|
/*!Handle a RSP insert breakpoint or matchpoint request
|
|
|
For now only memory breakpoints are implemented, which are implemented by
|
For now only memory breakpoints are implemented, which are implemented by
|
substituting a breakpoint at the specified address. The implementation must
|
substituting a breakpoint at the specified address. The implementation must
|
cope with the possibility of duplicate packets.
|
cope with the possibility of duplicate packets.
|
|
|
@todo This doesn't work with icache/immu yet
|
@todo This doesn't work with icache/immu yet
|
|
|
@param[in] buf The command received */
|
@param[in] buf The command received */
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void
|
static void
|
rsp_insert_matchpoint (struct rsp_buf *buf)
|
rsp_insert_matchpoint (struct rsp_buf *buf)
|
{
|
{
|
enum mp_type type; /* What sort of matchpoint */
|
enum mp_type type; /* What sort of matchpoint */
|
unsigned long int addr; /* Address specified */
|
unsigned long int addr; /* Address specified */
|
int len; /* Matchpoint length (not used) */
|
int len; /* Matchpoint length (not used) */
|
|
|
/* Break out the instruction */
|
/* Break out the instruction */
|
if (3 != sscanf (buf->data, "Z%1d,%lx,%1d", (int *)&type, &addr, &len))
|
if (3 != sscanf (buf->data, "Z%1d,%lx,%1d", (int *)&type, &addr, &len))
|
{
|
{
|
fprintf (stderr, "Warning: RSP matchpoint insertion request not "
|
fprintf (stderr, "Warning: RSP matchpoint insertion request not "
|
"recognized: ignored\n");
|
"recognized: ignored\n");
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
}
|
}
|
|
|
/* Sanity check that the length is 4 */
|
/* Sanity check that the length is 4 */
|
if (4 != len)
|
if (4 != len)
|
{
|
{
|
fprintf (stderr, "Warning: RSP matchpoint insertion length %d not "
|
fprintf (stderr, "Warning: RSP matchpoint insertion length %d not "
|
"valid: 4 assumed\n", len);
|
"valid: 4 assumed\n", len);
|
len = 4;
|
len = 4;
|
}
|
}
|
|
|
/* Sort out the type of matchpoint */
|
/* Sort out the type of matchpoint */
|
switch (type)
|
switch (type)
|
{
|
{
|
case BP_MEMORY:
|
case BP_MEMORY:
|
/* Memory breakpoint - substitute a TRAP instruction */
|
/* Memory breakpoint - substitute a TRAP instruction */
|
mp_hash_add (type, addr, eval_direct32 (addr, 0, 0));
|
mp_hash_add (type, addr, eval_direct32 (addr, 0, 0));
|
set_program32 (addr, OR1K_TRAP_INSTR);
|
set_program32 (addr, OR1K_TRAP_INSTR);
|
put_str_packet ("OK");
|
put_str_packet ("OK");
|
|
|
return;
|
return;
|
|
|
case BP_HARDWARE:
|
case BP_HARDWARE:
|
put_str_packet (""); /* Not supported */
|
put_str_packet (""); /* Not supported */
|
return;
|
return;
|
|
|
case WP_WRITE:
|
case WP_WRITE:
|
put_str_packet (""); /* Not supported */
|
put_str_packet (""); /* Not supported */
|
return;
|
return;
|
|
|
case WP_READ:
|
case WP_READ:
|
put_str_packet (""); /* Not supported */
|
put_str_packet (""); /* Not supported */
|
return;
|
return;
|
|
|
case WP_ACCESS:
|
case WP_ACCESS:
|
put_str_packet (""); /* Not supported */
|
put_str_packet (""); /* Not supported */
|
return;
|
return;
|
|
|
default:
|
default:
|
fprintf (stderr, "Warning: RSP matchpoint type %d not "
|
fprintf (stderr, "Warning: RSP matchpoint type %d not "
|
"recognized: ignored\n", type);
|
"recognized: ignored\n", type);
|
put_str_packet ("E01");
|
put_str_packet ("E01");
|
return;
|
return;
|
|
|
}
|
}
|
|
|
} /* rsp_insert_matchpoint () */
|
} /* rsp_insert_matchpoint () */
|
|
|
|
|
