/* Remote debugging interface for MIPS remote debugging protocol.
|
/* Remote debugging interface for MIPS remote debugging protocol.
|
Copyright 1993-1995, 2000 Free Software Foundation, Inc.
|
Copyright 1993-1995, 2000 Free Software Foundation, Inc.
|
Contributed by Cygnus Support. Written by Ian Lance Taylor
|
Contributed by Cygnus Support. Written by Ian Lance Taylor
|
<ian@cygnus.com>.
|
<ian@cygnus.com>.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 2 of the License, or
|
the Free Software Foundation; either version 2 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Boston, MA 02111-1307, USA. */
|
Boston, MA 02111-1307, USA. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "symfile.h"
|
#include "symfile.h"
|
#include "gdb_wait.h"
|
#include "gdb_wait.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "serial.h"
|
#include "serial.h"
|
#include "target.h"
|
#include "target.h"
|
#include "remote-utils.h"
|
#include "remote-utils.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
|
|
#include <signal.h>
|
#include <signal.h>
|
#include <sys/types.h>
|
#include <sys/types.h>
|
#include <sys/stat.h>
|
#include <sys/stat.h>
|
|
|
/* Microsoft C's stat.h doesn't define all the POSIX file modes. */
|
/* Microsoft C's stat.h doesn't define all the POSIX file modes. */
|
#ifndef S_IROTH
|
#ifndef S_IROTH
|
#define S_IROTH S_IREAD
|
#define S_IROTH S_IREAD
|
#endif
|
#endif
|
|
|
|
|
|
|
/* Breakpoint types. Values 0, 1, and 2 must agree with the watch
|
/* Breakpoint types. Values 0, 1, and 2 must agree with the watch
|
types passed by breakpoint.c to target_insert_watchpoint.
|
types passed by breakpoint.c to target_insert_watchpoint.
|
Value 3 is our own invention, and is used for ordinary instruction
|
Value 3 is our own invention, and is used for ordinary instruction
|
breakpoints. Value 4 is used to mark an unused watchpoint in tables. */
|
breakpoints. Value 4 is used to mark an unused watchpoint in tables. */
|
enum break_type
|
enum break_type
|
{
|
{
|
BREAK_WRITE, /* 0 */
|
BREAK_WRITE, /* 0 */
|
BREAK_READ, /* 1 */
|
BREAK_READ, /* 1 */
|
BREAK_ACCESS, /* 2 */
|
BREAK_ACCESS, /* 2 */
|
BREAK_FETCH, /* 3 */
|
BREAK_FETCH, /* 3 */
|
BREAK_UNUSED /* 4 */
|
BREAK_UNUSED /* 4 */
|
};
|
};
|
|
|
/* Prototypes for local functions. */
|
/* Prototypes for local functions. */
|
|
|
static int mips_readchar PARAMS ((int timeout));
|
static int mips_readchar PARAMS ((int timeout));
|
|
|
static int mips_receive_header PARAMS ((unsigned char *hdr, int *pgarbage,
|
static int mips_receive_header PARAMS ((unsigned char *hdr, int *pgarbage,
|
int ch, int timeout));
|
int ch, int timeout));
|
|
|
static int mips_receive_trailer PARAMS ((unsigned char *trlr, int *pgarbage,
|
static int mips_receive_trailer PARAMS ((unsigned char *trlr, int *pgarbage,
|
int *pch, int timeout));
|
int *pch, int timeout));
|
|
|
static int mips_cksum PARAMS ((const unsigned char *hdr,
|
static int mips_cksum PARAMS ((const unsigned char *hdr,
|
const unsigned char *data,
|
const unsigned char *data,
|
int len));
|
int len));
|
|
|
static void mips_send_packet PARAMS ((const char *s, int get_ack));
|
static void mips_send_packet PARAMS ((const char *s, int get_ack));
|
|
|
static void mips_send_command PARAMS ((const char *cmd, int prompt));
|
static void mips_send_command PARAMS ((const char *cmd, int prompt));
|
|
|
static int mips_receive_packet PARAMS ((char *buff, int throw_error,
|
static int mips_receive_packet PARAMS ((char *buff, int throw_error,
|
int timeout));
|
int timeout));
|
|
|
static CORE_ADDR mips_request PARAMS ((int cmd, CORE_ADDR addr,
|
static CORE_ADDR mips_request PARAMS ((int cmd, CORE_ADDR addr,
|
CORE_ADDR data, int *perr, int timeout,
|
CORE_ADDR data, int *perr, int timeout,
|
char *buff));
|
char *buff));
|
|
|
static void mips_initialize PARAMS ((void));
|
static void mips_initialize PARAMS ((void));
|
|
|
static void mips_open PARAMS ((char *name, int from_tty));
|
static void mips_open PARAMS ((char *name, int from_tty));
|
|
|
static void pmon_open PARAMS ((char *name, int from_tty));
|
static void pmon_open PARAMS ((char *name, int from_tty));
|
|
|
static void ddb_open PARAMS ((char *name, int from_tty));
|
static void ddb_open PARAMS ((char *name, int from_tty));
|
|
|
static void lsi_open PARAMS ((char *name, int from_tty));
|
static void lsi_open PARAMS ((char *name, int from_tty));
|
|
|
static void mips_close PARAMS ((int quitting));
|
static void mips_close PARAMS ((int quitting));
|
|
|
static void mips_detach PARAMS ((char *args, int from_tty));
|
static void mips_detach PARAMS ((char *args, int from_tty));
|
|
|
static void mips_resume PARAMS ((int pid, int step,
|
static void mips_resume PARAMS ((int pid, int step,
|
enum target_signal siggnal));
|
enum target_signal siggnal));
|
|
|
static int mips_wait PARAMS ((int pid, struct target_waitstatus * status));
|
static int mips_wait PARAMS ((int pid, struct target_waitstatus * status));
|
|
|
static int mips_map_regno PARAMS ((int regno));
|
static int mips_map_regno PARAMS ((int regno));
|
|
|
static void mips_fetch_registers PARAMS ((int regno));
|
static void mips_fetch_registers PARAMS ((int regno));
|
|
|
static void mips_prepare_to_store PARAMS ((void));
|
static void mips_prepare_to_store PARAMS ((void));
|
|
|
static void mips_store_registers PARAMS ((int regno));
|
static void mips_store_registers PARAMS ((int regno));
|
|
|
static unsigned int mips_fetch_word PARAMS ((CORE_ADDR addr));
|
static unsigned int mips_fetch_word PARAMS ((CORE_ADDR addr));
|
|
|
static int mips_store_word PARAMS ((CORE_ADDR addr, unsigned int value,
|
static int mips_store_word PARAMS ((CORE_ADDR addr, unsigned int value,
|
char *old_contents));
|
char *old_contents));
|
|
|
static int mips_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
|
static int mips_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
|
int write, struct target_ops * ignore));
|
int write, struct target_ops * ignore));
|
|
|
static void mips_files_info PARAMS ((struct target_ops * ignore));
|
static void mips_files_info PARAMS ((struct target_ops * ignore));
|
|
|
static void mips_create_inferior PARAMS ((char *execfile, char *args,
|
static void mips_create_inferior PARAMS ((char *execfile, char *args,
|
char **env));
|
char **env));
|
|
|
static void mips_mourn_inferior PARAMS ((void));
|
static void mips_mourn_inferior PARAMS ((void));
|
|
|
static int pmon_makeb64 PARAMS ((unsigned long v, char *p, int n, int *chksum));
|
static int pmon_makeb64 PARAMS ((unsigned long v, char *p, int n, int *chksum));
|
|
|
static int pmon_zeroset PARAMS ((int recsize, char **buff, int *amount,
|
static int pmon_zeroset PARAMS ((int recsize, char **buff, int *amount,
|
unsigned int *chksum));
|
unsigned int *chksum));
|
|
|
static int pmon_checkset PARAMS ((int recsize, char **buff, int *value));
|
static int pmon_checkset PARAMS ((int recsize, char **buff, int *value));
|
|
|
static void pmon_make_fastrec PARAMS ((char **outbuf, unsigned char *inbuf,
|
static void pmon_make_fastrec PARAMS ((char **outbuf, unsigned char *inbuf,
|
int *inptr, int inamount, int *recsize,
|
int *inptr, int inamount, int *recsize,
|
unsigned int *csum, unsigned int *zerofill));
|
unsigned int *csum, unsigned int *zerofill));
|
|
|
static int pmon_check_ack PARAMS ((char *mesg));
|
static int pmon_check_ack PARAMS ((char *mesg));
|
|
|
static void pmon_start_download PARAMS ((void));
|
static void pmon_start_download PARAMS ((void));
|
|
|
static void pmon_end_download PARAMS ((int final, int bintotal));
|
static void pmon_end_download PARAMS ((int final, int bintotal));
|
|
|
static void pmon_download PARAMS ((char *buffer, int length));
|
static void pmon_download PARAMS ((char *buffer, int length));
|
|
|
static void pmon_load_fast PARAMS ((char *file));
|
static void pmon_load_fast PARAMS ((char *file));
|
|
|
static void mips_load PARAMS ((char *file, int from_tty));
|
static void mips_load PARAMS ((char *file, int from_tty));
|
|
|
static int mips_make_srec PARAMS ((char *buffer, int type, CORE_ADDR memaddr,
|
static int mips_make_srec PARAMS ((char *buffer, int type, CORE_ADDR memaddr,
|
unsigned char *myaddr, int len));
|
unsigned char *myaddr, int len));
|
|
|
static int set_breakpoint PARAMS ((CORE_ADDR addr, int len,
|
static int set_breakpoint PARAMS ((CORE_ADDR addr, int len,
|
enum break_type type));
|
enum break_type type));
|
|
|
static int clear_breakpoint PARAMS ((CORE_ADDR addr, int len,
|
static int clear_breakpoint PARAMS ((CORE_ADDR addr, int len,
|
enum break_type type));
|
enum break_type type));
|
|
|
static int common_breakpoint PARAMS ((int set, CORE_ADDR addr, int len,
|
static int common_breakpoint PARAMS ((int set, CORE_ADDR addr, int len,
|
enum break_type type));
|
enum break_type type));
|
|
|
/* Forward declarations. */
|
/* Forward declarations. */
|
extern struct target_ops mips_ops;
|
extern struct target_ops mips_ops;
|
extern struct target_ops pmon_ops;
|
extern struct target_ops pmon_ops;
|
extern struct target_ops ddb_ops;
|
extern struct target_ops ddb_ops;
|
/* *INDENT-OFF* */
|
/* *INDENT-OFF* */
|
/* The MIPS remote debugging interface is built on top of a simple
|
/* The MIPS remote debugging interface is built on top of a simple
|
packet protocol. Each packet is organized as follows:
|
packet protocol. Each packet is organized as follows:
|
|
|
SYN The first character is always a SYN (ASCII 026, or ^V). SYN
|
SYN The first character is always a SYN (ASCII 026, or ^V). SYN
|
may not appear anywhere else in the packet. Any time a SYN is
|
may not appear anywhere else in the packet. Any time a SYN is
|
seen, a new packet should be assumed to have begun.
|
seen, a new packet should be assumed to have begun.
|
|
|
TYPE_LEN
|
TYPE_LEN
|
This byte contains the upper five bits of the logical length
|
This byte contains the upper five bits of the logical length
|
of the data section, plus a single bit indicating whether this
|
of the data section, plus a single bit indicating whether this
|
is a data packet or an acknowledgement. The documentation
|
is a data packet or an acknowledgement. The documentation
|
indicates that this bit is 1 for a data packet, but the actual
|
indicates that this bit is 1 for a data packet, but the actual
|
board uses 1 for an acknowledgement. The value of the byte is
|
board uses 1 for an acknowledgement. The value of the byte is
|
0x40 + (ack ? 0x20 : 0) + (len >> 6)
|
0x40 + (ack ? 0x20 : 0) + (len >> 6)
|
(we always have 0 <= len < 1024). Acknowledgement packets do
|
(we always have 0 <= len < 1024). Acknowledgement packets do
|
not carry data, and must have a data length of 0.
|
not carry data, and must have a data length of 0.
|
|
|
LEN1 This byte contains the lower six bits of the logical length of
|
LEN1 This byte contains the lower six bits of the logical length of
|
the data section. The value is
|
the data section. The value is
|
0x40 + (len & 0x3f)
|
0x40 + (len & 0x3f)
|
|
|
SEQ This byte contains the six bit sequence number of the packet.
|
SEQ This byte contains the six bit sequence number of the packet.
|
The value is
|
The value is
|
0x40 + seq
|
0x40 + seq
|
An acknowlegment packet contains the sequence number of the
|
An acknowlegment packet contains the sequence number of the
|
packet being acknowledged plus 1 modulo 64. Data packets are
|
packet being acknowledged plus 1 modulo 64. Data packets are
|
transmitted in sequence. There may only be one outstanding
|
transmitted in sequence. There may only be one outstanding
|
unacknowledged data packet at a time. The sequence numbers
|
unacknowledged data packet at a time. The sequence numbers
|
are independent in each direction. If an acknowledgement for
|
are independent in each direction. If an acknowledgement for
|
the previous packet is received (i.e., an acknowledgement with
|
the previous packet is received (i.e., an acknowledgement with
|
the sequence number of the packet just sent) the packet just
|
the sequence number of the packet just sent) the packet just
|
sent should be retransmitted. If no acknowledgement is
|
sent should be retransmitted. If no acknowledgement is
|
received within a timeout period, the packet should be
|
received within a timeout period, the packet should be
|
retransmitted. This has an unfortunate failure condition on a
|
retransmitted. This has an unfortunate failure condition on a
|
high-latency line, as a delayed acknowledgement may lead to an
|
high-latency line, as a delayed acknowledgement may lead to an
|
endless series of duplicate packets.
|
endless series of duplicate packets.
|
|
|
DATA The actual data bytes follow. The following characters are
|
DATA The actual data bytes follow. The following characters are
|
escaped inline with DLE (ASCII 020, or ^P):
|
escaped inline with DLE (ASCII 020, or ^P):
|
SYN (026) DLE S
|
SYN (026) DLE S
|
DLE (020) DLE D
|
DLE (020) DLE D
|
^C (003) DLE C
|
^C (003) DLE C
|
^S (023) DLE s
|
^S (023) DLE s
|
^Q (021) DLE q
|
^Q (021) DLE q
|
The additional DLE characters are not counted in the logical
|
The additional DLE characters are not counted in the logical
|
length stored in the TYPE_LEN and LEN1 bytes.
|
length stored in the TYPE_LEN and LEN1 bytes.
|
|
|
CSUM1
|
CSUM1
|
CSUM2
|
CSUM2
|
CSUM3
|
CSUM3
|
These bytes contain an 18 bit checksum of the complete
|
These bytes contain an 18 bit checksum of the complete
|
contents of the packet excluding the SEQ byte and the
|
contents of the packet excluding the SEQ byte and the
|
CSUM[123] bytes. The checksum is simply the twos complement
|
CSUM[123] bytes. The checksum is simply the twos complement
|
addition of all the bytes treated as unsigned characters. The
|
addition of all the bytes treated as unsigned characters. The
|
values of the checksum bytes are:
|
values of the checksum bytes are:
|
CSUM1: 0x40 + ((cksum >> 12) & 0x3f)
|
CSUM1: 0x40 + ((cksum >> 12) & 0x3f)
|
CSUM2: 0x40 + ((cksum >> 6) & 0x3f)
|
CSUM2: 0x40 + ((cksum >> 6) & 0x3f)
|
CSUM3: 0x40 + (cksum & 0x3f)
|
CSUM3: 0x40 + (cksum & 0x3f)
|
|
|
It happens that the MIPS remote debugging protocol always
|
It happens that the MIPS remote debugging protocol always
|
communicates with ASCII strings. Because of this, this
|
communicates with ASCII strings. Because of this, this
|
implementation doesn't bother to handle the DLE quoting mechanism,
|
implementation doesn't bother to handle the DLE quoting mechanism,
|
since it will never be required. */
|
since it will never be required. */
|
/* *INDENT-ON* */
|
/* *INDENT-ON* */
|
|
|
|
|
/* The SYN character which starts each packet. */
|
/* The SYN character which starts each packet. */
|
#define SYN '\026'
|
#define SYN '\026'
|
|
|
/* The 0x40 used to offset each packet (this value ensures that all of
|
/* The 0x40 used to offset each packet (this value ensures that all of
|
the header and trailer bytes, other than SYN, are printable ASCII
|
the header and trailer bytes, other than SYN, are printable ASCII
|
characters). */
|
characters). */
|
#define HDR_OFFSET 0x40
|
#define HDR_OFFSET 0x40
|
|
|
/* The indices of the bytes in the packet header. */
|
/* The indices of the bytes in the packet header. */
|
#define HDR_INDX_SYN 0
|
#define HDR_INDX_SYN 0
|
#define HDR_INDX_TYPE_LEN 1
|
#define HDR_INDX_TYPE_LEN 1
|
#define HDR_INDX_LEN1 2
|
#define HDR_INDX_LEN1 2
|
#define HDR_INDX_SEQ 3
|
#define HDR_INDX_SEQ 3
|
#define HDR_LENGTH 4
|
#define HDR_LENGTH 4
|
|
|
/* The data/ack bit in the TYPE_LEN header byte. */
|
/* The data/ack bit in the TYPE_LEN header byte. */
|
#define TYPE_LEN_DA_BIT 0x20
|
#define TYPE_LEN_DA_BIT 0x20
|
#define TYPE_LEN_DATA 0
|
#define TYPE_LEN_DATA 0
|
#define TYPE_LEN_ACK TYPE_LEN_DA_BIT
|
#define TYPE_LEN_ACK TYPE_LEN_DA_BIT
|
|
|
/* How to compute the header bytes. */
|
/* How to compute the header bytes. */
|
#define HDR_SET_SYN(data, len, seq) (SYN)
|
#define HDR_SET_SYN(data, len, seq) (SYN)
|
#define HDR_SET_TYPE_LEN(data, len, seq) \
|
#define HDR_SET_TYPE_LEN(data, len, seq) \
|
(HDR_OFFSET \
|
(HDR_OFFSET \
|
+ ((data) ? TYPE_LEN_DATA : TYPE_LEN_ACK) \
|
+ ((data) ? TYPE_LEN_DATA : TYPE_LEN_ACK) \
|
+ (((len) >> 6) & 0x1f))
|
+ (((len) >> 6) & 0x1f))
|
#define HDR_SET_LEN1(data, len, seq) (HDR_OFFSET + ((len) & 0x3f))
|
#define HDR_SET_LEN1(data, len, seq) (HDR_OFFSET + ((len) & 0x3f))
|
#define HDR_SET_SEQ(data, len, seq) (HDR_OFFSET + (seq))
|
#define HDR_SET_SEQ(data, len, seq) (HDR_OFFSET + (seq))
|
|
|
/* Check that a header byte is reasonable. */
|
/* Check that a header byte is reasonable. */
|
#define HDR_CHECK(ch) (((ch) & HDR_OFFSET) == HDR_OFFSET)
|
#define HDR_CHECK(ch) (((ch) & HDR_OFFSET) == HDR_OFFSET)
|
|
|
/* Get data from the header. These macros evaluate their argument
|
/* Get data from the header. These macros evaluate their argument
|
multiple times. */
|
multiple times. */
|
#define HDR_IS_DATA(hdr) \
|
#define HDR_IS_DATA(hdr) \
|
(((hdr)[HDR_INDX_TYPE_LEN] & TYPE_LEN_DA_BIT) == TYPE_LEN_DATA)
|
(((hdr)[HDR_INDX_TYPE_LEN] & TYPE_LEN_DA_BIT) == TYPE_LEN_DATA)
|
#define HDR_GET_LEN(hdr) \
|
#define HDR_GET_LEN(hdr) \
|
((((hdr)[HDR_INDX_TYPE_LEN] & 0x1f) << 6) + (((hdr)[HDR_INDX_LEN1] & 0x3f)))
|
((((hdr)[HDR_INDX_TYPE_LEN] & 0x1f) << 6) + (((hdr)[HDR_INDX_LEN1] & 0x3f)))
|
#define HDR_GET_SEQ(hdr) ((unsigned int)(hdr)[HDR_INDX_SEQ] & 0x3f)
|
#define HDR_GET_SEQ(hdr) ((unsigned int)(hdr)[HDR_INDX_SEQ] & 0x3f)
|
|
|
/* The maximum data length. */
|
/* The maximum data length. */
|
#define DATA_MAXLEN 1023
|
#define DATA_MAXLEN 1023
|
|
|
/* The trailer offset. */
|
/* The trailer offset. */
|
#define TRLR_OFFSET HDR_OFFSET
|
#define TRLR_OFFSET HDR_OFFSET
|
|
|
/* The indices of the bytes in the packet trailer. */
|
/* The indices of the bytes in the packet trailer. */
|
#define TRLR_INDX_CSUM1 0
|
#define TRLR_INDX_CSUM1 0
|
#define TRLR_INDX_CSUM2 1
|
#define TRLR_INDX_CSUM2 1
|
#define TRLR_INDX_CSUM3 2
|
#define TRLR_INDX_CSUM3 2
|
#define TRLR_LENGTH 3
|
#define TRLR_LENGTH 3
|
|
|
/* How to compute the trailer bytes. */
|
/* How to compute the trailer bytes. */
|
#define TRLR_SET_CSUM1(cksum) (TRLR_OFFSET + (((cksum) >> 12) & 0x3f))
|
#define TRLR_SET_CSUM1(cksum) (TRLR_OFFSET + (((cksum) >> 12) & 0x3f))
|
#define TRLR_SET_CSUM2(cksum) (TRLR_OFFSET + (((cksum) >> 6) & 0x3f))
|
#define TRLR_SET_CSUM2(cksum) (TRLR_OFFSET + (((cksum) >> 6) & 0x3f))
|
#define TRLR_SET_CSUM3(cksum) (TRLR_OFFSET + (((cksum) ) & 0x3f))
|
#define TRLR_SET_CSUM3(cksum) (TRLR_OFFSET + (((cksum) ) & 0x3f))
|
|
|
/* Check that a trailer byte is reasonable. */
|
/* Check that a trailer byte is reasonable. */
|
#define TRLR_CHECK(ch) (((ch) & TRLR_OFFSET) == TRLR_OFFSET)
|
#define TRLR_CHECK(ch) (((ch) & TRLR_OFFSET) == TRLR_OFFSET)
|
|
|
/* Get data from the trailer. This evaluates its argument multiple
|
/* Get data from the trailer. This evaluates its argument multiple
|
times. */
|
times. */
|
#define TRLR_GET_CKSUM(trlr) \
|
#define TRLR_GET_CKSUM(trlr) \
|
((((trlr)[TRLR_INDX_CSUM1] & 0x3f) << 12) \
|
((((trlr)[TRLR_INDX_CSUM1] & 0x3f) << 12) \
|
+ (((trlr)[TRLR_INDX_CSUM2] & 0x3f) << 6) \
|
+ (((trlr)[TRLR_INDX_CSUM2] & 0x3f) << 6) \
|
+ ((trlr)[TRLR_INDX_CSUM3] & 0x3f))
|
+ ((trlr)[TRLR_INDX_CSUM3] & 0x3f))
|
|
|
/* The sequence number modulos. */
|
/* The sequence number modulos. */
|
#define SEQ_MODULOS (64)
|
#define SEQ_MODULOS (64)
|
|
|
/* PMON commands to load from the serial port or UDP socket. */
|
/* PMON commands to load from the serial port or UDP socket. */
|
#define LOAD_CMD "load -b -s tty0\r"
|
#define LOAD_CMD "load -b -s tty0\r"
|
#define LOAD_CMD_UDP "load -b -s udp\r"
|
#define LOAD_CMD_UDP "load -b -s udp\r"
|
|
|
/* The target vectors for the four different remote MIPS targets.
|
/* The target vectors for the four different remote MIPS targets.
|
These are initialized with code in _initialize_remote_mips instead
|
These are initialized with code in _initialize_remote_mips instead
|
of static initializers, to make it easier to extend the target_ops
|
of static initializers, to make it easier to extend the target_ops
|
vector later. */
|
vector later. */
|
struct target_ops mips_ops, pmon_ops, ddb_ops, lsi_ops;
|
struct target_ops mips_ops, pmon_ops, ddb_ops, lsi_ops;
|
|
|
enum mips_monitor_type
|
enum mips_monitor_type
|
{
|
{
|
/* IDT/SIM monitor being used: */
|
/* IDT/SIM monitor being used: */
|
MON_IDT,
|
MON_IDT,
|
/* PMON monitor being used: */
|
/* PMON monitor being used: */
|
MON_PMON, /* 3.0.83 [COGENT,EB,FP,NET] Algorithmics Ltd. Nov 9 1995 17:19:50 */
|
MON_PMON, /* 3.0.83 [COGENT,EB,FP,NET] Algorithmics Ltd. Nov 9 1995 17:19:50 */
|
MON_DDB, /* 2.7.473 [DDBVR4300,EL,FP,NET] Risq Modular Systems, Thu Jun 6 09:28:40 PDT 1996 */
|
MON_DDB, /* 2.7.473 [DDBVR4300,EL,FP,NET] Risq Modular Systems, Thu Jun 6 09:28:40 PDT 1996 */
|
MON_LSI, /* 4.3.12 [EB,FP], LSI LOGIC Corp. Tue Feb 25 13:22:14 1997 */
|
MON_LSI, /* 4.3.12 [EB,FP], LSI LOGIC Corp. Tue Feb 25 13:22:14 1997 */
|
/* Last and unused value, for sizing vectors, etc. */
|
/* Last and unused value, for sizing vectors, etc. */
|
MON_LAST
|
MON_LAST
|
};
|
};
|
static enum mips_monitor_type mips_monitor = MON_LAST;
|
static enum mips_monitor_type mips_monitor = MON_LAST;
|
|
|
/* The monitor prompt text. If the user sets the PMON prompt
|
/* The monitor prompt text. If the user sets the PMON prompt
|
to some new value, the GDB `set monitor-prompt' command must also
|
to some new value, the GDB `set monitor-prompt' command must also
|
be used to inform GDB about the expected prompt. Otherwise, GDB
|
be used to inform GDB about the expected prompt. Otherwise, GDB
|
will not be able to connect to PMON in mips_initialize().
|
will not be able to connect to PMON in mips_initialize().
|
If the `set monitor-prompt' command is not used, the expected
|
If the `set monitor-prompt' command is not used, the expected
|
default prompt will be set according the target:
|
default prompt will be set according the target:
|
target prompt
|
target prompt
|
----- -----
|
----- -----
|
pmon PMON>
|
pmon PMON>
|
ddb NEC010>
|
ddb NEC010>
|
lsi PMON>
|
lsi PMON>
|
*/
|
*/
|
static char *mips_monitor_prompt;
|
static char *mips_monitor_prompt;
|
|
|
/* Set to 1 if the target is open. */
|
/* Set to 1 if the target is open. */
|
static int mips_is_open;
|
static int mips_is_open;
|
|
|
/* Currently active target description (if mips_is_open == 1) */
|
/* Currently active target description (if mips_is_open == 1) */
|
static struct target_ops *current_ops;
|
static struct target_ops *current_ops;
|
|
|
/* Set to 1 while the connection is being initialized. */
|
/* Set to 1 while the connection is being initialized. */
|
static int mips_initializing;
|
static int mips_initializing;
|
|
|
/* Set to 1 while the connection is being brought down. */
|
/* Set to 1 while the connection is being brought down. */
|
static int mips_exiting;
|
static int mips_exiting;
|
|
|
/* The next sequence number to send. */
|
/* The next sequence number to send. */
|
static unsigned int mips_send_seq;
|
static unsigned int mips_send_seq;
|
|
|
/* The next sequence number we expect to receive. */
|
/* The next sequence number we expect to receive. */
|
static unsigned int mips_receive_seq;
|
static unsigned int mips_receive_seq;
|
|
|
/* The time to wait before retransmitting a packet, in seconds. */
|
/* The time to wait before retransmitting a packet, in seconds. */
|
static int mips_retransmit_wait = 3;
|
static int mips_retransmit_wait = 3;
|
|
|
/* The number of times to try retransmitting a packet before giving up. */
|
/* The number of times to try retransmitting a packet before giving up. */
|
static int mips_send_retries = 10;
|
static int mips_send_retries = 10;
|
|
|
/* The number of garbage characters to accept when looking for an
|
/* The number of garbage characters to accept when looking for an
|
SYN for the next packet. */
|
SYN for the next packet. */
|
static int mips_syn_garbage = 1050;
|
static int mips_syn_garbage = 1050;
|
|
|
/* The time to wait for a packet, in seconds. */
|
/* The time to wait for a packet, in seconds. */
|
static int mips_receive_wait = 5;
|
static int mips_receive_wait = 5;
|
|
|
/* Set if we have sent a packet to the board but have not yet received
|
/* Set if we have sent a packet to the board but have not yet received
|
a reply. */
|
a reply. */
|
static int mips_need_reply = 0;
|
static int mips_need_reply = 0;
|
|
|
/* Handle used to access serial I/O stream. */
|
/* Handle used to access serial I/O stream. */
|
static serial_t mips_desc;
|
static serial_t mips_desc;
|
|
|
/* UDP handle used to download files to target. */
|
/* UDP handle used to download files to target. */
|
static serial_t udp_desc;
|
static serial_t udp_desc;
|
static int udp_in_use;
|
static int udp_in_use;
|
|
|
/* TFTP filename used to download files to DDB board, in the form
|
/* TFTP filename used to download files to DDB board, in the form
|
host:filename. */
|
host:filename. */
|
static char *tftp_name; /* host:filename */
|
static char *tftp_name; /* host:filename */
|
static char *tftp_localname; /* filename portion of above */
|
static char *tftp_localname; /* filename portion of above */
|
static int tftp_in_use;
|
static int tftp_in_use;
|
static FILE *tftp_file;
|
static FILE *tftp_file;
|
|
|
/* Counts the number of times the user tried to interrupt the target (usually
|
/* Counts the number of times the user tried to interrupt the target (usually
|
via ^C. */
|
via ^C. */
|
static int interrupt_count;
|
static int interrupt_count;
|
|
|
/* If non-zero, means that the target is running. */
|
/* If non-zero, means that the target is running. */
|
static int mips_wait_flag = 0;
|
static int mips_wait_flag = 0;
|
|
|
/* If non-zero, monitor supports breakpoint commands. */
|
/* If non-zero, monitor supports breakpoint commands. */
|
static int monitor_supports_breakpoints = 0;
|
static int monitor_supports_breakpoints = 0;
|
|
|
/* Data cache header. */
|
/* Data cache header. */
|
|
|
#if 0 /* not used (yet?) */
|
#if 0 /* not used (yet?) */
|
static DCACHE *mips_dcache;
|
static DCACHE *mips_dcache;
|
#endif
|
#endif
|
|
|
/* Non-zero means that we've just hit a read or write watchpoint */
|
/* Non-zero means that we've just hit a read or write watchpoint */
|
static int hit_watchpoint;
|
static int hit_watchpoint;
|
|
|
/* Table of breakpoints/watchpoints (used only on LSI PMON target).
|
/* Table of breakpoints/watchpoints (used only on LSI PMON target).
|
The table is indexed by a breakpoint number, which is an integer
|
The table is indexed by a breakpoint number, which is an integer
|
from 0 to 255 returned by the LSI PMON when a breakpoint is set.
|
from 0 to 255 returned by the LSI PMON when a breakpoint is set.
|
*/
|
*/
|
#define MAX_LSI_BREAKPOINTS 256
|
#define MAX_LSI_BREAKPOINTS 256
|
struct lsi_breakpoint_info
|
struct lsi_breakpoint_info
|
{
|
{
|
enum break_type type; /* type of breakpoint */
|
enum break_type type; /* type of breakpoint */
|
CORE_ADDR addr; /* address of breakpoint */
|
CORE_ADDR addr; /* address of breakpoint */
|
int len; /* length of region being watched */
|
int len; /* length of region being watched */
|
unsigned long value; /* value to watch */
|
unsigned long value; /* value to watch */
|
}
|
}
|
lsi_breakpoints[MAX_LSI_BREAKPOINTS];
|
lsi_breakpoints[MAX_LSI_BREAKPOINTS];
|
|
|
/* Error/warning codes returned by LSI PMON for breakpoint commands.
|
/* Error/warning codes returned by LSI PMON for breakpoint commands.
|
Warning values may be ORed together; error values may not. */
|
Warning values may be ORed together; error values may not. */
|
#define W_WARN 0x100 /* This bit is set if the error code is a warning */
|
#define W_WARN 0x100 /* This bit is set if the error code is a warning */
|
#define W_MSK 0x101 /* warning: Range feature is supported via mask */
|
#define W_MSK 0x101 /* warning: Range feature is supported via mask */
|
#define W_VAL 0x102 /* warning: Value check is not supported in hardware */
|
#define W_VAL 0x102 /* warning: Value check is not supported in hardware */
|
#define W_QAL 0x104 /* warning: Requested qualifiers are not supported in hardware */
|
#define W_QAL 0x104 /* warning: Requested qualifiers are not supported in hardware */
|
|
|
#define E_ERR 0x200 /* This bit is set if the error code is an error */
|
#define E_ERR 0x200 /* This bit is set if the error code is an error */
|
#define E_BPT 0x200 /* error: No such breakpoint number */
|
#define E_BPT 0x200 /* error: No such breakpoint number */
|
#define E_RGE 0x201 /* error: Range is not supported */
|
#define E_RGE 0x201 /* error: Range is not supported */
|
#define E_QAL 0x202 /* error: The requested qualifiers can not be used */
|
#define E_QAL 0x202 /* error: The requested qualifiers can not be used */
|
#define E_OUT 0x203 /* error: Out of hardware resources */
|
#define E_OUT 0x203 /* error: Out of hardware resources */
|
#define E_NON 0x204 /* error: Hardware breakpoint not supported */
|
#define E_NON 0x204 /* error: Hardware breakpoint not supported */
|
|
|
struct lsi_error
|
struct lsi_error
|
{
|
{
|
int code; /* error code */
|
int code; /* error code */
|
char *string; /* string associated with this code */
|
char *string; /* string associated with this code */
|
};
|
};
|
|
|
struct lsi_error lsi_warning_table[] =
|
struct lsi_error lsi_warning_table[] =
|
{
|
{
|
{W_MSK, "Range feature is supported via mask"},
|
{W_MSK, "Range feature is supported via mask"},
|
{W_VAL, "Value check is not supported in hardware"},
|
{W_VAL, "Value check is not supported in hardware"},
|
{W_QAL, "Requested qualifiers are not supported in hardware"},
|
{W_QAL, "Requested qualifiers are not supported in hardware"},
|
{0, NULL}
|
{0, NULL}
|
};
|
};
|
|
|
struct lsi_error lsi_error_table[] =
|
struct lsi_error lsi_error_table[] =
|
{
|
{
|
{E_BPT, "No such breakpoint number"},
|
{E_BPT, "No such breakpoint number"},
|
{E_RGE, "Range is not supported"},
|
{E_RGE, "Range is not supported"},
|
{E_QAL, "The requested qualifiers can not be used"},
|
{E_QAL, "The requested qualifiers can not be used"},
|
{E_OUT, "Out of hardware resources"},
|
{E_OUT, "Out of hardware resources"},
|
{E_NON, "Hardware breakpoint not supported"},
|
{E_NON, "Hardware breakpoint not supported"},
|
{0, NULL}
|
{0, NULL}
|
};
|
};
|
|
|
/* Set to 1 with the 'set monitor-warnings' command to enable printing
|
/* Set to 1 with the 'set monitor-warnings' command to enable printing
|
of warnings returned by PMON when hardware breakpoints are used. */
|
of warnings returned by PMON when hardware breakpoints are used. */
|
static int monitor_warnings;
|
static int monitor_warnings;
|
|
|
|
|
static void
|
static void
|
close_ports ()
|
close_ports ()
|
{
|
{
|
mips_is_open = 0;
|
mips_is_open = 0;
|
SERIAL_CLOSE (mips_desc);
|
SERIAL_CLOSE (mips_desc);
|
|
|
if (udp_in_use)
|
if (udp_in_use)
|
{
|
{
|
SERIAL_CLOSE (udp_desc);
|
SERIAL_CLOSE (udp_desc);
|
udp_in_use = 0;
|
udp_in_use = 0;
|
}
|
}
|
tftp_in_use = 0;
|
tftp_in_use = 0;
|
}
|
}
|
|
|
/* Handle low-level error that we can't recover from. Note that just
|
/* Handle low-level error that we can't recover from. Note that just
|
error()ing out from target_wait or some such low-level place will cause
|
error()ing out from target_wait or some such low-level place will cause
|
all hell to break loose--the rest of GDB will tend to get left in an
|
all hell to break loose--the rest of GDB will tend to get left in an
|
inconsistent state. */
|
inconsistent state. */
|
|
|
static NORETURN void
|
static NORETURN void
|
mips_error (char *string,...)
|
mips_error (char *string,...)
|
{
|
{
|
va_list args;
|
va_list args;
|
|
|
va_start (args, string);
|
va_start (args, string);
|
|
|
target_terminal_ours ();
|
target_terminal_ours ();
|
wrap_here (""); /* Force out any buffered output */
|
wrap_here (""); /* Force out any buffered output */
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
if (error_pre_print)
|
if (error_pre_print)
|
fprintf_filtered (gdb_stderr, error_pre_print);
|
fprintf_filtered (gdb_stderr, error_pre_print);
|
vfprintf_filtered (gdb_stderr, string, args);
|
vfprintf_filtered (gdb_stderr, string, args);
|
fprintf_filtered (gdb_stderr, "\n");
|
fprintf_filtered (gdb_stderr, "\n");
|
va_end (args);
|
va_end (args);
|
gdb_flush (gdb_stderr);
|
gdb_flush (gdb_stderr);
|
|
|
/* Clean up in such a way that mips_close won't try to talk to the
|
/* Clean up in such a way that mips_close won't try to talk to the
|
board (it almost surely won't work since we weren't able to talk to
|
board (it almost surely won't work since we weren't able to talk to
|
it). */
|
it). */
|
close_ports ();
|
close_ports ();
|
|
|
printf_unfiltered ("Ending remote MIPS debugging.\n");
|
printf_unfiltered ("Ending remote MIPS debugging.\n");
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
|
|
return_to_top_level (RETURN_ERROR);
|
return_to_top_level (RETURN_ERROR);
|
}
|
}
|
|
|
/* putc_readable - print a character, displaying non-printable chars in
|
/* putc_readable - print a character, displaying non-printable chars in
|
^x notation or in hex. */
|
^x notation or in hex. */
|
|
|
static void
|
static void
|
fputc_readable (ch, file)
|
fputc_readable (ch, file)
|
int ch;
|
int ch;
|
struct ui_file *file;
|
struct ui_file *file;
|
{
|
{
|
if (ch == '\n')
|
if (ch == '\n')
|
fputc_unfiltered ('\n', file);
|
fputc_unfiltered ('\n', file);
|
else if (ch == '\r')
|
else if (ch == '\r')
|
fprintf_unfiltered (file, "\\r");
|
fprintf_unfiltered (file, "\\r");
|
else if (ch < 0x20) /* ASCII control character */
|
else if (ch < 0x20) /* ASCII control character */
|
fprintf_unfiltered (file, "^%c", ch + '@');
|
fprintf_unfiltered (file, "^%c", ch + '@');
|
else if (ch >= 0x7f) /* non-ASCII characters (rubout or greater) */
|
else if (ch >= 0x7f) /* non-ASCII characters (rubout or greater) */
|
fprintf_unfiltered (file, "[%02x]", ch & 0xff);
|
fprintf_unfiltered (file, "[%02x]", ch & 0xff);
|
else
|
else
|
fputc_unfiltered (ch, file);
|
fputc_unfiltered (ch, file);
|
}
|
}
|
|
|
|
|
/* puts_readable - print a string, displaying non-printable chars in
|
/* puts_readable - print a string, displaying non-printable chars in
|
^x notation or in hex. */
|
^x notation or in hex. */
|
|
|
static void
|
static void
|
fputs_readable (string, file)
|
fputs_readable (string, file)
|
char *string;
|
char *string;
|
struct ui_file *file;
|
struct ui_file *file;
|
{
|
{
|
int c;
|
int c;
|
|
|
while ((c = *string++) != '\0')
|
while ((c = *string++) != '\0')
|
fputc_readable (c, file);
|
fputc_readable (c, file);
|
}
|
}
|
|
|
|
|
/* Wait until STRING shows up in mips_desc. Returns 1 if successful, else 0 if
|
/* Wait until STRING shows up in mips_desc. Returns 1 if successful, else 0 if
|
timed out. TIMEOUT specifies timeout value in seconds.
|
timed out. TIMEOUT specifies timeout value in seconds.
|
*/
|
*/
|
|
|
int
|
int
|
mips_expect_timeout (string, timeout)
|
mips_expect_timeout (string, timeout)
|
char *string;
|
char *string;
|
int timeout;
|
int timeout;
|
{
|
{
|
char *p = string;
|
char *p = string;
|
|
|
if (remote_debug)
|
if (remote_debug)
|
{
|
{
|
fprintf_unfiltered (gdb_stdlog, "Expected \"");
|
fprintf_unfiltered (gdb_stdlog, "Expected \"");
|
fputs_readable (string, gdb_stdlog);
|
fputs_readable (string, gdb_stdlog);
|
fprintf_unfiltered (gdb_stdlog, "\", got \"");
|
fprintf_unfiltered (gdb_stdlog, "\", got \"");
|
}
|
}
|
|
|
immediate_quit = 1;
|
immediate_quit = 1;
|
while (1)
|
while (1)
|
{
|
{
|
int c;
|
int c;
|
|
|
/* Must use SERIAL_READCHAR here cuz mips_readchar would get confused if we
|
/* Must use SERIAL_READCHAR here cuz mips_readchar would get confused if we
|
were waiting for the mips_monitor_prompt... */
|
were waiting for the mips_monitor_prompt... */
|
|
|
c = SERIAL_READCHAR (mips_desc, timeout);
|
c = SERIAL_READCHAR (mips_desc, timeout);
|
|
|
if (c == SERIAL_TIMEOUT)
|
if (c == SERIAL_TIMEOUT)
|
{
|
{
|
if (remote_debug)
|
if (remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "\": FAIL\n");
|
fprintf_unfiltered (gdb_stdlog, "\": FAIL\n");
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (remote_debug)
|
if (remote_debug)
|
fputc_readable (c, gdb_stdlog);
|
fputc_readable (c, gdb_stdlog);
|
|
|
if (c == *p++)
|
if (c == *p++)
|
{
|
{
|
if (*p == '\0')
|
if (*p == '\0')
|
{
|
{
|
immediate_quit = 0;
|
immediate_quit = 0;
|
if (remote_debug)
|
if (remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "\": OK\n");
|
fprintf_unfiltered (gdb_stdlog, "\": OK\n");
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
p = string;
|
p = string;
|
if (c == *p)
|
if (c == *p)
|
p++;
|
p++;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Wait until STRING shows up in mips_desc. Returns 1 if successful, else 0 if
|
/* Wait until STRING shows up in mips_desc. Returns 1 if successful, else 0 if
|
timed out. The timeout value is hard-coded to 2 seconds. Use
|
timed out. The timeout value is hard-coded to 2 seconds. Use
|
mips_expect_timeout if a different timeout value is needed.
|
mips_expect_timeout if a different timeout value is needed.
|
*/
|
*/
|
|
|
int
|
int
|
mips_expect (string)
|
mips_expect (string)
|
char *string;
|
char *string;
|
{
|
{
|
return mips_expect_timeout (string, 2);
|
return mips_expect_timeout (string, 2);
|
}
|
}
|
|
|
/* Read the required number of characters into the given buffer (which
|
/* Read the required number of characters into the given buffer (which
|
is assumed to be large enough). The only failure is a timeout. */
|
is assumed to be large enough). The only failure is a timeout. */
|
int
|
int
|
mips_getstring (string, n)
|
mips_getstring (string, n)
|
char *string;
|
char *string;
|
int n;
|
int n;
|
{
|
{
|
char *p = string;
|
char *p = string;
|
int c;
|
int c;
|
|
|
immediate_quit = 1;
|
immediate_quit = 1;
|
while (n > 0)
|
while (n > 0)
|
{
|
{
|
c = SERIAL_READCHAR (mips_desc, 2);
|
c = SERIAL_READCHAR (mips_desc, 2);
|
|
|
if (c == SERIAL_TIMEOUT)
|
if (c == SERIAL_TIMEOUT)
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"Failed to read %d characters from target (TIMEOUT)\n", n);
|
"Failed to read %d characters from target (TIMEOUT)\n", n);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
*p++ = c;
|
*p++ = c;
|
n--;
|
n--;
|
}
|
}
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Read a character from the remote, aborting on error. Returns
|
/* Read a character from the remote, aborting on error. Returns
|
SERIAL_TIMEOUT on timeout (since that's what SERIAL_READCHAR
|
SERIAL_TIMEOUT on timeout (since that's what SERIAL_READCHAR
|
returns). FIXME: If we see the string mips_monitor_prompt from
|
returns). FIXME: If we see the string mips_monitor_prompt from
|
the board, then we are debugging on the main console port, and we
|
the board, then we are debugging on the main console port, and we
|
have somehow dropped out of remote debugging mode. In this case,
|
have somehow dropped out of remote debugging mode. In this case,
|
we automatically go back in to remote debugging mode. This is a
|
we automatically go back in to remote debugging mode. This is a
|
hack, put in because I can't find any way for a program running on
|
hack, put in because I can't find any way for a program running on
|
the remote board to terminate without also ending remote debugging
|
the remote board to terminate without also ending remote debugging
|
mode. I assume users won't have any trouble with this; for one
|
mode. I assume users won't have any trouble with this; for one
|
thing, the IDT documentation generally assumes that the remote
|
thing, the IDT documentation generally assumes that the remote
|
debugging port is not the console port. This is, however, very
|
debugging port is not the console port. This is, however, very
|
convenient for DejaGnu when you only have one connected serial
|
convenient for DejaGnu when you only have one connected serial
|
port. */
|
port. */
|
|
|
static int
|
static int
|
mips_readchar (timeout)
|
mips_readchar (timeout)
|
int timeout;
|
int timeout;
|
{
|
{
|
int ch;
|
int ch;
|
static int state = 0;
|
static int state = 0;
|
int mips_monitor_prompt_len = strlen (mips_monitor_prompt);
|
int mips_monitor_prompt_len = strlen (mips_monitor_prompt);
|
|
|
{
|
{
|
int i;
|
int i;
|
|
|
i = timeout;
|
i = timeout;
|
if (i == -1 && watchdog > 0)
|
if (i == -1 && watchdog > 0)
|
i = watchdog;
|
i = watchdog;
|
}
|
}
|
|
|
if (state == mips_monitor_prompt_len)
|
if (state == mips_monitor_prompt_len)
|
timeout = 1;
|
timeout = 1;
|
ch = SERIAL_READCHAR (mips_desc, timeout);
|
ch = SERIAL_READCHAR (mips_desc, timeout);
|
|
|
if (ch == SERIAL_TIMEOUT && timeout == -1) /* Watchdog went off */
|
if (ch == SERIAL_TIMEOUT && timeout == -1) /* Watchdog went off */
|
{
|
{
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
error ("Watchdog has expired. Target detached.\n");
|
error ("Watchdog has expired. Target detached.\n");
|
}
|
}
|
|
|
if (ch == SERIAL_EOF)
|
if (ch == SERIAL_EOF)
|
mips_error ("End of file from remote");
|
mips_error ("End of file from remote");
|
if (ch == SERIAL_ERROR)
|
if (ch == SERIAL_ERROR)
|
mips_error ("Error reading from remote: %s", safe_strerror (errno));
|
mips_error ("Error reading from remote: %s", safe_strerror (errno));
|
if (remote_debug > 1)
|
if (remote_debug > 1)
|
{
|
{
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
if (ch != SERIAL_TIMEOUT)
|
if (ch != SERIAL_TIMEOUT)
|
fprintf_unfiltered (gdb_stdlog, "Read '%c' %d 0x%x\n", ch, ch, ch);
|
fprintf_unfiltered (gdb_stdlog, "Read '%c' %d 0x%x\n", ch, ch, ch);
|
else
|
else
|
fprintf_unfiltered (gdb_stdlog, "Timed out in read\n");
|
fprintf_unfiltered (gdb_stdlog, "Timed out in read\n");
|
}
|
}
|
|
|
/* If we have seen mips_monitor_prompt and we either time out, or
|
/* If we have seen mips_monitor_prompt and we either time out, or
|
we see a @ (which was echoed from a packet we sent), reset the
|
we see a @ (which was echoed from a packet we sent), reset the
|
board as described above. The first character in a packet after
|
board as described above. The first character in a packet after
|
the SYN (which is not echoed) is always an @ unless the packet is
|
the SYN (which is not echoed) is always an @ unless the packet is
|
more than 64 characters long, which ours never are. */
|
more than 64 characters long, which ours never are. */
|
if ((ch == SERIAL_TIMEOUT || ch == '@')
|
if ((ch == SERIAL_TIMEOUT || ch == '@')
|
&& state == mips_monitor_prompt_len
|
&& state == mips_monitor_prompt_len
|
&& !mips_initializing
|
&& !mips_initializing
|
&& !mips_exiting)
|
&& !mips_exiting)
|
{
|
{
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
fprintf_unfiltered (gdb_stdlog, "Reinitializing MIPS debugging mode\n");
|
fprintf_unfiltered (gdb_stdlog, "Reinitializing MIPS debugging mode\n");
|
|
|
mips_need_reply = 0;
|
mips_need_reply = 0;
|
mips_initialize ();
|
mips_initialize ();
|
|
|
state = 0;
|
state = 0;
|
|
|
/* At this point, about the only thing we can do is abort the command
|
/* At this point, about the only thing we can do is abort the command
|
in progress and get back to command level as quickly as possible. */
|
in progress and get back to command level as quickly as possible. */
|
|
|
error ("Remote board reset, debug protocol re-initialized.");
|
error ("Remote board reset, debug protocol re-initialized.");
|
}
|
}
|
|
|
if (ch == mips_monitor_prompt[state])
|
if (ch == mips_monitor_prompt[state])
|
++state;
|
++state;
|
else
|
else
|
state = 0;
|
state = 0;
|
|
|
return ch;
|
return ch;
|
}
|
}
|
|
|
/* Get a packet header, putting the data in the supplied buffer.
|
/* Get a packet header, putting the data in the supplied buffer.
|
PGARBAGE is a pointer to the number of garbage characters received
|
PGARBAGE is a pointer to the number of garbage characters received
|
so far. CH is the last character received. Returns 0 for success,
|
so far. CH is the last character received. Returns 0 for success,
|
or -1 for timeout. */
|
or -1 for timeout. */
|
|
|
static int
|
static int
|
mips_receive_header (hdr, pgarbage, ch, timeout)
|
mips_receive_header (hdr, pgarbage, ch, timeout)
|
unsigned char *hdr;
|
unsigned char *hdr;
|
int *pgarbage;
|
int *pgarbage;
|
int ch;
|
int ch;
|
int timeout;
|
int timeout;
|
{
|
{
|
int i;
|
int i;
|
|
|
while (1)
|
while (1)
|
{
|
{
|
/* Wait for a SYN. mips_syn_garbage is intended to prevent
|
/* Wait for a SYN. mips_syn_garbage is intended to prevent
|
sitting here indefinitely if the board sends us one garbage
|
sitting here indefinitely if the board sends us one garbage
|
character per second. ch may already have a value from the
|
character per second. ch may already have a value from the
|
last time through the loop. */
|
last time through the loop. */
|
while (ch != SYN)
|
while (ch != SYN)
|
{
|
{
|
ch = mips_readchar (timeout);
|
ch = mips_readchar (timeout);
|
if (ch == SERIAL_TIMEOUT)
|
if (ch == SERIAL_TIMEOUT)
|
return -1;
|
return -1;
|
if (ch != SYN)
|
if (ch != SYN)
|
{
|
{
|
/* Printing the character here lets the user of gdb see
|
/* Printing the character here lets the user of gdb see
|
what the program is outputting, if the debugging is
|
what the program is outputting, if the debugging is
|
being done on the console port. Don't use _filtered;
|
being done on the console port. Don't use _filtered;
|
we can't deal with a QUIT out of target_wait. */
|
we can't deal with a QUIT out of target_wait. */
|
if (!mips_initializing || remote_debug > 0)
|
if (!mips_initializing || remote_debug > 0)
|
{
|
{
|
fputc_readable (ch, gdb_stdlog);
|
fputc_readable (ch, gdb_stdlog);
|
gdb_flush (gdb_stdlog);
|
gdb_flush (gdb_stdlog);
|
}
|
}
|
|
|
++*pgarbage;
|
++*pgarbage;
|
if (mips_syn_garbage > 0
|
if (mips_syn_garbage > 0
|
&& *pgarbage > mips_syn_garbage)
|
&& *pgarbage > mips_syn_garbage)
|
mips_error ("Debug protocol failure: more than %d characters before a sync.",
|
mips_error ("Debug protocol failure: more than %d characters before a sync.",
|
mips_syn_garbage);
|
mips_syn_garbage);
|
}
|
}
|
}
|
}
|
|
|
/* Get the packet header following the SYN. */
|
/* Get the packet header following the SYN. */
|
for (i = 1; i < HDR_LENGTH; i++)
|
for (i = 1; i < HDR_LENGTH; i++)
|
{
|
{
|
ch = mips_readchar (timeout);
|
ch = mips_readchar (timeout);
|
if (ch == SERIAL_TIMEOUT)
|
if (ch == SERIAL_TIMEOUT)
|
return -1;
|
return -1;
|
/* Make sure this is a header byte. */
|
/* Make sure this is a header byte. */
|
if (ch == SYN || !HDR_CHECK (ch))
|
if (ch == SYN || !HDR_CHECK (ch))
|
break;
|
break;
|
|
|
hdr[i] = ch;
|
hdr[i] = ch;
|
}
|
}
|
|
|
/* If we got the complete header, we can return. Otherwise we
|
/* If we got the complete header, we can return. Otherwise we
|
loop around and keep looking for SYN. */
|
loop around and keep looking for SYN. */
|
if (i >= HDR_LENGTH)
|
if (i >= HDR_LENGTH)
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* Get a packet header, putting the data in the supplied buffer.
|
/* Get a packet header, putting the data in the supplied buffer.
|
PGARBAGE is a pointer to the number of garbage characters received
|
PGARBAGE is a pointer to the number of garbage characters received
|
so far. The last character read is returned in *PCH. Returns 0
|
so far. The last character read is returned in *PCH. Returns 0
|
for success, -1 for timeout, -2 for error. */
|
for success, -1 for timeout, -2 for error. */
|
|
|
static int
|
static int
|
mips_receive_trailer (trlr, pgarbage, pch, timeout)
|
mips_receive_trailer (trlr, pgarbage, pch, timeout)
|
unsigned char *trlr;
|
unsigned char *trlr;
|
int *pgarbage;
|
int *pgarbage;
|
int *pch;
|
int *pch;
|
int timeout;
|
int timeout;
|
{
|
{
|
int i;
|
int i;
|
int ch;
|
int ch;
|
|
|
for (i = 0; i < TRLR_LENGTH; i++)
|
for (i = 0; i < TRLR_LENGTH; i++)
|
{
|
{
|
ch = mips_readchar (timeout);
|
ch = mips_readchar (timeout);
|
*pch = ch;
|
*pch = ch;
|
if (ch == SERIAL_TIMEOUT)
|
if (ch == SERIAL_TIMEOUT)
|
return -1;
|
return -1;
|
if (!TRLR_CHECK (ch))
|
if (!TRLR_CHECK (ch))
|
return -2;
|
return -2;
|
trlr[i] = ch;
|
trlr[i] = ch;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Get the checksum of a packet. HDR points to the packet header.
|
/* Get the checksum of a packet. HDR points to the packet header.
|
DATA points to the packet data. LEN is the length of DATA. */
|
DATA points to the packet data. LEN is the length of DATA. */
|
|
|
static int
|
static int
|
mips_cksum (hdr, data, len)
|
mips_cksum (hdr, data, len)
|
const unsigned char *hdr;
|
const unsigned char *hdr;
|
const unsigned char *data;
|
const unsigned char *data;
|
int len;
|
int len;
|
{
|
{
|
register const unsigned char *p;
|
register const unsigned char *p;
|
register int c;
|
register int c;
|
register int cksum;
|
register int cksum;
|
|
|
cksum = 0;
|
cksum = 0;
|
|
|
/* The initial SYN is not included in the checksum. */
|
/* The initial SYN is not included in the checksum. */
|
c = HDR_LENGTH - 1;
|
c = HDR_LENGTH - 1;
|
p = hdr + 1;
|
p = hdr + 1;
|
while (c-- != 0)
|
while (c-- != 0)
|
cksum += *p++;
|
cksum += *p++;
|
|
|
c = len;
|
c = len;
|
p = data;
|
p = data;
|
while (c-- != 0)
|
while (c-- != 0)
|
cksum += *p++;
|
cksum += *p++;
|
|
|
return cksum;
|
return cksum;
|
}
|
}
|
|
|
/* Send a packet containing the given ASCII string. */
|
/* Send a packet containing the given ASCII string. */
|
|
|
static void
|
static void
|
mips_send_packet (s, get_ack)
|
mips_send_packet (s, get_ack)
|
const char *s;
|
const char *s;
|
int get_ack;
|
int get_ack;
|
{
|
{
|
/* unsigned */ int len;
|
/* unsigned */ int len;
|
unsigned char *packet;
|
unsigned char *packet;
|
register int cksum;
|
register int cksum;
|
int try;
|
int try;
|
|
|
len = strlen (s);
|
len = strlen (s);
|
if (len > DATA_MAXLEN)
|
if (len > DATA_MAXLEN)
|
mips_error ("MIPS protocol data packet too long: %s", s);
|
mips_error ("MIPS protocol data packet too long: %s", s);
|
|
|
packet = (unsigned char *) alloca (HDR_LENGTH + len + TRLR_LENGTH + 1);
|
packet = (unsigned char *) alloca (HDR_LENGTH + len + TRLR_LENGTH + 1);
|
|
|
packet[HDR_INDX_SYN] = HDR_SET_SYN (1, len, mips_send_seq);
|
packet[HDR_INDX_SYN] = HDR_SET_SYN (1, len, mips_send_seq);
|
packet[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (1, len, mips_send_seq);
|
packet[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (1, len, mips_send_seq);
|
packet[HDR_INDX_LEN1] = HDR_SET_LEN1 (1, len, mips_send_seq);
|
packet[HDR_INDX_LEN1] = HDR_SET_LEN1 (1, len, mips_send_seq);
|
packet[HDR_INDX_SEQ] = HDR_SET_SEQ (1, len, mips_send_seq);
|
packet[HDR_INDX_SEQ] = HDR_SET_SEQ (1, len, mips_send_seq);
|
|
|
memcpy (packet + HDR_LENGTH, s, len);
|
memcpy (packet + HDR_LENGTH, s, len);
|
|
|
cksum = mips_cksum (packet, packet + HDR_LENGTH, len);
|
cksum = mips_cksum (packet, packet + HDR_LENGTH, len);
|
packet[HDR_LENGTH + len + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
|
packet[HDR_LENGTH + len + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
|
packet[HDR_LENGTH + len + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
|
packet[HDR_LENGTH + len + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
|
packet[HDR_LENGTH + len + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
|
packet[HDR_LENGTH + len + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
|
|
|
/* Increment the sequence number. This will set mips_send_seq to
|
/* Increment the sequence number. This will set mips_send_seq to
|
the sequence number we expect in the acknowledgement. */
|
the sequence number we expect in the acknowledgement. */
|
mips_send_seq = (mips_send_seq + 1) % SEQ_MODULOS;
|
mips_send_seq = (mips_send_seq + 1) % SEQ_MODULOS;
|
|
|
/* We can only have one outstanding data packet, so we just wait for
|
/* We can only have one outstanding data packet, so we just wait for
|
the acknowledgement here. Keep retransmitting the packet until
|
the acknowledgement here. Keep retransmitting the packet until
|
we get one, or until we've tried too many times. */
|
we get one, or until we've tried too many times. */
|
for (try = 0; try < mips_send_retries; try++)
|
for (try = 0; try < mips_send_retries; try++)
|
{
|
{
|
int garbage;
|
int garbage;
|
int ch;
|
int ch;
|
|
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
{
|
{
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
packet[HDR_LENGTH + len + TRLR_LENGTH] = '\0';
|
packet[HDR_LENGTH + len + TRLR_LENGTH] = '\0';
|
fprintf_unfiltered (gdb_stdlog, "Writing \"%s\"\n", packet + 1);
|
fprintf_unfiltered (gdb_stdlog, "Writing \"%s\"\n", packet + 1);
|
}
|
}
|
|
|
if (SERIAL_WRITE (mips_desc, packet,
|
if (SERIAL_WRITE (mips_desc, packet,
|
HDR_LENGTH + len + TRLR_LENGTH) != 0)
|
HDR_LENGTH + len + TRLR_LENGTH) != 0)
|
mips_error ("write to target failed: %s", safe_strerror (errno));
|
mips_error ("write to target failed: %s", safe_strerror (errno));
|
|
|
if (!get_ack)
|
if (!get_ack)
|
return;
|
return;
|
|
|
garbage = 0;
|
garbage = 0;
|
ch = 0;
|
ch = 0;
|
while (1)
|
while (1)
|
{
|
{
|
unsigned char hdr[HDR_LENGTH + 1];
|
unsigned char hdr[HDR_LENGTH + 1];
|
unsigned char trlr[TRLR_LENGTH + 1];
|
unsigned char trlr[TRLR_LENGTH + 1];
|
int err;
|
int err;
|
unsigned int seq;
|
unsigned int seq;
|
|
|
/* Get the packet header. If we time out, resend the data
|
/* Get the packet header. If we time out, resend the data
|
packet. */
|
packet. */
|
err = mips_receive_header (hdr, &garbage, ch, mips_retransmit_wait);
|
err = mips_receive_header (hdr, &garbage, ch, mips_retransmit_wait);
|
if (err != 0)
|
if (err != 0)
|
break;
|
break;
|
|
|
ch = 0;
|
ch = 0;
|
|
|
/* If we get a data packet, assume it is a duplicate and
|
/* If we get a data packet, assume it is a duplicate and
|
ignore it. FIXME: If the acknowledgement is lost, this
|
ignore it. FIXME: If the acknowledgement is lost, this
|
data packet may be the packet the remote sends after the
|
data packet may be the packet the remote sends after the
|
acknowledgement. */
|
acknowledgement. */
|
if (HDR_IS_DATA (hdr))
|
if (HDR_IS_DATA (hdr))
|
{
|
{
|
int i;
|
int i;
|
|
|
/* Ignore any errors raised whilst attempting to ignore
|
/* Ignore any errors raised whilst attempting to ignore
|
packet. */
|
packet. */
|
|
|
len = HDR_GET_LEN (hdr);
|
len = HDR_GET_LEN (hdr);
|
|
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
{
|
{
|
int rch;
|
int rch;
|
|
|
rch = mips_readchar (2);
|
rch = mips_readchar (2);
|
if (rch == SYN)
|
if (rch == SYN)
|
{
|
{
|
ch = SYN;
|
ch = SYN;
|
break;
|
break;
|
}
|
}
|
if (rch == SERIAL_TIMEOUT)
|
if (rch == SERIAL_TIMEOUT)
|
break;
|
break;
|
/* ignore the character */
|
/* ignore the character */
|
}
|
}
|
|
|
if (i == len)
|
if (i == len)
|
(void) mips_receive_trailer (trlr, &garbage, &ch, 2);
|
(void) mips_receive_trailer (trlr, &garbage, &ch, 2);
|
|
|
/* We don't bother checking the checksum, or providing an
|
/* We don't bother checking the checksum, or providing an
|
ACK to the packet. */
|
ACK to the packet. */
|
continue;
|
continue;
|
}
|
}
|
|
|
/* If the length is not 0, this is a garbled packet. */
|
/* If the length is not 0, this is a garbled packet. */
|
if (HDR_GET_LEN (hdr) != 0)
|
if (HDR_GET_LEN (hdr) != 0)
|
continue;
|
continue;
|
|
|
/* Get the packet trailer. */
|
/* Get the packet trailer. */
|
err = mips_receive_trailer (trlr, &garbage, &ch,
|
err = mips_receive_trailer (trlr, &garbage, &ch,
|
mips_retransmit_wait);
|
mips_retransmit_wait);
|
|
|
/* If we timed out, resend the data packet. */
|
/* If we timed out, resend the data packet. */
|
if (err == -1)
|
if (err == -1)
|
break;
|
break;
|
|
|
/* If we got a bad character, reread the header. */
|
/* If we got a bad character, reread the header. */
|
if (err != 0)
|
if (err != 0)
|
continue;
|
continue;
|
|
|
/* If the checksum does not match the trailer checksum, this
|
/* If the checksum does not match the trailer checksum, this
|
is a bad packet; ignore it. */
|
is a bad packet; ignore it. */
|
if (mips_cksum (hdr, (unsigned char *) NULL, 0)
|
if (mips_cksum (hdr, (unsigned char *) NULL, 0)
|
!= TRLR_GET_CKSUM (trlr))
|
!= TRLR_GET_CKSUM (trlr))
|
continue;
|
continue;
|
|
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
{
|
{
|
hdr[HDR_LENGTH] = '\0';
|
hdr[HDR_LENGTH] = '\0';
|
trlr[TRLR_LENGTH] = '\0';
|
trlr[TRLR_LENGTH] = '\0';
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
fprintf_unfiltered (gdb_stdlog, "Got ack %d \"%s%s\"\n",
|
fprintf_unfiltered (gdb_stdlog, "Got ack %d \"%s%s\"\n",
|
HDR_GET_SEQ (hdr), hdr + 1, trlr);
|
HDR_GET_SEQ (hdr), hdr + 1, trlr);
|
}
|
}
|
|
|
/* If this ack is for the current packet, we're done. */
|
/* If this ack is for the current packet, we're done. */
|
seq = HDR_GET_SEQ (hdr);
|
seq = HDR_GET_SEQ (hdr);
|
if (seq == mips_send_seq)
|
if (seq == mips_send_seq)
|
return;
|
return;
|
|
|
/* If this ack is for the last packet, resend the current
|
/* If this ack is for the last packet, resend the current
|
packet. */
|
packet. */
|
if ((seq + 1) % SEQ_MODULOS == mips_send_seq)
|
if ((seq + 1) % SEQ_MODULOS == mips_send_seq)
|
break;
|
break;
|
|
|
/* Otherwise this is a bad ack; ignore it. Increment the
|
/* Otherwise this is a bad ack; ignore it. Increment the
|
garbage count to ensure that we do not stay in this loop
|
garbage count to ensure that we do not stay in this loop
|
forever. */
|
forever. */
|
++garbage;
|
++garbage;
|
}
|
}
|
}
|
}
|
|
|
mips_error ("Remote did not acknowledge packet");
|
mips_error ("Remote did not acknowledge packet");
|
}
|
}
|
|
|
/* Receive and acknowledge a packet, returning the data in BUFF (which
|
/* Receive and acknowledge a packet, returning the data in BUFF (which
|
should be DATA_MAXLEN + 1 bytes). The protocol documentation
|
should be DATA_MAXLEN + 1 bytes). The protocol documentation
|
implies that only the sender retransmits packets, so this code just
|
implies that only the sender retransmits packets, so this code just
|
waits silently for a packet. It returns the length of the received
|
waits silently for a packet. It returns the length of the received
|
packet. If THROW_ERROR is nonzero, call error() on errors. If not,
|
packet. If THROW_ERROR is nonzero, call error() on errors. If not,
|
don't print an error message and return -1. */
|
don't print an error message and return -1. */
|
|
|
static int
|
static int
|
mips_receive_packet (buff, throw_error, timeout)
|
mips_receive_packet (buff, throw_error, timeout)
|
char *buff;
|
char *buff;
|
int throw_error;
|
int throw_error;
|
int timeout;
|
int timeout;
|
{
|
{
|
int ch;
|
int ch;
|
int garbage;
|
int garbage;
|
int len;
|
int len;
|
unsigned char ack[HDR_LENGTH + TRLR_LENGTH + 1];
|
unsigned char ack[HDR_LENGTH + TRLR_LENGTH + 1];
|
int cksum;
|
int cksum;
|
|
|
ch = 0;
|
ch = 0;
|
garbage = 0;
|
garbage = 0;
|
while (1)
|
while (1)
|
{
|
{
|
unsigned char hdr[HDR_LENGTH];
|
unsigned char hdr[HDR_LENGTH];
|
unsigned char trlr[TRLR_LENGTH];
|
unsigned char trlr[TRLR_LENGTH];
|
int i;
|
int i;
|
int err;
|
int err;
|
|
|
if (mips_receive_header (hdr, &garbage, ch, timeout) != 0)
|
if (mips_receive_header (hdr, &garbage, ch, timeout) != 0)
|
{
|
{
|
if (throw_error)
|
if (throw_error)
|
mips_error ("Timed out waiting for remote packet");
|
mips_error ("Timed out waiting for remote packet");
|
else
|
else
|
return -1;
|
return -1;
|
}
|
}
|
|
|
ch = 0;
|
ch = 0;
|
|
|
/* An acknowledgement is probably a duplicate; ignore it. */
|
/* An acknowledgement is probably a duplicate; ignore it. */
|
if (!HDR_IS_DATA (hdr))
|
if (!HDR_IS_DATA (hdr))
|
{
|
{
|
len = HDR_GET_LEN (hdr);
|
len = HDR_GET_LEN (hdr);
|
/* Check if the length is valid for an ACK, we may aswell
|
/* Check if the length is valid for an ACK, we may aswell
|
try and read the remainder of the packet: */
|
try and read the remainder of the packet: */
|
if (len == 0)
|
if (len == 0)
|
{
|
{
|
/* Ignore the error condition, since we are going to
|
/* Ignore the error condition, since we are going to
|
ignore the packet anyway. */
|
ignore the packet anyway. */
|
(void) mips_receive_trailer (trlr, &garbage, &ch, timeout);
|
(void) mips_receive_trailer (trlr, &garbage, &ch, timeout);
|
}
|
}
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
fprintf_unfiltered (gdb_stdlog, "Ignoring unexpected ACK\n");
|
fprintf_unfiltered (gdb_stdlog, "Ignoring unexpected ACK\n");
|
continue;
|
continue;
|
}
|
}
|
|
|
len = HDR_GET_LEN (hdr);
|
len = HDR_GET_LEN (hdr);
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
{
|
{
|
int rch;
|
int rch;
|
|
|
rch = mips_readchar (timeout);
|
rch = mips_readchar (timeout);
|
if (rch == SYN)
|
if (rch == SYN)
|
{
|
{
|
ch = SYN;
|
ch = SYN;
|
break;
|
break;
|
}
|
}
|
if (rch == SERIAL_TIMEOUT)
|
if (rch == SERIAL_TIMEOUT)
|
{
|
{
|
if (throw_error)
|
if (throw_error)
|
mips_error ("Timed out waiting for remote packet");
|
mips_error ("Timed out waiting for remote packet");
|
else
|
else
|
return -1;
|
return -1;
|
}
|
}
|
buff[i] = rch;
|
buff[i] = rch;
|
}
|
}
|
|
|
if (i < len)
|
if (i < len)
|
{
|
{
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"Got new SYN after %d chars (wanted %d)\n",
|
"Got new SYN after %d chars (wanted %d)\n",
|
i, len);
|
i, len);
|
continue;
|
continue;
|
}
|
}
|
|
|
err = mips_receive_trailer (trlr, &garbage, &ch, timeout);
|
err = mips_receive_trailer (trlr, &garbage, &ch, timeout);
|
if (err == -1)
|
if (err == -1)
|
{
|
{
|
if (throw_error)
|
if (throw_error)
|
mips_error ("Timed out waiting for packet");
|
mips_error ("Timed out waiting for packet");
|
else
|
else
|
return -1;
|
return -1;
|
}
|
}
|
if (err == -2)
|
if (err == -2)
|
{
|
{
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
fprintf_unfiltered (gdb_stdlog, "Got SYN when wanted trailer\n");
|
fprintf_unfiltered (gdb_stdlog, "Got SYN when wanted trailer\n");
|
continue;
|
continue;
|
}
|
}
|
|
|
/* If this is the wrong sequence number, ignore it. */
|
/* If this is the wrong sequence number, ignore it. */
|
if (HDR_GET_SEQ (hdr) != mips_receive_seq)
|
if (HDR_GET_SEQ (hdr) != mips_receive_seq)
|
{
|
{
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
fprintf_unfiltered (gdb_stdlog,
|
fprintf_unfiltered (gdb_stdlog,
|
"Ignoring sequence number %d (want %d)\n",
|
"Ignoring sequence number %d (want %d)\n",
|
HDR_GET_SEQ (hdr), mips_receive_seq);
|
HDR_GET_SEQ (hdr), mips_receive_seq);
|
continue;
|
continue;
|
}
|
}
|
|
|
if (mips_cksum (hdr, buff, len) == TRLR_GET_CKSUM (trlr))
|
if (mips_cksum (hdr, buff, len) == TRLR_GET_CKSUM (trlr))
|
break;
|
break;
|
|
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
printf_unfiltered ("Bad checksum; data %d, trailer %d\n",
|
printf_unfiltered ("Bad checksum; data %d, trailer %d\n",
|
mips_cksum (hdr, buff, len),
|
mips_cksum (hdr, buff, len),
|
TRLR_GET_CKSUM (trlr));
|
TRLR_GET_CKSUM (trlr));
|
|
|
/* The checksum failed. Send an acknowledgement for the
|
/* The checksum failed. Send an acknowledgement for the
|
previous packet to tell the remote to resend the packet. */
|
previous packet to tell the remote to resend the packet. */
|
ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
|
ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
|
ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
|
ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
|
ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
|
ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
|
ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
|
ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
|
|
|
cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
|
cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
|
|
|
ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
|
|
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
{
|
{
|
ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
|
ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
|
printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
|
ack + 1);
|
ack + 1);
|
}
|
}
|
|
|
if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
|
if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
|
{
|
{
|
if (throw_error)
|
if (throw_error)
|
mips_error ("write to target failed: %s", safe_strerror (errno));
|
mips_error ("write to target failed: %s", safe_strerror (errno));
|
else
|
else
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
|
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
{
|
{
|
buff[len] = '\0';
|
buff[len] = '\0';
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
printf_unfiltered ("Got packet \"%s\"\n", buff);
|
printf_unfiltered ("Got packet \"%s\"\n", buff);
|
}
|
}
|
|
|
/* We got the packet. Send an acknowledgement. */
|
/* We got the packet. Send an acknowledgement. */
|
mips_receive_seq = (mips_receive_seq + 1) % SEQ_MODULOS;
|
mips_receive_seq = (mips_receive_seq + 1) % SEQ_MODULOS;
|
|
|
ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
|
ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
|
ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
|
ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
|
ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
|
ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
|
ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
|
ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
|
|
|
cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
|
cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
|
|
|
ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
|
ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
|
|
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
{
|
{
|
ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
|
ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
/* Don't use _filtered; we can't deal with a QUIT out of
|
target_wait, and I think this might be called from there. */
|
target_wait, and I think this might be called from there. */
|
printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
|
printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
|
ack + 1);
|
ack + 1);
|
}
|
}
|
|
|
if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
|
if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
|
{
|
{
|
if (throw_error)
|
if (throw_error)
|
mips_error ("write to target failed: %s", safe_strerror (errno));
|
mips_error ("write to target failed: %s", safe_strerror (errno));
|
else
|
else
|
return -1;
|
return -1;
|
}
|
}
|
|
|
return len;
|
return len;
|
}
|
}
|
|
|
/* Optionally send a request to the remote system and optionally wait
|
/* Optionally send a request to the remote system and optionally wait
|
for the reply. This implements the remote debugging protocol,
|
for the reply. This implements the remote debugging protocol,
|
which is built on top of the packet protocol defined above. Each
|
which is built on top of the packet protocol defined above. Each
|
request has an ADDR argument and a DATA argument. The following
|
request has an ADDR argument and a DATA argument. The following
|
requests are defined:
|
requests are defined:
|
|
|
\0 don't send a request; just wait for a reply
|
\0 don't send a request; just wait for a reply
|
i read word from instruction space at ADDR
|
i read word from instruction space at ADDR
|
d read word from data space at ADDR
|
d read word from data space at ADDR
|
I write DATA to instruction space at ADDR
|
I write DATA to instruction space at ADDR
|
D write DATA to data space at ADDR
|
D write DATA to data space at ADDR
|
r read register number ADDR
|
r read register number ADDR
|
R set register number ADDR to value DATA
|
R set register number ADDR to value DATA
|
c continue execution (if ADDR != 1, set pc to ADDR)
|
c continue execution (if ADDR != 1, set pc to ADDR)
|
s single step (if ADDR != 1, set pc to ADDR)
|
s single step (if ADDR != 1, set pc to ADDR)
|
|
|
The read requests return the value requested. The write requests
|
The read requests return the value requested. The write requests
|
return the previous value in the changed location. The execution
|
return the previous value in the changed location. The execution
|
requests return a UNIX wait value (the approximate signal which
|
requests return a UNIX wait value (the approximate signal which
|
caused execution to stop is in the upper eight bits).
|
caused execution to stop is in the upper eight bits).
|
|
|
If PERR is not NULL, this function waits for a reply. If an error
|
If PERR is not NULL, this function waits for a reply. If an error
|
occurs, it sets *PERR to 1 and sets errno according to what the
|
occurs, it sets *PERR to 1 and sets errno according to what the
|
target board reports. */
|
target board reports. */
|
|
|
static CORE_ADDR
|
static CORE_ADDR
|
mips_request (cmd, addr, data, perr, timeout, buff)
|
mips_request (cmd, addr, data, perr, timeout, buff)
|
int cmd;
|
int cmd;
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
CORE_ADDR data;
|
CORE_ADDR data;
|
int *perr;
|
int *perr;
|
int timeout;
|
int timeout;
|
char *buff;
|
char *buff;
|
{
|
{
|
char myBuff[DATA_MAXLEN + 1];
|
char myBuff[DATA_MAXLEN + 1];
|
int len;
|
int len;
|
int rpid;
|
int rpid;
|
char rcmd;
|
char rcmd;
|
int rerrflg;
|
int rerrflg;
|
unsigned long rresponse;
|
unsigned long rresponse;
|
|
|
if (buff == (char *) NULL)
|
if (buff == (char *) NULL)
|
buff = myBuff;
|
buff = myBuff;
|
|
|
if (cmd != '\0')
|
if (cmd != '\0')
|
{
|
{
|
if (mips_need_reply)
|
if (mips_need_reply)
|
internal_error ("mips_request: Trying to send command before reply");
|
internal_error ("mips_request: Trying to send command before reply");
|
sprintf (buff, "0x0 %c 0x%s 0x%s", cmd, paddr_nz (addr), paddr_nz (data));
|
sprintf (buff, "0x0 %c 0x%s 0x%s", cmd, paddr_nz (addr), paddr_nz (data));
|
mips_send_packet (buff, 1);
|
mips_send_packet (buff, 1);
|
mips_need_reply = 1;
|
mips_need_reply = 1;
|
}
|
}
|
|
|
if (perr == (int *) NULL)
|
if (perr == (int *) NULL)
|
return 0;
|
return 0;
|
|
|
if (!mips_need_reply)
|
if (!mips_need_reply)
|
internal_error ("mips_request: Trying to get reply before command");
|
internal_error ("mips_request: Trying to get reply before command");
|
|
|
mips_need_reply = 0;
|
mips_need_reply = 0;
|
|
|
len = mips_receive_packet (buff, 1, timeout);
|
len = mips_receive_packet (buff, 1, timeout);
|
buff[len] = '\0';
|
buff[len] = '\0';
|
|
|
if (sscanf (buff, "0x%x %c 0x%x 0x%lx",
|
if (sscanf (buff, "0x%x %c 0x%x 0x%lx",
|
&rpid, &rcmd, &rerrflg, &rresponse) != 4
|
&rpid, &rcmd, &rerrflg, &rresponse) != 4
|
|| (cmd != '\0' && rcmd != cmd))
|
|| (cmd != '\0' && rcmd != cmd))
|
mips_error ("Bad response from remote board");
|
mips_error ("Bad response from remote board");
|
|
|
if (rerrflg != 0)
|
if (rerrflg != 0)
|
{
|
{
|
*perr = 1;
|
*perr = 1;
|
|
|
/* FIXME: This will returns MIPS errno numbers, which may or may
|
/* FIXME: This will returns MIPS errno numbers, which may or may
|
not be the same as errno values used on other systems. If
|
not be the same as errno values used on other systems. If
|
they stick to common errno values, they will be the same, but
|
they stick to common errno values, they will be the same, but
|
if they don't, they must be translated. */
|
if they don't, they must be translated. */
|
errno = rresponse;
|
errno = rresponse;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
*perr = 0;
|
*perr = 0;
|
return rresponse;
|
return rresponse;
|
}
|
}
|
|
|
static void
|
static void
|
mips_initialize_cleanups (arg)
|
mips_initialize_cleanups (arg)
|
PTR arg;
|
PTR arg;
|
{
|
{
|
mips_initializing = 0;
|
mips_initializing = 0;
|
}
|
}
|
|
|
static void
|
static void
|
mips_exit_cleanups (arg)
|
mips_exit_cleanups (arg)
|
PTR arg;
|
PTR arg;
|
{
|
{
|
mips_exiting = 0;
|
mips_exiting = 0;
|
}
|
}
|
|
|
static void
|
static void
|
mips_send_command (cmd, prompt)
|
mips_send_command (cmd, prompt)
|
const char *cmd;
|
const char *cmd;
|
int prompt;
|
int prompt;
|
{
|
{
|
SERIAL_WRITE (mips_desc, cmd, strlen (cmd));
|
SERIAL_WRITE (mips_desc, cmd, strlen (cmd));
|
mips_expect (cmd);
|
mips_expect (cmd);
|
mips_expect ("\n");
|
mips_expect ("\n");
|
if (prompt)
|
if (prompt)
|
mips_expect (mips_monitor_prompt);
|
mips_expect (mips_monitor_prompt);
|
}
|
}
|
|
|
/* Enter remote (dbx) debug mode: */
|
/* Enter remote (dbx) debug mode: */
|
static void
|
static void
|
mips_enter_debug ()
|
mips_enter_debug ()
|
{
|
{
|
/* Reset the sequence numbers, ready for the new debug sequence: */
|
/* Reset the sequence numbers, ready for the new debug sequence: */
|
mips_send_seq = 0;
|
mips_send_seq = 0;
|
mips_receive_seq = 0;
|
mips_receive_seq = 0;
|
|
|
if (mips_monitor != MON_IDT)
|
if (mips_monitor != MON_IDT)
|
mips_send_command ("debug\r", 0);
|
mips_send_command ("debug\r", 0);
|
else /* assume IDT monitor by default */
|
else /* assume IDT monitor by default */
|
mips_send_command ("db tty0\r", 0);
|
mips_send_command ("db tty0\r", 0);
|
|
|
sleep (1);
|
sleep (1);
|
SERIAL_WRITE (mips_desc, "\r", sizeof "\r" - 1);
|
SERIAL_WRITE (mips_desc, "\r", sizeof "\r" - 1);
|
|
|
/* We don't need to absorb any spurious characters here, since the
|
/* We don't need to absorb any spurious characters here, since the
|
mips_receive_header will eat up a reasonable number of characters
|
mips_receive_header will eat up a reasonable number of characters
|
whilst looking for the SYN, however this avoids the "garbage"
|
whilst looking for the SYN, however this avoids the "garbage"
|
being displayed to the user. */
|
being displayed to the user. */
|
if (mips_monitor != MON_IDT)
|
if (mips_monitor != MON_IDT)
|
mips_expect ("\r");
|
mips_expect ("\r");
|
|
|
{
|
{
|
char buff[DATA_MAXLEN + 1];
|
char buff[DATA_MAXLEN + 1];
|
if (mips_receive_packet (buff, 1, 3) < 0)
|
if (mips_receive_packet (buff, 1, 3) < 0)
|
mips_error ("Failed to initialize (didn't receive packet).");
|
mips_error ("Failed to initialize (didn't receive packet).");
|
}
|
}
|
}
|
}
|
|
|
/* Exit remote (dbx) debug mode, returning to the monitor prompt: */
|
/* Exit remote (dbx) debug mode, returning to the monitor prompt: */
|
static int
|
static int
|
mips_exit_debug ()
|
mips_exit_debug ()
|
{
|
{
|
int err;
|
int err;
|
struct cleanup *old_cleanups = make_cleanup (mips_exit_cleanups, NULL);
|
struct cleanup *old_cleanups = make_cleanup (mips_exit_cleanups, NULL);
|
|
|
mips_exiting = 1;
|
mips_exiting = 1;
|
|
|
if (mips_monitor != MON_IDT)
|
if (mips_monitor != MON_IDT)
|
{
|
{
|
/* The DDB (NEC) and MiniRISC (LSI) versions of PMON exit immediately,
|
/* The DDB (NEC) and MiniRISC (LSI) versions of PMON exit immediately,
|
so we do not get a reply to this command: */
|
so we do not get a reply to this command: */
|
mips_request ('x', (unsigned int) 0, (unsigned int) 0, NULL,
|
mips_request ('x', (unsigned int) 0, (unsigned int) 0, NULL,
|
mips_receive_wait, NULL);
|
mips_receive_wait, NULL);
|
mips_need_reply = 0;
|
mips_need_reply = 0;
|
if (!mips_expect (" break!"))
|
if (!mips_expect (" break!"))
|
return -1;
|
return -1;
|
}
|
}
|
else
|
else
|
mips_request ('x', (unsigned int) 0, (unsigned int) 0, &err,
|
mips_request ('x', (unsigned int) 0, (unsigned int) 0, &err,
|
mips_receive_wait, NULL);
|
mips_receive_wait, NULL);
|
|
|
if (!mips_expect (mips_monitor_prompt))
|
if (!mips_expect (mips_monitor_prompt))
|
return -1;
|
return -1;
|
|
|
do_cleanups (old_cleanups);
|
do_cleanups (old_cleanups);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Initialize a new connection to the MIPS board, and make sure we are
|
/* Initialize a new connection to the MIPS board, and make sure we are
|
really connected. */
|
really connected. */
|
|
|
static void
|
static void
|
mips_initialize ()
|
mips_initialize ()
|
{
|
{
|
int err;
|
int err;
|
struct cleanup *old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
|
struct cleanup *old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
|
int j;
|
int j;
|
|
|
/* What is this code doing here? I don't see any way it can happen, and
|
/* What is this code doing here? I don't see any way it can happen, and
|
it might mean mips_initializing didn't get cleared properly.
|
it might mean mips_initializing didn't get cleared properly.
|
So I'll make it a warning. */
|
So I'll make it a warning. */
|
|
|
if (mips_initializing)
|
if (mips_initializing)
|
{
|
{
|
warning ("internal error: mips_initialize called twice");
|
warning ("internal error: mips_initialize called twice");
|
return;
|
return;
|
}
|
}
|
|
|
mips_wait_flag = 0;
|
mips_wait_flag = 0;
|
mips_initializing = 1;
|
mips_initializing = 1;
|
|
|
/* At this point, the packit protocol isn't responding. We'll try getting
|
/* At this point, the packit protocol isn't responding. We'll try getting
|
into the monitor, and restarting the protocol. */
|
into the monitor, and restarting the protocol. */
|
|
|
/* Force the system into the monitor. After this we *should* be at
|
/* Force the system into the monitor. After this we *should* be at
|
the mips_monitor_prompt. */
|
the mips_monitor_prompt. */
|
if (mips_monitor != MON_IDT)
|
if (mips_monitor != MON_IDT)
|
j = 0; /* start by checking if we are already at the prompt */
|
j = 0; /* start by checking if we are already at the prompt */
|
else
|
else
|
j = 1; /* start by sending a break */
|
j = 1; /* start by sending a break */
|
for (; j <= 4; j++)
|
for (; j <= 4; j++)
|
{
|
{
|
switch (j)
|
switch (j)
|
{
|
{
|
case 0: /* First, try sending a CR */
|
case 0: /* First, try sending a CR */
|
SERIAL_FLUSH_INPUT (mips_desc);
|
SERIAL_FLUSH_INPUT (mips_desc);
|
SERIAL_WRITE (mips_desc, "\r", 1);
|
SERIAL_WRITE (mips_desc, "\r", 1);
|
break;
|
break;
|
case 1: /* First, try sending a break */
|
case 1: /* First, try sending a break */
|
SERIAL_SEND_BREAK (mips_desc);
|
SERIAL_SEND_BREAK (mips_desc);
|
break;
|
break;
|
case 2: /* Then, try a ^C */
|
case 2: /* Then, try a ^C */
|
SERIAL_WRITE (mips_desc, "\003", 1);
|
SERIAL_WRITE (mips_desc, "\003", 1);
|
break;
|
break;
|
case 3: /* Then, try escaping from download */
|
case 3: /* Then, try escaping from download */
|
{
|
{
|
if (mips_monitor != MON_IDT)
|
if (mips_monitor != MON_IDT)
|
{
|
{
|
char tbuff[7];
|
char tbuff[7];
|
|
|
/* We shouldn't need to send multiple termination
|
/* We shouldn't need to send multiple termination
|
sequences, since the target performs line (or
|
sequences, since the target performs line (or
|
block) reads, and then processes those
|
block) reads, and then processes those
|
packets. In-case we were downloading a large packet
|
packets. In-case we were downloading a large packet
|
we flush the output buffer before inserting a
|
we flush the output buffer before inserting a
|
termination sequence. */
|
termination sequence. */
|
SERIAL_FLUSH_OUTPUT (mips_desc);
|
SERIAL_FLUSH_OUTPUT (mips_desc);
|
sprintf (tbuff, "\r/E/E\r");
|
sprintf (tbuff, "\r/E/E\r");
|
SERIAL_WRITE (mips_desc, tbuff, 6);
|
SERIAL_WRITE (mips_desc, tbuff, 6);
|
}
|
}
|
else
|
else
|
{
|
{
|
char srec[10];
|
char srec[10];
|
int i;
|
int i;
|
|
|
/* We are possibly in binary download mode, having
|
/* We are possibly in binary download mode, having
|
aborted in the middle of an S-record. ^C won't
|
aborted in the middle of an S-record. ^C won't
|
work because of binary mode. The only reliable way
|
work because of binary mode. The only reliable way
|
out is to send enough termination packets (8 bytes)
|
out is to send enough termination packets (8 bytes)
|
to fill up and then overflow the largest size
|
to fill up and then overflow the largest size
|
S-record (255 bytes in this case). This amounts to
|
S-record (255 bytes in this case). This amounts to
|
256/8 + 1 packets.
|
256/8 + 1 packets.
|
*/
|
*/
|
|
|
mips_make_srec (srec, '7', 0, NULL, 0);
|
mips_make_srec (srec, '7', 0, NULL, 0);
|
|
|
for (i = 1; i <= 33; i++)
|
for (i = 1; i <= 33; i++)
|
{
|
{
|
SERIAL_WRITE (mips_desc, srec, 8);
|
SERIAL_WRITE (mips_desc, srec, 8);
|
|
|
if (SERIAL_READCHAR (mips_desc, 0) >= 0)
|
if (SERIAL_READCHAR (mips_desc, 0) >= 0)
|
break; /* Break immediatly if we get something from
|
break; /* Break immediatly if we get something from
|
the board. */
|
the board. */
|
}
|
}
|
}
|
}
|
}
|
}
|
break;
|
break;
|
case 4:
|
case 4:
|
mips_error ("Failed to initialize.");
|
mips_error ("Failed to initialize.");
|
}
|
}
|
|
|
if (mips_expect (mips_monitor_prompt))
|
if (mips_expect (mips_monitor_prompt))
|
break;
|
break;
|
}
|
}
|
|
|
if (mips_monitor != MON_IDT)
|
if (mips_monitor != MON_IDT)
|
{
|
{
|
/* Sometimes PMON ignores the first few characters in the first
|
/* Sometimes PMON ignores the first few characters in the first
|
command sent after a load. Sending a blank command gets
|
command sent after a load. Sending a blank command gets
|
around that. */
|
around that. */
|
mips_send_command ("\r", -1);
|
mips_send_command ("\r", -1);
|
|
|
/* Ensure the correct target state: */
|
/* Ensure the correct target state: */
|
if (mips_monitor != MON_LSI)
|
if (mips_monitor != MON_LSI)
|
mips_send_command ("set regsize 64\r", -1);
|
mips_send_command ("set regsize 64\r", -1);
|
mips_send_command ("set hostport tty0\r", -1);
|
mips_send_command ("set hostport tty0\r", -1);
|
mips_send_command ("set brkcmd \"\"\r", -1);
|
mips_send_command ("set brkcmd \"\"\r", -1);
|
/* Delete all the current breakpoints: */
|
/* Delete all the current breakpoints: */
|
mips_send_command ("db *\r", -1);
|
mips_send_command ("db *\r", -1);
|
/* NOTE: PMON does not have breakpoint support through the
|
/* NOTE: PMON does not have breakpoint support through the
|
"debug" mode, only at the monitor command-line. */
|
"debug" mode, only at the monitor command-line. */
|
}
|
}
|
|
|
mips_enter_debug ();
|
mips_enter_debug ();
|
|
|
/* Clear all breakpoints: */
|
/* Clear all breakpoints: */
|
if ((mips_monitor == MON_IDT
|
if ((mips_monitor == MON_IDT
|
&& clear_breakpoint (-1, 0, BREAK_UNUSED) == 0)
|
&& clear_breakpoint (-1, 0, BREAK_UNUSED) == 0)
|
|| mips_monitor == MON_LSI)
|
|| mips_monitor == MON_LSI)
|
monitor_supports_breakpoints = 1;
|
monitor_supports_breakpoints = 1;
|
else
|
else
|
monitor_supports_breakpoints = 0;
|
monitor_supports_breakpoints = 0;
|
|
|
do_cleanups (old_cleanups);
|
do_cleanups (old_cleanups);
|
|
|
/* If this doesn't call error, we have connected; we don't care if
|
/* If this doesn't call error, we have connected; we don't care if
|
the request itself succeeds or fails. */
|
the request itself succeeds or fails. */
|
|
|
mips_request ('r', (unsigned int) 0, (unsigned int) 0, &err,
|
mips_request ('r', (unsigned int) 0, (unsigned int) 0, &err,
|
mips_receive_wait, NULL);
|
mips_receive_wait, NULL);
|
set_current_frame (create_new_frame (read_fp (), read_pc ()));
|
set_current_frame (create_new_frame (read_fp (), read_pc ()));
|
select_frame (get_current_frame (), 0);
|
select_frame (get_current_frame (), 0);
|
}
|
}
|
|
|
/* Open a connection to the remote board. */
|
/* Open a connection to the remote board. */
|
static void
|
static void
|
common_open (ops, name, from_tty, new_monitor, new_monitor_prompt)
|
common_open (ops, name, from_tty, new_monitor, new_monitor_prompt)
|
struct target_ops *ops;
|
struct target_ops *ops;
|
char *name;
|
char *name;
|
int from_tty;
|
int from_tty;
|
enum mips_monitor_type new_monitor;
|
enum mips_monitor_type new_monitor;
|
char *new_monitor_prompt;
|
char *new_monitor_prompt;
|
{
|
{
|
char *ptype;
|
char *ptype;
|
char *serial_port_name;
|
char *serial_port_name;
|
char *remote_name = 0;
|
char *remote_name = 0;
|
char *local_name = 0;
|
char *local_name = 0;
|
char **argv;
|
char **argv;
|
|
|
if (name == 0)
|
if (name == 0)
|
error (
|
error (
|
"To open a MIPS remote debugging connection, you need to specify what serial\n\
|
"To open a MIPS remote debugging connection, you need to specify what serial\n\
|
device is attached to the target board (e.g., /dev/ttya).\n"
|
device is attached to the target board (e.g., /dev/ttya).\n"
|
"If you want to use TFTP to download to the board, specify the name of a\n"
|
"If you want to use TFTP to download to the board, specify the name of a\n"
|
"temporary file to be used by GDB for downloads as the second argument.\n"
|
"temporary file to be used by GDB for downloads as the second argument.\n"
|
"This filename must be in the form host:filename, where host is the name\n"
|
"This filename must be in the form host:filename, where host is the name\n"
|
"of the host running the TFTP server, and the file must be readable by the\n"
|
"of the host running the TFTP server, and the file must be readable by the\n"
|
"world. If the local name of the temporary file differs from the name as\n"
|
"world. If the local name of the temporary file differs from the name as\n"
|
"seen from the board via TFTP, specify that name as the third parameter.\n");
|
"seen from the board via TFTP, specify that name as the third parameter.\n");
|
|
|
/* Parse the serial port name, the optional TFTP name, and the
|
/* Parse the serial port name, the optional TFTP name, and the
|
optional local TFTP name. */
|
optional local TFTP name. */
|
if ((argv = buildargv (name)) == NULL)
|
if ((argv = buildargv (name)) == NULL)
|
nomem (0);
|
nomem (0);
|
make_cleanup_freeargv (argv);
|
make_cleanup_freeargv (argv);
|
|
|
serial_port_name = strsave (argv[0]);
|
serial_port_name = strsave (argv[0]);
|
if (argv[1]) /* remote TFTP name specified? */
|
if (argv[1]) /* remote TFTP name specified? */
|
{
|
{
|
remote_name = argv[1];
|
remote_name = argv[1];
|
if (argv[2]) /* local TFTP filename specified? */
|
if (argv[2]) /* local TFTP filename specified? */
|
local_name = argv[2];
|
local_name = argv[2];
|
}
|
}
|
|
|
target_preopen (from_tty);
|
target_preopen (from_tty);
|
|
|
if (mips_is_open)
|
if (mips_is_open)
|
unpush_target (current_ops);
|
unpush_target (current_ops);
|
|
|
/* Open and initialize the serial port. */
|
/* Open and initialize the serial port. */
|
mips_desc = SERIAL_OPEN (serial_port_name);
|
mips_desc = SERIAL_OPEN (serial_port_name);
|
if (mips_desc == (serial_t) NULL)
|
if (mips_desc == (serial_t) NULL)
|
perror_with_name (serial_port_name);
|
perror_with_name (serial_port_name);
|
|
|
if (baud_rate != -1)
|
if (baud_rate != -1)
|
{
|
{
|
if (SERIAL_SETBAUDRATE (mips_desc, baud_rate))
|
if (SERIAL_SETBAUDRATE (mips_desc, baud_rate))
|
{
|
{
|
SERIAL_CLOSE (mips_desc);
|
SERIAL_CLOSE (mips_desc);
|
perror_with_name (serial_port_name);
|
perror_with_name (serial_port_name);
|
}
|
}
|
}
|
}
|
|
|
SERIAL_RAW (mips_desc);
|
SERIAL_RAW (mips_desc);
|
|
|
/* Open and initialize the optional download port. If it is in the form
|
/* Open and initialize the optional download port. If it is in the form
|
hostname#portnumber, it's a UDP socket. If it is in the form
|
hostname#portnumber, it's a UDP socket. If it is in the form
|
hostname:filename, assume it's the TFTP filename that must be
|
hostname:filename, assume it's the TFTP filename that must be
|
passed to the DDB board to tell it where to get the load file. */
|
passed to the DDB board to tell it where to get the load file. */
|
if (remote_name)
|
if (remote_name)
|
{
|
{
|
if (strchr (remote_name, '#'))
|
if (strchr (remote_name, '#'))
|
{
|
{
|
udp_desc = SERIAL_OPEN (remote_name);
|
udp_desc = SERIAL_OPEN (remote_name);
|
if (!udp_desc)
|
if (!udp_desc)
|
perror_with_name ("Unable to open UDP port");
|
perror_with_name ("Unable to open UDP port");
|
udp_in_use = 1;
|
udp_in_use = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Save the remote and local names of the TFTP temp file. If
|
/* Save the remote and local names of the TFTP temp file. If
|
the user didn't specify a local name, assume it's the same
|
the user didn't specify a local name, assume it's the same
|
as the part of the remote name after the "host:". */
|
as the part of the remote name after the "host:". */
|
if (tftp_name)
|
if (tftp_name)
|
free (tftp_name);
|
free (tftp_name);
|
if (tftp_localname)
|
if (tftp_localname)
|
free (tftp_localname);
|
free (tftp_localname);
|
if (local_name == NULL)
|
if (local_name == NULL)
|
if ((local_name = strchr (remote_name, ':')) != NULL)
|
if ((local_name = strchr (remote_name, ':')) != NULL)
|
local_name++; /* skip over the colon */
|
local_name++; /* skip over the colon */
|
if (local_name == NULL)
|
if (local_name == NULL)
|
local_name = remote_name; /* local name same as remote name */
|
local_name = remote_name; /* local name same as remote name */
|
tftp_name = strsave (remote_name);
|
tftp_name = strsave (remote_name);
|
tftp_localname = strsave (local_name);
|
tftp_localname = strsave (local_name);
|
tftp_in_use = 1;
|
tftp_in_use = 1;
|
}
|
}
|
}
|
}
|
|
|
current_ops = ops;
|
current_ops = ops;
|
mips_is_open = 1;
|
mips_is_open = 1;
|
|
|
/* Reset the expected monitor prompt if it's never been set before. */
|
/* Reset the expected monitor prompt if it's never been set before. */
|
if (mips_monitor_prompt == NULL)
|
if (mips_monitor_prompt == NULL)
|
mips_monitor_prompt = strsave (new_monitor_prompt);
|
mips_monitor_prompt = strsave (new_monitor_prompt);
|
mips_monitor = new_monitor;
|
mips_monitor = new_monitor;
|
|
|
mips_initialize ();
|
mips_initialize ();
|
|
|
if (from_tty)
|
if (from_tty)
|
printf_unfiltered ("Remote MIPS debugging using %s\n", serial_port_name);
|
printf_unfiltered ("Remote MIPS debugging using %s\n", serial_port_name);
|
|
|
/* Switch to using remote target now. */
|
/* Switch to using remote target now. */
|
push_target (ops);
|
push_target (ops);
|
|
|
/* FIXME: Should we call start_remote here? */
|
/* FIXME: Should we call start_remote here? */
|
|
|
/* Try to figure out the processor model if possible. */
|
/* Try to figure out the processor model if possible. */
|
ptype = mips_read_processor_type ();
|
ptype = mips_read_processor_type ();
|
if (ptype)
|
if (ptype)
|
mips_set_processor_type_command (strsave (ptype), 0);
|
mips_set_processor_type_command (strsave (ptype), 0);
|
|
|
/* This is really the job of start_remote however, that makes an assumption
|
/* This is really the job of start_remote however, that makes an assumption
|
that the target is about to print out a status message of some sort. That
|
that the target is about to print out a status message of some sort. That
|
doesn't happen here (in fact, it may not be possible to get the monitor to
|
doesn't happen here (in fact, it may not be possible to get the monitor to
|
send the appropriate packet). */
|
send the appropriate packet). */
|
|
|
flush_cached_frames ();
|
flush_cached_frames ();
|
registers_changed ();
|
registers_changed ();
|
stop_pc = read_pc ();
|
stop_pc = read_pc ();
|
set_current_frame (create_new_frame (read_fp (), stop_pc));
|
set_current_frame (create_new_frame (read_fp (), stop_pc));
|
select_frame (get_current_frame (), 0);
|
select_frame (get_current_frame (), 0);
|
print_stack_frame (selected_frame, -1, 1);
|
print_stack_frame (selected_frame, -1, 1);
|
free (serial_port_name);
|
free (serial_port_name);
|
}
|
}
|
|
|
static void
|
static void
|
mips_open (name, from_tty)
|
mips_open (name, from_tty)
|
char *name;
|
char *name;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
common_open (&mips_ops, name, from_tty, MON_IDT, TARGET_MONITOR_PROMPT);
|
common_open (&mips_ops, name, from_tty, MON_IDT, TARGET_MONITOR_PROMPT);
|
}
|
}
|
|
|
static void
|
static void
|
pmon_open (name, from_tty)
|
pmon_open (name, from_tty)
|
char *name;
|
char *name;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
common_open (&pmon_ops, name, from_tty, MON_PMON, "PMON> ");
|
common_open (&pmon_ops, name, from_tty, MON_PMON, "PMON> ");
|
}
|
}
|
|
|
static void
|
static void
|
ddb_open (name, from_tty)
|
ddb_open (name, from_tty)
|
char *name;
|
char *name;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
common_open (&ddb_ops, name, from_tty, MON_DDB, "NEC010>");
|
common_open (&ddb_ops, name, from_tty, MON_DDB, "NEC010>");
|
}
|
}
|
|
|
static void
|
static void
|
lsi_open (name, from_tty)
|
lsi_open (name, from_tty)
|
char *name;
|
char *name;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
int i;
|
int i;
|
|
|
/* Clear the LSI breakpoint table. */
|
/* Clear the LSI breakpoint table. */
|
for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
|
for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
|
lsi_breakpoints[i].type = BREAK_UNUSED;
|
lsi_breakpoints[i].type = BREAK_UNUSED;
|
|
|
common_open (&lsi_ops, name, from_tty, MON_LSI, "PMON> ");
|
common_open (&lsi_ops, name, from_tty, MON_LSI, "PMON> ");
|
}
|
}
|
|
|
/* Close a connection to the remote board. */
|
/* Close a connection to the remote board. */
|
|
|
static void
|
static void
|
mips_close (quitting)
|
mips_close (quitting)
|
int quitting;
|
int quitting;
|
{
|
{
|
if (mips_is_open)
|
if (mips_is_open)
|
{
|
{
|
/* Get the board out of remote debugging mode. */
|
/* Get the board out of remote debugging mode. */
|
(void) mips_exit_debug ();
|
(void) mips_exit_debug ();
|
|
|
close_ports ();
|
close_ports ();
|
}
|
}
|
}
|
}
|
|
|
/* Detach from the remote board. */
|
/* Detach from the remote board. */
|
|
|
static void
|
static void
|
mips_detach (args, from_tty)
|
mips_detach (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
if (args)
|
if (args)
|
error ("Argument given to \"detach\" when remotely debugging.");
|
error ("Argument given to \"detach\" when remotely debugging.");
|
|
|
pop_target ();
|
pop_target ();
|
|
|
mips_close (1);
|
mips_close (1);
|
|
|
if (from_tty)
|
if (from_tty)
|
printf_unfiltered ("Ending remote MIPS debugging.\n");
|
printf_unfiltered ("Ending remote MIPS debugging.\n");
|
}
|
}
|
|
|
/* Tell the target board to resume. This does not wait for a reply
|
/* Tell the target board to resume. This does not wait for a reply
|
from the board, except in the case of single-stepping on LSI boards,
|
from the board, except in the case of single-stepping on LSI boards,
|
where PMON does return a reply. */
|
where PMON does return a reply. */
|
|
|
static void
|
static void
|
mips_resume (pid, step, siggnal)
|
mips_resume (pid, step, siggnal)
|
int pid, step;
|
int pid, step;
|
enum target_signal siggnal;
|
enum target_signal siggnal;
|
{
|
{
|
int err;
|
int err;
|
|
|
/* LSI PMON requires returns a reply packet "0x1 s 0x0 0x57f" after
|
/* LSI PMON requires returns a reply packet "0x1 s 0x0 0x57f" after
|
a single step, so we wait for that. */
|
a single step, so we wait for that. */
|
mips_request (step ? 's' : 'c',
|
mips_request (step ? 's' : 'c',
|
(unsigned int) 1,
|
(unsigned int) 1,
|
(unsigned int) siggnal,
|
(unsigned int) siggnal,
|
mips_monitor == MON_LSI && step ? &err : (int *) NULL,
|
mips_monitor == MON_LSI && step ? &err : (int *) NULL,
|
mips_receive_wait, NULL);
|
mips_receive_wait, NULL);
|
}
|
}
|
|
|
/* Return the signal corresponding to SIG, where SIG is the number which
|
/* Return the signal corresponding to SIG, where SIG is the number which
|
the MIPS protocol uses for the signal. */
|
the MIPS protocol uses for the signal. */
|
enum target_signal
|
enum target_signal
|
mips_signal_from_protocol (sig)
|
mips_signal_from_protocol (sig)
|
int sig;
|
int sig;
|
{
|
{
|
/* We allow a few more signals than the IDT board actually returns, on
|
/* We allow a few more signals than the IDT board actually returns, on
|
the theory that there is at least *some* hope that perhaps the numbering
|
the theory that there is at least *some* hope that perhaps the numbering
|
for these signals is widely agreed upon. */
|
for these signals is widely agreed upon. */
|
if (sig <= 0
|
if (sig <= 0
|
|| sig > 31)
|
|| sig > 31)
|
return TARGET_SIGNAL_UNKNOWN;
|
return TARGET_SIGNAL_UNKNOWN;
|
|
|
/* Don't want to use target_signal_from_host because we are converting
|
/* Don't want to use target_signal_from_host because we are converting
|
from MIPS signal numbers, not host ones. Our internal numbers
|
from MIPS signal numbers, not host ones. Our internal numbers
|
match the MIPS numbers for the signals the board can return, which
|
match the MIPS numbers for the signals the board can return, which
|
are: SIGINT, SIGSEGV, SIGBUS, SIGILL, SIGFPE, SIGTRAP. */
|
are: SIGINT, SIGSEGV, SIGBUS, SIGILL, SIGFPE, SIGTRAP. */
|
return (enum target_signal) sig;
|
return (enum target_signal) sig;
|
}
|
}
|
|
|
/* Wait until the remote stops, and return a wait status. */
|
/* Wait until the remote stops, and return a wait status. */
|
|
|
static int
|
static int
|
mips_wait (pid, status)
|
mips_wait (pid, status)
|
int pid;
|
int pid;
|
struct target_waitstatus *status;
|
struct target_waitstatus *status;
|
{
|
{
|
int rstatus;
|
int rstatus;
|
int err;
|
int err;
|
char buff[DATA_MAXLEN];
|
char buff[DATA_MAXLEN];
|
int rpc, rfp, rsp;
|
int rpc, rfp, rsp;
|
char flags[20];
|
char flags[20];
|
int nfields;
|
int nfields;
|
int i;
|
int i;
|
|
|
interrupt_count = 0;
|
interrupt_count = 0;
|
hit_watchpoint = 0;
|
hit_watchpoint = 0;
|
|
|
/* If we have not sent a single step or continue command, then the
|
/* If we have not sent a single step or continue command, then the
|
board is waiting for us to do something. Return a status
|
board is waiting for us to do something. Return a status
|
indicating that it is stopped. */
|
indicating that it is stopped. */
|
if (!mips_need_reply)
|
if (!mips_need_reply)
|
{
|
{
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* No timeout; we sit here as long as the program continues to execute. */
|
/* No timeout; we sit here as long as the program continues to execute. */
|
mips_wait_flag = 1;
|
mips_wait_flag = 1;
|
rstatus = mips_request ('\000', (unsigned int) 0, (unsigned int) 0, &err, -1,
|
rstatus = mips_request ('\000', (unsigned int) 0, (unsigned int) 0, &err, -1,
|
buff);
|
buff);
|
mips_wait_flag = 0;
|
mips_wait_flag = 0;
|
if (err)
|
if (err)
|
mips_error ("Remote failure: %s", safe_strerror (errno));
|
mips_error ("Remote failure: %s", safe_strerror (errno));
|
|
|
/* On returning from a continue, the PMON monitor seems to start
|
/* On returning from a continue, the PMON monitor seems to start
|
echoing back the messages we send prior to sending back the
|
echoing back the messages we send prior to sending back the
|
ACK. The code can cope with this, but to try and avoid the
|
ACK. The code can cope with this, but to try and avoid the
|
unnecessary serial traffic, and "spurious" characters displayed
|
unnecessary serial traffic, and "spurious" characters displayed
|
to the user, we cheat and reset the debug protocol. The problems
|
to the user, we cheat and reset the debug protocol. The problems
|
seems to be caused by a check on the number of arguments, and the
|
seems to be caused by a check on the number of arguments, and the
|
command length, within the monitor causing it to echo the command
|
command length, within the monitor causing it to echo the command
|
as a bad packet. */
|
as a bad packet. */
|
if (mips_monitor == MON_PMON)
|
if (mips_monitor == MON_PMON)
|
{
|
{
|
mips_exit_debug ();
|
mips_exit_debug ();
|
mips_enter_debug ();
|
mips_enter_debug ();
|
}
|
}
|
|
|
/* See if we got back extended status. If so, pick out the pc, fp, sp, etc... */
|
/* See if we got back extended status. If so, pick out the pc, fp, sp, etc... */
|
|
|
nfields = sscanf (buff, "0x%*x %*c 0x%*x 0x%*x 0x%x 0x%x 0x%x 0x%*x %s",
|
nfields = sscanf (buff, "0x%*x %*c 0x%*x 0x%*x 0x%x 0x%x 0x%x 0x%*x %s",
|
&rpc, &rfp, &rsp, flags);
|
&rpc, &rfp, &rsp, flags);
|
if (nfields >= 3)
|
if (nfields >= 3)
|
{
|
{
|
char buf[MAX_REGISTER_RAW_SIZE];
|
char buf[MAX_REGISTER_RAW_SIZE];
|
|
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc);
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc);
|
supply_register (PC_REGNUM, buf);
|
supply_register (PC_REGNUM, buf);
|
|
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rfp);
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rfp);
|
supply_register (30, buf); /* This register they are avoiding and so it is unnamed */
|
supply_register (30, buf); /* This register they are avoiding and so it is unnamed */
|
|
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (SP_REGNUM), rsp);
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (SP_REGNUM), rsp);
|
supply_register (SP_REGNUM, buf);
|
supply_register (SP_REGNUM, buf);
|
|
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (FP_REGNUM), 0);
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (FP_REGNUM), 0);
|
supply_register (FP_REGNUM, buf);
|
supply_register (FP_REGNUM, buf);
|
|
|
if (nfields == 9)
|
if (nfields == 9)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i <= 2; i++)
|
for (i = 0; i <= 2; i++)
|
if (flags[i] == 'r' || flags[i] == 'w')
|
if (flags[i] == 'r' || flags[i] == 'w')
|
hit_watchpoint = 1;
|
hit_watchpoint = 1;
|
else if (flags[i] == '\000')
|
else if (flags[i] == '\000')
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (strcmp (target_shortname, "lsi") == 0)
|
if (strcmp (target_shortname, "lsi") == 0)
|
{
|
{
|
#if 0
|
#if 0
|
/* If this is an LSI PMON target, see if we just hit a hardrdware watchpoint.
|
/* If this is an LSI PMON target, see if we just hit a hardrdware watchpoint.
|
Right now, PMON doesn't give us enough information to determine which
|
Right now, PMON doesn't give us enough information to determine which
|
breakpoint we hit. So we have to look up the PC in our own table
|
breakpoint we hit. So we have to look up the PC in our own table
|
of breakpoints, and if found, assume it's just a normal instruction
|
of breakpoints, and if found, assume it's just a normal instruction
|
fetch breakpoint, not a data watchpoint. FIXME when PMON
|
fetch breakpoint, not a data watchpoint. FIXME when PMON
|
provides some way to tell us what type of breakpoint it is. */
|
provides some way to tell us what type of breakpoint it is. */
|
int i;
|
int i;
|
CORE_ADDR pc = read_pc ();
|
CORE_ADDR pc = read_pc ();
|
|
|
hit_watchpoint = 1;
|
hit_watchpoint = 1;
|
for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
|
for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
|
{
|
{
|
if (lsi_breakpoints[i].addr == pc
|
if (lsi_breakpoints[i].addr == pc
|
&& lsi_breakpoints[i].type == BREAK_FETCH)
|
&& lsi_breakpoints[i].type == BREAK_FETCH)
|
{
|
{
|
hit_watchpoint = 0;
|
hit_watchpoint = 0;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
#else
|
#else
|
/* If a data breakpoint was hit, PMON returns the following packet:
|
/* If a data breakpoint was hit, PMON returns the following packet:
|
0x1 c 0x0 0x57f 0x1
|
0x1 c 0x0 0x57f 0x1
|
The return packet from an ordinary breakpoint doesn't have the
|
The return packet from an ordinary breakpoint doesn't have the
|
extra 0x01 field tacked onto the end. */
|
extra 0x01 field tacked onto the end. */
|
if (nfields == 1 && rpc == 1)
|
if (nfields == 1 && rpc == 1)
|
hit_watchpoint = 1;
|
hit_watchpoint = 1;
|
#endif
|
#endif
|
}
|
}
|
|
|
/* NOTE: The following (sig) numbers are defined by PMON:
|
/* NOTE: The following (sig) numbers are defined by PMON:
|
SPP_SIGTRAP 5 breakpoint
|
SPP_SIGTRAP 5 breakpoint
|
SPP_SIGINT 2
|
SPP_SIGINT 2
|
SPP_SIGSEGV 11
|
SPP_SIGSEGV 11
|
SPP_SIGBUS 10
|
SPP_SIGBUS 10
|
SPP_SIGILL 4
|
SPP_SIGILL 4
|
SPP_SIGFPE 8
|
SPP_SIGFPE 8
|
SPP_SIGTERM 15 */
|
SPP_SIGTERM 15 */
|
|
|
/* Translate a MIPS waitstatus. We use constants here rather than WTERMSIG
|
/* Translate a MIPS waitstatus. We use constants here rather than WTERMSIG
|
and so on, because the constants we want here are determined by the
|
and so on, because the constants we want here are determined by the
|
MIPS protocol and have nothing to do with what host we are running on. */
|
MIPS protocol and have nothing to do with what host we are running on. */
|
if ((rstatus & 0xff) == 0)
|
if ((rstatus & 0xff) == 0)
|
{
|
{
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->value.integer = (((rstatus) >> 8) & 0xff);
|
status->value.integer = (((rstatus) >> 8) & 0xff);
|
}
|
}
|
else if ((rstatus & 0xff) == 0x7f)
|
else if ((rstatus & 0xff) == 0x7f)
|
{
|
{
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->value.sig = mips_signal_from_protocol (((rstatus) >> 8) & 0xff);
|
status->value.sig = mips_signal_from_protocol (((rstatus) >> 8) & 0xff);
|
|
|
/* If the stop PC is in the _exit function, assume
|
/* If the stop PC is in the _exit function, assume
|
we hit the 'break 0x3ff' instruction in _exit, so this
|
we hit the 'break 0x3ff' instruction in _exit, so this
|
is not a normal breakpoint. */
|
is not a normal breakpoint. */
|
if (strcmp (target_shortname, "lsi") == 0)
|
if (strcmp (target_shortname, "lsi") == 0)
|
{
|
{
|
char *func_name;
|
char *func_name;
|
CORE_ADDR func_start;
|
CORE_ADDR func_start;
|
CORE_ADDR pc = read_pc ();
|
CORE_ADDR pc = read_pc ();
|
|
|
find_pc_partial_function (pc, &func_name, &func_start, NULL);
|
find_pc_partial_function (pc, &func_name, &func_start, NULL);
|
if (func_name != NULL && strcmp (func_name, "_exit") == 0
|
if (func_name != NULL && strcmp (func_name, "_exit") == 0
|
&& func_start == pc)
|
&& func_start == pc)
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->kind = TARGET_WAITKIND_EXITED;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
status->kind = TARGET_WAITKIND_SIGNALLED;
|
status->kind = TARGET_WAITKIND_SIGNALLED;
|
status->value.sig = mips_signal_from_protocol (rstatus & 0x7f);
|
status->value.sig = mips_signal_from_protocol (rstatus & 0x7f);
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* We have to map between the register numbers used by gdb and the
|
/* We have to map between the register numbers used by gdb and the
|
register numbers used by the debugging protocol. This function
|
register numbers used by the debugging protocol. This function
|
assumes that we are using tm-mips.h. */
|
assumes that we are using tm-mips.h. */
|
|
|
#define REGNO_OFFSET 96
|
#define REGNO_OFFSET 96
|
|
|
static int
|
static int
|
mips_map_regno (regno)
|
mips_map_regno (regno)
|
int regno;
|
int regno;
|
{
|
{
|
if (regno < 32)
|
if (regno < 32)
|
return regno;
|
return regno;
|
if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
|
if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
|
return regno - FP0_REGNUM + 32;
|
return regno - FP0_REGNUM + 32;
|
switch (regno)
|
switch (regno)
|
{
|
{
|
case PC_REGNUM:
|
case PC_REGNUM:
|
return REGNO_OFFSET + 0;
|
return REGNO_OFFSET + 0;
|
case CAUSE_REGNUM:
|
case CAUSE_REGNUM:
|
return REGNO_OFFSET + 1;
|
return REGNO_OFFSET + 1;
|
case HI_REGNUM:
|
case HI_REGNUM:
|
return REGNO_OFFSET + 2;
|
return REGNO_OFFSET + 2;
|
case LO_REGNUM:
|
case LO_REGNUM:
|
return REGNO_OFFSET + 3;
|
return REGNO_OFFSET + 3;
|
case FCRCS_REGNUM:
|
case FCRCS_REGNUM:
|
return REGNO_OFFSET + 4;
|
return REGNO_OFFSET + 4;
|
case FCRIR_REGNUM:
|
case FCRIR_REGNUM:
|
return REGNO_OFFSET + 5;
|
return REGNO_OFFSET + 5;
|
default:
|
default:
|
/* FIXME: Is there a way to get the status register? */
|
/* FIXME: Is there a way to get the status register? */
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* Fetch the remote registers. */
|
/* Fetch the remote registers. */
|
|
|
static void
|
static void
|
mips_fetch_registers (regno)
|
mips_fetch_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
unsigned LONGEST val;
|
unsigned LONGEST val;
|
int err;
|
int err;
|
|
|
if (regno == -1)
|
if (regno == -1)
|
{
|
{
|
for (regno = 0; regno < NUM_REGS; regno++)
|
for (regno = 0; regno < NUM_REGS; regno++)
|
mips_fetch_registers (regno);
|
mips_fetch_registers (regno);
|
return;
|
return;
|
}
|
}
|
|
|
if (regno == FP_REGNUM || regno == ZERO_REGNUM)
|
if (regno == FP_REGNUM || regno == ZERO_REGNUM)
|
/* FP_REGNUM on the mips is a hack which is just supposed to read
|
/* FP_REGNUM on the mips is a hack which is just supposed to read
|
zero (see also mips-nat.c). */
|
zero (see also mips-nat.c). */
|
val = 0;
|
val = 0;
|
else
|
else
|
{
|
{
|
/* If PMON doesn't support this register, don't waste serial
|
/* If PMON doesn't support this register, don't waste serial
|
bandwidth trying to read it. */
|
bandwidth trying to read it. */
|
int pmon_reg = mips_map_regno (regno);
|
int pmon_reg = mips_map_regno (regno);
|
if (regno != 0 && pmon_reg == 0)
|
if (regno != 0 && pmon_reg == 0)
|
val = 0;
|
val = 0;
|
else
|
else
|
{
|
{
|
/* Unfortunately the PMON version in the Vr4300 board has been
|
/* Unfortunately the PMON version in the Vr4300 board has been
|
compiled without the 64bit register access commands. This
|
compiled without the 64bit register access commands. This
|
means we cannot get hold of the full register width. */
|
means we cannot get hold of the full register width. */
|
if (mips_monitor == MON_DDB)
|
if (mips_monitor == MON_DDB)
|
val = (unsigned) mips_request ('t', (unsigned int) pmon_reg,
|
val = (unsigned) mips_request ('t', (unsigned int) pmon_reg,
|
(unsigned int) 0, &err, mips_receive_wait, NULL);
|
(unsigned int) 0, &err, mips_receive_wait, NULL);
|
else
|
else
|
val = mips_request ('r', (unsigned int) pmon_reg,
|
val = mips_request ('r', (unsigned int) pmon_reg,
|
(unsigned int) 0, &err, mips_receive_wait, NULL);
|
(unsigned int) 0, &err, mips_receive_wait, NULL);
|
if (err)
|
if (err)
|
mips_error ("Can't read register %d: %s", regno,
|
mips_error ("Can't read register %d: %s", regno,
|
safe_strerror (errno));
|
safe_strerror (errno));
|
}
|
}
|
}
|
}
|
|
|
{
|
{
|
char buf[MAX_REGISTER_RAW_SIZE];
|
char buf[MAX_REGISTER_RAW_SIZE];
|
|
|
/* We got the number the register holds, but gdb expects to see a
|
/* We got the number the register holds, but gdb expects to see a
|
value in the target byte ordering. */
|
value in the target byte ordering. */
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (regno), val);
|
store_unsigned_integer (buf, REGISTER_RAW_SIZE (regno), val);
|
supply_register (regno, buf);
|
supply_register (regno, buf);
|
}
|
}
|
}
|
}
|
|
|
/* Prepare to store registers. The MIPS protocol can store individual
|
/* Prepare to store registers. The MIPS protocol can store individual
|
registers, so this function doesn't have to do anything. */
|
registers, so this function doesn't have to do anything. */
|
|
|
static void
|
static void
|
mips_prepare_to_store ()
|
mips_prepare_to_store ()
|
{
|
{
|
}
|
}
|
|
|
/* Store remote register(s). */
|
/* Store remote register(s). */
|
|
|
static void
|
static void
|
mips_store_registers (regno)
|
mips_store_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
int err;
|
int err;
|
|
|
if (regno == -1)
|
if (regno == -1)
|
{
|
{
|
for (regno = 0; regno < NUM_REGS; regno++)
|
for (regno = 0; regno < NUM_REGS; regno++)
|
mips_store_registers (regno);
|
mips_store_registers (regno);
|
return;
|
return;
|
}
|
}
|
|
|
mips_request ('R', (unsigned int) mips_map_regno (regno),
|
mips_request ('R', (unsigned int) mips_map_regno (regno),
|
read_register (regno),
|
read_register (regno),
|
&err, mips_receive_wait, NULL);
|
&err, mips_receive_wait, NULL);
|
if (err)
|
if (err)
|
mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));
|
mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));
|
}
|
}
|
|
|
/* Fetch a word from the target board. */
|
/* Fetch a word from the target board. */
|
|
|
static unsigned int
|
static unsigned int
|
mips_fetch_word (addr)
|
mips_fetch_word (addr)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
{
|
{
|
unsigned int val;
|
unsigned int val;
|
int err;
|
int err;
|
|
|
/* FIXME! addr was cast to uint! */
|
/* FIXME! addr was cast to uint! */
|
val = mips_request ('d', addr, (unsigned int) 0, &err,
|
val = mips_request ('d', addr, (unsigned int) 0, &err,
|
mips_receive_wait, NULL);
|
mips_receive_wait, NULL);
|
if (err)
|
if (err)
|
{
|
{
|
/* Data space failed; try instruction space. */
|
/* Data space failed; try instruction space. */
|
/* FIXME! addr was cast to uint! */
|
/* FIXME! addr was cast to uint! */
|
val = mips_request ('i', addr, (unsigned int) 0, &err,
|
val = mips_request ('i', addr, (unsigned int) 0, &err,
|
mips_receive_wait, NULL);
|
mips_receive_wait, NULL);
|
if (err)
|
if (err)
|
mips_error ("Can't read address 0x%s: %s",
|
mips_error ("Can't read address 0x%s: %s",
|
paddr_nz (addr), safe_strerror (errno));
|
paddr_nz (addr), safe_strerror (errno));
|
}
|
}
|
return val;
|
return val;
|
}
|
}
|
|
|
/* Store a word to the target board. Returns errno code or zero for
|
/* Store a word to the target board. Returns errno code or zero for
|
success. If OLD_CONTENTS is non-NULL, put the old contents of that
|
success. If OLD_CONTENTS is non-NULL, put the old contents of that
|
memory location there. */
|
memory location there. */
|
|
|
/* FIXME! make sure only 32-bit quantities get stored! */
|
/* FIXME! make sure only 32-bit quantities get stored! */
|
static int
|
static int
|
mips_store_word (addr, val, old_contents)
|
mips_store_word (addr, val, old_contents)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
unsigned int val;
|
unsigned int val;
|
char *old_contents;
|
char *old_contents;
|
{
|
{
|
int err;
|
int err;
|
unsigned int oldcontents;
|
unsigned int oldcontents;
|
|
|
oldcontents = mips_request ('D', addr, (unsigned int) val,
|
oldcontents = mips_request ('D', addr, (unsigned int) val,
|
&err,
|
&err,
|
mips_receive_wait, NULL);
|
mips_receive_wait, NULL);
|
if (err)
|
if (err)
|
{
|
{
|
/* Data space failed; try instruction space. */
|
/* Data space failed; try instruction space. */
|
oldcontents = mips_request ('I', addr,
|
oldcontents = mips_request ('I', addr,
|
(unsigned int) val, &err,
|
(unsigned int) val, &err,
|
mips_receive_wait, NULL);
|
mips_receive_wait, NULL);
|
if (err)
|
if (err)
|
return errno;
|
return errno;
|
}
|
}
|
if (old_contents != NULL)
|
if (old_contents != NULL)
|
store_unsigned_integer (old_contents, 4, oldcontents);
|
store_unsigned_integer (old_contents, 4, oldcontents);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Read or write LEN bytes from inferior memory at MEMADDR,
|
/* Read or write LEN bytes from inferior memory at MEMADDR,
|
transferring to or from debugger address MYADDR. Write to inferior
|
transferring to or from debugger address MYADDR. Write to inferior
|
if SHOULD_WRITE is nonzero. Returns length of data written or
|
if SHOULD_WRITE is nonzero. Returns length of data written or
|
read; 0 for error. Note that protocol gives us the correct value
|
read; 0 for error. Note that protocol gives us the correct value
|
for a longword, since it transfers values in ASCII. We want the
|
for a longword, since it transfers values in ASCII. We want the
|
byte values, so we have to swap the longword values. */
|
byte values, so we have to swap the longword values. */
|
|
|
static int
|
static int
|
mips_xfer_memory (memaddr, myaddr, len, write, ignore)
|
mips_xfer_memory (memaddr, myaddr, len, write, ignore)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
int write;
|
int write;
|
struct target_ops *ignore;
|
struct target_ops *ignore;
|
{
|
{
|
register int i;
|
register int i;
|
/* Round starting address down to longword boundary. */
|
/* Round starting address down to longword boundary. */
|
register CORE_ADDR addr = memaddr & ~3;
|
register CORE_ADDR addr = memaddr & ~3;
|
/* Round ending address up; get number of longwords that makes. */
|
/* Round ending address up; get number of longwords that makes. */
|
register int count = (((memaddr + len) - addr) + 3) / 4;
|
register int count = (((memaddr + len) - addr) + 3) / 4;
|
/* Allocate buffer of that many longwords. */
|
/* Allocate buffer of that many longwords. */
|
register char *buffer = alloca (count * 4);
|
register char *buffer = alloca (count * 4);
|
|
|
int status;
|
int status;
|
|
|
if (write)
|
if (write)
|
{
|
{
|
/* Fill start and end extra bytes of buffer with existing data. */
|
/* Fill start and end extra bytes of buffer with existing data. */
|
if (addr != memaddr || len < 4)
|
if (addr != memaddr || len < 4)
|
{
|
{
|
/* Need part of initial word -- fetch it. */
|
/* Need part of initial word -- fetch it. */
|
store_unsigned_integer (&buffer[0], 4, mips_fetch_word (addr));
|
store_unsigned_integer (&buffer[0], 4, mips_fetch_word (addr));
|
}
|
}
|
|
|
if (count > 1)
|
if (count > 1)
|
{
|
{
|
/* Need part of last word -- fetch it. FIXME: we do this even
|
/* Need part of last word -- fetch it. FIXME: we do this even
|
if we don't need it. */
|
if we don't need it. */
|
store_unsigned_integer (&buffer[(count - 1) * 4], 4,
|
store_unsigned_integer (&buffer[(count - 1) * 4], 4,
|
mips_fetch_word (addr + (count - 1) * 4));
|
mips_fetch_word (addr + (count - 1) * 4));
|
}
|
}
|
|
|
/* Copy data to be written over corresponding part of buffer */
|
/* Copy data to be written over corresponding part of buffer */
|
|
|
memcpy ((char *) buffer + (memaddr & 3), myaddr, len);
|
memcpy ((char *) buffer + (memaddr & 3), myaddr, len);
|
|
|
/* Write the entire buffer. */
|
/* Write the entire buffer. */
|
|
|
for (i = 0; i < count; i++, addr += 4)
|
for (i = 0; i < count; i++, addr += 4)
|
{
|
{
|
status = mips_store_word (addr,
|
status = mips_store_word (addr,
|
extract_unsigned_integer (&buffer[i * 4], 4),
|
extract_unsigned_integer (&buffer[i * 4], 4),
|
NULL);
|
NULL);
|
/* Report each kilobyte (we download 32-bit words at a time) */
|
/* Report each kilobyte (we download 32-bit words at a time) */
|
if (i % 256 == 255)
|
if (i % 256 == 255)
|
{
|
{
|
printf_unfiltered ("*");
|
printf_unfiltered ("*");
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
if (status)
|
if (status)
|
{
|
{
|
errno = status;
|
errno = status;
|
return 0;
|
return 0;
|
}
|
}
|
/* FIXME: Do we want a QUIT here? */
|
/* FIXME: Do we want a QUIT here? */
|
}
|
}
|
if (count >= 256)
|
if (count >= 256)
|
printf_unfiltered ("\n");
|
printf_unfiltered ("\n");
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Read all the longwords */
|
/* Read all the longwords */
|
for (i = 0; i < count; i++, addr += 4)
|
for (i = 0; i < count; i++, addr += 4)
|
{
|
{
|
store_unsigned_integer (&buffer[i * 4], 4, mips_fetch_word (addr));
|
store_unsigned_integer (&buffer[i * 4], 4, mips_fetch_word (addr));
|
QUIT;
|
QUIT;
|
}
|
}
|
|
|
/* Copy appropriate bytes out of the buffer. */
|
/* Copy appropriate bytes out of the buffer. */
|
memcpy (myaddr, buffer + (memaddr & 3), len);
|
memcpy (myaddr, buffer + (memaddr & 3), len);
|
}
|
}
|
return len;
|
return len;
|
}
|
}
|
|
|
/* Print info on this target. */
|
/* Print info on this target. */
|
|
|
static void
|
static void
|
mips_files_info (ignore)
|
mips_files_info (ignore)
|
struct target_ops *ignore;
|
struct target_ops *ignore;
|
{
|
{
|
printf_unfiltered ("Debugging a MIPS board over a serial line.\n");
|
printf_unfiltered ("Debugging a MIPS board over a serial line.\n");
|
}
|
}
|
|
|
/* Kill the process running on the board. This will actually only
|
/* Kill the process running on the board. This will actually only
|
work if we are doing remote debugging over the console input. I
|
work if we are doing remote debugging over the console input. I
|
think that if IDT/sim had the remote debug interrupt enabled on the
|
think that if IDT/sim had the remote debug interrupt enabled on the
|
right port, we could interrupt the process with a break signal. */
|
right port, we could interrupt the process with a break signal. */
|
|
|
static void
|
static void
|
mips_kill ()
|
mips_kill ()
|
{
|
{
|
if (!mips_wait_flag)
|
if (!mips_wait_flag)
|
return;
|
return;
|
|
|
interrupt_count++;
|
interrupt_count++;
|
|
|
if (interrupt_count >= 2)
|
if (interrupt_count >= 2)
|
{
|
{
|
interrupt_count = 0;
|
interrupt_count = 0;
|
|
|
target_terminal_ours ();
|
target_terminal_ours ();
|
|
|
if (query ("Interrupted while waiting for the program.\n\
|
if (query ("Interrupted while waiting for the program.\n\
|
Give up (and stop debugging it)? "))
|
Give up (and stop debugging it)? "))
|
{
|
{
|
/* Clean up in such a way that mips_close won't try to talk to the
|
/* Clean up in such a way that mips_close won't try to talk to the
|
board (it almost surely won't work since we weren't able to talk to
|
board (it almost surely won't work since we weren't able to talk to
|
it). */
|
it). */
|
mips_wait_flag = 0;
|
mips_wait_flag = 0;
|
close_ports ();
|
close_ports ();
|
|
|
printf_unfiltered ("Ending remote MIPS debugging.\n");
|
printf_unfiltered ("Ending remote MIPS debugging.\n");
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
|
|
return_to_top_level (RETURN_QUIT);
|
return_to_top_level (RETURN_QUIT);
|
}
|
}
|
|
|
target_terminal_inferior ();
|
target_terminal_inferior ();
|
}
|
}
|
|
|
if (remote_debug > 0)
|
if (remote_debug > 0)
|
printf_unfiltered ("Sending break\n");
|
printf_unfiltered ("Sending break\n");
|
|
|
SERIAL_SEND_BREAK (mips_desc);
|
SERIAL_SEND_BREAK (mips_desc);
|
|
|
#if 0
|
#if 0
|
if (mips_is_open)
|
if (mips_is_open)
|
{
|
{
|
char cc;
|
char cc;
|
|
|
/* Send a ^C. */
|
/* Send a ^C. */
|
cc = '\003';
|
cc = '\003';
|
SERIAL_WRITE (mips_desc, &cc, 1);
|
SERIAL_WRITE (mips_desc, &cc, 1);
|
sleep (1);
|
sleep (1);
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Start running on the target board. */
|
/* Start running on the target board. */
|
|
|
static void
|
static void
|
mips_create_inferior (execfile, args, env)
|
mips_create_inferior (execfile, args, env)
|
char *execfile;
|
char *execfile;
|
char *args;
|
char *args;
|
char **env;
|
char **env;
|
{
|
{
|
CORE_ADDR entry_pt;
|
CORE_ADDR entry_pt;
|
|
|
if (args && *args)
|
if (args && *args)
|
{
|
{
|
warning ("\
|
warning ("\
|
Can't pass arguments to remote MIPS board; arguments ignored.");
|
Can't pass arguments to remote MIPS board; arguments ignored.");
|
/* And don't try to use them on the next "run" command. */
|
/* And don't try to use them on the next "run" command. */
|
execute_command ("set args", 0);
|
execute_command ("set args", 0);
|
}
|
}
|
|
|
if (execfile == 0 || exec_bfd == 0)
|
if (execfile == 0 || exec_bfd == 0)
|
error ("No executable file specified");
|
error ("No executable file specified");
|
|
|
entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
|
entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
|
|
|
init_wait_for_inferior ();
|
init_wait_for_inferior ();
|
|
|
/* FIXME: Should we set inferior_pid here? */
|
/* FIXME: Should we set inferior_pid here? */
|
|
|
proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
|
proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
|
}
|
}
|
|
|
/* Clean up after a process. Actually nothing to do. */
|
/* Clean up after a process. Actually nothing to do. */
|
|
|
static void
|
static void
|
mips_mourn_inferior ()
|
mips_mourn_inferior ()
|
{
|
{
|
if (current_ops != NULL)
|
if (current_ops != NULL)
|
unpush_target (current_ops);
|
unpush_target (current_ops);
|
generic_mourn_inferior ();
|
generic_mourn_inferior ();
|
}
|
}
|
|
|
/* We can write a breakpoint and read the shadow contents in one
|
/* We can write a breakpoint and read the shadow contents in one
|
operation. */
|
operation. */
|
|
|
/* Insert a breakpoint. On targets that don't have built-in breakpoint
|
/* Insert a breakpoint. On targets that don't have built-in breakpoint
|
support, we read the contents of the target location and stash it,
|
support, we read the contents of the target location and stash it,
|
then overwrite it with a breakpoint instruction. ADDR is the target
|
then overwrite it with a breakpoint instruction. ADDR is the target
|
location in the target machine. CONTENTS_CACHE is a pointer to
|
location in the target machine. CONTENTS_CACHE is a pointer to
|
memory allocated for saving the target contents. It is guaranteed
|
memory allocated for saving the target contents. It is guaranteed
|
by the caller to be long enough to save sizeof BREAKPOINT bytes (this
|
by the caller to be long enough to save sizeof BREAKPOINT bytes (this
|
is accomplished via BREAKPOINT_MAX). */
|
is accomplished via BREAKPOINT_MAX). */
|
|
|
static int
|
static int
|
mips_insert_breakpoint (addr, contents_cache)
|
mips_insert_breakpoint (addr, contents_cache)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *contents_cache;
|
char *contents_cache;
|
{
|
{
|
if (monitor_supports_breakpoints)
|
if (monitor_supports_breakpoints)
|
return set_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
|
return set_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
|
else
|
else
|
return memory_insert_breakpoint (addr, contents_cache);
|
return memory_insert_breakpoint (addr, contents_cache);
|
}
|
}
|
|
|
static int
|
static int
|
mips_remove_breakpoint (addr, contents_cache)
|
mips_remove_breakpoint (addr, contents_cache)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *contents_cache;
|
char *contents_cache;
|
{
|
{
|
if (monitor_supports_breakpoints)
|
if (monitor_supports_breakpoints)
|
return clear_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
|
return clear_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
|
else
|
else
|
return memory_remove_breakpoint (addr, contents_cache);
|
return memory_remove_breakpoint (addr, contents_cache);
|
}
|
}
|
|
|
#if 0 /* currently not used */
|
#if 0 /* currently not used */
|
/* PMON does not currently provide support for the debug mode 'b'
|
/* PMON does not currently provide support for the debug mode 'b'
|
commands to manipulate breakpoints. However, if we wanted to use
|
commands to manipulate breakpoints. However, if we wanted to use
|
the monitor breakpoints (rather than the GDB BREAK_INSN version)
|
the monitor breakpoints (rather than the GDB BREAK_INSN version)
|
then this code performs the work needed to leave debug mode,
|
then this code performs the work needed to leave debug mode,
|
set/clear the breakpoint, and then return to debug mode. */
|
set/clear the breakpoint, and then return to debug mode. */
|
|
|
#define PMON_MAX_BP (33) /* 32 SW, 1 HW */
|
#define PMON_MAX_BP (33) /* 32 SW, 1 HW */
|
static CORE_ADDR mips_pmon_bp_info[PMON_MAX_BP];
|
static CORE_ADDR mips_pmon_bp_info[PMON_MAX_BP];
|
/* NOTE: The code relies on this vector being zero-initialised by the system */
|
/* NOTE: The code relies on this vector being zero-initialised by the system */
|
|
|
static int
|
static int
|
pmon_insert_breakpoint (addr, contents_cache)
|
pmon_insert_breakpoint (addr, contents_cache)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *contents_cache;
|
char *contents_cache;
|
{
|
{
|
int status;
|
int status;
|
|
|
if (monitor_supports_breakpoints)
|
if (monitor_supports_breakpoints)
|
{
|
{
|
char tbuff[12]; /* space for breakpoint command */
|
char tbuff[12]; /* space for breakpoint command */
|
int bpnum;
|
int bpnum;
|
CORE_ADDR bpaddr;
|
CORE_ADDR bpaddr;
|
|
|
/* PMON does not support debug level breakpoint set/remove: */
|
/* PMON does not support debug level breakpoint set/remove: */
|
if (mips_exit_debug ())
|
if (mips_exit_debug ())
|
mips_error ("Failed to exit debug mode");
|
mips_error ("Failed to exit debug mode");
|
|
|
sprintf (tbuff, "b %08x\r", addr);
|
sprintf (tbuff, "b %08x\r", addr);
|
mips_send_command (tbuff, 0);
|
mips_send_command (tbuff, 0);
|
|
|
mips_expect ("Bpt ");
|
mips_expect ("Bpt ");
|
|
|
if (!mips_getstring (tbuff, 2))
|
if (!mips_getstring (tbuff, 2))
|
return 1;
|
return 1;
|
tbuff[2] = '\0'; /* terminate the string */
|
tbuff[2] = '\0'; /* terminate the string */
|
if (sscanf (tbuff, "%d", &bpnum) != 1)
|
if (sscanf (tbuff, "%d", &bpnum) != 1)
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"Invalid decimal breakpoint number from target: %s\n", tbuff);
|
"Invalid decimal breakpoint number from target: %s\n", tbuff);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
mips_expect (" = ");
|
mips_expect (" = ");
|
|
|
/* Lead in the hex number we are expecting: */
|
/* Lead in the hex number we are expecting: */
|
tbuff[0] = '0';
|
tbuff[0] = '0';
|
tbuff[1] = 'x';
|
tbuff[1] = 'x';
|
|
|
/* FIXME!! only 8 bytes! need to expand for Bfd64;
|
/* FIXME!! only 8 bytes! need to expand for Bfd64;
|
which targets return 64-bit addresses? PMON returns only 32! */
|
which targets return 64-bit addresses? PMON returns only 32! */
|
if (!mips_getstring (&tbuff[2], 8))
|
if (!mips_getstring (&tbuff[2], 8))
|
return 1;
|
return 1;
|
tbuff[10] = '\0'; /* terminate the string */
|
tbuff[10] = '\0'; /* terminate the string */
|
|
|
if (sscanf (tbuff, "0x%08x", &bpaddr) != 1)
|
if (sscanf (tbuff, "0x%08x", &bpaddr) != 1)
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"Invalid hex address from target: %s\n", tbuff);
|
"Invalid hex address from target: %s\n", tbuff);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
if (bpnum >= PMON_MAX_BP)
|
if (bpnum >= PMON_MAX_BP)
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"Error: Returned breakpoint number %d outside acceptable range (0..%d)\n",
|
"Error: Returned breakpoint number %d outside acceptable range (0..%d)\n",
|
bpnum, PMON_MAX_BP - 1);
|
bpnum, PMON_MAX_BP - 1);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
if (bpaddr != addr)
|
if (bpaddr != addr)
|
fprintf_unfiltered (gdb_stderr, "Warning: Breakpoint addresses do not match: 0x%x != 0x%x\n", addr, bpaddr);
|
fprintf_unfiltered (gdb_stderr, "Warning: Breakpoint addresses do not match: 0x%x != 0x%x\n", addr, bpaddr);
|
|
|
mips_pmon_bp_info[bpnum] = bpaddr;
|
mips_pmon_bp_info[bpnum] = bpaddr;
|
|
|
mips_expect ("\r\n");
|
mips_expect ("\r\n");
|
mips_expect (mips_monitor_prompt);
|
mips_expect (mips_monitor_prompt);
|
|
|
mips_enter_debug ();
|
mips_enter_debug ();
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return mips_store_word (addr, BREAK_INSN, contents_cache);
|
return mips_store_word (addr, BREAK_INSN, contents_cache);
|
}
|
}
|
|
|
static int
|
static int
|
pmon_remove_breakpoint (addr, contents_cache)
|
pmon_remove_breakpoint (addr, contents_cache)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *contents_cache;
|
char *contents_cache;
|
{
|
{
|
if (monitor_supports_breakpoints)
|
if (monitor_supports_breakpoints)
|
{
|
{
|
int bpnum;
|
int bpnum;
|
char tbuff[7]; /* enough for delete breakpoint command */
|
char tbuff[7]; /* enough for delete breakpoint command */
|
|
|
for (bpnum = 0; bpnum < PMON_MAX_BP; bpnum++)
|
for (bpnum = 0; bpnum < PMON_MAX_BP; bpnum++)
|
if (mips_pmon_bp_info[bpnum] == addr)
|
if (mips_pmon_bp_info[bpnum] == addr)
|
break;
|
break;
|
|
|
if (bpnum >= PMON_MAX_BP)
|
if (bpnum >= PMON_MAX_BP)
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"pmon_remove_breakpoint: Failed to find breakpoint at address 0x%s\n",
|
"pmon_remove_breakpoint: Failed to find breakpoint at address 0x%s\n",
|
paddr_nz (addr));
|
paddr_nz (addr));
|
return 1;
|
return 1;
|
}
|
}
|
|
|
if (mips_exit_debug ())
|
if (mips_exit_debug ())
|
mips_error ("Failed to exit debug mode");
|
mips_error ("Failed to exit debug mode");
|
|
|
sprintf (tbuff, "db %02d\r", bpnum);
|
sprintf (tbuff, "db %02d\r", bpnum);
|
|
|
mips_send_command (tbuff, -1);
|
mips_send_command (tbuff, -1);
|
/* NOTE: If the breakpoint does not exist then a "Bpt <dd> not
|
/* NOTE: If the breakpoint does not exist then a "Bpt <dd> not
|
set" message will be returned. */
|
set" message will be returned. */
|
|
|
mips_enter_debug ();
|
mips_enter_debug ();
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return target_write_memory (addr, contents_cache, BREAK_INSN_SIZE);
|
return target_write_memory (addr, contents_cache, BREAK_INSN_SIZE);
|
}
|
}
|
#endif
|
#endif
|
|
|
|
|
/* Tell whether this target can support a hardware breakpoint. CNT
|
/* Tell whether this target can support a hardware breakpoint. CNT
|
is the number of hardware breakpoints already installed. This
|
is the number of hardware breakpoints already installed. This
|
implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro. */
|
implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro. */
|
|
|
int
|
int
|
remote_mips_can_use_hardware_watchpoint (cnt)
|
remote_mips_can_use_hardware_watchpoint (cnt)
|
int cnt;
|
int cnt;
|
{
|
{
|
return cnt < MAX_LSI_BREAKPOINTS && strcmp (target_shortname, "lsi") == 0;
|
return cnt < MAX_LSI_BREAKPOINTS && strcmp (target_shortname, "lsi") == 0;
|
}
|
}
|
|
|
|
|
/* Compute a don't care mask for the region bounding ADDR and ADDR + LEN - 1.
|
/* Compute a don't care mask for the region bounding ADDR and ADDR + LEN - 1.
|
This is used for memory ref breakpoints. */
|
This is used for memory ref breakpoints. */
|
|
|
static unsigned long
|
static unsigned long
|
calculate_mask (addr, len)
|
calculate_mask (addr, len)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int len;
|
int len;
|
{
|
{
|
unsigned long mask;
|
unsigned long mask;
|
int i;
|
int i;
|
|
|
mask = addr ^ (addr + len - 1);
|
mask = addr ^ (addr + len - 1);
|
|
|
for (i = 32; i >= 0; i--)
|
for (i = 32; i >= 0; i--)
|
if (mask == 0)
|
if (mask == 0)
|
break;
|
break;
|
else
|
else
|
mask >>= 1;
|
mask >>= 1;
|
|
|
mask = (unsigned long) 0xffffffff >> i;
|
mask = (unsigned long) 0xffffffff >> i;
|
|
|
return mask;
|
return mask;
|
}
|
}
|
|
|
|
|
/* Insert a hardware breakpoint. This works only on LSI targets, which
|
/* Insert a hardware breakpoint. This works only on LSI targets, which
|
implement ordinary breakpoints using hardware facilities. */
|
implement ordinary breakpoints using hardware facilities. */
|
|
|
int
|
int
|
remote_mips_insert_hw_breakpoint (addr, contents_cache)
|
remote_mips_insert_hw_breakpoint (addr, contents_cache)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *contents_cache;
|
char *contents_cache;
|
{
|
{
|
if (strcmp (target_shortname, "lsi") == 0)
|
if (strcmp (target_shortname, "lsi") == 0)
|
return mips_insert_breakpoint (addr, contents_cache);
|
return mips_insert_breakpoint (addr, contents_cache);
|
else
|
else
|
return -1;
|
return -1;
|
}
|
}
|
|
|
|
|
/* Remove a hardware breakpoint. This works only on LSI targets, which
|
/* Remove a hardware breakpoint. This works only on LSI targets, which
|
implement ordinary breakpoints using hardware facilities. */
|
implement ordinary breakpoints using hardware facilities. */
|
|
|
int
|
int
|
remote_mips_remove_hw_breakpoint (addr, contents_cache)
|
remote_mips_remove_hw_breakpoint (addr, contents_cache)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *contents_cache;
|
char *contents_cache;
|
{
|
{
|
if (strcmp (target_shortname, "lsi") == 0)
|
if (strcmp (target_shortname, "lsi") == 0)
|
return mips_remove_breakpoint (addr, contents_cache);
|
return mips_remove_breakpoint (addr, contents_cache);
|
else
|
else
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* Set a data watchpoint. ADDR and LEN should be obvious. TYPE is 0
|
/* Set a data watchpoint. ADDR and LEN should be obvious. TYPE is 0
|
for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
|
for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
|
watchpoint. */
|
watchpoint. */
|
|
|
int
|
int
|
remote_mips_set_watchpoint (addr, len, type)
|
remote_mips_set_watchpoint (addr, len, type)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int len;
|
int len;
|
int type;
|
int type;
|
{
|
{
|
if (set_breakpoint (addr, len, type))
|
if (set_breakpoint (addr, len, type))
|
return -1;
|
return -1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
remote_mips_remove_watchpoint (addr, len, type)
|
remote_mips_remove_watchpoint (addr, len, type)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int len;
|
int len;
|
int type;
|
int type;
|
{
|
{
|
if (clear_breakpoint (addr, len, type))
|
if (clear_breakpoint (addr, len, type))
|
return -1;
|
return -1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
remote_mips_stopped_by_watchpoint (void)
|
remote_mips_stopped_by_watchpoint (void)
|
{
|
{
|
return hit_watchpoint;
|
return hit_watchpoint;
|
}
|
}
|
|
|
|
|
/* Insert a breakpoint. */
|
/* Insert a breakpoint. */
|
|
|
static int
|
static int
|
set_breakpoint (addr, len, type)
|
set_breakpoint (addr, len, type)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int len;
|
int len;
|
enum break_type type;
|
enum break_type type;
|
{
|
{
|
return common_breakpoint (1, addr, len, type);
|
return common_breakpoint (1, addr, len, type);
|
}
|
}
|
|
|
|
|
/* Clear a breakpoint. */
|
/* Clear a breakpoint. */
|
|
|
static int
|
static int
|
clear_breakpoint (addr, len, type)
|
clear_breakpoint (addr, len, type)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int len;
|
int len;
|
enum break_type type;
|
enum break_type type;
|
{
|
{
|
return common_breakpoint (0, addr, len, type);
|
return common_breakpoint (0, addr, len, type);
|
}
|
}
|
|
|
|
|
/* Check the error code from the return packet for an LSI breakpoint
|
/* Check the error code from the return packet for an LSI breakpoint
|
command. If there's no error, just return 0. If it's a warning,
|
command. If there's no error, just return 0. If it's a warning,
|
print the warning text and return 0. If it's an error, print
|
print the warning text and return 0. If it's an error, print
|
the error text and return 1. <ADDR> is the address of the breakpoint
|
the error text and return 1. <ADDR> is the address of the breakpoint
|
that was being set. <RERRFLG> is the error code returned by PMON.
|
that was being set. <RERRFLG> is the error code returned by PMON.
|
This is a helper function for common_breakpoint. */
|
This is a helper function for common_breakpoint. */
|
|
|
static int
|
static int
|
check_lsi_error (addr, rerrflg)
|
check_lsi_error (addr, rerrflg)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int rerrflg;
|
int rerrflg;
|
{
|
{
|
struct lsi_error *err;
|
struct lsi_error *err;
|
char *saddr = paddr_nz (addr); /* printable address string */
|
char *saddr = paddr_nz (addr); /* printable address string */
|
|
|
if (rerrflg == 0) /* no error */
|
if (rerrflg == 0) /* no error */
|
return 0;
|
return 0;
|
|
|
/* Warnings can be ORed together, so check them all. */
|
/* Warnings can be ORed together, so check them all. */
|
if (rerrflg & W_WARN)
|
if (rerrflg & W_WARN)
|
{
|
{
|
if (monitor_warnings)
|
if (monitor_warnings)
|
{
|
{
|
int found = 0;
|
int found = 0;
|
for (err = lsi_warning_table; err->code != 0; err++)
|
for (err = lsi_warning_table; err->code != 0; err++)
|
{
|
{
|
if ((err->code & rerrflg) == err->code)
|
if ((err->code & rerrflg) == err->code)
|
{
|
{
|
found = 1;
|
found = 1;
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"common_breakpoint (0x%s): Warning: %s\n",
|
"common_breakpoint (0x%s): Warning: %s\n",
|
saddr,
|
saddr,
|
err->string);
|
err->string);
|
}
|
}
|
}
|
}
|
if (!found)
|
if (!found)
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"common_breakpoint (0x%s): Unknown warning: 0x%x\n",
|
"common_breakpoint (0x%s): Unknown warning: 0x%x\n",
|
saddr,
|
saddr,
|
rerrflg);
|
rerrflg);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Errors are unique, i.e. can't be ORed together. */
|
/* Errors are unique, i.e. can't be ORed together. */
|
for (err = lsi_error_table; err->code != 0; err++)
|
for (err = lsi_error_table; err->code != 0; err++)
|
{
|
{
|
if ((err->code & rerrflg) == err->code)
|
if ((err->code & rerrflg) == err->code)
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"common_breakpoint (0x%s): Error: %s\n",
|
"common_breakpoint (0x%s): Error: %s\n",
|
saddr,
|
saddr,
|
err->string);
|
err->string);
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"common_breakpoint (0x%s): Unknown error: 0x%x\n",
|
"common_breakpoint (0x%s): Unknown error: 0x%x\n",
|
saddr,
|
saddr,
|
rerrflg);
|
rerrflg);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
|
|
/* This routine sends a breakpoint command to the remote target.
|
/* This routine sends a breakpoint command to the remote target.
|
|
|
<SET> is 1 if setting a breakpoint, or 0 if clearing a breakpoint.
|
<SET> is 1 if setting a breakpoint, or 0 if clearing a breakpoint.
|
<ADDR> is the address of the breakpoint.
|
<ADDR> is the address of the breakpoint.
|
<LEN> the length of the region to break on.
|
<LEN> the length of the region to break on.
|
<TYPE> is the type of breakpoint:
|
<TYPE> is the type of breakpoint:
|
0 = write (BREAK_WRITE)
|
0 = write (BREAK_WRITE)
|
1 = read (BREAK_READ)
|
1 = read (BREAK_READ)
|
2 = read/write (BREAK_ACCESS)
|
2 = read/write (BREAK_ACCESS)
|
3 = instruction fetch (BREAK_FETCH)
|
3 = instruction fetch (BREAK_FETCH)
|
|
|
Return 0 if successful; otherwise 1. */
|
Return 0 if successful; otherwise 1. */
|
|
|
static int
|
static int
|
common_breakpoint (set, addr, len, type)
|
common_breakpoint (set, addr, len, type)
|
int set;
|
int set;
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int len;
|
int len;
|
enum break_type type;
|
enum break_type type;
|
{
|
{
|
char buf[DATA_MAXLEN + 1];
|
char buf[DATA_MAXLEN + 1];
|
char cmd, rcmd;
|
char cmd, rcmd;
|
int rpid, rerrflg, rresponse, rlen;
|
int rpid, rerrflg, rresponse, rlen;
|
int nfields;
|
int nfields;
|
|
|
addr = ADDR_BITS_REMOVE (addr);
|
addr = ADDR_BITS_REMOVE (addr);
|
|
|
if (mips_monitor == MON_LSI)
|
if (mips_monitor == MON_LSI)
|
{
|
{
|
if (set == 0) /* clear breakpoint */
|
if (set == 0) /* clear breakpoint */
|
{
|
{
|
/* The LSI PMON "clear breakpoint" has this form:
|
/* The LSI PMON "clear breakpoint" has this form:
|
<pid> 'b' <bptn> 0x0
|
<pid> 'b' <bptn> 0x0
|
reply:
|
reply:
|
<pid> 'b' 0x0 <code>
|
<pid> 'b' 0x0 <code>
|
|
|
<bptn> is a breakpoint number returned by an earlier 'B' command.
|
<bptn> is a breakpoint number returned by an earlier 'B' command.
|
Possible return codes: OK, E_BPT. */
|
Possible return codes: OK, E_BPT. */
|
|
|
int i;
|
int i;
|
|
|
/* Search for the breakpoint in the table. */
|
/* Search for the breakpoint in the table. */
|
for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
|
for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
|
if (lsi_breakpoints[i].type == type
|
if (lsi_breakpoints[i].type == type
|
&& lsi_breakpoints[i].addr == addr
|
&& lsi_breakpoints[i].addr == addr
|
&& lsi_breakpoints[i].len == len)
|
&& lsi_breakpoints[i].len == len)
|
break;
|
break;
|
|
|
/* Clear the table entry and tell PMON to clear the breakpoint. */
|
/* Clear the table entry and tell PMON to clear the breakpoint. */
|
if (i == MAX_LSI_BREAKPOINTS)
|
if (i == MAX_LSI_BREAKPOINTS)
|
{
|
{
|
warning ("common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
|
warning ("common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
|
paddr_nz (addr));
|
paddr_nz (addr));
|
return 1;
|
return 1;
|
}
|
}
|
|
|
lsi_breakpoints[i].type = BREAK_UNUSED;
|
lsi_breakpoints[i].type = BREAK_UNUSED;
|
sprintf (buf, "0x0 b 0x%x 0x0", i);
|
sprintf (buf, "0x0 b 0x%x 0x0", i);
|
mips_send_packet (buf, 1);
|
mips_send_packet (buf, 1);
|
|
|
rlen = mips_receive_packet (buf, 1, mips_receive_wait);
|
rlen = mips_receive_packet (buf, 1, mips_receive_wait);
|
buf[rlen] = '\0';
|
buf[rlen] = '\0';
|
|
|
nfields = sscanf (buf, "0x%x b 0x0 0x%x", &rpid, &rerrflg);
|
nfields = sscanf (buf, "0x%x b 0x0 0x%x", &rpid, &rerrflg);
|
if (nfields != 2)
|
if (nfields != 2)
|
mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
|
mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
|
|
|
return (check_lsi_error (addr, rerrflg));
|
return (check_lsi_error (addr, rerrflg));
|
}
|
}
|
else
|
else
|
/* set a breakpoint */
|
/* set a breakpoint */
|
{
|
{
|
/* The LSI PMON "set breakpoint" command has this form:
|
/* The LSI PMON "set breakpoint" command has this form:
|
<pid> 'B' <addr> 0x0
|
<pid> 'B' <addr> 0x0
|
reply:
|
reply:
|
<pid> 'B' <bptn> <code>
|
<pid> 'B' <bptn> <code>
|
|
|
The "set data breakpoint" command has this form:
|
The "set data breakpoint" command has this form:
|
|
|
<pid> 'A' <addr1> <type> [<addr2> [<value>]]
|
<pid> 'A' <addr1> <type> [<addr2> [<value>]]
|
|
|
where: type= "0x1" = read
|
where: type= "0x1" = read
|
"0x2" = write
|
"0x2" = write
|
"0x3" = access (read or write)
|
"0x3" = access (read or write)
|
|
|
The reply returns two values:
|
The reply returns two values:
|
bptn - a breakpoint number, which is a small integer with
|
bptn - a breakpoint number, which is a small integer with
|
possible values of zero through 255.
|
possible values of zero through 255.
|
code - an error return code, a value of zero indicates a
|
code - an error return code, a value of zero indicates a
|
succesful completion, other values indicate various
|
succesful completion, other values indicate various
|
errors and warnings.
|
errors and warnings.
|
|
|
Possible return codes: OK, W_QAL, E_QAL, E_OUT, E_NON.
|
Possible return codes: OK, W_QAL, E_QAL, E_OUT, E_NON.
|
|
|
*/
|
*/
|
|
|
if (type == BREAK_FETCH) /* instruction breakpoint */
|
if (type == BREAK_FETCH) /* instruction breakpoint */
|
{
|
{
|
cmd = 'B';
|
cmd = 'B';
|
sprintf (buf, "0x0 B 0x%s 0x0", paddr_nz (addr));
|
sprintf (buf, "0x0 B 0x%s 0x0", paddr_nz (addr));
|
}
|
}
|
else
|
else
|
/* watchpoint */
|
/* watchpoint */
|
{
|
{
|
cmd = 'A';
|
cmd = 'A';
|
sprintf (buf, "0x0 A 0x%s 0x%x 0x%s", paddr_nz (addr),
|
sprintf (buf, "0x0 A 0x%s 0x%x 0x%s", paddr_nz (addr),
|
type == BREAK_READ ? 1 : (type == BREAK_WRITE ? 2 : 3),
|
type == BREAK_READ ? 1 : (type == BREAK_WRITE ? 2 : 3),
|
paddr_nz (addr + len - 1));
|
paddr_nz (addr + len - 1));
|
}
|
}
|
mips_send_packet (buf, 1);
|
mips_send_packet (buf, 1);
|
|
|
rlen = mips_receive_packet (buf, 1, mips_receive_wait);
|
rlen = mips_receive_packet (buf, 1, mips_receive_wait);
|
buf[rlen] = '\0';
|
buf[rlen] = '\0';
|
|
|
nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
|
nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
|
&rpid, &rcmd, &rresponse, &rerrflg);
|
&rpid, &rcmd, &rresponse, &rerrflg);
|
if (nfields != 4 || rcmd != cmd || rresponse > 255)
|
if (nfields != 4 || rcmd != cmd || rresponse > 255)
|
mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
|
mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
|
|
|
if (rerrflg != 0)
|
if (rerrflg != 0)
|
if (check_lsi_error (addr, rerrflg))
|
if (check_lsi_error (addr, rerrflg))
|
return 1;
|
return 1;
|
|
|
/* rresponse contains PMON's breakpoint number. Record the
|
/* rresponse contains PMON's breakpoint number. Record the
|
information for this breakpoint so we can clear it later. */
|
information for this breakpoint so we can clear it later. */
|
lsi_breakpoints[rresponse].type = type;
|
lsi_breakpoints[rresponse].type = type;
|
lsi_breakpoints[rresponse].addr = addr;
|
lsi_breakpoints[rresponse].addr = addr;
|
lsi_breakpoints[rresponse].len = len;
|
lsi_breakpoints[rresponse].len = len;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* On non-LSI targets, the breakpoint command has this form:
|
/* On non-LSI targets, the breakpoint command has this form:
|
0x0 <CMD> <ADDR> <MASK> <FLAGS>
|
0x0 <CMD> <ADDR> <MASK> <FLAGS>
|
<MASK> is a don't care mask for addresses.
|
<MASK> is a don't care mask for addresses.
|
<FLAGS> is any combination of `r', `w', or `f' for read/write/fetch.
|
<FLAGS> is any combination of `r', `w', or `f' for read/write/fetch.
|
*/
|
*/
|
unsigned long mask;
|
unsigned long mask;
|
|
|
mask = calculate_mask (addr, len);
|
mask = calculate_mask (addr, len);
|
addr &= ~mask;
|
addr &= ~mask;
|
|
|
if (set) /* set a breakpoint */
|
if (set) /* set a breakpoint */
|
{
|
{
|
char *flags;
|
char *flags;
|
switch (type)
|
switch (type)
|
{
|
{
|
case BREAK_WRITE: /* write */
|
case BREAK_WRITE: /* write */
|
flags = "w";
|
flags = "w";
|
break;
|
break;
|
case BREAK_READ: /* read */
|
case BREAK_READ: /* read */
|
flags = "r";
|
flags = "r";
|
break;
|
break;
|
case BREAK_ACCESS: /* read/write */
|
case BREAK_ACCESS: /* read/write */
|
flags = "rw";
|
flags = "rw";
|
break;
|
break;
|
case BREAK_FETCH: /* fetch */
|
case BREAK_FETCH: /* fetch */
|
flags = "f";
|
flags = "f";
|
break;
|
break;
|
default:
|
default:
|
abort ();
|
abort ();
|
}
|
}
|
|
|
cmd = 'B';
|
cmd = 'B';
|
sprintf (buf, "0x0 B 0x%s 0x%s %s", paddr_nz (addr),
|
sprintf (buf, "0x0 B 0x%s 0x%s %s", paddr_nz (addr),
|
paddr_nz (mask), flags);
|
paddr_nz (mask), flags);
|
}
|
}
|
else
|
else
|
{
|
{
|
cmd = 'b';
|
cmd = 'b';
|
sprintf (buf, "0x0 b 0x%s", paddr_nz (addr));
|
sprintf (buf, "0x0 b 0x%s", paddr_nz (addr));
|
}
|
}
|
|
|
mips_send_packet (buf, 1);
|
mips_send_packet (buf, 1);
|
|
|
rlen = mips_receive_packet (buf, 1, mips_receive_wait);
|
rlen = mips_receive_packet (buf, 1, mips_receive_wait);
|
buf[rlen] = '\0';
|
buf[rlen] = '\0';
|
|
|
nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
|
nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
|
&rpid, &rcmd, &rerrflg, &rresponse);
|
&rpid, &rcmd, &rerrflg, &rresponse);
|
|
|
if (nfields != 4 || rcmd != cmd)
|
if (nfields != 4 || rcmd != cmd)
|
mips_error ("common_breakpoint: Bad response from remote board: %s",
|
mips_error ("common_breakpoint: Bad response from remote board: %s",
|
buf);
|
buf);
|
|
|
if (rerrflg != 0)
|
if (rerrflg != 0)
|
{
|
{
|
/* Ddb returns "0x0 b 0x16 0x0\000", whereas
|
/* Ddb returns "0x0 b 0x16 0x0\000", whereas
|
Cogent returns "0x0 b 0xffffffff 0x16\000": */
|
Cogent returns "0x0 b 0xffffffff 0x16\000": */
|
if (mips_monitor == MON_DDB)
|
if (mips_monitor == MON_DDB)
|
rresponse = rerrflg;
|
rresponse = rerrflg;
|
if (rresponse != 22) /* invalid argument */
|
if (rresponse != 22) /* invalid argument */
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"common_breakpoint (0x%s): Got error: 0x%x\n",
|
"common_breakpoint (0x%s): Got error: 0x%x\n",
|
paddr_nz (addr), rresponse);
|
paddr_nz (addr), rresponse);
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
send_srec (srec, len, addr)
|
send_srec (srec, len, addr)
|
char *srec;
|
char *srec;
|
int len;
|
int len;
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
{
|
{
|
while (1)
|
while (1)
|
{
|
{
|
int ch;
|
int ch;
|
|
|
SERIAL_WRITE (mips_desc, srec, len);
|
SERIAL_WRITE (mips_desc, srec, len);
|
|
|
ch = mips_readchar (2);
|
ch = mips_readchar (2);
|
|
|
switch (ch)
|
switch (ch)
|
{
|
{
|
case SERIAL_TIMEOUT:
|
case SERIAL_TIMEOUT:
|
error ("Timeout during download.");
|
error ("Timeout during download.");
|
break;
|
break;
|
case 0x6: /* ACK */
|
case 0x6: /* ACK */
|
return;
|
return;
|
case 0x15: /* NACK */
|
case 0x15: /* NACK */
|
fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %s! Retrying.\n", paddr_u (addr));
|
fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %s! Retrying.\n", paddr_u (addr));
|
continue;
|
continue;
|
default:
|
default:
|
error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);
|
error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Download a binary file by converting it to S records. */
|
/* Download a binary file by converting it to S records. */
|
|
|
static void
|
static void
|
mips_load_srec (args)
|
mips_load_srec (args)
|
char *args;
|
char *args;
|
{
|
{
|
bfd *abfd;
|
bfd *abfd;
|
asection *s;
|
asection *s;
|
char *buffer, srec[1024];
|
char *buffer, srec[1024];
|
unsigned int i;
|
unsigned int i;
|
unsigned int srec_frame = 200;
|
unsigned int srec_frame = 200;
|
int reclen;
|
int reclen;
|
static int hashmark = 1;
|
static int hashmark = 1;
|
|
|
buffer = alloca (srec_frame * 2 + 256);
|
buffer = alloca (srec_frame * 2 + 256);
|
|
|
abfd = bfd_openr (args, 0);
|
abfd = bfd_openr (args, 0);
|
if (!abfd)
|
if (!abfd)
|
{
|
{
|
printf_filtered ("Unable to open file %s\n", args);
|
printf_filtered ("Unable to open file %s\n", args);
|
return;
|
return;
|
}
|
}
|
|
|
if (bfd_check_format (abfd, bfd_object) == 0)
|
if (bfd_check_format (abfd, bfd_object) == 0)
|
{
|
{
|
printf_filtered ("File is not an object file\n");
|
printf_filtered ("File is not an object file\n");
|
return;
|
return;
|
}
|
}
|
|
|
/* This actually causes a download in the IDT binary format: */
|
/* This actually causes a download in the IDT binary format: */
|
mips_send_command (LOAD_CMD, 0);
|
mips_send_command (LOAD_CMD, 0);
|
|
|
for (s = abfd->sections; s; s = s->next)
|
for (s = abfd->sections; s; s = s->next)
|
{
|
{
|
if (s->flags & SEC_LOAD)
|
if (s->flags & SEC_LOAD)
|
{
|
{
|
unsigned int numbytes;
|
unsigned int numbytes;
|
|
|
/* FIXME! vma too small????? */
|
/* FIXME! vma too small????? */
|
printf_filtered ("%s\t: 0x%4lx .. 0x%4lx ", s->name,
|
printf_filtered ("%s\t: 0x%4lx .. 0x%4lx ", s->name,
|
(long) s->vma,
|
(long) s->vma,
|
(long) (s->vma + s->_raw_size));
|
(long) (s->vma + s->_raw_size));
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
|
|
for (i = 0; i < s->_raw_size; i += numbytes)
|
for (i = 0; i < s->_raw_size; i += numbytes)
|
{
|
{
|
numbytes = min (srec_frame, s->_raw_size - i);
|
numbytes = min (srec_frame, s->_raw_size - i);
|
|
|
bfd_get_section_contents (abfd, s, buffer, i, numbytes);
|
bfd_get_section_contents (abfd, s, buffer, i, numbytes);
|
|
|
reclen = mips_make_srec (srec, '3', s->vma + i, buffer, numbytes);
|
reclen = mips_make_srec (srec, '3', s->vma + i, buffer, numbytes);
|
send_srec (srec, reclen, s->vma + i);
|
send_srec (srec, reclen, s->vma + i);
|
|
|
if (hashmark)
|
if (hashmark)
|
{
|
{
|
putchar_unfiltered ('#');
|
putchar_unfiltered ('#');
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
|
|
} /* Per-packet (or S-record) loop */
|
} /* Per-packet (or S-record) loop */
|
|
|
putchar_unfiltered ('\n');
|
putchar_unfiltered ('\n');
|
} /* Loadable sections */
|
} /* Loadable sections */
|
}
|
}
|
if (hashmark)
|
if (hashmark)
|
putchar_unfiltered ('\n');
|
putchar_unfiltered ('\n');
|
|
|
/* Write a type 7 terminator record. no data for a type 7, and there
|
/* Write a type 7 terminator record. no data for a type 7, and there
|
is no data, so len is 0. */
|
is no data, so len is 0. */
|
|
|
reclen = mips_make_srec (srec, '7', abfd->start_address, NULL, 0);
|
reclen = mips_make_srec (srec, '7', abfd->start_address, NULL, 0);
|
|
|
send_srec (srec, reclen, abfd->start_address);
|
send_srec (srec, reclen, abfd->start_address);
|
|
|
SERIAL_FLUSH_INPUT (mips_desc);
|
SERIAL_FLUSH_INPUT (mips_desc);
|
}
|
}
|
|
|
/*
|
/*
|
* mips_make_srec -- make an srecord. This writes each line, one at a
|
* mips_make_srec -- make an srecord. This writes each line, one at a
|
* time, each with it's own header and trailer line.
|
* time, each with it's own header and trailer line.
|
* An srecord looks like this:
|
* An srecord looks like this:
|
*
|
*
|
* byte count-+ address
|
* byte count-+ address
|
* start ---+ | | data +- checksum
|
* start ---+ | | data +- checksum
|
* | | | |
|
* | | | |
|
* S01000006F6B692D746573742E73726563E4
|
* S01000006F6B692D746573742E73726563E4
|
* S315000448600000000000000000FC00005900000000E9
|
* S315000448600000000000000000FC00005900000000E9
|
* S31A0004000023C1400037DE00F023604000377B009020825000348D
|
* S31A0004000023C1400037DE00F023604000377B009020825000348D
|
* S30B0004485A0000000000004E
|
* S30B0004485A0000000000004E
|
* S70500040000F6
|
* S70500040000F6
|
*
|
*
|
* S<type><length><address><data><checksum>
|
* S<type><length><address><data><checksum>
|
*
|
*
|
* Where
|
* Where
|
* - length
|
* - length
|
* is the number of bytes following upto the checksum. Note that
|
* is the number of bytes following upto the checksum. Note that
|
* this is not the number of chars following, since it takes two
|
* this is not the number of chars following, since it takes two
|
* chars to represent a byte.
|
* chars to represent a byte.
|
* - type
|
* - type
|
* is one of:
|
* is one of:
|
* 0) header record
|
* 0) header record
|
* 1) two byte address data record
|
* 1) two byte address data record
|
* 2) three byte address data record
|
* 2) three byte address data record
|
* 3) four byte address data record
|
* 3) four byte address data record
|
* 7) four byte address termination record
|
* 7) four byte address termination record
|
* 8) three byte address termination record
|
* 8) three byte address termination record
|
* 9) two byte address termination record
|
* 9) two byte address termination record
|
*
|
*
|
* - address
|
* - address
|
* is the start address of the data following, or in the case of
|
* is the start address of the data following, or in the case of
|
* a termination record, the start address of the image
|
* a termination record, the start address of the image
|
* - data
|
* - data
|
* is the data.
|
* is the data.
|
* - checksum
|
* - checksum
|
* is the sum of all the raw byte data in the record, from the length
|
* is the sum of all the raw byte data in the record, from the length
|
* upwards, modulo 256 and subtracted from 255.
|
* upwards, modulo 256 and subtracted from 255.
|
*
|
*
|
* This routine returns the length of the S-record.
|
* This routine returns the length of the S-record.
|
*
|
*
|
*/
|
*/
|
|
|
static int
|
static int
|
mips_make_srec (buf, type, memaddr, myaddr, len)
|
mips_make_srec (buf, type, memaddr, myaddr, len)
|
char *buf;
|
char *buf;
|
int type;
|
int type;
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
unsigned char *myaddr;
|
unsigned char *myaddr;
|
int len;
|
int len;
|
{
|
{
|
unsigned char checksum;
|
unsigned char checksum;
|
int i;
|
int i;
|
|
|
/* Create the header for the srec. addr_size is the number of bytes in the address,
|
/* Create the header for the srec. addr_size is the number of bytes in the address,
|
and 1 is the number of bytes in the count. */
|
and 1 is the number of bytes in the count. */
|
|
|
/* FIXME!! bigger buf required for 64-bit! */
|
/* FIXME!! bigger buf required for 64-bit! */
|
buf[0] = 'S';
|
buf[0] = 'S';
|
buf[1] = type;
|
buf[1] = type;
|
buf[2] = len + 4 + 1; /* len + 4 byte address + 1 byte checksum */
|
buf[2] = len + 4 + 1; /* len + 4 byte address + 1 byte checksum */
|
/* This assumes S3 style downloads (4byte addresses). There should
|
/* This assumes S3 style downloads (4byte addresses). There should
|
probably be a check, or the code changed to make it more
|
probably be a check, or the code changed to make it more
|
explicit. */
|
explicit. */
|
buf[3] = memaddr >> 24;
|
buf[3] = memaddr >> 24;
|
buf[4] = memaddr >> 16;
|
buf[4] = memaddr >> 16;
|
buf[5] = memaddr >> 8;
|
buf[5] = memaddr >> 8;
|
buf[6] = memaddr;
|
buf[6] = memaddr;
|
memcpy (&buf[7], myaddr, len);
|
memcpy (&buf[7], myaddr, len);
|
|
|
/* Note that the checksum is calculated on the raw data, not the
|
/* Note that the checksum is calculated on the raw data, not the
|
hexified data. It includes the length, address and the data
|
hexified data. It includes the length, address and the data
|
portions of the packet. */
|
portions of the packet. */
|
checksum = 0;
|
checksum = 0;
|
buf += 2; /* Point at length byte */
|
buf += 2; /* Point at length byte */
|
for (i = 0; i < len + 4 + 1; i++)
|
for (i = 0; i < len + 4 + 1; i++)
|
checksum += *buf++;
|
checksum += *buf++;
|
|
|
*buf = ~checksum;
|
*buf = ~checksum;
|
|
|
return len + 8;
|
return len + 8;
|
}
|
}
|
|
|
/* The following manifest controls whether we enable the simple flow
|
/* The following manifest controls whether we enable the simple flow
|
control support provided by the monitor. If enabled the code will
|
control support provided by the monitor. If enabled the code will
|
wait for an affirmative ACK between transmitting packets. */
|
wait for an affirmative ACK between transmitting packets. */
|
#define DOETXACK (1)
|
#define DOETXACK (1)
|
|
|
/* The PMON fast-download uses an encoded packet format constructed of
|
/* The PMON fast-download uses an encoded packet format constructed of
|
3byte data packets (encoded as 4 printable ASCII characters), and
|
3byte data packets (encoded as 4 printable ASCII characters), and
|
escape sequences (preceded by a '/'):
|
escape sequences (preceded by a '/'):
|
|
|
'K' clear checksum
|
'K' clear checksum
|
'C' compare checksum (12bit value, not included in checksum calculation)
|
'C' compare checksum (12bit value, not included in checksum calculation)
|
'S' define symbol name (for addr) terminated with "," and padded to 4char boundary
|
'S' define symbol name (for addr) terminated with "," and padded to 4char boundary
|
'Z' zero fill multiple of 3bytes
|
'Z' zero fill multiple of 3bytes
|
'B' byte (12bit encoded value, of 8bit data)
|
'B' byte (12bit encoded value, of 8bit data)
|
'A' address (36bit encoded value)
|
'A' address (36bit encoded value)
|
'E' define entry as original address, and exit load
|
'E' define entry as original address, and exit load
|
|
|
The packets are processed in 4 character chunks, so the escape
|
The packets are processed in 4 character chunks, so the escape
|
sequences that do not have any data (or variable length data)
|
sequences that do not have any data (or variable length data)
|
should be padded to a 4 character boundary. The decoder will give
|
should be padded to a 4 character boundary. The decoder will give
|
an error if the complete message block size is not a multiple of
|
an error if the complete message block size is not a multiple of
|
4bytes (size of record).
|
4bytes (size of record).
|
|
|
The encoding of numbers is done in 6bit fields. The 6bit value is
|
The encoding of numbers is done in 6bit fields. The 6bit value is
|
used to index into this string to get the specific character
|
used to index into this string to get the specific character
|
encoding for the value: */
|
encoding for the value: */
|
static char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,.";
|
static char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,.";
|
|
|
/* Convert the number of bits required into an encoded number, 6bits
|
/* Convert the number of bits required into an encoded number, 6bits
|
at a time (range 0..63). Keep a checksum if required (passed
|
at a time (range 0..63). Keep a checksum if required (passed
|
pointer non-NULL). The function returns the number of encoded
|
pointer non-NULL). The function returns the number of encoded
|
characters written into the buffer. */
|
characters written into the buffer. */
|
static int
|
static int
|
pmon_makeb64 (v, p, n, chksum)
|
pmon_makeb64 (v, p, n, chksum)
|
unsigned long v;
|
unsigned long v;
|
char *p;
|
char *p;
|
int n;
|
int n;
|
int *chksum;
|
int *chksum;
|
{
|
{
|
int count = (n / 6);
|
int count = (n / 6);
|
|
|
if ((n % 12) != 0)
|
if ((n % 12) != 0)
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"Fast encoding bitcount must be a multiple of 12bits: %dbit%s\n", n, (n == 1) ? "" : "s");
|
"Fast encoding bitcount must be a multiple of 12bits: %dbit%s\n", n, (n == 1) ? "" : "s");
|
return (0);
|
return (0);
|
}
|
}
|
if (n > 36)
|
if (n > 36)
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"Fast encoding cannot process more than 36bits at the moment: %dbits\n", n);
|
"Fast encoding cannot process more than 36bits at the moment: %dbits\n", n);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* Deal with the checksum: */
|
/* Deal with the checksum: */
|
if (chksum != NULL)
|
if (chksum != NULL)
|
{
|
{
|
switch (n)
|
switch (n)
|
{
|
{
|
case 36:
|
case 36:
|
*chksum += ((v >> 24) & 0xFFF);
|
*chksum += ((v >> 24) & 0xFFF);
|
case 24:
|
case 24:
|
*chksum += ((v >> 12) & 0xFFF);
|
*chksum += ((v >> 12) & 0xFFF);
|
case 12:
|
case 12:
|
*chksum += ((v >> 0) & 0xFFF);
|
*chksum += ((v >> 0) & 0xFFF);
|
}
|
}
|
}
|
}
|
|
|
do
|
do
|
{
|
{
|
n -= 6;
|
n -= 6;
|
*p++ = encoding[(v >> n) & 0x3F];
|
*p++ = encoding[(v >> n) & 0x3F];
|
}
|
}
|
while (n > 0);
|
while (n > 0);
|
|
|
return (count);
|
return (count);
|
}
|
}
|
|
|
/* Shorthand function (that could be in-lined) to output the zero-fill
|
/* Shorthand function (that could be in-lined) to output the zero-fill
|
escape sequence into the data stream. */
|
escape sequence into the data stream. */
|
static int
|
static int
|
pmon_zeroset (recsize, buff, amount, chksum)
|
pmon_zeroset (recsize, buff, amount, chksum)
|
int recsize;
|
int recsize;
|
char **buff;
|
char **buff;
|
int *amount;
|
int *amount;
|
unsigned int *chksum;
|
unsigned int *chksum;
|
{
|
{
|
int count;
|
int count;
|
|
|
sprintf (*buff, "/Z");
|
sprintf (*buff, "/Z");
|
count = pmon_makeb64 (*amount, (*buff + 2), 12, chksum);
|
count = pmon_makeb64 (*amount, (*buff + 2), 12, chksum);
|
*buff += (count + 2);
|
*buff += (count + 2);
|
*amount = 0;
|
*amount = 0;
|
return (recsize + count + 2);
|
return (recsize + count + 2);
|
}
|
}
|
|
|
static int
|
static int
|
pmon_checkset (recsize, buff, value)
|
pmon_checkset (recsize, buff, value)
|
int recsize;
|
int recsize;
|
char **buff;
|
char **buff;
|
int *value;
|
int *value;
|
{
|
{
|
int count;
|
int count;
|
|
|
/* Add the checksum (without updating the value): */
|
/* Add the checksum (without updating the value): */
|
sprintf (*buff, "/C");
|
sprintf (*buff, "/C");
|
count = pmon_makeb64 (*value, (*buff + 2), 12, NULL);
|
count = pmon_makeb64 (*value, (*buff + 2), 12, NULL);
|
*buff += (count + 2);
|
*buff += (count + 2);
|
sprintf (*buff, "\n");
|
sprintf (*buff, "\n");
|
*buff += 2; /* include zero terminator */
|
*buff += 2; /* include zero terminator */
|
/* Forcing a checksum validation clears the sum: */
|
/* Forcing a checksum validation clears the sum: */
|
*value = 0;
|
*value = 0;
|
return (recsize + count + 3);
|
return (recsize + count + 3);
|
}
|
}
|
|
|
/* Amount of padding we leave after at the end of the output buffer,
|
/* Amount of padding we leave after at the end of the output buffer,
|
for the checksum and line termination characters: */
|
for the checksum and line termination characters: */
|
#define CHECKSIZE (4 + 4 + 4 + 2)
|
#define CHECKSIZE (4 + 4 + 4 + 2)
|
/* zero-fill, checksum, transfer end and line termination space. */
|
/* zero-fill, checksum, transfer end and line termination space. */
|
|
|
/* The amount of binary data loaded from the object file in a single
|
/* The amount of binary data loaded from the object file in a single
|
operation: */
|
operation: */
|
#define BINCHUNK (1024)
|
#define BINCHUNK (1024)
|
|
|
/* Maximum line of data accepted by the monitor: */
|
/* Maximum line of data accepted by the monitor: */
|
#define MAXRECSIZE (550)
|
#define MAXRECSIZE (550)
|
/* NOTE: This constant depends on the monitor being used. This value
|
/* NOTE: This constant depends on the monitor being used. This value
|
is for PMON 5.x on the Cogent Vr4300 board. */
|
is for PMON 5.x on the Cogent Vr4300 board. */
|
|
|
static void
|
static void
|
pmon_make_fastrec (outbuf, inbuf, inptr, inamount, recsize, csum, zerofill)
|
pmon_make_fastrec (outbuf, inbuf, inptr, inamount, recsize, csum, zerofill)
|
char **outbuf;
|
char **outbuf;
|
unsigned char *inbuf;
|
unsigned char *inbuf;
|
int *inptr;
|
int *inptr;
|
int inamount;
|
int inamount;
|
int *recsize;
|
int *recsize;
|
unsigned int *csum;
|
unsigned int *csum;
|
unsigned int *zerofill;
|
unsigned int *zerofill;
|
{
|
{
|
int count = 0;
|
int count = 0;
|
char *p = *outbuf;
|
char *p = *outbuf;
|
|
|
/* This is a simple check to ensure that our data will fit within
|
/* This is a simple check to ensure that our data will fit within
|
the maximum allowable record size. Each record output is 4bytes
|
the maximum allowable record size. Each record output is 4bytes
|
in length. We must allow space for a pending zero fill command,
|
in length. We must allow space for a pending zero fill command,
|
the record, and a checksum record. */
|
the record, and a checksum record. */
|
while ((*recsize < (MAXRECSIZE - CHECKSIZE)) && ((inamount - *inptr) > 0))
|
while ((*recsize < (MAXRECSIZE - CHECKSIZE)) && ((inamount - *inptr) > 0))
|
{
|
{
|
/* Process the binary data: */
|
/* Process the binary data: */
|
if ((inamount - *inptr) < 3)
|
if ((inamount - *inptr) < 3)
|
{
|
{
|
if (*zerofill != 0)
|
if (*zerofill != 0)
|
*recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
|
*recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
|
sprintf (p, "/B");
|
sprintf (p, "/B");
|
count = pmon_makeb64 (inbuf[*inptr], &p[2], 12, csum);
|
count = pmon_makeb64 (inbuf[*inptr], &p[2], 12, csum);
|
p += (2 + count);
|
p += (2 + count);
|
*recsize += (2 + count);
|
*recsize += (2 + count);
|
(*inptr)++;
|
(*inptr)++;
|
}
|
}
|
else
|
else
|
{
|
{
|
unsigned int value = ((inbuf[*inptr + 0] << 16) | (inbuf[*inptr + 1] << 8) | inbuf[*inptr + 2]);
|
unsigned int value = ((inbuf[*inptr + 0] << 16) | (inbuf[*inptr + 1] << 8) | inbuf[*inptr + 2]);
|
/* Simple check for zero data. TODO: A better check would be
|
/* Simple check for zero data. TODO: A better check would be
|
to check the last, and then the middle byte for being zero
|
to check the last, and then the middle byte for being zero
|
(if the first byte is not). We could then check for
|
(if the first byte is not). We could then check for
|
following runs of zeros, and if above a certain size it is
|
following runs of zeros, and if above a certain size it is
|
worth the 4 or 8 character hit of the byte insertions used
|
worth the 4 or 8 character hit of the byte insertions used
|
to pad to the start of the zeroes. NOTE: This also depends
|
to pad to the start of the zeroes. NOTE: This also depends
|
on the alignment at the end of the zero run. */
|
on the alignment at the end of the zero run. */
|
if (value == 0x00000000)
|
if (value == 0x00000000)
|
{
|
{
|
(*zerofill)++;
|
(*zerofill)++;
|
if (*zerofill == 0xFFF) /* 12bit counter */
|
if (*zerofill == 0xFFF) /* 12bit counter */
|
*recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
|
*recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (*zerofill != 0)
|
if (*zerofill != 0)
|
*recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
|
*recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
|
count = pmon_makeb64 (value, p, 24, csum);
|
count = pmon_makeb64 (value, p, 24, csum);
|
p += count;
|
p += count;
|
*recsize += count;
|
*recsize += count;
|
}
|
}
|
*inptr += 3;
|
*inptr += 3;
|
}
|
}
|
}
|
}
|
|
|
*outbuf = p;
|
*outbuf = p;
|
return;
|
return;
|
}
|
}
|
|
|
static int
|
static int
|
pmon_check_ack (mesg)
|
pmon_check_ack (mesg)
|
char *mesg;
|
char *mesg;
|
{
|
{
|
#if defined(DOETXACK)
|
#if defined(DOETXACK)
|
int c;
|
int c;
|
|
|
if (!tftp_in_use)
|
if (!tftp_in_use)
|
{
|
{
|
c = SERIAL_READCHAR (udp_in_use ? udp_desc : mips_desc, 2);
|
c = SERIAL_READCHAR (udp_in_use ? udp_desc : mips_desc, 2);
|
if ((c == SERIAL_TIMEOUT) || (c != 0x06))
|
if ((c == SERIAL_TIMEOUT) || (c != 0x06))
|
{
|
{
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"Failed to receive valid ACK for %s\n", mesg);
|
"Failed to receive valid ACK for %s\n", mesg);
|
return (-1); /* terminate the download */
|
return (-1); /* terminate the download */
|
}
|
}
|
}
|
}
|
#endif /* DOETXACK */
|
#endif /* DOETXACK */
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* pmon_download - Send a sequence of characters to the PMON download port,
|
/* pmon_download - Send a sequence of characters to the PMON download port,
|
which is either a serial port or a UDP socket. */
|
which is either a serial port or a UDP socket. */
|
|
|
static void
|
static void
|
pmon_start_download ()
|
pmon_start_download ()
|
{
|
{
|
if (tftp_in_use)
|
if (tftp_in_use)
|
{
|
{
|
/* Create the temporary download file. */
|
/* Create the temporary download file. */
|
if ((tftp_file = fopen (tftp_localname, "w")) == NULL)
|
if ((tftp_file = fopen (tftp_localname, "w")) == NULL)
|
perror_with_name (tftp_localname);
|
perror_with_name (tftp_localname);
|
}
|
}
|
else
|
else
|
{
|
{
|
mips_send_command (udp_in_use ? LOAD_CMD_UDP : LOAD_CMD, 0);
|
mips_send_command (udp_in_use ? LOAD_CMD_UDP : LOAD_CMD, 0);
|
mips_expect ("Downloading from ");
|
mips_expect ("Downloading from ");
|
mips_expect (udp_in_use ? "udp" : "tty0");
|
mips_expect (udp_in_use ? "udp" : "tty0");
|
mips_expect (", ^C to abort\r\n");
|
mips_expect (", ^C to abort\r\n");
|
}
|
}
|
}
|
}
|
|
|
static int
|
static int
|
mips_expect_download (char *string)
|
mips_expect_download (char *string)
|
{
|
{
|
if (!mips_expect (string))
|
if (!mips_expect (string))
|
{
|
{
|
fprintf_unfiltered (gdb_stderr, "Load did not complete successfully.\n");
|
fprintf_unfiltered (gdb_stderr, "Load did not complete successfully.\n");
|
if (tftp_in_use)
|
if (tftp_in_use)
|
remove (tftp_localname); /* Remove temporary file */
|
remove (tftp_localname); /* Remove temporary file */
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
return 1;
|
return 1;
|
}
|
}
|
|
|
static void
|
static void
|
pmon_end_download (final, bintotal)
|
pmon_end_download (final, bintotal)
|
int final;
|
int final;
|
int bintotal;
|
int bintotal;
|
{
|
{
|
char hexnumber[9]; /* includes '\0' space */
|
char hexnumber[9]; /* includes '\0' space */
|
|
|
if (tftp_in_use)
|
if (tftp_in_use)
|
{
|
{
|
static char *load_cmd_prefix = "load -b -s ";
|
static char *load_cmd_prefix = "load -b -s ";
|
char *cmd;
|
char *cmd;
|
struct stat stbuf;
|
struct stat stbuf;
|
|
|
/* Close off the temporary file containing the load data. */
|
/* Close off the temporary file containing the load data. */
|
fclose (tftp_file);
|
fclose (tftp_file);
|
tftp_file = NULL;
|
tftp_file = NULL;
|
|
|
/* Make the temporary file readable by the world. */
|
/* Make the temporary file readable by the world. */
|
if (stat (tftp_localname, &stbuf) == 0)
|
if (stat (tftp_localname, &stbuf) == 0)
|
chmod (tftp_localname, stbuf.st_mode | S_IROTH);
|
chmod (tftp_localname, stbuf.st_mode | S_IROTH);
|
|
|
/* Must reinitialize the board to prevent PMON from crashing. */
|
/* Must reinitialize the board to prevent PMON from crashing. */
|
mips_send_command ("initEther\r", -1);
|
mips_send_command ("initEther\r", -1);
|
|
|
/* Send the load command. */
|
/* Send the load command. */
|
cmd = xmalloc (strlen (load_cmd_prefix) + strlen (tftp_name) + 2);
|
cmd = xmalloc (strlen (load_cmd_prefix) + strlen (tftp_name) + 2);
|
strcpy (cmd, load_cmd_prefix);
|
strcpy (cmd, load_cmd_prefix);
|
strcat (cmd, tftp_name);
|
strcat (cmd, tftp_name);
|
strcat (cmd, "\r");
|
strcat (cmd, "\r");
|
mips_send_command (cmd, 0);
|
mips_send_command (cmd, 0);
|
free (cmd);
|
free (cmd);
|
if (!mips_expect_download ("Downloading from "))
|
if (!mips_expect_download ("Downloading from "))
|
return;
|
return;
|
if (!mips_expect_download (tftp_name))
|
if (!mips_expect_download (tftp_name))
|
return;
|
return;
|
if (!mips_expect_download (", ^C to abort\r\n"))
|
if (!mips_expect_download (", ^C to abort\r\n"))
|
return;
|
return;
|
}
|
}
|
|
|
/* Wait for the stuff that PMON prints after the load has completed.
|
/* Wait for the stuff that PMON prints after the load has completed.
|
The timeout value for use in the tftp case (15 seconds) was picked
|
The timeout value for use in the tftp case (15 seconds) was picked
|
arbitrarily but might be too small for really large downloads. FIXME. */
|
arbitrarily but might be too small for really large downloads. FIXME. */
|
if (mips_monitor == MON_LSI)
|
if (mips_monitor == MON_LSI)
|
{
|
{
|
pmon_check_ack ("termination");
|
pmon_check_ack ("termination");
|
mips_expect_timeout ("Entry address is ", tftp_in_use ? 15 : 2);
|
mips_expect_timeout ("Entry address is ", tftp_in_use ? 15 : 2);
|
}
|
}
|
else
|
else
|
mips_expect_timeout ("Entry Address = ", tftp_in_use ? 15 : 2);
|
mips_expect_timeout ("Entry Address = ", tftp_in_use ? 15 : 2);
|
|
|
sprintf (hexnumber, "%x", final);
|
sprintf (hexnumber, "%x", final);
|
mips_expect (hexnumber);
|
mips_expect (hexnumber);
|
mips_expect ("\r\n");
|
mips_expect ("\r\n");
|
if (mips_monitor != MON_LSI)
|
if (mips_monitor != MON_LSI)
|
pmon_check_ack ("termination");
|
pmon_check_ack ("termination");
|
mips_expect ("\r\ntotal = 0x");
|
mips_expect ("\r\ntotal = 0x");
|
sprintf (hexnumber, "%x", bintotal);
|
sprintf (hexnumber, "%x", bintotal);
|
mips_expect (hexnumber);
|
mips_expect (hexnumber);
|
if (!mips_expect_download (" bytes\r\n"))
|
if (!mips_expect_download (" bytes\r\n"))
|
return;
|
return;
|
|
|
if (tftp_in_use)
|
if (tftp_in_use)
|
remove (tftp_localname); /* Remove temporary file */
|
remove (tftp_localname); /* Remove temporary file */
|
}
|
}
|
|
|
static void
|
static void
|
pmon_download (buffer, length)
|
pmon_download (buffer, length)
|
char *buffer;
|
char *buffer;
|
int length;
|
int length;
|
{
|
{
|
if (tftp_in_use)
|
if (tftp_in_use)
|
fwrite (buffer, 1, length, tftp_file);
|
fwrite (buffer, 1, length, tftp_file);
|
else
|
else
|
SERIAL_WRITE (udp_in_use ? udp_desc : mips_desc, buffer, length);
|
SERIAL_WRITE (udp_in_use ? udp_desc : mips_desc, buffer, length);
|
}
|
}
|
|
|
static void
|
static void
|
pmon_load_fast (file)
|
pmon_load_fast (file)
|
char *file;
|
char *file;
|
{
|
{
|
bfd *abfd;
|
bfd *abfd;
|
asection *s;
|
asection *s;
|
unsigned char *binbuf;
|
unsigned char *binbuf;
|
char *buffer;
|
char *buffer;
|
int reclen;
|
int reclen;
|
unsigned int csum = 0;
|
unsigned int csum = 0;
|
int hashmark = !tftp_in_use;
|
int hashmark = !tftp_in_use;
|
int bintotal = 0;
|
int bintotal = 0;
|
int final = 0;
|
int final = 0;
|
int finished = 0;
|
int finished = 0;
|
|
|
buffer = (char *) xmalloc (MAXRECSIZE + 1);
|
buffer = (char *) xmalloc (MAXRECSIZE + 1);
|
binbuf = (unsigned char *) xmalloc (BINCHUNK);
|
binbuf = (unsigned char *) xmalloc (BINCHUNK);
|
|
|
abfd = bfd_openr (file, 0);
|
abfd = bfd_openr (file, 0);
|
if (!abfd)
|
if (!abfd)
|
{
|
{
|
printf_filtered ("Unable to open file %s\n", file);
|
printf_filtered ("Unable to open file %s\n", file);
|
return;
|
return;
|
}
|
}
|
|
|
if (bfd_check_format (abfd, bfd_object) == 0)
|
if (bfd_check_format (abfd, bfd_object) == 0)
|
{
|
{
|
printf_filtered ("File is not an object file\n");
|
printf_filtered ("File is not an object file\n");
|
return;
|
return;
|
}
|
}
|
|
|
/* Setup the required download state: */
|
/* Setup the required download state: */
|
mips_send_command ("set dlproto etxack\r", -1);
|
mips_send_command ("set dlproto etxack\r", -1);
|
mips_send_command ("set dlecho off\r", -1);
|
mips_send_command ("set dlecho off\r", -1);
|
/* NOTE: We get a "cannot set variable" message if the variable is
|
/* NOTE: We get a "cannot set variable" message if the variable is
|
already defined to have the argument we give. The code doesn't
|
already defined to have the argument we give. The code doesn't
|
care, since it just scans to the next prompt anyway. */
|
care, since it just scans to the next prompt anyway. */
|
/* Start the download: */
|
/* Start the download: */
|
pmon_start_download ();
|
pmon_start_download ();
|
|
|
/* Zero the checksum */
|
/* Zero the checksum */
|
sprintf (buffer, "/Kxx\n");
|
sprintf (buffer, "/Kxx\n");
|
reclen = strlen (buffer);
|
reclen = strlen (buffer);
|
pmon_download (buffer, reclen);
|
pmon_download (buffer, reclen);
|
finished = pmon_check_ack ("/Kxx");
|
finished = pmon_check_ack ("/Kxx");
|
|
|
for (s = abfd->sections; s && !finished; s = s->next)
|
for (s = abfd->sections; s && !finished; s = s->next)
|
if (s->flags & SEC_LOAD) /* only deal with loadable sections */
|
if (s->flags & SEC_LOAD) /* only deal with loadable sections */
|
{
|
{
|
bintotal += s->_raw_size;
|
bintotal += s->_raw_size;
|
final = (s->vma + s->_raw_size);
|
final = (s->vma + s->_raw_size);
|
|
|
printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s->name, (unsigned int) s->vma,
|
printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s->name, (unsigned int) s->vma,
|
(unsigned int) (s->vma + s->_raw_size));
|
(unsigned int) (s->vma + s->_raw_size));
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
|
|
/* Output the starting address */
|
/* Output the starting address */
|
sprintf (buffer, "/A");
|
sprintf (buffer, "/A");
|
reclen = pmon_makeb64 (s->vma, &buffer[2], 36, &csum);
|
reclen = pmon_makeb64 (s->vma, &buffer[2], 36, &csum);
|
buffer[2 + reclen] = '\n';
|
buffer[2 + reclen] = '\n';
|
buffer[3 + reclen] = '\0';
|
buffer[3 + reclen] = '\0';
|
reclen += 3; /* for the initial escape code and carriage return */
|
reclen += 3; /* for the initial escape code and carriage return */
|
pmon_download (buffer, reclen);
|
pmon_download (buffer, reclen);
|
finished = pmon_check_ack ("/A");
|
finished = pmon_check_ack ("/A");
|
|
|
if (!finished)
|
if (!finished)
|
{
|
{
|
unsigned int binamount;
|
unsigned int binamount;
|
unsigned int zerofill = 0;
|
unsigned int zerofill = 0;
|
char *bp = buffer;
|
char *bp = buffer;
|
unsigned int i;
|
unsigned int i;
|
|
|
reclen = 0;
|
reclen = 0;
|
|
|
for (i = 0; ((i < s->_raw_size) && !finished); i += binamount)
|
for (i = 0; ((i < s->_raw_size) && !finished); i += binamount)
|
{
|
{
|
int binptr = 0;
|
int binptr = 0;
|
|
|
binamount = min (BINCHUNK, s->_raw_size - i);
|
binamount = min (BINCHUNK, s->_raw_size - i);
|
|
|
bfd_get_section_contents (abfd, s, binbuf, i, binamount);
|
bfd_get_section_contents (abfd, s, binbuf, i, binamount);
|
|
|
/* This keeps a rolling checksum, until we decide to output
|
/* This keeps a rolling checksum, until we decide to output
|
the line: */
|
the line: */
|
for (; ((binamount - binptr) > 0);)
|
for (; ((binamount - binptr) > 0);)
|
{
|
{
|
pmon_make_fastrec (&bp, binbuf, &binptr, binamount, &reclen, &csum, &zerofill);
|
pmon_make_fastrec (&bp, binbuf, &binptr, binamount, &reclen, &csum, &zerofill);
|
if (reclen >= (MAXRECSIZE - CHECKSIZE))
|
if (reclen >= (MAXRECSIZE - CHECKSIZE))
|
{
|
{
|
reclen = pmon_checkset (reclen, &bp, &csum);
|
reclen = pmon_checkset (reclen, &bp, &csum);
|
pmon_download (buffer, reclen);
|
pmon_download (buffer, reclen);
|
finished = pmon_check_ack ("data record");
|
finished = pmon_check_ack ("data record");
|
if (finished)
|
if (finished)
|
{
|
{
|
zerofill = 0; /* do not transmit pending zerofills */
|
zerofill = 0; /* do not transmit pending zerofills */
|
break;
|
break;
|
}
|
}
|
|
|
if (hashmark)
|
if (hashmark)
|
{
|
{
|
putchar_unfiltered ('#');
|
putchar_unfiltered ('#');
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
|
|
bp = buffer;
|
bp = buffer;
|
reclen = 0; /* buffer processed */
|
reclen = 0; /* buffer processed */
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Ensure no out-standing zerofill requests: */
|
/* Ensure no out-standing zerofill requests: */
|
if (zerofill != 0)
|
if (zerofill != 0)
|
reclen = pmon_zeroset (reclen, &bp, &zerofill, &csum);
|
reclen = pmon_zeroset (reclen, &bp, &zerofill, &csum);
|
|
|
/* and then flush the line: */
|
/* and then flush the line: */
|
if (reclen > 0)
|
if (reclen > 0)
|
{
|
{
|
reclen = pmon_checkset (reclen, &bp, &csum);
|
reclen = pmon_checkset (reclen, &bp, &csum);
|
/* Currently pmon_checkset outputs the line terminator by
|
/* Currently pmon_checkset outputs the line terminator by
|
default, so we write out the buffer so far: */
|
default, so we write out the buffer so far: */
|
pmon_download (buffer, reclen);
|
pmon_download (buffer, reclen);
|
finished = pmon_check_ack ("record remnant");
|
finished = pmon_check_ack ("record remnant");
|
}
|
}
|
}
|
}
|
|
|
putchar_unfiltered ('\n');
|
putchar_unfiltered ('\n');
|
}
|
}
|
|
|
/* Terminate the transfer. We know that we have an empty output
|
/* Terminate the transfer. We know that we have an empty output
|
buffer at this point. */
|
buffer at this point. */
|
sprintf (buffer, "/E/E\n"); /* include dummy padding characters */
|
sprintf (buffer, "/E/E\n"); /* include dummy padding characters */
|
reclen = strlen (buffer);
|
reclen = strlen (buffer);
|
pmon_download (buffer, reclen);
|
pmon_download (buffer, reclen);
|
|
|
if (finished)
|
if (finished)
|
{ /* Ignore the termination message: */
|
{ /* Ignore the termination message: */
|
SERIAL_FLUSH_INPUT (udp_in_use ? udp_desc : mips_desc);
|
SERIAL_FLUSH_INPUT (udp_in_use ? udp_desc : mips_desc);
|
}
|
}
|
else
|
else
|
{ /* Deal with termination message: */
|
{ /* Deal with termination message: */
|
pmon_end_download (final, bintotal);
|
pmon_end_download (final, bintotal);
|
}
|
}
|
|
|
return;
|
return;
|
}
|
}
|
|
|
/* mips_load -- download a file. */
|
/* mips_load -- download a file. */
|
|
|
static void
|
static void
|
mips_load (file, from_tty)
|
mips_load (file, from_tty)
|
char *file;
|
char *file;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
/* Get the board out of remote debugging mode. */
|
/* Get the board out of remote debugging mode. */
|
if (mips_exit_debug ())
|
if (mips_exit_debug ())
|
error ("mips_load: Couldn't get into monitor mode.");
|
error ("mips_load: Couldn't get into monitor mode.");
|
|
|
if (mips_monitor != MON_IDT)
|
if (mips_monitor != MON_IDT)
|
pmon_load_fast (file);
|
pmon_load_fast (file);
|
else
|
else
|
mips_load_srec (file);
|
mips_load_srec (file);
|
|
|
mips_initialize ();
|
mips_initialize ();
|
|
|
/* Finally, make the PC point at the start address */
|
/* Finally, make the PC point at the start address */
|
if (mips_monitor != MON_IDT)
|
if (mips_monitor != MON_IDT)
|
{
|
{
|
/* Work around problem where PMON monitor updates the PC after a load
|
/* Work around problem where PMON monitor updates the PC after a load
|
to a different value than GDB thinks it has. The following ensures
|
to a different value than GDB thinks it has. The following ensures
|
that the write_pc() WILL update the PC value: */
|
that the write_pc() WILL update the PC value: */
|
register_valid[PC_REGNUM] = 0;
|
register_valid[PC_REGNUM] = 0;
|
}
|
}
|
if (exec_bfd)
|
if (exec_bfd)
|
write_pc (bfd_get_start_address (exec_bfd));
|
write_pc (bfd_get_start_address (exec_bfd));
|
|
|
inferior_pid = 0; /* No process now */
|
inferior_pid = 0; /* No process now */
|
|
|
/* This is necessary because many things were based on the PC at the time that
|
/* This is necessary because many things were based on the PC at the time that
|
we attached to the monitor, which is no longer valid now that we have loaded
|
we attached to the monitor, which is no longer valid now that we have loaded
|
new code (and just changed the PC). Another way to do this might be to call
|
new code (and just changed the PC). Another way to do this might be to call
|
normal_stop, except that the stack may not be valid, and things would get
|
normal_stop, except that the stack may not be valid, and things would get
|
horribly confused... */
|
horribly confused... */
|
|
|
clear_symtab_users ();
|
clear_symtab_users ();
|
}
|
}
|
|
|
|
|
/* Pass the command argument as a packet to PMON verbatim. */
|
/* Pass the command argument as a packet to PMON verbatim. */
|
|
|
static void
|
static void
|
pmon_command (args, from_tty)
|
pmon_command (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
char buf[DATA_MAXLEN + 1];
|
char buf[DATA_MAXLEN + 1];
|
int rlen;
|
int rlen;
|
|
|
sprintf (buf, "0x0 %s", args);
|
sprintf (buf, "0x0 %s", args);
|
mips_send_packet (buf, 1);
|
mips_send_packet (buf, 1);
|
printf_filtered ("Send packet: %s\n", buf);
|
printf_filtered ("Send packet: %s\n", buf);
|
|
|
rlen = mips_receive_packet (buf, 1, mips_receive_wait);
|
rlen = mips_receive_packet (buf, 1, mips_receive_wait);
|
buf[rlen] = '\0';
|
buf[rlen] = '\0';
|
printf_filtered ("Received packet: %s\n", buf);
|
printf_filtered ("Received packet: %s\n", buf);
|
}
|
}
|
|
|
void
|
void
|
_initialize_remote_mips ()
|
_initialize_remote_mips ()
|
{
|
{
|
/* Initialize the fields in mips_ops that are common to all four targets. */
|
/* Initialize the fields in mips_ops that are common to all four targets. */
|
mips_ops.to_longname = "Remote MIPS debugging over serial line";
|
mips_ops.to_longname = "Remote MIPS debugging over serial line";
|
mips_ops.to_close = mips_close;
|
mips_ops.to_close = mips_close;
|
mips_ops.to_detach = mips_detach;
|
mips_ops.to_detach = mips_detach;
|
mips_ops.to_resume = mips_resume;
|
mips_ops.to_resume = mips_resume;
|
mips_ops.to_fetch_registers = mips_fetch_registers;
|
mips_ops.to_fetch_registers = mips_fetch_registers;
|
mips_ops.to_store_registers = mips_store_registers;
|
mips_ops.to_store_registers = mips_store_registers;
|
mips_ops.to_prepare_to_store = mips_prepare_to_store;
|
mips_ops.to_prepare_to_store = mips_prepare_to_store;
|
mips_ops.to_xfer_memory = mips_xfer_memory;
|
mips_ops.to_xfer_memory = mips_xfer_memory;
|
mips_ops.to_files_info = mips_files_info;
|
mips_ops.to_files_info = mips_files_info;
|
mips_ops.to_insert_breakpoint = mips_insert_breakpoint;
|
mips_ops.to_insert_breakpoint = mips_insert_breakpoint;
|
mips_ops.to_remove_breakpoint = mips_remove_breakpoint;
|
mips_ops.to_remove_breakpoint = mips_remove_breakpoint;
|
mips_ops.to_kill = mips_kill;
|
mips_ops.to_kill = mips_kill;
|
mips_ops.to_load = mips_load;
|
mips_ops.to_load = mips_load;
|
mips_ops.to_create_inferior = mips_create_inferior;
|
mips_ops.to_create_inferior = mips_create_inferior;
|
mips_ops.to_mourn_inferior = mips_mourn_inferior;
|
mips_ops.to_mourn_inferior = mips_mourn_inferior;
|
mips_ops.to_stratum = process_stratum;
|
mips_ops.to_stratum = process_stratum;
|
mips_ops.to_has_all_memory = 1;
|
mips_ops.to_has_all_memory = 1;
|
mips_ops.to_has_memory = 1;
|
mips_ops.to_has_memory = 1;
|
mips_ops.to_has_stack = 1;
|
mips_ops.to_has_stack = 1;
|
mips_ops.to_has_registers = 1;
|
mips_ops.to_has_registers = 1;
|
mips_ops.to_has_execution = 1;
|
mips_ops.to_has_execution = 1;
|
mips_ops.to_magic = OPS_MAGIC;
|
mips_ops.to_magic = OPS_MAGIC;
|
|
|
/* Copy the common fields to all four target vectors. */
|
/* Copy the common fields to all four target vectors. */
|
pmon_ops = ddb_ops = lsi_ops = mips_ops;
|
pmon_ops = ddb_ops = lsi_ops = mips_ops;
|
|
|
/* Initialize target-specific fields in the target vectors. */
|
/* Initialize target-specific fields in the target vectors. */
|
mips_ops.to_shortname = "mips";
|
mips_ops.to_shortname = "mips";
|
mips_ops.to_doc = "\
|
mips_ops.to_doc = "\
|
Debug a board using the MIPS remote debugging protocol over a serial line.\n\
|
Debug a board using the MIPS remote debugging protocol over a serial line.\n\
|
The argument is the device it is connected to or, if it contains a colon,\n\
|
The argument is the device it is connected to or, if it contains a colon,\n\
|
HOST:PORT to access a board over a network";
|
HOST:PORT to access a board over a network";
|
mips_ops.to_open = mips_open;
|
mips_ops.to_open = mips_open;
|
mips_ops.to_wait = mips_wait;
|
mips_ops.to_wait = mips_wait;
|
|
|
pmon_ops.to_shortname = "pmon";
|
pmon_ops.to_shortname = "pmon";
|
pmon_ops.to_doc = "\
|
pmon_ops.to_doc = "\
|
Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
|
Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
|
line. The argument is the device it is connected to or, if it contains a\n\
|
line. The argument is the device it is connected to or, if it contains a\n\
|
colon, HOST:PORT to access a board over a network";
|
colon, HOST:PORT to access a board over a network";
|
pmon_ops.to_open = pmon_open;
|
pmon_ops.to_open = pmon_open;
|
pmon_ops.to_wait = mips_wait;
|
pmon_ops.to_wait = mips_wait;
|
|
|
ddb_ops.to_shortname = "ddb";
|
ddb_ops.to_shortname = "ddb";
|
ddb_ops.to_doc = "\
|
ddb_ops.to_doc = "\
|
Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
|
Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
|
line. The first argument is the device it is connected to or, if it contains\n\
|
line. The first argument is the device it is connected to or, if it contains\n\
|
a colon, HOST:PORT to access a board over a network. The optional second\n\
|
a colon, HOST:PORT to access a board over a network. The optional second\n\
|
parameter is the temporary file in the form HOST:FILENAME to be used for\n\
|
parameter is the temporary file in the form HOST:FILENAME to be used for\n\
|
TFTP downloads to the board. The optional third parameter is the local name\n\
|
TFTP downloads to the board. The optional third parameter is the local name\n\
|
of the TFTP temporary file, if it differs from the filename seen by the board.";
|
of the TFTP temporary file, if it differs from the filename seen by the board.";
|
ddb_ops.to_open = ddb_open;
|
ddb_ops.to_open = ddb_open;
|
ddb_ops.to_wait = mips_wait;
|
ddb_ops.to_wait = mips_wait;
|
|
|
lsi_ops.to_shortname = "lsi";
|
lsi_ops.to_shortname = "lsi";
|
lsi_ops.to_doc = pmon_ops.to_doc;
|
lsi_ops.to_doc = pmon_ops.to_doc;
|
lsi_ops.to_open = lsi_open;
|
lsi_ops.to_open = lsi_open;
|
lsi_ops.to_wait = mips_wait;
|
lsi_ops.to_wait = mips_wait;
|
|
|
/* Add the targets. */
|
/* Add the targets. */
|
add_target (&mips_ops);
|
add_target (&mips_ops);
|
add_target (&pmon_ops);
|
add_target (&pmon_ops);
|
add_target (&ddb_ops);
|
add_target (&ddb_ops);
|
add_target (&lsi_ops);
|
add_target (&lsi_ops);
|
|
|
add_show_from_set (
|
add_show_from_set (
|
add_set_cmd ("timeout", no_class, var_zinteger,
|
add_set_cmd ("timeout", no_class, var_zinteger,
|
(char *) &mips_receive_wait,
|
(char *) &mips_receive_wait,
|
"Set timeout in seconds for remote MIPS serial I/O.",
|
"Set timeout in seconds for remote MIPS serial I/O.",
|
&setlist),
|
&setlist),
|
&showlist);
|
&showlist);
|
|
|
add_show_from_set (
|
add_show_from_set (
|
add_set_cmd ("retransmit-timeout", no_class, var_zinteger,
|
add_set_cmd ("retransmit-timeout", no_class, var_zinteger,
|
(char *) &mips_retransmit_wait,
|
(char *) &mips_retransmit_wait,
|
"Set retransmit timeout in seconds for remote MIPS serial I/O.\n\
|
"Set retransmit timeout in seconds for remote MIPS serial I/O.\n\
|
This is the number of seconds to wait for an acknowledgement to a packet\n\
|
This is the number of seconds to wait for an acknowledgement to a packet\n\
|
before resending the packet.", &setlist),
|
before resending the packet.", &setlist),
|
&showlist);
|
&showlist);
|
|
|
add_show_from_set (
|
add_show_from_set (
|
add_set_cmd ("syn-garbage-limit", no_class, var_zinteger,
|
add_set_cmd ("syn-garbage-limit", no_class, var_zinteger,
|
(char *) &mips_syn_garbage,
|
(char *) &mips_syn_garbage,
|
"Set the maximum number of characters to ignore when scanning for a SYN.\n\
|
"Set the maximum number of characters to ignore when scanning for a SYN.\n\
|
This is the maximum number of characters GDB will ignore when trying to\n\
|
This is the maximum number of characters GDB will ignore when trying to\n\
|
synchronize with the remote system. A value of -1 means that there is no limit\n\
|
synchronize with the remote system. A value of -1 means that there is no limit\n\
|
(Note that these characters are printed out even though they are ignored.)",
|
(Note that these characters are printed out even though they are ignored.)",
|
&setlist),
|
&setlist),
|
&showlist);
|
&showlist);
|
|
|
add_show_from_set
|
add_show_from_set
|
(add_set_cmd ("monitor-prompt", class_obscure, var_string,
|
(add_set_cmd ("monitor-prompt", class_obscure, var_string,
|
(char *) &mips_monitor_prompt,
|
(char *) &mips_monitor_prompt,
|
"Set the prompt that GDB expects from the monitor.",
|
"Set the prompt that GDB expects from the monitor.",
|
&setlist),
|
&setlist),
|
&showlist);
|
&showlist);
|
|
|
add_show_from_set (
|
add_show_from_set (
|
add_set_cmd ("monitor-warnings", class_obscure, var_zinteger,
|
add_set_cmd ("monitor-warnings", class_obscure, var_zinteger,
|
(char *) &monitor_warnings,
|
(char *) &monitor_warnings,
|
"Set printing of monitor warnings.\n"
|
"Set printing of monitor warnings.\n"
|
"When enabled, monitor warnings about hardware breakpoints "
|
"When enabled, monitor warnings about hardware breakpoints "
|
"will be displayed.",
|
"will be displayed.",
|
&setlist),
|
&setlist),
|
&showlist);
|
&showlist);
|
|
|
add_com ("pmon <command>", class_obscure, pmon_command,
|
add_com ("pmon <command>", class_obscure, pmon_command,
|
"Send a packet to PMON (must be in debug mode).");
|
"Send a packet to PMON (must be in debug mode).");
|
}
|
}
|
|
|
