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