gdb/remote-e7000.c

   1 /* Remote debugging interface for Hitachi E7000 ICE, for GDB
   2    Copyright 1993, 1994 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 /* Clean up when a program exits.
1380
1381    The program actually lives on in the remote processor's RAM, and may be
1382    run again without a download.  Don't leave it full of breakpoint
1383    instructions.  */
1384
1385 static void
1386 e7000_mourn_inferior ()
1387 {
1388   remove_breakpoints ();
1389   unpush_target (&e7000_ops);
1390   generic_mourn_inferior ();    /* Do all the proper things now */
1391 }
1392
1393 #ifdef  HARD_BREAKPOINTS
1394 #define MAX_E7000DEBUG_BREAKPOINTS (BC_BREAKPOINTS ? 5 :  200)
1395 #else
1396 #define MAX_E7000DEBUG_BREAKPOINTS 200
1397 #endif
1398
1399 extern int memory_breakpoint_size;
1400
1401 static CORE_ADDR breakaddr[MAX_E7000DEBUG_BREAKPOINTS] = {0};
1402
1403 static int
1404 e7000_insert_breakpoint (addr, shadow)
1405      CORE_ADDR addr;
1406      unsigned char *shadow;
1407 {
1408   int i;
1409   char buf[200];
1410   static char nop[2] = NOP;
1411
1412   for (i = 0; i <= MAX_E7000DEBUG_BREAKPOINTS; i++)
1413     if (breakaddr[i] == 0)
1414       {
1415         breakaddr[i] = addr;
1416         /* Save old contents, and insert a nop in the space */
1417 #ifdef HARD_BREAKPOINTS
1418         if (BC_BREAKPOINTS)
1419           {
1420             sprintf (buf, "BC%d A=%x\r", i+1, addr);
1421             puts_e7000debug (buf);
1422           }
1423         else
1424           {
1425             sprintf (buf, "B %x\r", addr);
1426             puts_e7000debug (buf);
1427           }
1428 #else
1429 #if 0
1430         e7000_read_inferior_memory (addr, shadow, 2);
1431         e7000_write_inferior_memory (addr, nop, 2);
1432 #endif
1433
1434         sprintf (buf, "B %x\r", addr);
1435         puts_e7000debug (buf);
1436 #endif
1437         expect_prompt ();
1438         return 0;
1439       }
1440
1441   error ("Too many breakpoints ( > %d) for the E7000\n",
1442          MAX_E7000DEBUG_BREAKPOINTS);
1443   return 1;
1444 }
1445
1446 static int
1447 e7000_remove_breakpoint (addr, shadow)
1448      CORE_ADDR addr;
1449      unsigned char *shadow;
1450 {
1451   int i;
1452   char buf[200];
1453
1454   for (i = 0; i < MAX_E7000DEBUG_BREAKPOINTS; i++)
1455     if (breakaddr[i] == addr)
1456       {
1457         breakaddr[i] = 0;
1458 #ifdef HARD_BREAKPOINTS
1459         if (BC_BREAKPOINTS)
1460           {
1461             sprintf (buf, "BC%d - \r",  i+1);
1462             puts_e7000debug (buf);
1463           }
1464         else
1465           {
1466             sprintf (buf, "B - %x\r",  addr);
1467             puts_e7000debug (buf);
1468           }
1469         expect_prompt ();
1470 #else
1471         sprintf (buf, "B - %x\r", addr);
1472         puts_e7000debug (buf);
1473         expect_prompt ();
1474
1475 #if 0
1476         /* Replace the insn under the break */
1477         e7000_write_inferior_memory (addr, shadow, 2);
1478 #endif
1479 #endif
1480
1481         return 0;
1482       }
1483
1484   warning ("Can't find breakpoint associated with 0x%x\n", addr);
1485   return 1;
1486 }
1487
1488 /* Put a command string, in args, out to STDBUG.  Output from STDBUG
1489    is placed on the users terminal until the prompt is seen. */
1490
1491 static void
1492 e7000_command (args, fromtty)
1493      char *args;
1494      int fromtty;
1495 {
1496   /* FIXME: arbitrary limit on length of args.  */
1497   char buf[200];
1498
1499   echo = 0;
1500
1501   if (!e7000_desc)
1502     error ("e7000 target not open.");
1503   if (!args)
1504     {
1505       puts_e7000debug ("\r");
1506     }
1507   else
1508     {
1509       sprintf (buf, "%s\r", args);
1510       puts_e7000debug (buf);
1511     }
1512
1513   echo++;
1514   ctrl_c = 2;
1515   expect_full_prompt ();
1516   echo--;
1517   ctrl_c = 0;
1518   printf_unfiltered ("\n");
1519
1520   /* Who knows what the command did... */
1521   registers_changed ();
1522 }
1523
1524
1525 static void
1526 e7000_drain_command (args, fromtty)
1527      char *args;
1528      int fromtty;
1529
1530 {
1531   int c;
1532
1533   puts_e7000debug("end\r");
1534   putchar_e7000 (CTRLC);
1535
1536   while ((c = SERIAL_READCHAR (e7000_desc, 1) != SERIAL_TIMEOUT))
1537     {
1538       if (quit_flag)
1539         {
1540           putchar_e7000(CTRLC);
1541           quit_flag = 0;
1542         }
1543       if (c > ' ' && c < 127)
1544         printf ("%c", c & 0xff);
1545       else
1546         printf ("<%x>", c & 0xff);
1547     }
1548 }
1549
1550 #define NITEMS 7
1551
1552 static int
1553 why_stop ()
1554 {
1555   static  char *strings[NITEMS] = {
1556     "STEP NORMAL",
1557     "BREAK POINT",
1558     "BREAK KEY",
1559     "BREAK CONDI",
1560     "CYCLE ACCESS",
1561     "ILLEGAL INSTRUCTION",
1562     "WRITE PROTECT",
1563   };
1564   char *p[NITEMS];
1565   int c;
1566   int i;
1567
1568   for (i = 0; i < NITEMS; ++i)
1569     p[i] = strings[i];
1570
1571   c = gch ();
1572   while (1)
1573     {
1574       for (i = 0; i < NITEMS; i++)
1575         {
1576           if (c == *(p[i]))
1577             {
1578               p[i]++;
1579               if (*(p[i]) == 0)
1580                 {
1581                   /* found one of the choices */
1582                   return i;
1583                 }
1584             }
1585           else
1586             p[i] = strings[i];
1587         }
1588
1589       c = gch ();
1590     }
1591 }
1592
1593 /* Suck characters, if a string match, then return the strings index
1594    otherwise echo them.  */
1595
1596 int
1597 expect_n (strings)
1598 char **strings;
1599 {
1600   char *(ptr[10]);
1601   int n;
1602   int c;
1603   char saveaway[100];
1604   char *buffer = saveaway;
1605   /* Count number of expect strings  */
1606
1607   for (n = 0; strings[n]; n++)
1608     {
1609       ptr[n] = strings[n];
1610     }
1611
1612   while (1)
1613     {
1614       int i;
1615       int gotone = 0;
1616
1617       c = SERIAL_READCHAR (e7000_desc, 1);
1618       if (c == SERIAL_TIMEOUT)
1619         {
1620           printf_unfiltered ("[waiting for e7000...]\n");
1621         }
1622 #ifdef __GO32__
1623       if (kbhit ())
1624         {
1625           int k = getkey();
1626
1627           if (k == 1)
1628             quit_flag = 1;
1629         }
1630 #endif
1631       if (quit_flag)
1632         {
1633           putchar_e7000 (CTRLC);        /* interrupt the running program */
1634           quit_flag = 0;
1635         }
1636
1637       for (i = 0; i < n; i++)
1638         {
1639           if (c == ptr[i][0])
1640             {
1641               ptr[i]++;
1642               if (ptr[i][0] == 0)
1643                 {
1644                   /* Gone all the way */
1645                   return i;
1646                 }
1647               gotone = 1;
1648             }
1649           else
1650             {
1651               ptr[i] = strings[i];
1652             }
1653         }
1654
1655       if (gotone)
1656         {
1657           /* Save it up incase we find that there was no match */
1658           *buffer ++ = c;
1659         }
1660       else
1661         {
1662           if (buffer != saveaway)
1663             {
1664               *buffer++ = 0;
1665               printf ("%s", buffer);
1666               buffer = saveaway;
1667             }
1668           if (c != SERIAL_TIMEOUT)
1669             {
1670               putchar (c);
1671               fflush (stdout);
1672             }
1673         }
1674     }
1675 }
1676
1677 /* We subtract two from the pc here rather than use
1678    DECR_PC_AFTER_BREAK since the e7000 doesn't always add two to the
1679    pc, and the simulators never do. */
1680
1681 static void
1682 sub2_from_pc ()
1683 {
1684   char buf[4];
1685   char buf2[200];
1686
1687   store_signed_integer (buf,
1688                         REGISTER_RAW_SIZE(PC_REGNUM),
1689                         read_register (PC_REGNUM) -2);
1690   supply_register (PC_REGNUM, buf);
1691   sprintf (buf2, ".PC %x\r", read_register (PC_REGNUM));
1692   puts_e7000debug (buf2);
1693 }
1694
1695 #define WAS_SLEEP 0
1696 #define WAS_INT 1
1697 #define WAS_RUNNING 2
1698 #define WAS_OTHER 3
1699
1700 static char *estrings[] = {
1701   "** SLEEP",
1702   "BREAK !",
1703   "** PC",
1704   "PC",
1705   NULL
1706 };
1707
1708 /* Wait until the remote machine stops, then return, storing status in
1709    STATUS just as `wait' would.  */
1710
1711 static int
1712 e7000_wait (pid, status)
1713      int pid;
1714      struct target_waitstatus *status;
1715 {
1716   int stop_reason;
1717   int regno;
1718   int running_count = 0;
1719   int had_sleep = 0;
1720   int loop = 1;
1721
1722   /* Then echo chars until PC= string seen */
1723   gch ();                       /* Drop cr */
1724   gch ();                       /* and space */
1725
1726   while (loop)
1727     {
1728       switch (expect_n (estrings))
1729         {
1730         case WAS_OTHER:
1731           /* how did this happen ? */
1732           loop = 0;
1733           break;
1734         case WAS_SLEEP:
1735           had_sleep = 1;
1736           putchar_e7000 (CTRLC);
1737           loop = 0;
1738           break;
1739         case WAS_INT:
1740           loop = 0;
1741           break;
1742         case WAS_RUNNING:
1743           running_count++;
1744           if (running_count == 20)
1745             {
1746               printf_unfiltered ("[running...]\n");
1747               running_count = 0;
1748             }
1749           break;
1750         default:
1751           /* error? */
1752           break;
1753         }
1754     }
1755
1756   /* Skip till the PC= */
1757   expect ("=");
1758   fetch_regs_from_dump (gch, want_nopc);
1759
1760   /* And supply the extra ones the simulator uses */
1761   for (regno = NUM_REALREGS; regno < NUM_REGS; regno++)
1762     {
1763       int buf = 0;
1764       supply_register (regno, (char *) &buf);
1765     }
1766
1767   stop_reason = why_stop ();
1768   expect_full_prompt ();
1769
1770   status->kind = TARGET_WAITKIND_STOPPED;
1771   status->value.sig = TARGET_SIGNAL_TRAP;
1772
1773   switch (stop_reason)
1774     {
1775     case 1:                     /* Breakpoint */
1776       write_pc (read_pc () - 2); /* PC is always off by 2 for breakpoints */
1777       status->value.sig = TARGET_SIGNAL_TRAP;
1778       break;
1779     case 0:                     /* Single step */
1780       status->value.sig = TARGET_SIGNAL_TRAP;
1781       break;
1782     case 2:                     /* Interrupt */
1783       if (had_sleep)
1784         {
1785           status->value.sig = TARGET_SIGNAL_TRAP;
1786           sub2_from_pc ();
1787         }
1788       else
1789         {
1790           status->value.sig = TARGET_SIGNAL_INT;
1791         }
1792       break;
1793     case 3:
1794       break;
1795     case 4:
1796       printf_unfiltered ("a cycle address error?\n");
1797       status->value.sig = TARGET_SIGNAL_UNKNOWN;
1798       break;
1799     case 5:
1800       status->value.sig = TARGET_SIGNAL_ILL;
1801       break;
1802     case 6:
1803       status->value.sig = TARGET_SIGNAL_SEGV;
1804       break;
1805     case 7:                     /* Anything else (NITEMS + 1) */
1806       printf_unfiltered ("a write protect error?\n");
1807       status->value.sig = TARGET_SIGNAL_UNKNOWN;
1808       break;
1809     default:
1810       /* Get the user's attention - this should never happen. */
1811       abort ();
1812     }
1813
1814   return 0;
1815 }
1816
1817 /* Define the target subroutine names. */
1818
1819 struct target_ops e7000_ops =
1820 {
1821   "e7000",
1822   "Remote Hitachi e7000 target",
1823   "Use a remote Hitachi e7000 ICE connected by a serial line,\n\
1824 or a network connection.\n\
1825 Arguments are the name of the device for the serial line,\n\
1826 the speed to connect at in bits per second.\n\
1827 eg\n\
1828 target e7000 /dev/ttya 9600\n\
1829 target e7000 foobar",
1830   e7000_open,                   /* to_open */
1831   e7000_close,                  /* to_close */
1832   0,                            /* to_attach */
1833   e7000_detach,                 /* to_detach */
1834   e7000_resume,                 /* to_resume */
1835   e7000_wait,                   /* to_wait */
1836   e7000_fetch_register,         /* to_fetch_registers */
1837   e7000_store_register,         /* to_store_registers */
1838   e7000_prepare_to_store,       /* to_prepare_to_store */
1839   e7000_xfer_inferior_memory,   /* to_xfer_memory */
1840   e7000_files_info,             /* to_files_info */
1841   e7000_insert_breakpoint,      /* to_insert_breakpoint */
1842   e7000_remove_breakpoint,      /* to_remove_breakpoint */
1843   0,                            /* to_terminal_init */
1844   0,                            /* to_terminal_inferior */
1845   0,                            /* to_terminal_ours_for_output */
1846   0,                            /* to_terminal_ours */
1847   0,                            /* to_terminal_info */
1848   e7000_kill,                   /* to_kill */
1849   generic_load,                 /* to_load */
1850   0,                            /* to_lookup_symbol */
1851   e7000_create_inferior,        /* to_create_inferior */
1852   e7000_mourn_inferior,         /* to_mourn_inferior */
1853   0,                            /* to_can_run */
1854   0,                            /* to_notice_signals */
1855   0,                            /* to_thread_alive */
1856   0,                            /* to_stop */
1857   process_stratum,              /* to_stratum */
1858   0,                            /* next (unused) */
1859   1,                            /* to_has_all_memory */
1860   1,                            /* to_has_memory */
1861   1,                            /* to_has_stack */
1862   1,                            /* to_has_registers */
1863   1,                            /* to_has_execution */
1864   0,                            /* to_sections */
1865   0,                            /* to_sections_end */
1866   OPS_MAGIC,                    /* Always the last thing */
1867 };
1868
1869 void
1870 _initialize_remote_e7000 ()
1871 {
1872   add_target (&e7000_ops);
1873
1874   add_com ("e7000 <command>", class_obscure, e7000_command,
1875            "Send a command to the e7000 monitor.");
1876
1877   add_com ("ftplogin <machine> <name> <passwd> <dir>", class_obscure, e7000_login_command,
1878            "Login to machine and change to directory.");
1879
1880   add_com ("ftpload <file>", class_obscure, e7000_ftp_command,
1881            "Fetch and load a file from previously described place.");
1882
1883   add_com ("drain", class_obscure, e7000_drain_command,
1884            "Drain pending e7000 text buffers.");
1885 }