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