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