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