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