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