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