* remote-mips.c (mips_load): Use regcache_set_valid_p() instead
[external/binutils.git] / gdb / remote-mips.c
1 /* Remote debugging interface for MIPS remote debugging protocol.
2
3    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4    2003, 2004, 2006, 2007 Free Software Foundation, Inc.
5
6    Contributed by Cygnus Support.  Written by Ian Lance Taylor
7    <ian@cygnus.com>.
8
9    This file is part of GDB.
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
24 #include "defs.h"
25 #include "inferior.h"
26 #include "bfd.h"
27 #include "symfile.h"
28 #include "gdbcmd.h"
29 #include "gdbcore.h"
30 #include "serial.h"
31 #include "target.h"
32 #include "exceptions.h"
33 #include "gdb_string.h"
34 #include "gdb_stat.h"
35 #include "regcache.h"
36 #include <ctype.h>
37 #include "mips-tdep.h"
38 \f
39
40 /* Breakpoint types.  Values 0, 1, and 2 must agree with the watch
41    types passed by breakpoint.c to target_insert_watchpoint.
42    Value 3 is our own invention, and is used for ordinary instruction
43    breakpoints.  Value 4 is used to mark an unused watchpoint in tables.  */
44 enum break_type
45   {
46     BREAK_WRITE,                /* 0 */
47     BREAK_READ,                 /* 1 */
48     BREAK_ACCESS,               /* 2 */
49     BREAK_FETCH,                /* 3 */
50     BREAK_UNUSED                /* 4 */
51   };
52
53 /* Prototypes for local functions.  */
54
55 static int mips_readchar (int timeout);
56
57 static int mips_receive_header (unsigned char *hdr, int *pgarbage,
58                                 int ch, int timeout);
59
60 static int mips_receive_trailer (unsigned char *trlr, int *pgarbage,
61                                  int *pch, int timeout);
62
63 static int mips_cksum (const unsigned char *hdr,
64                        const unsigned char *data, int len);
65
66 static void mips_send_packet (const char *s, int get_ack);
67
68 static void mips_send_command (const char *cmd, int prompt);
69
70 static int mips_receive_packet (char *buff, int throw_error, int timeout);
71
72 static ULONGEST mips_request (int cmd, ULONGEST addr, ULONGEST data,
73                               int *perr, int timeout, char *buff);
74
75 static void mips_initialize (void);
76
77 static void mips_open (char *name, int from_tty);
78
79 static void pmon_open (char *name, int from_tty);
80
81 static void ddb_open (char *name, int from_tty);
82
83 static void lsi_open (char *name, int from_tty);
84
85 static void mips_close (int quitting);
86
87 static void mips_detach (char *args, int from_tty);
88
89 static void mips_resume (ptid_t ptid, int step,
90                          enum target_signal siggnal);
91
92 static ptid_t mips_wait (ptid_t ptid,
93                                struct target_waitstatus *status);
94
95 static int mips_map_regno (int regno);
96
97 static void mips_fetch_registers (struct regcache *regcache, int regno);
98
99 static void mips_prepare_to_store (struct regcache *regcache);
100
101 static void mips_store_registers (struct regcache *regcache, int regno);
102
103 static unsigned int mips_fetch_word (CORE_ADDR addr);
104
105 static int mips_store_word (CORE_ADDR addr, unsigned int value,
106                             char *old_contents);
107
108 static int mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
109                              int write, 
110                              struct mem_attrib *attrib,
111                              struct target_ops *target);
112
113 static void mips_files_info (struct target_ops *ignore);
114
115 static void mips_mourn_inferior (void);
116
117 static int pmon_makeb64 (unsigned long v, char *p, int n, int *chksum);
118
119 static int pmon_zeroset (int recsize, char **buff, int *amount,
120                          unsigned int *chksum);
121
122 static int pmon_checkset (int recsize, char **buff, int *value);
123
124 static void pmon_make_fastrec (char **outbuf, unsigned char *inbuf,
125                                int *inptr, int inamount, int *recsize,
126                                unsigned int *csum, unsigned int *zerofill);
127
128 static int pmon_check_ack (char *mesg);
129
130 static void pmon_start_download (void);
131
132 static void pmon_end_download (int final, int bintotal);
133
134 static void pmon_download (char *buffer, int length);
135
136 static void pmon_load_fast (char *file);
137
138 static void mips_load (char *file, int from_tty);
139
140 static int mips_make_srec (char *buffer, int type, CORE_ADDR memaddr,
141                            unsigned char *myaddr, int len);
142
143 static int set_breakpoint (CORE_ADDR addr, int len, enum break_type type);
144
145 static int clear_breakpoint (CORE_ADDR addr, int len, enum break_type type);
146
147 static int common_breakpoint (int set, CORE_ADDR addr, int len,
148                               enum break_type type);
149
150 /* Forward declarations.  */
151 extern struct target_ops mips_ops;
152 extern struct target_ops pmon_ops;
153 extern struct target_ops ddb_ops;
154 \f/* *INDENT-OFF* */
155 /* The MIPS remote debugging interface is built on top of a simple
156    packet protocol.  Each packet is organized as follows:
157
158    SYN  The first character is always a SYN (ASCII 026, or ^V).  SYN
159    may not appear anywhere else in the packet.  Any time a SYN is
160    seen, a new packet should be assumed to have begun.
161
162    TYPE_LEN
163    This byte contains the upper five bits of the logical length
164    of the data section, plus a single bit indicating whether this
165    is a data packet or an acknowledgement.  The documentation
166    indicates that this bit is 1 for a data packet, but the actual
167    board uses 1 for an acknowledgement.  The value of the byte is
168    0x40 + (ack ? 0x20 : 0) + (len >> 6)
169    (we always have 0 <= len < 1024).  Acknowledgement packets do
170    not carry data, and must have a data length of 0.
171
172    LEN1 This byte contains the lower six bits of the logical length of
173    the data section.  The value is
174    0x40 + (len & 0x3f)
175
176    SEQ  This byte contains the six bit sequence number of the packet.
177    The value is
178    0x40 + seq
179    An acknowlegment packet contains the sequence number of the
180    packet being acknowledged plus 1 modulo 64.  Data packets are
181    transmitted in sequence.  There may only be one outstanding
182    unacknowledged data packet at a time.  The sequence numbers
183    are independent in each direction.  If an acknowledgement for
184    the previous packet is received (i.e., an acknowledgement with
185    the sequence number of the packet just sent) the packet just
186    sent should be retransmitted.  If no acknowledgement is
187    received within a timeout period, the packet should be
188    retransmitted.  This has an unfortunate failure condition on a
189    high-latency line, as a delayed acknowledgement may lead to an
190    endless series of duplicate packets.
191
192    DATA The actual data bytes follow.  The following characters are
193    escaped inline with DLE (ASCII 020, or ^P):
194    SYN (026)    DLE S
195    DLE (020)    DLE D
196    ^C  (003)    DLE C
197    ^S  (023)    DLE s
198    ^Q  (021)    DLE q
199    The additional DLE characters are not counted in the logical
200    length stored in the TYPE_LEN and LEN1 bytes.
201
202    CSUM1
203    CSUM2
204    CSUM3
205    These bytes contain an 18 bit checksum of the complete
206    contents of the packet excluding the SEQ byte and the
207    CSUM[123] bytes.  The checksum is simply the twos complement
208    addition of all the bytes treated as unsigned characters.  The
209    values of the checksum bytes are:
210    CSUM1: 0x40 + ((cksum >> 12) & 0x3f)
211    CSUM2: 0x40 + ((cksum >> 6) & 0x3f)
212    CSUM3: 0x40 + (cksum & 0x3f)
213
214    It happens that the MIPS remote debugging protocol always
215    communicates with ASCII strings.  Because of this, this
216    implementation doesn't bother to handle the DLE quoting mechanism,
217    since it will never be required.  */
218 /* *INDENT-ON* */
219
220
221 /* The SYN character which starts each packet.  */
222 #define SYN '\026'
223
224 /* The 0x40 used to offset each packet (this value ensures that all of
225    the header and trailer bytes, other than SYN, are printable ASCII
226    characters).  */
227 #define HDR_OFFSET 0x40
228
229 /* The indices of the bytes in the packet header.  */
230 #define HDR_INDX_SYN 0
231 #define HDR_INDX_TYPE_LEN 1
232 #define HDR_INDX_LEN1 2
233 #define HDR_INDX_SEQ 3
234 #define HDR_LENGTH 4
235
236 /* The data/ack bit in the TYPE_LEN header byte.  */
237 #define TYPE_LEN_DA_BIT 0x20
238 #define TYPE_LEN_DATA 0
239 #define TYPE_LEN_ACK TYPE_LEN_DA_BIT
240
241 /* How to compute the header bytes.  */
242 #define HDR_SET_SYN(data, len, seq) (SYN)
243 #define HDR_SET_TYPE_LEN(data, len, seq) \
244   (HDR_OFFSET \
245    + ((data) ? TYPE_LEN_DATA : TYPE_LEN_ACK) \
246    + (((len) >> 6) & 0x1f))
247 #define HDR_SET_LEN1(data, len, seq) (HDR_OFFSET + ((len) & 0x3f))
248 #define HDR_SET_SEQ(data, len, seq) (HDR_OFFSET + (seq))
249
250 /* Check that a header byte is reasonable.  */
251 #define HDR_CHECK(ch) (((ch) & HDR_OFFSET) == HDR_OFFSET)
252
253 /* Get data from the header.  These macros evaluate their argument
254    multiple times.  */
255 #define HDR_IS_DATA(hdr) \
256   (((hdr)[HDR_INDX_TYPE_LEN] & TYPE_LEN_DA_BIT) == TYPE_LEN_DATA)
257 #define HDR_GET_LEN(hdr) \
258   ((((hdr)[HDR_INDX_TYPE_LEN] & 0x1f) << 6) + (((hdr)[HDR_INDX_LEN1] & 0x3f)))
259 #define HDR_GET_SEQ(hdr) ((unsigned int)(hdr)[HDR_INDX_SEQ] & 0x3f)
260
261 /* The maximum data length.  */
262 #define DATA_MAXLEN 1023
263
264 /* The trailer offset.  */
265 #define TRLR_OFFSET HDR_OFFSET
266
267 /* The indices of the bytes in the packet trailer.  */
268 #define TRLR_INDX_CSUM1 0
269 #define TRLR_INDX_CSUM2 1
270 #define TRLR_INDX_CSUM3 2
271 #define TRLR_LENGTH 3
272
273 /* How to compute the trailer bytes.  */
274 #define TRLR_SET_CSUM1(cksum) (TRLR_OFFSET + (((cksum) >> 12) & 0x3f))
275 #define TRLR_SET_CSUM2(cksum) (TRLR_OFFSET + (((cksum) >>  6) & 0x3f))
276 #define TRLR_SET_CSUM3(cksum) (TRLR_OFFSET + (((cksum)      ) & 0x3f))
277
278 /* Check that a trailer byte is reasonable.  */
279 #define TRLR_CHECK(ch) (((ch) & TRLR_OFFSET) == TRLR_OFFSET)
280
281 /* Get data from the trailer.  This evaluates its argument multiple
282    times.  */
283 #define TRLR_GET_CKSUM(trlr) \
284   ((((trlr)[TRLR_INDX_CSUM1] & 0x3f) << 12) \
285    + (((trlr)[TRLR_INDX_CSUM2] & 0x3f) <<  6) \
286    + ((trlr)[TRLR_INDX_CSUM3] & 0x3f))
287
288 /* The sequence number modulos.  */
289 #define SEQ_MODULOS (64)
290
291 /* PMON commands to load from the serial port or UDP socket.  */
292 #define LOAD_CMD        "load -b -s tty0\r"
293 #define LOAD_CMD_UDP    "load -b -s udp\r"
294
295 /* The target vectors for the four different remote MIPS targets.
296    These are initialized with code in _initialize_remote_mips instead
297    of static initializers, to make it easier to extend the target_ops
298    vector later.  */
299 struct target_ops mips_ops, pmon_ops, ddb_ops, lsi_ops;
300
301 enum mips_monitor_type
302   {
303     /* IDT/SIM monitor being used: */
304     MON_IDT,
305     /* PMON monitor being used: */
306     MON_PMON,                   /* 3.0.83 [COGENT,EB,FP,NET] Algorithmics Ltd. Nov  9 1995 17:19:50 */
307     MON_DDB,                    /* 2.7.473 [DDBVR4300,EL,FP,NET] Risq Modular Systems,  Thu Jun 6 09:28:40 PDT 1996 */
308     MON_LSI,                    /* 4.3.12 [EB,FP], LSI LOGIC Corp. Tue Feb 25 13:22:14 1997 */
309     /* Last and unused value, for sizing vectors, etc. */
310     MON_LAST
311   };
312 static enum mips_monitor_type mips_monitor = MON_LAST;
313
314 /* The monitor prompt text.  If the user sets the PMON prompt
315    to some new value, the GDB `set monitor-prompt' command must also
316    be used to inform GDB about the expected prompt.  Otherwise, GDB
317    will not be able to connect to PMON in mips_initialize().
318    If the `set monitor-prompt' command is not used, the expected
319    default prompt will be set according the target:
320    target               prompt
321    -----                -----
322    pmon         PMON> 
323    ddb          NEC010>
324    lsi          PMON>
325  */
326 static char *mips_monitor_prompt;
327
328 /* Set to 1 if the target is open.  */
329 static int mips_is_open;
330
331 /* Currently active target description (if mips_is_open == 1) */
332 static struct target_ops *current_ops;
333
334 /* Set to 1 while the connection is being initialized.  */
335 static int mips_initializing;
336
337 /* Set to 1 while the connection is being brought down.  */
338 static int mips_exiting;
339
340 /* The next sequence number to send.  */
341 static unsigned int mips_send_seq;
342
343 /* The next sequence number we expect to receive.  */
344 static unsigned int mips_receive_seq;
345
346 /* The time to wait before retransmitting a packet, in seconds.  */
347 static int mips_retransmit_wait = 3;
348
349 /* The number of times to try retransmitting a packet before giving up.  */
350 static int mips_send_retries = 10;
351
352 /* The number of garbage characters to accept when looking for an
353    SYN for the next packet.  */
354 static int mips_syn_garbage = 10;
355
356 /* The time to wait for a packet, in seconds.  */
357 static int mips_receive_wait = 5;
358
359 /* Set if we have sent a packet to the board but have not yet received
360    a reply.  */
361 static int mips_need_reply = 0;
362
363 /* Handle used to access serial I/O stream.  */
364 static struct serial *mips_desc;
365
366 /* UDP handle used to download files to target.  */
367 static struct serial *udp_desc;
368 static int udp_in_use;
369
370 /* TFTP filename used to download files to DDB board, in the form
371    host:filename.  */
372 static char *tftp_name;         /* host:filename */
373 static char *tftp_localname;    /* filename portion of above */
374 static int tftp_in_use;
375 static FILE *tftp_file;
376
377 /* Counts the number of times the user tried to interrupt the target (usually
378    via ^C.  */
379 static int interrupt_count;
380
381 /* If non-zero, means that the target is running. */
382 static int mips_wait_flag = 0;
383
384 /* If non-zero, monitor supports breakpoint commands. */
385 static int monitor_supports_breakpoints = 0;
386
387 /* Data cache header.  */
388
389 #if 0                           /* not used (yet?) */
390 static DCACHE *mips_dcache;
391 #endif
392
393 /* Non-zero means that we've just hit a read or write watchpoint */
394 static int hit_watchpoint;
395
396 /* Table of breakpoints/watchpoints (used only on LSI PMON target).
397    The table is indexed by a breakpoint number, which is an integer
398    from 0 to 255 returned by the LSI PMON when a breakpoint is set.
399  */
400 #define MAX_LSI_BREAKPOINTS 256
401 struct lsi_breakpoint_info
402   {
403     enum break_type type;       /* type of breakpoint */
404     CORE_ADDR addr;             /* address of breakpoint */
405     int len;                    /* length of region being watched */
406     unsigned long value;        /* value to watch */
407   }
408 lsi_breakpoints[MAX_LSI_BREAKPOINTS];
409
410 /* Error/warning codes returned by LSI PMON for breakpoint commands.
411    Warning values may be ORed together; error values may not.  */
412 #define W_WARN  0x100           /* This bit is set if the error code is a warning */
413 #define W_MSK   0x101           /* warning: Range feature is supported via mask */
414 #define W_VAL   0x102           /* warning: Value check is not supported in hardware */
415 #define W_QAL   0x104           /* warning: Requested qualifiers are not supported in hardware */
416
417 #define E_ERR   0x200           /* This bit is set if the error code is an error */
418 #define E_BPT   0x200           /* error: No such breakpoint number */
419 #define E_RGE   0x201           /* error: Range is not supported */
420 #define E_QAL   0x202           /* error: The requested qualifiers can not be used */
421 #define E_OUT   0x203           /* error: Out of hardware resources */
422 #define E_NON   0x204           /* error: Hardware breakpoint not supported */
423
424 struct lsi_error
425   {
426     int code;                   /* error code */
427     char *string;               /* string associated with this code */
428   };
429
430 struct lsi_error lsi_warning_table[] =
431 {
432   {W_MSK, "Range feature is supported via mask"},
433   {W_VAL, "Value check is not supported in hardware"},
434   {W_QAL, "Requested qualifiers are not supported in hardware"},
435   {0, NULL}
436 };
437
438 struct lsi_error lsi_error_table[] =
439 {
440   {E_BPT, "No such breakpoint number"},
441   {E_RGE, "Range is not supported"},
442   {E_QAL, "The requested qualifiers can not be used"},
443   {E_OUT, "Out of hardware resources"},
444   {E_NON, "Hardware breakpoint not supported"},
445   {0, NULL}
446 };
447
448 /* Set to 1 with the 'set monitor-warnings' command to enable printing
449    of warnings returned by PMON when hardware breakpoints are used.  */
450 static int monitor_warnings;
451
452
453 static void
454 close_ports (void)
455 {
456   mips_is_open = 0;
457   serial_close (mips_desc);
458
459   if (udp_in_use)
460     {
461       serial_close (udp_desc);
462       udp_in_use = 0;
463     }
464   tftp_in_use = 0;
465 }
466
467 /* Handle low-level error that we can't recover from.  Note that just
468    error()ing out from target_wait or some such low-level place will cause
469    all hell to break loose--the rest of GDB will tend to get left in an
470    inconsistent state.  */
471
472 static NORETURN void
473 mips_error (char *string,...)
474 {
475   va_list args;
476
477   va_start (args, string);
478
479   target_terminal_ours ();
480   wrap_here ("");               /* Force out any buffered output */
481   gdb_flush (gdb_stdout);
482   if (error_pre_print)
483     fputs_filtered (error_pre_print, gdb_stderr);
484   vfprintf_filtered (gdb_stderr, string, args);
485   fprintf_filtered (gdb_stderr, "\n");
486   va_end (args);
487   gdb_flush (gdb_stderr);
488
489   /* Clean up in such a way that mips_close won't try to talk to the
490      board (it almost surely won't work since we weren't able to talk to
491      it).  */
492   close_ports ();
493
494   printf_unfiltered ("Ending remote MIPS debugging.\n");
495   target_mourn_inferior ();
496
497   deprecated_throw_reason (RETURN_ERROR);
498 }
499
500 /* putc_readable - print a character, displaying non-printable chars in
501    ^x notation or in hex.  */
502
503 static void
504 fputc_readable (int ch, struct ui_file *file)
505 {
506   if (ch == '\n')
507     fputc_unfiltered ('\n', file);
508   else if (ch == '\r')
509     fprintf_unfiltered (file, "\\r");
510   else if (ch < 0x20)           /* ASCII control character */
511     fprintf_unfiltered (file, "^%c", ch + '@');
512   else if (ch >= 0x7f)          /* non-ASCII characters (rubout or greater) */
513     fprintf_unfiltered (file, "[%02x]", ch & 0xff);
514   else
515     fputc_unfiltered (ch, file);
516 }
517
518
519 /* puts_readable - print a string, displaying non-printable chars in
520    ^x notation or in hex.  */
521
522 static void
523 fputs_readable (const char *string, struct ui_file *file)
524 {
525   int c;
526
527   while ((c = *string++) != '\0')
528     fputc_readable (c, file);
529 }
530
531
532 /* Wait until STRING shows up in mips_desc.  Returns 1 if successful, else 0 if
533    timed out.  TIMEOUT specifies timeout value in seconds.
534  */
535
536 static int
537 mips_expect_timeout (const char *string, int timeout)
538 {
539   const char *p = string;
540
541   if (remote_debug)
542     {
543       fprintf_unfiltered (gdb_stdlog, "Expected \"");
544       fputs_readable (string, gdb_stdlog);
545       fprintf_unfiltered (gdb_stdlog, "\", got \"");
546     }
547
548   immediate_quit++;
549   while (1)
550     {
551       int c;
552
553       /* Must use serial_readchar() here cuz mips_readchar would get
554          confused if we were waiting for the mips_monitor_prompt... */
555
556       c = serial_readchar (mips_desc, timeout);
557
558       if (c == SERIAL_TIMEOUT)
559         {
560           if (remote_debug)
561             fprintf_unfiltered (gdb_stdlog, "\": FAIL\n");
562           return 0;
563         }
564
565       if (remote_debug)
566         fputc_readable (c, gdb_stdlog);
567
568       if (c == *p++)
569         {
570           if (*p == '\0')
571             {
572               immediate_quit--;
573               if (remote_debug)
574                 fprintf_unfiltered (gdb_stdlog, "\": OK\n");
575               return 1;
576             }
577         }
578       else
579         {
580           p = string;
581           if (c == *p)
582             p++;
583         }
584     }
585 }
586
587 /* Wait until STRING shows up in mips_desc.  Returns 1 if successful, else 0 if
588    timed out.  The timeout value is hard-coded to 2 seconds.  Use
589    mips_expect_timeout if a different timeout value is needed.
590  */
591
592 static int
593 mips_expect (const char *string)
594 {
595   return mips_expect_timeout (string, remote_timeout);
596 }
597
598 /* Read a character from the remote, aborting on error.  Returns
599    SERIAL_TIMEOUT on timeout (since that's what serial_readchar()
600    returns).  FIXME: If we see the string mips_monitor_prompt from the
601    board, then we are debugging on the main console port, and we have
602    somehow dropped out of remote debugging mode.  In this case, we
603    automatically go back in to remote debugging mode.  This is a hack,
604    put in because I can't find any way for a program running on the
605    remote board to terminate without also ending remote debugging
606    mode.  I assume users won't have any trouble with this; for one
607    thing, the IDT documentation generally assumes that the remote
608    debugging port is not the console port.  This is, however, very
609    convenient for DejaGnu when you only have one connected serial
610    port.  */
611
612 static int
613 mips_readchar (int timeout)
614 {
615   int ch;
616   static int state = 0;
617   int mips_monitor_prompt_len = strlen (mips_monitor_prompt);
618
619   {
620     int i;
621
622     i = timeout;
623     if (i == -1 && watchdog > 0)
624       i = watchdog;
625   }
626
627   if (state == mips_monitor_prompt_len)
628     timeout = 1;
629   ch = serial_readchar (mips_desc, timeout);
630
631   if (ch == SERIAL_TIMEOUT && timeout == -1)    /* Watchdog went off */
632     {
633       target_mourn_inferior ();
634       error ("Watchdog has expired.  Target detached.\n");
635     }
636
637   if (ch == SERIAL_EOF)
638     mips_error ("End of file from remote");
639   if (ch == SERIAL_ERROR)
640     mips_error ("Error reading from remote: %s", safe_strerror (errno));
641   if (remote_debug > 1)
642     {
643       /* Don't use _filtered; we can't deal with a QUIT out of
644          target_wait, and I think this might be called from there.  */
645       if (ch != SERIAL_TIMEOUT)
646         fprintf_unfiltered (gdb_stdlog, "Read '%c' %d 0x%x\n", ch, ch, ch);
647       else
648         fprintf_unfiltered (gdb_stdlog, "Timed out in read\n");
649     }
650
651   /* If we have seen mips_monitor_prompt and we either time out, or
652      we see a @ (which was echoed from a packet we sent), reset the
653      board as described above.  The first character in a packet after
654      the SYN (which is not echoed) is always an @ unless the packet is
655      more than 64 characters long, which ours never are.  */
656   if ((ch == SERIAL_TIMEOUT || ch == '@')
657       && state == mips_monitor_prompt_len
658       && !mips_initializing
659       && !mips_exiting)
660     {
661       if (remote_debug > 0)
662         /* Don't use _filtered; we can't deal with a QUIT out of
663            target_wait, and I think this might be called from there.  */
664         fprintf_unfiltered (gdb_stdlog, "Reinitializing MIPS debugging mode\n");
665
666       mips_need_reply = 0;
667       mips_initialize ();
668
669       state = 0;
670
671       /* At this point, about the only thing we can do is abort the command
672          in progress and get back to command level as quickly as possible. */
673
674       error ("Remote board reset, debug protocol re-initialized.");
675     }
676
677   if (ch == mips_monitor_prompt[state])
678     ++state;
679   else
680     state = 0;
681
682   return ch;
683 }
684
685 /* Get a packet header, putting the data in the supplied buffer.
686    PGARBAGE is a pointer to the number of garbage characters received
687    so far.  CH is the last character received.  Returns 0 for success,
688    or -1 for timeout.  */
689
690 static int
691 mips_receive_header (unsigned char *hdr, int *pgarbage, int ch, int timeout)
692 {
693   int i;
694
695   while (1)
696     {
697       /* Wait for a SYN.  mips_syn_garbage is intended to prevent
698          sitting here indefinitely if the board sends us one garbage
699          character per second.  ch may already have a value from the
700          last time through the loop.  */
701       while (ch != SYN)
702         {
703           ch = mips_readchar (timeout);
704           if (ch == SERIAL_TIMEOUT)
705             return -1;
706           if (ch != SYN)
707             {
708               /* Printing the character here lets the user of gdb see
709                  what the program is outputting, if the debugging is
710                  being done on the console port.  Don't use _filtered:
711                  we can't deal with a QUIT out of target_wait and
712                  buffered target output confuses the user. */
713               if (!mips_initializing || remote_debug > 0)
714                 {
715                   if (isprint (ch) || isspace (ch))
716                     {
717                       fputc_unfiltered (ch, gdb_stdtarg);
718                     }
719                   else
720                     {
721                       fputc_readable (ch, gdb_stdtarg);
722                     }
723                   gdb_flush (gdb_stdtarg);
724                 }
725               
726               /* Only count unprintable characters. */
727               if (! (isprint (ch) || isspace (ch)))
728                 (*pgarbage) += 1;
729
730               if (mips_syn_garbage > 0
731                   && *pgarbage > mips_syn_garbage)
732                 mips_error ("Debug protocol failure:  more than %d characters before a sync.",
733                             mips_syn_garbage);
734             }
735         }
736
737       /* Get the packet header following the SYN.  */
738       for (i = 1; i < HDR_LENGTH; i++)
739         {
740           ch = mips_readchar (timeout);
741           if (ch == SERIAL_TIMEOUT)
742             return -1;
743           /* Make sure this is a header byte.  */
744           if (ch == SYN || !HDR_CHECK (ch))
745             break;
746
747           hdr[i] = ch;
748         }
749
750       /* If we got the complete header, we can return.  Otherwise we
751          loop around and keep looking for SYN.  */
752       if (i >= HDR_LENGTH)
753         return 0;
754     }
755 }
756
757 /* Get a packet header, putting the data in the supplied buffer.
758    PGARBAGE is a pointer to the number of garbage characters received
759    so far.  The last character read is returned in *PCH.  Returns 0
760    for success, -1 for timeout, -2 for error.  */
761
762 static int
763 mips_receive_trailer (unsigned char *trlr, int *pgarbage, int *pch, int timeout)
764 {
765   int i;
766   int ch;
767
768   for (i = 0; i < TRLR_LENGTH; i++)
769     {
770       ch = mips_readchar (timeout);
771       *pch = ch;
772       if (ch == SERIAL_TIMEOUT)
773         return -1;
774       if (!TRLR_CHECK (ch))
775         return -2;
776       trlr[i] = ch;
777     }
778   return 0;
779 }
780
781 /* Get the checksum of a packet.  HDR points to the packet header.
782    DATA points to the packet data.  LEN is the length of DATA.  */
783
784 static int
785 mips_cksum (const unsigned char *hdr, const unsigned char *data, int len)
786 {
787   const unsigned char *p;
788   int c;
789   int cksum;
790
791   cksum = 0;
792
793   /* The initial SYN is not included in the checksum.  */
794   c = HDR_LENGTH - 1;
795   p = hdr + 1;
796   while (c-- != 0)
797     cksum += *p++;
798
799   c = len;
800   p = data;
801   while (c-- != 0)
802     cksum += *p++;
803
804   return cksum;
805 }
806
807 /* Send a packet containing the given ASCII string.  */
808
809 static void
810 mips_send_packet (const char *s, int get_ack)
811 {
812   /* unsigned */ int len;
813   unsigned char *packet;
814   int cksum;
815   int try;
816
817   len = strlen (s);
818   if (len > DATA_MAXLEN)
819     mips_error ("MIPS protocol data packet too long: %s", s);
820
821   packet = (unsigned char *) alloca (HDR_LENGTH + len + TRLR_LENGTH + 1);
822
823   packet[HDR_INDX_SYN] = HDR_SET_SYN (1, len, mips_send_seq);
824   packet[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (1, len, mips_send_seq);
825   packet[HDR_INDX_LEN1] = HDR_SET_LEN1 (1, len, mips_send_seq);
826   packet[HDR_INDX_SEQ] = HDR_SET_SEQ (1, len, mips_send_seq);
827
828   memcpy (packet + HDR_LENGTH, s, len);
829
830   cksum = mips_cksum (packet, packet + HDR_LENGTH, len);
831   packet[HDR_LENGTH + len + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
832   packet[HDR_LENGTH + len + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
833   packet[HDR_LENGTH + len + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
834
835   /* Increment the sequence number.  This will set mips_send_seq to
836      the sequence number we expect in the acknowledgement.  */
837   mips_send_seq = (mips_send_seq + 1) % SEQ_MODULOS;
838
839   /* We can only have one outstanding data packet, so we just wait for
840      the acknowledgement here.  Keep retransmitting the packet until
841      we get one, or until we've tried too many times.  */
842   for (try = 0; try < mips_send_retries; try++)
843     {
844       int garbage;
845       int ch;
846
847       if (remote_debug > 0)
848         {
849           /* Don't use _filtered; we can't deal with a QUIT out of
850              target_wait, and I think this might be called from there.  */
851           packet[HDR_LENGTH + len + TRLR_LENGTH] = '\0';
852           fprintf_unfiltered (gdb_stdlog, "Writing \"%s\"\n", packet + 1);
853         }
854
855       if (serial_write (mips_desc, packet,
856                         HDR_LENGTH + len + TRLR_LENGTH) != 0)
857         mips_error ("write to target failed: %s", safe_strerror (errno));
858
859       if (!get_ack)
860         return;
861
862       garbage = 0;
863       ch = 0;
864       while (1)
865         {
866           unsigned char hdr[HDR_LENGTH + 1];
867           unsigned char trlr[TRLR_LENGTH + 1];
868           int err;
869           unsigned int seq;
870
871           /* Get the packet header.  If we time out, resend the data
872              packet.  */
873           err = mips_receive_header (hdr, &garbage, ch, mips_retransmit_wait);
874           if (err != 0)
875             break;
876
877           ch = 0;
878
879           /* If we get a data packet, assume it is a duplicate and
880              ignore it.  FIXME: If the acknowledgement is lost, this
881              data packet may be the packet the remote sends after the
882              acknowledgement.  */
883           if (HDR_IS_DATA (hdr))
884             {
885               int i;
886
887               /* Ignore any errors raised whilst attempting to ignore
888                  packet. */
889
890               len = HDR_GET_LEN (hdr);
891
892               for (i = 0; i < len; i++)
893                 {
894                   int rch;
895
896                   rch = mips_readchar (remote_timeout);
897                   if (rch == SYN)
898                     {
899                       ch = SYN;
900                       break;
901                     }
902                   if (rch == SERIAL_TIMEOUT)
903                     break;
904                   /* ignore the character */
905                 }
906
907               if (i == len)
908                 (void) mips_receive_trailer (trlr, &garbage, &ch,
909                                              remote_timeout);
910
911               /* We don't bother checking the checksum, or providing an
912                  ACK to the packet. */
913               continue;
914             }
915
916           /* If the length is not 0, this is a garbled packet.  */
917           if (HDR_GET_LEN (hdr) != 0)
918             continue;
919
920           /* Get the packet trailer.  */
921           err = mips_receive_trailer (trlr, &garbage, &ch,
922                                       mips_retransmit_wait);
923
924           /* If we timed out, resend the data packet.  */
925           if (err == -1)
926             break;
927
928           /* If we got a bad character, reread the header.  */
929           if (err != 0)
930             continue;
931
932           /* If the checksum does not match the trailer checksum, this
933              is a bad packet; ignore it.  */
934           if (mips_cksum (hdr, (unsigned char *) NULL, 0)
935               != TRLR_GET_CKSUM (trlr))
936             continue;
937
938           if (remote_debug > 0)
939             {
940               hdr[HDR_LENGTH] = '\0';
941               trlr[TRLR_LENGTH] = '\0';
942               /* Don't use _filtered; we can't deal with a QUIT out of
943                  target_wait, and I think this might be called from there.  */
944               fprintf_unfiltered (gdb_stdlog, "Got ack %d \"%s%s\"\n",
945                                   HDR_GET_SEQ (hdr), hdr + 1, trlr);
946             }
947
948           /* If this ack is for the current packet, we're done.  */
949           seq = HDR_GET_SEQ (hdr);
950           if (seq == mips_send_seq)
951             return;
952
953           /* If this ack is for the last packet, resend the current
954              packet.  */
955           if ((seq + 1) % SEQ_MODULOS == mips_send_seq)
956             break;
957
958           /* Otherwise this is a bad ack; ignore it.  Increment the
959              garbage count to ensure that we do not stay in this loop
960              forever.  */
961           ++garbage;
962         }
963     }
964
965   mips_error ("Remote did not acknowledge packet");
966 }
967
968 /* Receive and acknowledge a packet, returning the data in BUFF (which
969    should be DATA_MAXLEN + 1 bytes).  The protocol documentation
970    implies that only the sender retransmits packets, so this code just
971    waits silently for a packet.  It returns the length of the received
972    packet.  If THROW_ERROR is nonzero, call error() on errors.  If not,
973    don't print an error message and return -1.  */
974
975 static int
976 mips_receive_packet (char *buff, int throw_error, int timeout)
977 {
978   int ch;
979   int garbage;
980   int len;
981   unsigned char ack[HDR_LENGTH + TRLR_LENGTH + 1];
982   int cksum;
983
984   ch = 0;
985   garbage = 0;
986   while (1)
987     {
988       unsigned char hdr[HDR_LENGTH];
989       unsigned char trlr[TRLR_LENGTH];
990       int i;
991       int err;
992
993       if (mips_receive_header (hdr, &garbage, ch, timeout) != 0)
994         {
995           if (throw_error)
996             mips_error ("Timed out waiting for remote packet");
997           else
998             return -1;
999         }
1000
1001       ch = 0;
1002
1003       /* An acknowledgement is probably a duplicate; ignore it.  */
1004       if (!HDR_IS_DATA (hdr))
1005         {
1006           len = HDR_GET_LEN (hdr);
1007           /* Check if the length is valid for an ACK, we may aswell
1008              try and read the remainder of the packet: */
1009           if (len == 0)
1010             {
1011               /* Ignore the error condition, since we are going to
1012                  ignore the packet anyway. */
1013               (void) mips_receive_trailer (trlr, &garbage, &ch, timeout);
1014             }
1015           /* Don't use _filtered; we can't deal with a QUIT out of
1016              target_wait, and I think this might be called from there.  */
1017           if (remote_debug > 0)
1018             fprintf_unfiltered (gdb_stdlog, "Ignoring unexpected ACK\n");
1019           continue;
1020         }
1021
1022       len = HDR_GET_LEN (hdr);
1023       for (i = 0; i < len; i++)
1024         {
1025           int rch;
1026
1027           rch = mips_readchar (timeout);
1028           if (rch == SYN)
1029             {
1030               ch = SYN;
1031               break;
1032             }
1033           if (rch == SERIAL_TIMEOUT)
1034             {
1035               if (throw_error)
1036                 mips_error ("Timed out waiting for remote packet");
1037               else
1038                 return -1;
1039             }
1040           buff[i] = rch;
1041         }
1042
1043       if (i < len)
1044         {
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             fprintf_unfiltered (gdb_stdlog,
1049                                 "Got new SYN after %d chars (wanted %d)\n",
1050                                 i, len);
1051           continue;
1052         }
1053
1054       err = mips_receive_trailer (trlr, &garbage, &ch, timeout);
1055       if (err == -1)
1056         {
1057           if (throw_error)
1058             mips_error ("Timed out waiting for packet");
1059           else
1060             return -1;
1061         }
1062       if (err == -2)
1063         {
1064           /* Don't use _filtered; we can't deal with a QUIT out of
1065              target_wait, and I think this might be called from there.  */
1066           if (remote_debug > 0)
1067             fprintf_unfiltered (gdb_stdlog, "Got SYN when wanted trailer\n");
1068           continue;
1069         }
1070
1071       /* If this is the wrong sequence number, ignore it.  */
1072       if (HDR_GET_SEQ (hdr) != mips_receive_seq)
1073         {
1074           /* Don't use _filtered; we can't deal with a QUIT out of
1075              target_wait, and I think this might be called from there.  */
1076           if (remote_debug > 0)
1077             fprintf_unfiltered (gdb_stdlog,
1078                                 "Ignoring sequence number %d (want %d)\n",
1079                                 HDR_GET_SEQ (hdr), mips_receive_seq);
1080           continue;
1081         }
1082
1083       if (mips_cksum (hdr, buff, len) == TRLR_GET_CKSUM (trlr))
1084         break;
1085
1086       if (remote_debug > 0)
1087         /* Don't use _filtered; we can't deal with a QUIT out of
1088            target_wait, and I think this might be called from there.  */
1089         printf_unfiltered ("Bad checksum; data %d, trailer %d\n",
1090                            mips_cksum (hdr, buff, len),
1091                            TRLR_GET_CKSUM (trlr));
1092
1093       /* The checksum failed.  Send an acknowledgement for the
1094          previous packet to tell the remote to resend the packet.  */
1095       ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
1096       ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
1097       ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
1098       ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
1099
1100       cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
1101
1102       ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
1103       ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
1104       ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
1105
1106       if (remote_debug > 0)
1107         {
1108           ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
1109           /* Don't use _filtered; we can't deal with a QUIT out of
1110              target_wait, and I think this might be called from there.  */
1111           printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
1112                              ack + 1);
1113         }
1114
1115       if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
1116         {
1117           if (throw_error)
1118             mips_error ("write to target failed: %s", safe_strerror (errno));
1119           else
1120             return -1;
1121         }
1122     }
1123
1124   if (remote_debug > 0)
1125     {
1126       buff[len] = '\0';
1127       /* Don't use _filtered; we can't deal with a QUIT out of
1128          target_wait, and I think this might be called from there.  */
1129       printf_unfiltered ("Got packet \"%s\"\n", buff);
1130     }
1131
1132   /* We got the packet.  Send an acknowledgement.  */
1133   mips_receive_seq = (mips_receive_seq + 1) % SEQ_MODULOS;
1134
1135   ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
1136   ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
1137   ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
1138   ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
1139
1140   cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
1141
1142   ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
1143   ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
1144   ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
1145
1146   if (remote_debug > 0)
1147     {
1148       ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
1149       /* Don't use _filtered; we can't deal with a QUIT out of
1150          target_wait, and I think this might be called from there.  */
1151       printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
1152                          ack + 1);
1153     }
1154
1155   if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
1156     {
1157       if (throw_error)
1158         mips_error ("write to target failed: %s", safe_strerror (errno));
1159       else
1160         return -1;
1161     }
1162
1163   return len;
1164 }
1165 \f
1166 /* Optionally send a request to the remote system and optionally wait
1167    for the reply.  This implements the remote debugging protocol,
1168    which is built on top of the packet protocol defined above.  Each
1169    request has an ADDR argument and a DATA argument.  The following
1170    requests are defined:
1171
1172    \0   don't send a request; just wait for a reply
1173    i    read word from instruction space at ADDR
1174    d    read word from data space at ADDR
1175    I    write DATA to instruction space at ADDR
1176    D    write DATA to data space at ADDR
1177    r    read register number ADDR
1178    R    set register number ADDR to value DATA
1179    c    continue execution (if ADDR != 1, set pc to ADDR)
1180    s    single step (if ADDR != 1, set pc to ADDR)
1181
1182    The read requests return the value requested.  The write requests
1183    return the previous value in the changed location.  The execution
1184    requests return a UNIX wait value (the approximate signal which
1185    caused execution to stop is in the upper eight bits).
1186
1187    If PERR is not NULL, this function waits for a reply.  If an error
1188    occurs, it sets *PERR to 1 and sets errno according to what the
1189    target board reports.  */
1190
1191 static ULONGEST
1192 mips_request (int cmd,
1193               ULONGEST addr,
1194               ULONGEST data,
1195               int *perr,
1196               int timeout,
1197               char *buff)
1198 {
1199   char myBuff[DATA_MAXLEN + 1];
1200   int len;
1201   int rpid;
1202   char rcmd;
1203   int rerrflg;
1204   unsigned long rresponse;
1205
1206   if (buff == (char *) NULL)
1207     buff = myBuff;
1208
1209   if (cmd != '\0')
1210     {
1211       if (mips_need_reply)
1212         internal_error (__FILE__, __LINE__,
1213                         _("mips_request: Trying to send command before reply"));
1214       sprintf (buff, "0x0 %c 0x%s 0x%s", cmd, paddr_nz (addr), paddr_nz (data));
1215       mips_send_packet (buff, 1);
1216       mips_need_reply = 1;
1217     }
1218
1219   if (perr == (int *) NULL)
1220     return 0;
1221
1222   if (!mips_need_reply)
1223     internal_error (__FILE__, __LINE__,
1224                     _("mips_request: Trying to get reply before command"));
1225
1226   mips_need_reply = 0;
1227
1228   len = mips_receive_packet (buff, 1, timeout);
1229   buff[len] = '\0';
1230
1231   if (sscanf (buff, "0x%x %c 0x%x 0x%lx",
1232               &rpid, &rcmd, &rerrflg, &rresponse) != 4
1233       || (cmd != '\0' && rcmd != cmd))
1234     mips_error ("Bad response from remote board");
1235
1236   if (rerrflg != 0)
1237     {
1238       *perr = 1;
1239
1240       /* FIXME: This will returns MIPS errno numbers, which may or may
1241          not be the same as errno values used on other systems.  If
1242          they stick to common errno values, they will be the same, but
1243          if they don't, they must be translated.  */
1244       errno = rresponse;
1245
1246       return 0;
1247     }
1248
1249   *perr = 0;
1250   return rresponse;
1251 }
1252
1253 static void
1254 mips_initialize_cleanups (void *arg)
1255 {
1256   mips_initializing = 0;
1257 }
1258
1259 static void
1260 mips_exit_cleanups (void *arg)
1261 {
1262   mips_exiting = 0;
1263 }
1264
1265 static void
1266 mips_send_command (const char *cmd, int prompt)
1267 {
1268   serial_write (mips_desc, cmd, strlen (cmd));
1269   mips_expect (cmd);
1270   mips_expect ("\n");
1271   if (prompt)
1272     mips_expect (mips_monitor_prompt);
1273 }
1274
1275 /* Enter remote (dbx) debug mode: */
1276 static void
1277 mips_enter_debug (void)
1278 {
1279   /* Reset the sequence numbers, ready for the new debug sequence: */
1280   mips_send_seq = 0;
1281   mips_receive_seq = 0;
1282
1283   if (mips_monitor != MON_IDT)
1284     mips_send_command ("debug\r", 0);
1285   else                          /* assume IDT monitor by default */
1286     mips_send_command ("db tty0\r", 0);
1287
1288   sleep (1);
1289   serial_write (mips_desc, "\r", sizeof "\r" - 1);
1290
1291   /* We don't need to absorb any spurious characters here, since the
1292      mips_receive_header will eat up a reasonable number of characters
1293      whilst looking for the SYN, however this avoids the "garbage"
1294      being displayed to the user. */
1295   if (mips_monitor != MON_IDT)
1296     mips_expect ("\r");
1297
1298   {
1299     char buff[DATA_MAXLEN + 1];
1300     if (mips_receive_packet (buff, 1, 3) < 0)
1301       mips_error ("Failed to initialize (didn't receive packet).");
1302   }
1303 }
1304
1305 /* Exit remote (dbx) debug mode, returning to the monitor prompt: */
1306 static int
1307 mips_exit_debug (void)
1308 {
1309   int err;
1310   struct cleanup *old_cleanups = make_cleanup (mips_exit_cleanups, NULL);
1311
1312   mips_exiting = 1;
1313
1314   if (mips_monitor != MON_IDT)
1315     {
1316       /* The DDB (NEC) and MiniRISC (LSI) versions of PMON exit immediately,
1317          so we do not get a reply to this command: */
1318       mips_request ('x', 0, 0, NULL, mips_receive_wait, NULL);
1319       mips_need_reply = 0;
1320       if (!mips_expect (" break!"))
1321         return -1;
1322     }
1323   else
1324     mips_request ('x', 0, 0, &err, mips_receive_wait, NULL);
1325
1326   if (!mips_expect (mips_monitor_prompt))
1327     return -1;
1328
1329   do_cleanups (old_cleanups);
1330
1331   return 0;
1332 }
1333
1334 /* Initialize a new connection to the MIPS board, and make sure we are
1335    really connected.  */
1336
1337 static void
1338 mips_initialize (void)
1339 {
1340   int err;
1341   struct cleanup *old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
1342   int j;
1343
1344   /* What is this code doing here?  I don't see any way it can happen, and
1345      it might mean mips_initializing didn't get cleared properly.
1346      So I'll make it a warning.  */
1347
1348   if (mips_initializing)
1349     {
1350       warning ("internal error: mips_initialize called twice");
1351       return;
1352     }
1353
1354   mips_wait_flag = 0;
1355   mips_initializing = 1;
1356
1357   /* At this point, the packit protocol isn't responding.  We'll try getting
1358      into the monitor, and restarting the protocol.  */
1359
1360   /* Force the system into the monitor.  After this we *should* be at
1361      the mips_monitor_prompt.  */
1362   if (mips_monitor != MON_IDT)
1363     j = 0;                      /* start by checking if we are already at the prompt */
1364   else
1365     j = 1;                      /* start by sending a break */
1366   for (; j <= 4; j++)
1367     {
1368       switch (j)
1369         {
1370         case 0:         /* First, try sending a CR */
1371           serial_flush_input (mips_desc);
1372           serial_write (mips_desc, "\r", 1);
1373           break;
1374         case 1:         /* First, try sending a break */
1375           serial_send_break (mips_desc);
1376           break;
1377         case 2:         /* Then, try a ^C */
1378           serial_write (mips_desc, "\003", 1);
1379           break;
1380         case 3:         /* Then, try escaping from download */
1381           {
1382             if (mips_monitor != MON_IDT)
1383               {
1384                 char tbuff[7];
1385
1386                 /* We shouldn't need to send multiple termination
1387                    sequences, since the target performs line (or
1388                    block) reads, and then processes those
1389                    packets. In-case we were downloading a large packet
1390                    we flush the output buffer before inserting a
1391                    termination sequence. */
1392                 serial_flush_output (mips_desc);
1393                 sprintf (tbuff, "\r/E/E\r");
1394                 serial_write (mips_desc, tbuff, 6);
1395               }
1396             else
1397               {
1398                 char srec[10];
1399                 int i;
1400
1401                 /* We are possibly in binary download mode, having
1402                    aborted in the middle of an S-record.  ^C won't
1403                    work because of binary mode.  The only reliable way
1404                    out is to send enough termination packets (8 bytes)
1405                    to fill up and then overflow the largest size
1406                    S-record (255 bytes in this case).  This amounts to
1407                    256/8 + 1 packets.
1408                  */
1409
1410                 mips_make_srec (srec, '7', 0, NULL, 0);
1411
1412                 for (i = 1; i <= 33; i++)
1413                   {
1414                     serial_write (mips_desc, srec, 8);
1415
1416                     if (serial_readchar (mips_desc, 0) >= 0)
1417                       break;    /* Break immediatly if we get something from
1418                                    the board. */
1419                   }
1420               }
1421           }
1422           break;
1423         case 4:
1424           mips_error ("Failed to initialize.");
1425         }
1426
1427       if (mips_expect (mips_monitor_prompt))
1428         break;
1429     }
1430
1431   if (mips_monitor != MON_IDT)
1432     {
1433       /* Sometimes PMON ignores the first few characters in the first
1434          command sent after a load.  Sending a blank command gets
1435          around that.  */
1436       mips_send_command ("\r", -1);
1437
1438       /* Ensure the correct target state: */
1439       if (mips_monitor != MON_LSI)
1440         mips_send_command ("set regsize 64\r", -1);
1441       mips_send_command ("set hostport tty0\r", -1);
1442       mips_send_command ("set brkcmd \"\"\r", -1);
1443       /* Delete all the current breakpoints: */
1444       mips_send_command ("db *\r", -1);
1445       /* NOTE: PMON does not have breakpoint support through the
1446          "debug" mode, only at the monitor command-line. */
1447     }
1448
1449   mips_enter_debug ();
1450
1451   /* Clear all breakpoints: */
1452   if ((mips_monitor == MON_IDT
1453        && clear_breakpoint (-1, 0, BREAK_UNUSED) == 0)
1454       || mips_monitor == MON_LSI)
1455     monitor_supports_breakpoints = 1;
1456   else
1457     monitor_supports_breakpoints = 0;
1458
1459   do_cleanups (old_cleanups);
1460
1461   /* If this doesn't call error, we have connected; we don't care if
1462      the request itself succeeds or fails.  */
1463
1464   mips_request ('r', 0, 0, &err, mips_receive_wait, NULL);
1465 }
1466
1467 /* Open a connection to the remote board.  */
1468 static void
1469 common_open (struct target_ops *ops, char *name, int from_tty,
1470              enum mips_monitor_type new_monitor,
1471              const char *new_monitor_prompt)
1472 {
1473   char *ptype;
1474   char *serial_port_name;
1475   char *remote_name = 0;
1476   char *local_name = 0;
1477   char **argv;
1478
1479   if (name == 0)
1480     error (
1481             "To open a MIPS remote debugging connection, you need to specify what serial\n\
1482 device is attached to the target board (e.g., /dev/ttya).\n"
1483             "If you want to use TFTP to download to the board, specify the name of a\n"
1484             "temporary file to be used by GDB for downloads as the second argument.\n"
1485             "This filename must be in the form host:filename, where host is the name\n"
1486             "of the host running the TFTP server, and the file must be readable by the\n"
1487             "world.  If the local name of the temporary file differs from the name as\n"
1488             "seen from the board via TFTP, specify that name as the third parameter.\n");
1489
1490   /* Parse the serial port name, the optional TFTP name, and the
1491      optional local TFTP name.  */
1492   if ((argv = buildargv (name)) == NULL)
1493     nomem (0);
1494   make_cleanup_freeargv (argv);
1495
1496   serial_port_name = xstrdup (argv[0]);
1497   if (argv[1])                  /* remote TFTP name specified? */
1498     {
1499       remote_name = argv[1];
1500       if (argv[2])              /* local TFTP filename specified? */
1501         local_name = argv[2];
1502     }
1503
1504   target_preopen (from_tty);
1505
1506   if (mips_is_open)
1507     unpush_target (current_ops);
1508
1509   /* Open and initialize the serial port.  */
1510   mips_desc = serial_open (serial_port_name);
1511   if (mips_desc == NULL)
1512     perror_with_name (serial_port_name);
1513
1514   if (baud_rate != -1)
1515     {
1516       if (serial_setbaudrate (mips_desc, baud_rate))
1517         {
1518           serial_close (mips_desc);
1519           perror_with_name (serial_port_name);
1520         }
1521     }
1522
1523   serial_raw (mips_desc);
1524
1525   /* Open and initialize the optional download port.  If it is in the form
1526      hostname#portnumber, it's a UDP socket.  If it is in the form
1527      hostname:filename, assume it's the TFTP filename that must be
1528      passed to the DDB board to tell it where to get the load file.  */
1529   if (remote_name)
1530     {
1531       if (strchr (remote_name, '#'))
1532         {
1533           udp_desc = serial_open (remote_name);
1534           if (!udp_desc)
1535             perror_with_name ("Unable to open UDP port");
1536           udp_in_use = 1;
1537         }
1538       else
1539         {
1540           /* Save the remote and local names of the TFTP temp file.  If
1541              the user didn't specify a local name, assume it's the same
1542              as the part of the remote name after the "host:".  */
1543           if (tftp_name)
1544             xfree (tftp_name);
1545           if (tftp_localname)
1546             xfree (tftp_localname);
1547           if (local_name == NULL)
1548             if ((local_name = strchr (remote_name, ':')) != NULL)
1549               local_name++;     /* skip over the colon */
1550           if (local_name == NULL)
1551             local_name = remote_name;   /* local name same as remote name */
1552           tftp_name = xstrdup (remote_name);
1553           tftp_localname = xstrdup (local_name);
1554           tftp_in_use = 1;
1555         }
1556     }
1557
1558   current_ops = ops;
1559   mips_is_open = 1;
1560
1561   /* Reset the expected monitor prompt if it's never been set before.  */
1562   if (mips_monitor_prompt == NULL)
1563     mips_monitor_prompt = xstrdup (new_monitor_prompt);
1564   mips_monitor = new_monitor;
1565
1566   mips_initialize ();
1567
1568   if (from_tty)
1569     printf_unfiltered ("Remote MIPS debugging using %s\n", serial_port_name);
1570
1571   /* Switch to using remote target now.  */
1572   push_target (ops);
1573
1574   /* FIXME: Should we call start_remote here?  */
1575
1576   /* Try to figure out the processor model if possible.  */
1577   deprecated_mips_set_processor_regs_hack ();
1578
1579   /* This is really the job of start_remote however, that makes an
1580      assumption that the target is about to print out a status message
1581      of some sort.  That doesn't happen here (in fact, it may not be
1582      possible to get the monitor to send the appropriate packet).  */
1583
1584   reinit_frame_cache ();
1585   registers_changed ();
1586   stop_pc = read_pc ();
1587   print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
1588   xfree (serial_port_name);
1589 }
1590
1591 static void
1592 mips_open (char *name, int from_tty)
1593 {
1594   const char *monitor_prompt = NULL;
1595   if (gdbarch_bfd_arch_info (current_gdbarch) != NULL
1596       && gdbarch_bfd_arch_info (current_gdbarch)->arch == bfd_arch_mips)
1597     {
1598     switch (gdbarch_bfd_arch_info (current_gdbarch)->mach)
1599       {
1600       case bfd_mach_mips4100:
1601       case bfd_mach_mips4300:
1602       case bfd_mach_mips4600:
1603       case bfd_mach_mips4650:
1604       case bfd_mach_mips5000:
1605         monitor_prompt = "<RISQ> ";
1606         break;
1607       }
1608     }
1609   if (monitor_prompt == NULL)
1610     monitor_prompt = "<IDT>";
1611   common_open (&mips_ops, name, from_tty, MON_IDT, monitor_prompt);
1612 }
1613
1614 static void
1615 pmon_open (char *name, int from_tty)
1616 {
1617   common_open (&pmon_ops, name, from_tty, MON_PMON, "PMON> ");
1618 }
1619
1620 static void
1621 ddb_open (char *name, int from_tty)
1622 {
1623   common_open (&ddb_ops, name, from_tty, MON_DDB, "NEC010>");
1624 }
1625
1626 static void
1627 lsi_open (char *name, int from_tty)
1628 {
1629   int i;
1630
1631   /* Clear the LSI breakpoint table.  */
1632   for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
1633     lsi_breakpoints[i].type = BREAK_UNUSED;
1634
1635   common_open (&lsi_ops, name, from_tty, MON_LSI, "PMON> ");
1636 }
1637
1638 /* Close a connection to the remote board.  */
1639
1640 static void
1641 mips_close (int quitting)
1642 {
1643   if (mips_is_open)
1644     {
1645       /* Get the board out of remote debugging mode.  */
1646       (void) mips_exit_debug ();
1647
1648       close_ports ();
1649     }
1650 }
1651
1652 /* Detach from the remote board.  */
1653
1654 static void
1655 mips_detach (char *args, int from_tty)
1656 {
1657   if (args)
1658     error ("Argument given to \"detach\" when remotely debugging.");
1659
1660   pop_target ();
1661
1662   mips_close (1);
1663
1664   if (from_tty)
1665     printf_unfiltered ("Ending remote MIPS debugging.\n");
1666 }
1667
1668 /* Tell the target board to resume.  This does not wait for a reply
1669    from the board, except in the case of single-stepping on LSI boards,
1670    where PMON does return a reply.  */
1671
1672 static void
1673 mips_resume (ptid_t ptid, int step, enum target_signal siggnal)
1674 {
1675   int err;
1676
1677   /* LSI PMON requires returns a reply packet "0x1 s 0x0 0x57f" after
1678      a single step, so we wait for that.  */
1679   mips_request (step ? 's' : 'c', 1, siggnal,
1680                 mips_monitor == MON_LSI && step ? &err : (int *) NULL,
1681                 mips_receive_wait, NULL);
1682 }
1683
1684 /* Return the signal corresponding to SIG, where SIG is the number which
1685    the MIPS protocol uses for the signal.  */
1686 static enum target_signal
1687 mips_signal_from_protocol (int sig)
1688 {
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.  */
1692   if (sig <= 0
1693       || sig > 31)
1694     return TARGET_SIGNAL_UNKNOWN;
1695
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;
1701 }
1702
1703 /* Wait until the remote stops, and return a wait status.  */
1704
1705 static ptid_t
1706 mips_wait (ptid_t ptid, struct target_waitstatus *status)
1707 {
1708   int rstatus;
1709   int err;
1710   char buff[DATA_MAXLEN];
1711   int rpc, rfp, rsp;
1712   char flags[20];
1713   int nfields;
1714   int i;
1715
1716   interrupt_count = 0;
1717   hit_watchpoint = 0;
1718
1719   /* If we have not sent a single step or continue command, then the
1720      board is waiting for us to do something.  Return a status
1721      indicating that it is stopped.  */
1722   if (!mips_need_reply)
1723     {
1724       status->kind = TARGET_WAITKIND_STOPPED;
1725       status->value.sig = TARGET_SIGNAL_TRAP;
1726       return inferior_ptid;
1727     }
1728
1729   /* No timeout; we sit here as long as the program continues to execute.  */
1730   mips_wait_flag = 1;
1731   rstatus = mips_request ('\000', 0, 0, &err, -1, buff);
1732   mips_wait_flag = 0;
1733   if (err)
1734     mips_error ("Remote failure: %s", safe_strerror (errno));
1735
1736   /* On returning from a continue, the PMON monitor seems to start
1737      echoing back the messages we send prior to sending back the
1738      ACK. The code can cope with this, but to try and avoid the
1739      unnecessary serial traffic, and "spurious" characters displayed
1740      to the user, we cheat and reset the debug protocol. The problems
1741      seems to be caused by a check on the number of arguments, and the
1742      command length, within the monitor causing it to echo the command
1743      as a bad packet. */
1744   if (mips_monitor == MON_PMON)
1745     {
1746       mips_exit_debug ();
1747       mips_enter_debug ();
1748     }
1749
1750   /* See if we got back extended status.  If so, pick out the pc, fp, sp, etc... */
1751
1752   nfields = sscanf (buff, "0x%*x %*c 0x%*x 0x%*x 0x%x 0x%x 0x%x 0x%*x %s",
1753                     &rpc, &rfp, &rsp, flags);
1754   if (nfields >= 3)
1755     {
1756       struct regcache *regcache = get_current_regcache ();
1757       struct gdbarch *gdbarch = get_regcache_arch (regcache);
1758       char buf[MAX_REGISTER_SIZE];
1759
1760       store_unsigned_integer (buf,
1761                               register_size
1762                                 (gdbarch, gdbarch_pc_regnum (gdbarch)), rpc);
1763       regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), buf);
1764
1765       store_unsigned_integer
1766         (buf, register_size (gdbarch, gdbarch_pc_regnum (gdbarch)), rfp);
1767       regcache_raw_supply (regcache, 30, buf);  /* This register they are avoiding and so it is unnamed */
1768
1769       store_unsigned_integer (buf, register_size (gdbarch,
1770                               gdbarch_sp_regnum (gdbarch)), rsp);
1771       regcache_raw_supply (regcache, gdbarch_sp_regnum (gdbarch), buf);
1772
1773       store_unsigned_integer (buf,
1774                               register_size (gdbarch,
1775                                              gdbarch_deprecated_fp_regnum
1776                                                (gdbarch)),
1777                               0);
1778       regcache_raw_supply (regcache,
1779                            gdbarch_deprecated_fp_regnum (gdbarch), buf);
1780
1781       if (nfields == 9)
1782         {
1783           int i;
1784
1785           for (i = 0; i <= 2; i++)
1786             if (flags[i] == 'r' || flags[i] == 'w')
1787               hit_watchpoint = 1;
1788             else if (flags[i] == '\000')
1789               break;
1790         }
1791     }
1792
1793   if (strcmp (target_shortname, "lsi") == 0)
1794     {
1795 #if 0
1796       /* If this is an LSI PMON target, see if we just hit a hardrdware watchpoint.
1797          Right now, PMON doesn't give us enough information to determine which
1798          breakpoint we hit.  So we have to look up the PC in our own table
1799          of breakpoints, and if found, assume it's just a normal instruction
1800          fetch breakpoint, not a data watchpoint.  FIXME when PMON
1801          provides some way to tell us what type of breakpoint it is.  */
1802       int i;
1803       CORE_ADDR pc = read_pc ();
1804
1805       hit_watchpoint = 1;
1806       for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
1807         {
1808           if (lsi_breakpoints[i].addr == pc
1809               && lsi_breakpoints[i].type == BREAK_FETCH)
1810             {
1811               hit_watchpoint = 0;
1812               break;
1813             }
1814         }
1815 #else
1816       /* If a data breakpoint was hit, PMON returns the following packet:
1817          0x1 c 0x0 0x57f 0x1
1818          The return packet from an ordinary breakpoint doesn't have the
1819          extra 0x01 field tacked onto the end.  */
1820       if (nfields == 1 && rpc == 1)
1821         hit_watchpoint = 1;
1822 #endif
1823     }
1824
1825   /* NOTE: The following (sig) numbers are defined by PMON:
1826      SPP_SIGTRAP     5       breakpoint
1827      SPP_SIGINT      2
1828      SPP_SIGSEGV     11
1829      SPP_SIGBUS      10
1830      SPP_SIGILL      4
1831      SPP_SIGFPE      8
1832      SPP_SIGTERM     15 */
1833
1834   /* Translate a MIPS waitstatus.  We use constants here rather than WTERMSIG
1835      and so on, because the constants we want here are determined by the
1836      MIPS protocol and have nothing to do with what host we are running on.  */
1837   if ((rstatus & 0xff) == 0)
1838     {
1839       status->kind = TARGET_WAITKIND_EXITED;
1840       status->value.integer = (((rstatus) >> 8) & 0xff);
1841     }
1842   else if ((rstatus & 0xff) == 0x7f)
1843     {
1844       status->kind = TARGET_WAITKIND_STOPPED;
1845       status->value.sig = mips_signal_from_protocol (((rstatus) >> 8) & 0xff);
1846
1847       /* If the stop PC is in the _exit function, assume
1848          we hit the 'break 0x3ff' instruction in _exit, so this
1849          is not a normal breakpoint.  */
1850       if (strcmp (target_shortname, "lsi") == 0)
1851         {
1852           char *func_name;
1853           CORE_ADDR func_start;
1854           CORE_ADDR pc = read_pc ();
1855
1856           find_pc_partial_function (pc, &func_name, &func_start, NULL);
1857           if (func_name != NULL && strcmp (func_name, "_exit") == 0
1858               && func_start == pc)
1859             status->kind = TARGET_WAITKIND_EXITED;
1860         }
1861     }
1862   else
1863     {
1864       status->kind = TARGET_WAITKIND_SIGNALLED;
1865       status->value.sig = mips_signal_from_protocol (rstatus & 0x7f);
1866     }
1867
1868   return inferior_ptid;
1869 }
1870
1871 /* We have to map between the register numbers used by gdb and the
1872    register numbers used by the debugging protocol.  */
1873
1874 #define REGNO_OFFSET 96
1875
1876 static int
1877 mips_map_regno (int regno)
1878 {
1879   if (regno < 32)
1880     return regno;
1881   if (regno >= mips_regnum (current_gdbarch)->fp0
1882       && regno < mips_regnum (current_gdbarch)->fp0 + 32)
1883     return regno - mips_regnum (current_gdbarch)->fp0 + 32;
1884   else if (regno == mips_regnum (current_gdbarch)->pc)
1885     return REGNO_OFFSET + 0;
1886   else if (regno == mips_regnum (current_gdbarch)->cause)
1887     return REGNO_OFFSET + 1;
1888   else if (regno == mips_regnum (current_gdbarch)->hi)
1889     return REGNO_OFFSET + 2;
1890   else if (regno == mips_regnum (current_gdbarch)->lo)
1891     return REGNO_OFFSET + 3;
1892   else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
1893     return REGNO_OFFSET + 4;
1894   else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
1895     return REGNO_OFFSET + 5;
1896   else
1897     /* FIXME: Is there a way to get the status register?  */
1898     return 0;
1899 }
1900
1901 /* Fetch the remote registers.  */
1902
1903 static void
1904 mips_fetch_registers (struct regcache *regcache, int regno)
1905 {
1906   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1907   unsigned LONGEST val;
1908   int err;
1909
1910   if (regno == -1)
1911     {
1912       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
1913         mips_fetch_registers (regcache, regno);
1914       return;
1915     }
1916
1917   if (regno == gdbarch_deprecated_fp_regnum (gdbarch)
1918       || regno == MIPS_ZERO_REGNUM)
1919     /* gdbarch_deprecated_fp_regnum on the mips is a hack which is just
1920        supposed to read zero (see also mips-nat.c).  */
1921     val = 0;
1922   else
1923     {
1924       /* If PMON doesn't support this register, don't waste serial
1925          bandwidth trying to read it.  */
1926       int pmon_reg = mips_map_regno (regno);
1927       if (regno != 0 && pmon_reg == 0)
1928         val = 0;
1929       else
1930         {
1931           /* Unfortunately the PMON version in the Vr4300 board has been
1932              compiled without the 64bit register access commands. This
1933              means we cannot get hold of the full register width. */
1934           if (mips_monitor == MON_DDB)
1935             val = (unsigned) mips_request ('t', pmon_reg, 0,
1936                                            &err, mips_receive_wait, NULL);
1937           else
1938             val = mips_request ('r', pmon_reg, 0,
1939                                 &err, mips_receive_wait, NULL);
1940           if (err)
1941             mips_error ("Can't read register %d: %s", regno,
1942                         safe_strerror (errno));
1943         }
1944     }
1945
1946   {
1947     char buf[MAX_REGISTER_SIZE];
1948
1949     /* We got the number the register holds, but gdb expects to see a
1950        value in the target byte ordering.  */
1951     store_unsigned_integer (buf, register_size (gdbarch, regno), val);
1952     regcache_raw_supply (regcache, regno, buf);
1953   }
1954 }
1955
1956 /* Prepare to store registers.  The MIPS protocol can store individual
1957    registers, so this function doesn't have to do anything.  */
1958
1959 static void
1960 mips_prepare_to_store (struct regcache *regcache)
1961 {
1962 }
1963
1964 /* Store remote register(s).  */
1965
1966 static void
1967 mips_store_registers (struct regcache *regcache, int regno)
1968 {
1969   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1970   ULONGEST val;
1971   int err;
1972
1973   if (regno == -1)
1974     {
1975       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
1976         mips_store_registers (regcache, regno);
1977       return;
1978     }
1979
1980   regcache_cooked_read_unsigned (regcache, regno, &val);
1981   mips_request ('R', mips_map_regno (regno), val,
1982                 &err, mips_receive_wait, NULL);
1983   if (err)
1984     mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));
1985 }
1986
1987 /* Fetch a word from the target board.  */
1988
1989 static unsigned int
1990 mips_fetch_word (CORE_ADDR addr)
1991 {
1992   unsigned int val;
1993   int err;
1994
1995   val = mips_request ('d', addr, 0, &err, mips_receive_wait, NULL);
1996   if (err)
1997     {
1998       /* Data space failed; try instruction space.  */
1999       val = mips_request ('i', addr, 0, &err,
2000                           mips_receive_wait, NULL);
2001       if (err)
2002         mips_error ("Can't read address 0x%s: %s",
2003                     paddr_nz (addr), safe_strerror (errno));
2004     }
2005   return val;
2006 }
2007
2008 /* Store a word to the target board.  Returns errno code or zero for
2009    success.  If OLD_CONTENTS is non-NULL, put the old contents of that
2010    memory location there.  */
2011
2012 /* FIXME! make sure only 32-bit quantities get stored! */
2013 static int
2014 mips_store_word (CORE_ADDR addr, unsigned int val, char *old_contents)
2015 {
2016   int err;
2017   unsigned int oldcontents;
2018
2019   oldcontents = mips_request ('D', addr, val, &err,
2020                               mips_receive_wait, NULL);
2021   if (err)
2022     {
2023       /* Data space failed; try instruction space.  */
2024       oldcontents = mips_request ('I', addr, val, &err,
2025                                   mips_receive_wait, NULL);
2026       if (err)
2027         return errno;
2028     }
2029   if (old_contents != NULL)
2030     store_unsigned_integer (old_contents, 4, oldcontents);
2031   return 0;
2032 }
2033
2034 /* Read or write LEN bytes from inferior memory at MEMADDR,
2035    transferring to or from debugger address MYADDR.  Write to inferior
2036    if SHOULD_WRITE is nonzero.  Returns length of data written or
2037    read; 0 for error.  Note that protocol gives us the correct value
2038    for a longword, since it transfers values in ASCII.  We want the
2039    byte values, so we have to swap the longword values.  */
2040
2041 static int mask_address_p = 1;
2042
2043 static int
2044 mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
2045                   struct mem_attrib *attrib, struct target_ops *target)
2046 {
2047   int i;
2048   CORE_ADDR addr;
2049   int count;
2050   char *buffer;
2051   int status;
2052
2053   /* PMON targets do not cope well with 64 bit addresses.  Mask the
2054      value down to 32 bits. */
2055   if (mask_address_p)
2056     memaddr &= (CORE_ADDR) 0xffffffff;
2057
2058   /* Round starting address down to longword boundary.  */
2059   addr = memaddr & ~3;
2060   /* Round ending address up; get number of longwords that makes.  */
2061   count = (((memaddr + len) - addr) + 3) / 4;
2062   /* Allocate buffer of that many longwords.  */
2063   buffer = alloca (count * 4);
2064
2065   if (write)
2066     {
2067       /* Fill start and end extra bytes of buffer with existing data.  */
2068       if (addr != memaddr || len < 4)
2069         {
2070           /* Need part of initial word -- fetch it.  */
2071           store_unsigned_integer (&buffer[0], 4, mips_fetch_word (addr));
2072         }
2073
2074       if (count > 1)
2075         {
2076           /* Need part of last word -- fetch it.  FIXME: we do this even
2077              if we don't need it.  */
2078           store_unsigned_integer (&buffer[(count - 1) * 4], 4,
2079                                   mips_fetch_word (addr + (count - 1) * 4));
2080         }
2081
2082       /* Copy data to be written over corresponding part of buffer */
2083
2084       memcpy ((char *) buffer + (memaddr & 3), myaddr, len);
2085
2086       /* Write the entire buffer.  */
2087
2088       for (i = 0; i < count; i++, addr += 4)
2089         {
2090           status = mips_store_word (addr,
2091                                extract_unsigned_integer (&buffer[i * 4], 4),
2092                                     NULL);
2093           /* Report each kilobyte (we download 32-bit words at a time) */
2094           if (i % 256 == 255)
2095             {
2096               printf_unfiltered ("*");
2097               gdb_flush (gdb_stdout);
2098             }
2099           if (status)
2100             {
2101               errno = status;
2102               return 0;
2103             }
2104           /* FIXME: Do we want a QUIT here?  */
2105         }
2106       if (count >= 256)
2107         printf_unfiltered ("\n");
2108     }
2109   else
2110     {
2111       /* Read all the longwords */
2112       for (i = 0; i < count; i++, addr += 4)
2113         {
2114           store_unsigned_integer (&buffer[i * 4], 4, mips_fetch_word (addr));
2115           QUIT;
2116         }
2117
2118       /* Copy appropriate bytes out of the buffer.  */
2119       memcpy (myaddr, buffer + (memaddr & 3), len);
2120     }
2121   return len;
2122 }
2123
2124 /* Print info on this target.  */
2125
2126 static void
2127 mips_files_info (struct target_ops *ignore)
2128 {
2129   printf_unfiltered ("Debugging a MIPS board over a serial line.\n");
2130 }
2131
2132 /* Kill the process running on the board.  This will actually only
2133    work if we are doing remote debugging over the console input.  I
2134    think that if IDT/sim had the remote debug interrupt enabled on the
2135    right port, we could interrupt the process with a break signal.  */
2136
2137 static void
2138 mips_kill (void)
2139 {
2140   if (!mips_wait_flag)
2141     return;
2142
2143   interrupt_count++;
2144
2145   if (interrupt_count >= 2)
2146     {
2147       interrupt_count = 0;
2148
2149       target_terminal_ours ();
2150
2151       if (query ("Interrupted while waiting for the program.\n\
2152 Give up (and stop debugging it)? "))
2153         {
2154           /* Clean up in such a way that mips_close won't try to talk to the
2155              board (it almost surely won't work since we weren't able to talk to
2156              it).  */
2157           mips_wait_flag = 0;
2158           close_ports ();
2159
2160           printf_unfiltered ("Ending remote MIPS debugging.\n");
2161           target_mourn_inferior ();
2162
2163           deprecated_throw_reason (RETURN_QUIT);
2164         }
2165
2166       target_terminal_inferior ();
2167     }
2168
2169   if (remote_debug > 0)
2170     printf_unfiltered ("Sending break\n");
2171
2172   serial_send_break (mips_desc);
2173
2174 #if 0
2175   if (mips_is_open)
2176     {
2177       char cc;
2178
2179       /* Send a ^C.  */
2180       cc = '\003';
2181       serial_write (mips_desc, &cc, 1);
2182       sleep (1);
2183       target_mourn_inferior ();
2184     }
2185 #endif
2186 }
2187
2188 /* Start running on the target board.  */
2189
2190 static void
2191 mips_create_inferior (char *execfile, char *args, char **env, int from_tty)
2192 {
2193   CORE_ADDR entry_pt;
2194
2195   if (args && *args)
2196     {
2197       warning ("\
2198 Can't pass arguments to remote MIPS board; arguments ignored.");
2199       /* And don't try to use them on the next "run" command.  */
2200       execute_command ("set args", 0);
2201     }
2202
2203   if (execfile == 0 || exec_bfd == 0)
2204     error ("No executable file specified");
2205
2206   entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
2207
2208   init_wait_for_inferior ();
2209
2210   /* FIXME: Should we set inferior_ptid here?  */
2211
2212   write_pc (entry_pt);
2213 }
2214
2215 /* Clean up after a process.  Actually nothing to do.  */
2216
2217 static void
2218 mips_mourn_inferior (void)
2219 {
2220   if (current_ops != NULL)
2221     unpush_target (current_ops);
2222   generic_mourn_inferior ();
2223 }
2224 \f
2225 /* We can write a breakpoint and read the shadow contents in one
2226    operation.  */
2227
2228 /* Insert a breakpoint.  On targets that don't have built-in
2229    breakpoint support, we read the contents of the target location and
2230    stash it, then overwrite it with a breakpoint instruction.  ADDR is
2231    the target location in the target machine.  BPT is the breakpoint
2232    being inserted or removed, which contains memory for saving the
2233    target contents.  */
2234
2235 static int
2236 mips_insert_breakpoint (struct bp_target_info *bp_tgt)
2237 {
2238   if (monitor_supports_breakpoints)
2239     return set_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
2240                            BREAK_FETCH);
2241   else
2242     return memory_insert_breakpoint (bp_tgt);
2243 }
2244
2245 static int
2246 mips_remove_breakpoint (struct bp_target_info *bp_tgt)
2247 {
2248   if (monitor_supports_breakpoints)
2249     return clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
2250                              BREAK_FETCH);
2251   else
2252     return memory_remove_breakpoint (bp_tgt);
2253 }
2254
2255 /* Tell whether this target can support a hardware breakpoint.  CNT
2256    is the number of hardware breakpoints already installed.  This
2257    implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro.  */
2258
2259 int
2260 mips_can_use_watchpoint (int type, int cnt, int othertype)
2261 {
2262   return cnt < MAX_LSI_BREAKPOINTS && strcmp (target_shortname, "lsi") == 0;
2263 }
2264
2265
2266 /* Compute a don't care mask for the region bounding ADDR and ADDR + LEN - 1.
2267    This is used for memory ref breakpoints.  */
2268
2269 static unsigned long
2270 calculate_mask (CORE_ADDR addr, int len)
2271 {
2272   unsigned long mask;
2273   int i;
2274
2275   mask = addr ^ (addr + len - 1);
2276
2277   for (i = 32; i >= 0; i--)
2278     if (mask == 0)
2279       break;
2280     else
2281       mask >>= 1;
2282
2283   mask = (unsigned long) 0xffffffff >> i;
2284
2285   return mask;
2286 }
2287
2288
2289 /* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
2290    for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
2291    watchpoint. */
2292
2293 int
2294 mips_insert_watchpoint (CORE_ADDR addr, int len, int type)
2295 {
2296   if (set_breakpoint (addr, len, type))
2297     return -1;
2298
2299   return 0;
2300 }
2301
2302 int
2303 mips_remove_watchpoint (CORE_ADDR addr, int len, int type)
2304 {
2305   if (clear_breakpoint (addr, len, type))
2306     return -1;
2307
2308   return 0;
2309 }
2310
2311 int
2312 mips_stopped_by_watchpoint (void)
2313 {
2314   return hit_watchpoint;
2315 }
2316
2317
2318 /* Insert a breakpoint.  */
2319
2320 static int
2321 set_breakpoint (CORE_ADDR addr, int len, enum break_type type)
2322 {
2323   return common_breakpoint (1, addr, len, type);
2324 }
2325
2326
2327 /* Clear a breakpoint.  */
2328
2329 static int
2330 clear_breakpoint (CORE_ADDR addr, int len, enum break_type type)
2331 {
2332   return common_breakpoint (0, addr, len, type);
2333 }
2334
2335
2336 /* Check the error code from the return packet for an LSI breakpoint
2337    command.  If there's no error, just return 0.  If it's a warning,
2338    print the warning text and return 0.  If it's an error, print
2339    the error text and return 1.  <ADDR> is the address of the breakpoint
2340    that was being set.  <RERRFLG> is the error code returned by PMON. 
2341    This is a helper function for common_breakpoint.  */
2342
2343 static int
2344 check_lsi_error (CORE_ADDR addr, int rerrflg)
2345 {
2346   struct lsi_error *err;
2347   char *saddr = paddr_nz (addr);        /* printable address string */
2348
2349   if (rerrflg == 0)             /* no error */
2350     return 0;
2351
2352   /* Warnings can be ORed together, so check them all.  */
2353   if (rerrflg & W_WARN)
2354     {
2355       if (monitor_warnings)
2356         {
2357           int found = 0;
2358           for (err = lsi_warning_table; err->code != 0; err++)
2359             {
2360               if ((err->code & rerrflg) == err->code)
2361                 {
2362                   found = 1;
2363                   fprintf_unfiltered (gdb_stderr,
2364                                   "common_breakpoint (0x%s): Warning: %s\n",
2365                                       saddr,
2366                                       err->string);
2367                 }
2368             }
2369           if (!found)
2370             fprintf_unfiltered (gdb_stderr,
2371                         "common_breakpoint (0x%s): Unknown warning: 0x%x\n",
2372                                 saddr,
2373                                 rerrflg);
2374         }
2375       return 0;
2376     }
2377
2378   /* Errors are unique, i.e. can't be ORed together.  */
2379   for (err = lsi_error_table; err->code != 0; err++)
2380     {
2381       if ((err->code & rerrflg) == err->code)
2382         {
2383           fprintf_unfiltered (gdb_stderr,
2384                               "common_breakpoint (0x%s): Error: %s\n",
2385                               saddr,
2386                               err->string);
2387           return 1;
2388         }
2389     }
2390   fprintf_unfiltered (gdb_stderr,
2391                       "common_breakpoint (0x%s): Unknown error: 0x%x\n",
2392                       saddr,
2393                       rerrflg);
2394   return 1;
2395 }
2396
2397
2398 /* This routine sends a breakpoint command to the remote target.
2399
2400    <SET> is 1 if setting a breakpoint, or 0 if clearing a breakpoint.
2401    <ADDR> is the address of the breakpoint.
2402    <LEN> the length of the region to break on.
2403    <TYPE> is the type of breakpoint:
2404    0 = write                    (BREAK_WRITE)
2405    1 = read                     (BREAK_READ)
2406    2 = read/write               (BREAK_ACCESS)
2407    3 = instruction fetch        (BREAK_FETCH)
2408
2409    Return 0 if successful; otherwise 1.  */
2410
2411 static int
2412 common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
2413 {
2414   char buf[DATA_MAXLEN + 1];
2415   char cmd, rcmd;
2416   int rpid, rerrflg, rresponse, rlen;
2417   int nfields;
2418
2419   addr = gdbarch_addr_bits_remove (current_gdbarch, addr);
2420
2421   if (mips_monitor == MON_LSI)
2422     {
2423       if (set == 0)             /* clear breakpoint */
2424         {
2425           /* The LSI PMON "clear breakpoint" has this form:
2426              <pid> 'b' <bptn> 0x0
2427              reply:
2428              <pid> 'b' 0x0 <code>
2429
2430              <bptn> is a breakpoint number returned by an earlier 'B' command.
2431              Possible return codes: OK, E_BPT.  */
2432
2433           int i;
2434
2435           /* Search for the breakpoint in the table.  */
2436           for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
2437             if (lsi_breakpoints[i].type == type
2438                 && lsi_breakpoints[i].addr == addr
2439                 && lsi_breakpoints[i].len == len)
2440               break;
2441
2442           /* Clear the table entry and tell PMON to clear the breakpoint.  */
2443           if (i == MAX_LSI_BREAKPOINTS)
2444             {
2445               warning ("common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
2446                        paddr_nz (addr));
2447               return 1;
2448             }
2449
2450           lsi_breakpoints[i].type = BREAK_UNUSED;
2451           sprintf (buf, "0x0 b 0x%x 0x0", i);
2452           mips_send_packet (buf, 1);
2453
2454           rlen = mips_receive_packet (buf, 1, mips_receive_wait);
2455           buf[rlen] = '\0';
2456
2457           nfields = sscanf (buf, "0x%x b 0x0 0x%x", &rpid, &rerrflg);
2458           if (nfields != 2)
2459             mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
2460
2461           return (check_lsi_error (addr, rerrflg));
2462         }
2463       else
2464         /* set a breakpoint */
2465         {
2466           /* The LSI PMON "set breakpoint" command has this form:
2467              <pid> 'B' <addr> 0x0
2468              reply:
2469              <pid> 'B' <bptn> <code>
2470
2471              The "set data breakpoint" command has this form:
2472
2473              <pid> 'A' <addr1> <type> [<addr2>  [<value>]]
2474
2475              where: type= "0x1" = read
2476              "0x2" = write
2477              "0x3" = access (read or write)
2478
2479              The reply returns two values:
2480              bptn - a breakpoint number, which is a small integer with
2481              possible values of zero through 255.
2482              code - an error return code, a value of zero indicates a
2483              succesful completion, other values indicate various
2484              errors and warnings.
2485
2486              Possible return codes: OK, W_QAL, E_QAL, E_OUT, E_NON.  
2487
2488            */
2489
2490           if (type == BREAK_FETCH)      /* instruction breakpoint */
2491             {
2492               cmd = 'B';
2493               sprintf (buf, "0x0 B 0x%s 0x0", paddr_nz (addr));
2494             }
2495           else
2496             /* watchpoint */
2497             {
2498               cmd = 'A';
2499               sprintf (buf, "0x0 A 0x%s 0x%x 0x%s", paddr_nz (addr),
2500                      type == BREAK_READ ? 1 : (type == BREAK_WRITE ? 2 : 3),
2501                        paddr_nz (addr + len - 1));
2502             }
2503           mips_send_packet (buf, 1);
2504
2505           rlen = mips_receive_packet (buf, 1, mips_receive_wait);
2506           buf[rlen] = '\0';
2507
2508           nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
2509                             &rpid, &rcmd, &rresponse, &rerrflg);
2510           if (nfields != 4 || rcmd != cmd || rresponse > 255)
2511             mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
2512
2513           if (rerrflg != 0)
2514             if (check_lsi_error (addr, rerrflg))
2515               return 1;
2516
2517           /* rresponse contains PMON's breakpoint number.  Record the
2518              information for this breakpoint so we can clear it later.  */
2519           lsi_breakpoints[rresponse].type = type;
2520           lsi_breakpoints[rresponse].addr = addr;
2521           lsi_breakpoints[rresponse].len = len;
2522
2523           return 0;
2524         }
2525     }
2526   else
2527     {
2528       /* On non-LSI targets, the breakpoint command has this form:
2529          0x0 <CMD> <ADDR> <MASK> <FLAGS>
2530          <MASK> is a don't care mask for addresses.
2531          <FLAGS> is any combination of `r', `w', or `f' for read/write/fetch.
2532        */
2533       unsigned long mask;
2534
2535       mask = calculate_mask (addr, len);
2536       addr &= ~mask;
2537
2538       if (set)                  /* set a breakpoint */
2539         {
2540           char *flags;
2541           switch (type)
2542             {
2543             case BREAK_WRITE:   /* write */
2544               flags = "w";
2545               break;
2546             case BREAK_READ:    /* read */
2547               flags = "r";
2548               break;
2549             case BREAK_ACCESS:  /* read/write */
2550               flags = "rw";
2551               break;
2552             case BREAK_FETCH:   /* fetch */
2553               flags = "f";
2554               break;
2555             default:
2556               internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
2557             }
2558
2559           cmd = 'B';
2560           sprintf (buf, "0x0 B 0x%s 0x%s %s", paddr_nz (addr),
2561                    paddr_nz (mask), flags);
2562         }
2563       else
2564         {
2565           cmd = 'b';
2566           sprintf (buf, "0x0 b 0x%s", paddr_nz (addr));
2567         }
2568
2569       mips_send_packet (buf, 1);
2570
2571       rlen = mips_receive_packet (buf, 1, mips_receive_wait);
2572       buf[rlen] = '\0';
2573
2574       nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
2575                         &rpid, &rcmd, &rerrflg, &rresponse);
2576
2577       if (nfields != 4 || rcmd != cmd)
2578         mips_error ("common_breakpoint: Bad response from remote board: %s",
2579                     buf);
2580
2581       if (rerrflg != 0)
2582         {
2583           /* Ddb returns "0x0 b 0x16 0x0\000", whereas
2584              Cogent returns "0x0 b 0xffffffff 0x16\000": */
2585           if (mips_monitor == MON_DDB)
2586             rresponse = rerrflg;
2587           if (rresponse != 22)  /* invalid argument */
2588             fprintf_unfiltered (gdb_stderr,
2589                              "common_breakpoint (0x%s):  Got error: 0x%x\n",
2590                                 paddr_nz (addr), rresponse);
2591           return 1;
2592         }
2593     }
2594   return 0;
2595 }
2596 \f
2597 static void
2598 send_srec (char *srec, int len, CORE_ADDR addr)
2599 {
2600   while (1)
2601     {
2602       int ch;
2603
2604       serial_write (mips_desc, srec, len);
2605
2606       ch = mips_readchar (remote_timeout);
2607
2608       switch (ch)
2609         {
2610         case SERIAL_TIMEOUT:
2611           error ("Timeout during download.");
2612           break;
2613         case 0x6:               /* ACK */
2614           return;
2615         case 0x15:              /* NACK */
2616           fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %s!  Retrying.\n", paddr_u (addr));
2617           continue;
2618         default:
2619           error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);
2620         }
2621     }
2622 }
2623
2624 /*  Download a binary file by converting it to S records. */
2625
2626 static void
2627 mips_load_srec (char *args)
2628 {
2629   bfd *abfd;
2630   asection *s;
2631   char *buffer, srec[1024];
2632   unsigned int i;
2633   unsigned int srec_frame = 200;
2634   int reclen;
2635   static int hashmark = 1;
2636
2637   buffer = alloca (srec_frame * 2 + 256);
2638
2639   abfd = bfd_openr (args, 0);
2640   if (!abfd)
2641     {
2642       printf_filtered ("Unable to open file %s\n", args);
2643       return;
2644     }
2645
2646   if (bfd_check_format (abfd, bfd_object) == 0)
2647     {
2648       printf_filtered ("File is not an object file\n");
2649       return;
2650     }
2651
2652 /* This actually causes a download in the IDT binary format: */
2653   mips_send_command (LOAD_CMD, 0);
2654
2655   for (s = abfd->sections; s; s = s->next)
2656     {
2657       if (s->flags & SEC_LOAD)
2658         {
2659           unsigned int numbytes;
2660
2661           /* FIXME!  vma too small????? */
2662           printf_filtered ("%s\t: 0x%4lx .. 0x%4lx  ", s->name,
2663                            (long) s->vma,
2664                            (long) (s->vma + bfd_get_section_size (s)));
2665           gdb_flush (gdb_stdout);
2666
2667           for (i = 0; i < bfd_get_section_size (s); i += numbytes)
2668             {
2669               numbytes = min (srec_frame, bfd_get_section_size (s) - i);
2670
2671               bfd_get_section_contents (abfd, s, buffer, i, numbytes);
2672
2673               reclen = mips_make_srec (srec, '3', s->vma + i, 
2674                                        buffer, numbytes);
2675               send_srec (srec, reclen, s->vma + i);
2676
2677               if (deprecated_ui_load_progress_hook)
2678                 deprecated_ui_load_progress_hook (s->name, i);
2679
2680               if (hashmark)
2681                 {
2682                   putchar_unfiltered ('#');
2683                   gdb_flush (gdb_stdout);
2684                 }
2685
2686             }                   /* Per-packet (or S-record) loop */
2687
2688           putchar_unfiltered ('\n');
2689         }                       /* Loadable sections */
2690     }
2691   if (hashmark)
2692     putchar_unfiltered ('\n');
2693
2694   /* Write a type 7 terminator record. no data for a type 7, and there
2695      is no data, so len is 0.  */
2696
2697   reclen = mips_make_srec (srec, '7', abfd->start_address, NULL, 0);
2698
2699   send_srec (srec, reclen, abfd->start_address);
2700
2701   serial_flush_input (mips_desc);
2702 }
2703
2704 /*
2705  * mips_make_srec -- make an srecord. This writes each line, one at a
2706  *      time, each with it's own header and trailer line.
2707  *      An srecord looks like this:
2708  *
2709  * byte count-+     address
2710  * start ---+ |        |       data        +- checksum
2711  *          | |        |                   |
2712  *        S01000006F6B692D746573742E73726563E4
2713  *        S315000448600000000000000000FC00005900000000E9
2714  *        S31A0004000023C1400037DE00F023604000377B009020825000348D
2715  *        S30B0004485A0000000000004E
2716  *        S70500040000F6
2717  *
2718  *      S<type><length><address><data><checksum>
2719  *
2720  *      Where
2721  *      - length
2722  *        is the number of bytes following upto the checksum. Note that
2723  *        this is not the number of chars following, since it takes two
2724  *        chars to represent a byte.
2725  *      - type
2726  *        is one of:
2727  *        0) header record
2728  *        1) two byte address data record
2729  *        2) three byte address data record
2730  *        3) four byte address data record
2731  *        7) four byte address termination record
2732  *        8) three byte address termination record
2733  *        9) two byte address termination record
2734  *       
2735  *      - address
2736  *        is the start address of the data following, or in the case of
2737  *        a termination record, the start address of the image
2738  *      - data
2739  *        is the data.
2740  *      - checksum
2741  *        is the sum of all the raw byte data in the record, from the length
2742  *        upwards, modulo 256 and subtracted from 255.
2743  *
2744  * This routine returns the length of the S-record.
2745  *
2746  */
2747
2748 static int
2749 mips_make_srec (char *buf, int type, CORE_ADDR memaddr, unsigned char *myaddr,
2750                 int len)
2751 {
2752   unsigned char checksum;
2753   int i;
2754
2755   /* Create the header for the srec. addr_size is the number of bytes in the address,
2756      and 1 is the number of bytes in the count.  */
2757
2758   /* FIXME!! bigger buf required for 64-bit! */
2759   buf[0] = 'S';
2760   buf[1] = type;
2761   buf[2] = len + 4 + 1;         /* len + 4 byte address + 1 byte checksum */
2762   /* This assumes S3 style downloads (4byte addresses). There should
2763      probably be a check, or the code changed to make it more
2764      explicit. */
2765   buf[3] = memaddr >> 24;
2766   buf[4] = memaddr >> 16;
2767   buf[5] = memaddr >> 8;
2768   buf[6] = memaddr;
2769   memcpy (&buf[7], myaddr, len);
2770
2771   /* Note that the checksum is calculated on the raw data, not the
2772      hexified data.  It includes the length, address and the data
2773      portions of the packet.  */
2774   checksum = 0;
2775   buf += 2;                     /* Point at length byte */
2776   for (i = 0; i < len + 4 + 1; i++)
2777     checksum += *buf++;
2778
2779   *buf = ~checksum;
2780
2781   return len + 8;
2782 }
2783
2784 /* The following manifest controls whether we enable the simple flow
2785    control support provided by the monitor. If enabled the code will
2786    wait for an affirmative ACK between transmitting packets. */
2787 #define DOETXACK (1)
2788
2789 /* The PMON fast-download uses an encoded packet format constructed of
2790    3byte data packets (encoded as 4 printable ASCII characters), and
2791    escape sequences (preceded by a '/'):
2792
2793    'K'     clear checksum
2794    'C'     compare checksum (12bit value, not included in checksum calculation)
2795    'S'     define symbol name (for addr) terminated with "," and padded to 4char boundary
2796    'Z'     zero fill multiple of 3bytes
2797    'B'     byte (12bit encoded value, of 8bit data)
2798    'A'     address (36bit encoded value)
2799    'E'     define entry as original address, and exit load
2800
2801    The packets are processed in 4 character chunks, so the escape
2802    sequences that do not have any data (or variable length data)
2803    should be padded to a 4 character boundary.  The decoder will give
2804    an error if the complete message block size is not a multiple of
2805    4bytes (size of record).
2806
2807    The encoding of numbers is done in 6bit fields.  The 6bit value is
2808    used to index into this string to get the specific character
2809    encoding for the value: */
2810 static char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,.";
2811
2812 /* Convert the number of bits required into an encoded number, 6bits
2813    at a time (range 0..63).  Keep a checksum if required (passed
2814    pointer non-NULL). The function returns the number of encoded
2815    characters written into the buffer. */
2816 static int
2817 pmon_makeb64 (unsigned long v, char *p, int n, int *chksum)
2818 {
2819   int count = (n / 6);
2820
2821   if ((n % 12) != 0)
2822     {
2823       fprintf_unfiltered (gdb_stderr,
2824                           "Fast encoding bitcount must be a multiple of 12bits: %dbit%s\n", n, (n == 1) ? "" : "s");
2825       return (0);
2826     }
2827   if (n > 36)
2828     {
2829       fprintf_unfiltered (gdb_stderr,
2830                           "Fast encoding cannot process more than 36bits at the moment: %dbits\n", n);
2831       return (0);
2832     }
2833
2834   /* Deal with the checksum: */
2835   if (chksum != NULL)
2836     {
2837       switch (n)
2838         {
2839         case 36:
2840           *chksum += ((v >> 24) & 0xFFF);
2841         case 24:
2842           *chksum += ((v >> 12) & 0xFFF);
2843         case 12:
2844           *chksum += ((v >> 0) & 0xFFF);
2845         }
2846     }
2847
2848   do
2849     {
2850       n -= 6;
2851       *p++ = encoding[(v >> n) & 0x3F];
2852     }
2853   while (n > 0);
2854
2855   return (count);
2856 }
2857
2858 /* Shorthand function (that could be in-lined) to output the zero-fill
2859    escape sequence into the data stream. */
2860 static int
2861 pmon_zeroset (int recsize, char **buff, int *amount, unsigned int *chksum)
2862 {
2863   int count;
2864
2865   sprintf (*buff, "/Z");
2866   count = pmon_makeb64 (*amount, (*buff + 2), 12, chksum);
2867   *buff += (count + 2);
2868   *amount = 0;
2869   return (recsize + count + 2);
2870 }
2871
2872 static int
2873 pmon_checkset (int recsize, char **buff, int *value)
2874 {
2875   int count;
2876
2877   /* Add the checksum (without updating the value): */
2878   sprintf (*buff, "/C");
2879   count = pmon_makeb64 (*value, (*buff + 2), 12, NULL);
2880   *buff += (count + 2);
2881   sprintf (*buff, "\n");
2882   *buff += 2;                   /* include zero terminator */
2883   /* Forcing a checksum validation clears the sum: */
2884   *value = 0;
2885   return (recsize + count + 3);
2886 }
2887
2888 /* Amount of padding we leave after at the end of the output buffer,
2889    for the checksum and line termination characters: */
2890 #define CHECKSIZE (4 + 4 + 4 + 2)
2891 /* zero-fill, checksum, transfer end and line termination space. */
2892
2893 /* The amount of binary data loaded from the object file in a single
2894    operation: */
2895 #define BINCHUNK (1024)
2896
2897 /* Maximum line of data accepted by the monitor: */
2898 #define MAXRECSIZE (550)
2899 /* NOTE: This constant depends on the monitor being used. This value
2900    is for PMON 5.x on the Cogent Vr4300 board. */
2901
2902 static void
2903 pmon_make_fastrec (char **outbuf, unsigned char *inbuf, int *inptr,
2904                    int inamount, int *recsize, unsigned int *csum,
2905                    unsigned int *zerofill)
2906 {
2907   int count = 0;
2908   char *p = *outbuf;
2909
2910   /* This is a simple check to ensure that our data will fit within
2911      the maximum allowable record size. Each record output is 4bytes
2912      in length. We must allow space for a pending zero fill command,
2913      the record, and a checksum record. */
2914   while ((*recsize < (MAXRECSIZE - CHECKSIZE)) && ((inamount - *inptr) > 0))
2915     {
2916       /* Process the binary data: */
2917       if ((inamount - *inptr) < 3)
2918         {
2919           if (*zerofill != 0)
2920             *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
2921           sprintf (p, "/B");
2922           count = pmon_makeb64 (inbuf[*inptr], &p[2], 12, csum);
2923           p += (2 + count);
2924           *recsize += (2 + count);
2925           (*inptr)++;
2926         }
2927       else
2928         {
2929           unsigned int value = ((inbuf[*inptr + 0] << 16) | (inbuf[*inptr + 1] << 8) | inbuf[*inptr + 2]);
2930           /* Simple check for zero data. TODO: A better check would be
2931              to check the last, and then the middle byte for being zero
2932              (if the first byte is not). We could then check for
2933              following runs of zeros, and if above a certain size it is
2934              worth the 4 or 8 character hit of the byte insertions used
2935              to pad to the start of the zeroes. NOTE: This also depends
2936              on the alignment at the end of the zero run. */
2937           if (value == 0x00000000)
2938             {
2939               (*zerofill)++;
2940               if (*zerofill == 0xFFF)   /* 12bit counter */
2941                 *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
2942             }
2943           else
2944             {
2945               if (*zerofill != 0)
2946                 *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
2947               count = pmon_makeb64 (value, p, 24, csum);
2948               p += count;
2949               *recsize += count;
2950             }
2951           *inptr += 3;
2952         }
2953     }
2954
2955   *outbuf = p;
2956   return;
2957 }
2958
2959 static int
2960 pmon_check_ack (char *mesg)
2961 {
2962 #if defined(DOETXACK)
2963   int c;
2964
2965   if (!tftp_in_use)
2966     {
2967       c = serial_readchar (udp_in_use ? udp_desc : mips_desc,
2968                            remote_timeout);
2969       if ((c == SERIAL_TIMEOUT) || (c != 0x06))
2970         {
2971           fprintf_unfiltered (gdb_stderr,
2972                               "Failed to receive valid ACK for %s\n", mesg);
2973           return (-1);          /* terminate the download */
2974         }
2975     }
2976 #endif /* DOETXACK */
2977   return (0);
2978 }
2979
2980 /* pmon_download - Send a sequence of characters to the PMON download port,
2981    which is either a serial port or a UDP socket.  */
2982
2983 static void
2984 pmon_start_download (void)
2985 {
2986   if (tftp_in_use)
2987     {
2988       /* Create the temporary download file.  */
2989       if ((tftp_file = fopen (tftp_localname, "w")) == NULL)
2990         perror_with_name (tftp_localname);
2991     }
2992   else
2993     {
2994       mips_send_command (udp_in_use ? LOAD_CMD_UDP : LOAD_CMD, 0);
2995       mips_expect ("Downloading from ");
2996       mips_expect (udp_in_use ? "udp" : "tty0");
2997       mips_expect (", ^C to abort\r\n");
2998     }
2999 }
3000
3001 static int
3002 mips_expect_download (char *string)
3003 {
3004   if (!mips_expect (string))
3005     {
3006       fprintf_unfiltered (gdb_stderr, "Load did not complete successfully.\n");
3007       if (tftp_in_use)
3008         remove (tftp_localname);        /* Remove temporary file */
3009       return 0;
3010     }
3011   else
3012     return 1;
3013 }
3014
3015 static void
3016 pmon_check_entry_address (char *entry_address, int final)
3017 {
3018   char hexnumber[9];            /* includes '\0' space */
3019   mips_expect_timeout (entry_address, tftp_in_use ? 15 : remote_timeout);
3020   sprintf (hexnumber, "%x", final);
3021   mips_expect (hexnumber);
3022   mips_expect ("\r\n");
3023 }
3024
3025 static int
3026 pmon_check_total (int bintotal)
3027 {
3028   char hexnumber[9];            /* includes '\0' space */
3029   mips_expect ("\r\ntotal = 0x");
3030   sprintf (hexnumber, "%x", bintotal);
3031   mips_expect (hexnumber);
3032   return mips_expect_download (" bytes\r\n");
3033 }
3034
3035 static void
3036 pmon_end_download (int final, int bintotal)
3037 {
3038   char hexnumber[9];            /* includes '\0' space */
3039
3040   if (tftp_in_use)
3041     {
3042       static char *load_cmd_prefix = "load -b -s ";
3043       char *cmd;
3044       struct stat stbuf;
3045
3046       /* Close off the temporary file containing the load data.  */
3047       fclose (tftp_file);
3048       tftp_file = NULL;
3049
3050       /* Make the temporary file readable by the world.  */
3051       if (stat (tftp_localname, &stbuf) == 0)
3052         chmod (tftp_localname, stbuf.st_mode | S_IROTH);
3053
3054       /* Must reinitialize the board to prevent PMON from crashing.  */
3055       mips_send_command ("initEther\r", -1);
3056
3057       /* Send the load command.  */
3058       cmd = xmalloc (strlen (load_cmd_prefix) + strlen (tftp_name) + 2);
3059       strcpy (cmd, load_cmd_prefix);
3060       strcat (cmd, tftp_name);
3061       strcat (cmd, "\r");
3062       mips_send_command (cmd, 0);
3063       xfree (cmd);
3064       if (!mips_expect_download ("Downloading from "))
3065         return;
3066       if (!mips_expect_download (tftp_name))
3067         return;
3068       if (!mips_expect_download (", ^C to abort\r\n"))
3069         return;
3070     }
3071
3072   /* Wait for the stuff that PMON prints after the load has completed.
3073      The timeout value for use in the tftp case (15 seconds) was picked
3074      arbitrarily but might be too small for really large downloads. FIXME. */
3075   switch (mips_monitor)
3076     {
3077     case MON_LSI:
3078       pmon_check_ack ("termination");
3079       pmon_check_entry_address ("Entry address is ", final);
3080       if (!pmon_check_total (bintotal))
3081         return;
3082       break;
3083     default:
3084       pmon_check_entry_address ("Entry Address  = ", final);
3085       pmon_check_ack ("termination");
3086       if (!pmon_check_total (bintotal))
3087         return;
3088       break;
3089     }
3090
3091   if (tftp_in_use)
3092     remove (tftp_localname);    /* Remove temporary file */
3093 }
3094
3095 static void
3096 pmon_download (char *buffer, int length)
3097 {
3098   if (tftp_in_use)
3099     fwrite (buffer, 1, length, tftp_file);
3100   else
3101     serial_write (udp_in_use ? udp_desc : mips_desc, buffer, length);
3102 }
3103
3104 static void
3105 pmon_load_fast (char *file)
3106 {
3107   bfd *abfd;
3108   asection *s;
3109   unsigned char *binbuf;
3110   char *buffer;
3111   int reclen;
3112   unsigned int csum = 0;
3113   int hashmark = !tftp_in_use;
3114   int bintotal = 0;
3115   int final = 0;
3116   int finished = 0;
3117
3118   buffer = (char *) xmalloc (MAXRECSIZE + 1);
3119   binbuf = (unsigned char *) xmalloc (BINCHUNK);
3120
3121   abfd = bfd_openr (file, 0);
3122   if (!abfd)
3123     {
3124       printf_filtered ("Unable to open file %s\n", file);
3125       return;
3126     }
3127
3128   if (bfd_check_format (abfd, bfd_object) == 0)
3129     {
3130       printf_filtered ("File is not an object file\n");
3131       return;
3132     }
3133
3134   /* Setup the required download state: */
3135   mips_send_command ("set dlproto etxack\r", -1);
3136   mips_send_command ("set dlecho off\r", -1);
3137   /* NOTE: We get a "cannot set variable" message if the variable is
3138      already defined to have the argument we give. The code doesn't
3139      care, since it just scans to the next prompt anyway. */
3140   /* Start the download: */
3141   pmon_start_download ();
3142
3143   /* Zero the checksum */
3144   sprintf (buffer, "/Kxx\n");
3145   reclen = strlen (buffer);
3146   pmon_download (buffer, reclen);
3147   finished = pmon_check_ack ("/Kxx");
3148
3149   for (s = abfd->sections; s && !finished; s = s->next)
3150     if (s->flags & SEC_LOAD)    /* only deal with loadable sections */
3151       {
3152         bintotal += bfd_get_section_size (s);
3153         final = (s->vma + bfd_get_section_size (s));
3154
3155         printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, (unsigned int) s->vma,
3156                          (unsigned int) (s->vma + bfd_get_section_size (s)));
3157         gdb_flush (gdb_stdout);
3158
3159         /* Output the starting address */
3160         sprintf (buffer, "/A");
3161         reclen = pmon_makeb64 (s->vma, &buffer[2], 36, &csum);
3162         buffer[2 + reclen] = '\n';
3163         buffer[3 + reclen] = '\0';
3164         reclen += 3;            /* for the initial escape code and carriage return */
3165         pmon_download (buffer, reclen);
3166         finished = pmon_check_ack ("/A");
3167
3168         if (!finished)
3169           {
3170             unsigned int binamount;
3171             unsigned int zerofill = 0;
3172             char *bp = buffer;
3173             unsigned int i;
3174
3175             reclen = 0;
3176
3177             for (i = 0;
3178                  i < bfd_get_section_size (s) && !finished;
3179                  i += binamount)
3180               {
3181                 int binptr = 0;
3182
3183                 binamount = min (BINCHUNK, bfd_get_section_size (s) - i);
3184
3185                 bfd_get_section_contents (abfd, s, binbuf, i, binamount);
3186
3187                 /* This keeps a rolling checksum, until we decide to output
3188                    the line: */
3189                 for (; ((binamount - binptr) > 0);)
3190                   {
3191                     pmon_make_fastrec (&bp, binbuf, &binptr, binamount, 
3192                                        &reclen, &csum, &zerofill);
3193                     if (reclen >= (MAXRECSIZE - CHECKSIZE))
3194                       {
3195                         reclen = pmon_checkset (reclen, &bp, &csum);
3196                         pmon_download (buffer, reclen);
3197                         finished = pmon_check_ack ("data record");
3198                         if (finished)
3199                           {
3200                             zerofill = 0;       /* do not transmit pending zerofills */
3201                             break;
3202                           }
3203
3204                         if (deprecated_ui_load_progress_hook)
3205                           deprecated_ui_load_progress_hook (s->name, i);
3206
3207                         if (hashmark)
3208                           {
3209                             putchar_unfiltered ('#');
3210                             gdb_flush (gdb_stdout);
3211                           }
3212
3213                         bp = buffer;
3214                         reclen = 0;     /* buffer processed */
3215                       }
3216                   }
3217               }
3218
3219             /* Ensure no out-standing zerofill requests: */
3220             if (zerofill != 0)
3221               reclen = pmon_zeroset (reclen, &bp, &zerofill, &csum);
3222
3223             /* and then flush the line: */
3224             if (reclen > 0)
3225               {
3226                 reclen = pmon_checkset (reclen, &bp, &csum);
3227                 /* Currently pmon_checkset outputs the line terminator by
3228                    default, so we write out the buffer so far: */
3229                 pmon_download (buffer, reclen);
3230                 finished = pmon_check_ack ("record remnant");
3231               }
3232           }
3233
3234         putchar_unfiltered ('\n');
3235       }
3236
3237   /* Terminate the transfer. We know that we have an empty output
3238      buffer at this point. */
3239   sprintf (buffer, "/E/E\n");   /* include dummy padding characters */
3240   reclen = strlen (buffer);
3241   pmon_download (buffer, reclen);
3242
3243   if (finished)
3244     {                           /* Ignore the termination message: */
3245       serial_flush_input (udp_in_use ? udp_desc : mips_desc);
3246     }
3247   else
3248     {                           /* Deal with termination message: */
3249       pmon_end_download (final, bintotal);
3250     }
3251
3252   return;
3253 }
3254
3255 /* mips_load -- download a file. */
3256
3257 static void
3258 mips_load (char *file, int from_tty)
3259 {
3260   /* Get the board out of remote debugging mode.  */
3261   if (mips_exit_debug ())
3262     error ("mips_load:  Couldn't get into monitor mode.");
3263
3264   if (mips_monitor != MON_IDT)
3265     pmon_load_fast (file);
3266   else
3267     mips_load_srec (file);
3268
3269   mips_initialize ();
3270
3271   /* Finally, make the PC point at the start address */
3272   if (mips_monitor != MON_IDT)
3273     {
3274       /* Work around problem where PMON monitor updates the PC after a load
3275          to a different value than GDB thinks it has. The following ensures
3276          that the write_pc() WILL update the PC value: */
3277       regcache_set_valid_p (get_current_regcache (),
3278                             gdbarch_pc_regnum (current_gdbarch), 0);
3279     }
3280   if (exec_bfd)
3281     write_pc (bfd_get_start_address (exec_bfd));
3282
3283   inferior_ptid = null_ptid;    /* No process now */
3284
3285 /* This is necessary because many things were based on the PC at the time that
3286    we attached to the monitor, which is no longer valid now that we have loaded
3287    new code (and just changed the PC).  Another way to do this might be to call
3288    normal_stop, except that the stack may not be valid, and things would get
3289    horribly confused... */
3290
3291   clear_symtab_users ();
3292 }
3293
3294
3295 /* Pass the command argument as a packet to PMON verbatim.  */
3296
3297 static void
3298 pmon_command (char *args, int from_tty)
3299 {
3300   char buf[DATA_MAXLEN + 1];
3301   int rlen;
3302
3303   sprintf (buf, "0x0 %s", args);
3304   mips_send_packet (buf, 1);
3305   printf_filtered ("Send packet: %s\n", buf);
3306
3307   rlen = mips_receive_packet (buf, 1, mips_receive_wait);
3308   buf[rlen] = '\0';
3309   printf_filtered ("Received packet: %s\n", buf);
3310 }
3311 \f
3312 extern initialize_file_ftype _initialize_remote_mips; /* -Wmissing-prototypes */
3313
3314 void
3315 _initialize_remote_mips (void)
3316 {
3317   /* Initialize the fields in mips_ops that are common to all four targets.  */
3318   mips_ops.to_longname = "Remote MIPS debugging over serial line";
3319   mips_ops.to_close = mips_close;
3320   mips_ops.to_detach = mips_detach;
3321   mips_ops.to_resume = mips_resume;
3322   mips_ops.to_fetch_registers = mips_fetch_registers;
3323   mips_ops.to_store_registers = mips_store_registers;
3324   mips_ops.to_prepare_to_store = mips_prepare_to_store;
3325   mips_ops.deprecated_xfer_memory = mips_xfer_memory;
3326   mips_ops.to_files_info = mips_files_info;
3327   mips_ops.to_insert_breakpoint = mips_insert_breakpoint;
3328   mips_ops.to_remove_breakpoint = mips_remove_breakpoint;
3329   mips_ops.to_insert_watchpoint = mips_insert_watchpoint;
3330   mips_ops.to_remove_watchpoint = mips_remove_watchpoint;
3331   mips_ops.to_stopped_by_watchpoint = mips_stopped_by_watchpoint;
3332   mips_ops.to_can_use_hw_breakpoint = mips_can_use_watchpoint;
3333   mips_ops.to_kill = mips_kill;
3334   mips_ops.to_load = mips_load;
3335   mips_ops.to_create_inferior = mips_create_inferior;
3336   mips_ops.to_mourn_inferior = mips_mourn_inferior;
3337   mips_ops.to_log_command = serial_log_command;
3338   mips_ops.to_stratum = process_stratum;
3339   mips_ops.to_has_all_memory = 1;
3340   mips_ops.to_has_memory = 1;
3341   mips_ops.to_has_stack = 1;
3342   mips_ops.to_has_registers = 1;
3343   mips_ops.to_has_execution = 1;
3344   mips_ops.to_magic = OPS_MAGIC;
3345
3346   /* Copy the common fields to all four target vectors.  */
3347   pmon_ops = ddb_ops = lsi_ops = mips_ops;
3348
3349   /* Initialize target-specific fields in the target vectors.  */
3350   mips_ops.to_shortname = "mips";
3351   mips_ops.to_doc = "\
3352 Debug a board using the MIPS remote debugging protocol over a serial line.\n\
3353 The argument is the device it is connected to or, if it contains a colon,\n\
3354 HOST:PORT to access a board over a network";
3355   mips_ops.to_open = mips_open;
3356   mips_ops.to_wait = mips_wait;
3357
3358   pmon_ops.to_shortname = "pmon";
3359   pmon_ops.to_doc = "\
3360 Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
3361 line. The argument is the device it is connected to or, if it contains a\n\
3362 colon, HOST:PORT to access a board over a network";
3363   pmon_ops.to_open = pmon_open;
3364   pmon_ops.to_wait = mips_wait;
3365
3366   ddb_ops.to_shortname = "ddb";
3367   ddb_ops.to_doc = "\
3368 Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
3369 line. The first argument is the device it is connected to or, if it contains\n\
3370 a colon, HOST:PORT to access a board over a network.  The optional second\n\
3371 parameter is the temporary file in the form HOST:FILENAME to be used for\n\
3372 TFTP downloads to the board.  The optional third parameter is the local name\n\
3373 of the TFTP temporary file, if it differs from the filename seen by the board.";
3374   ddb_ops.to_open = ddb_open;
3375   ddb_ops.to_wait = mips_wait;
3376
3377   lsi_ops.to_shortname = "lsi";
3378   lsi_ops.to_doc = pmon_ops.to_doc;
3379   lsi_ops.to_open = lsi_open;
3380   lsi_ops.to_wait = mips_wait;
3381
3382   /* Add the targets.  */
3383   add_target (&mips_ops);
3384   add_target (&pmon_ops);
3385   add_target (&ddb_ops);
3386   add_target (&lsi_ops);
3387
3388   add_setshow_zinteger_cmd ("timeout", no_class, &mips_receive_wait, _("\
3389 Set timeout in seconds for remote MIPS serial I/O."), _("\
3390 Show timeout in seconds for remote MIPS serial I/O."), NULL,
3391                             NULL,
3392                             NULL, /* FIXME: i18n: */
3393                             &setlist, &showlist);
3394
3395   add_setshow_zinteger_cmd ("retransmit-timeout", no_class,
3396                             &mips_retransmit_wait, _("\
3397 Set retransmit timeout in seconds for remote MIPS serial I/O."), _("\
3398 Show retransmit timeout in seconds for remote MIPS serial I/O."), _("\
3399 This is the number of seconds to wait for an acknowledgement to a packet\n\
3400 before resending the packet."),
3401                             NULL,
3402                             NULL, /* FIXME: i18n: */
3403                             &setlist, &showlist);
3404
3405   add_setshow_zinteger_cmd ("syn-garbage-limit", no_class,
3406                             &mips_syn_garbage,  _("\
3407 Set the maximum number of characters to ignore when scanning for a SYN."), _("\
3408 Show the maximum number of characters to ignore when scanning for a SYN."), _("\
3409 This is the maximum number of characters GDB will ignore when trying to\n\
3410 synchronize with the remote system.  A value of -1 means that there is no\n\
3411 limit. (Note that these characters are printed out even though they are\n\
3412 ignored.)"),
3413                             NULL,
3414                             NULL, /* FIXME: i18n: */
3415                             &setlist, &showlist);
3416
3417   add_setshow_string_cmd ("monitor-prompt", class_obscure,
3418                           &mips_monitor_prompt, _("\
3419 Set the prompt that GDB expects from the monitor."), _("\
3420 Show the prompt that GDB expects from the monitor."), NULL,
3421                           NULL,
3422                           NULL, /* FIXME: i18n: */
3423                           &setlist, &showlist);
3424
3425   add_setshow_zinteger_cmd ("monitor-warnings", class_obscure,
3426                             &monitor_warnings, _("\
3427 Set printing of monitor warnings."), _("\
3428 Show printing of monitor warnings."), _("\
3429 When enabled, monitor warnings about hardware breakpoints will be displayed."),
3430                             NULL,
3431                             NULL, /* FIXME: i18n: */
3432                             &setlist, &showlist);
3433
3434   add_com ("pmon", class_obscure, pmon_command,
3435            _("Send a packet to PMON (must be in debug mode)."));
3436
3437   add_setshow_boolean_cmd ("mask-address", no_class, &mask_address_p, _("\
3438 Set zeroing of upper 32 bits of 64-bit addresses when talking to PMON targets."), _("\
3439 Show zeroing of upper 32 bits of 64-bit addresses when talking to PMON targets."), _("\
3440 Use \"on\" to enable the masking and \"off\" to disable it."),
3441                            NULL,
3442                            NULL, /* FIXME: i18n: */
3443                            &setlist, &showlist);
3444 }