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