gdb/remote-e7000.c

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