contrib/gdb/gdb/remote-e7000.c

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