1/* Remote debugging interface for Renesas E7000 ICE, for GDB 2 3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 4 2002, 2003 Free Software Foundation, Inc. 5 6 Contributed by Cygnus Support. 7 8 Written by Steve Chamberlain for Cygnus Support. 9 10 This file is part of GDB. 11 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; either version 2 of the License, or 15 (at your option) any later version. 16 17 This program is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program; if not, write to the Free Software 24 Foundation, Inc., 59 Temple Place - Suite 330, 25 Boston, MA 02111-1307, USA. */ 26 27/* The E7000 is an in-circuit emulator for the Renesas H8/300-H and 28 Renesas-SH processor. It has serial port and a lan port. 29 30 The monitor command set makes it difficult to load large ammounts of 31 data over the lan without using ftp - so try not to issue load 32 commands when communicating over ethernet; use the ftpload command. 33 34 The monitor pauses for a second when dumping srecords to the serial 35 line too, so we use a slower per byte mechanism but without the 36 startup overhead. Even so, it's pretty slow... */ 37 38#include "defs.h" 39#include "gdbcore.h" 40#include "gdbarch.h" 41#include "inferior.h" 42#include "target.h" 43#include "value.h" 44#include "command.h" 45#include "gdb_string.h" 46#include "gdbcmd.h" 47#include <sys/types.h> 48#include "serial.h" 49#include "remote-utils.h" 50#include "symfile.h" 51#include "regcache.h" 52#include <time.h> 53#include <ctype.h> 54 55 56#if 1 57#define HARD_BREAKPOINTS /* Now handled by set option. */ 58#define BC_BREAKPOINTS use_hard_breakpoints 59#endif 60 61#define CTRLC 0x03 62#define ENQ 0x05 63#define ACK 0x06 64#define CTRLZ 0x1a 65 66/* This file is used by 2 different targets, sh-elf and h8300. The 67 h8300 is not multiarched and doesn't use the registers defined in 68 tm-sh.h. To avoid using a macro GDB_TARGET_IS_SH, we do runtime check 69 of the target, which requires that these namse below are always 70 defined also in the h8300 case. */ 71 72#if !defined (PR_REGNUM) 73#define PR_REGNUM -1 74#endif 75#if !defined (GBR_REGNUM) 76#define GBR_REGNUM -1 77#endif 78#if !defined (VBR_REGNUM) 79#define VBR_REGNUM -1 80#endif 81#if !defined (MACH_REGNUM) 82#define MACH_REGNUM -1 83#endif 84#if !defined (MACL_REGNUM) 85#define MACL_REGNUM -1 86#endif 87#if !defined (SR_REGNUM) 88#define SR_REGNUM -1 89#endif 90 91extern void report_transfer_performance (unsigned long, time_t, time_t); 92 93extern char *sh_processor_type; 94 95/* Local function declarations. */ 96 97static void e7000_close (int); 98 99static void e7000_fetch_register (int); 100 101static void e7000_store_register (int); 102 103static void e7000_command (char *, int); 104 105static void e7000_login_command (char *, int); 106 107static void e7000_ftp_command (char *, int); 108 109static void e7000_drain_command (char *, int); 110 111static void expect (char *); 112 113static void expect_full_prompt (void); 114 115static void expect_prompt (void); 116 117static int e7000_parse_device (char *args, char *dev_name, int baudrate); 118/* Variables. */ 119 120static struct serial *e7000_desc; 121 122/* Allow user to chose between using hardware breakpoints or memory. */ 123static int use_hard_breakpoints = 0; /* use sw breakpoints by default */ 124 125/* Nonzero if using the tcp serial driver. */ 126 127static int using_tcp; /* direct tcp connection to target */ 128static int using_tcp_remote; /* indirect connection to target 129 via tcp to controller */ 130 131/* Nonzero if using the pc isa card. */ 132 133static int using_pc; 134 135extern struct target_ops e7000_ops; /* Forward declaration */ 136 137char *ENQSTRING = "\005"; 138 139/* Nonzero if some routine (as opposed to the user) wants echoing. 140 FIXME: Do this reentrantly with an extra parameter. */ 141 142static int echo; 143 144static int ctrl_c; 145 146static int timeout = 20; 147 148/* Send data to e7000debug. */ 149 150static void 151puts_e7000debug (char *buf) 152{ 153 if (!e7000_desc) 154 error ("Use \"target e7000 ...\" first."); 155 156 if (remote_debug) 157 printf_unfiltered ("Sending %s\n", buf); 158 159 if (serial_write (e7000_desc, buf, strlen (buf))) 160 fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n", safe_strerror (errno)); 161 162 /* And expect to see it echoed, unless using the pc interface */ 163#if 0 164 if (!using_pc) 165#endif 166 expect (buf); 167} 168 169static void 170putchar_e7000 (int x) 171{ 172 char b[1]; 173 174 b[0] = x; 175 serial_write (e7000_desc, b, 1); 176} 177 178static void 179write_e7000 (char *s) 180{ 181 serial_write (e7000_desc, s, strlen (s)); 182} 183 184static int 185normal (int x) 186{ 187 if (x == '\n') 188 return '\r'; 189 return x; 190} 191 192/* Read a character from the remote system, doing all the fancy timeout 193 stuff. Handles serial errors and EOF. If TIMEOUT == 0, and no chars, 194 returns -1, else returns next char. Discards chars > 127. */ 195 196static int 197readchar (int timeout) 198{ 199 int c; 200 201 do 202 { 203 c = serial_readchar (e7000_desc, timeout); 204 } 205 while (c > 127); 206 207 if (c == SERIAL_TIMEOUT) 208 { 209 if (timeout == 0) 210 return -1; 211 echo = 0; 212 error ("Timeout reading from remote system."); 213 } 214 else if (c < 0) 215 error ("Serial communication error"); 216 217 if (remote_debug) 218 { 219 putchar_unfiltered (c); 220 gdb_flush (gdb_stdout); 221 } 222 223 return normal (c); 224} 225 226#if 0 227char * 228tl (int x) 229{ 230 static char b[8][10]; 231 static int p; 232 233 p++; 234 p &= 7; 235 if (x >= ' ') 236 { 237 b[p][0] = x; 238 b[p][1] = 0; 239 } 240 else 241 { 242 sprintf (b[p], "<%d>", x); 243 } 244 245 return b[p]; 246} 247#endif 248 249/* Scan input from the remote system, until STRING is found. If 250 DISCARD is non-zero, then discard non-matching input, else print it 251 out. Let the user break out immediately. */ 252 253static void 254expect (char *string) 255{ 256 char *p = string; 257 int c; 258 int nl = 0; 259 260 while (1) 261 { 262 c = readchar (timeout); 263 264 if (echo) 265 { 266 if (c == '\r' || c == '\n') 267 { 268 if (!nl) 269 putchar_unfiltered ('\n'); 270 nl = 1; 271 } 272 else 273 { 274 nl = 0; 275 putchar_unfiltered (c); 276 } 277 gdb_flush (gdb_stdout); 278 } 279 if (normal (c) == normal (*p++)) 280 { 281 if (*p == '\0') 282 return; 283 } 284 else 285 { 286 p = string; 287 288 if (normal (c) == normal (string[0])) 289 p++; 290 } 291 } 292} 293 294/* Keep discarding input until we see the e7000 prompt. 295 296 The convention for dealing with the prompt is that you 297 o give your command 298 o *then* wait for the prompt. 299 300 Thus the last thing that a procedure does with the serial line will 301 be an expect_prompt(). Exception: e7000_resume does not wait for 302 the prompt, because the terminal is being handed over to the 303 inferior. However, the next thing which happens after that is a 304 e7000_wait which does wait for the prompt. Note that this includes 305 abnormal exit, e.g. error(). This is necessary to prevent getting 306 into states from which we can't recover. */ 307 308static void 309expect_prompt (void) 310{ 311 expect (":"); 312} 313 314static void 315expect_full_prompt (void) 316{ 317 expect ("\r:"); 318} 319 320static int 321convert_hex_digit (int ch) 322{ 323 if (ch >= '0' && ch <= '9') 324 return ch - '0'; 325 else if (ch >= 'A' && ch <= 'F') 326 return ch - 'A' + 10; 327 else if (ch >= 'a' && ch <= 'f') 328 return ch - 'a' + 10; 329 return -1; 330} 331 332static int 333get_hex (int *start) 334{ 335 int value = convert_hex_digit (*start); 336 int try; 337 338 *start = readchar (timeout); 339 while ((try = convert_hex_digit (*start)) >= 0) 340 { 341 value <<= 4; 342 value += try; 343 *start = readchar (timeout); 344 } 345 return value; 346} 347 348#if 0 349/* Get N 32-bit words from remote, each preceded by a space, and put 350 them in registers starting at REGNO. */ 351 352static void 353get_hex_regs (int n, int regno) 354{ 355 long val; 356 int i; 357 358 for (i = 0; i < n; i++) 359 { 360 int j; 361 362 val = 0; 363 for (j = 0; j < 8; j++) 364 val = (val << 4) + get_hex_digit (j == 0); 365 supply_register (regno++, (char *) &val); 366 } 367} 368#endif 369 370/* This is called not only when we first attach, but also when the 371 user types "run" after having attached. */ 372 373static void 374e7000_create_inferior (char *execfile, char *args, char **env) 375{ 376 int entry_pt; 377 378 if (args && *args) 379 error ("Can't pass arguments to remote E7000DEBUG process"); 380 381 if (execfile == 0 || exec_bfd == 0) 382 error ("No executable file specified"); 383 384 entry_pt = (int) bfd_get_start_address (exec_bfd); 385 386#ifdef CREATE_INFERIOR_HOOK 387 CREATE_INFERIOR_HOOK (0); /* No process-ID */ 388#endif 389 390 /* The "process" (board) is already stopped awaiting our commands, and 391 the program is already downloaded. We just set its PC and go. */ 392 393 clear_proceed_status (); 394 395 /* Tell wait_for_inferior that we've started a new process. */ 396 init_wait_for_inferior (); 397 398 /* Set up the "saved terminal modes" of the inferior 399 based on what modes we are starting it with. */ 400 target_terminal_init (); 401 402 /* Install inferior's terminal modes. */ 403 target_terminal_inferior (); 404 405 /* insert_step_breakpoint (); FIXME, do we need this? */ 406 proceed ((CORE_ADDR) entry_pt, -1, 0); /* Let 'er rip... */ 407} 408 409/* Open a connection to a remote debugger. NAME is the filename used 410 for communication. */ 411 412static int baudrate = 9600; 413static char dev_name[100]; 414 415static char *machine = ""; 416static char *user = ""; 417static char *passwd = ""; 418static char *dir = ""; 419 420/* Grab the next token and buy some space for it */ 421 422static char * 423next (char **ptr) 424{ 425 char *p = *ptr; 426 char *s; 427 char *r; 428 int l = 0; 429 430 while (*p && *p == ' ') 431 p++; 432 s = p; 433 while (*p && (*p != ' ' && *p != '\t')) 434 { 435 l++; 436 p++; 437 } 438 r = xmalloc (l + 1); 439 memcpy (r, s, l); 440 r[l] = 0; 441 *ptr = p; 442 return r; 443} 444 445static void 446e7000_login_command (char *args, int from_tty) 447{ 448 if (args) 449 { 450 machine = next (&args); 451 user = next (&args); 452 passwd = next (&args); 453 dir = next (&args); 454 if (from_tty) 455 { 456 printf_unfiltered ("Set info to %s %s %s %s\n", machine, user, passwd, dir); 457 } 458 } 459 else 460 { 461 error ("Syntax is ftplogin <machine> <user> <passwd> <directory>"); 462 } 463} 464 465/* Start an ftp transfer from the E7000 to a host */ 466 467static void 468e7000_ftp_command (char *args, int from_tty) 469{ 470 /* FIXME: arbitrary limit on machine names and such. */ 471 char buf[200]; 472 473 int oldtimeout = timeout; 474 timeout = remote_timeout; 475 476 sprintf (buf, "ftp %s\r", machine); 477 puts_e7000debug (buf); 478 expect (" Username : "); 479 sprintf (buf, "%s\r", user); 480 puts_e7000debug (buf); 481 expect (" Password : "); 482 write_e7000 (passwd); 483 write_e7000 ("\r"); 484 expect ("success\r"); 485 expect ("FTP>"); 486 sprintf (buf, "cd %s\r", dir); 487 puts_e7000debug (buf); 488 expect ("FTP>"); 489 sprintf (buf, "ll 0;s:%s\r", args); 490 puts_e7000debug (buf); 491 expect ("FTP>"); 492 puts_e7000debug ("bye\r"); 493 expect (":"); 494 timeout = oldtimeout; 495} 496 497static int 498e7000_parse_device (char *args, char *dev_name, int baudrate) 499{ 500 char junk[128]; 501 int n = 0; 502 if (args && strcasecmp (args, "pc") == 0) 503 { 504 strcpy (dev_name, args); 505 using_pc = 1; 506 } 507 else 508 { 509 /* FIXME! temp hack to allow use with port master - 510 target tcp_remote <device> */ 511 if (args && strncmp (args, "tcp", 10) == 0) 512 { 513 char com_type[128]; 514 n = sscanf (args, " %s %s %d %s", com_type, dev_name, &baudrate, junk); 515 using_tcp_remote = 1; 516 n--; 517 } 518 else if (args) 519 { 520 n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk); 521 } 522 523 if (n != 1 && n != 2) 524 { 525 error ("Bad arguments. Usage:\ttarget e7000 <device> <speed>\n\ 526or \t\ttarget e7000 <host>[:<port>]\n\ 527or \t\ttarget e7000 tcp_remote <host>[:<port>]\n\ 528or \t\ttarget e7000 pc\n"); 529 } 530 531#if !defined(__GO32__) && !defined(_WIN32) && !defined(__CYGWIN__) 532 /* FIXME! test for ':' is ambiguous */ 533 if (n == 1 && strchr (dev_name, ':') == 0) 534 { 535 /* Default to normal telnet port */ 536 /* serial_open will use this to determine tcp communication */ 537 strcat (dev_name, ":23"); 538 } 539#endif 540 if (!using_tcp_remote && strchr (dev_name, ':')) 541 using_tcp = 1; 542 } 543 544 return n; 545} 546 547/* Stub for catch_errors. */ 548 549static int 550e7000_start_remote (void *dummy) 551{ 552 int loop; 553 int sync; 554 int try; 555 int quit_trying; 556 557 immediate_quit++; /* Allow user to interrupt it */ 558 559 /* Hello? Are you there? */ 560 sync = 0; 561 loop = 0; 562 try = 0; 563 quit_trying = 20; 564 putchar_e7000 (CTRLC); 565 while (!sync && ++try <= quit_trying) 566 { 567 int c; 568 569 printf_unfiltered ("[waiting for e7000...]\n"); 570 571 write_e7000 ("\r"); 572 c = readchar (1); 573 574 /* FIXME! this didn't seem right-> while (c != SERIAL_TIMEOUT) 575 * we get stuck in this loop ... 576 * We may never timeout, and never sync up :-( 577 */ 578 while (!sync && c != -1) 579 { 580 /* Dont echo cr's */ 581 if (c != '\r') 582 { 583 putchar_unfiltered (c); 584 gdb_flush (gdb_stdout); 585 } 586 /* Shouldn't we either break here, or check for sync in inner loop? */ 587 if (c == ':') 588 sync = 1; 589 590 if (loop++ == 20) 591 { 592 putchar_e7000 (CTRLC); 593 loop = 0; 594 } 595 596 QUIT; 597 598 if (quit_flag) 599 { 600 putchar_e7000 (CTRLC); 601 /* Was-> quit_flag = 0; */ 602 c = -1; 603 quit_trying = try + 1; /* we don't want to try anymore */ 604 } 605 else 606 { 607 c = readchar (1); 608 } 609 } 610 } 611 612 if (!sync) 613 { 614 fprintf_unfiltered (gdb_stderr, "Giving up after %d tries...\n", try); 615 error ("Unable to synchronize with target.\n"); 616 } 617 618 puts_e7000debug ("\r"); 619 expect_prompt (); 620 puts_e7000debug ("b -\r"); /* Clear breakpoints */ 621 expect_prompt (); 622 623 immediate_quit--; 624 625/* This is really the job of start_remote however, that makes an assumption 626 that the target is about to print out a status message of some sort. That 627 doesn't happen here. */ 628 629 flush_cached_frames (); 630 registers_changed (); 631 stop_pc = read_pc (); 632 print_stack_frame (get_selected_frame (), -1, 1); 633 634 return 1; 635} 636 637static void 638e7000_open (char *args, int from_tty) 639{ 640 int n; 641 642 target_preopen (from_tty); 643 644 n = e7000_parse_device (args, dev_name, baudrate); 645 646 push_target (&e7000_ops); 647 648 e7000_desc = serial_open (dev_name); 649 650 if (!e7000_desc) 651 perror_with_name (dev_name); 652 653 if (serial_setbaudrate (e7000_desc, baudrate)) 654 { 655 serial_close (e7000_desc); 656 perror_with_name (dev_name); 657 } 658 serial_raw (e7000_desc); 659 660 /* Start the remote connection; if error (0), discard this target. 661 In particular, if the user quits, be sure to discard it 662 (we'd be in an inconsistent state otherwise). */ 663 if (!catch_errors (e7000_start_remote, (char *) 0, 664 "Couldn't establish connection to remote target\n", RETURN_MASK_ALL)) 665 if (from_tty) 666 printf_filtered ("Remote target %s connected to %s\n", target_shortname, 667 dev_name); 668} 669 670/* Close out all files and local state before this target loses control. */ 671 672static void 673e7000_close (int quitting) 674{ 675 if (e7000_desc) 676 { 677 serial_close (e7000_desc); 678 e7000_desc = 0; 679 } 680} 681 682/* Terminate the open connection to the remote debugger. Use this 683 when you want to detach and do something else with your gdb. */ 684 685static void 686e7000_detach (char *arg, int from_tty) 687{ 688 pop_target (); /* calls e7000_close to do the real work */ 689 if (from_tty) 690 printf_unfiltered ("Ending remote %s debugging\n", target_shortname); 691} 692 693/* Tell the remote machine to resume. */ 694 695static void 696e7000_resume (ptid_t ptid, int step, enum target_signal sigal) 697{ 698 if (step) 699 puts_e7000debug ("S\r"); 700 else 701 puts_e7000debug ("G\r"); 702} 703 704/* Read the remote registers into the block REGS. 705 706 For the H8/300 a register dump looks like: 707 708 PC=00021A CCR=80:I******* 709 ER0 - ER3 0000000A 0000002E 0000002E 00000000 710 ER4 - ER7 00000000 00000000 00000000 00FFEFF6 711 000218 MOV.B R1L,R2L 712 STEP NORMAL END or 713 BREAK POINT 714 */ 715 716char *want_h8300h = "PC=%p CCR=%c\n\ 717 ER0 - ER3 %0 %1 %2 %3\n\ 718 ER4 - ER7 %4 %5 %6 %7\n"; 719 720char *want_nopc_h8300h = "%p CCR=%c\n\ 721 ER0 - ER3 %0 %1 %2 %3\n\ 722 ER4 - ER7 %4 %5 %6 %7"; 723 724char *want_h8300s = "PC=%p CCR=%c\n\ 725 MACH=\n\ 726 ER0 - ER3 %0 %1 %2 %3\n\ 727 ER4 - ER7 %4 %5 %6 %7\n"; 728 729char *want_nopc_h8300s = "%p CCR=%c EXR=%9\n\ 730 ER0 - ER3 %0 %1 %2 %3\n\ 731 ER4 - ER7 %4 %5 %6 %7"; 732 733char *want_sh = "PC=%16 SR=%22\n\ 734PR=%17 GBR=%18 VBR=%19\n\ 735MACH=%20 MACL=%21\n\ 736R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\ 737R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n"; 738 739char *want_nopc_sh = "%16 SR=%22\n\ 740 PR=%17 GBR=%18 VBR=%19\n\ 741 MACH=%20 MACL=%21\n\ 742 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\ 743 R8-15 %8 %9 %10 %11 %12 %13 %14 %15"; 744 745char *want_sh3 = "PC=%16 SR=%22\n\ 746PR=%17 GBR=%18 VBR=%19\n\ 747MACH=%20 MACL=%21 SSR=%23 SPC=%24\n\ 748R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\ 749R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\ 750R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\ 751R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\ 752R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\ 753R4_BANK1-R7_BANK1 %37 %38 %39 %40"; 754 755char *want_nopc_sh3 = "%16 SR=%22\n\ 756 PR=%17 GBR=%18 VBR=%19\n\ 757 MACH=%20 MACL=%21 SSR=%22 SPC=%23\n\ 758 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\ 759 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\ 760 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\ 761 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\ 762 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\ 763 R4_BANK1-R7_BANK1 %37 %38 %39 %40"; 764 765static int 766gch (void) 767{ 768 return readchar (timeout); 769} 770 771static unsigned int 772gbyte (void) 773{ 774 int high = convert_hex_digit (gch ()); 775 int low = convert_hex_digit (gch ()); 776 777 return (high << 4) + low; 778} 779 780static void 781fetch_regs_from_dump (int (*nextchar) (), char *want) 782{ 783 int regno; 784 char buf[MAX_REGISTER_SIZE]; 785 786 int thischar = nextchar (); 787 788 if (want == NULL) 789 internal_error (__FILE__, __LINE__, "Register set not selected."); 790 791 while (*want) 792 { 793 switch (*want) 794 { 795 case '\n': 796 /* Skip to end of line and then eat all new line type stuff */ 797 while (thischar != '\n' && thischar != '\r') 798 thischar = nextchar (); 799 while (thischar == '\n' || thischar == '\r') 800 thischar = nextchar (); 801 want++; 802 break; 803 804 case ' ': 805 while (thischar == ' ' 806 || thischar == '\t' 807 || thischar == '\r' 808 || thischar == '\n') 809 thischar = nextchar (); 810 want++; 811 break; 812 813 default: 814 if (*want == thischar) 815 { 816 want++; 817 if (*want) 818 thischar = nextchar (); 819 820 } 821 else if (thischar == ' ' || thischar == '\n' || thischar == '\r') 822 { 823 thischar = nextchar (); 824 } 825 else 826 { 827 error ("out of sync in fetch registers wanted <%s>, got <%c 0x%x>", 828 want, thischar, thischar); 829 } 830 831 break; 832 case '%': 833 /* Got a register command */ 834 want++; 835 switch (*want) 836 { 837#ifdef PC_REGNUM 838 case 'p': 839 regno = PC_REGNUM; 840 want++; 841 break; 842#endif 843#ifdef CCR_REGNUM 844 case 'c': 845 regno = CCR_REGNUM; 846 want++; 847 break; 848#endif 849#ifdef SP_REGNUM 850 case 's': 851 regno = SP_REGNUM; 852 want++; 853 break; 854#endif 855#ifdef DEPRECATED_FP_REGNUM 856 case 'f': 857 regno = DEPRECATED_FP_REGNUM; 858 want++; 859 break; 860#endif 861 862 default: 863 if (isdigit (want[0])) 864 { 865 if (isdigit (want[1])) 866 { 867 regno = (want[0] - '0') * 10 + want[1] - '0'; 868 want += 2; 869 } 870 else 871 { 872 regno = want[0] - '0'; 873 want++; 874 } 875 } 876 877 else 878 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 879 } 880 store_signed_integer (buf, 881 DEPRECATED_REGISTER_RAW_SIZE (regno), 882 (LONGEST) get_hex (&thischar)); 883 supply_register (regno, buf); 884 break; 885 } 886 } 887} 888 889static void 890e7000_fetch_registers (void) 891{ 892 int regno; 893 char *wanted = NULL; 894 895 puts_e7000debug ("R\r"); 896 897 if (TARGET_ARCHITECTURE->arch == bfd_arch_sh) 898 { 899 wanted = want_sh; 900 switch (TARGET_ARCHITECTURE->mach) 901 { 902 case bfd_mach_sh3: 903 case bfd_mach_sh3e: 904 case bfd_mach_sh4: 905 wanted = want_sh3; 906 } 907 } 908 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300) 909 { 910 wanted = want_h8300h; 911 switch (TARGET_ARCHITECTURE->mach) 912 { 913 case bfd_mach_h8300s: 914 case bfd_mach_h8300sn: 915 case bfd_mach_h8300sx: 916 case bfd_mach_h8300sxn: 917 wanted = want_h8300s; 918 } 919 } 920 921 fetch_regs_from_dump (gch, wanted); 922 923 /* And supply the extra ones the simulator uses */ 924 for (regno = NUM_REALREGS; regno < NUM_REGS; regno++) 925 { 926 int buf = 0; 927 928 supply_register (regno, (char *) (&buf)); 929 } 930} 931 932/* Fetch register REGNO, or all registers if REGNO is -1. Returns 933 errno value. */ 934 935static void 936e7000_fetch_register (int regno) 937{ 938 e7000_fetch_registers (); 939} 940 941/* Store the remote registers from the contents of the block REGS. */ 942 943static void 944e7000_store_registers (void) 945{ 946 int regno; 947 948 for (regno = 0; regno < NUM_REALREGS; regno++) 949 e7000_store_register (regno); 950 951 registers_changed (); 952} 953 954/* Store register REGNO, or all if REGNO == 0. Return errno value. */ 955 956static void 957e7000_store_register (int regno) 958{ 959 char buf[200]; 960 961 if (regno == -1) 962 { 963 e7000_store_registers (); 964 return; 965 } 966 967 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300) 968 { 969 if (regno <= 7) 970 { 971 sprintf (buf, ".ER%d %s\r", regno, phex_nz (read_register (regno), 0)); 972 puts_e7000debug (buf); 973 } 974 else if (regno == PC_REGNUM) 975 { 976 sprintf (buf, ".PC %s\r", phex_nz (read_register (regno), 0)); 977 puts_e7000debug (buf); 978 } 979#ifdef CCR_REGNUM 980 else if (regno == CCR_REGNUM) 981 { 982 sprintf (buf, ".CCR %s\r", phex_nz (read_register (regno), 0)); 983 puts_e7000debug (buf); 984 } 985#endif 986 } 987 988 else if (TARGET_ARCHITECTURE->arch == bfd_arch_sh) 989 { 990 if (regno == PC_REGNUM) 991 { 992 sprintf (buf, ".PC %s\r", phex_nz (read_register (regno), 0)); 993 puts_e7000debug (buf); 994 } 995 996 else if (regno == SR_REGNUM) 997 { 998 sprintf (buf, ".SR %s\r", phex_nz (read_register (regno), 0)); 999 puts_e7000debug (buf); 1000 } 1001 1002 else if (regno == PR_REGNUM) 1003 { 1004 sprintf (buf, ".PR %s\r", phex_nz (read_register (regno), 0)); 1005 puts_e7000debug (buf); 1006 } 1007 1008 else if (regno == GBR_REGNUM) 1009 { 1010 sprintf (buf, ".GBR %s\r", phex_nz (read_register (regno), 0)); 1011 puts_e7000debug (buf); 1012 } 1013 1014 else if (regno == VBR_REGNUM) 1015 { 1016 sprintf (buf, ".VBR %s\r", phex_nz (read_register (regno), 0)); 1017 puts_e7000debug (buf); 1018 } 1019 1020 else if (regno == MACH_REGNUM) 1021 { 1022 sprintf (buf, ".MACH %s\r", phex_nz (read_register (regno), 0)); 1023 puts_e7000debug (buf); 1024 } 1025 1026 else if (regno == MACL_REGNUM) 1027 { 1028 sprintf (buf, ".MACL %s\r", phex_nz (read_register (regno), 0)); 1029 puts_e7000debug (buf); 1030 } 1031 else 1032 { 1033 sprintf (buf, ".R%d %s\r", regno, phex_nz (read_register (regno), 0)); 1034 puts_e7000debug (buf); 1035 } 1036 } 1037 1038 expect_prompt (); 1039} 1040 1041/* Get ready to modify the registers array. On machines which store 1042 individual registers, this doesn't need to do anything. On machines 1043 which store all the registers in one fell swoop, this makes sure 1044 that registers contains all the registers from the program being 1045 debugged. */ 1046 1047static void 1048e7000_prepare_to_store (void) 1049{ 1050 /* Do nothing, since we can store individual regs */ 1051} 1052 1053static void 1054e7000_files_info (struct target_ops *ops) 1055{ 1056 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baudrate); 1057} 1058 1059static int 1060stickbyte (char *where, unsigned int what) 1061{ 1062 static CONST char digs[] = "0123456789ABCDEF"; 1063 1064 where[0] = digs[(what >> 4) & 0xf]; 1065 where[1] = digs[(what & 0xf) & 0xf]; 1066 1067 return what; 1068} 1069 1070/* Write a small ammount of memory. */ 1071 1072static int 1073write_small (CORE_ADDR memaddr, unsigned char *myaddr, int len) 1074{ 1075 int i; 1076 char buf[200]; 1077 1078 for (i = 0; i < len; i++) 1079 { 1080 if (((memaddr + i) & 3) == 0 && (i + 3 < len)) 1081 { 1082 /* Can be done with a long word */ 1083 sprintf (buf, "m %s %x%02x%02x%02x;l\r", 1084 paddr_nz (memaddr + i), 1085 myaddr[i], myaddr[i + 1], myaddr[i + 2], myaddr[i + 3]); 1086 puts_e7000debug (buf); 1087 i += 3; 1088 } 1089 else 1090 { 1091 sprintf (buf, "m %s %x\r", paddr_nz (memaddr + i), myaddr[i]); 1092 puts_e7000debug (buf); 1093 } 1094 } 1095 1096 expect_prompt (); 1097 1098 return len; 1099} 1100 1101/* Write a large ammount of memory, this only works with the serial 1102 mode enabled. Command is sent as 1103 1104 il ;s:s\r -> 1105 <- il ;s:s\r 1106 <- ENQ 1107 ACK -> 1108 <- LO s\r 1109 Srecords... 1110 ^Z -> 1111 <- ENQ 1112 ACK -> 1113 <- : 1114 */ 1115 1116static int 1117write_large (CORE_ADDR memaddr, unsigned char *myaddr, int len) 1118{ 1119 int i; 1120#define maxstride 128 1121 int stride; 1122 1123 puts_e7000debug ("IL ;S:FK\r"); 1124 expect (ENQSTRING); 1125 putchar_e7000 (ACK); 1126 expect ("LO FK\r"); 1127 1128 for (i = 0; i < len; i += stride) 1129 { 1130 char compose[maxstride * 2 + 50]; 1131 int address = i + memaddr; 1132 int j; 1133 int check_sum; 1134 int where = 0; 1135 int alen; 1136 1137 stride = len - i; 1138 if (stride > maxstride) 1139 stride = maxstride; 1140 1141 compose[where++] = 'S'; 1142 check_sum = 0; 1143 if (address >= 0xffffff) 1144 alen = 4; 1145 else if (address >= 0xffff) 1146 alen = 3; 1147 else 1148 alen = 2; 1149 /* Insert type. */ 1150 compose[where++] = alen - 1 + '0'; 1151 /* Insert length. */ 1152 check_sum += stickbyte (compose + where, alen + stride + 1); 1153 where += 2; 1154 while (alen > 0) 1155 { 1156 alen--; 1157 check_sum += stickbyte (compose + where, address >> (8 * (alen))); 1158 where += 2; 1159 } 1160 1161 for (j = 0; j < stride; j++) 1162 { 1163 check_sum += stickbyte (compose + where, myaddr[i + j]); 1164 where += 2; 1165 } 1166 stickbyte (compose + where, ~check_sum); 1167 where += 2; 1168 compose[where++] = '\r'; 1169 compose[where++] = '\n'; 1170 compose[where++] = 0; 1171 1172 serial_write (e7000_desc, compose, where); 1173 j = readchar (0); 1174 if (j == -1) 1175 { 1176 /* This is ok - nothing there */ 1177 } 1178 else if (j == ENQ) 1179 { 1180 /* Hmm, it's trying to tell us something */ 1181 expect (":"); 1182 error ("Error writing memory"); 1183 } 1184 else 1185 { 1186 printf_unfiltered ("@%d}@", j); 1187 while ((j = readchar (0)) > 0) 1188 { 1189 printf_unfiltered ("@{%d}@", j); 1190 } 1191 } 1192 } 1193 1194 /* Send the trailer record */ 1195 write_e7000 ("S70500000000FA\r"); 1196 putchar_e7000 (CTRLZ); 1197 expect (ENQSTRING); 1198 putchar_e7000 (ACK); 1199 expect (":"); 1200 1201 return len; 1202} 1203 1204/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's 1205 memory at MEMADDR. Returns length moved. 1206 1207 Can't use the Srecord load over ethernet, so don't use fast method 1208 then. */ 1209 1210static int 1211e7000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) 1212{ 1213 if (len < 16 || using_tcp || using_pc) 1214 return write_small (memaddr, myaddr, len); 1215 else 1216 return write_large (memaddr, myaddr, len); 1217} 1218 1219/* Read LEN bytes from inferior memory at MEMADDR. Put the result 1220 at debugger address MYADDR. Returns length moved. 1221 1222 Small transactions we send 1223 m <addr>;l 1224 and receive 1225 00000000 12345678 ? 1226 */ 1227 1228static int 1229e7000_read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) 1230{ 1231 int count; 1232 int c; 1233 int i; 1234 char buf[200]; 1235 /* Starting address of this pass. */ 1236 1237/* printf("READ INF %x %x %d\n", memaddr, myaddr, len); */ 1238 if (((memaddr - 1) + len) < memaddr) 1239 { 1240 errno = EIO; 1241 return 0; 1242 } 1243 1244 sprintf (buf, "m %s;l\r", paddr_nz (memaddr)); 1245 puts_e7000debug (buf); 1246 1247 for (count = 0; count < len; count += 4) 1248 { 1249 /* Suck away the address */ 1250 c = gch (); 1251 while (c != ' ') 1252 c = gch (); 1253 c = gch (); 1254 if (c == '*') 1255 { /* Some kind of error */ 1256 puts_e7000debug (".\r"); /* Some errors leave us in memory input mode */ 1257 expect_full_prompt (); 1258 return -1; 1259 } 1260 while (c != ' ') 1261 c = gch (); 1262 1263 /* Now read in the data */ 1264 for (i = 0; i < 4; i++) 1265 { 1266 int b = gbyte (); 1267 if (count + i < len) 1268 { 1269 myaddr[count + i] = b; 1270 } 1271 } 1272 1273 /* Skip the trailing ? and send a . to end and a cr for more */ 1274 gch (); 1275 gch (); 1276 if (count + 4 >= len) 1277 puts_e7000debug (".\r"); 1278 else 1279 puts_e7000debug ("\r"); 1280 1281 } 1282 expect_prompt (); 1283 return len; 1284} 1285 1286 1287 1288/* 1289 For large transfers we used to send 1290 1291 1292 d <addr> <endaddr>\r 1293 1294 and receive 1295 <ADDRESS> < D A T A > < ASCII CODE > 1296 00000000 5F FD FD FF DF 7F DF FF 01 00 01 00 02 00 08 04 "_..............." 1297 00000010 FF D7 FF 7F D7 F1 7F FF 00 05 00 00 08 00 40 00 "..............@." 1298 00000020 7F FD FF F7 7F FF FF F7 00 00 00 00 00 00 00 00 "................" 1299 1300 A cost in chars for each transaction of 80 + 5*n-bytes. 1301 1302 Large transactions could be done with the srecord load code, but 1303 there is a pause for a second before dumping starts, which slows the 1304 average rate down! 1305 */ 1306 1307static int 1308e7000_read_inferior_memory_large (CORE_ADDR memaddr, unsigned char *myaddr, 1309 int len) 1310{ 1311 int count; 1312 int c; 1313 char buf[200]; 1314 1315 /* Starting address of this pass. */ 1316 1317 if (((memaddr - 1) + len) < memaddr) 1318 { 1319 errno = EIO; 1320 return 0; 1321 } 1322 1323 sprintf (buf, "d %s %s\r", paddr_nz (memaddr), paddr_nz (memaddr + len - 1)); 1324 puts_e7000debug (buf); 1325 1326 count = 0; 1327 c = gch (); 1328 1329 /* skip down to the first ">" */ 1330 while (c != '>') 1331 c = gch (); 1332 /* now skip to the end of that line */ 1333 while (c != '\r') 1334 c = gch (); 1335 c = gch (); 1336 1337 while (count < len) 1338 { 1339 /* get rid of any white space before the address */ 1340 while (c <= ' ') 1341 c = gch (); 1342 1343 /* Skip the address */ 1344 get_hex (&c); 1345 1346 /* read in the bytes on the line */ 1347 while (c != '"' && count < len) 1348 { 1349 if (c == ' ') 1350 c = gch (); 1351 else 1352 { 1353 myaddr[count++] = get_hex (&c); 1354 } 1355 } 1356 /* throw out the rest of the line */ 1357 while (c != '\r') 1358 c = gch (); 1359 } 1360 1361 /* wait for the ":" prompt */ 1362 while (c != ':') 1363 c = gch (); 1364 1365 return len; 1366} 1367 1368#if 0 1369 1370static int 1371fast_but_for_the_pause_e7000_read_inferior_memory (CORE_ADDR memaddr, 1372 char *myaddr, int len) 1373{ 1374 int loop; 1375 int c; 1376 char buf[200]; 1377 1378 if (((memaddr - 1) + len) < memaddr) 1379 { 1380 errno = EIO; 1381 return 0; 1382 } 1383 1384 sprintf (buf, "is %x@%x:s\r", memaddr, len); 1385 puts_e7000debug (buf); 1386 gch (); 1387 c = gch (); 1388 if (c != ENQ) 1389 { 1390 /* Got an error */ 1391 error ("Memory read error"); 1392 } 1393 putchar_e7000 (ACK); 1394 expect ("SV s"); 1395 loop = 1; 1396 while (loop) 1397 { 1398 int type; 1399 int length; 1400 int addr; 1401 int i; 1402 1403 c = gch (); 1404 switch (c) 1405 { 1406 case ENQ: /* ENQ, at the end */ 1407 loop = 0; 1408 break; 1409 case 'S': 1410 /* Start of an Srecord */ 1411 type = gch (); 1412 length = gbyte (); 1413 switch (type) 1414 { 1415 case '7': /* Termination record, ignore */ 1416 case '0': 1417 case '8': 1418 case '9': 1419 /* Header record - ignore it */ 1420 while (length--) 1421 { 1422 gbyte (); 1423 } 1424 break; 1425 case '1': 1426 case '2': 1427 case '3': 1428 { 1429 int alen; 1430 1431 alen = type - '0' + 1; 1432 addr = 0; 1433 while (alen--) 1434 { 1435 addr = (addr << 8) + gbyte (); 1436 length--; 1437 } 1438 1439 for (i = 0; i < length - 1; i++) 1440 myaddr[i + addr - memaddr] = gbyte (); 1441 1442 gbyte (); /* Ignore checksum */ 1443 } 1444 } 1445 } 1446 } 1447 1448 putchar_e7000 (ACK); 1449 expect ("TOP ADDRESS ="); 1450 expect ("END ADDRESS ="); 1451 expect (":"); 1452 1453 return len; 1454} 1455 1456#endif 1457 1458/* Transfer LEN bytes between GDB address MYADDR and target address 1459 MEMADDR. If WRITE is non-zero, transfer them to the target, 1460 otherwise transfer them from the target. TARGET is unused. 1461 1462 Returns the number of bytes transferred. */ 1463 1464static int 1465e7000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len, 1466 int write, struct mem_attrib *attrib, 1467 struct target_ops *target) 1468{ 1469 if (write) 1470 return e7000_write_inferior_memory (memaddr, myaddr, len); 1471 else if (len < 16) 1472 return e7000_read_inferior_memory (memaddr, myaddr, len); 1473 else 1474 return e7000_read_inferior_memory_large (memaddr, myaddr, len); 1475} 1476 1477static void 1478e7000_kill (void) 1479{ 1480} 1481 1482static void 1483e7000_load (char *args, int from_tty) 1484{ 1485 struct cleanup *old_chain; 1486 asection *section; 1487 bfd *pbfd; 1488 bfd_vma entry; 1489#define WRITESIZE 0x1000 1490 char buf[2 + 4 + 4 + WRITESIZE]; /* `DT' + <addr> + <len> + <data> */ 1491 char *filename; 1492 int quiet; 1493 int nostart; 1494 time_t start_time, end_time; /* Start and end times of download */ 1495 unsigned long data_count; /* Number of bytes transferred to memory */ 1496 int oldtimeout = timeout; 1497 1498 timeout = remote_timeout; 1499 1500 1501 /* FIXME! change test to test for type of download */ 1502 if (!using_tcp) 1503 { 1504 generic_load (args, from_tty); 1505 return; 1506 } 1507 1508 /* for direct tcp connections, we can do a fast binary download */ 1509 buf[0] = 'D'; 1510 buf[1] = 'T'; 1511 quiet = 0; 1512 nostart = 0; 1513 filename = NULL; 1514 1515 while (*args != '\000') 1516 { 1517 char *arg; 1518 1519 while (isspace (*args)) 1520 args++; 1521 1522 arg = args; 1523 1524 while ((*args != '\000') && !isspace (*args)) 1525 args++; 1526 1527 if (*args != '\000') 1528 *args++ = '\000'; 1529 1530 if (*arg != '-') 1531 filename = arg; 1532 else if (strncmp (arg, "-quiet", strlen (arg)) == 0) 1533 quiet = 1; 1534 else if (strncmp (arg, "-nostart", strlen (arg)) == 0) 1535 nostart = 1; 1536 else 1537 error ("unknown option `%s'", arg); 1538 } 1539 1540 if (!filename) 1541 filename = get_exec_file (1); 1542 1543 pbfd = bfd_openr (filename, gnutarget); 1544 if (pbfd == NULL) 1545 { 1546 perror_with_name (filename); 1547 return; 1548 } 1549 old_chain = make_cleanup_bfd_close (pbfd); 1550 1551 if (!bfd_check_format (pbfd, bfd_object)) 1552 error ("\"%s\" is not an object file: %s", filename, 1553 bfd_errmsg (bfd_get_error ())); 1554 1555 start_time = time (NULL); 1556 data_count = 0; 1557 1558 puts_e7000debug ("mw\r"); 1559 1560 expect ("\nOK"); 1561 1562 for (section = pbfd->sections; section; section = section->next) 1563 { 1564 if (bfd_get_section_flags (pbfd, section) & SEC_LOAD) 1565 { 1566 bfd_vma section_address; 1567 bfd_size_type section_size; 1568 file_ptr fptr; 1569 1570 section_address = bfd_get_section_vma (pbfd, section); 1571 section_size = bfd_get_section_size (section); 1572 1573 if (!quiet) 1574 printf_filtered ("[Loading section %s at 0x%s (%s bytes)]\n", 1575 bfd_get_section_name (pbfd, section), 1576 paddr_nz (section_address), 1577 paddr_u (section_size)); 1578 1579 fptr = 0; 1580 1581 data_count += section_size; 1582 1583 while (section_size > 0) 1584 { 1585 int count; 1586 static char inds[] = "|/-\\"; 1587 static int k = 0; 1588 1589 QUIT; 1590 1591 count = min (section_size, WRITESIZE); 1592 1593 buf[2] = section_address >> 24; 1594 buf[3] = section_address >> 16; 1595 buf[4] = section_address >> 8; 1596 buf[5] = section_address; 1597 1598 buf[6] = count >> 24; 1599 buf[7] = count >> 16; 1600 buf[8] = count >> 8; 1601 buf[9] = count; 1602 1603 bfd_get_section_contents (pbfd, section, buf + 10, fptr, count); 1604 1605 if (serial_write (e7000_desc, buf, count + 10)) 1606 fprintf_unfiltered (gdb_stderr, 1607 "e7000_load: serial_write failed: %s\n", 1608 safe_strerror (errno)); 1609 1610 expect ("OK"); 1611 1612 if (!quiet) 1613 { 1614 printf_unfiltered ("\r%c", inds[k++ % 4]); 1615 gdb_flush (gdb_stdout); 1616 } 1617 1618 section_address += count; 1619 fptr += count; 1620 section_size -= count; 1621 } 1622 } 1623 } 1624 1625 write_e7000 ("ED"); 1626 1627 expect_prompt (); 1628 1629 end_time = time (NULL); 1630 1631/* Finally, make the PC point at the start address */ 1632 1633 if (exec_bfd) 1634 write_pc (bfd_get_start_address (exec_bfd)); 1635 1636 inferior_ptid = null_ptid; /* No process now */ 1637 1638/* This is necessary because many things were based on the PC at the time that 1639 we attached to the monitor, which is no longer valid now that we have loaded 1640 new code (and just changed the PC). Another way to do this might be to call 1641 normal_stop, except that the stack may not be valid, and things would get 1642 horribly confused... */ 1643 1644 clear_symtab_users (); 1645 1646 if (!nostart) 1647 { 1648 entry = bfd_get_start_address (pbfd); 1649 1650 if (!quiet) 1651 printf_unfiltered ("[Starting %s at 0x%s]\n", filename, paddr_nz (entry)); 1652 1653/* start_routine (entry); */ 1654 } 1655 1656 report_transfer_performance (data_count, start_time, end_time); 1657 1658 do_cleanups (old_chain); 1659 timeout = oldtimeout; 1660} 1661 1662/* Clean up when a program exits. 1663 1664 The program actually lives on in the remote processor's RAM, and may be 1665 run again without a download. Don't leave it full of breakpoint 1666 instructions. */ 1667 1668static void 1669e7000_mourn_inferior (void) 1670{ 1671 remove_breakpoints (); 1672 unpush_target (&e7000_ops); 1673 generic_mourn_inferior (); /* Do all the proper things now */ 1674} 1675 1676#define MAX_BREAKPOINTS 200 1677#ifdef HARD_BREAKPOINTS 1678#define MAX_E7000DEBUG_BREAKPOINTS (BC_BREAKPOINTS ? 5 : MAX_BREAKPOINTS) 1679#else 1680#define MAX_E7000DEBUG_BREAKPOINTS MAX_BREAKPOINTS 1681#endif 1682 1683/* Since we can change to soft breakpoints dynamically, we must define 1684 more than enough. Was breakaddr[MAX_E7000DEBUG_BREAKPOINTS]. */ 1685static CORE_ADDR breakaddr[MAX_BREAKPOINTS] = 1686{0}; 1687 1688static int 1689e7000_insert_breakpoint (CORE_ADDR addr, char *shadow) 1690{ 1691 int i; 1692 char buf[200]; 1693#if 0 1694 static char nop[2] = NOP; 1695#endif 1696 1697 for (i = 0; i <= MAX_E7000DEBUG_BREAKPOINTS; i++) 1698 if (breakaddr[i] == 0) 1699 { 1700 breakaddr[i] = addr; 1701 /* Save old contents, and insert a nop in the space */ 1702#ifdef HARD_BREAKPOINTS 1703 if (BC_BREAKPOINTS) 1704 { 1705 sprintf (buf, "BC%d A=%s\r", i + 1, paddr_nz (addr)); 1706 puts_e7000debug (buf); 1707 } 1708 else 1709 { 1710 sprintf (buf, "B %s\r", paddr_nz (addr)); 1711 puts_e7000debug (buf); 1712 } 1713#else 1714#if 0 1715 e7000_read_inferior_memory (addr, shadow, 2); 1716 e7000_write_inferior_memory (addr, nop, 2); 1717#endif 1718 1719 sprintf (buf, "B %x\r", addr); 1720 puts_e7000debug (buf); 1721#endif 1722 expect_prompt (); 1723 return 0; 1724 } 1725 1726 error ("Too many breakpoints ( > %d) for the E7000\n", 1727 MAX_E7000DEBUG_BREAKPOINTS); 1728 return 1; 1729} 1730 1731static int 1732e7000_remove_breakpoint (CORE_ADDR addr, char *shadow) 1733{ 1734 int i; 1735 char buf[200]; 1736 1737 for (i = 0; i < MAX_E7000DEBUG_BREAKPOINTS; i++) 1738 if (breakaddr[i] == addr) 1739 { 1740 breakaddr[i] = 0; 1741#ifdef HARD_BREAKPOINTS 1742 if (BC_BREAKPOINTS) 1743 { 1744 sprintf (buf, "BC%d - \r", i + 1); 1745 puts_e7000debug (buf); 1746 } 1747 else 1748 { 1749 sprintf (buf, "B - %s\r", paddr_nz (addr)); 1750 puts_e7000debug (buf); 1751 } 1752 expect_prompt (); 1753#else 1754 sprintf (buf, "B - %s\r", paddr_nz (addr)); 1755 puts_e7000debug (buf); 1756 expect_prompt (); 1757 1758#if 0 1759 /* Replace the insn under the break */ 1760 e7000_write_inferior_memory (addr, shadow, 2); 1761#endif 1762#endif 1763 1764 return 0; 1765 } 1766 1767 warning ("Can't find breakpoint associated with 0x%s\n", paddr_nz (addr)); 1768 return 1; 1769} 1770 1771/* Put a command string, in args, out to STDBUG. Output from STDBUG 1772 is placed on the users terminal until the prompt is seen. */ 1773 1774static void 1775e7000_command (char *args, int fromtty) 1776{ 1777 /* FIXME: arbitrary limit on length of args. */ 1778 char buf[200]; 1779 1780 echo = 0; 1781 1782 if (!e7000_desc) 1783 error ("e7000 target not open."); 1784 if (!args) 1785 { 1786 puts_e7000debug ("\r"); 1787 } 1788 else 1789 { 1790 sprintf (buf, "%s\r", args); 1791 puts_e7000debug (buf); 1792 } 1793 1794 echo++; 1795 ctrl_c = 2; 1796 expect_full_prompt (); 1797 echo--; 1798 ctrl_c = 0; 1799 printf_unfiltered ("\n"); 1800 1801 /* Who knows what the command did... */ 1802 registers_changed (); 1803} 1804 1805 1806static void 1807e7000_drain_command (char *args, int fromtty) 1808{ 1809 int c; 1810 1811 puts_e7000debug ("end\r"); 1812 putchar_e7000 (CTRLC); 1813 1814 while ((c = readchar (1)) != -1) 1815 { 1816 if (quit_flag) 1817 { 1818 putchar_e7000 (CTRLC); 1819 quit_flag = 0; 1820 } 1821 if (c > ' ' && c < 127) 1822 printf_unfiltered ("%c", c & 0xff); 1823 else 1824 printf_unfiltered ("<%x>", c & 0xff); 1825 } 1826} 1827 1828#define NITEMS 7 1829 1830static int 1831why_stop (void) 1832{ 1833 static char *strings[NITEMS] = 1834 { 1835 "STEP NORMAL", 1836 "BREAK POINT", 1837 "BREAK KEY", 1838 "BREAK CONDI", 1839 "CYCLE ACCESS", 1840 "ILLEGAL INSTRUCTION", 1841 "WRITE PROTECT", 1842 }; 1843 char *p[NITEMS]; 1844 int c; 1845 int i; 1846 1847 for (i = 0; i < NITEMS; ++i) 1848 p[i] = strings[i]; 1849 1850 c = gch (); 1851 while (1) 1852 { 1853 for (i = 0; i < NITEMS; i++) 1854 { 1855 if (c == *(p[i])) 1856 { 1857 p[i]++; 1858 if (*(p[i]) == 0) 1859 { 1860 /* found one of the choices */ 1861 return i; 1862 } 1863 } 1864 else 1865 p[i] = strings[i]; 1866 } 1867 1868 c = gch (); 1869 } 1870} 1871 1872/* Suck characters, if a string match, then return the strings index 1873 otherwise echo them. */ 1874 1875static int 1876expect_n (char **strings) 1877{ 1878 char *(ptr[10]); 1879 int n; 1880 int c; 1881 char saveaway[100]; 1882 char *buffer = saveaway; 1883 /* Count number of expect strings */ 1884 1885 for (n = 0; strings[n]; n++) 1886 { 1887 ptr[n] = strings[n]; 1888 } 1889 1890 while (1) 1891 { 1892 int i; 1893 int gotone = 0; 1894 1895 c = readchar (1); 1896 if (c == -1) 1897 { 1898 printf_unfiltered ("[waiting for e7000...]\n"); 1899 } 1900#ifdef __GO32__ 1901 if (kbhit ()) 1902 { 1903 int k = getkey (); 1904 1905 if (k == 1) 1906 quit_flag = 1; 1907 } 1908#endif 1909 if (quit_flag) 1910 { 1911 putchar_e7000 (CTRLC); /* interrupt the running program */ 1912 quit_flag = 0; 1913 } 1914 1915 for (i = 0; i < n; i++) 1916 { 1917 if (c == ptr[i][0]) 1918 { 1919 ptr[i]++; 1920 if (ptr[i][0] == 0) 1921 { 1922 /* Gone all the way */ 1923 return i; 1924 } 1925 gotone = 1; 1926 } 1927 else 1928 { 1929 ptr[i] = strings[i]; 1930 } 1931 } 1932 1933 if (gotone) 1934 { 1935 /* Save it up incase we find that there was no match */ 1936 *buffer++ = c; 1937 } 1938 else 1939 { 1940 if (buffer != saveaway) 1941 { 1942 *buffer++ = 0; 1943 printf_unfiltered ("%s", buffer); 1944 buffer = saveaway; 1945 } 1946 if (c != -1) 1947 { 1948 putchar_unfiltered (c); 1949 gdb_flush (gdb_stdout); 1950 } 1951 } 1952 } 1953} 1954 1955/* We subtract two from the pc here rather than use 1956 DECR_PC_AFTER_BREAK since the e7000 doesn't always add two to the 1957 pc, and the simulators never do. */ 1958 1959static void 1960sub2_from_pc (void) 1961{ 1962 char buf[4]; 1963 char buf2[200]; 1964 1965 store_signed_integer (buf, 1966 DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), 1967 read_register (PC_REGNUM) - 2); 1968 supply_register (PC_REGNUM, buf); 1969 sprintf (buf2, ".PC %s\r", phex_nz (read_register (PC_REGNUM), 0)); 1970 puts_e7000debug (buf2); 1971} 1972 1973#define WAS_SLEEP 0 1974#define WAS_INT 1 1975#define WAS_RUNNING 2 1976#define WAS_OTHER 3 1977 1978static char *estrings[] = 1979{ 1980 "** SLEEP", 1981 "BREAK !", 1982 "** PC", 1983 "PC", 1984 NULL 1985}; 1986 1987/* Wait until the remote machine stops, then return, storing status in 1988 STATUS just as `wait' would. */ 1989 1990static ptid_t 1991e7000_wait (ptid_t ptid, struct target_waitstatus *status) 1992{ 1993 int stop_reason; 1994 int regno; 1995 int running_count = 0; 1996 int had_sleep = 0; 1997 int loop = 1; 1998 char *wanted_nopc = NULL; 1999 2000 /* Then echo chars until PC= string seen */ 2001 gch (); /* Drop cr */ 2002 gch (); /* and space */ 2003 2004 while (loop) 2005 { 2006 switch (expect_n (estrings)) 2007 { 2008 case WAS_OTHER: 2009 /* how did this happen ? */ 2010 loop = 0; 2011 break; 2012 case WAS_SLEEP: 2013 had_sleep = 1; 2014 putchar_e7000 (CTRLC); 2015 loop = 0; 2016 break; 2017 case WAS_INT: 2018 loop = 0; 2019 break; 2020 case WAS_RUNNING: 2021 running_count++; 2022 if (running_count == 20) 2023 { 2024 printf_unfiltered ("[running...]\n"); 2025 running_count = 0; 2026 } 2027 break; 2028 default: 2029 /* error? */ 2030 break; 2031 } 2032 } 2033 2034 /* Skip till the PC= */ 2035 expect ("="); 2036 2037 if (TARGET_ARCHITECTURE->arch == bfd_arch_sh) 2038 { 2039 wanted_nopc = want_nopc_sh; 2040 switch (TARGET_ARCHITECTURE->mach) 2041 { 2042 case bfd_mach_sh3: 2043 case bfd_mach_sh3e: 2044 case bfd_mach_sh4: 2045 wanted_nopc = want_nopc_sh3; 2046 } 2047 } 2048 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300) 2049 { 2050 wanted_nopc = want_nopc_h8300h; 2051 switch (TARGET_ARCHITECTURE->mach) 2052 { 2053 case bfd_mach_h8300s: 2054 case bfd_mach_h8300sn: 2055 case bfd_mach_h8300sx: 2056 case bfd_mach_h8300sxn: 2057 wanted_nopc = want_nopc_h8300s; 2058 } 2059 } 2060 fetch_regs_from_dump (gch, wanted_nopc); 2061 2062 /* And supply the extra ones the simulator uses */ 2063 for (regno = NUM_REALREGS; regno < NUM_REGS; regno++) 2064 { 2065 int buf = 0; 2066 supply_register (regno, (char *) &buf); 2067 } 2068 2069 stop_reason = why_stop (); 2070 expect_full_prompt (); 2071 2072 status->kind = TARGET_WAITKIND_STOPPED; 2073 status->value.sig = TARGET_SIGNAL_TRAP; 2074 2075 switch (stop_reason) 2076 { 2077 case 1: /* Breakpoint */ 2078 write_pc (read_pc ()); /* PC is always off by 2 for breakpoints */ 2079 status->value.sig = TARGET_SIGNAL_TRAP; 2080 break; 2081 case 0: /* Single step */ 2082 status->value.sig = TARGET_SIGNAL_TRAP; 2083 break; 2084 case 2: /* Interrupt */ 2085 if (had_sleep) 2086 { 2087 status->value.sig = TARGET_SIGNAL_TRAP; 2088 sub2_from_pc (); 2089 } 2090 else 2091 { 2092 status->value.sig = TARGET_SIGNAL_INT; 2093 } 2094 break; 2095 case 3: 2096 break; 2097 case 4: 2098 printf_unfiltered ("a cycle address error?\n"); 2099 status->value.sig = TARGET_SIGNAL_UNKNOWN; 2100 break; 2101 case 5: 2102 status->value.sig = TARGET_SIGNAL_ILL; 2103 break; 2104 case 6: 2105 status->value.sig = TARGET_SIGNAL_SEGV; 2106 break; 2107 case 7: /* Anything else (NITEMS + 1) */ 2108 printf_unfiltered ("a write protect error?\n"); 2109 status->value.sig = TARGET_SIGNAL_UNKNOWN; 2110 break; 2111 default: 2112 /* Get the user's attention - this should never happen. */ 2113 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 2114 } 2115 2116 return inferior_ptid; 2117} 2118 2119/* Stop the running program. */ 2120 2121static void 2122e7000_stop (void) 2123{ 2124 /* Sending a ^C is supposed to stop the running program. */ 2125 putchar_e7000 (CTRLC); 2126} 2127 2128/* Define the target subroutine names. */ 2129 2130struct target_ops e7000_ops; 2131 2132static void 2133init_e7000_ops (void) 2134{ 2135 e7000_ops.to_shortname = "e7000"; 2136 e7000_ops.to_longname = "Remote Renesas e7000 target"; 2137 e7000_ops.to_doc = "Use a remote Renesas e7000 ICE connected by a serial line;\n\ 2138or a network connection.\n\ 2139Arguments are the name of the device for the serial line,\n\ 2140the speed to connect at in bits per second.\n\ 2141eg\n\ 2142target e7000 /dev/ttya 9600\n\ 2143target e7000 foobar"; 2144 e7000_ops.to_open = e7000_open; 2145 e7000_ops.to_close = e7000_close; 2146 e7000_ops.to_detach = e7000_detach; 2147 e7000_ops.to_resume = e7000_resume; 2148 e7000_ops.to_wait = e7000_wait; 2149 e7000_ops.to_fetch_registers = e7000_fetch_register; 2150 e7000_ops.to_store_registers = e7000_store_register; 2151 e7000_ops.to_prepare_to_store = e7000_prepare_to_store; 2152 e7000_ops.to_xfer_memory = e7000_xfer_inferior_memory; 2153 e7000_ops.to_files_info = e7000_files_info; 2154 e7000_ops.to_insert_breakpoint = e7000_insert_breakpoint; 2155 e7000_ops.to_remove_breakpoint = e7000_remove_breakpoint; 2156 e7000_ops.to_kill = e7000_kill; 2157 e7000_ops.to_load = e7000_load; 2158 e7000_ops.to_create_inferior = e7000_create_inferior; 2159 e7000_ops.to_mourn_inferior = e7000_mourn_inferior; 2160 e7000_ops.to_stop = e7000_stop; 2161 e7000_ops.to_stratum = process_stratum; 2162 e7000_ops.to_has_all_memory = 1; 2163 e7000_ops.to_has_memory = 1; 2164 e7000_ops.to_has_stack = 1; 2165 e7000_ops.to_has_registers = 1; 2166 e7000_ops.to_has_execution = 1; 2167 e7000_ops.to_magic = OPS_MAGIC; 2168}; 2169 2170extern initialize_file_ftype _initialize_remote_e7000; /* -Wmissing-prototypes */ 2171 2172void 2173_initialize_remote_e7000 (void) 2174{ 2175 init_e7000_ops (); 2176 add_target (&e7000_ops); 2177 2178 add_com ("e7000", class_obscure, e7000_command, 2179 "Send a command to the e7000 monitor."); 2180 2181 add_com ("ftplogin", class_obscure, e7000_login_command, 2182 "Login to machine and change to directory."); 2183 2184 add_com ("ftpload", class_obscure, e7000_ftp_command, 2185 "Fetch and load a file from previously described place."); 2186 2187 add_com ("drain", class_obscure, e7000_drain_command, 2188 "Drain pending e7000 text buffers."); 2189 2190 add_show_from_set (add_set_cmd ("usehardbreakpoints", no_class, 2191 var_integer, (char *) &use_hard_breakpoints, 2192 "Set use of hardware breakpoints for all breakpoints.\n", &setlist), 2193 &showlist); 2194} 2195