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