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