gdb/remote-mips.c

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