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