gdb/remote-e7000.c

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