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