1 /* Remote debugging interface for MIPS remote debugging protocol.
2 Copyright 1993, 1994, 1995 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Ian Lance Taylor
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
31 #include "remote-utils.h"
32 #include "gdb_string.h"
35 #include <sys/types.h>
37 #ifdef ANSI_PROTOTYPES
43 /* Microsoft C's stat.h doesn't define all the POSIX file modes. */
45 #define S_IROTH S_IREAD
48 extern void mips_set_processor_type_command PARAMS ((char *, int));
51 /* Prototypes for local functions. */
53 static int mips_readchar PARAMS ((int timeout));
55 static int mips_receive_header PARAMS ((unsigned char *hdr, int *pgarbage,
56 int ch, int timeout));
58 static int mips_receive_trailer PARAMS ((unsigned char *trlr, int *pgarbage,
59 int *pch, int timeout));
61 static int mips_cksum PARAMS ((const unsigned char *hdr,
62 const unsigned char *data,
65 static void mips_send_packet PARAMS ((const char *s, int get_ack));
67 static void mips_send_command PARAMS ((const char *cmd, int prompt));
69 static int mips_receive_packet PARAMS ((char *buff, int throw_error,
72 static CORE_ADDR mips_request PARAMS ((int cmd, CORE_ADDR addr,
73 CORE_ADDR data, int *perr, int timeout,
76 static void mips_initialize PARAMS ((void));
78 static void mips_open PARAMS ((char *name, int from_tty));
80 static void pmon_open PARAMS ((char *name, int from_tty));
82 static void ddb_open PARAMS ((char *name, int from_tty));
84 static void lsi_open PARAMS ((char *name, int from_tty));
86 static void mips_close PARAMS ((int quitting));
88 static void mips_detach PARAMS ((char *args, int from_tty));
90 static void mips_resume PARAMS ((int pid, int step,
91 enum target_signal siggnal));
93 static int mips_wait PARAMS ((int pid, struct target_waitstatus *status));
95 static int pmon_wait PARAMS ((int pid, struct target_waitstatus *status));
97 static int mips_map_regno PARAMS ((int regno));
99 static void mips_fetch_registers PARAMS ((int regno));
101 static void mips_prepare_to_store PARAMS ((void));
103 static void mips_store_registers PARAMS ((int regno));
105 static unsigned int mips_fetch_word PARAMS ((CORE_ADDR addr));
107 static int mips_store_word PARAMS ((CORE_ADDR addr, unsigned int value,
108 char *old_contents));
110 static int mips_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
111 int write, struct target_ops *ignore));
113 static void mips_files_info PARAMS ((struct target_ops *ignore));
115 static void mips_create_inferior PARAMS ((char *execfile, char *args,
118 static void mips_mourn_inferior PARAMS ((void));
120 static int pmon_makeb64 PARAMS ((unsigned long v, char *p, int n, int *chksum));
122 static int pmon_zeroset PARAMS ((int recsize, char **buff, int *amount,
123 unsigned int *chksum));
125 static int pmon_checkset PARAMS ((int recsize, char **buff, int *value));
127 static void pmon_make_fastrec PARAMS ((char **outbuf, unsigned char *inbuf,
128 int *inptr, int inamount, int *recsize,
129 unsigned int *csum, unsigned int *zerofill));
131 static int pmon_check_ack PARAMS ((char *mesg));
133 static void pmon_start_download PARAMS ((void));
135 static void pmon_end_download PARAMS ((int final, int bintotal));
137 static void pmon_download PARAMS ((char *buffer, int length));
139 static void pmon_load_fast PARAMS ((char *file));
141 static void mips_load PARAMS ((char *file, int from_tty));
143 static int mips_make_srec PARAMS ((char *buffer, int type, CORE_ADDR memaddr,
144 unsigned char *myaddr, int len));
146 static int common_breakpoint PARAMS ((int cmd, CORE_ADDR addr, CORE_ADDR mask,
149 /* Forward declarations. */
150 extern struct target_ops mips_ops;
151 extern struct target_ops pmon_ops;
152 extern struct target_ops ddb_ops;
154 /* The MIPS remote debugging interface is built on top of a simple
155 packet protocol. Each packet is organized as follows:
157 SYN The first character is always a SYN (ASCII 026, or ^V). SYN
158 may not appear anywhere else in the packet. Any time a SYN is
159 seen, a new packet should be assumed to have begun.
162 This byte contains the upper five bits of the logical length
163 of the data section, plus a single bit indicating whether this
164 is a data packet or an acknowledgement. The documentation
165 indicates that this bit is 1 for a data packet, but the actual
166 board uses 1 for an acknowledgement. The value of the byte is
167 0x40 + (ack ? 0x20 : 0) + (len >> 6)
168 (we always have 0 <= len < 1024). Acknowledgement packets do
169 not carry data, and must have a data length of 0.
171 LEN1 This byte contains the lower six bits of the logical length of
172 the data section. The value is
175 SEQ This byte contains the six bit sequence number of the packet.
178 An acknowlegment packet contains the sequence number of the
179 packet being acknowledged plus 1 modulo 64. Data packets are
180 transmitted in sequence. There may only be one outstanding
181 unacknowledged data packet at a time. The sequence numbers
182 are independent in each direction. If an acknowledgement for
183 the previous packet is received (i.e., an acknowledgement with
184 the sequence number of the packet just sent) the packet just
185 sent should be retransmitted. If no acknowledgement is
186 received within a timeout period, the packet should be
187 retransmitted. This has an unfortunate failure condition on a
188 high-latency line, as a delayed acknowledgement may lead to an
189 endless series of duplicate packets.
191 DATA The actual data bytes follow. The following characters are
192 escaped inline with DLE (ASCII 020, or ^P):
198 The additional DLE characters are not counted in the logical
199 length stored in the TYPE_LEN and LEN1 bytes.
204 These bytes contain an 18 bit checksum of the complete
205 contents of the packet excluding the SEQ byte and the
206 CSUM[123] bytes. The checksum is simply the twos complement
207 addition of all the bytes treated as unsigned characters. The
208 values of the checksum bytes are:
209 CSUM1: 0x40 + ((cksum >> 12) & 0x3f)
210 CSUM2: 0x40 + ((cksum >> 6) & 0x3f)
211 CSUM3: 0x40 + (cksum & 0x3f)
213 It happens that the MIPS remote debugging protocol always
214 communicates with ASCII strings. Because of this, this
215 implementation doesn't bother to handle the DLE quoting mechanism,
216 since it will never be required. */
218 /* The SYN character which starts each packet. */
221 /* The 0x40 used to offset each packet (this value ensures that all of
222 the header and trailer bytes, other than SYN, are printable ASCII
224 #define HDR_OFFSET 0x40
226 /* The indices of the bytes in the packet header. */
227 #define HDR_INDX_SYN 0
228 #define HDR_INDX_TYPE_LEN 1
229 #define HDR_INDX_LEN1 2
230 #define HDR_INDX_SEQ 3
233 /* The data/ack bit in the TYPE_LEN header byte. */
234 #define TYPE_LEN_DA_BIT 0x20
235 #define TYPE_LEN_DATA 0
236 #define TYPE_LEN_ACK TYPE_LEN_DA_BIT
238 /* How to compute the header bytes. */
239 #define HDR_SET_SYN(data, len, seq) (SYN)
240 #define HDR_SET_TYPE_LEN(data, len, seq) \
242 + ((data) ? TYPE_LEN_DATA : TYPE_LEN_ACK) \
243 + (((len) >> 6) & 0x1f))
244 #define HDR_SET_LEN1(data, len, seq) (HDR_OFFSET + ((len) & 0x3f))
245 #define HDR_SET_SEQ(data, len, seq) (HDR_OFFSET + (seq))
247 /* Check that a header byte is reasonable. */
248 #define HDR_CHECK(ch) (((ch) & HDR_OFFSET) == HDR_OFFSET)
250 /* Get data from the header. These macros evaluate their argument
252 #define HDR_IS_DATA(hdr) \
253 (((hdr)[HDR_INDX_TYPE_LEN] & TYPE_LEN_DA_BIT) == TYPE_LEN_DATA)
254 #define HDR_GET_LEN(hdr) \
255 ((((hdr)[HDR_INDX_TYPE_LEN] & 0x1f) << 6) + (((hdr)[HDR_INDX_LEN1] & 0x3f)))
256 #define HDR_GET_SEQ(hdr) ((unsigned int)(hdr)[HDR_INDX_SEQ] & 0x3f)
258 /* The maximum data length. */
259 #define DATA_MAXLEN 1023
261 /* The trailer offset. */
262 #define TRLR_OFFSET HDR_OFFSET
264 /* The indices of the bytes in the packet trailer. */
265 #define TRLR_INDX_CSUM1 0
266 #define TRLR_INDX_CSUM2 1
267 #define TRLR_INDX_CSUM3 2
268 #define TRLR_LENGTH 3
270 /* How to compute the trailer bytes. */
271 #define TRLR_SET_CSUM1(cksum) (TRLR_OFFSET + (((cksum) >> 12) & 0x3f))
272 #define TRLR_SET_CSUM2(cksum) (TRLR_OFFSET + (((cksum) >> 6) & 0x3f))
273 #define TRLR_SET_CSUM3(cksum) (TRLR_OFFSET + (((cksum) ) & 0x3f))
275 /* Check that a trailer byte is reasonable. */
276 #define TRLR_CHECK(ch) (((ch) & TRLR_OFFSET) == TRLR_OFFSET)
278 /* Get data from the trailer. This evaluates its argument multiple
280 #define TRLR_GET_CKSUM(trlr) \
281 ((((trlr)[TRLR_INDX_CSUM1] & 0x3f) << 12) \
282 + (((trlr)[TRLR_INDX_CSUM2] & 0x3f) << 6) \
283 + ((trlr)[TRLR_INDX_CSUM3] & 0x3f))
285 /* The sequence number modulos. */
286 #define SEQ_MODULOS (64)
288 /* PMON commands to load from the serial port or UDP socket. */
289 #define LOAD_CMD "load -b -s tty0\r"
290 #define LOAD_CMD_UDP "load -b -s udp\r"
292 enum mips_monitor_type {
293 /* IDT/SIM monitor being used: */
295 /* PMON monitor being used: */
296 MON_PMON, /* 3.0.83 [COGENT,EB,FP,NET] Algorithmics Ltd. Nov 9 1995 17:19:50 */
297 MON_DDB, /* 2.7.473 [DDBVR4300,EL,FP,NET] Risq Modular Systems, Thu Jun 6 09:28:40 PDT 1996 */
298 MON_LSI, /* 4.3.12 [EB,FP], LSI LOGIC Corp. Tue Feb 25 13:22:14 1997 */
299 /* Last and unused value, for sizing vectors, etc. */
302 static enum mips_monitor_type mips_monitor = MON_LAST;
304 /* The monitor prompt text. If the user sets the PMON prompt
305 to some new value, the GDB `set monitor-prompt' command must also
306 be used to inform GDB about the expected prompt. Otherwise, GDB
307 will not be able to connect to PMON in mips_initialize().
308 If the `set monitor-prompt' command is not used, the expected
309 default prompt will be set according the target:
316 static char *mips_monitor_prompt;
318 /* Set to 1 if the target is open. */
319 static int mips_is_open;
321 /* Currently active target description (if mips_is_open == 1) */
322 static struct target_ops *current_ops;
324 /* Set to 1 while the connection is being initialized. */
325 static int mips_initializing;
327 /* Set to 1 while the connection is being brought down. */
328 static int mips_exiting;
330 /* The next sequence number to send. */
331 static unsigned int mips_send_seq;
333 /* The next sequence number we expect to receive. */
334 static unsigned int mips_receive_seq;
336 /* The time to wait before retransmitting a packet, in seconds. */
337 static int mips_retransmit_wait = 3;
339 /* The number of times to try retransmitting a packet before giving up. */
340 static int mips_send_retries = 10;
342 /* The number of garbage characters to accept when looking for an
343 SYN for the next packet. */
344 static int mips_syn_garbage = 1050;
346 /* The time to wait for a packet, in seconds. */
347 static int mips_receive_wait = 5;
349 /* Set if we have sent a packet to the board but have not yet received
351 static int mips_need_reply = 0;
353 /* Handle used to access serial I/O stream. */
354 static serial_t mips_desc;
356 /* UDP handle used to download files to target. */
357 static serial_t udp_desc;
358 static int udp_in_use;
360 /* TFTP filename used to download files to DDB board, in the form
362 static char *tftp_name; /* host:filename */
363 static char *tftp_localname; /* filename portion of above */
364 static int tftp_in_use;
365 static FILE *tftp_file;
367 /* Counts the number of times the user tried to interrupt the target (usually
369 static int interrupt_count;
371 /* If non-zero, means that the target is running. */
372 static int mips_wait_flag = 0;
374 /* If non-zero, monitor supports breakpoint commands. */
375 static monitor_supports_breakpoints = 0;
377 /* Data cache header. */
379 #if 0 /* not used (yet?) */
380 static DCACHE *mips_dcache;
383 /* Non-zero means that we've just hit a read or write watchpoint */
384 static int hit_watchpoint;
390 SERIAL_CLOSE (mips_desc);
394 SERIAL_CLOSE (udp_desc);
400 /* Handle low-level error that we can't recover from. Note that just
401 error()ing out from target_wait or some such low-level place will cause
402 all hell to break loose--the rest of GDB will tend to get left in an
403 inconsistent state. */
406 #ifdef ANSI_PROTOTYPES
407 mips_error (char *string, ...)
409 mips_error (va_alist)
415 #ifdef ANSI_PROTOTYPES
416 va_start (args, string);
420 string = va_arg (args, char *);
423 target_terminal_ours ();
424 wrap_here(""); /* Force out any buffered output */
425 gdb_flush (gdb_stdout);
427 fprintf_filtered (gdb_stderr, error_pre_print);
428 vfprintf_filtered (gdb_stderr, string, args);
429 fprintf_filtered (gdb_stderr, "\n");
431 gdb_flush (gdb_stderr);
433 /* Clean up in such a way that mips_close won't try to talk to the
434 board (it almost surely won't work since we weren't able to talk to
438 printf_unfiltered ("Ending remote MIPS debugging.\n");
439 target_mourn_inferior ();
441 return_to_top_level (RETURN_ERROR);
444 /* putc_readable - print a character, displaying non-printable chars in
445 ^x notation or in hex. */
452 putchar_unfiltered ('\n');
454 printf_unfiltered ("\\r");
455 else if (ch < 0x20) /* ASCII control character */
456 printf_unfiltered ("^%c", ch + '@');
457 else if (ch >= 0x7f) /* non-ASCII characters (rubout or greater) */
458 printf_unfiltered ("[%02x]", ch & 0xff);
460 putchar_unfiltered (ch);
464 /* puts_readable - print a string, displaying non-printable chars in
465 ^x notation or in hex. */
468 puts_readable (string)
473 while ((c = *string++) != '\0')
478 /* Wait until STRING shows up in mips_desc. Returns 1 if successful, else 0 if
479 timed out. TIMEOUT specifies timeout value in seconds.
483 mips_expect_timeout (string, timeout)
491 printf_unfiltered ("Expected \"");
492 puts_readable (string);
493 printf_unfiltered ("\", got \"");
501 /* Must use SERIAL_READCHAR here cuz mips_readchar would get confused if we
502 were waiting for the mips_monitor_prompt... */
504 c = SERIAL_READCHAR (mips_desc, timeout);
506 if (c == SERIAL_TIMEOUT)
509 printf_unfiltered ("\": FAIL\n");
522 printf_unfiltered ("\": OK\n");
535 /* Wait until STRING shows up in mips_desc. Returns 1 if successful, else 0 if
536 timed out. The timeout value is hard-coded to 2 seconds. Use
537 mips_expect_timeout if a different timeout value is needed.
544 return mips_expect_timeout (string, 2);
547 /* Read the required number of characters into the given buffer (which
548 is assumed to be large enough). The only failure is a timeout. */
550 mips_getstring (string, n)
560 c = SERIAL_READCHAR (mips_desc, 2);
562 if (c == SERIAL_TIMEOUT) {
563 fprintf_unfiltered (stderr, "Failed to read %d characters from target (TIMEOUT)\n", n);
574 /* Read a character from the remote, aborting on error. Returns
575 SERIAL_TIMEOUT on timeout (since that's what SERIAL_READCHAR
576 returns). FIXME: If we see the string mips_monitor_prompt from
577 the board, then we are debugging on the main console port, and we
578 have somehow dropped out of remote debugging mode. In this case,
579 we automatically go back in to remote debugging mode. This is a
580 hack, put in because I can't find any way for a program running on
581 the remote board to terminate without also ending remote debugging
582 mode. I assume users won't have any trouble with this; for one
583 thing, the IDT documentation generally assumes that the remote
584 debugging port is not the console port. This is, however, very
585 convenient for DejaGnu when you only have one connected serial
589 mips_readchar (timeout)
593 static int state = 0;
594 int mips_monitor_prompt_len = strlen (mips_monitor_prompt);
596 #ifdef MAINTENANCE_CMDS
601 if (i == -1 && watchdog > 0)
606 if (state == mips_monitor_prompt_len)
608 ch = SERIAL_READCHAR (mips_desc, timeout);
609 #ifdef MAINTENANCE_CMDS
610 if (ch == SERIAL_TIMEOUT && timeout == -1) /* Watchdog went off */
612 target_mourn_inferior ();
613 error ("Watchdog has expired. Target detached.\n");
616 if (ch == SERIAL_EOF)
617 mips_error ("End of file from remote");
618 if (ch == SERIAL_ERROR)
619 mips_error ("Error reading from remote: %s", safe_strerror (errno));
620 if (remote_debug > 1)
622 /* Don't use _filtered; we can't deal with a QUIT out of
623 target_wait, and I think this might be called from there. */
624 if (ch != SERIAL_TIMEOUT)
625 printf_unfiltered ("Read '%c' %d 0x%x\n", ch, ch, ch);
627 printf_unfiltered ("Timed out in read\n");
630 /* If we have seen mips_monitor_prompt and we either time out, or
631 we see a @ (which was echoed from a packet we sent), reset the
632 board as described above. The first character in a packet after
633 the SYN (which is not echoed) is always an @ unless the packet is
634 more than 64 characters long, which ours never are. */
635 if ((ch == SERIAL_TIMEOUT || ch == '@')
636 && state == mips_monitor_prompt_len
637 && ! mips_initializing
640 if (remote_debug > 0)
641 /* Don't use _filtered; we can't deal with a QUIT out of
642 target_wait, and I think this might be called from there. */
643 printf_unfiltered ("Reinitializing MIPS debugging mode\n");
650 /* At this point, about the only thing we can do is abort the command
651 in progress and get back to command level as quickly as possible. */
653 error ("Remote board reset, debug protocol re-initialized.");
656 if (ch == mips_monitor_prompt[state])
664 /* Get a packet header, putting the data in the supplied buffer.
665 PGARBAGE is a pointer to the number of garbage characters received
666 so far. CH is the last character received. Returns 0 for success,
667 or -1 for timeout. */
670 mips_receive_header (hdr, pgarbage, ch, timeout)
680 /* Wait for a SYN. mips_syn_garbage is intended to prevent
681 sitting here indefinitely if the board sends us one garbage
682 character per second. ch may already have a value from the
683 last time through the loop. */
686 ch = mips_readchar (timeout);
687 if (ch == SERIAL_TIMEOUT)
691 /* Printing the character here lets the user of gdb see
692 what the program is outputting, if the debugging is
693 being done on the console port. Don't use _filtered;
694 we can't deal with a QUIT out of target_wait. */
695 if (! mips_initializing || remote_debug > 0)
698 gdb_flush (gdb_stdout);
702 if (mips_syn_garbage > 0
703 && *pgarbage > mips_syn_garbage)
704 mips_error ("Debug protocol failure: more than %d characters before a sync.",
709 /* Get the packet header following the SYN. */
710 for (i = 1; i < HDR_LENGTH; i++)
712 ch = mips_readchar (timeout);
713 if (ch == SERIAL_TIMEOUT)
715 /* Make sure this is a header byte. */
716 if (ch == SYN || ! HDR_CHECK (ch))
722 /* If we got the complete header, we can return. Otherwise we
723 loop around and keep looking for SYN. */
729 /* Get a packet header, putting the data in the supplied buffer.
730 PGARBAGE is a pointer to the number of garbage characters received
731 so far. The last character read is returned in *PCH. Returns 0
732 for success, -1 for timeout, -2 for error. */
735 mips_receive_trailer (trlr, pgarbage, pch, timeout)
744 for (i = 0; i < TRLR_LENGTH; i++)
746 ch = mips_readchar (timeout);
748 if (ch == SERIAL_TIMEOUT)
750 if (! TRLR_CHECK (ch))
757 /* Get the checksum of a packet. HDR points to the packet header.
758 DATA points to the packet data. LEN is the length of DATA. */
761 mips_cksum (hdr, data, len)
762 const unsigned char *hdr;
763 const unsigned char *data;
766 register const unsigned char *p;
772 /* The initial SYN is not included in the checksum. */
786 /* Send a packet containing the given ASCII string. */
789 mips_send_packet (s, get_ack)
793 /* unsigned */ int len;
794 unsigned char *packet;
799 if (len > DATA_MAXLEN)
800 mips_error ("MIPS protocol data packet too long: %s", s);
802 packet = (unsigned char *) alloca (HDR_LENGTH + len + TRLR_LENGTH + 1);
804 packet[HDR_INDX_SYN] = HDR_SET_SYN (1, len, mips_send_seq);
805 packet[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (1, len, mips_send_seq);
806 packet[HDR_INDX_LEN1] = HDR_SET_LEN1 (1, len, mips_send_seq);
807 packet[HDR_INDX_SEQ] = HDR_SET_SEQ (1, len, mips_send_seq);
809 memcpy (packet + HDR_LENGTH, s, len);
811 cksum = mips_cksum (packet, packet + HDR_LENGTH, len);
812 packet[HDR_LENGTH + len + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
813 packet[HDR_LENGTH + len + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
814 packet[HDR_LENGTH + len + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
816 /* Increment the sequence number. This will set mips_send_seq to
817 the sequence number we expect in the acknowledgement. */
818 mips_send_seq = (mips_send_seq + 1) % SEQ_MODULOS;
820 /* We can only have one outstanding data packet, so we just wait for
821 the acknowledgement here. Keep retransmitting the packet until
822 we get one, or until we've tried too many times. */
823 for (try = 0; try < mips_send_retries; try++)
828 if (remote_debug > 0)
830 /* Don't use _filtered; we can't deal with a QUIT out of
831 target_wait, and I think this might be called from there. */
832 packet[HDR_LENGTH + len + TRLR_LENGTH] = '\0';
833 printf_unfiltered ("Writing \"%s\"\n", packet + 1);
836 if (SERIAL_WRITE (mips_desc, packet,
837 HDR_LENGTH + len + TRLR_LENGTH) != 0)
838 mips_error ("write to target failed: %s", safe_strerror (errno));
847 unsigned char hdr[HDR_LENGTH + 1];
848 unsigned char trlr[TRLR_LENGTH + 1];
852 /* Get the packet header. If we time out, resend the data
854 err = mips_receive_header (hdr, &garbage, ch, mips_retransmit_wait);
860 /* If we get a data packet, assume it is a duplicate and
861 ignore it. FIXME: If the acknowledgement is lost, this
862 data packet may be the packet the remote sends after the
864 if (HDR_IS_DATA (hdr)) {
867 /* Ignore any errors raised whilst attempting to ignore
870 len = HDR_GET_LEN (hdr);
872 for (i = 0; i < len; i++)
876 rch = mips_readchar (2);
882 if (rch == SERIAL_TIMEOUT)
884 /* ignore the character */
888 (void) mips_receive_trailer (trlr, &garbage, &ch, 2);
890 /* We don't bother checking the checksum, or providing an
891 ACK to the packet. */
895 /* If the length is not 0, this is a garbled packet. */
896 if (HDR_GET_LEN (hdr) != 0)
899 /* Get the packet trailer. */
900 err = mips_receive_trailer (trlr, &garbage, &ch,
901 mips_retransmit_wait);
903 /* If we timed out, resend the data packet. */
907 /* If we got a bad character, reread the header. */
911 /* If the checksum does not match the trailer checksum, this
912 is a bad packet; ignore it. */
913 if (mips_cksum (hdr, (unsigned char *) NULL, 0)
914 != TRLR_GET_CKSUM (trlr))
917 if (remote_debug > 0)
919 hdr[HDR_LENGTH] = '\0';
920 trlr[TRLR_LENGTH] = '\0';
921 /* Don't use _filtered; we can't deal with a QUIT out of
922 target_wait, and I think this might be called from there. */
923 printf_unfiltered ("Got ack %d \"%s%s\"\n",
924 HDR_GET_SEQ (hdr), hdr + 1, trlr);
927 /* If this ack is for the current packet, we're done. */
928 seq = HDR_GET_SEQ (hdr);
929 if (seq == mips_send_seq)
932 /* If this ack is for the last packet, resend the current
934 if ((seq + 1) % SEQ_MODULOS == mips_send_seq)
937 /* Otherwise this is a bad ack; ignore it. Increment the
938 garbage count to ensure that we do not stay in this loop
944 mips_error ("Remote did not acknowledge packet");
947 /* Receive and acknowledge a packet, returning the data in BUFF (which
948 should be DATA_MAXLEN + 1 bytes). The protocol documentation
949 implies that only the sender retransmits packets, so this code just
950 waits silently for a packet. It returns the length of the received
951 packet. If THROW_ERROR is nonzero, call error() on errors. If not,
952 don't print an error message and return -1. */
955 mips_receive_packet (buff, throw_error, timeout)
963 unsigned char ack[HDR_LENGTH + TRLR_LENGTH + 1];
970 unsigned char hdr[HDR_LENGTH];
971 unsigned char trlr[TRLR_LENGTH];
975 if (mips_receive_header (hdr, &garbage, ch, timeout) != 0)
978 mips_error ("Timed out waiting for remote packet");
985 /* An acknowledgement is probably a duplicate; ignore it. */
986 if (! HDR_IS_DATA (hdr))
988 len = HDR_GET_LEN (hdr);
989 /* Check if the length is valid for an ACK, we may aswell
990 try and read the remainder of the packet: */
993 /* Ignore the error condition, since we are going to
994 ignore the packet anyway. */
995 (void) mips_receive_trailer (trlr, &garbage, &ch, timeout);
997 /* Don't use _filtered; we can't deal with a QUIT out of
998 target_wait, and I think this might be called from there. */
999 if (remote_debug > 0)
1000 printf_unfiltered ("Ignoring unexpected ACK\n");
1004 len = HDR_GET_LEN (hdr);
1005 for (i = 0; i < len; i++)
1009 rch = mips_readchar (timeout);
1015 if (rch == SERIAL_TIMEOUT)
1018 mips_error ("Timed out waiting for remote packet");
1027 /* Don't use _filtered; we can't deal with a QUIT out of
1028 target_wait, and I think this might be called from there. */
1029 if (remote_debug > 0)
1030 printf_unfiltered ("Got new SYN after %d chars (wanted %d)\n",
1035 err = mips_receive_trailer (trlr, &garbage, &ch, timeout);
1039 mips_error ("Timed out waiting for packet");
1045 /* Don't use _filtered; we can't deal with a QUIT out of
1046 target_wait, and I think this might be called from there. */
1047 if (remote_debug > 0)
1048 printf_unfiltered ("Got SYN when wanted trailer\n");
1052 /* If this is the wrong sequence number, ignore it. */
1053 if (HDR_GET_SEQ (hdr) != mips_receive_seq)
1055 /* Don't use _filtered; we can't deal with a QUIT out of
1056 target_wait, and I think this might be called from there. */
1057 if (remote_debug > 0)
1058 printf_unfiltered ("Ignoring sequence number %d (want %d)\n",
1059 HDR_GET_SEQ (hdr), mips_receive_seq);
1063 if (mips_cksum (hdr, buff, len) == TRLR_GET_CKSUM (trlr))
1066 if (remote_debug > 0)
1067 /* Don't use _filtered; we can't deal with a QUIT out of
1068 target_wait, and I think this might be called from there. */
1069 printf_unfiltered ("Bad checksum; data %d, trailer %d\n",
1070 mips_cksum (hdr, buff, len),
1071 TRLR_GET_CKSUM (trlr));
1073 /* The checksum failed. Send an acknowledgement for the
1074 previous packet to tell the remote to resend the packet. */
1075 ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
1076 ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
1077 ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
1078 ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
1080 cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
1082 ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
1083 ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
1084 ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
1086 if (remote_debug > 0)
1088 ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
1089 /* Don't use _filtered; we can't deal with a QUIT out of
1090 target_wait, and I think this might be called from there. */
1091 printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
1095 if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
1098 mips_error ("write to target failed: %s", safe_strerror (errno));
1104 if (remote_debug > 0)
1107 /* Don't use _filtered; we can't deal with a QUIT out of
1108 target_wait, and I think this might be called from there. */
1109 printf_unfiltered ("Got packet \"%s\"\n", buff);
1112 /* We got the packet. Send an acknowledgement. */
1113 mips_receive_seq = (mips_receive_seq + 1) % SEQ_MODULOS;
1115 ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
1116 ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
1117 ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
1118 ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
1120 cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
1122 ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
1123 ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
1124 ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
1126 if (remote_debug > 0)
1128 ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
1129 /* Don't use _filtered; we can't deal with a QUIT out of
1130 target_wait, and I think this might be called from there. */
1131 printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
1135 if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
1138 mips_error ("write to target failed: %s", safe_strerror (errno));
1146 /* Optionally send a request to the remote system and optionally wait
1147 for the reply. This implements the remote debugging protocol,
1148 which is built on top of the packet protocol defined above. Each
1149 request has an ADDR argument and a DATA argument. The following
1150 requests are defined:
1152 \0 don't send a request; just wait for a reply
1153 i read word from instruction space at ADDR
1154 d read word from data space at ADDR
1155 I write DATA to instruction space at ADDR
1156 D write DATA to data space at ADDR
1157 r read register number ADDR
1158 R set register number ADDR to value DATA
1159 c continue execution (if ADDR != 1, set pc to ADDR)
1160 s single step (if ADDR != 1, set pc to ADDR)
1162 The read requests return the value requested. The write requests
1163 return the previous value in the changed location. The execution
1164 requests return a UNIX wait value (the approximate signal which
1165 caused execution to stop is in the upper eight bits).
1167 If PERR is not NULL, this function waits for a reply. If an error
1168 occurs, it sets *PERR to 1 and sets errno according to what the
1169 target board reports. */
1172 mips_request (cmd, addr, data, perr, timeout, buff)
1180 char myBuff[DATA_MAXLEN + 1];
1187 if (buff == (char *) NULL)
1192 if (mips_need_reply)
1193 fatal ("mips_request: Trying to send command before reply");
1194 sprintf (buff, "0x0 %c 0x%s 0x%s", cmd, paddr_nz (addr), paddr_nz (data));
1195 mips_send_packet (buff, 1);
1196 mips_need_reply = 1;
1199 if (perr == (int *) NULL)
1202 if (! mips_need_reply)
1203 fatal ("mips_request: Trying to get reply before command");
1205 mips_need_reply = 0;
1207 len = mips_receive_packet (buff, 1, timeout);
1210 if (sscanf (buff, "0x%x %c 0x%x 0x%x",
1211 &rpid, &rcmd, &rerrflg, &rresponse) != 4
1212 || (cmd != '\0' && rcmd != cmd))
1213 mips_error ("Bad response from remote board");
1219 /* FIXME: This will returns MIPS errno numbers, which may or may
1220 not be the same as errno values used on other systems. If
1221 they stick to common errno values, they will be the same, but
1222 if they don't, they must be translated. */
1233 mips_initialize_cleanups (arg)
1236 mips_initializing = 0;
1240 mips_exit_cleanups (arg)
1247 mips_send_command (cmd, prompt)
1251 SERIAL_WRITE (mips_desc, cmd, strlen(cmd));
1255 mips_expect (mips_monitor_prompt);
1258 /* Enter remote (dbx) debug mode: */
1262 /* Reset the sequence numbers, ready for the new debug sequence: */
1264 mips_receive_seq = 0;
1266 if (mips_monitor != MON_IDT)
1267 mips_send_command ("debug\r", 0);
1268 else /* assume IDT monitor by default */
1269 mips_send_command ("db tty0\r", 0);
1271 SERIAL_WRITE (mips_desc, "\r", sizeof "\r" - 1);
1273 /* We don't need to absorb any spurious characters here, since the
1274 mips_receive_header will eat up a reasonable number of characters
1275 whilst looking for the SYN, however this avoids the "garbage"
1276 being displayed to the user. */
1277 if (mips_monitor != MON_IDT)
1281 char buff[DATA_MAXLEN + 1];
1282 if (mips_receive_packet (buff, 1, 3) < 0)
1283 mips_error ("Failed to initialize (didn't receive packet).");
1287 /* Exit remote (dbx) debug mode, returning to the monitor prompt: */
1292 struct cleanup *old_cleanups = make_cleanup (mips_exit_cleanups, NULL);
1296 if (mips_monitor != MON_IDT)
1298 /* The DDB (NEC) and MiniRISC (LSI) versions of PMON exit immediately,
1299 so we do not get a reply to this command: */
1300 mips_request ('x', (unsigned int) 0, (unsigned int) 0, NULL,
1301 mips_receive_wait, NULL);
1302 mips_need_reply = 0;
1303 if (!mips_expect (" break!"))
1307 mips_request ('x', (unsigned int) 0, (unsigned int) 0, &err,
1308 mips_receive_wait, NULL);
1310 if (mips_monitor == MON_IDT && !mips_expect ("Exiting remote debug"))
1313 if (mips_monitor == MON_DDB)
1315 if (!mips_expect ("\n"))
1319 if (!mips_expect ("\r\n"))
1322 if (!mips_expect (mips_monitor_prompt))
1325 do_cleanups (old_cleanups);
1330 /* Initialize a new connection to the MIPS board, and make sure we are
1331 really connected. */
1337 struct cleanup *old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
1340 /* What is this code doing here? I don't see any way it can happen, and
1341 it might mean mips_initializing didn't get cleared properly.
1342 So I'll make it a warning. */
1344 if (mips_initializing)
1346 warning ("internal error: mips_initialize called twice");
1351 mips_initializing = 1;
1353 /* At this point, the packit protocol isn't responding. We'll try getting
1354 into the monitor, and restarting the protocol. */
1356 /* Force the system into the monitor. After this we *should* be at
1357 the mips_monitor_prompt. */
1358 if (mips_monitor != MON_IDT)
1359 j = 0; /* start by checking if we are already at the prompt */
1361 j = 1; /* start by sending a break */
1366 case 0: /* First, try sending a CR */
1367 SERIAL_FLUSH_INPUT (mips_desc);
1368 SERIAL_WRITE (mips_desc, "\r", 1);
1370 case 1: /* First, try sending a break */
1371 SERIAL_SEND_BREAK (mips_desc);
1373 case 2: /* Then, try a ^C */
1374 SERIAL_WRITE (mips_desc, "\003", 1);
1376 case 3: /* Then, try escaping from download */
1378 if (mips_monitor != MON_IDT)
1382 /* We shouldn't need to send multiple termination
1383 sequences, since the target performs line (or
1384 block) reads, and then processes those
1385 packets. In-case we were downloading a large packet
1386 we flush the output buffer before inserting a
1387 termination sequence. */
1388 SERIAL_FLUSH_OUTPUT (mips_desc);
1389 sprintf (tbuff, "\r/E/E\r");
1390 SERIAL_WRITE (mips_desc, tbuff, 6);
1397 /* We are possibly in binary download mode, having
1398 aborted in the middle of an S-record. ^C won't
1399 work because of binary mode. The only reliable way
1400 out is to send enough termination packets (8 bytes)
1401 to fill up and then overflow the largest size
1402 S-record (255 bytes in this case). This amounts to
1406 mips_make_srec (srec, '7', 0, NULL, 0);
1408 for (i = 1; i <= 33; i++)
1410 SERIAL_WRITE (mips_desc, srec, 8);
1412 if (SERIAL_READCHAR (mips_desc, 0) >= 0)
1413 break; /* Break immediatly if we get something from
1420 mips_error ("Failed to initialize.");
1423 if (mips_expect (mips_monitor_prompt))
1427 if (mips_monitor != MON_IDT)
1429 /* Ensure the correct target state: */
1430 if (mips_monitor != MON_LSI)
1431 mips_send_command ("set regsize 64\r", -1);
1432 mips_send_command ("set hostport tty0\r", -1);
1433 mips_send_command ("set brkcmd \"\"\r", -1);
1434 /* Delete all the current breakpoints: */
1435 mips_send_command ("db *\r", -1);
1436 /* NOTE: PMON does not have breakpoint support through the
1437 "debug" mode, only at the monitor command-line. */
1440 mips_enter_debug ();
1442 /* Clear all breakpoints: */
1443 if (mips_monitor == MON_IDT && common_breakpoint ('b', -1, 0, NULL) == 0)
1444 monitor_supports_breakpoints = 1;
1446 monitor_supports_breakpoints = 0;
1448 do_cleanups (old_cleanups);
1450 /* If this doesn't call error, we have connected; we don't care if
1451 the request itself succeeds or fails. */
1453 mips_request ('r', (unsigned int) 0, (unsigned int) 0, &err,
1454 mips_receive_wait, NULL);
1455 set_current_frame (create_new_frame (read_fp (), read_pc ()));
1456 select_frame (get_current_frame (), 0);
1459 /* Open a connection to the remote board. */
1461 common_open (ops, name, from_tty, new_monitor, new_monitor_prompt)
1462 struct target_ops *ops;
1465 enum mips_monitor_type new_monitor;
1466 char *new_monitor_prompt;
1469 char *serial_port_name;
1470 char *remote_name = 0;
1471 char *local_name = 0;
1476 "To open a MIPS remote debugging connection, you need to specify what serial\n\
1477 device is attached to the target board (e.g., /dev/ttya).\n"
1478 "If you want to use TFTP to download to the board, specify the name of a\n"
1479 "temporary file to be used by GDB for downloads as the second argument.\n"
1480 "This filename must be in the form host:filename, where host is the name\n"
1481 "of the host running the TFTP server, and the file must be readable by the\n"
1482 "world. If the local name of the temporary file differs from the name as\n"
1483 "seen from the board via TFTP, specify that name as the third parameter.\n");
1485 /* Parse the serial port name, the optional TFTP name, and the
1486 optional local TFTP name. */
1487 if ((argv = buildargv (name)) == NULL)
1489 make_cleanup (freeargv, (char *) argv);
1491 serial_port_name = strsave (argv[0]);
1492 if (argv[1]) /* remote TFTP name specified? */
1494 remote_name = argv[1];
1495 if (argv[2]) /* local TFTP filename specified? */
1496 local_name = argv[2];
1499 target_preopen (from_tty);
1502 unpush_target (current_ops);
1504 /* Open and initialize the serial port. */
1505 mips_desc = SERIAL_OPEN (serial_port_name);
1506 if (mips_desc == (serial_t) NULL)
1507 perror_with_name (serial_port_name);
1509 if (baud_rate != -1)
1511 if (SERIAL_SETBAUDRATE (mips_desc, baud_rate))
1513 SERIAL_CLOSE (mips_desc);
1514 perror_with_name (serial_port_name);
1518 SERIAL_RAW (mips_desc);
1520 /* Open and initialize the optional download port. If it is in the form
1521 hostname#portnumber, it's a UDP socket. If it is in the form
1522 hostname:filename, assume it's the TFTP filename that must be
1523 passed to the DDB board to tell it where to get the load file. */
1526 if (strchr (remote_name, '#'))
1528 udp_desc = SERIAL_OPEN (remote_name);
1530 perror_with_name ("Unable to open UDP port");
1535 /* Save the remote and local names of the TFTP temp file. If
1536 the user didn't specify a local name, assume it's the same
1537 as the part of the remote name after the "host:". */
1541 free (tftp_localname);
1542 if (local_name == NULL)
1543 if ((local_name = strchr (remote_name, ':')) != NULL)
1544 local_name++; /* skip over the colon */
1545 if (local_name == NULL)
1546 local_name = remote_name; /* local name same as remote name */
1547 tftp_name = strsave (remote_name);
1548 tftp_localname = strsave (local_name);
1556 /* Reset the expected monitor prompt if it's never been set before. */
1557 if (mips_monitor_prompt == NULL)
1558 mips_monitor_prompt = strsave (new_monitor_prompt);
1559 mips_monitor = new_monitor;
1564 printf_unfiltered ("Remote MIPS debugging using %s\n", serial_port_name);
1566 /* Switch to using remote target now. */
1569 /* FIXME: Should we call start_remote here? */
1571 /* Try to figure out the processor model if possible. */
1572 ptype = mips_read_processor_type ();
1574 mips_set_processor_type_command (strsave (ptype), 0);
1576 /* This is really the job of start_remote however, that makes an assumption
1577 that the target is about to print out a status message of some sort. That
1578 doesn't happen here (in fact, it may not be possible to get the monitor to
1579 send the appropriate packet). */
1581 flush_cached_frames ();
1582 registers_changed ();
1583 stop_pc = read_pc ();
1584 set_current_frame (create_new_frame (read_fp (), stop_pc));
1585 select_frame (get_current_frame (), 0);
1586 print_stack_frame (selected_frame, -1, 1);
1587 free (serial_port_name);
1591 mips_open (name, from_tty)
1595 common_open (&mips_ops, name, from_tty, MON_IDT, TARGET_MONITOR_PROMPT);
1599 pmon_open (name, from_tty)
1603 common_open (&pmon_ops, name, from_tty, MON_PMON, "PMON> ");
1607 ddb_open (name, from_tty)
1611 common_open (&ddb_ops, name, from_tty, MON_DDB, "NEC010>");
1615 lsi_open (name, from_tty)
1619 common_open (&ddb_ops, name, from_tty, MON_LSI, "PMON> ");
1622 /* Close a connection to the remote board. */
1625 mips_close (quitting)
1630 /* Get the board out of remote debugging mode. */
1631 (void) mips_exit_debug ();
1637 /* Detach from the remote board. */
1640 mips_detach (args, from_tty)
1645 error ("Argument given to \"detach\" when remotely debugging.");
1652 printf_unfiltered ("Ending remote MIPS debugging.\n");
1655 /* Tell the target board to resume. This does not wait for a reply
1659 mips_resume (pid, step, siggnal)
1661 enum target_signal siggnal;
1665 /* start-sanitize-gm */
1666 #ifndef GENERAL_MAGIC
1667 if (siggnal != TARGET_SIGNAL_0)
1669 ("Can't send signals to a remote system. Try `handle %s ignore'.",
1670 target_signal_to_name (siggnal));
1671 #endif /* GENERAL_MAGIC */
1672 /* end-sanitize-gm */
1674 /* LSI PMON requires returns a reply packet "0x1 s 0x0 0x57f" after
1675 a single step, so we wait for that. */
1676 mips_request (step ? 's' : 'c',
1678 (unsigned int) siggnal,
1679 mips_monitor == MON_LSI && step ? &err : (int *) NULL,
1680 mips_receive_wait, NULL);
1683 /* Return the signal corresponding to SIG, where SIG is the number which
1684 the MIPS protocol uses for the signal. */
1686 mips_signal_from_protocol (sig)
1689 /* We allow a few more signals than the IDT board actually returns, on
1690 the theory that there is at least *some* hope that perhaps the numbering
1691 for these signals is widely agreed upon. */
1694 return TARGET_SIGNAL_UNKNOWN;
1696 /* Don't want to use target_signal_from_host because we are converting
1697 from MIPS signal numbers, not host ones. Our internal numbers
1698 match the MIPS numbers for the signals the board can return, which
1699 are: SIGINT, SIGSEGV, SIGBUS, SIGILL, SIGFPE, SIGTRAP. */
1700 return (enum target_signal) sig;
1703 /* Wait until the remote stops, and return a wait status. */
1706 mips_wait (pid, status)
1708 struct target_waitstatus *status;
1712 char buff[DATA_MAXLEN];
1717 interrupt_count = 0;
1720 /* If we have not sent a single step or continue command, then the
1721 board is waiting for us to do something. Return a status
1722 indicating that it is stopped. */
1723 if (! mips_need_reply)
1725 status->kind = TARGET_WAITKIND_STOPPED;
1726 status->value.sig = TARGET_SIGNAL_TRAP;
1730 /* No timeout; we sit here as long as the program continues to execute. */
1732 rstatus = mips_request ('\000', (unsigned int) 0, (unsigned int) 0, &err, -1,
1736 mips_error ("Remote failure: %s", safe_strerror (errno));
1738 nfields = sscanf (buff, "0x%*x %*c 0x%*x 0x%*x 0x%x 0x%x 0x%x 0x%*x %s",
1739 &rpc, &rfp, &rsp, flags);
1741 /* See if we got back extended status. If so, pick out the pc, fp, sp, etc... */
1743 if (nfields == 7 || nfields == 9)
1745 char buf[MAX_REGISTER_RAW_SIZE];
1747 store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc);
1748 supply_register (PC_REGNUM, buf);
1750 store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rfp);
1751 supply_register (30, buf); /* This register they are avoiding and so it is unnamed */
1753 store_unsigned_integer (buf, REGISTER_RAW_SIZE (SP_REGNUM), rsp);
1754 supply_register (SP_REGNUM, buf);
1756 store_unsigned_integer (buf, REGISTER_RAW_SIZE (FP_REGNUM), 0);
1757 supply_register (FP_REGNUM, buf);
1763 for (i = 0; i <= 2; i++)
1764 if (flags[i] == 'r' || flags[i] == 'w')
1766 else if (flags[i] == '\000')
1771 /* Translate a MIPS waitstatus. We use constants here rather than WTERMSIG
1772 and so on, because the constants we want here are determined by the
1773 MIPS protocol and have nothing to do with what host we are running on. */
1774 if ((rstatus & 0377) == 0)
1776 status->kind = TARGET_WAITKIND_EXITED;
1777 status->value.integer = (((rstatus) >> 8) & 0377);
1779 else if ((rstatus & 0377) == 0177)
1781 status->kind = TARGET_WAITKIND_STOPPED;
1782 status->value.sig = mips_signal_from_protocol (((rstatus) >> 8) & 0377);
1786 status->kind = TARGET_WAITKIND_SIGNALLED;
1787 status->value.sig = mips_signal_from_protocol (rstatus & 0177);
1794 pmon_wait (pid, status)
1796 struct target_waitstatus *status;
1800 char buff[DATA_MAXLEN];
1802 interrupt_count = 0;
1805 /* If we have not sent a single step or continue command, then the
1806 board is waiting for us to do something. Return a status
1807 indicating that it is stopped. */
1808 if (! mips_need_reply)
1810 status->kind = TARGET_WAITKIND_STOPPED;
1811 status->value.sig = TARGET_SIGNAL_TRAP;
1815 /* Sit, polling the serial until the target decides to talk to
1816 us. NOTE: the timeout value we use is used not just for the
1817 first character, but for all the characters. */
1819 rstatus = mips_request ('\000', (unsigned int) 0, (unsigned int) 0, &err, -1,
1823 mips_error ("Remote failure: %s", safe_strerror (errno));
1825 /* NOTE: The following (sig) numbers are defined by PMON:
1826 SPP_SIGTRAP 5 breakpoint
1834 /* On returning from a continue, the PMON monitor seems to start
1835 echoing back the messages we send prior to sending back the
1836 ACK. The code can cope with this, but to try and avoid the
1837 unnecessary serial traffic, and "spurious" characters displayed
1838 to the user, we cheat and reset the debug protocol. The problems
1839 seems to be caused by a check on the number of arguments, and the
1840 command length, within the monitor causing it to echo the command
1842 if (mips_monitor != MON_DDB && mips_monitor != MON_LSI)
1845 mips_enter_debug ();
1848 /* Translate a MIPS waitstatus. We use constants here rather than WTERMSIG
1849 and so on, because the constants we want here are determined by the
1850 MIPS protocol and have nothing to do with what host we are running on. */
1851 if ((rstatus & 0377) == 0)
1853 status->kind = TARGET_WAITKIND_EXITED;
1854 status->value.integer = (((rstatus) >> 8) & 0377);
1856 else if ((rstatus & 0377) == 0177)
1858 status->kind = TARGET_WAITKIND_STOPPED;
1859 status->value.sig = mips_signal_from_protocol (((rstatus) >> 8) & 0377);
1863 status->kind = TARGET_WAITKIND_SIGNALLED;
1864 status->value.sig = mips_signal_from_protocol (rstatus & 0177);
1870 /* We have to map between the register numbers used by gdb and the
1871 register numbers used by the debugging protocol. This function
1872 assumes that we are using tm-mips.h. */
1874 #define REGNO_OFFSET 96
1877 mips_map_regno (regno)
1882 if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
1883 return regno - FP0_REGNUM + 32;
1887 return REGNO_OFFSET + 0;
1889 return REGNO_OFFSET + 1;
1891 return REGNO_OFFSET + 2;
1893 return REGNO_OFFSET + 3;
1895 return REGNO_OFFSET + 4;
1897 return REGNO_OFFSET + 5;
1899 /* FIXME: Is there a way to get the status register? */
1904 /* Fetch the remote registers. */
1907 mips_fetch_registers (regno)
1910 unsigned LONGEST val;
1915 for (regno = 0; regno < NUM_REGS; regno++)
1916 mips_fetch_registers (regno);
1920 if (regno == FP_REGNUM || regno == ZERO_REGNUM)
1921 /* FP_REGNUM on the mips is a hack which is just supposed to read
1922 zero (see also mips-nat.c). */
1926 /* If PMON doesn't support this register, don't waste serial
1927 bandwidth trying to read it. */
1928 int pmon_reg = mips_map_regno (regno);
1929 if (regno != 0 && pmon_reg == 0)
1933 /* Unfortunately the PMON version in the Vr4300 board has been
1934 compiled without the 64bit register access commands. This
1935 means we cannot get hold of the full register width. */
1936 if (mips_monitor == MON_DDB)
1937 val = (unsigned)mips_request ('t', (unsigned int) pmon_reg,
1938 (unsigned int) 0, &err, mips_receive_wait, NULL);
1940 val = mips_request ('r', (unsigned int) pmon_reg,
1941 (unsigned int) 0, &err, mips_receive_wait, NULL);
1943 mips_error ("Can't read register %d: %s", regno,
1944 safe_strerror (errno));
1949 char buf[MAX_REGISTER_RAW_SIZE];
1951 /* We got the number the register holds, but gdb expects to see a
1952 value in the target byte ordering. */
1953 store_unsigned_integer (buf, REGISTER_RAW_SIZE (regno), val);
1954 supply_register (regno, buf);
1958 /* Prepare to store registers. The MIPS protocol can store individual
1959 registers, so this function doesn't have to do anything. */
1962 mips_prepare_to_store ()
1966 /* Store remote register(s). */
1969 mips_store_registers (regno)
1976 for (regno = 0; regno < NUM_REGS; regno++)
1977 mips_store_registers (regno);
1981 mips_request ('R', (unsigned int) mips_map_regno (regno),
1982 read_register (regno),
1983 &err, mips_receive_wait, NULL);
1985 mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));
1988 /* Fetch a word from the target board. */
1991 mips_fetch_word (addr)
1997 /* FIXME! addr was cast to uint! */
1998 val = mips_request ('d', addr, (unsigned int) 0, &err,
1999 mips_receive_wait, NULL);
2002 /* Data space failed; try instruction space. */
2003 /* FIXME! addr was cast to uint! */
2004 val = mips_request ('i', addr, (unsigned int) 0, &err,
2005 mips_receive_wait, NULL);
2007 mips_error ("Can't read address 0x%s: %s",
2008 paddr_nz (addr), safe_strerror (errno));
2013 /* Store a word to the target board. Returns errno code or zero for
2014 success. If OLD_CONTENTS is non-NULL, put the old contents of that
2015 memory location there. */
2017 /* FIXME! make sure only 32-bit quantities get stored! */
2019 mips_store_word (addr, val, old_contents)
2025 unsigned int oldcontents;
2027 oldcontents = mips_request ('D', addr, (unsigned int) val,
2029 mips_receive_wait, NULL);
2032 /* Data space failed; try instruction space. */
2033 oldcontents = mips_request ('I', addr,
2034 (unsigned int) val, &err,
2035 mips_receive_wait, NULL);
2039 if (old_contents != NULL)
2040 store_unsigned_integer (old_contents, 4, oldcontents);
2044 /* Read or write LEN bytes from inferior memory at MEMADDR,
2045 transferring to or from debugger address MYADDR. Write to inferior
2046 if SHOULD_WRITE is nonzero. Returns length of data written or
2047 read; 0 for error. Note that protocol gives us the correct value
2048 for a longword, since it transfers values in ASCII. We want the
2049 byte values, so we have to swap the longword values. */
2052 mips_xfer_memory (memaddr, myaddr, len, write, ignore)
2057 struct target_ops *ignore;
2060 /* Round starting address down to longword boundary. */
2061 register CORE_ADDR addr = memaddr &~ 3;
2062 /* Round ending address up; get number of longwords that makes. */
2063 register int count = (((memaddr + len) - addr) + 3) / 4;
2064 /* Allocate buffer of that many longwords. */
2065 register char *buffer = alloca (count * 4);
2071 /* Fill start and end extra bytes of buffer with existing data. */
2072 if (addr != memaddr || len < 4)
2074 /* Need part of initial word -- fetch it. */
2075 store_unsigned_integer (&buffer[0], 4, mips_fetch_word (addr));
2080 /* Need part of last word -- fetch it. FIXME: we do this even
2081 if we don't need it. */
2082 store_unsigned_integer (&buffer[(count - 1) * 4], 4,
2083 mips_fetch_word (addr + (count - 1) * 4));
2086 /* Copy data to be written over corresponding part of buffer */
2088 memcpy ((char *) buffer + (memaddr & 3), myaddr, len);
2090 /* Write the entire buffer. */
2092 for (i = 0; i < count; i++, addr += 4)
2094 status = mips_store_word (addr,
2095 extract_unsigned_integer (&buffer[i*4], 4),
2097 /* Report each kilobyte (we download 32-bit words at a time) */
2100 printf_unfiltered ("*");
2108 /* FIXME: Do we want a QUIT here? */
2111 printf_unfiltered ("\n");
2115 /* Read all the longwords */
2116 for (i = 0; i < count; i++, addr += 4)
2118 store_unsigned_integer (&buffer[i*4], 4, mips_fetch_word (addr));
2122 /* Copy appropriate bytes out of the buffer. */
2123 memcpy (myaddr, buffer + (memaddr & 3), len);
2128 /* Print info on this target. */
2131 mips_files_info (ignore)
2132 struct target_ops *ignore;
2134 printf_unfiltered ("Debugging a MIPS board over a serial line.\n");
2137 /* Kill the process running on the board. This will actually only
2138 work if we are doing remote debugging over the console input. I
2139 think that if IDT/sim had the remote debug interrupt enabled on the
2140 right port, we could interrupt the process with a break signal. */
2145 if (!mips_wait_flag)
2150 if (interrupt_count >= 2)
2152 interrupt_count = 0;
2154 target_terminal_ours ();
2156 if (query ("Interrupted while waiting for the program.\n\
2157 Give up (and stop debugging it)? "))
2159 /* Clean up in such a way that mips_close won't try to talk to the
2160 board (it almost surely won't work since we weren't able to talk to
2165 printf_unfiltered ("Ending remote MIPS debugging.\n");
2166 target_mourn_inferior ();
2168 return_to_top_level (RETURN_QUIT);
2171 target_terminal_inferior ();
2174 if (remote_debug > 0)
2175 printf_unfiltered ("Sending break\n");
2177 SERIAL_SEND_BREAK (mips_desc);
2186 SERIAL_WRITE (mips_desc, &cc, 1);
2188 target_mourn_inferior ();
2193 /* Start running on the target board. */
2196 mips_create_inferior (execfile, args, env)
2206 Can't pass arguments to remote MIPS board; arguments ignored.");
2207 /* And don't try to use them on the next "run" command. */
2208 execute_command ("set args", 0);
2211 if (execfile == 0 || exec_bfd == 0)
2212 error ("No executable file specified");
2214 entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
2216 init_wait_for_inferior ();
2218 /* FIXME: Should we set inferior_pid here? */
2220 /* start-sanitize-gm */
2221 #ifdef GENERAL_MAGIC
2222 magic_create_inferior_hook ();
2223 proceed (entry_pt, TARGET_SIGNAL_PWR, 0);
2225 /* end-sanitize-gm */
2226 proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
2227 /* start-sanitize-gm */
2228 #endif /* GENERAL_MAGIC */
2229 /* end-sanitize-gm */
2232 /* Clean up after a process. Actually nothing to do. */
2235 mips_mourn_inferior ()
2237 if (current_ops != NULL)
2238 unpush_target (current_ops);
2239 generic_mourn_inferior ();
2242 /* We can write a breakpoint and read the shadow contents in one
2245 /* The IDT board uses an unusual breakpoint value, and sometimes gets
2246 confused when it sees the usual MIPS breakpoint instruction. */
2248 #define BREAK_INSN (0x00000a0d)
2249 #define BREAK_INSN_SIZE (4)
2251 /* Insert a breakpoint on targets that don't have any better breakpoint
2252 support. We read the contents of the target location and stash it,
2253 then overwrite it with a breakpoint instruction. ADDR is the target
2254 location in the target machine. CONTENTS_CACHE is a pointer to
2255 memory allocated for saving the target contents. It is guaranteed
2256 by the caller to be long enough to save sizeof BREAKPOINT bytes (this
2257 is accomplished via BREAKPOINT_MAX). */
2260 mips_insert_breakpoint (addr, contents_cache)
2262 char *contents_cache;
2264 if (monitor_supports_breakpoints)
2265 return common_breakpoint ('B', addr, 0x3, "f");
2267 return mips_store_word (addr, BREAK_INSN, contents_cache);
2271 mips_remove_breakpoint (addr, contents_cache)
2273 char *contents_cache;
2275 if (monitor_supports_breakpoints)
2276 return common_breakpoint ('b', addr, 0, NULL);
2278 return target_write_memory (addr, contents_cache, BREAK_INSN_SIZE);
2281 #if 0 /* currently not used */
2282 /* PMON does not currently provide support for the debug mode 'b'
2283 commands to manipulate breakpoints. However, if we wanted to use
2284 the monitor breakpoints (rather than the GDB BREAK_INSN version)
2285 then this code performs the work needed to leave debug mode,
2286 set/clear the breakpoint, and then return to debug mode. */
2288 #define PMON_MAX_BP (33) /* 32 SW, 1 HW */
2289 static CORE_ADDR mips_pmon_bp_info[PMON_MAX_BP];
2290 /* NOTE: The code relies on this vector being zero-initialised by the system */
2293 pmon_insert_breakpoint (addr, contents_cache)
2295 char *contents_cache;
2299 if (monitor_supports_breakpoints)
2301 char tbuff[12]; /* space for breakpoint command */
2305 /* PMON does not support debug level breakpoint set/remove: */
2306 if (mips_exit_debug ())
2307 mips_error ("Failed to exit debug mode");
2309 sprintf (tbuff, "b %08x\r", addr);
2310 mips_send_command (tbuff, 0);
2312 mips_expect ("Bpt ");
2314 if (!mips_getstring (tbuff, 2))
2316 tbuff[2] = '\0'; /* terminate the string */
2317 if (sscanf (tbuff, "%d", &bpnum) != 1)
2319 fprintf_unfiltered (stderr, "Invalid decimal breakpoint number from target: %s\n", tbuff);
2323 mips_expect (" = ");
2325 /* Lead in the hex number we are expecting: */
2329 /* FIXME!! only 8 bytes! need to expand for Bfd64;
2330 which targets return 64-bit addresses? PMON returns only 32! */
2331 if (!mips_getstring (&tbuff[2], 8))
2333 tbuff[10] = '\0'; /* terminate the string */
2335 if (sscanf (tbuff, "0x%08x", &bpaddr) != 1)
2337 fprintf_unfiltered (stderr, "Invalid hex address from target: %s\n", tbuff);
2341 if (bpnum >= PMON_MAX_BP)
2343 fprintf_unfiltered (stderr, "Error: Returned breakpoint number %d outside acceptable range (0..%d)\n",
2344 bpnum, PMON_MAX_BP - 1);
2349 fprintf_unfiltered (stderr, "Warning: Breakpoint addresses do not match: 0x%x != 0x%x\n", addr, bpaddr);
2351 mips_pmon_bp_info[bpnum] = bpaddr;
2353 mips_expect ("\r\n");
2354 mips_expect (mips_monitor_prompt);
2356 mips_enter_debug ();
2361 return mips_store_word (addr, BREAK_INSN, contents_cache);
2365 pmon_remove_breakpoint (addr, contents_cache)
2367 char *contents_cache;
2369 if (monitor_supports_breakpoints)
2372 char tbuff[7]; /* enough for delete breakpoint command */
2374 for (bpnum = 0; bpnum < PMON_MAX_BP; bpnum++)
2375 if (mips_pmon_bp_info[bpnum] == addr)
2378 if (bpnum >= PMON_MAX_BP)
2380 fprintf_unfiltered (stderr,
2381 "pmon_remove_breakpoint: Failed to find breakpoint at address 0x%s\n",
2386 if (mips_exit_debug ())
2387 mips_error ("Failed to exit debug mode");
2389 sprintf (tbuff, "db %02d\r", bpnum);
2391 mips_send_command (tbuff, -1);
2392 /* NOTE: If the breakpoint does not exist then a "Bpt <dd> not
2393 set" message will be returned. */
2395 mips_enter_debug ();
2400 return target_write_memory (addr, contents_cache, BREAK_INSN_SIZE);
2404 /* Compute a don't care mask for the region bounding ADDR and ADDR + LEN - 1.
2405 This is used for memory ref breakpoints. */
2407 static unsigned long
2408 calculate_mask (addr, len)
2415 mask = addr ^ (addr + len - 1);
2417 for (i = 32; i >= 0; i--)
2423 mask = (unsigned long) 0xffffffff >> i;
2428 /* Set a data watchpoint. ADDR and LEN should be obvious. TYPE is either 1
2429 for a read watchpoint, or 2 for a read/write watchpoint. */
2432 remote_mips_set_watchpoint (addr, len, type)
2437 CORE_ADDR first_addr;
2441 mask = calculate_mask (addr, len);
2443 first_addr = addr & ~mask;
2453 case 2: /* read/write */
2460 if (common_breakpoint ('B', first_addr, mask, flags))
2467 remote_mips_remove_watchpoint (addr, len, type)
2472 CORE_ADDR first_addr;
2475 mask = calculate_mask (addr, len);
2477 first_addr = addr & ~mask;
2479 if (common_breakpoint ('b', first_addr, 0, NULL))
2486 remote_mips_stopped_by_watchpoint ()
2488 return hit_watchpoint;
2491 /* This routine generates the a breakpoint command of the form:
2493 0x0 <CMD> <ADDR> <MASK> <FLAGS>
2495 Where <CMD> is one of: `B' to set, or `b' to clear a breakpoint. <ADDR> is
2496 the address of the breakpoint. <MASK> is a don't care mask for addresses.
2497 <FLAGS> is any combination of `r', `w', or `f' for read/write/or fetch.
2499 Return 0 if successful; otherwise 1. */
2502 common_breakpoint (cmd, addr, mask, flags)
2509 char buf[DATA_MAXLEN + 1];
2511 int rpid, rerrflg, rresponse;
2514 addr = ADDR_BITS_REMOVE (addr);
2516 sprintf (buf, "0x0 %c 0x%s 0x%s %s", cmd, paddr_nz (addr), paddr_nz (mask),
2519 sprintf (buf, "0x0 %c 0x%s", cmd, paddr_nz (addr));
2521 mips_send_packet (buf, 1);
2523 len = mips_receive_packet (buf, 1, mips_receive_wait);
2526 nfields = sscanf (buf, "0x%x %c 0x%x 0x%x", &rpid, &rcmd, &rerrflg, &rresponse);
2530 mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
2534 /* Ddb returns "0x0 b 0x16 0x0\000", whereas
2535 Cogent returns "0x0 b 0xffffffff 0x16\000": */
2536 if (mips_monitor == MON_DDB)
2537 rresponse = rerrflg;
2538 if (rresponse != 22) /* invalid argument */
2539 fprintf_unfiltered (stderr, "common_breakpoint (0x%s): Got error: 0x%x\n",
2540 paddr_nz (addr), rresponse);
2548 send_srec (srec, len, addr)
2557 SERIAL_WRITE (mips_desc, srec, len);
2559 ch = mips_readchar (2);
2563 case SERIAL_TIMEOUT:
2564 error ("Timeout during download.");
2568 case 0x15: /* NACK */
2569 fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %d! Retrying.\n", addr);
2572 error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);
2577 /* Download a binary file by converting it to S records. */
2580 mips_load_srec (args)
2585 char *buffer, srec[1024];
2587 unsigned int srec_frame = 200;
2589 static int hashmark = 1;
2591 buffer = alloca (srec_frame * 2 + 256);
2593 abfd = bfd_openr (args, 0);
2596 printf_filtered ("Unable to open file %s\n", args);
2600 if (bfd_check_format (abfd, bfd_object) == 0)
2602 printf_filtered ("File is not an object file\n");
2606 /* This actually causes a download in the IDT binary format: */
2607 mips_send_command (LOAD_CMD, 0);
2609 for (s = abfd->sections; s; s = s->next)
2611 if (s->flags & SEC_LOAD)
2613 unsigned int numbytes;
2615 /* FIXME! vma too small?? */
2616 printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s->name, s->vma,
2617 s->vma + s->_raw_size);
2618 gdb_flush (gdb_stdout);
2620 for (i = 0; i < s->_raw_size; i += numbytes)
2622 numbytes = min (srec_frame, s->_raw_size - i);
2624 bfd_get_section_contents (abfd, s, buffer, i, numbytes);
2626 reclen = mips_make_srec (srec, '3', s->vma + i, buffer, numbytes);
2627 send_srec (srec, reclen, s->vma + i);
2631 putchar_unfiltered ('#');
2632 gdb_flush (gdb_stdout);
2635 } /* Per-packet (or S-record) loop */
2637 putchar_unfiltered ('\n');
2638 } /* Loadable sections */
2641 putchar_unfiltered ('\n');
2643 /* Write a type 7 terminator record. no data for a type 7, and there
2644 is no data, so len is 0. */
2646 reclen = mips_make_srec (srec, '7', abfd->start_address, NULL, 0);
2648 send_srec (srec, reclen, abfd->start_address);
2650 SERIAL_FLUSH_INPUT (mips_desc);
2654 * mips_make_srec -- make an srecord. This writes each line, one at a
2655 * time, each with it's own header and trailer line.
2656 * An srecord looks like this:
2658 * byte count-+ address
2659 * start ---+ | | data +- checksum
2661 * S01000006F6B692D746573742E73726563E4
2662 * S315000448600000000000000000FC00005900000000E9
2663 * S31A0004000023C1400037DE00F023604000377B009020825000348D
2664 * S30B0004485A0000000000004E
2667 * S<type><length><address><data><checksum>
2671 * is the number of bytes following upto the checksum. Note that
2672 * this is not the number of chars following, since it takes two
2673 * chars to represent a byte.
2677 * 1) two byte address data record
2678 * 2) three byte address data record
2679 * 3) four byte address data record
2680 * 7) four byte address termination record
2681 * 8) three byte address termination record
2682 * 9) two byte address termination record
2685 * is the start address of the data following, or in the case of
2686 * a termination record, the start address of the image
2690 * is the sum of all the raw byte data in the record, from the length
2691 * upwards, modulo 256 and subtracted from 255.
2693 * This routine returns the length of the S-record.
2698 mips_make_srec (buf, type, memaddr, myaddr, len)
2702 unsigned char *myaddr;
2705 unsigned char checksum;
2708 /* Create the header for the srec. addr_size is the number of bytes in the address,
2709 and 1 is the number of bytes in the count. */
2711 /* FIXME!! bigger buf required for 64-bit! */
2714 buf[2] = len + 4 + 1; /* len + 4 byte address + 1 byte checksum */
2715 /* This assumes S3 style downloads (4byte addresses). There should
2716 probably be a check, or the code changed to make it more
2718 buf[3] = memaddr >> 24;
2719 buf[4] = memaddr >> 16;
2720 buf[5] = memaddr >> 8;
2722 memcpy (&buf[7], myaddr, len);
2724 /* Note that the checksum is calculated on the raw data, not the
2725 hexified data. It includes the length, address and the data
2726 portions of the packet. */
2728 buf += 2; /* Point at length byte */
2729 for (i = 0; i < len + 4 + 1; i++)
2737 /* The following manifest controls whether we enable the simple flow
2738 control support provided by the monitor. If enabled the code will
2739 wait for an affirmative ACK between transmitting packets. */
2740 #define DOETXACK (1)
2742 /* The PMON fast-download uses an encoded packet format constructed of
2743 3byte data packets (encoded as 4 printable ASCII characters), and
2744 escape sequences (preceded by a '/'):
2747 'C' compare checksum (12bit value, not included in checksum calculation)
2748 'S' define symbol name (for addr) terminated with "," and padded to 4char boundary
2749 'Z' zero fill multiple of 3bytes
2750 'B' byte (12bit encoded value, of 8bit data)
2751 'A' address (36bit encoded value)
2752 'E' define entry as original address, and exit load
2754 The packets are processed in 4 character chunks, so the escape
2755 sequences that do not have any data (or variable length data)
2756 should be padded to a 4 character boundary. The decoder will give
2757 an error if the complete message block size is not a multiple of
2758 4bytes (size of record).
2760 The encoding of numbers is done in 6bit fields. The 6bit value is
2761 used to index into this string to get the specific character
2762 encoding for the value: */
2763 static char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,.";
2765 /* Convert the number of bits required into an encoded number, 6bits
2766 at a time (range 0..63). Keep a checksum if required (passed
2767 pointer non-NULL). The function returns the number of encoded
2768 characters written into the buffer. */
2770 pmon_makeb64 (v, p, n, chksum)
2776 int count = (n / 6);
2778 if ((n % 12) != 0) {
2779 fprintf_unfiltered(stderr,"Fast encoding bitcount must be a multiple of 12bits: %dbit%s\n",n,(n == 1)?"":"s");
2783 fprintf_unfiltered(stderr,"Fast encoding cannot process more than 36bits at the moment: %dbits\n",n);
2787 /* Deal with the checksum: */
2788 if (chksum != NULL) {
2790 case 36: *chksum += ((v >> 24) & 0xFFF);
2791 case 24: *chksum += ((v >> 12) & 0xFFF);
2792 case 12: *chksum += ((v >> 0) & 0xFFF);
2798 *p++ = encoding[(v >> n) & 0x3F];
2804 /* Shorthand function (that could be in-lined) to output the zero-fill
2805 escape sequence into the data stream. */
2807 pmon_zeroset (recsize, buff, amount, chksum)
2811 unsigned int *chksum;
2815 sprintf(*buff,"/Z");
2816 count = pmon_makeb64 (*amount, (*buff + 2), 12, chksum);
2817 *buff += (count + 2);
2819 return(recsize + count + 2);
2823 pmon_checkset (recsize, buff, value)
2830 /* Add the checksum (without updating the value): */
2831 sprintf (*buff, "/C");
2832 count = pmon_makeb64 (*value, (*buff + 2), 12, NULL);
2833 *buff += (count + 2);
2834 sprintf (*buff, "\n");
2835 *buff += 2; /* include zero terminator */
2836 /* Forcing a checksum validation clears the sum: */
2838 return(recsize + count + 3);
2841 /* Amount of padding we leave after at the end of the output buffer,
2842 for the checksum and line termination characters: */
2843 #define CHECKSIZE (4 + 4 + 4 + 2)
2844 /* zero-fill, checksum, transfer end and line termination space. */
2846 /* The amount of binary data loaded from the object file in a single
2848 #define BINCHUNK (1024)
2850 /* Maximum line of data accepted by the monitor: */
2851 #define MAXRECSIZE (550)
2852 /* NOTE: This constant depends on the monitor being used. This value
2853 is for PMON 5.x on the Cogent Vr4300 board. */
2856 pmon_make_fastrec (outbuf, inbuf, inptr, inamount, recsize, csum, zerofill)
2858 unsigned char *inbuf;
2863 unsigned int *zerofill;
2868 /* This is a simple check to ensure that our data will fit within
2869 the maximum allowable record size. Each record output is 4bytes
2870 in length. We must allow space for a pending zero fill command,
2871 the record, and a checksum record. */
2872 while ((*recsize < (MAXRECSIZE - CHECKSIZE)) && ((inamount - *inptr) > 0)) {
2873 /* Process the binary data: */
2874 if ((inamount - *inptr) < 3) {
2876 *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
2878 count = pmon_makeb64 (inbuf[*inptr], &p[2], 12, csum);
2880 *recsize += (2 + count);
2883 unsigned int value = ((inbuf[*inptr + 0] << 16) | (inbuf[*inptr + 1] << 8) | inbuf[*inptr + 2]);
2884 /* Simple check for zero data. TODO: A better check would be
2885 to check the last, and then the middle byte for being zero
2886 (if the first byte is not). We could then check for
2887 following runs of zeros, and if above a certain size it is
2888 worth the 4 or 8 character hit of the byte insertions used
2889 to pad to the start of the zeroes. NOTE: This also depends
2890 on the alignment at the end of the zero run. */
2891 if (value == 0x00000000) {
2893 if (*zerofill == 0xFFF) /* 12bit counter */
2894 *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
2897 *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
2898 count = pmon_makeb64 (value, p, 24, csum);
2911 pmon_check_ack(mesg)
2914 #if defined(DOETXACK)
2919 c = SERIAL_READCHAR (udp_in_use ? udp_desc : mips_desc, 2);
2920 if ((c == SERIAL_TIMEOUT) || (c != 0x06))
2922 fprintf_unfiltered (gdb_stderr,
2923 "Failed to receive valid ACK for %s\n", mesg);
2924 return(-1); /* terminate the download */
2927 #endif /* DOETXACK */
2931 /* pmon_download - Send a sequence of characters to the PMON download port,
2932 which is either a serial port or a UDP socket. */
2935 pmon_start_download ()
2939 /* Create the temporary download file. */
2940 if ((tftp_file = fopen (tftp_localname, "w")) == NULL)
2941 perror_with_name (tftp_localname);
2945 mips_send_command (udp_in_use ? LOAD_CMD_UDP : LOAD_CMD, 0);
2946 mips_expect ("Downloading from ");
2947 mips_expect (udp_in_use ? "udp" : "tty0");
2948 mips_expect (", ^C to abort\r\n");
2953 mips_expect_download (char *string)
2955 if (!mips_expect (string))
2957 fprintf_unfiltered (gdb_stderr, "Load did not complete successfully.\n");
2959 remove (tftp_localname); /* Remove temporary file */
2967 pmon_end_download (final, bintotal)
2971 char hexnumber[9]; /* includes '\0' space */
2975 static char *load_cmd_prefix = "load -b -s ";
2979 /* Close off the temporary file containing the load data. */
2983 /* Make the temporary file readable by the world. */
2984 if (stat (tftp_localname, &stbuf) == 0)
2985 chmod (tftp_localname, stbuf.st_mode | S_IROTH);
2987 /* Must reinitialize the board to prevent PMON from crashing. */
2988 mips_send_command ("initEther\r", -1);
2990 /* Send the load command. */
2991 cmd = xmalloc (strlen (load_cmd_prefix) + strlen (tftp_name) + 2);
2992 strcpy (cmd, load_cmd_prefix);
2993 strcat (cmd, tftp_name);
2995 mips_send_command (cmd, 0);
2997 if (!mips_expect_download ("Downloading from "))
2999 if (!mips_expect_download (tftp_name))
3001 if (!mips_expect_download (", ^C to abort\r\n"))
3005 /* Wait for the stuff that PMON prints after the load has completed.
3006 The timeout value for use in the tftp case (15 seconds) was picked
3007 arbitrarily but might be too small for really large downloads. FIXME. */
3008 if (mips_monitor == MON_LSI)
3010 pmon_check_ack ("termination");
3011 mips_expect_timeout ("Entry address is ", tftp_in_use ? 15 : 2);
3014 mips_expect_timeout ("Entry Address = ", tftp_in_use ? 15 : 2);
3016 sprintf (hexnumber,"%x",final);
3017 mips_expect (hexnumber);
3018 mips_expect ("\r\n");
3019 if (mips_monitor != MON_LSI)
3020 pmon_check_ack ("termination");
3021 mips_expect ("\r\ntotal = 0x");
3022 sprintf (hexnumber,"%x",bintotal);
3023 mips_expect (hexnumber);
3024 if (!mips_expect_download (" bytes\r\n"))
3028 remove (tftp_localname); /* Remove temporary file */
3032 pmon_download (buffer, length)
3037 fwrite (buffer, 1, length, tftp_file);
3039 SERIAL_WRITE (udp_in_use ? udp_desc : mips_desc, buffer, length);
3043 pmon_load_fast (file)
3048 unsigned char *binbuf;
3051 unsigned int csum = 0;
3052 int hashmark = !tftp_in_use;
3057 buffer = (char *)xmalloc(MAXRECSIZE + 1);
3058 binbuf = (unsigned char *)xmalloc(BINCHUNK);
3060 abfd = bfd_openr(file,0);
3063 printf_filtered ("Unable to open file %s\n",file);
3067 if (bfd_check_format(abfd,bfd_object) == 0)
3069 printf_filtered("File is not an object file\n");
3073 /* Setup the required download state: */
3074 mips_send_command ("set dlproto etxack\r", -1);
3075 mips_send_command ("set dlecho off\r", -1);
3076 /* NOTE: We get a "cannot set variable" message if the variable is
3077 already defined to have the argument we give. The code doesn't
3078 care, since it just scans to the next prompt anyway. */
3079 /* Start the download: */
3080 pmon_start_download();
3082 /* Zero the checksum */
3083 sprintf(buffer,"/Kxx\n");
3084 reclen = strlen(buffer);
3085 pmon_download (buffer, reclen);
3086 finished = pmon_check_ack("/Kxx");
3088 for (s = abfd->sections; s && !finished; s = s->next)
3089 if (s->flags & SEC_LOAD) /* only deal with loadable sections */
3091 bintotal += s->_raw_size;
3092 final = (s->vma + s->_raw_size);
3094 printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s->name, (unsigned int)s->vma,
3095 (unsigned int)(s->vma + s->_raw_size));
3096 gdb_flush (gdb_stdout);
3098 /* Output the starting address */
3099 sprintf(buffer,"/A");
3100 reclen = pmon_makeb64(s->vma,&buffer[2],36,&csum);
3101 buffer[2 + reclen] = '\n';
3102 buffer[3 + reclen] = '\0';
3103 reclen += 3; /* for the initial escape code and carriage return */
3104 pmon_download (buffer, reclen);
3105 finished = pmon_check_ack("/A");
3109 unsigned int binamount;
3110 unsigned int zerofill = 0;
3116 for (i = 0; ((i < s->_raw_size) && !finished); i += binamount) {
3119 binamount = min (BINCHUNK, s->_raw_size - i);
3121 bfd_get_section_contents (abfd, s, binbuf, i, binamount);
3123 /* This keeps a rolling checksum, until we decide to output
3125 for (; ((binamount - binptr) > 0);) {
3126 pmon_make_fastrec (&bp, binbuf, &binptr, binamount, &reclen, &csum, &zerofill);
3127 if (reclen >= (MAXRECSIZE - CHECKSIZE)) {
3128 reclen = pmon_checkset (reclen, &bp, &csum);
3129 pmon_download (buffer, reclen);
3130 finished = pmon_check_ack("data record");
3132 zerofill = 0; /* do not transmit pending zerofills */
3137 putchar_unfiltered ('#');
3138 gdb_flush (gdb_stdout);
3142 reclen = 0; /* buffer processed */
3147 /* Ensure no out-standing zerofill requests: */
3149 reclen = pmon_zeroset (reclen, &bp, &zerofill, &csum);
3151 /* and then flush the line: */
3153 reclen = pmon_checkset (reclen, &bp, &csum);
3154 /* Currently pmon_checkset outputs the line terminator by
3155 default, so we write out the buffer so far: */
3156 pmon_download (buffer, reclen);
3157 finished = pmon_check_ack("record remnant");
3161 putchar_unfiltered ('\n');
3164 /* Terminate the transfer. We know that we have an empty output
3165 buffer at this point. */
3166 sprintf (buffer, "/E/E\n"); /* include dummy padding characters */
3167 reclen = strlen (buffer);
3168 pmon_download (buffer, reclen);
3170 if (finished) { /* Ignore the termination message: */
3171 SERIAL_FLUSH_INPUT (udp_in_use ? udp_desc : mips_desc);
3172 } else { /* Deal with termination message: */
3173 pmon_end_download (final, bintotal);
3179 /* mips_load -- download a file. */
3182 mips_load (file, from_tty)
3186 /* Get the board out of remote debugging mode. */
3187 if (mips_exit_debug ())
3188 error ("mips_load: Couldn't get into monitor mode.");
3190 if (mips_monitor != MON_IDT)
3191 pmon_load_fast (file);
3193 mips_load_srec (file);
3197 /* Finally, make the PC point at the start address */
3198 if (mips_monitor == MON_DDB)
3200 /* Work around problem where DDB monitor does not update the
3201 PC after a load. The following ensures that the write_pc()
3202 WILL update the PC value: */
3203 register_valid[PC_REGNUM] = 0;
3206 write_pc (bfd_get_start_address (exec_bfd));
3208 inferior_pid = 0; /* No process now */
3210 /* This is necessary because many things were based on the PC at the time that
3211 we attached to the monitor, which is no longer valid now that we have loaded
3212 new code (and just changed the PC). Another way to do this might be to call
3213 normal_stop, except that the stack may not be valid, and things would get
3214 horribly confused... */
3216 clear_symtab_users ();
3219 /* The target vector. */
3221 struct target_ops mips_ops =
3223 "mips", /* to_shortname */
3224 "Remote MIPS debugging over serial line", /* to_longname */
3226 Debug a board using the MIPS remote debugging protocol over a serial line.\n\
3227 The argument is the device it is connected to or, if it contains a colon,\n\
3228 HOST:PORT to access a board over a network", /* to_doc */
3229 mips_open, /* to_open */
3230 mips_close, /* to_close */
3231 NULL, /* to_attach */
3232 mips_detach, /* to_detach */
3233 mips_resume, /* to_resume */
3234 mips_wait, /* to_wait */
3235 mips_fetch_registers, /* to_fetch_registers */
3236 mips_store_registers, /* to_store_registers */
3237 mips_prepare_to_store, /* to_prepare_to_store */
3238 mips_xfer_memory, /* to_xfer_memory */
3239 mips_files_info, /* to_files_info */
3240 mips_insert_breakpoint, /* to_insert_breakpoint */
3241 mips_remove_breakpoint, /* to_remove_breakpoint */
3242 NULL, /* to_terminal_init */
3243 NULL, /* to_terminal_inferior */
3244 NULL, /* to_terminal_ours_for_output */
3245 NULL, /* to_terminal_ours */
3246 NULL, /* to_terminal_info */
3247 mips_kill, /* to_kill */
3248 mips_load, /* to_load */
3249 NULL, /* to_lookup_symbol */
3250 mips_create_inferior, /* to_create_inferior */
3251 mips_mourn_inferior, /* to_mourn_inferior */
3252 NULL, /* to_can_run */
3253 NULL, /* to_notice_signals */
3254 0, /* to_thread_alive */
3256 process_stratum, /* to_stratum */
3258 1, /* to_has_all_memory */
3259 1, /* to_has_memory */
3260 1, /* to_has_stack */
3261 1, /* to_has_registers */
3262 1, /* to_has_execution */
3263 NULL, /* sections */
3264 NULL, /* sections_end */
3265 OPS_MAGIC /* to_magic */
3268 /* An alternative target vector: */
3269 struct target_ops pmon_ops =
3271 "pmon", /* to_shortname */
3272 "Remote MIPS debugging over serial line", /* to_longname */
3274 Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
3275 line. The argument is the device it is connected to or, if it contains a\n\
3276 colon, HOST:PORT to access a board over a network", /* to_doc */
3277 pmon_open, /* to_open */
3278 mips_close, /* to_close */
3279 NULL, /* to_attach */
3280 mips_detach, /* to_detach */
3281 mips_resume, /* to_resume */
3282 pmon_wait, /* to_wait */
3283 mips_fetch_registers, /* to_fetch_registers */
3284 mips_store_registers, /* to_store_registers */
3285 mips_prepare_to_store, /* to_prepare_to_store */
3286 mips_xfer_memory, /* to_xfer_memory */
3287 mips_files_info, /* to_files_info */
3288 mips_insert_breakpoint, /* to_insert_breakpoint */
3289 mips_remove_breakpoint, /* to_remove_breakpoint */
3290 NULL, /* to_terminal_init */
3291 NULL, /* to_terminal_inferior */
3292 NULL, /* to_terminal_ours_for_output */
3293 NULL, /* to_terminal_ours */
3294 NULL, /* to_terminal_info */
3295 mips_kill, /* to_kill */
3296 mips_load, /* to_load */
3297 NULL, /* to_lookup_symbol */
3298 mips_create_inferior, /* to_create_inferior */
3299 mips_mourn_inferior, /* to_mourn_inferior */
3300 NULL, /* to_can_run */
3301 NULL, /* to_notice_signals */
3302 0, /* to_thread_alive */
3304 process_stratum, /* to_stratum */
3306 1, /* to_has_all_memory */
3307 1, /* to_has_memory */
3308 1, /* to_has_stack */
3309 1, /* to_has_registers */
3310 1, /* to_has_execution */
3311 NULL, /* sections */
3312 NULL, /* sections_end */
3313 OPS_MAGIC /* to_magic */
3316 /* Another alternative target vector. This is a PMON system, but with
3317 a different monitor prompt, aswell as some other operational
3319 struct target_ops ddb_ops =
3321 "ddb", /* to_shortname */
3322 "Remote MIPS debugging over serial line", /* to_longname */
3324 Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
3325 line. The first argument is the device it is connected to or, if it contains\n\
3326 a colon, HOST:PORT to access a board over a network. The optional second\n\
3327 parameter is the temporary file in the form HOST:FILENAME to be used for\n\
3328 TFTP downloads to the board. The optional third parameter is the local\n\
3329 of the TFTP temporary file, if it differs from the filename seen by the board",
3331 ddb_open, /* to_open */
3332 mips_close, /* to_close */
3333 NULL, /* to_attach */
3334 mips_detach, /* to_detach */
3335 mips_resume, /* to_resume */
3336 pmon_wait, /* to_wait */
3337 mips_fetch_registers, /* to_fetch_registers */
3338 mips_store_registers, /* to_store_registers */
3339 mips_prepare_to_store, /* to_prepare_to_store */
3340 mips_xfer_memory, /* to_xfer_memory */
3341 mips_files_info, /* to_files_info */
3342 mips_insert_breakpoint, /* to_insert_breakpoint */
3343 mips_remove_breakpoint, /* to_remove_breakpoint */
3344 NULL, /* to_terminal_init */
3345 NULL, /* to_terminal_inferior */
3346 NULL, /* to_terminal_ours_for_output */
3347 NULL, /* to_terminal_ours */
3348 NULL, /* to_terminal_info */
3349 mips_kill, /* to_kill */
3350 mips_load, /* to_load */
3351 NULL, /* to_lookup_symbol */
3352 mips_create_inferior, /* to_create_inferior */
3353 mips_mourn_inferior, /* to_mourn_inferior */
3354 NULL, /* to_can_run */
3355 NULL, /* to_notice_signals */
3356 0, /* to_thread_alive */
3358 process_stratum, /* to_stratum */
3360 1, /* to_has_all_memory */
3361 1, /* to_has_memory */
3362 1, /* to_has_stack */
3363 1, /* to_has_registers */
3364 1, /* to_has_execution */
3365 NULL, /* sections */
3366 NULL, /* sections_end */
3367 OPS_MAGIC /* to_magic */
3370 /* Another alternative target vector for LSI Logic MiniRISC boards.
3371 This is a PMON system, but with some other operational differences. */
3372 struct target_ops lsi_ops =
3374 "lsi", /* to_shortname */
3375 "Remote MIPS debugging over serial line", /* to_longname */
3377 Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
3378 line. The first argument is the device it is connected to or, if it contains\n\
3379 a colon, HOST:PORT to access a board over a network. The optional second\n\
3380 parameter is the temporary file in the form HOST:FILENAME to be used for\n\
3381 TFTP downloads to the board. The optional third parameter is the local\n\
3382 of the TFTP temporary file, if it differs from the filename seen by the board",
3384 lsi_open, /* to_open */
3385 mips_close, /* to_close */
3386 NULL, /* to_attach */
3387 mips_detach, /* to_detach */
3388 mips_resume, /* to_resume */
3389 pmon_wait, /* to_wait */
3390 mips_fetch_registers, /* to_fetch_registers */
3391 mips_store_registers, /* to_store_registers */
3392 mips_prepare_to_store, /* to_prepare_to_store */
3393 mips_xfer_memory, /* to_xfer_memory */
3394 mips_files_info, /* to_files_info */
3395 mips_insert_breakpoint, /* to_insert_breakpoint */
3396 mips_remove_breakpoint, /* to_remove_breakpoint */
3397 NULL, /* to_terminal_init */
3398 NULL, /* to_terminal_inferior */
3399 NULL, /* to_terminal_ours_for_output */
3400 NULL, /* to_terminal_ours */
3401 NULL, /* to_terminal_info */
3402 mips_kill, /* to_kill */
3403 mips_load, /* to_load */
3404 NULL, /* to_lookup_symbol */
3405 mips_create_inferior, /* to_create_inferior */
3406 mips_mourn_inferior, /* to_mourn_inferior */
3407 NULL, /* to_can_run */
3408 NULL, /* to_notice_signals */
3409 0, /* to_thread_alive */
3411 process_stratum, /* to_stratum */
3413 1, /* to_has_all_memory */
3414 1, /* to_has_memory */
3415 1, /* to_has_stack */
3416 1, /* to_has_registers */
3417 1, /* to_has_execution */
3418 NULL, /* sections */
3419 NULL, /* sections_end */
3420 OPS_MAGIC /* to_magic */
3424 _initialize_remote_mips ()
3426 add_target (&mips_ops);
3427 add_target (&pmon_ops);
3428 add_target (&ddb_ops);
3429 add_target (&lsi_ops);
3432 add_set_cmd ("timeout", no_class, var_zinteger,
3433 (char *) &mips_receive_wait,
3434 "Set timeout in seconds for remote MIPS serial I/O.",
3439 add_set_cmd ("retransmit-timeout", no_class, var_zinteger,
3440 (char *) &mips_retransmit_wait,
3441 "Set retransmit timeout in seconds for remote MIPS serial I/O.\n\
3442 This is the number of seconds to wait for an acknowledgement to a packet\n\
3443 before resending the packet.", &setlist),
3447 add_set_cmd ("syn-garbage-limit", no_class, var_zinteger,
3448 (char *) &mips_syn_garbage,
3449 "Set the maximum number of characters to ignore when scanning for a SYN.\n\
3450 This is the maximum number of characters GDB will ignore when trying to\n\
3451 synchronize with the remote system. A value of -1 means that there is no limit\n\
3452 (Note that these characters are printed out even though they are ignored.)",
3457 (add_set_cmd ("monitor-prompt", class_obscure, var_string,
3458 (char *) &mips_monitor_prompt,
3459 "Set the prompt that GDB expects from the monitor.",