gdb/remote-es.c

   1 /* Memory-access and commands for remote es1800 processes, for GDB.
   2    Copyright (C) 1988, 1992 Free Software Foundation, Inc.
   3
   4    This file is added to GDB to make it possible to do debugging via an
   5    ES-1800 emulator. The code was originally written by Johan Holmberg
   6    TT/SJ Ericsson Telecom AB and later modified by Johan Henriksson
   7    TT/SJ. It was modified for gdb 4.0 by TX/DK Jan Nordenand by TX/DKG
   8    Harald Johansen.
   9
  10 This file is part of GDB.
  11
  12 GDB is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 1, or (at your option)
  15 any later version.
  16
  17 GDB is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with GDB; see the file COPYING.  If not, write to
  24 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  25
  26
  27 /* Emulator communication protocol.
  28    All values are encoded in ascii hex digits.
  29
  30         Request
  31 Command
  32 Reply
  33         read registers:
  34 DR<cr>
  35      - 0 -    - 1 -    - 2 -    - 3 -      - 4 -    - 5 -    -- 6 -   - 7 -
  36 D = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX   XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
  37 A = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX   XXXXXXXX XXXXXXXX XXXXXXXX
  38     PC = XXXXXX       SSP = XXXXXX    USP = XXXXXX     SR = XXXXXXXX
  39  >
  40 Each byte of register data is described by two hex digits.
  41
  42         write regs
  43 D0=XXXXXXXX<cr>
  44  >D1=XXXXXXXX<cr>
  45  >D2=XXXXXXXX<cr>
  46  >D3=XXXXXXXX<cr>
  47  >D4=XXXXXXXX<cr>
  48  >D5=XXXXXXXX<cr>
  49  >D6=XXXXXXXX<cr>
  50  >D7=XXXXXXXX<cr>
  51  >A0=XXXXXXXX<cr>
  52  >A1=XXXXXXXX<cr>
  53  >A2=XXXXXXXX<cr>
  54  >A3=XXXXXXXX<cr>
  55  >A4=XXXXXXXX<cr>
  56  >A5=XXXXXXXX<cr>
  57  >A6=XXXXXXXX<cr>
  58  >A7=XXXXXXXX<cr>
  59  >SR=XXXXXXXX<cr>
  60  >PC=XXXXXX<cr>
  61  >
  62 Each byte of register data is described by two hex digits.
  63
  64         read mem
  65 @.BAA..AA
  66 $FFFFFFXX
  67  >
  68 AA..AA is address, XXXXXXX is the contents
  69
  70         write mem
  71         @.BAA..AA=$XXXXXXXX
  72  >
  73 AA..AA is address, XXXXXXXX is data
  74
  75         cont
  76 PC=$AA..AA
  77  >RBK
  78 R>
  79 AA..AA is address to resume. If AA..AA is omitted, resume at same address.
  80
  81         step
  82 PC=$AA..AA
  83  >STP
  84 R>
  85 AA..AA is address to resume. If AA..AA is omitted, resume at same address.
  86
  87         kill req
  88 STP
  89  >
  90 */
  91
  92
  93 #include <stdio.h>
  94 #include <signal.h>
  95 #include <sys/ioctl.h>
  96 #include <sys/file.h>
  97 #include <errno.h>
  98 #include <ctype.h>
  99 #include <string.h>
 100 #include <setjmp.h>
 101 #include <fcntl.h>
 102 #include "defs.h"
 103 #include "frame.h"
 104 #include "inferior.h"
 105 #include "target.h"
 106 #include "wait.h"
 107 #include "terminal.h"
 108 #include "command.h"
 109 #include "remote-utils.h"
 110
 111 #ifdef USG
 112 #include <sys/types.h>
 113 #include <sgtty.h>
 114 #endif
 115
 116 #include <signal.h>
 117
 118 /* External variables referenced. */
 119
 120 extern bfd *exec_bfd;
 121
 122 /* Prototypes for local functions */
 123
 124 static void
 125 es1800_child_detach PARAMS ((char *, int));
 126
 127 static void
 128 es1800_child_open PARAMS ((char *, int));
 129
 130 static void
 131 es1800_transparent PARAMS ((char *, int));
 132
 133 static void
 134 es1800_create_inferior PARAMS ((char *, char *, char **));
 135
 136 static void
 137 es1800_load PARAMS ((char *, int));
 138
 139 static void
 140 es1800_kill PARAMS ((void));
 141
 142 static int
 143 verify_break PARAMS ((int));
 144
 145 static int
 146 es1800_remove_breakpoint PARAMS ((CORE_ADDR, char *));
 147
 148 static int
 149 es1800_insert_breakpoint PARAMS ((CORE_ADDR, char *));
 150
 151 static void
 152 es1800_files_info PARAMS ((struct target_ops *));
 153
 154 static int
 155 es1800_xfer_inferior_memory PARAMS ((CORE_ADDR, char *, int, int,
 156                                      struct target_ops *));
 157
 158 static void
 159 es1800_prepare_to_store PARAMS ((void));
 160
 161 static int
 162 es1800_wait PARAMS ((WAITTYPE *));
 163
 164 static void es1800_resume PARAMS ((int, int, enum target_signal));
 165
 166 static void
 167 es1800_detach PARAMS ((char *, int));
 168
 169 static void
 170 es1800_attach PARAMS ((char *, int));
 171
 172 static int
 173 damn_b PARAMS ((char *));
 174
 175 static void
 176 es1800_open PARAMS ((char *, int));
 177
 178 static void
 179 es1800_timer PARAMS ((void));
 180
 181 static void
 182 es1800_reset PARAMS ((char *));
 183
 184 static void
 185 es1800_request_quit PARAMS ((void));
 186
 187 static int
 188 readchar PARAMS ((void));
 189
 190 static void
 191 expect PARAMS ((char *, int));
 192
 193 static void
 194 expect_prompt PARAMS ((void));
 195
 196 static void
 197 download PARAMS ((FILE *, int, int));
 198
 199 #if 0
 200 static void
 201 bfd_copy PARAMS ((bfd *, bfd *));
 202 #endif
 203
 204 static void
 205 get_break_addr PARAMS ((int, CORE_ADDR *));
 206
 207 static int
 208 fromhex PARAMS ((int));
 209
 210 static int
 211 tohex PARAMS ((int));
 212
 213 static void
 214 es1800_close PARAMS ((int));
 215
 216 static void
 217 es1800_fetch_registers PARAMS ((void));
 218
 219 static void
 220 es1800_fetch_register PARAMS ((int));
 221
 222 static void
 223 es1800_store_register PARAMS ((int));
 224
 225 static void
 226 es1800_read_bytes PARAMS ((CORE_ADDR, char *, int));
 227
 228 static void
 229 es1800_write_bytes PARAMS ((CORE_ADDR, char *, int));
 230
 231 static void
 232 send_with_reply PARAMS ((char *, char *, int));
 233
 234 static void
 235 send_command PARAMS ((char *));
 236
 237 static void
 238 send PARAMS ((char *));
 239
 240 static void
 241 getmessage PARAMS ((char *, int));
 242
 243 static void
 244 es1800_mourn_inferior PARAMS ((void));
 245
 246 static void
 247 es1800_create_break_insn PARAMS ((char *, int));
 248
 249 static void
 250 es1800_init_break PARAMS ((char *, int));
 251
 252 /* Local variables */
 253
 254 #define LOG_FILE "es1800.log"
 255 #if defined (LOG_FILE)
 256 static FILE *log_file;
 257 #endif
 258
 259 extern struct target_ops es1800_ops;            /* Forward decl */
 260 extern struct target_ops es1800_child_ops;      /* Forward decl */
 261
 262 static int kiodebug;
 263 static int timeout = 100;
 264 static char *savename;                          /* Name of i/o device used */
 265 static TERMINAL es1800_sg_save;                 /* Save stty state */
 266 static int es1800_fc_save;                      /* Save fcntl state */
 267
 268 /* indicates that the emulator uses 32-bit data-adress (68020-mode)
 269    instead of 24-bit (68000 -mode) */
 270
 271 static int m68020;
 272
 273 #define MODE (m68020 ? "M68020" : "M68000" )
 274 #define ES1800_BREAK_VEC (0xf)
 275
 276 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
 277    es1800_open knows that we don't have a file open when the program
 278    starts.  */
 279
 280 static int es1800_desc = -1;
 281
 282 #define PBUFSIZ 1000
 283 #define HDRLEN sizeof("@.BAAAAAAAA=$VV\r")
 284
 285 /* Maximum number of bytes to read/write at once.  The value here
 286    is chosen to fill up a packet.  */
 287
 288 #define MAXBUFBYTES ((PBUFSIZ-150)*16/75 )
 289
 290 static int es1800_break_vec = 0;
 291 static char es1800_break_insn[2];
 292 static long es1800_break_address;
 293 static void (*old_sigint)();            /* Old signal-handler for sigint */
 294 static jmp_buf interrupt;
 295
 296 /* Local signalhandler to allow breaking tranfers or program run.
 297    Rely on global variables: old_sigint(), interrupt */
 298
 299 static void
 300 es1800_request_quit ()
 301 {
 302   /* restore original signalhandler */
 303   signal (SIGINT, old_sigint);
 304   longjmp (interrupt, 1);
 305 }
 306
 307
 308 /* Reset emulator.
 309    Sending reset character(octal 32) to emulator.
 310    quit - return to '(esgdb)' prompt or continue        */
 311
 312 static void
 313 es1800_reset (quit)
 314      char *quit;
 315 {
 316   char buf[80];
 317
 318   if (quit)
 319     {
 320       printf ("\nResetting emulator...  ");
 321     }
 322   strcpy (buf, "\032");
 323   send (buf);
 324   expect_prompt ();
 325   if (quit)
 326     {
 327       error ("done\n");
 328     }
 329 }
 330
 331
 332 /* Called when SIGALRM signal sent due to alarm() timeout.
 333    Rely on global variables: timeout  */
 334
 335 #ifndef HAVE_TERMIO
 336
 337 static void
 338 es1800_timer ()
 339 {
 340   if (kiodebug)
 341     {
 342       printf ("es1800_timer called\n");
 343     }
 344   alarm (timeout);
 345 }
 346
 347 #endif  /* HAVE_TERMIO */
 348
 349
 350 /* Open a connection to a remote debugger and push the new target
 351    onto the stack. Check if the emulator is responding and find out
 352    what kind of processor the emulator is connected to.
 353    Initiate the breakpoint handling in the emulator.
 354
 355    name     - the filename used for communication (ex. '/dev/tta')
 356    from_tty - says whether to be verbose or not */
 357
 358 static void
 359 es1800_open (name, from_tty)
 360      char *name;
 361      int from_tty;
 362 {
 363   TERMINAL sg;
 364   char buf[PBUFSIZ];
 365   char *p;
 366   int i, fcflag;
 367   char baudrate[1024];
 368
 369   m68020 = 0;
 370
 371   if (!name)           /* no device name given in target command */
 372     {
 373       error_no_arg ("serial port device name");
 374     }
 375   sprintf(baudrate, "%d", sr_get_baud_rate());
 376
 377   target_preopen (from_tty);
 378   es1800_close (0);
 379
 380   /* open the device and configure it for communication */
 381
 382 #ifndef DEBUG_STDIN
 383
 384   es1800_desc = open (name, O_RDWR);
 385   if (es1800_desc < 0)
 386     {
 387       perror_with_name (name);
 388     }
 389   savename = savestring (name, strlen (name));
 390
 391   if (ioctl (es1800_desc, TIOCGETP, &sg) == -1)
 392     {
 393       perror_with_name (name);
 394     }
 395   es1800_sg_save = sg;
 396
 397   if ((fcflag = fcntl (es1800_desc, F_GETFL, 0)) == -1)
 398     {
 399       perror_with_name ("fcntl serial");
 400     }
 401   es1800_fc_save = fcflag;
 402
 403   fcflag = (fcflag & (FREAD | FWRITE)); /* mask out any funny stuff */
 404   if (fcntl (es1800_desc, F_SETFL, fcflag) == -1)
 405     {
 406       perror_with_name ("fcntl serial");
 407     }
 408
 409 #ifdef HAVE_TERMIO
 410   sg.c_cc[VMIN] = 0;            /* read with timeout.  */
 411   sg.c_cc[VTIME] = timeout * 10;
 412   sg.c_lflag &= ~(ICANON | ECHO);
 413   sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);
 414 #else
 415   sg.sg_ispeed = damn_b (baudrate);
 416   sg.sg_ospeed = damn_b (baudrate);
 417   sg.sg_flags = CBREAK+TANDEM;
 418 #endif
 419
 420   if ((ioctl (es1800_desc, TIOCSETP, &sg)) == -1)
 421     {
 422       perror ("es1800_open: error in ioctl");
 423     }
 424
 425 #endif  /* DEBUG_STDIN */
 426
 427   push_target (&es1800_ops);    /* Switch to using remote target now */
 428   if (from_tty)
 429     {
 430       printf ("Remote ES1800 debugging using %s\n", name);
 431     }
 432
 433 #ifndef HAVE_TERMIO
 434
 435 #ifndef NO_SIGINTERRUPT
 436
 437   /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
 438      the read.  */
 439
 440   if (siginterrupt (SIGALRM, 1) != 0)
 441     {
 442       perror ("es1800_open: error in siginterrupt");
 443     }
 444
 445 #endif  /* NO_SIGINTERRUPT */
 446
 447   /* Set up read timeout timer.  */
 448
 449   if ((void(*)()) signal (SIGALRM, es1800_timer) == (void(*)()) -1)
 450     {
 451       perror ("es1800_open: error in signal");
 452     }
 453
 454 #endif  /* HAVE_TERMIO */
 455
 456
 457 #if defined (LOG_FILE)
 458
 459   log_file = fopen (LOG_FILE, "w");
 460   if (log_file == NULL)
 461     {
 462       perror_with_name (LOG_FILE);
 463     }
 464
 465 #endif  /* LOG_FILE */
 466
 467   /* Hello?  Are you there?, also check mode  */
 468
 469   /*  send_with_reply( "DB 0 TO 1", buf, sizeof(buf)); */
 470   /*  for (p = buf, i = 0; *p++ =='0';)  */   /* count the number of zeros */
 471   /*      i++; */
 472
 473   send ("\032");
 474   getmessage (buf, sizeof (buf));  /* send reset character */
 475
 476   if (from_tty)
 477     {
 478       printf ("Checking mode.... ");
 479     }
 480   /*  m68020 = (i==8); */   /* if eight zeros then we are in m68020 mode */
 481
 482   /* What kind of processor am i talking to ?*/
 483   p = buf;
 484   while (*p++ != '\n') {;}
 485   while (*p++ != '\n') {;}
 486   while (*p++ != '\n') {;}
 487   for (i = 0; i < 20; i++, p++) {;}
 488   m68020 = !strncmp (p, "68020", 5);
 489   if (from_tty)
 490     {
 491       printf ("You are in %s(%c%c%c%c%c)-mode\n", MODE, p[0], p[1], p[2],
 492               p[3], p[4]);
 493     }
 494
 495   /* if no init_break statement is present in .gdb file we have to check
 496      whether to download a breakpoint routine or not */
 497
 498 #if 0
 499   if ((es1800_break_vec == 0) || (verify_break (es1800_break_vec) != 0)
 500       && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
 501     {
 502       CORE_ADDR memaddress;
 503       printf ("Give the start address of the breakpoint routine: ");
 504       scanf ("%li", &memaddress);
 505       es1800_init_break ((es1800_break_vec ? es1800_break_vec :
 506                           ES1800_BREAK_VEC), memaddress);
 507     }
 508 #endif
 509
 510 }
 511
 512 /*  Close out all files and local state before this target loses control.
 513     quitting - are we quitting gdb now? */
 514
 515 static void
 516 es1800_close (quitting)
 517      int quitting;
 518 {
 519   if (es1800_desc >= 0)
 520     {
 521       printf ("\nClosing connection to emulator...\n");
 522       ioctl (es1800_desc, TIOCSETP, &es1800_sg_save);
 523       fcntl (es1800_desc,F_SETFL, es1800_fc_save);
 524       close (es1800_desc);
 525       es1800_desc = -1;
 526     }
 527   if (savename != NULL)
 528     {
 529       free (savename);
 530     }
 531   savename = NULL;
 532
 533 #if defined (LOG_FILE)
 534
 535   if (log_file != NULL)
 536     {
 537       if (ferror (log_file))
 538         {
 539           printf ("Error writing log file.\n");
 540         }
 541       if (fclose (log_file) != 0)
 542         {
 543           printf ("Error closing log file.\n");
 544         }
 545       log_file = NULL;
 546     }
 547
 548 #endif  /* LOG_FILE */
 549
 550 }
 551
 552 /* damn_b()
 553
 554    Translate baud rates from integers to damn B_codes.  Unix should
 555    have outgrown this crap years ago, but even POSIX wouldn't buck it.
 556    rate - the baudrate given as a string
 557    return value: the baudrate as a B_code */
 558
 559 #ifndef B19200
 560 #  define B19200 EXTA
 561 #endif
 562 #ifndef B38400
 563 #  define B38400 EXTB
 564 #endif
 565
 566 struct
 567 {
 568   char *rate,
 569   damn_b;
 570 } baudtab[] = {
 571   {"0", B0},
 572   {"50", B50},
 573   {"75", B75},
 574   {"110", B110},
 575   {"134", B134},
 576   {"150", B150},
 577   {"200", B200},
 578   {"300", B300},
 579   {"600", B600},
 580   {"1200", B1200},
 581   {"1800", B1800},
 582   {"2400", B2400},
 583   {"4800", B4800},
 584   {"9600", B9600},
 585   {"19200", B19200},
 586   {"38400", B38400},
 587   {0, -1},
 588 };
 589
 590 static int
 591 damn_b (rate)
 592      char *rate;
 593 {
 594   int i;
 595
 596   for (i = 0; baudtab[i].rate != 0; i++)
 597     {
 598       if (STREQ (rate, baudtab[i].rate))
 599         {
 600           return (baudtab[i].damn_b);
 601         }
 602     }
 603   error ("Illegal baudrate");
 604 }
 605
 606
 607 /*  Attaches to a process on the target side
 608     proc_id  - the id of the process to be attached.
 609     from_tty - says whether to be verbose or not */
 610
 611 static void
 612 es1800_attach (args, from_tty)
 613     char *args;
 614     int from_tty;
 615 {
 616   error ("Cannot attach to pid %s, this feature is not implemented yet.",
 617          args);
 618 }
 619
 620
 621 /* Takes a program previously attached to and detaches it.
 622    We better not have left any breakpoints
 623    in the program or it'll die when it hits one.
 624    Close the open connection to the remote debugger.
 625    Use this when you want to detach and do something else
 626    with your gdb.
 627
 628    args     - arguments given to the 'detach' command
 629    from_tty - says whether to be verbose or not */
 630
 631 static void
 632 es1800_detach (args, from_tty)
 633      char *args;
 634      int from_tty;
 635 {
 636   if (args)
 637     {
 638       error ("Argument given to \"detach\" when remotely debugging.");
 639     }
 640   pop_target ();
 641   if (from_tty)
 642     {
 643       printf ("Ending es1800 remote debugging.\n");
 644     }
 645 }
 646
 647
 648 /* Tell the remote machine to resume.
 649    step    - single-step or run free
 650    siggnal - the signal value to be given to the target (0 = no signal) */
 651
 652 static void
 653 es1800_resume (pid, step, siggnal)
 654      int pid;
 655      int step;
 656      enum target_signal siggnal;
 657 {
 658   char buf[PBUFSIZ];
 659
 660   if (siggnal)
 661     {
 662       error ("Can't send signals to a remote system.");
 663     }
 664   if (step)
 665     {
 666       strcpy (buf,"STP\r");
 667       send (buf);
 668     }
 669   else
 670     {
 671       send_command ("RBK");
 672     }
 673 }
 674
 675 /* Wait until the remote machine stops, then return,
 676    storing status in STATUS just as `wait' would.
 677    status -  */
 678
 679 static int
 680 es1800_wait (status)
 681      struct target_waitstatus *status;
 682 {
 683   unsigned char buf[PBUFSIZ];
 684   int old_timeout = timeout;
 685
 686   status->kind = TARGET_WAITKIND_EXITED;
 687   status->value.integer = 0;
 688
 689   timeout = 0;          /* Don't time out -- user program is running. */
 690   if (!setjmp (interrupt))
 691     {
 692       old_sigint = signal (SIGINT, es1800_request_quit);
 693       while (1)
 694         {
 695           getmessage (buf, sizeof(buf));
 696           if (strncmp ( buf, "\r\n* BREAK *", 11) == 0)
 697             {
 698               status->kind = TARGET_WAITKIND_STOPPED;
 699               status->value.sig = TARGET_SIGNAL_TRAP;
 700               send_command ("STP");     /* Restore stack and PC and such */
 701               if (m68020)
 702                 {
 703                   send_command ("STP");
 704                 }
 705               break;
 706             }
 707           if (strncmp (buf, "STP\r\n ", 6) == 0)
 708             {
 709               status->kind = TARGET_WAITKIND_STOPPED;
 710               status->value.sig = TARGET_SIGNAL_TRAP;
 711               break;
 712             }
 713           if (buf[strlen (buf) - 2] == 'R')
 714             {
 715               printf ("Unexpected emulator reply: \n%s\n", buf);
 716             }
 717           else
 718             {
 719               printf ("Unexpected stop: \n%s\n", buf);
 720               status->kind = TARGET_WAITKIND_STOPPED;
 721               status->value.sig = TARGET_SIGNAL_QUIT;
 722               break;
 723             }
 724         }
 725     }
 726   else
 727     {
 728       fflush (stdin);
 729       printf ("\nStopping emulator...");
 730       if (!setjmp (interrupt))
 731         {
 732           old_sigint = signal (SIGINT, es1800_request_quit);
 733           send_command ("STP");
 734           printf (" emulator stopped\n");
 735           status->kind = TARGET_WAITKIND_STOPPED;
 736           status->value.sig = TARGET_SIGNAL_INT;
 737         }
 738       else
 739         {
 740           fflush (stdin);
 741           es1800_reset ((char*) 1);
 742         }
 743     }
 744   signal (SIGINT, old_sigint);
 745   timeout = old_timeout;
 746   return (0);
 747 }
 748
 749
 750 /* Fetch register values from remote machine.
 751    regno - the register to be fetched (fetch all registers if -1) */
 752
 753 static void
 754 es1800_fetch_register (regno)
 755      int regno;
 756 {
 757   char buf[PBUFSIZ];
 758   int k;
 759   int r;
 760   char *p;
 761   static char regtab[18][4] =
 762     {
 763       "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
 764       "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
 765       "SR ", "PC "
 766     };
 767
 768   if ((regno < 15) || (regno == 16) || (regno == 17))
 769     {
 770       r = regno * 4;
 771       send_with_reply (regtab[regno], buf, sizeof (buf));
 772       p = buf;
 773       for (k = 0; k < 4; k++)
 774         {
 775           if ((p[k*2 + 1] == 0) || (p[k*2 + 2] == 0))
 776             {
 777               error ("Emulator reply is too short: %s", buf);
 778             }
 779           registers[r++] = (fromhex (p[k*2 + 1]) * 16) + fromhex (p[k*2 + 2]);
 780         }
 781     }
 782   else
 783     {
 784       es1800_fetch_registers ();
 785     }
 786 }
 787
 788 /* Read the remote registers into REGISTERS.
 789    Always fetches all registers. */
 790
 791 static void
 792 es1800_fetch_registers ()
 793 {
 794   char buf[PBUFSIZ];
 795   char SR_buf[PBUFSIZ];
 796   int i;
 797   int k;
 798   int r;
 799   char *p;
 800
 801   send_with_reply ("DR", buf, sizeof (buf));
 802
 803   /* Reply is edited to a string that describes registers byte by byte,
 804      each byte encoded as two hex characters.  */
 805
 806   p = buf;
 807   r = 0;
 808
 809   /*  parsing row one - D0-D7-registers  */
 810
 811   while (*p++ != '\n') {;}
 812   for (i = 4; i < 70; i += (i == 39 ? 3 : 1))
 813     {
 814       for (k = 0; k < 4; k++)
 815         {
 816           if (p[i+0] == 0 || p[i+1] == 0)
 817             {
 818               error ("Emulator reply is too short: %s", buf);
 819             }
 820           registers[r++] = (fromhex (p[i+0]) * 16) + fromhex (p[i+1]);
 821           i += 2;
 822         }
 823     }
 824   p += i;
 825
 826   /*  parsing row two - A0-A6-registers  */
 827
 828   while (*p++ != '\n') {;}
 829   for (i = 4; i < 61; i += (i == 39 ? 3 : 1))
 830     {
 831       for (k = 0; k < 4; k++)
 832         {
 833           if (p[i+0] == 0 || p[i+1] == 0)
 834             {
 835               error ("Emulator reply is too short: %s", buf);
 836             }
 837           registers[r++] = (fromhex (p[i+0])) * 16 + fromhex (p[i+1]);
 838           i += 2;
 839         }
 840     }
 841   p += i;
 842
 843   while (*p++ != '\n') {;}
 844
 845   /* fetch SSP-, SR- and PC-registers  */
 846
 847   /* first - check STATUS-word and decide which stackpointer to use */
 848
 849   send_with_reply ("SR", SR_buf, sizeof (SR_buf));
 850   p = SR_buf;
 851   p += 5;
 852
 853   if (m68020)
 854     {
 855       if (*p == '3')             /* use masterstackpointer MSP */
 856         {
 857           send_with_reply ("MSP", buf, sizeof (buf));
 858         }
 859       else if (*p == '2')       /* use interruptstackpointer ISP  */
 860         {
 861           send_with_reply ("ISP", buf, sizeof (buf));
 862         }
 863       else                      /* use userstackpointer USP  */
 864         {
 865           send_with_reply ("USP", buf, sizeof (buf));
 866         }
 867       p = buf;
 868       for (k = 0; k<4; k++)
 869         {
 870           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 871             {
 872               error ("Emulator reply is too short: %s", buf);
 873             }
 874           registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
 875         }
 876
 877       p = SR_buf;
 878       for (k = 0; k < 4; k++)
 879         {
 880           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 881             {
 882               error ("Emulator reply is too short: %s", buf);
 883             }
 884           registers[r++] =
 885             fromhex (SR_buf[k*2+1]) * 16 + fromhex (SR_buf[k*2+2]);
 886         }
 887       send_with_reply ("PC", buf, sizeof (buf));
 888       p = buf;
 889       for (k = 0; k<4; k++)
 890         {
 891           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 892             {
 893               error ("Emulator reply is too short: %s", buf);
 894             }
 895           registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
 896         }
 897     }
 898   else    /* 68000-mode */
 899     {
 900       if (*p == '2') /* use supervisorstackpointer SSP  */
 901         {
 902           send_with_reply ("SSP", buf, sizeof (buf));
 903         }
 904       else  /* use userstackpointer USP  */
 905         {
 906           send_with_reply ("USP", buf, sizeof (buf));
 907         }
 908
 909       /* fetch STACKPOINTER */
 910
 911       p = buf;
 912       for (k = 0; k < 4; k++)
 913         {
 914           if (p[k*2 + 1] == 0 || p[k*2 + 2] == 0)
 915             {
 916               error ("Emulator reply is too short: %s", buf);
 917             }
 918           registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
 919         }
 920
 921       /* fetch STATUS */
 922
 923       p = SR_buf;
 924       for (k = 0; k < 4; k++)
 925         {
 926           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 927             {
 928               error ("Emulator reply is too short: %s", buf);
 929             }
 930           registers[r++] =
 931             fromhex (SR_buf[k*2+1]) * 16 + fromhex (SR_buf[k*2+2]);
 932         }
 933
 934       /* fetch PC */
 935
 936       send_with_reply ("PC", buf, sizeof (buf));
 937       p = buf;
 938       for (k = 0; k < 4; k++)
 939         {
 940           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 941             {
 942               error ("Emulator reply is too short: %s", buf);
 943             }
 944           registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
 945         }
 946     }
 947 }
 948
 949 /* Store register value, located in REGISTER, on the target processor.
 950    regno - the register-number of the register to store
 951            (-1 means store them all)
 952    FIXME: Return errno value.  */
 953
 954 static void
 955 es1800_store_register(regno)
 956      int regno;
 957 {
 958
 959   static char regtab[18][4] =
 960     {
 961       "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
 962       "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
 963       "SR ", "PC "
 964     };
 965
 966   char buf[PBUFSIZ];
 967   char SR_buf[PBUFSIZ];
 968   char stack_pointer[4];
 969   char *p;
 970   int i;
 971   int j;
 972   int k;
 973   unsigned char *r;
 974
 975   r = (unsigned char *) registers;
 976
 977   if (regno == -1)  /* write all registers */
 978     {
 979       j = 0;
 980       k = 18;
 981     }
 982   else              /* write one register */
 983     {
 984       j = regno;
 985       k = regno+1;
 986       r += regno * 4;
 987     }
 988
 989   if ((regno == -1) || (regno == 15))
 990     {
 991       /* fetch current status */
 992       send_with_reply ("SR", SR_buf, sizeof (SR_buf));
 993       p = SR_buf;
 994       p += 5;
 995       if (m68020)
 996         {
 997           if (*p == '3') /* use masterstackpointer MSP */
 998             {
 999               strcpy (stack_pointer,"MSP");
1000             }
1001           else
1002             {
1003               if (*p == '2') /* use interruptstackpointer ISP  */
1004                 {
1005                   strcpy (stack_pointer,"ISP");
1006                 }
1007               else
1008                 {
1009                   strcpy (stack_pointer,"USP");  /* use userstackpointer USP  */
1010                 }
1011             }
1012         }
1013       else  /* 68000-mode */
1014         {
1015           if (*p == '2') /* use supervisorstackpointer SSP  */
1016             {
1017               strcpy (stack_pointer,"SSP");
1018             }
1019           else
1020             {
1021               strcpy (stack_pointer,"USP");/* use userstackpointer USP  */
1022             }
1023         }
1024       strcpy (regtab[15],stack_pointer);
1025     }
1026
1027   for (i = j; i<k; i++)
1028     {
1029       buf[0] = regtab[i][0];
1030       buf[1] = regtab[i][1];
1031       buf[2] = regtab[i][2];
1032       buf[3] = '=';
1033       buf[4] = '$';
1034       buf[5] = tohex ((*r >> 4) & 0x0f);
1035       buf[6] = tohex (*r++ & 0x0f);
1036       buf[7] = tohex ((*r >> 4) & 0x0f);
1037       buf[8] = tohex (*r++ & 0x0f);
1038       buf[9] = tohex ((*r >> 4) & 0x0f);
1039       buf[10] = tohex (*r++ & 0x0f);
1040       buf[11] = tohex ((*r >> 4) & 0x0f);
1041       buf[12] = tohex (*r++ & 0x0f);
1042       buf[13] = 0;
1043
1044       send_with_reply (buf, buf, sizeof (buf)); /* FIXME, reply not used? */
1045     }
1046 }
1047
1048
1049 /* Prepare to store registers.  */
1050
1051 static void
1052 es1800_prepare_to_store ()
1053 {
1054   /* Do nothing, since we can store individual regs */
1055 }
1056
1057 /* Convert hex digit A to a number.  */
1058
1059 static int
1060 fromhex (a)
1061      int a;
1062 {
1063   if (a >= '0' && a <= '9')
1064     {
1065       return a - '0';
1066     }
1067   else if (a >= 'a' && a <= 'f')
1068     {
1069       return a - 'a' + 10;
1070     }
1071   else if (a >= 'A' && a <= 'F')
1072     {
1073       return a - 'A' + 10;
1074     }
1075   else
1076     {
1077       error ("Reply contains invalid hex digit");
1078     }
1079   return (-1);
1080 }
1081
1082
1083 /* Convert number NIB to a hex digit.  */
1084
1085 static int
1086 tohex (nib)
1087      int nib;
1088 {
1089   if (nib < 10)
1090     {
1091       return ('0' + nib);
1092     }
1093   else
1094     {
1095       return ('A' + nib - 10);
1096     }
1097 }
1098
1099 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
1100    to or from debugger address MYADDR.  Write to inferior if WRITE is
1101    nonzero.  Returns length of data written or read; 0 for error.
1102
1103    memaddr - the target's address
1104    myaddr  - gdb's address
1105    len     - number of bytes
1106    write   - write if != 0 otherwise read       */
1107
1108 static int
1109 es1800_xfer_inferior_memory (memaddr, myaddr, len, write, tops)
1110      CORE_ADDR memaddr;
1111      char *myaddr;
1112      int len;
1113      int write;
1114      struct target_ops *tops;   /* Unused */
1115 {
1116   int origlen = len;
1117   int xfersize;
1118
1119   while (len > 0)
1120     {
1121       xfersize = len > MAXBUFBYTES ? MAXBUFBYTES : len;
1122       if (write)
1123         {
1124           es1800_write_bytes (memaddr, myaddr, xfersize);
1125         }
1126       else
1127         {
1128           es1800_read_bytes (memaddr, myaddr, xfersize);
1129         }
1130       memaddr += xfersize;
1131       myaddr += xfersize;
1132       len -= xfersize;
1133     }
1134   return (origlen); /* no error possible */
1135 }
1136
1137
1138 /* Write memory data directly to the emulator.
1139    This does not inform the data cache; the data cache uses this.
1140    MEMADDR is the address in the remote memory space.
1141    MYADDR is the address of the buffer in our space.
1142    LEN is the number of bytes.
1143
1144    memaddr - the target's address
1145    myaddr  - gdb's address
1146    len     - number of bytes   */
1147
1148 static void
1149 es1800_write_bytes (memaddr, myaddr, len)
1150      CORE_ADDR memaddr;
1151      char *myaddr;
1152      int len;
1153 {
1154   char buf[PBUFSIZ];
1155   int i;
1156   char *p;
1157
1158   p = myaddr;
1159   for (i = 0; i < len; i++)
1160     {
1161       sprintf (buf, "@.B$%x=$%x", memaddr+i, (*p++) & 0xff);
1162       send_with_reply (buf, buf, sizeof (buf));      /* FIXME send_command? */
1163     }
1164 }
1165
1166
1167 /* Read memory data directly from the emulator.
1168    This does not use the data cache; the data cache uses this.
1169
1170    memaddr - the target's address
1171    myaddr  - gdb's address
1172    len     - number of bytes   */
1173
1174 static void
1175 es1800_read_bytes (memaddr, myaddr, len)
1176      CORE_ADDR memaddr;
1177      char *myaddr;
1178      int len;
1179 {
1180   static int DB_tab[16] = {8,11,14,17,20,23,26,29,34,37,40,43,46,49,52,55};
1181   char buf[PBUFSIZ];
1182   int i;
1183   int low_addr;
1184   char *p;
1185   char *b;
1186
1187   if (len > PBUFSIZ / 2 - 1)
1188     {
1189       abort ();
1190     }
1191
1192   if (len == 1) /* The emulator does not like expressions like:  */
1193     {
1194       len = 2;  /* DB.B $20018 TO $20018                       */
1195     }
1196
1197   /* Reply describes registers byte by byte, each byte encoded as two hex
1198      characters.  */
1199
1200   sprintf (buf, "DB.B $%x TO $%x", memaddr, memaddr+len-1);
1201   send_with_reply (buf, buf, sizeof (buf));
1202   b = buf;
1203   low_addr = memaddr&0x0f;
1204   for (i = low_addr; i < low_addr + len; i++)
1205     {
1206       if ((!(i % 16)) && i)
1207         {   /* if (i = 16,32,48)  */
1208           while (*p++!='\n') {;}
1209           b = p;
1210         }
1211       p = b + DB_tab[i%16] + (m68020 ? 2 : 0);
1212       if (p[0] == 32 || p[1] == 32)
1213         {
1214           error ("Emulator reply is too short: %s", buf);
1215         }
1216       myaddr[i-low_addr] = fromhex (p[0]) * 16 + fromhex (p[1]);
1217     }
1218 }
1219
1220 /* Information about the current target  */
1221
1222 static void
1223 es1800_files_info (tops)
1224      struct target_ops *tops;   /* Unused */
1225 {
1226   printf ("ES1800 Attached to %s at %d baud in %s mode\n", savename, 19200,
1227           MODE);
1228 }
1229
1230
1231 /* We read the contents of the target location and stash it,
1232    then overwrite it with a breakpoint instruction.
1233
1234    addr           - is the target location in the target machine.
1235    contents_cache - is a pointer to memory allocated for saving the target contents.
1236                     It is guaranteed by the caller to be long enough to save sizeof
1237                     BREAKPOINT bytes.
1238
1239    FIXME: This size is target_arch dependent and should be available in
1240    the target_arch transfer vector, if we ever have one...  */
1241
1242 static int
1243 es1800_insert_breakpoint (addr, contents_cache)
1244      CORE_ADDR addr;
1245      char *contents_cache;
1246 {
1247   int val;
1248
1249   val = target_read_memory (addr, contents_cache, sizeof (es1800_break_insn));
1250
1251   if (val == 0)
1252     {
1253       val = target_write_memory (addr, es1800_break_insn,
1254                                  sizeof (es1800_break_insn));
1255     }
1256
1257   return (val);
1258 }
1259
1260
1261 /* Write back the stashed instruction
1262
1263    addr           - is the target location in the target machine.
1264    contents_cache - is a pointer to memory allocated for saving the target contents.
1265                     It is guaranteed by the caller to be long enough to save sizeof
1266                     BREAKPOINT bytes.   */
1267
1268 static int
1269 es1800_remove_breakpoint (addr, contents_cache)
1270      CORE_ADDR addr;
1271      char *contents_cache;
1272 {
1273
1274   return (target_write_memory (addr, contents_cache,
1275                                sizeof (es1800_break_insn)));
1276 }
1277
1278 /* create_break_insn ()
1279    Primitive datastructures containing the es1800 breakpoint instruction  */
1280
1281 static void
1282 es1800_create_break_insn (ins, vec)
1283      char *ins;
1284      int vec;
1285 {
1286   if (vec == 15)
1287     {
1288       ins[0] = 0x4e;
1289       ins[1] = 0x4f;
1290     }
1291 }
1292
1293
1294 /* verify_break ()
1295    Seach for breakpoint routine in emulator memory.
1296    returns non-zero on failure
1297    vec - trap vector used for breakpoints  */
1298
1299 static int
1300 verify_break (vec)
1301      int vec;
1302 {
1303   CORE_ADDR memaddress;
1304   char buf[8];
1305   char *instr = "NqNqNqNs";      /* breakpoint routine */
1306   int status;
1307
1308   get_break_addr (vec, &memaddress);
1309
1310   if (memaddress)
1311     {
1312       status = target_read_memory (memaddress, buf, 8);
1313       if (status != 0)
1314         {
1315           memory_error (status, memaddress);
1316         }
1317       return (STRCMP (instr, buf));
1318     }
1319     return (-1);
1320 }
1321
1322
1323 /* get_break_addr ()
1324    find address of breakpint routine
1325    vec - trap vector used for breakpoints
1326    addrp - store the address here       */
1327
1328 static void
1329 get_break_addr (vec, addrp)
1330      int vec;
1331      CORE_ADDR *addrp;
1332 {
1333   CORE_ADDR memaddress = 0;
1334   int status;
1335   int k;
1336   char buf[PBUFSIZ];
1337   char base_addr[4];
1338   char *p;
1339
1340   if (m68020)
1341     {
1342       send_with_reply ("VBR ", buf, sizeof (buf));
1343       p = buf;
1344       for (k = 0; k < 4; k++)
1345         {
1346           if ((p[k*2 + 1] == 0) || (p[k*2 + 2] == 0))
1347             {
1348               error ("Emulator reply is too short: %s", buf);
1349             }
1350           base_addr[k] = (fromhex (p[k*2 + 1]) * 16) + fromhex (p[k*2 + 2]);
1351         }
1352       /* base addr of exception vector table */
1353       memaddress = *((CORE_ADDR *) base_addr);
1354     }
1355
1356     memaddress += (vec + 32) * 4;     /* address of trap vector */
1357     status = target_read_memory (memaddress, (char *) addrp, 4);
1358     if (status != 0)
1359       {
1360         memory_error (status, memaddress);
1361       }
1362 }
1363
1364
1365 /* Kill an inferior process */
1366
1367 static void
1368 es1800_kill ()
1369 {
1370   if (inferior_pid != 0)
1371     {
1372       inferior_pid = 0;
1373       es1800_mourn_inferior ();
1374     }
1375 }
1376
1377
1378 /* Load a file to the ES1800 emulator.
1379    Converts the file from a.out format into Extended Tekhex format
1380    before the file is loaded.
1381    Also loads the trap routine, and sets the ES1800 breakpoint on it
1382    filename - the a.out to be loaded
1383    from_tty - says whether to be verbose or not
1384    FIXME Uses emulator overlay memory for trap routine  */
1385
1386 static void
1387 es1800_load (filename, from_tty)
1388      char *filename;
1389      int from_tty;
1390 {
1391
1392   FILE *instream;
1393   char loadname[15];
1394   char buf[160];
1395   struct cleanup *old_chain;
1396   int es1800_load_format = 5;
1397
1398   if (es1800_desc < 0)
1399     {
1400       printf ("No emulator attached, type emulator-command first\n");
1401       return;
1402     }
1403
1404   filename = tilde_expand (filename);
1405   make_cleanup (free, filename);
1406
1407   switch (es1800_load_format)
1408     {
1409       case 2:   /* Extended Tekhex  */
1410         if (from_tty)
1411           {
1412             printf ("Converting \"%s\" to Extended Tekhex Format\n", filename);
1413           }
1414         sprintf (buf, "tekhex %s", filename);
1415         system (buf);
1416         sprintf (loadname, "out.hex");
1417         break;
1418
1419       case 5:   /* Motorola S-rec  */
1420         if (from_tty)
1421           {
1422             printf ("Converting \"%s\" to Motorola S-record format\n",
1423                     filename);
1424           }
1425         /* in the future the source code in copy (part of binutils-1.93) will
1426            be included in this file */
1427         sprintf (buf,
1428                  "copy -s \"a.out-sunos-big\" -d \"srec\" %s /tmp/out.hex",
1429                  filename);
1430         system (buf);
1431         sprintf (loadname, "/tmp/out.hex");
1432         break;
1433
1434       default:
1435         error ("Downloading format not defined\n");
1436     }
1437
1438   breakpoint_init_inferior ();
1439   inferior_pid = 0;
1440   if (from_tty)
1441     {
1442       printf ("Downloading \"%s\" to the ES 1800\n",filename);
1443     }
1444   if ((instream = fopen (loadname, "r")) == NULL)
1445     {
1446       perror_with_name ("fopen:");
1447     }
1448
1449   old_chain = make_cleanup (fclose, instream);
1450   immediate_quit++;
1451
1452   es1800_reset (0);
1453
1454   download (instream, from_tty, es1800_load_format);
1455
1456   /* if breakpoint routine is not present anymore we have to check
1457      whether to download a new breakpoint routine or not */
1458
1459   if ((verify_break (es1800_break_vec) != 0)
1460       && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
1461     {
1462       char buf[128];
1463       printf ("Using break vector 0x%x\n", es1800_break_vec);
1464       sprintf (buf, "0x%x ", es1800_break_vec);
1465       printf ("Give the start address of the breakpoint routine: ");
1466       fgets (buf + strlen (buf), sizeof (buf) - strlen (buf), stdin);
1467       es1800_init_break (buf, 0);
1468     }
1469
1470   do_cleanups (old_chain);
1471   expect_prompt ();
1472   readchar ();  /* FIXME I am getting a ^G = 7 after the prompt  */
1473   printf ("\n");
1474
1475   if (fclose (instream) == EOF)
1476     {
1477       ;
1478     }
1479
1480   if (es1800_load_format != 2)
1481     {
1482       sprintf (buf, "/usr/bin/rm %s", loadname);
1483       system (buf);
1484     }
1485
1486   symbol_file_command (filename, from_tty);   /* reading symbol table */
1487   immediate_quit--;
1488 }
1489
1490 #if 0
1491
1492 #define NUMCPYBYTES 20
1493
1494 static void
1495 bfd_copy (from_bfd, to_bfd)
1496      bfd *from_bfd;
1497      bfd *to_bfd;
1498 {
1499   asection *p, *new;
1500   int i;
1501   char buf[NUMCPYBYTES];
1502
1503   for (p = from_bfd->sections; p != NULL; p = p->next)
1504     {
1505       printf ("  Copying section %s. Size = %x.\n", p->name, p->_cooked_size);
1506       printf ("    vma = %x,  offset = %x,  output_sec = %x\n",
1507               p->vma, p->output_offset, p->output_section);
1508       new = bfd_make_section (to_bfd, p->name);
1509       if (p->_cooked_size &&
1510           !bfd_set_section_size (to_bfd, new, p->_cooked_size))
1511         {
1512           error ("Wrong BFD size!\n");
1513         }
1514       if (!bfd_set_section_flags (to_bfd, new, p->flags))
1515         {
1516           error ("bfd_set_section_flags");
1517         }
1518       new->vma = p->vma;
1519
1520       for (i = 0; (i + NUMCPYBYTES) < p->_cooked_size ; i += NUMCPYBYTES)
1521         {
1522           if (!bfd_get_section_contents (from_bfd, p, (PTR) buf, (file_ptr) i,
1523                                         (bfd_size_type) NUMCPYBYTES))
1524             {
1525               error ("bfd_get_section_contents\n");
1526             }
1527         if (!bfd_set_section_contents (to_bfd, new, (PTR) buf, (file_ptr) i,
1528                                       (bfd_size_type) NUMCPYBYTES))
1529           {
1530             error ("bfd_set_section_contents\n");
1531           }
1532       }
1533       bfd_get_section_contents (from_bfd, p, (PTR) buf, (file_ptr) i,
1534                                 (bfd_size_type) (p->_cooked_size - i));
1535       bfd_set_section_contents (to_bfd, new, (PTR) buf,(file_ptr) i,
1536                                 (bfd_size_type) (p->_cooked_size - i));
1537     }
1538 }
1539
1540 #endif
1541
1542 /* Start an process on the es1800 and set inferior_pid to the new
1543    process' pid.
1544    execfile - the file to run
1545    args     - arguments passed to the program
1546    env      - the environment vector to pass    */
1547
1548 static void
1549 es1800_create_inferior (execfile, args, env)
1550      char *execfile;
1551      char *args;
1552      char **env;
1553 {
1554   int entry_pt;
1555   int pid;
1556 #if 0
1557   struct expression *expr;
1558   register struct cleanup *old_chain = 0;
1559   register value val;
1560 #endif
1561
1562   if (args && *args)
1563     {
1564       error ("Can't pass arguments to remote ES1800 process");
1565     }
1566
1567 #if 0
1568   if (query ("Use 'start' as entry point? "))
1569     {
1570       expr = parse_c_expression ("start");
1571       old_chain = make_cleanup (free_current_contents, &expr);
1572       val = evaluate_expression (expr);
1573       entry_pt = (val->location).address;
1574     }
1575   else
1576     {
1577       printf ("Enter the program's entry point (in hexadecimal): ");
1578       scanf ("%x", &entry_pt);
1579     }
1580 #endif
1581
1582   if (execfile == 0 || exec_bfd == 0)
1583     {
1584       error ("No exec file specified");
1585     }
1586
1587   entry_pt = (int) bfd_get_start_address (exec_bfd);
1588
1589   pid = 42;
1590
1591   /* Now that we have a child process, make it our target.  */
1592
1593   push_target (&es1800_child_ops);
1594
1595   /* The "process" (board) is already stopped awaiting our commands, and
1596      the program is already downloaded.  We just set its PC and go.  */
1597
1598   inferior_pid = pid;           /* Needed for wait_for_inferior below */
1599
1600   clear_proceed_status ();
1601
1602   /* Tell wait_for_inferior that we've started a new process.  */
1603
1604   init_wait_for_inferior ();
1605
1606   /* Set up the "saved terminal modes" of the inferior
1607      based on what modes we are starting it with.  */
1608
1609   target_terminal_init ();
1610
1611   /* Install inferior's terminal modes.  */
1612
1613   target_terminal_inferior ();
1614
1615   /* remote_start (args); */
1616   /* trap_expected = 0; */
1617   /* insert_step_breakpoint ();  FIXME, do we need this?  */
1618
1619   proceed ((CORE_ADDR) entry_pt, -1, 0);                /* Let 'er rip... */
1620
1621 }
1622
1623
1624 /* The process has died, clean up.  */
1625
1626 static void
1627 es1800_mourn_inferior ()
1628 {
1629   remove_breakpoints ();
1630   unpush_target (&es1800_child_ops);
1631   generic_mourn_inferior ();    /* Do all the proper things now */
1632 }
1633
1634 /* ES1800-protocol specific routines */
1635
1636 /* Keep discarding input from the remote system, until STRING is found.
1637    Let the user break out immediately.
1638    string - the string to expect
1639    nowait - break out if string not the emulator's first respond otherwise
1640             read until string is found (== 0)   */
1641
1642 static void
1643 expect (string, nowait)
1644      char *string;
1645     int nowait;
1646 {
1647   char c;
1648   char *p = string;
1649
1650   immediate_quit++;
1651   while (1)
1652     {
1653       c = readchar ();
1654       if (isalpha (c))
1655         {
1656           c = toupper (c);
1657         }
1658       if (c == toupper (*p))
1659         {
1660           p++;
1661           if (*p == '\0')
1662             {
1663               immediate_quit--;
1664               return;
1665             }
1666         }
1667       else if (!nowait)
1668         {
1669           p = string;
1670         }
1671       else
1672         {
1673           printf ("\'%s\' expected\n" , string);
1674           printf ("char %d is %d", p - string, c);
1675           error ("\n" );
1676         }
1677     }
1678 }
1679
1680 /* Keep discarding input until we see the prompt.  */
1681
1682 static void
1683 expect_prompt ()
1684 {
1685   expect (">", 0);
1686 }
1687
1688
1689 /* Read one character */
1690
1691 #ifdef DEBUG_STDIN
1692
1693 /* read from stdin */
1694
1695 static int
1696 readchar ()
1697 {
1698   char buf[1];
1699
1700   buf[0] = '\0';
1701   printf ("readchar, give one character\n");
1702   read (0, buf, 1);
1703
1704 #if defined (LOG_FILE)
1705   putc (buf[0] & 0x7f, log_file);
1706 #endif
1707
1708   return (buf[0] & 0x7f);
1709 }
1710
1711 #else   /* !DEBUG_STDIN */
1712
1713 /* Read a character from the remote system, doing all the fancy
1714    timeout stuff.  */
1715
1716 static int
1717 readchar ()
1718 {
1719   char buf[1];
1720
1721   buf[0] = '\0';
1722
1723 #ifdef HAVE_TERMIO
1724
1725   /* termio does the timeout for us.  */
1726   read (es1800_desc, buf, 1);
1727
1728 #else
1729
1730   alarm (timeout);
1731   while (read (es1800_desc, buf, 1) != 1)
1732     {
1733       if (errno == EINTR)
1734         {
1735           error ("Timeout reading from remote system.");
1736         }
1737       else if (errno != EWOULDBLOCK)
1738         {
1739           perror_with_name ("remote read");
1740         }
1741     }
1742   alarm (0);
1743 #endif
1744
1745 #if defined (LOG_FILE)
1746   putc (buf[0] & 0x7f, log_file);
1747   fflush (log_file);
1748 #endif
1749
1750   return (buf[0] & 0x7f);
1751 }
1752
1753 #endif  /* DEBUG_STDIN */
1754
1755
1756 /* Send a command to the emulator and save the reply.
1757    Report an error if we get an error reply.
1758    string - the es1800 command
1759    buf    - containing the emulator reply on return
1760    len    - size of buf  */
1761
1762 static void
1763 send_with_reply (string, buf, len)
1764     char *string, *buf;
1765     int len;
1766 {
1767   send (string);
1768   write (es1800_desc, "\r", 1);
1769
1770 #ifndef DEBUG_STDIN
1771   expect (string, 1);
1772   expect ("\r\n", 0);
1773 #endif
1774
1775   getmessage (buf, len);
1776 }
1777
1778
1779 /* Send the command in STR to the emulator adding \r. check
1780    the echo for consistency.
1781    string - the es1800 command  */
1782
1783 static void
1784 send_command (string)
1785      char *string;
1786 {
1787   send (string);
1788   write (es1800_desc, "\r", 1);
1789
1790 #ifndef DEBUG_STDIN
1791   expect (string, 0);
1792   expect_prompt ();
1793 #endif
1794
1795 }
1796
1797 /* Send a string
1798    string - the es1800 command  */
1799
1800 static void
1801 send (string)
1802      char *string;
1803 {
1804   if (kiodebug)
1805     {
1806       fprintf (stderr, "Sending: %s\n", string);
1807     }
1808   write (es1800_desc, string, strlen (string));
1809 }
1810
1811
1812 /* Read a message from the emulator and store it in BUF.
1813    buf    - containing the emulator reply on return
1814    len    - size of buf  */
1815
1816 static void
1817 getmessage (buf, len)
1818      char *buf;
1819      int len;
1820 {
1821   char *bp;
1822   int c;
1823   int prompt_found = 0;
1824   extern kiodebug;
1825
1826 #if defined (LOG_FILE)
1827   /* This is a convenient place to do this.  The idea is to do it often
1828      enough that we never lose much data if we terminate abnormally.  */
1829   fflush (log_file);
1830 #endif
1831
1832   bp = buf;
1833   c = readchar ();
1834   do
1835     {
1836       if (c)
1837         {
1838           if (len-- < 2) /* char and terminaling NULL */
1839             {
1840               error ("input buffer overrun\n");
1841             }
1842           *bp++ = c;
1843         }
1844       c = readchar ();
1845       if ((c == '>') && (*(bp - 1) == ' '))
1846         {
1847           prompt_found = 1;
1848         }
1849     }
1850   while (!prompt_found);
1851   *bp = 0;
1852
1853   if (kiodebug)
1854     {
1855       fprintf (stderr,"message received :%s\n", buf);
1856     }
1857 }
1858
1859 static void
1860 download (instream, from_tty, format)
1861 FILE *instream;
1862      int from_tty;
1863      int format;
1864 {
1865   char c;
1866   char buf[160];
1867   int i = 0;
1868
1869   send_command ("SET #2,$1A");                  /* reset char = ^Z */
1870   send_command ("SET #3,$11,$13");              /* XON  XOFF */
1871   if (format == 2)
1872     {
1873       send_command ("SET #26,#2");
1874     }
1875   else
1876     {
1877       send_command ("SET #26,#5");              /* Format=Extended Tekhex */
1878     }
1879   send_command ("DFB = $10");
1880   send_command ("PUR");
1881   send_command ("CES");
1882   send ("DNL\r");
1883   expect ("DNL", 1);
1884   if (from_tty)
1885     {
1886       printf ("    0 records loaded...\r");
1887     }
1888   while (fgets (buf, 160, instream))
1889       {
1890         send (buf);
1891         if (from_tty)
1892           {
1893             printf ("%5d\b\b\b\b\b",++i);
1894             fflush (stdout);
1895           }
1896         if ((c = readchar ()) != 006)
1897           {
1898             error ("expected ACK");
1899           }
1900       }
1901   if (from_tty)
1902     {
1903       printf ("- All");
1904     }
1905 }
1906
1907 /* Additional commands */
1908
1909 /* Talk directly to the emulator
1910    FIXME, uses busy wait, and is SUNOS (or at least BSD) specific  */
1911
1912 /*ARGSUSED*/
1913 static void
1914 es1800_transparent (args, from_tty)
1915      char *args;
1916      int from_tty;
1917 {
1918   int console;
1919   struct sgttyb modebl;
1920   int fcflag;
1921   int cc;
1922   struct sgttyb console_mode_save;
1923   int console_fc_save;
1924   int es1800_fc_save;
1925   int inputcnt = 80;
1926   char inputbuf[80];
1927   int consolecnt = 0;
1928   char consolebuf[80];
1929   int es1800_cnt = 0;
1930   char es1800_buf[80];
1931   int i;
1932
1933   dont_repeat ();
1934   if (es1800_desc < 0)
1935     {
1936       printf ("No emulator attached, type emulator-command first\n");
1937       return;
1938     }
1939
1940   printf ("\n");
1941   printf ("You are now communicating directly with the ES 1800 emulator.\n");
1942   printf ("To leave this mode (transparent mode), press ^E.\n");
1943   printf ("\n");
1944   printf (" >");
1945   fflush (stdout);
1946
1947   if ((console = open ("/dev/tty", O_RDWR)) == -1)
1948     {
1949       perror_with_name ("/dev/tty:");
1950     }
1951
1952   if ((fcflag = fcntl (console, F_GETFL, 0)) == -1)
1953     {
1954       perror_with_name ("fcntl console");
1955     }
1956
1957   console_fc_save = fcflag;
1958   fcflag = fcflag | FNDELAY;
1959
1960   if (fcntl (console, F_SETFL, fcflag) == -1)
1961     {
1962       perror_with_name ("fcntl console");
1963     }
1964
1965   if (ioctl (console, TIOCGETP, &modebl))
1966     {
1967       perror_with_name ("ioctl console");
1968     }
1969
1970   console_mode_save = modebl;
1971   modebl.sg_flags = RAW;
1972
1973   if (ioctl (console, TIOCSETP, &modebl))
1974     {
1975       perror_with_name ("ioctl console");
1976     }
1977
1978   if ((fcflag = fcntl (es1800_desc, F_GETFL, 0)) == -1)
1979     {
1980       perror_with_name ("fcntl serial");
1981     }
1982
1983   es1800_fc_save = fcflag;
1984   fcflag = fcflag | FNDELAY;
1985
1986   if (fcntl (es1800_desc, F_SETFL, fcflag) == -1)
1987     {
1988       perror_with_name ("fcntl serial");
1989     }
1990
1991   while (1)
1992     {
1993       cc = read (console, inputbuf, inputcnt);
1994       if (cc != -1)
1995         {
1996           if ((*inputbuf & 0x7f) == 0x05)
1997             {
1998               break;
1999             }
2000           for (i = 0; i < cc; )
2001             {
2002               es1800_buf[es1800_cnt++] = inputbuf[i++];
2003             }
2004           if ((cc = write (es1800_desc, es1800_buf, es1800_cnt)) == -1)
2005             {
2006               perror_with_name ("FEL! read:");
2007             }
2008           es1800_cnt -= cc;
2009           if (es1800_cnt && cc)
2010             {
2011               for (i = 0; i < es1800_cnt; i++)
2012                 {
2013                   es1800_buf[i] = es1800_buf[cc+i];
2014                 }
2015             }
2016         }
2017       else if (errno != EWOULDBLOCK)
2018         {
2019           perror_with_name ("FEL! read:");
2020         }
2021
2022       cc = read (es1800_desc,inputbuf,inputcnt);
2023       if (cc != -1)
2024         {
2025           for (i = 0; i < cc; )
2026             {
2027               consolebuf[consolecnt++] = inputbuf[i++];
2028             }
2029           if ((cc = write (console,consolebuf,consolecnt)) == -1)
2030             {
2031               perror_with_name ("FEL! write:");
2032             }
2033           consolecnt -= cc;
2034           if (consolecnt && cc)
2035             {
2036               for (i = 0; i < consolecnt; i++)
2037                 {
2038                   consolebuf[i] = consolebuf[cc+i];
2039                 }
2040             }
2041         }
2042       else if (errno != EWOULDBLOCK)
2043         {
2044           perror_with_name ("FEL! read:");
2045         }
2046     }
2047
2048   console_fc_save = console_fc_save & !FNDELAY;
2049   if (fcntl (console, F_SETFL, console_fc_save) == -1)
2050     {
2051       perror_with_name ("FEL! fcntl");
2052     }
2053
2054   if (ioctl (console, TIOCSETP, &console_mode_save))
2055     {
2056       perror_with_name ("FEL! ioctl");
2057     }
2058
2059   close (console);
2060
2061   if (fcntl (es1800_desc, F_SETFL, es1800_fc_save) == -1)
2062     {
2063       perror_with_name ("FEL! fcntl");
2064     }
2065
2066   printf ("\n");
2067
2068 }
2069
2070 static void
2071 es1800_init_break (args, from_tty)
2072      char *args;
2073      int from_tty;
2074 {
2075   CORE_ADDR memaddress = 0;
2076   char buf[PBUFSIZ];
2077   char base_addr[4];
2078   char *space_index;
2079   char *p;
2080   int k;
2081
2082   if (args == NULL)
2083     {
2084       error_no_arg ("a trap vector");
2085     }
2086
2087   if (!(space_index = strchr (args, ' ')))
2088     {
2089       error ("Two arguments needed (trap vector and address of break routine).\n");
2090     }
2091
2092   *space_index = '\0';
2093
2094   es1800_break_vec = strtol (args, (char **) NULL, 0);
2095   es1800_break_address = parse_and_eval_address (space_index + 1);
2096
2097   es1800_create_break_insn (es1800_break_insn, es1800_break_vec);
2098
2099   if (m68020)
2100     {
2101       send_with_reply ("VBR ", buf, sizeof (buf));
2102       p = buf;
2103       for (k = 0; k < 4; k++)
2104         {
2105           if ((p[k*2 + 1] == 0) || (p[k*2 + 2] == 0))
2106             {
2107               error ("Emulator reply is too short: %s", buf);
2108             }
2109           base_addr[k] = (fromhex (p[k*2 + 1]) * 16) + fromhex (p[k*2 + 2]);
2110         }
2111       /* base addr of exception vector table */
2112       memaddress =  *((CORE_ADDR *) base_addr);
2113     }
2114
2115   memaddress += (es1800_break_vec + 32) * 4;     /* address of trap vector */
2116
2117   sprintf (buf, "@.L%lx=$%lx", memaddress, es1800_break_address);
2118   send_command (buf);   /* set the address of the break routine in the */
2119                        /* trap vector */
2120
2121   sprintf (buf, "@.L%lx=$4E714E71", es1800_break_address);      /* NOP; NOP */
2122   send_command (buf);
2123   sprintf (buf, "@.L%lx=$4E714E73", es1800_break_address + 4);  /* NOP; RTE */
2124   send_command (buf);
2125
2126   sprintf (buf, "AC2=$%lx", es1800_break_address + 4);
2127   /* breakpoint at es1800-break_address */
2128   send_command (buf);
2129   send_command ("WHEN AC2 THEN BRK");          /* ie in exception routine */
2130
2131   if (from_tty)
2132     {
2133       printf ("Breakpoint (trap $%x) routine at address: %lx\n",
2134               es1800_break_vec, es1800_break_address);
2135     }
2136 }
2137
2138 static void
2139 es1800_child_open (arg, from_tty)
2140      char *arg;
2141      int from_tty;
2142 {
2143   error ("Use the \"run\" command to start a child process.");
2144 }
2145
2146 static void
2147 es1800_child_detach (args, from_tty)
2148      char *args;
2149      int from_tty;
2150 {
2151   if (args)
2152     {
2153       error ("Argument given to \"detach\" when remotely debugging.");
2154     }
2155
2156   pop_target ();
2157   if (from_tty)
2158     {
2159       printf ("Ending debugging the process %d.\n", inferior_pid);
2160     }
2161 }
2162
2163
2164 /* Define the target subroutine names  */
2165
2166 static struct target_ops es1800_ops =
2167 {
2168   "es1800",                     /* to_shortname */
2169                                 /* to_longname */
2170   "Remote serial target in ES1800-emulator protocol",
2171                                 /* to_doc */
2172   "Remote debugging on the es1800 emulator via a serial line.\n\
2173 Specify the serial device it is connected to (e.g. /dev/ttya).",
2174   es1800_open,                  /* to_open */
2175   es1800_close,                 /* to_close */
2176   es1800_attach,                /* to_attach */
2177   es1800_detach,                /* to_detach */
2178   es1800_resume,                /* to_resume */
2179   NULL,                         /* to_wait */
2180   NULL,                         /* to_fetch_registers */
2181   NULL,                         /* to_store_registers */
2182   es1800_prepare_to_store,      /* to_prepare_to_store */
2183   es1800_xfer_inferior_memory,  /* to_xfer_memory */
2184   es1800_files_info,            /* to_files_info */
2185   es1800_insert_breakpoint,     /* to_insert_breakpoint */
2186   es1800_remove_breakpoint,     /* to_remove_breakpoint */
2187   NULL,                         /* to_terminal_init */
2188   NULL,                         /* to_terminal_inferior */
2189   NULL,                         /* to_terminal_ours_for_output */
2190   NULL,                         /* to_terminal_ours */
2191   NULL,                         /* to_terminal_info */
2192   NULL,                         /* to_kill */
2193   es1800_load,                  /* to_load */
2194   NULL,                         /* to_lookup_symbol */
2195   es1800_create_inferior,       /* to_create_inferior */
2196   NULL,                         /* to_mourn_inferior */
2197   0,                            /* to_can_run */
2198   0,                            /* notice_signals */
2199   core_stratum,                 /* to_stratum */
2200   0,                            /* to_next */
2201   0,                            /* to_has_all_memory */
2202   1,                            /* to_has_memory */
2203   0,                            /* to_has_stack */
2204   0,                            /* to_has_registers */
2205   0,                            /* to_has_execution */
2206   NULL,                         /* to_sections */
2207   NULL,                         /* to_sections_end */
2208   OPS_MAGIC                     /* to_magic (always last) */
2209 };
2210
2211 /* Define the target subroutine names  */
2212
2213 static struct target_ops es1800_child_ops =
2214 {
2215   "es1800_process",             /* to_shortname */
2216                                 /* to_longname */
2217   "Remote serial target in ES1800-emulator protocol",
2218                                 /* to_doc */
2219   "Remote debugging on the es1800 emulator via a serial line.\n\
2220 Specify the serial device it is connected to (e.g. /dev/ttya).",
2221   es1800_child_open,            /* to_open */
2222   NULL,                         /* to_close */
2223   es1800_attach,                /* to_attach */
2224   es1800_child_detach,          /* to_detach */
2225   es1800_resume,                /* to_resume */
2226   es1800_wait,                  /* to_wait */
2227   es1800_fetch_register,        /* to_fetch_registers */
2228   es1800_store_register,        /* to_store_registers */
2229   es1800_prepare_to_store,      /* to_prepare_to_store */
2230   es1800_xfer_inferior_memory,  /* to_xfer_memory */
2231   es1800_files_info,            /* to_files_info */
2232   es1800_insert_breakpoint,     /* to_insert_breakpoint */
2233   es1800_remove_breakpoint,     /* to_remove_breakpoint */
2234   NULL,                         /* to_terminal_init */
2235   NULL,                         /* to_terminal_inferior */
2236   NULL,                         /* to_terminal_ours_for_output */
2237   NULL,                         /* to_terminal_ours */
2238   NULL,                         /* to_terminal_info */
2239   es1800_kill,                  /* to_kill */
2240   es1800_load,                  /* to_load */
2241   NULL,                         /* to_lookup_symbol */
2242   es1800_create_inferior,       /* to_create_inferior */
2243   es1800_mourn_inferior,        /* to_mourn_inferior */
2244   0,                            /* to_can_run */
2245   0,                            /* notice_signals */
2246   process_stratum,              /* to_stratum */
2247   0,                            /* to_next */
2248   1,                            /* to_has_all_memory */
2249   1,                            /* to_has_memory */
2250   1,                            /* to_has_stack */
2251   1,                            /* to_has_registers */
2252   1,                            /* to_has_execution */
2253   NULL,                         /* to_sections */
2254   NULL,                         /* to_sections_end */
2255   OPS_MAGIC                     /* to_magic (always last) */
2256 };
2257
2258 void
2259 _initialize_es1800 ()
2260 {
2261   add_target (&es1800_ops);
2262   add_target (&es1800_child_ops);
2263   add_com ("transparent", class_support, es1800_transparent,
2264            "Start transparent communication with the ES 1800 emulator.");
2265   add_com ("init_break", class_support, es1800_init_break,
2266            "Download break routine and initialize break facility on ES 1800");
2267 }