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