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   int 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%x",
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   SERIAL_WRITE (mips_desc, "\r", sizeof "\r" - 1);
1350
1351   /* We don't need to absorb any spurious characters here, since the
1352      mips_receive_header will eat up a reasonable number of characters
1353      whilst looking for the SYN, however this avoids the "garbage"
1354      being displayed to the user. */
1355   if (mips_monitor != MON_IDT)
1356     mips_expect ("\r");
1357
1358   {
1359     char buff[DATA_MAXLEN + 1];
1360     if (mips_receive_packet (buff, 1, 3) < 0)
1361       mips_error ("Failed to initialize (didn't receive packet).");
1362   }
1363 }
1364
1365 /* Exit remote (dbx) debug mode, returning to the monitor prompt: */
1366 static int
1367 mips_exit_debug ()
1368 {
1369   int err;
1370   struct cleanup *old_cleanups = make_cleanup (mips_exit_cleanups, NULL);
1371
1372   mips_exiting = 1;
1373
1374   if (mips_monitor != MON_IDT)
1375     {
1376       /* The DDB (NEC) and MiniRISC (LSI) versions of PMON exit immediately,
1377          so we do not get a reply to this command: */
1378       mips_request ('x', (unsigned int) 0, (unsigned int) 0, NULL,
1379                 mips_receive_wait, NULL);
1380       mips_need_reply = 0;
1381       if (!mips_expect (" break!"))
1382         return -1;
1383     }
1384   else
1385     mips_request ('x', (unsigned int) 0, (unsigned int) 0, &err,
1386                   mips_receive_wait, NULL);
1387
1388   if (mips_monitor == MON_IDT && !mips_expect ("Exiting remote debug"))
1389     return -1;
1390
1391   if (mips_monitor == MON_DDB)
1392     {
1393       if (!mips_expect ("\n"))
1394         return -1;
1395     }
1396   else
1397     if (!mips_expect ("\r\n"))
1398       return -1;
1399
1400   if (!mips_expect (mips_monitor_prompt))
1401     return -1;
1402
1403   do_cleanups (old_cleanups);
1404
1405   return 0;
1406 }
1407
1408 /* Initialize a new connection to the MIPS board, and make sure we are
1409    really connected.  */
1410
1411 static void
1412 mips_initialize ()
1413 {
1414   int err;
1415   struct cleanup *old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
1416   int j;
1417
1418   /* What is this code doing here?  I don't see any way it can happen, and
1419      it might mean mips_initializing didn't get cleared properly.
1420      So I'll make it a warning.  */
1421
1422   if (mips_initializing)
1423     {
1424       warning ("internal error: mips_initialize called twice");
1425       return;
1426     }
1427
1428   mips_wait_flag = 0;
1429   mips_initializing = 1;
1430
1431   /* At this point, the packit protocol isn't responding.  We'll try getting
1432      into the monitor, and restarting the protocol.  */
1433
1434   /* Force the system into the monitor.  After this we *should* be at
1435      the mips_monitor_prompt.  */
1436   if (mips_monitor != MON_IDT)
1437     j = 0; /* start by checking if we are already at the prompt */
1438   else
1439     j = 1; /* start by sending a break */
1440   for (; j <= 4; j++)
1441     {
1442       switch (j)
1443         {
1444         case 0:                 /* First, try sending a CR */
1445           SERIAL_FLUSH_INPUT (mips_desc);
1446           SERIAL_WRITE (mips_desc, "\r", 1);
1447           break;
1448         case 1:                 /* First, try sending a break */
1449           SERIAL_SEND_BREAK (mips_desc);
1450           break;
1451         case 2:                 /* Then, try a ^C */
1452           SERIAL_WRITE (mips_desc, "\003", 1);
1453           break;
1454         case 3:                 /* Then, try escaping from download */
1455           {
1456             if (mips_monitor != MON_IDT)
1457               {
1458                 char tbuff[7];
1459
1460                 /* We shouldn't need to send multiple termination
1461                    sequences, since the target performs line (or
1462                    block) reads, and then processes those
1463                    packets. In-case we were downloading a large packet
1464                    we flush the output buffer before inserting a
1465                    termination sequence. */
1466                 SERIAL_FLUSH_OUTPUT (mips_desc);
1467                 sprintf (tbuff, "\r/E/E\r");
1468                 SERIAL_WRITE (mips_desc, tbuff, 6);
1469               }
1470             else
1471               {
1472                 char srec[10];
1473                 int i;
1474
1475                 /* We are possibly in binary download mode, having
1476                    aborted in the middle of an S-record.  ^C won't
1477                    work because of binary mode.  The only reliable way
1478                    out is to send enough termination packets (8 bytes)
1479                    to fill up and then overflow the largest size
1480                    S-record (255 bytes in this case).  This amounts to
1481                    256/8 + 1 packets.
1482                    */
1483
1484                 mips_make_srec (srec, '7', 0, NULL, 0);
1485
1486                 for (i = 1; i <= 33; i++)
1487                   {
1488                     SERIAL_WRITE (mips_desc, srec, 8);
1489
1490                     if (SERIAL_READCHAR (mips_desc, 0) >= 0)
1491                       break;    /* Break immediatly if we get something from
1492                                    the board. */
1493                   }
1494               }
1495           }
1496           break;
1497         case 4:
1498           mips_error ("Failed to initialize.");
1499         }
1500
1501       if (mips_expect (mips_monitor_prompt))
1502         break;
1503     }
1504
1505   if (mips_monitor != MON_IDT)
1506     {
1507       /* Sometimes PMON ignores the first few characters in the first
1508          command sent after a load.  Sending a blank command gets
1509          around that.  */
1510       mips_send_command ("\r", -1);
1511
1512       /* Ensure the correct target state: */
1513       if (mips_monitor != MON_LSI)
1514         mips_send_command ("set regsize 64\r", -1);
1515       mips_send_command ("set hostport tty0\r", -1);
1516       mips_send_command ("set brkcmd \"\"\r", -1);
1517       /* Delete all the current breakpoints: */
1518       mips_send_command ("db *\r", -1);
1519       /* NOTE: PMON does not have breakpoint support through the
1520          "debug" mode, only at the monitor command-line. */
1521     }
1522
1523   mips_enter_debug ();
1524
1525   /* Clear all breakpoints: */
1526   if ((mips_monitor == MON_IDT
1527        && clear_breakpoint (BREAK_UNUSED, -1, 0) == 0)
1528       || mips_monitor == MON_LSI)
1529     monitor_supports_breakpoints = 1;
1530   else
1531     monitor_supports_breakpoints = 0;
1532
1533   do_cleanups (old_cleanups);
1534
1535   /* If this doesn't call error, we have connected; we don't care if
1536      the request itself succeeds or fails.  */
1537
1538   mips_request ('r', (unsigned int) 0, (unsigned int) 0, &err,
1539                 mips_receive_wait, NULL);
1540   set_current_frame (create_new_frame (read_fp (), read_pc ()));
1541   select_frame (get_current_frame (), 0);
1542 }
1543
1544 /* Open a connection to the remote board.  */
1545 static void
1546 common_open (ops, name, from_tty, new_monitor, new_monitor_prompt)
1547      struct target_ops *ops;
1548      char *name;
1549      int from_tty;
1550      enum mips_monitor_type new_monitor;
1551      char *new_monitor_prompt;
1552 {
1553   char *ptype;
1554   char *serial_port_name;
1555   char *remote_name = 0;
1556   char *local_name = 0;
1557   char **argv;
1558
1559   if (name == 0)
1560     error (
1561 "To open a MIPS remote debugging connection, you need to specify what serial\n\
1562 device is attached to the target board (e.g., /dev/ttya).\n"
1563 "If you want to use TFTP to download to the board, specify the name of a\n"
1564 "temporary file to be used by GDB for downloads as the second argument.\n"
1565 "This filename must be in the form host:filename, where host is the name\n"
1566 "of the host running the TFTP server, and the file must be readable by the\n"
1567 "world.  If the local name of the temporary file differs from the name as\n"
1568 "seen from the board via TFTP, specify that name as the third parameter.\n");
1569
1570   /* Parse the serial port name, the optional TFTP name, and the
1571      optional local TFTP name.  */
1572   if ((argv = buildargv (name)) == NULL)
1573     nomem(0);
1574   make_cleanup (freeargv, (char *) argv);
1575
1576   serial_port_name = strsave (argv[0]);
1577   if (argv[1])                          /* remote TFTP name specified? */
1578     {
1579       remote_name = argv[1];
1580       if (argv[2])                      /* local TFTP filename specified? */
1581         local_name = argv[2];
1582     }
1583
1584   target_preopen (from_tty);
1585
1586   if (mips_is_open)
1587     unpush_target (current_ops);
1588
1589   /* Open and initialize the serial port.  */
1590   mips_desc = SERIAL_OPEN (serial_port_name);
1591   if (mips_desc == (serial_t) NULL)
1592     perror_with_name (serial_port_name);
1593
1594   if (baud_rate != -1)
1595     {
1596       if (SERIAL_SETBAUDRATE (mips_desc, baud_rate))
1597         {
1598           SERIAL_CLOSE (mips_desc);
1599           perror_with_name (serial_port_name);
1600         }
1601     }
1602
1603   SERIAL_RAW (mips_desc);
1604
1605   /* Open and initialize the optional download port.  If it is in the form
1606      hostname#portnumber, it's a UDP socket.  If it is in the form
1607      hostname:filename, assume it's the TFTP filename that must be
1608      passed to the DDB board to tell it where to get the load file.  */
1609   if (remote_name)
1610     {
1611       if (strchr (remote_name, '#'))
1612         {
1613           udp_desc = SERIAL_OPEN (remote_name);
1614           if (!udp_desc)
1615             perror_with_name ("Unable to open UDP port");
1616           udp_in_use = 1;
1617         }
1618       else
1619         {
1620           /* Save the remote and local names of the TFTP temp file.  If
1621              the user didn't specify a local name, assume it's the same
1622              as the part of the remote name after the "host:".  */
1623           if (tftp_name)
1624             free (tftp_name);
1625           if (tftp_localname)
1626             free (tftp_localname);
1627           if (local_name == NULL)
1628               if ((local_name = strchr (remote_name, ':')) != NULL)
1629                 local_name++;           /* skip over the colon */
1630           if (local_name == NULL)
1631             local_name = remote_name;   /* local name same as remote name */
1632           tftp_name = strsave (remote_name);
1633           tftp_localname = strsave (local_name);
1634           tftp_in_use = 1;
1635         }
1636     }
1637
1638   current_ops = ops;
1639   mips_is_open = 1;
1640
1641   /* Reset the expected monitor prompt if it's never been set before.  */
1642   if (mips_monitor_prompt == NULL)
1643     mips_monitor_prompt = strsave (new_monitor_prompt);
1644   mips_monitor = new_monitor;
1645
1646   mips_initialize ();
1647
1648   if (from_tty)
1649     printf_unfiltered ("Remote MIPS debugging using %s\n", serial_port_name);
1650
1651   /* Switch to using remote target now.  */
1652   push_target (ops);
1653
1654   /* FIXME: Should we call start_remote here?  */
1655
1656   /* Try to figure out the processor model if possible.  */
1657   ptype = mips_read_processor_type ();
1658   if (ptype)
1659     mips_set_processor_type_command (strsave (ptype), 0);
1660
1661 /* This is really the job of start_remote however, that makes an assumption
1662    that the target is about to print out a status message of some sort.  That
1663    doesn't happen here (in fact, it may not be possible to get the monitor to
1664    send the appropriate packet).  */
1665
1666   flush_cached_frames ();
1667   registers_changed ();
1668   stop_pc = read_pc ();
1669   set_current_frame (create_new_frame (read_fp (), stop_pc));
1670   select_frame (get_current_frame (), 0);
1671   print_stack_frame (selected_frame, -1, 1);
1672   free (serial_port_name);
1673 }
1674
1675 static void
1676 mips_open (name, from_tty)
1677      char *name;
1678      int from_tty;
1679 {
1680   common_open (&mips_ops, name, from_tty, MON_IDT, TARGET_MONITOR_PROMPT);
1681 }
1682
1683 static void
1684 pmon_open (name, from_tty)
1685      char *name;
1686      int from_tty;
1687 {
1688   common_open (&pmon_ops, name, from_tty, MON_PMON, "PMON> ");
1689 }
1690
1691 static void
1692 ddb_open (name, from_tty)
1693      char *name;
1694      int from_tty;
1695 {
1696   common_open (&ddb_ops, name, from_tty, MON_DDB, "NEC010>");
1697 }
1698
1699 static void
1700 lsi_open (name, from_tty)
1701      char *name;
1702      int from_tty;
1703 {
1704   int i;
1705
1706   /* Clear the LSI breakpoint table.  */
1707   for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
1708     lsi_breakpoints[i].type = BREAK_UNUSED;
1709
1710   common_open (&lsi_ops, name, from_tty, MON_LSI, "PMON> ");
1711 }
1712
1713 /* Close a connection to the remote board.  */
1714
1715 static void
1716 mips_close (quitting)
1717      int quitting;
1718 {
1719   if (mips_is_open)
1720     {
1721       /* Get the board out of remote debugging mode.  */
1722       (void) mips_exit_debug ();
1723
1724       close_ports ();
1725     }
1726 }
1727
1728 /* Detach from the remote board.  */
1729
1730 static void
1731 mips_detach (args, from_tty)
1732      char *args;
1733      int from_tty;
1734 {
1735   if (args)
1736     error ("Argument given to \"detach\" when remotely debugging.");
1737
1738   pop_target ();
1739
1740   mips_close (1);
1741
1742   if (from_tty)
1743     printf_unfiltered ("Ending remote MIPS debugging.\n");
1744 }
1745
1746 /* Tell the target board to resume.  This does not wait for a reply
1747    from the board, except in the case of single-stepping on LSI boards,
1748    where PMON does return a reply.  */
1749
1750 static void
1751 mips_resume (pid, step, siggnal)
1752      int pid, step;
1753      enum target_signal siggnal;
1754 {
1755   int err;
1756
1757   /* LSI PMON requires returns a reply packet "0x1 s 0x0 0x57f" after
1758      a single step, so we wait for that.  */
1759   mips_request (step ? 's' : 'c',
1760                 (unsigned int) 1,
1761                 (unsigned int) siggnal,
1762                 mips_monitor == MON_LSI && step ? &err : (int *) NULL,
1763                 mips_receive_wait, NULL);
1764 }
1765
1766 /* Return the signal corresponding to SIG, where SIG is the number which
1767    the MIPS protocol uses for the signal.  */
1768 enum target_signal
1769 mips_signal_from_protocol (sig)
1770      int sig;
1771 {
1772   /* We allow a few more signals than the IDT board actually returns, on
1773      the theory that there is at least *some* hope that perhaps the numbering
1774      for these signals is widely agreed upon.  */
1775   if (sig <= 0
1776       || sig > 31)
1777     return TARGET_SIGNAL_UNKNOWN;
1778
1779   /* Don't want to use target_signal_from_host because we are converting
1780      from MIPS signal numbers, not host ones.  Our internal numbers
1781      match the MIPS numbers for the signals the board can return, which
1782      are: SIGINT, SIGSEGV, SIGBUS, SIGILL, SIGFPE, SIGTRAP.  */
1783   return (enum target_signal) sig;
1784 }
1785
1786 /* Wait until the remote stops, and return a wait status.  */
1787
1788 static int
1789 mips_wait (pid, status)
1790      int pid;
1791      struct target_waitstatus *status;
1792 {
1793   int rstatus;
1794   int err;
1795   char buff[DATA_MAXLEN];
1796   int rpc, rfp, rsp;
1797   char flags[20];
1798   int nfields;
1799   int i;
1800
1801   interrupt_count = 0;
1802   hit_watchpoint = 0;
1803
1804   /* If we have not sent a single step or continue command, then the
1805      board is waiting for us to do something.  Return a status
1806      indicating that it is stopped.  */
1807   if (! mips_need_reply)
1808     {
1809       status->kind = TARGET_WAITKIND_STOPPED;
1810       status->value.sig = TARGET_SIGNAL_TRAP;
1811       return 0;
1812     }
1813
1814   /* No timeout; we sit here as long as the program continues to execute.  */
1815   mips_wait_flag = 1;
1816   rstatus = mips_request ('\000', (unsigned int) 0, (unsigned int) 0, &err, -1,
1817                           buff);
1818   mips_wait_flag = 0;
1819   if (err)
1820     mips_error ("Remote failure: %s", safe_strerror (errno));
1821
1822   /* On returning from a continue, the PMON monitor seems to start
1823      echoing back the messages we send prior to sending back the
1824      ACK. The code can cope with this, but to try and avoid the
1825      unnecessary serial traffic, and "spurious" characters displayed
1826      to the user, we cheat and reset the debug protocol. The problems
1827      seems to be caused by a check on the number of arguments, and the
1828      command length, within the monitor causing it to echo the command
1829      as a bad packet. */
1830   if (mips_monitor == MON_PMON)
1831     {
1832       mips_exit_debug ();
1833       mips_enter_debug ();
1834     }
1835
1836   /* See if we got back extended status.  If so, pick out the pc, fp, sp, etc... */
1837
1838   nfields = sscanf (buff, "0x%*x %*c 0x%*x 0x%*x 0x%x 0x%x 0x%x 0x%*x %s",
1839                     &rpc, &rfp, &rsp, flags);
1840   if (nfields >= 3)
1841     {
1842       char buf[MAX_REGISTER_RAW_SIZE];
1843
1844       store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc);
1845       supply_register (PC_REGNUM, buf);
1846
1847       store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rfp);
1848       supply_register (30, buf); /* This register they are avoiding and so it is unnamed */
1849
1850       store_unsigned_integer (buf, REGISTER_RAW_SIZE (SP_REGNUM), rsp);
1851       supply_register (SP_REGNUM, buf);
1852
1853       store_unsigned_integer (buf, REGISTER_RAW_SIZE (FP_REGNUM), 0);
1854       supply_register (FP_REGNUM, buf);
1855
1856       if (nfields == 9)
1857         {
1858           int i;
1859
1860           for (i = 0; i <= 2; i++)
1861             if (flags[i] == 'r' || flags[i] == 'w')
1862               hit_watchpoint = 1;
1863             else if (flags[i] == '\000')
1864               break;
1865         }
1866     }
1867
1868   if (strcmp (target_shortname, "lsi") == 0)
1869     {
1870 #if 0
1871       /* If this is an LSI PMON target, see if we just hit a hardrdware watchpoint.
1872          Right now, PMON doesn't give us enough information to determine which
1873          breakpoint we hit.  So we have to look up the PC in our own table
1874          of breakpoints, and if found, assume it's just a normal instruction
1875          fetch breakpoint, not a data watchpoint.  FIXME when PMON
1876          provides some way to tell us what type of breakpoint it is.  */
1877       int i;
1878       CORE_ADDR pc = read_pc();
1879
1880       hit_watchpoint = 1;
1881       for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
1882         {
1883           if (lsi_breakpoints[i].addr == pc
1884               && lsi_breakpoints[i].type == BREAK_FETCH)
1885             {
1886               hit_watchpoint = 0;
1887               break;
1888             }
1889         }
1890 #else
1891       /* If a data breakpoint was hit, PMON returns the following packet:
1892              0x1 c 0x0 0x57f 0x1
1893          The return packet from an ordinary breakpoint doesn't have the
1894          extra 0x01 field tacked onto the end.  */
1895       if (nfields == 1 && rpc == 1)
1896         hit_watchpoint = 1;
1897 #endif
1898     }
1899
1900   /* NOTE: The following (sig) numbers are defined by PMON:
1901         SPP_SIGTRAP     5       breakpoint
1902         SPP_SIGINT      2
1903         SPP_SIGSEGV     11
1904         SPP_SIGBUS      10
1905         SPP_SIGILL      4
1906         SPP_SIGFPE      8
1907         SPP_SIGTERM     15 */
1908
1909   /* Translate a MIPS waitstatus.  We use constants here rather than WTERMSIG
1910      and so on, because the constants we want here are determined by the
1911      MIPS protocol and have nothing to do with what host we are running on.  */
1912   if ((rstatus & 0xff) == 0)
1913     {
1914       status->kind = TARGET_WAITKIND_EXITED;
1915       status->value.integer = (((rstatus) >> 8) & 0xff);
1916     }
1917   else if ((rstatus & 0xff) == 0x7f)
1918     {
1919       status->kind = TARGET_WAITKIND_STOPPED;
1920       status->value.sig = mips_signal_from_protocol (((rstatus) >> 8) & 0xff);
1921
1922       /* If the stop PC is in the _exit function, assume
1923          we hit the 'break 0x3ff' instruction in _exit, so this
1924          is not a normal breakpoint.  */
1925       if (strcmp (target_shortname, "lsi") == 0)
1926         {
1927           char *func_name;
1928           CORE_ADDR func_start;
1929           CORE_ADDR pc = read_pc();
1930
1931           find_pc_partial_function (pc, &func_name, &func_start, NULL);
1932           if (func_name != NULL && strcmp (func_name, "_exit") == 0
1933               && func_start == pc)
1934             status->kind = TARGET_WAITKIND_EXITED;
1935         }
1936     }
1937   else
1938     {
1939       status->kind = TARGET_WAITKIND_SIGNALLED;
1940       status->value.sig = mips_signal_from_protocol (rstatus & 0x7f);
1941     }
1942
1943   return 0;
1944 }
1945
1946 /* We have to map between the register numbers used by gdb and the
1947    register numbers used by the debugging protocol.  This function
1948    assumes that we are using tm-mips.h.  */
1949
1950 #define REGNO_OFFSET 96
1951
1952 static int
1953 mips_map_regno (regno)
1954      int regno;
1955 {
1956   if (regno < 32)
1957     return regno;
1958   if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
1959     return regno - FP0_REGNUM + 32;
1960   switch (regno)
1961     {
1962     case PC_REGNUM:
1963       return REGNO_OFFSET + 0;
1964     case CAUSE_REGNUM:
1965       return REGNO_OFFSET + 1;
1966     case HI_REGNUM:
1967       return REGNO_OFFSET + 2;
1968     case LO_REGNUM:
1969       return REGNO_OFFSET + 3;
1970     case FCRCS_REGNUM:
1971       return REGNO_OFFSET + 4;
1972     case FCRIR_REGNUM:
1973       return REGNO_OFFSET + 5;
1974     default:
1975       /* FIXME: Is there a way to get the status register?  */
1976       return 0;
1977     }
1978 }
1979
1980 /* Fetch the remote registers.  */
1981
1982 static void
1983 mips_fetch_registers (regno)
1984      int regno;
1985 {
1986   unsigned LONGEST val;
1987   int err;
1988
1989   if (regno == -1)
1990     {
1991       for (regno = 0; regno < NUM_REGS; regno++)
1992         mips_fetch_registers (regno);
1993       return;
1994     }
1995
1996   if (regno == FP_REGNUM || regno == ZERO_REGNUM)
1997     /* FP_REGNUM on the mips is a hack which is just supposed to read
1998        zero (see also mips-nat.c).  */
1999     val = 0;
2000   else
2001     {
2002       /* If PMON doesn't support this register, don't waste serial
2003          bandwidth trying to read it.  */
2004       int pmon_reg = mips_map_regno (regno);
2005       if (regno != 0 && pmon_reg == 0)
2006         val = 0;
2007       else
2008         {
2009           /* Unfortunately the PMON version in the Vr4300 board has been
2010              compiled without the 64bit register access commands. This
2011              means we cannot get hold of the full register width. */
2012           if (mips_monitor == MON_DDB)
2013             val = (unsigned)mips_request ('t', (unsigned int) pmon_reg,
2014                                 (unsigned int) 0, &err, mips_receive_wait, NULL);
2015           else
2016             val = mips_request ('r', (unsigned int) pmon_reg,
2017                                 (unsigned int) 0, &err, mips_receive_wait, NULL);
2018           if (err)
2019             mips_error ("Can't read register %d: %s", regno,
2020                         safe_strerror (errno));
2021         }
2022     }
2023
2024   {
2025     char buf[MAX_REGISTER_RAW_SIZE];
2026
2027     /* We got the number the register holds, but gdb expects to see a
2028        value in the target byte ordering.  */
2029     store_unsigned_integer (buf, REGISTER_RAW_SIZE (regno), val);
2030     supply_register (regno, buf);
2031   }
2032 }
2033
2034 /* Prepare to store registers.  The MIPS protocol can store individual
2035    registers, so this function doesn't have to do anything.  */
2036
2037 static void
2038 mips_prepare_to_store ()
2039 {
2040 }
2041
2042 /* Store remote register(s).  */
2043
2044 static void
2045 mips_store_registers (regno)
2046      int regno;
2047 {
2048   int err;
2049
2050   if (regno == -1)
2051     {
2052       for (regno = 0; regno < NUM_REGS; regno++)
2053         mips_store_registers (regno);
2054       return;
2055     }
2056
2057   mips_request ('R', (unsigned int) mips_map_regno (regno),
2058                 read_register (regno),
2059                 &err, mips_receive_wait, NULL);
2060   if (err)
2061     mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));
2062 }
2063
2064 /* Fetch a word from the target board.  */
2065
2066 static unsigned int
2067 mips_fetch_word (addr)
2068      CORE_ADDR addr;
2069 {
2070   unsigned int val;
2071   int err;
2072
2073   /* FIXME! addr was cast to uint! */
2074   val = mips_request ('d', addr, (unsigned int) 0, &err,
2075                       mips_receive_wait, NULL);
2076   if (err)
2077     {
2078       /* Data space failed; try instruction space.  */
2079       /* FIXME! addr was cast to uint! */
2080       val = mips_request ('i', addr, (unsigned int) 0, &err,
2081                           mips_receive_wait, NULL);
2082       if (err)
2083         mips_error ("Can't read address 0x%s: %s",
2084               paddr_nz (addr), safe_strerror (errno));
2085     }
2086   return val;
2087 }
2088
2089 /* Store a word to the target board.  Returns errno code or zero for
2090    success.  If OLD_CONTENTS is non-NULL, put the old contents of that
2091    memory location there.  */
2092
2093 /* FIXME! make sure only 32-bit quantities get stored! */
2094 static int
2095 mips_store_word (addr, val, old_contents)
2096      CORE_ADDR addr;
2097      unsigned int val;
2098      char *old_contents;
2099 {
2100   int err;
2101   unsigned int oldcontents;
2102
2103   oldcontents = mips_request ('D', addr, (unsigned int) val,
2104                               &err,
2105                               mips_receive_wait, NULL);
2106   if (err)
2107     {
2108       /* Data space failed; try instruction space.  */
2109       oldcontents = mips_request ('I', addr,
2110                                   (unsigned int) val, &err,
2111                                   mips_receive_wait, NULL);
2112       if (err)
2113         return errno;
2114     }
2115   if (old_contents != NULL)
2116     store_unsigned_integer (old_contents, 4, oldcontents);
2117   return 0;
2118 }
2119
2120 /* Read or write LEN bytes from inferior memory at MEMADDR,
2121    transferring to or from debugger address MYADDR.  Write to inferior
2122    if SHOULD_WRITE is nonzero.  Returns length of data written or
2123    read; 0 for error.  Note that protocol gives us the correct value
2124    for a longword, since it transfers values in ASCII.  We want the
2125    byte values, so we have to swap the longword values.  */
2126
2127 static int
2128 mips_xfer_memory (memaddr, myaddr, len, write, ignore)
2129      CORE_ADDR memaddr;
2130      char *myaddr;
2131      int len;
2132      int write;
2133      struct target_ops *ignore;
2134 {
2135   register int i;
2136   /* Round starting address down to longword boundary.  */
2137   register CORE_ADDR addr = memaddr &~ 3;
2138   /* Round ending address up; get number of longwords that makes.  */
2139   register int count = (((memaddr + len) - addr) + 3) / 4;
2140   /* Allocate buffer of that many longwords.  */
2141   register char *buffer = alloca (count * 4);
2142
2143   int status;
2144
2145   if (write)
2146     {
2147       /* Fill start and end extra bytes of buffer with existing data.  */
2148       if (addr != memaddr || len < 4)
2149         {
2150           /* Need part of initial word -- fetch it.  */
2151           store_unsigned_integer (&buffer[0], 4, mips_fetch_word (addr));
2152         }
2153
2154       if (count > 1)
2155         {
2156           /* Need part of last word -- fetch it.  FIXME: we do this even
2157              if we don't need it.  */
2158           store_unsigned_integer (&buffer[(count - 1) * 4], 4,
2159                                   mips_fetch_word (addr + (count - 1) * 4));
2160         }
2161
2162       /* Copy data to be written over corresponding part of buffer */
2163
2164       memcpy ((char *) buffer + (memaddr & 3), myaddr, len);
2165
2166       /* Write the entire buffer.  */
2167
2168       for (i = 0; i < count; i++, addr += 4)
2169         {
2170           status = mips_store_word (addr,
2171                                     extract_unsigned_integer (&buffer[i*4], 4),
2172                                     NULL);
2173           /* Report each kilobyte (we download 32-bit words at a time) */
2174           if (i % 256 == 255)
2175             {
2176               printf_unfiltered ("*");
2177               fflush (stdout);
2178             }
2179           if (status)
2180             {
2181               errno = status;
2182               return 0;
2183             }
2184           /* FIXME: Do we want a QUIT here?  */
2185         }
2186       if (count >= 256)
2187         printf_unfiltered ("\n");
2188     }
2189   else
2190     {
2191       /* Read all the longwords */
2192       for (i = 0; i < count; i++, addr += 4)
2193         {
2194           store_unsigned_integer (&buffer[i*4], 4, mips_fetch_word (addr));
2195           QUIT;
2196         }
2197
2198       /* Copy appropriate bytes out of the buffer.  */
2199       memcpy (myaddr, buffer + (memaddr & 3), len);
2200     }
2201   return len;
2202 }
2203
2204 /* Print info on this target.  */
2205
2206 static void
2207 mips_files_info (ignore)
2208      struct target_ops *ignore;
2209 {
2210   printf_unfiltered ("Debugging a MIPS board over a serial line.\n");
2211 }
2212
2213 /* Kill the process running on the board.  This will actually only
2214    work if we are doing remote debugging over the console input.  I
2215    think that if IDT/sim had the remote debug interrupt enabled on the
2216    right port, we could interrupt the process with a break signal.  */
2217
2218 static void
2219 mips_kill ()
2220 {
2221   if (!mips_wait_flag)
2222     return;
2223
2224   interrupt_count++;
2225
2226   if (interrupt_count >= 2)
2227     {
2228       interrupt_count = 0;
2229
2230       target_terminal_ours ();
2231
2232       if (query ("Interrupted while waiting for the program.\n\
2233 Give up (and stop debugging it)? "))
2234         {
2235           /* Clean up in such a way that mips_close won't try to talk to the
2236              board (it almost surely won't work since we weren't able to talk to
2237              it).  */
2238           mips_wait_flag = 0;
2239           close_ports();
2240
2241           printf_unfiltered ("Ending remote MIPS debugging.\n");
2242           target_mourn_inferior ();
2243
2244           return_to_top_level (RETURN_QUIT);
2245         }
2246
2247       target_terminal_inferior ();
2248     }
2249
2250   if (remote_debug > 0)
2251     printf_unfiltered ("Sending break\n");
2252
2253   SERIAL_SEND_BREAK (mips_desc);
2254
2255 #if 0
2256   if (mips_is_open)
2257     {
2258       char cc;
2259
2260       /* Send a ^C.  */
2261       cc = '\003';
2262       SERIAL_WRITE (mips_desc, &cc, 1);
2263       sleep (1);
2264       target_mourn_inferior ();
2265     }
2266 #endif
2267 }
2268
2269 /* Start running on the target board.  */
2270
2271 static void
2272 mips_create_inferior (execfile, args, env)
2273      char *execfile;
2274      char *args;
2275      char **env;
2276 {
2277   CORE_ADDR entry_pt;
2278
2279   if (args && *args)
2280     {
2281       warning ("\
2282 Can't pass arguments to remote MIPS board; arguments ignored.");
2283       /* And don't try to use them on the next "run" command.  */
2284       execute_command ("set args", 0);
2285     }
2286
2287   if (execfile == 0 || exec_bfd == 0)
2288     error ("No executable file specified");
2289
2290   entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
2291
2292   init_wait_for_inferior ();
2293
2294   /* FIXME: Should we set inferior_pid here?  */
2295
2296   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
2297 }
2298
2299 /* Clean up after a process.  Actually nothing to do.  */
2300
2301 static void
2302 mips_mourn_inferior ()
2303 {
2304   if (current_ops != NULL)
2305     unpush_target (current_ops);
2306   generic_mourn_inferior ();
2307 }
2308 \f
2309 /* We can write a breakpoint and read the shadow contents in one
2310    operation.  */
2311
2312 /* Insert a breakpoint.  On targets that don't have built-in breakpoint
2313    support, we read the contents of the target location and stash it,
2314    then overwrite it with a breakpoint instruction.  ADDR is the target
2315    location in the target machine.  CONTENTS_CACHE is a pointer to
2316    memory allocated for saving the target contents.  It is guaranteed
2317    by the caller to be long enough to save sizeof BREAKPOINT bytes (this
2318    is accomplished via BREAKPOINT_MAX).  */
2319
2320 static int
2321 mips_insert_breakpoint (addr, contents_cache)
2322      CORE_ADDR addr;
2323      char *contents_cache;
2324 {
2325   if (monitor_supports_breakpoints)
2326     return set_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
2327   else
2328     return memory_insert_breakpoint (addr, contents_cache);
2329 }
2330
2331 static int
2332 mips_remove_breakpoint (addr, contents_cache)
2333      CORE_ADDR addr;
2334      char *contents_cache;
2335 {
2336   if (monitor_supports_breakpoints)
2337     return clear_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
2338   else
2339     return memory_remove_breakpoint (addr, contents_cache);
2340 }
2341
2342 #if 0 /* currently not used */
2343 /* PMON does not currently provide support for the debug mode 'b'
2344    commands to manipulate breakpoints. However, if we wanted to use
2345    the monitor breakpoints (rather than the GDB BREAK_INSN version)
2346    then this code performs the work needed to leave debug mode,
2347    set/clear the breakpoint, and then return to debug mode. */
2348
2349 #define PMON_MAX_BP (33) /* 32 SW, 1 HW */
2350 static CORE_ADDR mips_pmon_bp_info[PMON_MAX_BP];
2351 /* NOTE: The code relies on this vector being zero-initialised by the system */
2352
2353 static int
2354 pmon_insert_breakpoint (addr, contents_cache)
2355      CORE_ADDR addr;
2356      char *contents_cache;
2357 {
2358   int status;
2359
2360   if (monitor_supports_breakpoints)
2361     {
2362       char tbuff[12]; /* space for breakpoint command */
2363       int bpnum;
2364       CORE_ADDR bpaddr;
2365
2366       /* PMON does not support debug level breakpoint set/remove: */
2367       if (mips_exit_debug ())
2368         mips_error ("Failed to exit debug mode");
2369
2370       sprintf (tbuff, "b %08x\r", addr);
2371       mips_send_command (tbuff, 0);
2372
2373       mips_expect ("Bpt ");
2374
2375       if (!mips_getstring (tbuff, 2))
2376         return 1;
2377       tbuff[2] = '\0'; /* terminate the string */
2378       if (sscanf (tbuff, "%d", &bpnum) != 1)
2379         {
2380           fprintf_unfiltered (stderr, "Invalid decimal breakpoint number from target: %s\n", tbuff);
2381           return 1;
2382         }
2383
2384       mips_expect (" = ");
2385
2386       /* Lead in the hex number we are expecting: */
2387       tbuff[0] = '0';
2388       tbuff[1] = 'x';
2389
2390       /* FIXME!! only 8 bytes!  need to expand for Bfd64;
2391          which targets return 64-bit addresses?  PMON returns only 32! */
2392       if (!mips_getstring (&tbuff[2], 8))
2393         return 1;
2394       tbuff[10] = '\0'; /* terminate the string */
2395
2396       if (sscanf (tbuff, "0x%08x", &bpaddr) != 1)
2397         {
2398           fprintf_unfiltered (stderr, "Invalid hex address from target: %s\n", tbuff);
2399           return 1;
2400         }
2401
2402       if (bpnum >= PMON_MAX_BP)
2403         {
2404           fprintf_unfiltered (stderr, "Error: Returned breakpoint number %d outside acceptable range (0..%d)\n",
2405                               bpnum, PMON_MAX_BP - 1);
2406           return 1;
2407         }
2408
2409       if (bpaddr != addr)
2410         fprintf_unfiltered (stderr, "Warning: Breakpoint addresses do not match: 0x%x != 0x%x\n", addr, bpaddr);
2411
2412       mips_pmon_bp_info[bpnum] = bpaddr;
2413
2414       mips_expect ("\r\n");
2415       mips_expect (mips_monitor_prompt);
2416
2417       mips_enter_debug ();
2418
2419       return 0;
2420     }
2421
2422   return mips_store_word (addr, BREAK_INSN, contents_cache);
2423 }
2424
2425 static int
2426 pmon_remove_breakpoint (addr, contents_cache)
2427      CORE_ADDR addr;
2428      char *contents_cache;
2429 {
2430   if (monitor_supports_breakpoints)
2431     {
2432       int bpnum;
2433       char tbuff[7]; /* enough for delete breakpoint command */
2434
2435       for (bpnum = 0; bpnum < PMON_MAX_BP; bpnum++)
2436         if (mips_pmon_bp_info[bpnum] == addr)
2437           break;
2438
2439       if (bpnum >= PMON_MAX_BP)
2440         {
2441           fprintf_unfiltered (stderr,
2442             "pmon_remove_breakpoint: Failed to find breakpoint at address 0x%s\n",
2443             paddr_nz (addr));
2444           return 1;
2445         }
2446
2447       if (mips_exit_debug ())
2448         mips_error ("Failed to exit debug mode");
2449
2450       sprintf (tbuff, "db %02d\r", bpnum);
2451
2452       mips_send_command (tbuff, -1);
2453       /* NOTE: If the breakpoint does not exist then a "Bpt <dd> not
2454          set" message will be returned. */
2455
2456       mips_enter_debug ();
2457
2458       return 0;
2459     }
2460
2461   return target_write_memory (addr, contents_cache, BREAK_INSN_SIZE);
2462 }
2463 #endif
2464
2465
2466 /* Tell whether this target can support a hardware breakpoint.  CNT
2467    is the number of hardware breakpoints already installed.  This
2468    implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro.  */
2469
2470 int
2471 remote_mips_can_use_hardware_watchpoint (cnt)
2472      int cnt;
2473 {
2474     return cnt < MAX_LSI_BREAKPOINTS && strcmp (target_shortname, "lsi") == 0;
2475 }
2476
2477
2478 /* Compute a don't care mask for the region bounding ADDR and ADDR + LEN - 1.
2479    This is used for memory ref breakpoints.  */
2480
2481 static unsigned long
2482 calculate_mask (addr, len)
2483      CORE_ADDR addr;
2484      int len;
2485 {
2486   unsigned long mask;
2487   int i;
2488
2489   mask = addr ^ (addr + len - 1);
2490
2491   for (i = 32; i >= 0; i--)
2492     if (mask == 0)
2493       break;
2494     else
2495       mask >>= 1;
2496
2497   mask = (unsigned long) 0xffffffff >> i;
2498
2499   return mask;
2500 }
2501
2502 /* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
2503    for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
2504    watchpoint. */
2505
2506 int
2507 remote_mips_set_watchpoint (addr, len, type)
2508      CORE_ADDR addr;
2509      int len;
2510      int type;
2511 {
2512   if (set_breakpoint (addr, len, type))
2513     return -1;
2514
2515   return 0;
2516 }
2517
2518 int
2519 remote_mips_remove_watchpoint (addr, len, type)
2520      CORE_ADDR addr;
2521      int len;
2522      int type;
2523 {
2524   if (clear_breakpoint (addr, len, type))
2525     return -1;
2526
2527   return 0;
2528 }
2529
2530 int
2531 remote_mips_stopped_by_watchpoint ()
2532 {
2533   return hit_watchpoint;
2534 }
2535
2536
2537 /* Insert a breakpoint.  */
2538
2539 static int
2540 set_breakpoint (addr, len, type)
2541      CORE_ADDR addr;
2542      int len;
2543      enum break_type type;
2544 {
2545   return common_breakpoint (1, addr, len, type);
2546 }
2547
2548
2549 /* Clear a breakpoint.  */
2550
2551 static int
2552 clear_breakpoint (addr, len, type)
2553      CORE_ADDR addr;
2554      int len;
2555      enum break_type type;
2556 {
2557   return common_breakpoint (0, addr, len, type);
2558 }
2559
2560
2561 /* Check the error code from the return packet for an LSI breakpoint
2562    command.  If there's no error, just return 0.  If it's a warning,
2563    print the warning text and return 0.  If it's an error, print
2564    the error text and return 1.  <ADDR> is the address of the breakpoint
2565    that was being set.  <RERRFLG> is the error code returned by PMON.
2566    This is a helper function for common_breakpoint.  */
2567
2568 static int
2569 check_lsi_error (addr, rerrflg)
2570      CORE_ADDR addr;
2571      int rerrflg;
2572 {
2573   struct lsi_error *err;
2574   char *saddr = paddr_nz (addr);        /* printable address string */
2575
2576   if (rerrflg == 0)             /* no error */
2577     return 0;
2578
2579   /* Warnings can be ORed together, so check them all.  */
2580   if (rerrflg & W_WARN)
2581     {
2582       if (monitor_warnings)
2583         {
2584           int found = 0;
2585           for (err = lsi_warning_table; err->code != 0; err++)
2586             {
2587               if ((err->code & rerrflg) == err->code)
2588                 {
2589                   found = 1;
2590                   fprintf_unfiltered (stderr,
2591                                       "common_breakpoint (0x%s): Warning: %s\n",
2592                                       saddr,
2593                                       err->string);
2594                 }
2595             }
2596           if (!found)
2597             fprintf_unfiltered (stderr,
2598                                 "common_breakpoint (0x%s): Unknown warning: 0x%x\n",
2599                                 saddr,
2600                                 rerrflg);
2601         }
2602       return 0;
2603     }
2604
2605   /* Errors are unique, i.e. can't be ORed together.  */
2606   for (err = lsi_error_table; err->code != 0; err++)
2607     {
2608       if ((err->code & rerrflg) == err->code)
2609         {
2610           fprintf_unfiltered (stderr,
2611                               "common_breakpoint (0x%s): Error: %s\n",
2612                               saddr,
2613                               err->string);
2614           return 1;
2615         }
2616     }
2617   fprintf_unfiltered (stderr,
2618                       "common_breakpoint (0x%s): Unknown error: 0x%x\n",
2619                       saddr,
2620                       rerrflg);
2621   return 1;
2622 }
2623
2624
2625 /* This routine sends a breakpoint command to the remote target.
2626
2627    <SET> is 1 if setting a breakpoint, or 0 if clearing a breakpoint.
2628    <ADDR> is the address of the breakpoint.
2629    <LEN> the length of the region to break on.
2630    <TYPE> is the type of breakpoint:
2631      0 = write                  (BREAK_WRITE)
2632      1 = read                   (BREAK_READ)
2633      2 = read/write             (BREAK_ACCESS)
2634      3 = instruction fetch      (BREAK_FETCH)
2635
2636    Return 0 if successful; otherwise 1.  */
2637
2638 static int
2639 common_breakpoint (set, addr, len, type)
2640      int set;
2641      CORE_ADDR addr;
2642      int len;
2643      enum break_type type;
2644 {
2645   char buf[DATA_MAXLEN + 1];
2646   char cmd, rcmd;
2647   int rpid, rerrflg, rresponse, rlen;
2648   int nfields;
2649
2650   addr = ADDR_BITS_REMOVE (addr);
2651
2652   if (mips_monitor == MON_LSI)
2653     {
2654       if (set == 0)     /* clear breakpoint */
2655         {
2656           /* The LSI PMON "clear breakpoint" has this form:
2657                <pid> 'b' <bptn> 0x0
2658                reply:
2659                <pid> 'b' 0x0 <code>
2660
2661              <bptn> is a breakpoint number returned by an earlier 'B' command.
2662              Possible return codes: OK, E_BPT.  */
2663
2664           int i;
2665
2666           /* Search for the breakpoint in the table.  */
2667           for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
2668             if (lsi_breakpoints[i].type == type
2669                 && lsi_breakpoints[i].addr == addr
2670                 && lsi_breakpoints[i].len == len)
2671               break;
2672
2673           /* Clear the table entry and tell PMON to clear the breakpoint.  */
2674           if (i == MAX_LSI_BREAKPOINTS)
2675             {
2676               warning ("common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
2677                        paddr_nz (addr));
2678               return 1;
2679             }
2680
2681           lsi_breakpoints[i].type = BREAK_UNUSED;
2682           sprintf (buf, "0x0 b 0x%x 0x0", i);
2683           mips_send_packet (buf, 1);
2684
2685           rlen = mips_receive_packet (buf, 1, mips_receive_wait);
2686           buf[rlen] = '\0';
2687
2688           nfields = sscanf (buf, "0x%x b 0x0 0x%x", &rpid, &rerrflg);
2689           if (nfields != 2)
2690             mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
2691
2692           return (check_lsi_error (addr, rerrflg));
2693         }
2694       else      /* set a breakpoint */
2695         {
2696           /* The LSI PMON "set breakpoint" command has this form:
2697                <pid> 'B' <addr> 0x0
2698                reply:
2699                <pid> 'B' <bptn> <code>
2700
2701              The "set data breakpoint" command has this form:
2702
2703                 <pid> 'A' <addr1> <type> [<addr2>  [<value>]]
2704
2705                 where: type= "0x1" = read
2706                      "0x2" = write
2707                      "0x3" = access (read or write)
2708
2709              The reply returns two values:
2710                      bptn - a breakpoint number, which is a small integer with
2711                             possible values of zero through 255.
2712                      code - an error return code, a value of zero indicates a
2713                             succesful completion, other values indicate various
2714                             errors and warnings.
2715
2716              Possible return codes: OK, W_QAL, E_QAL, E_OUT, E_NON.
2717
2718           */
2719
2720           if (type == BREAK_FETCH)      /* instruction breakpoint */
2721             {
2722               cmd = 'B';
2723               sprintf (buf, "0x0 B 0x%s 0x0", paddr_nz (addr));
2724             }
2725           else                          /* watchpoint */
2726             {
2727               cmd = 'A';
2728               sprintf (buf, "0x0 A 0x%s 0x%x 0x%s", paddr_nz (addr),
2729                        type == BREAK_READ ? 1 : (type == BREAK_WRITE ? 2 : 3),
2730                        paddr_nz (addr + len - 1));
2731             }
2732           mips_send_packet (buf, 1);
2733
2734           rlen = mips_receive_packet (buf, 1, mips_receive_wait);
2735           buf[rlen] = '\0';
2736
2737           nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
2738                             &rpid, &rcmd, &rresponse, &rerrflg);
2739           if (nfields != 4 || rcmd != cmd || rresponse > 255)
2740             mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
2741
2742           if (rerrflg != 0)
2743             if (check_lsi_error (addr, rerrflg))
2744               return 1;
2745
2746           /* rresponse contains PMON's breakpoint number.  Record the
2747              information for this breakpoint so we can clear it later.  */
2748           lsi_breakpoints[rresponse].type = type;
2749           lsi_breakpoints[rresponse].addr = addr;
2750           lsi_breakpoints[rresponse].len =  len;
2751
2752           return 0;
2753         }
2754     }
2755   else
2756     {
2757       /* On non-LSI targets, the breakpoint command has this form:
2758            0x0 <CMD> <ADDR> <MASK> <FLAGS>
2759          <MASK> is a don't care mask for addresses.
2760          <FLAGS> is any combination of `r', `w', or `f' for read/write/fetch.
2761        */
2762       unsigned long mask;
2763
2764       mask = calculate_mask (addr, len);
2765       addr &= ~mask;
2766
2767       if (set)          /* set a breakpoint */
2768         {
2769           char *flags;
2770           switch (type)
2771             {
2772             case BREAK_WRITE:           /* write */
2773               flags = "w";
2774               break;
2775             case BREAK_READ:            /* read */
2776               flags = "r";
2777               break;
2778             case BREAK_ACCESS:          /* read/write */
2779               flags = "rw";
2780               break;
2781             default:
2782               abort ();
2783             }
2784
2785           cmd = 'B';
2786           sprintf (buf, "0x0 B 0x%s 0x%s %s", paddr_nz (addr),
2787                    paddr_nz (mask), flags);
2788         }
2789       else
2790         {
2791           cmd = 'b';
2792           sprintf (buf, "0x0 b 0x%s", paddr_nz (addr));
2793         }
2794
2795       mips_send_packet (buf, 1);
2796
2797       rlen = mips_receive_packet (buf, 1, mips_receive_wait);
2798       buf[rlen] = '\0';
2799
2800       nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
2801                         &rpid, &rcmd, &rerrflg, &rresponse);
2802
2803       if (nfields != 4 || rcmd != cmd)
2804         mips_error ("common_breakpoint: Bad response from remote board: %s",
2805                     buf);
2806
2807       if (rerrflg != 0)
2808         {
2809           /* Ddb returns "0x0 b 0x16 0x0\000", whereas
2810              Cogent returns "0x0 b 0xffffffff 0x16\000": */
2811           if (mips_monitor == MON_DDB)
2812             rresponse = rerrflg;
2813           if (rresponse != 22) /* invalid argument */
2814             fprintf_unfiltered (stderr, "common_breakpoint (0x%s):  Got error: 0x%x\n",
2815                                 paddr_nz (addr), rresponse);
2816           return 1;
2817         }
2818     }
2819   return 0;
2820 }
2821 \f
2822 static void
2823 send_srec (srec, len, addr)
2824      char *srec;
2825      int len;
2826      CORE_ADDR addr;
2827 {
2828   while (1)
2829     {
2830       int ch;
2831
2832       SERIAL_WRITE (mips_desc, srec, len);
2833
2834       ch = mips_readchar (2);
2835
2836       switch (ch)
2837         {
2838         case SERIAL_TIMEOUT:
2839           error ("Timeout during download.");
2840           break;
2841         case 0x6:               /* ACK */
2842           return;
2843         case 0x15:              /* NACK */
2844           fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %d!  Retrying.\n", addr);
2845           continue;
2846         default:
2847           error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);
2848         }
2849     }
2850 }
2851
2852 /*  Download a binary file by converting it to S records. */
2853
2854 static void
2855 mips_load_srec (args)
2856      char *args;
2857 {
2858   bfd *abfd;
2859   asection *s;
2860   char *buffer, srec[1024];
2861   unsigned int i;
2862   unsigned int srec_frame = 200;
2863   int reclen;
2864   static int hashmark = 1;
2865
2866   buffer = alloca (srec_frame * 2 + 256);
2867
2868   abfd = bfd_openr (args, 0);
2869   if (!abfd)
2870     {
2871       printf_filtered ("Unable to open file %s\n", args);
2872       return;
2873     }
2874
2875   if (bfd_check_format (abfd, bfd_object) == 0)
2876     {
2877       printf_filtered ("File is not an object file\n");
2878       return;
2879     }
2880
2881 /* This actually causes a download in the IDT binary format: */
2882   mips_send_command (LOAD_CMD, 0);
2883
2884   for (s = abfd->sections; s; s = s->next)
2885     {
2886       if (s->flags & SEC_LOAD)
2887         {
2888           unsigned int numbytes;
2889
2890           /* FIXME!  vma too small?? */
2891           printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, s->vma,
2892                            s->vma + s->_raw_size);
2893           gdb_flush (gdb_stdout);
2894
2895           for (i = 0; i < s->_raw_size; i += numbytes)
2896             {
2897               numbytes = min (srec_frame, s->_raw_size - i);
2898
2899               bfd_get_section_contents (abfd, s, buffer, i, numbytes);
2900
2901               reclen = mips_make_srec (srec, '3', s->vma + i, buffer, numbytes);
2902               send_srec (srec, reclen, s->vma + i);
2903
2904               if (hashmark)
2905                 {
2906                   putchar_unfiltered ('#');
2907                   gdb_flush (gdb_stdout);
2908                 }
2909
2910             } /* Per-packet (or S-record) loop */
2911
2912           putchar_unfiltered ('\n');
2913         } /* Loadable sections */
2914     }
2915   if (hashmark)
2916     putchar_unfiltered ('\n');
2917
2918   /* Write a type 7 terminator record. no data for a type 7, and there
2919      is no data, so len is 0.  */
2920
2921   reclen = mips_make_srec (srec, '7', abfd->start_address, NULL, 0);
2922
2923   send_srec (srec, reclen, abfd->start_address);
2924
2925   SERIAL_FLUSH_INPUT (mips_desc);
2926 }
2927
2928 /*
2929  * mips_make_srec -- make an srecord. This writes each line, one at a
2930  *      time, each with it's own header and trailer line.
2931  *      An srecord looks like this:
2932  *
2933  * byte count-+     address
2934  * start ---+ |        |       data        +- checksum
2935  *          | |        |                   |
2936  *        S01000006F6B692D746573742E73726563E4
2937  *        S315000448600000000000000000FC00005900000000E9
2938  *        S31A0004000023C1400037DE00F023604000377B009020825000348D
2939  *        S30B0004485A0000000000004E
2940  *        S70500040000F6
2941  *
2942  *      S<type><length><address><data><checksum>
2943  *
2944  *      Where
2945  *      - length
2946  *        is the number of bytes following upto the checksum. Note that
2947  *        this is not the number of chars following, since it takes two
2948  *        chars to represent a byte.
2949  *      - type
2950  *        is one of:
2951  *        0) header record
2952  *        1) two byte address data record
2953  *        2) three byte address data record
2954  *        3) four byte address data record
2955  *        7) four byte address termination record
2956  *        8) three byte address termination record
2957  *        9) two byte address termination record
2958  *
2959  *      - address
2960  *        is the start address of the data following, or in the case of
2961  *        a termination record, the start address of the image
2962  *      - data
2963  *        is the data.
2964  *      - checksum
2965  *        is the sum of all the raw byte data in the record, from the length
2966  *        upwards, modulo 256 and subtracted from 255.
2967  *
2968  * This routine returns the length of the S-record.
2969  *
2970  */
2971
2972 static int
2973 mips_make_srec (buf, type, memaddr, myaddr, len)
2974      char *buf;
2975      int type;
2976      CORE_ADDR memaddr;
2977      unsigned char *myaddr;
2978      int len;
2979 {
2980   unsigned char checksum;
2981   int i;
2982
2983   /* Create the header for the srec. addr_size is the number of bytes in the address,
2984      and 1 is the number of bytes in the count.  */
2985
2986   /* FIXME!! bigger buf required for 64-bit! */
2987   buf[0] = 'S';
2988   buf[1] = type;
2989   buf[2] = len + 4 + 1;         /* len + 4 byte address + 1 byte checksum */
2990   /* This assumes S3 style downloads (4byte addresses). There should
2991      probably be a check, or the code changed to make it more
2992      explicit. */
2993   buf[3] = memaddr >> 24;
2994   buf[4] = memaddr >> 16;
2995   buf[5] = memaddr >> 8;
2996   buf[6] = memaddr;
2997   memcpy (&buf[7], myaddr, len);
2998
2999   /* Note that the checksum is calculated on the raw data, not the
3000      hexified data.  It includes the length, address and the data
3001      portions of the packet.  */
3002   checksum = 0;
3003   buf += 2;                     /* Point at length byte */
3004   for (i = 0; i < len + 4 + 1; i++)
3005     checksum += *buf++;
3006
3007   *buf = ~checksum;
3008
3009   return len + 8;
3010 }
3011
3012 /* The following manifest controls whether we enable the simple flow
3013    control support provided by the monitor. If enabled the code will
3014    wait for an affirmative ACK between transmitting packets. */
3015 #define DOETXACK (1)
3016
3017 /* The PMON fast-download uses an encoded packet format constructed of
3018    3byte data packets (encoded as 4 printable ASCII characters), and
3019    escape sequences (preceded by a '/'):
3020
3021         'K'     clear checksum
3022         'C'     compare checksum (12bit value, not included in checksum calculation)
3023         'S'     define symbol name (for addr) terminated with "," and padded to 4char boundary
3024         'Z'     zero fill multiple of 3bytes
3025         'B'     byte (12bit encoded value, of 8bit data)
3026         'A'     address (36bit encoded value)
3027         'E'     define entry as original address, and exit load
3028
3029    The packets are processed in 4 character chunks, so the escape
3030    sequences that do not have any data (or variable length data)
3031    should be padded to a 4 character boundary.  The decoder will give
3032    an error if the complete message block size is not a multiple of
3033    4bytes (size of record).
3034
3035    The encoding of numbers is done in 6bit fields.  The 6bit value is
3036    used to index into this string to get the specific character
3037    encoding for the value: */
3038 static char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,.";
3039
3040 /* Convert the number of bits required into an encoded number, 6bits
3041    at a time (range 0..63).  Keep a checksum if required (passed
3042    pointer non-NULL). The function returns the number of encoded
3043    characters written into the buffer. */
3044 static int
3045 pmon_makeb64 (v, p, n, chksum)
3046      unsigned long v;
3047      char *p;
3048      int n;
3049      int *chksum;
3050 {
3051   int count = (n / 6);
3052
3053   if ((n % 12) != 0) {
3054     fprintf_unfiltered(stderr,"Fast encoding bitcount must be a multiple of 12bits: %dbit%s\n",n,(n == 1)?"":"s");
3055     return(0);
3056   }
3057   if (n > 36) {
3058     fprintf_unfiltered(stderr,"Fast encoding cannot process more than 36bits at the moment: %dbits\n",n);
3059     return(0);
3060   }
3061
3062   /* Deal with the checksum: */
3063   if (chksum != NULL) {
3064     switch (n) {
3065      case 36: *chksum += ((v >> 24) & 0xFFF);
3066      case 24: *chksum += ((v >> 12) & 0xFFF);
3067      case 12: *chksum += ((v >>  0) & 0xFFF);
3068     }
3069   }
3070
3071   do {
3072     n -= 6;
3073     *p++ = encoding[(v >> n) & 0x3F];
3074   } while (n > 0);
3075
3076   return(count);
3077 }
3078
3079 /* Shorthand function (that could be in-lined) to output the zero-fill
3080    escape sequence into the data stream. */
3081 static int
3082 pmon_zeroset (recsize, buff, amount, chksum)
3083      int recsize;
3084      char **buff;
3085      int *amount;
3086      unsigned int *chksum;
3087 {
3088   int count;
3089
3090   sprintf(*buff,"/Z");
3091   count = pmon_makeb64 (*amount, (*buff + 2), 12, chksum);
3092   *buff += (count + 2);
3093   *amount = 0;
3094   return(recsize + count + 2);
3095 }
3096
3097 static int
3098 pmon_checkset (recsize, buff, value)
3099      int recsize;
3100      char **buff;
3101      int *value;
3102 {
3103   int count;
3104
3105   /* Add the checksum (without updating the value): */
3106   sprintf (*buff, "/C");
3107   count = pmon_makeb64 (*value, (*buff + 2), 12, NULL);
3108   *buff += (count + 2);
3109   sprintf (*buff, "\n");
3110   *buff += 2; /* include zero terminator */
3111   /* Forcing a checksum validation clears the sum: */
3112   *value = 0;
3113   return(recsize + count + 3);
3114 }
3115
3116 /* Amount of padding we leave after at the end of the output buffer,
3117    for the checksum and line termination characters: */
3118 #define CHECKSIZE (4 + 4 + 4 + 2)
3119 /* zero-fill, checksum, transfer end and line termination space. */
3120
3121 /* The amount of binary data loaded from the object file in a single
3122    operation: */
3123 #define BINCHUNK (1024)
3124
3125 /* Maximum line of data accepted by the monitor: */
3126 #define MAXRECSIZE (550)
3127 /* NOTE: This constant depends on the monitor being used. This value
3128    is for PMON 5.x on the Cogent Vr4300 board. */
3129
3130 static void
3131 pmon_make_fastrec (outbuf, inbuf, inptr, inamount, recsize, csum, zerofill)
3132      char **outbuf;
3133      unsigned char *inbuf;
3134      int *inptr;
3135      int inamount;
3136      int *recsize;
3137      unsigned int *csum;
3138      unsigned int *zerofill;
3139 {
3140   int count = 0;
3141   char *p = *outbuf;
3142
3143   /* This is a simple check to ensure that our data will fit within
3144      the maximum allowable record size. Each record output is 4bytes
3145      in length. We must allow space for a pending zero fill command,
3146      the record, and a checksum record. */
3147   while ((*recsize < (MAXRECSIZE - CHECKSIZE)) && ((inamount - *inptr) > 0)) {
3148     /* Process the binary data: */
3149     if ((inamount - *inptr) < 3) {
3150       if (*zerofill != 0)
3151        *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
3152       sprintf (p, "/B");
3153       count = pmon_makeb64 (inbuf[*inptr], &p[2], 12, csum);
3154       p += (2 + count);
3155       *recsize += (2 + count);
3156       (*inptr)++;
3157     } else {
3158       unsigned int value = ((inbuf[*inptr + 0] << 16) | (inbuf[*inptr + 1] << 8) | inbuf[*inptr + 2]);
3159       /* Simple check for zero data. TODO: A better check would be
3160          to check the last, and then the middle byte for being zero
3161          (if the first byte is not). We could then check for
3162          following runs of zeros, and if above a certain size it is
3163          worth the 4 or 8 character hit of the byte insertions used
3164          to pad to the start of the zeroes. NOTE: This also depends
3165          on the alignment at the end of the zero run. */
3166       if (value == 0x00000000) {
3167         (*zerofill)++;
3168         if (*zerofill == 0xFFF) /* 12bit counter */
3169          *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
3170       }else {
3171         if (*zerofill != 0)
3172          *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
3173         count = pmon_makeb64 (value, p, 24, csum);
3174         p += count;
3175         *recsize += count;
3176       }
3177       *inptr += 3;
3178     }
3179   }
3180
3181   *outbuf = p;
3182   return;
3183 }
3184
3185 static int
3186 pmon_check_ack(mesg)
3187      char *mesg;
3188 {
3189 #if defined(DOETXACK)
3190   int c;
3191
3192   if (!tftp_in_use)
3193     {
3194       c = SERIAL_READCHAR (udp_in_use ? udp_desc : mips_desc, 2);
3195       if ((c == SERIAL_TIMEOUT) || (c != 0x06))
3196         {
3197           fprintf_unfiltered (gdb_stderr,
3198                               "Failed to receive valid ACK for %s\n", mesg);
3199           return(-1); /* terminate the download */
3200         }
3201     }
3202 #endif /* DOETXACK */
3203   return(0);
3204 }
3205
3206 /* pmon_download - Send a sequence of characters to the PMON download port,
3207    which is either a serial port or a UDP socket.  */
3208
3209 static void
3210 pmon_start_download ()
3211 {
3212   if (tftp_in_use)
3213     {
3214       /* Create the temporary download file.  */
3215       if ((tftp_file = fopen (tftp_localname, "w")) == NULL)
3216         perror_with_name (tftp_localname);
3217     }
3218   else
3219     {
3220       mips_send_command (udp_in_use ? LOAD_CMD_UDP : LOAD_CMD, 0);
3221       mips_expect ("Downloading from ");
3222       mips_expect (udp_in_use ? "udp" : "tty0");
3223       mips_expect (", ^C to abort\r\n");
3224     }
3225 }
3226
3227 static int
3228 mips_expect_download (char *string)
3229 {
3230   if (!mips_expect (string))
3231     {
3232       fprintf_unfiltered (gdb_stderr, "Load did not complete successfully.\n");
3233       if (tftp_in_use)
3234         remove (tftp_localname);        /* Remove temporary file */
3235       return 0;
3236     }
3237   else
3238     return 1;
3239 }
3240
3241 static void
3242 pmon_end_download (final, bintotal)
3243      int final;
3244      int bintotal;
3245 {
3246   char hexnumber[9]; /* includes '\0' space */
3247
3248   if (tftp_in_use)
3249     {
3250       static char *load_cmd_prefix = "load -b -s ";
3251       char *cmd;
3252       struct stat stbuf;
3253
3254       /* Close off the temporary file containing the load data.  */
3255       fclose (tftp_file);
3256       tftp_file = NULL;
3257
3258       /* Make the temporary file readable by the world.  */
3259       if (stat (tftp_localname, &stbuf) == 0)
3260         chmod (tftp_localname, stbuf.st_mode | S_IROTH);
3261
3262       /* Must reinitialize the board to prevent PMON from crashing.  */
3263       mips_send_command ("initEther\r", -1);
3264
3265       /* Send the load command.  */
3266       cmd = xmalloc (strlen (load_cmd_prefix) + strlen (tftp_name) + 2);
3267       strcpy (cmd, load_cmd_prefix);
3268       strcat (cmd, tftp_name);
3269       strcat (cmd, "\r");
3270       mips_send_command (cmd, 0);
3271       free (cmd);
3272       if (!mips_expect_download ("Downloading from "))
3273         return;
3274       if (!mips_expect_download (tftp_name))
3275         return;
3276       if (!mips_expect_download (", ^C to abort\r\n"))
3277         return;
3278     }
3279
3280   /* Wait for the stuff that PMON prints after the load has completed.
3281      The timeout value for use in the tftp case (15 seconds) was picked
3282      arbitrarily but might be too small for really large downloads. FIXME. */
3283   if (mips_monitor == MON_LSI)
3284     {
3285       pmon_check_ack ("termination");
3286       mips_expect_timeout ("Entry address is ", tftp_in_use ? 15 : 2);
3287     }
3288   else
3289     mips_expect_timeout ("Entry Address  = ", tftp_in_use ? 15 : 2);
3290
3291   sprintf (hexnumber,"%x",final);
3292   mips_expect (hexnumber);
3293   mips_expect ("\r\n");
3294   if (mips_monitor != MON_LSI)
3295     pmon_check_ack ("termination");
3296   mips_expect ("\r\ntotal = 0x");
3297   sprintf (hexnumber,"%x",bintotal);
3298   mips_expect (hexnumber);
3299   if (!mips_expect_download (" bytes\r\n"))
3300     return;
3301
3302   if (tftp_in_use)
3303     remove (tftp_localname);    /* Remove temporary file */
3304 }
3305
3306 static void
3307 pmon_download (buffer, length)
3308      char *buffer;
3309      int length;
3310 {
3311   if (tftp_in_use)
3312     fwrite (buffer, 1, length, tftp_file);
3313   else
3314     SERIAL_WRITE (udp_in_use ? udp_desc : mips_desc, buffer, length);
3315 }
3316
3317 static void
3318 pmon_load_fast (file)
3319      char *file;
3320 {
3321   bfd *abfd;
3322   asection *s;
3323   unsigned char *binbuf;
3324   char *buffer;
3325   int reclen;
3326   unsigned int csum = 0;
3327   int hashmark = !tftp_in_use;
3328   int bintotal = 0;
3329   int final = 0;
3330   int finished = 0;
3331
3332   buffer = (char *)xmalloc(MAXRECSIZE + 1);
3333   binbuf = (unsigned char *)xmalloc(BINCHUNK);
3334
3335   abfd = bfd_openr(file,0);
3336   if (!abfd)
3337    {
3338      printf_filtered ("Unable to open file %s\n",file);
3339      return;
3340    }
3341
3342   if (bfd_check_format(abfd,bfd_object) == 0)
3343    {
3344      printf_filtered("File is not an object file\n");
3345      return;
3346    }
3347
3348   /* Setup the required download state: */
3349   mips_send_command ("set dlproto etxack\r", -1);
3350   mips_send_command ("set dlecho off\r", -1);
3351   /* NOTE: We get a "cannot set variable" message if the variable is
3352      already defined to have the argument we give. The code doesn't
3353      care, since it just scans to the next prompt anyway. */
3354   /* Start the download: */
3355   pmon_start_download();
3356
3357   /* Zero the checksum */
3358   sprintf(buffer,"/Kxx\n");
3359   reclen = strlen(buffer);
3360   pmon_download (buffer, reclen);
3361   finished = pmon_check_ack("/Kxx");
3362
3363   for (s = abfd->sections; s && !finished; s = s->next)
3364    if (s->flags & SEC_LOAD) /* only deal with loadable sections */
3365     {
3366       bintotal += s->_raw_size;
3367       final = (s->vma + s->_raw_size);
3368
3369       printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, (unsigned int)s->vma,
3370                        (unsigned int)(s->vma + s->_raw_size));
3371       gdb_flush (gdb_stdout);
3372
3373       /* Output the starting address */
3374       sprintf(buffer,"/A");
3375       reclen = pmon_makeb64(s->vma,&buffer[2],36,&csum);
3376       buffer[2 + reclen] = '\n';
3377       buffer[3 + reclen] = '\0';
3378       reclen += 3; /* for the initial escape code and carriage return */
3379       pmon_download (buffer, reclen);
3380       finished = pmon_check_ack("/A");
3381
3382       if (!finished)
3383        {
3384          unsigned int binamount;
3385          unsigned int zerofill = 0;
3386          char *bp = buffer;
3387          unsigned int i;
3388
3389          reclen = 0;
3390
3391          for (i = 0; ((i < s->_raw_size) && !finished); i += binamount) {
3392            int binptr = 0;
3393
3394            binamount = min (BINCHUNK, s->_raw_size - i);
3395
3396            bfd_get_section_contents (abfd, s, binbuf, i, binamount);
3397
3398            /* This keeps a rolling checksum, until we decide to output
3399               the line: */
3400            for (; ((binamount - binptr) > 0);) {
3401              pmon_make_fastrec (&bp, binbuf, &binptr, binamount, &reclen, &csum, &zerofill);
3402              if (reclen >= (MAXRECSIZE - CHECKSIZE)) {
3403                reclen = pmon_checkset (reclen, &bp, &csum);
3404                pmon_download (buffer, reclen);
3405                finished = pmon_check_ack("data record");
3406                if (finished) {
3407                  zerofill = 0; /* do not transmit pending zerofills */
3408                  break;
3409                }
3410
3411                if (hashmark) {
3412                  putchar_unfiltered ('#');
3413                  gdb_flush (gdb_stdout);
3414                }
3415
3416                bp = buffer;
3417                reclen = 0; /* buffer processed */
3418              }
3419            }
3420          }
3421
3422          /* Ensure no out-standing zerofill requests: */
3423          if (zerofill != 0)
3424           reclen = pmon_zeroset (reclen, &bp, &zerofill, &csum);
3425
3426          /* and then flush the line: */
3427          if (reclen > 0) {
3428            reclen = pmon_checkset (reclen, &bp, &csum);
3429            /* Currently pmon_checkset outputs the line terminator by
3430               default, so we write out the buffer so far: */
3431            pmon_download (buffer, reclen);
3432            finished = pmon_check_ack("record remnant");
3433          }
3434        }
3435
3436       putchar_unfiltered ('\n');
3437     }
3438
3439   /* Terminate the transfer. We know that we have an empty output
3440      buffer at this point. */
3441   sprintf (buffer, "/E/E\n"); /* include dummy padding characters */
3442   reclen = strlen (buffer);
3443   pmon_download (buffer, reclen);
3444
3445   if (finished) { /* Ignore the termination message: */
3446     SERIAL_FLUSH_INPUT (udp_in_use ? udp_desc : mips_desc);
3447   } else { /* Deal with termination message: */
3448     pmon_end_download (final, bintotal);
3449   }
3450
3451   return;
3452 }
3453
3454 /* mips_load -- download a file. */
3455
3456 static void
3457 mips_load (file, from_tty)
3458     char *file;
3459     int  from_tty;
3460 {
3461   /* Get the board out of remote debugging mode.  */
3462   if (mips_exit_debug ())
3463     error ("mips_load:  Couldn't get into monitor mode.");
3464
3465   if (mips_monitor != MON_IDT)
3466    pmon_load_fast (file);
3467   else
3468    mips_load_srec (file);
3469
3470   mips_initialize ();
3471
3472   /* Finally, make the PC point at the start address */
3473   if (mips_monitor != MON_IDT)
3474     {
3475       /* Work around problem where PMON monitor updates the PC after a load
3476          to a different value than GDB thinks it has. The following ensures
3477          that the write_pc() WILL update the PC value: */
3478       register_valid[PC_REGNUM] = 0;
3479     }
3480   if (exec_bfd)
3481     write_pc (bfd_get_start_address (exec_bfd));
3482
3483   inferior_pid = 0;             /* No process now */
3484
3485 /* This is necessary because many things were based on the PC at the time that
3486    we attached to the monitor, which is no longer valid now that we have loaded
3487    new code (and just changed the PC).  Another way to do this might be to call
3488    normal_stop, except that the stack may not be valid, and things would get
3489    horribly confused... */
3490
3491   clear_symtab_users ();
3492 }
3493
3494
3495 /* Pass the command argument as a packet to PMON verbatim.  */
3496
3497 static void
3498 pmon_command (args, from_tty)
3499      char *args;
3500      int from_tty;
3501 {
3502   char buf[DATA_MAXLEN + 1];
3503   int rlen;
3504
3505   sprintf (buf, "0x0 %s", args);
3506   mips_send_packet (buf, 1);
3507   printf_filtered ("Send packet: %s\n", buf);
3508
3509   rlen = mips_receive_packet (buf, 1, mips_receive_wait);
3510   buf[rlen] = '\0';
3511   printf_filtered ("Received packet: %s\n", buf);
3512 }
3513 \f
3514 void
3515 _initialize_remote_mips ()
3516 {
3517   /* Initialize the fields in mips_ops that are common to all four targets.  */
3518   mips_ops.to_longname = "Remote MIPS debugging over serial line";
3519   mips_ops.to_close = mips_close;
3520   mips_ops.to_detach = mips_detach;
3521   mips_ops.to_resume = mips_resume;
3522   mips_ops.to_fetch_registers = mips_fetch_registers;
3523   mips_ops.to_store_registers = mips_store_registers;
3524   mips_ops.to_prepare_to_store = mips_prepare_to_store;
3525   mips_ops.to_xfer_memory = mips_xfer_memory;
3526   mips_ops.to_files_info = mips_files_info;
3527   mips_ops.to_insert_breakpoint = mips_insert_breakpoint;
3528   mips_ops.to_remove_breakpoint = mips_remove_breakpoint;
3529   mips_ops.to_kill = mips_kill;
3530   mips_ops.to_load = mips_load;
3531   mips_ops.to_create_inferior = mips_create_inferior;
3532   mips_ops.to_mourn_inferior = mips_mourn_inferior;
3533   mips_ops.to_stratum = process_stratum;
3534   mips_ops.to_has_all_memory = 1;
3535   mips_ops.to_has_memory = 1;
3536   mips_ops.to_has_stack = 1;
3537   mips_ops.to_has_registers = 1;
3538   mips_ops.to_has_execution = 1;
3539   mips_ops.to_magic = OPS_MAGIC;
3540
3541   /* Copy the common fields to all four target vectors.  */
3542   pmon_ops = ddb_ops = lsi_ops = mips_ops;
3543
3544   /* Initialize target-specific fields in the target vectors.  */
3545   mips_ops.to_shortname = "mips";
3546   mips_ops.to_doc = "\
3547 Debug a board using the MIPS remote debugging protocol over a serial line.\n\
3548 The argument is the device it is connected to or, if it contains a colon,\n\
3549 HOST:PORT to access a board over a network";
3550   mips_ops.to_open = mips_open;
3551   mips_ops.to_wait = mips_wait;
3552
3553   pmon_ops.to_shortname = "pmon";
3554   pmon_ops.to_doc =   "\
3555 Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
3556 line. The argument is the device it is connected to or, if it contains a\n\
3557 colon, HOST:PORT to access a board over a network";
3558   pmon_ops.to_open = pmon_open;
3559   pmon_ops.to_wait = mips_wait;
3560
3561   ddb_ops.to_shortname = "ddb";
3562   ddb_ops.to_doc = "\
3563 Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
3564 line. The first argument is the device it is connected to or, if it contains\n\
3565 a colon, HOST:PORT to access a board over a network.  The optional second\n\
3566 parameter is the temporary file in the form HOST:FILENAME to be used for\n\
3567 TFTP downloads to the board.  The optional third parameter is the local name\n\
3568 of the TFTP temporary file, if it differs from the filename seen by the board.";
3569   ddb_ops.to_open = ddb_open;
3570   ddb_ops.to_wait = mips_wait;
3571
3572   lsi_ops.to_shortname = "lsi";
3573   lsi_ops.to_doc = pmon_ops.to_doc;
3574   lsi_ops.to_open = lsi_open;
3575   lsi_ops.to_wait = mips_wait;
3576
3577   /* Add the targets.  */
3578   add_target (&mips_ops);
3579   add_target (&pmon_ops);
3580   add_target (&ddb_ops);
3581   add_target (&lsi_ops);
3582
3583   add_show_from_set (
3584     add_set_cmd ("timeout", no_class, var_zinteger,
3585                  (char *) &mips_receive_wait,
3586                  "Set timeout in seconds for remote MIPS serial I/O.",
3587                  &setlist),
3588         &showlist);
3589
3590   add_show_from_set (
3591     add_set_cmd ("retransmit-timeout", no_class, var_zinteger,
3592                  (char *) &mips_retransmit_wait,
3593          "Set retransmit timeout in seconds for remote MIPS serial I/O.\n\
3594 This is the number of seconds to wait for an acknowledgement to a packet\n\
3595 before resending the packet.", &setlist),
3596         &showlist);
3597
3598   add_show_from_set (
3599     add_set_cmd ("syn-garbage-limit", no_class, var_zinteger,
3600                  (char *) &mips_syn_garbage,
3601 "Set the maximum number of characters to ignore when scanning for a SYN.\n\
3602 This is the maximum number of characters GDB will ignore when trying to\n\
3603 synchronize with the remote system.  A value of -1 means that there is no limit\n\
3604 (Note that these characters are printed out even though they are ignored.)",
3605                  &setlist),
3606                      &showlist);
3607
3608   add_show_from_set
3609     (add_set_cmd ("monitor-prompt", class_obscure, var_string,
3610                   (char *) &mips_monitor_prompt,
3611                   "Set the prompt that GDB expects from the monitor.",
3612                   &setlist),
3613      &showlist);
3614
3615   add_show_from_set (
3616     add_set_cmd ("monitor-warnings", class_obscure, var_zinteger,
3617                  (char *)&monitor_warnings,
3618                  "Set printing of monitor warnings.\n"
3619                  "When enabled, monitor warnings about hardware breakpoints "
3620                  "will be displayed.",
3621                  &setlist),
3622                      &showlist);
3623
3624   add_com ("pmon <command>", class_obscure, pmon_command,
3625            "Send a packet to PMON (must be in debug mode).");
3626 }