gdb/remote-e7000.c

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