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