gdb/remote-e7000.c

   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
  91 extern void report_transfer_performance (unsigned long, time_t, time_t);
  92
  93 extern char *sh_processor_type;
  94
  95 /* Local function declarations.  */
  96
  97 static void e7000_close (int);
  98
  99 static void e7000_fetch_register (int);
 100
 101 static void e7000_store_register (int);
 102
 103 static void e7000_command (char *, int);
 104
 105 static void e7000_login_command (char *, int);
 106
 107 static void e7000_ftp_command (char *, int);
 108
 109 static void e7000_drain_command (char *, int);
 110
 111 static void expect (char *);
 112
 113 static void expect_full_prompt (void);
 114
 115 static void expect_prompt (void);
 116
 117 static int e7000_parse_device (char *args, char *dev_name, int baudrate);
 118 /* Variables. */
 119
 120 static struct serial *e7000_desc;
 121
 122 /* Allow user to chose between using hardware breakpoints or memory. */
 123 static int use_hard_breakpoints = 0;    /* use sw breakpoints by default */
 124
 125 /* Nonzero if using the tcp serial driver.  */
 126
 127 static int using_tcp;           /* direct tcp connection to target */
 128 static int using_tcp_remote;    /* indirect connection to target
 129                                    via tcp to controller */
 130
 131 /* Nonzero if using the pc isa card.  */
 132
 133 static int using_pc;
 134
 135 extern struct target_ops e7000_ops;     /* Forward declaration */
 136
 137 char *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
 142 static int echo;
 143
 144 static int ctrl_c;
 145
 146 static int timeout = 20;
 147
 148 /* Send data to e7000debug.  */
 149
 150 static void
 151 puts_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
 169 static void
 170 putchar_e7000 (int x)
 171 {
 172   char b[1];
 173
 174   b[0] = x;
 175   serial_write (e7000_desc, b, 1);
 176 }
 177
 178 static void
 179 write_e7000 (char *s)
 180 {
 181   serial_write (e7000_desc, s, strlen (s));
 182 }
 183
 184 static int
 185 normal (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
 196 static int
 197 readchar (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
 227 char *
 228 tl (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
 253 static void
 254 expect (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
 308 static void
 309 expect_prompt (void)
 310 {
 311   expect (":");
 312 }
 313
 314 static void
 315 expect_full_prompt (void)
 316 {
 317   expect ("\r:");
 318 }
 319
 320 static int
 321 convert_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
 332 static int
 333 get_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
 352 static void
 353 get_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
 373 static void
 374 e7000_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
 412 static int baudrate = 9600;
 413 static char dev_name[100];
 414
 415 static char *machine = "";
 416 static char *user = "";
 417 static char *passwd = "";
 418 static char *dir = "";
 419
 420 /* Grab the next token and buy some space for it */
 421
 422 static char *
 423 next (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
 445 static void
 446 e7000_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
 467 static void
 468 e7000_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
 497 static int
 498 e7000_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\
 526 or \t\ttarget e7000 <host>[:<port>]\n\
 527 or \t\ttarget e7000 tcp_remote <host>[:<port>]\n\
 528 or \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
 549 static int
 550 e7000_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
 637 static void
 638 e7000_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
 672 static void
 673 e7000_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
 685 static void
 686 e7000_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
 695 static void
 696 e7000_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
 716 char *want_h8300h = "PC=%p CCR=%c\n\
 717  ER0 - ER3  %0 %1 %2 %3\n\
 718  ER4 - ER7  %4 %5 %6 %7\n";
 719
 720 char *want_nopc_h8300h = "%p CCR=%c\n\
 721  ER0 - ER3  %0 %1 %2 %3\n\
 722  ER4 - ER7  %4 %5 %6 %7";
 723
 724 char *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
 729 char *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
 733 char *want_sh = "PC=%16 SR=%22\n\
 734 PR=%17 GBR=%18 VBR=%19\n\
 735 MACH=%20 MACL=%21\n\
 736 R0-7  %0 %1 %2 %3 %4 %5 %6 %7\n\
 737 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n";
 738
 739 char *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
 745 char *want_sh3 = "PC=%16 SR=%22\n\
 746 PR=%17 GBR=%18 VBR=%19\n\
 747 MACH=%20 MACL=%21 SSR=%23 SPC=%24\n\
 748 R0-7  %0 %1 %2 %3 %4 %5 %6 %7\n\
 749 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
 750 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
 751 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
 752 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
 753 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
 754
 755 char *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
 765 static int
 766 gch (void)
 767 {
 768   return readchar (timeout);
 769 }
 770
 771 static unsigned int
 772 gbyte (void)
 773 {
 774   int high = convert_hex_digit (gch ());
 775   int low = convert_hex_digit (gch ());
 776
 777   return (high << 4) + low;
 778 }
 779
 780 static void
 781 fetch_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
 889 static void
 890 e7000_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
 935 static void
 936 e7000_fetch_register (int regno)
 937 {
 938   e7000_fetch_registers ();
 939 }
 940
 941 /* Store the remote registers from the contents of the block REGS.  */
 942
 943 static void
 944 e7000_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
 956 static void
 957 e7000_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
1047 static void
1048 e7000_prepare_to_store (void)
1049 {
1050   /* Do nothing, since we can store individual regs */
1051 }
1052
1053 static void
1054 e7000_files_info (struct target_ops *ops)
1055 {
1056   printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baudrate);
1057 }
1058
1059 static int
1060 stickbyte (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
1072 static int
1073 write_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
1116 static int
1117 write_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
1210 static int
1211 e7000_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
1228 static int
1229 e7000_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
1307 static int
1308 e7000_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
1370 static int
1371 fast_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
1464 static int
1465 e7000_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
1477 static void
1478 e7000_kill (void)
1479 {
1480 }
1481
1482 static void
1483 e7000_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_before_reloc (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
1668 static void
1669 e7000_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]. */
1685 static CORE_ADDR breakaddr[MAX_BREAKPOINTS] =
1686 {0};
1687
1688 static int
1689 e7000_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
1731 static int
1732 e7000_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
1774 static void
1775 e7000_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
1806 static void
1807 e7000_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
1830 static int
1831 why_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
1875 static int
1876 expect_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
1959 static void
1960 sub2_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
1978 static 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
1990 static ptid_t
1991 e7000_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
2121 static void
2122 e7000_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
2130 struct target_ops e7000_ops;
2131
2132 static void
2133 init_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\
2138 or a network connection.\n\
2139 Arguments are the name of the device for the serial line,\n\
2140 the speed to connect at in bits per second.\n\
2141 eg\n\
2142 target e7000 /dev/ttya 9600\n\
2143 target 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
2170 extern initialize_file_ftype _initialize_remote_e7000; /* -Wmissing-prototypes */
2171
2172 void
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 }