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
 110 #ifdef USG
 111 #include <sys/types.h>
 112 #include <sgtty.h>
 113 #endif
 114
 115 #include <signal.h>
 116
 117 /* External variables referenced. */
 118
 119 extern bfd *exec_bfd;
 120
 121 /* Prototypes for local functions */
 122
 123 static void
 124 es1800_child_detach PARAMS ((char *, int));
 125
 126 static void
 127 es1800_child_open PARAMS ((char *, int));
 128
 129 static void
 130 es1800_transparent PARAMS ((char *, int));
 131
 132 static void
 133 es1800_create_inferior PARAMS ((char *, char *, char **));
 134
 135 static void
 136 es1800_load PARAMS ((char *, int));
 137
 138 static void
 139 es1800_kill PARAMS ((void));
 140
 141 static int
 142 verify_break PARAMS ((int));
 143
 144 static int
 145 es1800_remove_breakpoint PARAMS ((CORE_ADDR, char *));
 146
 147 static int
 148 es1800_insert_breakpoint PARAMS ((CORE_ADDR, char *));
 149
 150 static void
 151 es1800_files_info PARAMS ((struct target_ops *));
 152
 153 static int
 154 es1800_xfer_inferior_memory PARAMS ((CORE_ADDR, char *, int, int,
 155                                      struct target_ops *));
 156
 157 static void
 158 es1800_prepare_to_store PARAMS ((void));
 159
 160 static int
 161 es1800_wait PARAMS ((WAITTYPE *));
 162
 163 static void
 164 es1800_resume PARAMS ((int, int));
 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;
 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   baudrate = baud_rate ? baud_rate : "19200";  /* default baudrate = 19200 */
 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 (step, siggnal)
 654      int step;
 655      int siggnal;
 656 {
 657   char buf[PBUFSIZ];
 658
 659   if (siggnal)
 660     {
 661       error ("Can't send signals to a remote system.");
 662     }
 663   if (step)
 664     {
 665       strcpy (buf,"STP\r");
 666       send (buf);
 667     }
 668   else
 669     {
 670       send_command ("RBK");
 671     }
 672 }
 673
 674 /* Wait until the remote machine stops, then return,
 675    storing status in STATUS just as `wait' would.
 676    status -  */
 677
 678 static int
 679 es1800_wait (status)
 680      WAITTYPE *status;
 681 {
 682   unsigned char buf[PBUFSIZ];
 683   int old_timeout = timeout;
 684
 685   WSETEXIT ((*status), 0);
 686   timeout = 0;          /* Don't time out -- user program is running. */
 687   if (!setjmp (interrupt))
 688     {
 689       old_sigint = signal (SIGINT, es1800_request_quit);
 690       while (1)
 691         {
 692           getmessage (buf, sizeof(buf));
 693           if (strncmp ( buf, "\r\n* BREAK *", 11) == 0)
 694             {
 695               WSETSTOP ((*status), SIGTRAP);
 696               send_command ("STP");     /* Restore stack and PC and such */
 697               if (m68020)
 698                 {
 699                   send_command ("STP");
 700                 }
 701               break;
 702             }
 703           if (strncmp (buf, "STP\r\n ", 6) == 0)
 704             {
 705               WSETSTOP ((*status), SIGTRAP);
 706               break;
 707             }
 708           if (buf[strlen (buf) - 2] == 'R')
 709             {
 710               printf ("Unexpected emulator reply: \n%s\n", buf);
 711             }
 712           else
 713             {
 714               printf ("Unexpected stop: \n%s\n", buf);
 715               WSETSTOP ((*status), SIGQUIT);
 716               break;
 717             }
 718         }
 719     }
 720   else
 721     {
 722       fflush (stdin);
 723       printf ("\nStopping emulator...");
 724       if (!setjmp (interrupt))
 725         {
 726           old_sigint = signal (SIGINT, es1800_request_quit);
 727           send_command ("STP");
 728           printf (" emulator stopped\n");
 729           WSETSTOP ((*status), SIGINT);
 730         }
 731       else
 732         {
 733           fflush (stdin);
 734           es1800_reset ((char*) 1);
 735         }
 736     }
 737   signal (SIGINT, old_sigint);
 738   timeout = old_timeout;
 739   return (0);
 740 }
 741
 742
 743 /* Fetch register values from remote machine.
 744    regno - the register to be fetched (fetch all registers if -1) */
 745
 746 static void
 747 es1800_fetch_register (regno)
 748      int regno;
 749 {
 750   char buf[PBUFSIZ];
 751   int k;
 752   int r;
 753   char *p;
 754   static char regtab[18][4] =
 755     {
 756       "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
 757       "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
 758       "SR ", "PC "
 759     };
 760
 761   if ((regno < 15) || (regno == 16) || (regno == 17))
 762     {
 763       r = regno * 4;
 764       send_with_reply (regtab[regno], buf, sizeof (buf));
 765       p = buf;
 766       for (k = 0; k < 4; k++)
 767         {
 768           if ((p[k*2 + 1] == 0) || (p[k*2 + 2] == 0))
 769             {
 770               error ("Emulator reply is too short: %s", buf);
 771             }
 772           registers[r++] = (fromhex (p[k*2 + 1]) * 16) + fromhex (p[k*2 + 2]);
 773         }
 774     }
 775   else
 776     {
 777       es1800_fetch_registers ();
 778     }
 779 }
 780
 781 /* Read the remote registers into REGISTERS.
 782    Always fetches all registers. */
 783
 784 static void
 785 es1800_fetch_registers ()
 786 {
 787   char buf[PBUFSIZ];
 788   char SR_buf[PBUFSIZ];
 789   int i;
 790   int k;
 791   int r;
 792   char *p;
 793
 794   send_with_reply ("DR", buf, sizeof (buf));
 795
 796   /* Reply is edited to a string that describes registers byte by byte,
 797      each byte encoded as two hex characters.  */
 798
 799   p = buf;
 800   r = 0;
 801
 802   /*  parsing row one - D0-D7-registers  */
 803
 804   while (*p++ != '\n') {;}
 805   for (i = 4; i < 70; i += (i == 39 ? 3 : 1))
 806     {
 807       for (k = 0; k < 4; k++)
 808         {
 809           if (p[i+0] == 0 || p[i+1] == 0)
 810             {
 811               error ("Emulator reply is too short: %s", buf);
 812             }
 813           registers[r++] = (fromhex (p[i+0]) * 16) + fromhex (p[i+1]);
 814           i += 2;
 815         }
 816     }
 817   p += i;
 818
 819   /*  parsing row two - A0-A6-registers  */
 820
 821   while (*p++ != '\n') {;}
 822   for (i = 4; i < 61; i += (i == 39 ? 3 : 1))
 823     {
 824       for (k = 0; k < 4; k++)
 825         {
 826           if (p[i+0] == 0 || p[i+1] == 0)
 827             {
 828               error ("Emulator reply is too short: %s", buf);
 829             }
 830           registers[r++] = (fromhex (p[i+0])) * 16 + fromhex (p[i+1]);
 831           i += 2;
 832         }
 833     }
 834   p += i;
 835
 836   while (*p++ != '\n') {;}
 837
 838   /* fetch SSP-, SR- and PC-registers  */
 839
 840   /* first - check STATUS-word and decide which stackpointer to use */
 841
 842   send_with_reply ("SR", SR_buf, sizeof (SR_buf));
 843   p = SR_buf;
 844   p += 5;
 845
 846   if (m68020)
 847     {
 848       if (*p == '3')             /* use masterstackpointer MSP */
 849         {
 850           send_with_reply ("MSP", buf, sizeof (buf));
 851         }
 852       else if (*p == '2')       /* use interruptstackpointer ISP  */
 853         {
 854           send_with_reply ("ISP", buf, sizeof (buf));
 855         }
 856       else                      /* use userstackpointer USP  */
 857         {
 858           send_with_reply ("USP", buf, sizeof (buf));
 859         }
 860       p = buf;
 861       for (k = 0; k<4; k++)
 862         {
 863           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 864             {
 865               error ("Emulator reply is too short: %s", buf);
 866             }
 867           registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
 868         }
 869
 870       p = SR_buf;
 871       for (k = 0; k < 4; k++)
 872         {
 873           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 874             {
 875               error ("Emulator reply is too short: %s", buf);
 876             }
 877           registers[r++] =
 878             fromhex (SR_buf[k*2+1]) * 16 + fromhex (SR_buf[k*2+2]);
 879         }
 880       send_with_reply ("PC", buf, sizeof (buf));
 881       p = buf;
 882       for (k = 0; k<4; k++)
 883         {
 884           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 885             {
 886               error ("Emulator reply is too short: %s", buf);
 887             }
 888           registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
 889         }
 890     }
 891   else    /* 68000-mode */
 892     {
 893       if (*p == '2') /* use supervisorstackpointer SSP  */
 894         {
 895           send_with_reply ("SSP", buf, sizeof (buf));
 896         }
 897       else  /* use userstackpointer USP  */
 898         {
 899           send_with_reply ("USP", buf, sizeof (buf));
 900         }
 901
 902       /* fetch STACKPOINTER */
 903
 904       p = buf;
 905       for (k = 0; k < 4; k++)
 906         {
 907           if (p[k*2 + 1] == 0 || p[k*2 + 2] == 0)
 908             {
 909               error ("Emulator reply is too short: %s", buf);
 910             }
 911           registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
 912         }
 913
 914       /* fetch STATUS */
 915
 916       p = SR_buf;
 917       for (k = 0; k < 4; k++)
 918         {
 919           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 920             {
 921               error ("Emulator reply is too short: %s", buf);
 922             }
 923           registers[r++] =
 924             fromhex (SR_buf[k*2+1]) * 16 + fromhex (SR_buf[k*2+2]);
 925         }
 926
 927       /* fetch PC */
 928
 929       send_with_reply ("PC", buf, sizeof (buf));
 930       p = buf;
 931       for (k = 0; k < 4; k++)
 932         {
 933           if (p[k*2+1] == 0 || p[k*2+2] == 0)
 934             {
 935               error ("Emulator reply is too short: %s", buf);
 936             }
 937           registers[r++] = fromhex (buf[k*2+1]) * 16 + fromhex (buf[k*2+2]);
 938         }
 939     }
 940 }
 941
 942 /* Store register value, located in REGISTER, on the target processor.
 943    regno - the register-number of the register to store
 944            (-1 means store them all)
 945    FIXME: Return errno value.  */
 946
 947 static void
 948 es1800_store_register(regno)
 949      int regno;
 950 {
 951
 952   static char regtab[18][4] =
 953     {
 954       "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
 955       "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
 956       "SR ", "PC "
 957     };
 958
 959   char buf[PBUFSIZ];
 960   char SR_buf[PBUFSIZ];
 961   char stack_pointer[4];
 962   char *p;
 963   int i;
 964   int j;
 965   int k;
 966   unsigned char *r;
 967
 968   r = (unsigned char *) registers;
 969
 970   if (regno == -1)  /* write all registers */
 971     {
 972       j = 0;
 973       k = 18;
 974     }
 975   else              /* write one register */
 976     {
 977       j = regno;
 978       k = regno+1;
 979       r += regno * 4;
 980     }
 981
 982   if ((regno == -1) || (regno == 15))
 983     {
 984       /* fetch current status */
 985       send_with_reply ("SR", SR_buf, sizeof (SR_buf));
 986       p = SR_buf;
 987       p += 5;
 988       if (m68020)
 989         {
 990           if (*p == '3') /* use masterstackpointer MSP */
 991             {
 992               strcpy (stack_pointer,"MSP");
 993             }
 994           else
 995             {
 996               if (*p == '2') /* use interruptstackpointer ISP  */
 997                 {
 998                   strcpy (stack_pointer,"ISP");
 999                 }
1000               else
1001                 {
1002                   strcpy (stack_pointer,"USP");  /* use userstackpointer USP  */
1003                 }
1004             }
1005         }
1006       else  /* 68000-mode */
1007         {
1008           if (*p == '2') /* use supervisorstackpointer SSP  */
1009             {
1010               strcpy (stack_pointer,"SSP");
1011             }
1012           else
1013             {
1014               strcpy (stack_pointer,"USP");/* use userstackpointer USP  */
1015             }
1016         }
1017       strcpy (regtab[15],stack_pointer);
1018     }
1019
1020   for (i = j; i<k; i++)
1021     {
1022       buf[0] = regtab[i][0];
1023       buf[1] = regtab[i][1];
1024       buf[2] = regtab[i][2];
1025       buf[3] = '=';
1026       buf[4] = '$';
1027       buf[5] = tohex ((*r >> 4) & 0x0f);
1028       buf[6] = tohex (*r++ & 0x0f);
1029       buf[7] = tohex ((*r >> 4) & 0x0f);
1030       buf[8] = tohex (*r++ & 0x0f);
1031       buf[9] = tohex ((*r >> 4) & 0x0f);
1032       buf[10] = tohex (*r++ & 0x0f);
1033       buf[11] = tohex ((*r >> 4) & 0x0f);
1034       buf[12] = tohex (*r++ & 0x0f);
1035       buf[13] = 0;
1036
1037       send_with_reply (buf, buf, sizeof (buf)); /* FIXME, reply not used? */
1038     }
1039 }
1040
1041
1042 /* Prepare to store registers.  */
1043
1044 static void
1045 es1800_prepare_to_store ()
1046 {
1047   /* Do nothing, since we can store individual regs */
1048 }
1049
1050 /* Convert hex digit A to a number.  */
1051
1052 static int
1053 fromhex (a)
1054      int a;
1055 {
1056   if (a >= '0' && a <= '9')
1057     {
1058       return a - '0';
1059     }
1060   else if (a >= 'a' && a <= 'f')
1061     {
1062       return a - 'a' + 10;
1063     }
1064   else if (a >= 'A' && a <= 'F')
1065     {
1066       return a - 'A' + 10;
1067     }
1068   else
1069     {
1070       error ("Reply contains invalid hex digit");
1071     }
1072   return (-1);
1073 }
1074
1075
1076 /* Convert number NIB to a hex digit.  */
1077
1078 static int
1079 tohex (nib)
1080      int nib;
1081 {
1082   if (nib < 10)
1083     {
1084       return ('0' + nib);
1085     }
1086   else
1087     {
1088       return ('A' + nib - 10);
1089     }
1090 }
1091
1092 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
1093    to or from debugger address MYADDR.  Write to inferior if WRITE is
1094    nonzero.  Returns length of data written or read; 0 for error.
1095
1096    memaddr - the target's address
1097    myaddr  - gdb's address
1098    len     - number of bytes
1099    write   - write if != 0 otherwise read       */
1100
1101 static int
1102 es1800_xfer_inferior_memory (memaddr, myaddr, len, write, tops)
1103      CORE_ADDR memaddr;
1104      char *myaddr;
1105      int len;
1106      int write;
1107      struct target_ops *tops;   /* Unused */
1108 {
1109   int origlen = len;
1110   int xfersize;
1111
1112   while (len > 0)
1113     {
1114       xfersize = len > MAXBUFBYTES ? MAXBUFBYTES : len;
1115       if (write)
1116         {
1117           es1800_write_bytes (memaddr, myaddr, xfersize);
1118         }
1119       else
1120         {
1121           es1800_read_bytes (memaddr, myaddr, xfersize);
1122         }
1123       memaddr += xfersize;
1124       myaddr += xfersize;
1125       len -= xfersize;
1126     }
1127   return (origlen); /* no error possible */
1128 }
1129
1130
1131 /* Write memory data directly to the emulator.
1132    This does not inform the data cache; the data cache uses this.
1133    MEMADDR is the address in the remote memory space.
1134    MYADDR is the address of the buffer in our space.
1135    LEN is the number of bytes.
1136
1137    memaddr - the target's address
1138    myaddr  - gdb's address
1139    len     - number of bytes   */
1140
1141 static void
1142 es1800_write_bytes (memaddr, myaddr, len)
1143      CORE_ADDR memaddr;
1144      char *myaddr;
1145      int len;
1146 {
1147   char buf[PBUFSIZ];
1148   int i;
1149   char *p;
1150
1151   p = myaddr;
1152   for (i = 0; i < len; i++)
1153     {
1154       sprintf (buf, "@.B$%x=$%x", memaddr+i, (*p++) & 0xff);
1155       send_with_reply (buf, buf, sizeof (buf));      /* FIXME send_command? */
1156     }
1157 }
1158
1159
1160 /* Read memory data directly from the emulator.
1161    This does not use the data cache; the data cache uses this.
1162
1163    memaddr - the target's address
1164    myaddr  - gdb's address
1165    len     - number of bytes   */
1166
1167 static void
1168 es1800_read_bytes (memaddr, myaddr, len)
1169      CORE_ADDR memaddr;
1170      char *myaddr;
1171      int len;
1172 {
1173   static int DB_tab[16] = {8,11,14,17,20,23,26,29,34,37,40,43,46,49,52,55};
1174   char buf[PBUFSIZ];
1175   int i;
1176   int low_addr;
1177   char *p;
1178   char *b;
1179
1180   if (len > PBUFSIZ / 2 - 1)
1181     {
1182       abort ();
1183     }
1184
1185   if (len == 1) /* The emulator does not like expressions like:  */
1186     {
1187       len = 2;  /* DB.B $20018 TO $20018                       */
1188     }
1189
1190   /* Reply describes registers byte by byte, each byte encoded as two hex
1191      characters.  */
1192
1193   sprintf (buf, "DB.B $%x TO $%x", memaddr, memaddr+len-1);
1194   send_with_reply (buf, buf, sizeof (buf));
1195   b = buf;
1196   low_addr = memaddr&0x0f;
1197   for (i = low_addr; i < low_addr + len; i++)
1198     {
1199       if ((!(i % 16)) && i)
1200         {   /* if (i = 16,32,48)  */
1201           while (*p++!='\n') {;}
1202           b = p;
1203         }
1204       p = b + DB_tab[i%16] + (m68020 ? 2 : 0);
1205       if (p[0] == 32 || p[1] == 32)
1206         {
1207           error ("Emulator reply is too short: %s", buf);
1208         }
1209       myaddr[i-low_addr] = fromhex (p[0]) * 16 + fromhex (p[1]);
1210     }
1211 }
1212
1213 /* Information about the current target  */
1214
1215 static void
1216 es1800_files_info (tops)
1217      struct target_ops *tops;   /* Unused */
1218 {
1219   printf ("ES1800 Attached to %s at %d baud in %s mode\n", savename, 19200,
1220           MODE);
1221 }
1222
1223
1224 /* We read the contents of the target location and stash it,
1225    then overwrite it with a breakpoint instruction.
1226
1227    addr           - is the target location in the target machine.
1228    contents_cache - is a pointer to memory allocated for saving the target contents.
1229                     It is guaranteed by the caller to be long enough to save sizeof
1230                     BREAKPOINT bytes.
1231
1232    FIXME: This size is target_arch dependent and should be available in
1233    the target_arch transfer vector, if we ever have one...  */
1234
1235 static int
1236 es1800_insert_breakpoint (addr, contents_cache)
1237      CORE_ADDR addr;
1238      char *contents_cache;
1239 {
1240   int val;
1241
1242   val = target_read_memory (addr, contents_cache, sizeof (es1800_break_insn));
1243
1244   if (val == 0)
1245     {
1246       val = target_write_memory (addr, es1800_break_insn,
1247                                  sizeof (es1800_break_insn));
1248     }
1249
1250   return (val);
1251 }
1252
1253
1254 /* Write back the stashed instruction
1255
1256    addr           - is the target location in the target machine.
1257    contents_cache - is a pointer to memory allocated for saving the target contents.
1258                     It is guaranteed by the caller to be long enough to save sizeof
1259                     BREAKPOINT bytes.   */
1260
1261 static int
1262 es1800_remove_breakpoint (addr, contents_cache)
1263      CORE_ADDR addr;
1264      char *contents_cache;
1265 {
1266
1267   return (target_write_memory (addr, contents_cache,
1268                                sizeof (es1800_break_insn)));
1269 }
1270
1271 /* create_break_insn ()
1272    Primitive datastructures containing the es1800 breakpoint instruction  */
1273
1274 static void
1275 es1800_create_break_insn (ins, vec)
1276      char *ins;
1277      int vec;
1278 {
1279   if (vec == 15)
1280     {
1281       ins[0] = 0x4e;
1282       ins[1] = 0x4f;
1283     }
1284 }
1285
1286
1287 /* verify_break ()
1288    Seach for breakpoint routine in emulator memory.
1289    returns non-zero on failure
1290    vec - trap vector used for breakpoints  */
1291
1292 static int
1293 verify_break (vec)
1294      int vec;
1295 {
1296   CORE_ADDR memaddress;
1297   char buf[8];
1298   char *instr = "NqNqNqNs";      /* breakpoint routine */
1299   int status;
1300
1301   get_break_addr (vec, &memaddress);
1302
1303   if (memaddress)
1304     {
1305       status = target_read_memory (memaddress, buf, 8);
1306       if (status != 0)
1307         {
1308           memory_error (status, memaddress);
1309         }
1310       return (STRCMP (instr, buf));
1311     }
1312     return (-1);
1313 }
1314
1315
1316 /* get_break_addr ()
1317    find address of breakpint routine
1318    vec - trap vector used for breakpoints
1319    addrp - store the address here       */
1320
1321 static void
1322 get_break_addr (vec, addrp)
1323      int vec;
1324      CORE_ADDR *addrp;
1325 {
1326   CORE_ADDR memaddress = 0;
1327   int status;
1328   int k;
1329   char buf[PBUFSIZ];
1330   char base_addr[4];
1331   char *p;
1332
1333   if (m68020)
1334     {
1335       send_with_reply ("VBR ", buf, sizeof (buf));
1336       p = buf;
1337       for (k = 0; k < 4; k++)
1338         {
1339           if ((p[k*2 + 1] == 0) || (p[k*2 + 2] == 0))
1340             {
1341               error ("Emulator reply is too short: %s", buf);
1342             }
1343           base_addr[k] = (fromhex (p[k*2 + 1]) * 16) + fromhex (p[k*2 + 2]);
1344         }
1345       /* base addr of exception vector table */
1346       memaddress = *((CORE_ADDR *) base_addr);
1347     }
1348
1349     memaddress += (vec + 32) * 4;     /* address of trap vector */
1350     status = target_read_memory (memaddress, (char *) addrp, 4);
1351     if (status != 0)
1352       {
1353         memory_error (status, memaddress);
1354       }
1355 }
1356
1357
1358 /* Kill an inferior process */
1359
1360 static void
1361 es1800_kill ()
1362 {
1363   if (inferior_pid != 0)
1364     {
1365       inferior_pid = 0;
1366       es1800_mourn_inferior ();
1367     }
1368 }
1369
1370
1371 /* Load a file to the ES1800 emulator.
1372    Converts the file from a.out format into Extended Tekhex format
1373    before the file is loaded.
1374    Also loads the trap routine, and sets the ES1800 breakpoint on it
1375    filename - the a.out to be loaded
1376    from_tty - says whether to be verbose or not
1377    FIXME Uses emulator overlay memory for trap routine  */
1378
1379 static void
1380 es1800_load (filename, from_tty)
1381      char *filename;
1382      int from_tty;
1383 {
1384
1385   FILE *instream;
1386   char loadname[15];
1387   char buf[160];
1388   struct cleanup *old_chain;
1389   int es1800_load_format = 5;
1390
1391   if (es1800_desc < 0)
1392     {
1393       printf ("No emulator attached, type emulator-command first\n");
1394       return;
1395     }
1396
1397   filename = tilde_expand (filename);
1398   make_cleanup (free, filename);
1399
1400   switch (es1800_load_format)
1401     {
1402       case 2:   /* Extended Tekhex  */
1403         if (from_tty)
1404           {
1405             printf ("Converting \"%s\" to Extended Tekhex Format\n", filename);
1406           }
1407         sprintf (buf, "tekhex %s", filename);
1408         system (buf);
1409         sprintf (loadname, "out.hex");
1410         break;
1411
1412       case 5:   /* Motorola S-rec  */
1413         if (from_tty)
1414           {
1415             printf ("Converting \"%s\" to Motorola S-record format\n",
1416                     filename);
1417           }
1418         /* in the future the source code in copy (part of binutils-1.93) will
1419            be included in this file */
1420         sprintf (buf,
1421                  "copy -s \"a.out-sunos-big\" -d \"srec\" %s /tmp/out.hex",
1422                  filename);
1423         system (buf);
1424         sprintf (loadname, "/tmp/out.hex");
1425         break;
1426
1427       default:
1428         error ("Downloading format not defined\n");
1429     }
1430
1431   mark_breakpoints_out ();
1432   inferior_pid = 0;
1433   if (from_tty)
1434     {
1435       printf ("Downloading \"%s\" to the ES 1800\n",filename);
1436     }
1437   if ((instream = fopen (loadname, "r")) == NULL)
1438     {
1439       perror_with_name ("fopen:");
1440     }
1441
1442   old_chain = make_cleanup (fclose, instream);
1443   immediate_quit++;
1444
1445   es1800_reset (0);
1446
1447   download (instream, from_tty, es1800_load_format);
1448
1449   /* if breakpoint routine is not present anymore we have to check
1450      whether to download a new breakpoint routine or not */
1451
1452   if ((verify_break (es1800_break_vec) != 0)
1453       && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
1454     {
1455       char buf[128];
1456       printf ("Using break vector 0x%x\n", es1800_break_vec);
1457       sprintf (buf, "0x%x ", es1800_break_vec);
1458       printf ("Give the start address of the breakpoint routine: ");
1459       fgets (buf + strlen (buf), sizeof (buf) - strlen (buf), stdin);
1460       es1800_init_break (buf, 0);
1461     }
1462
1463   do_cleanups (old_chain);
1464   expect_prompt ();
1465   readchar ();  /* FIXME I am getting a ^G = 7 after the prompt  */
1466   printf ("\n");
1467
1468   if (fclose (instream) == EOF)
1469     {
1470       ;
1471     }
1472
1473   if (es1800_load_format != 2)
1474     {
1475       sprintf (buf, "/usr/bin/rm %s", loadname);
1476       system (buf);
1477     }
1478
1479   symbol_file_command (filename, from_tty);   /* reading symbol table */
1480   immediate_quit--;
1481 }
1482
1483 #if 0
1484
1485 #define NUMCPYBYTES 20
1486
1487 static void
1488 bfd_copy (from_bfd, to_bfd)
1489      bfd *from_bfd;
1490      bfd *to_bfd;
1491 {
1492   asection *p, *new;
1493   int i;
1494   char buf[NUMCPYBYTES];
1495
1496   for (p = from_bfd->sections; p != NULL; p = p->next)
1497     {
1498       printf ("  Copying section %s. Size = %x.\n", p->name, p->_cooked_size);
1499       printf ("    vma = %x,  offset = %x,  output_sec = %x\n",
1500               p->vma, p->output_offset, p->output_section);
1501       new = bfd_make_section (to_bfd, p->name);
1502       if (p->_cooked_size &&
1503           !bfd_set_section_size (to_bfd, new, p->_cooked_size))
1504         {
1505           error ("Wrong BFD size!\n");
1506         }
1507       if (!bfd_set_section_flags (to_bfd, new, p->flags))
1508         {
1509           error ("bfd_set_section_flags");
1510         }
1511       new->vma = p->vma;
1512
1513       for (i = 0; (i + NUMCPYBYTES) < p->_cooked_size ; i += NUMCPYBYTES)
1514         {
1515           if (!bfd_get_section_contents (from_bfd, p, (PTR) buf, (file_ptr) i,
1516                                         (bfd_size_type) NUMCPYBYTES))
1517             {
1518               error ("bfd_get_section_contents\n");
1519             }
1520         if (!bfd_set_section_contents (to_bfd, new, (PTR) buf, (file_ptr) i,
1521                                       (bfd_size_type) NUMCPYBYTES))
1522           {
1523             error ("bfd_set_section_contents\n");
1524           }
1525       }
1526       bfd_get_section_contents (from_bfd, p, (PTR) buf, (file_ptr) i,
1527                                 (bfd_size_type) (p->_cooked_size - i));
1528       bfd_set_section_contents (to_bfd, new, (PTR) buf,(file_ptr) i,
1529                                 (bfd_size_type) (p->_cooked_size - i));
1530     }
1531 }
1532
1533 #endif
1534
1535 /* Start an process on the es1800 and set inferior_pid to the new
1536    process' pid.
1537    execfile - the file to run
1538    args     - arguments passed to the program
1539    env      - the environment vector to pass    */
1540
1541 static void
1542 es1800_create_inferior (execfile, args, env)
1543      char *execfile;
1544      char *args;
1545      char **env;
1546 {
1547   int entry_pt;
1548   int pid;
1549 #if 0
1550   struct expression *expr;
1551   register struct cleanup *old_chain = 0;
1552   register value val;
1553 #endif
1554
1555   if (args && *args)
1556     {
1557       error ("Can't pass arguments to remote ES1800 process");
1558     }
1559
1560 #if 0
1561   if (query ("Use 'start' as entry point? "))
1562     {
1563       expr = parse_c_expression ("start");
1564       old_chain = make_cleanup (free_current_contents, &expr);
1565       val = evaluate_expression (expr);
1566       entry_pt = (val->location).address;
1567     }
1568   else
1569     {
1570       printf ("Enter the program's entry point (in hexadecimal): ");
1571       scanf ("%x", &entry_pt);
1572     }
1573 #endif
1574
1575   if (execfile == 0 || exec_bfd == 0)
1576     {
1577       error ("No exec file specified");
1578     }
1579
1580   entry_pt = (int) bfd_get_start_address (exec_bfd);
1581
1582   pid = 42;
1583
1584   /* Now that we have a child process, make it our target.  */
1585
1586   push_target (&es1800_child_ops);
1587
1588   /* The "process" (board) is already stopped awaiting our commands, and
1589      the program is already downloaded.  We just set its PC and go.  */
1590
1591   inferior_pid = pid;           /* Needed for wait_for_inferior below */
1592
1593   clear_proceed_status ();
1594
1595   /* Tell wait_for_inferior that we've started a new process.  */
1596
1597   init_wait_for_inferior ();
1598
1599   /* Set up the "saved terminal modes" of the inferior
1600      based on what modes we are starting it with.  */
1601
1602   target_terminal_init ();
1603
1604   /* Install inferior's terminal modes.  */
1605
1606   target_terminal_inferior ();
1607
1608   /* remote_start (args); */
1609   /* trap_expected = 0; */
1610   /* insert_step_breakpoint ();  FIXME, do we need this?  */
1611
1612   proceed ((CORE_ADDR) entry_pt, -1, 0);                /* Let 'er rip... */
1613
1614 }
1615
1616
1617 /* The process has died, clean up.  */
1618
1619 static void
1620 es1800_mourn_inferior ()
1621 {
1622   remove_breakpoints ();
1623   unpush_target (&es1800_child_ops);
1624   generic_mourn_inferior ();    /* Do all the proper things now */
1625 }
1626
1627 /* ES1800-protocol specific routines */
1628
1629 /* Keep discarding input from the remote system, until STRING is found.
1630    Let the user break out immediately.
1631    string - the string to expect
1632    nowait - break out if string not the emulator's first respond otherwise
1633             read until string is found (== 0)   */
1634
1635 static void
1636 expect (string, nowait)
1637      char *string;
1638     int nowait;
1639 {
1640   char c;
1641   char *p = string;
1642
1643   immediate_quit++;
1644   while (1)
1645     {
1646       c = readchar ();
1647       if (isalpha (c))
1648         {
1649           c = toupper (c);
1650         }
1651       if (c == toupper (*p))
1652         {
1653           p++;
1654           if (*p == '\0')
1655             {
1656               immediate_quit--;
1657               return;
1658             }
1659         }
1660       else if (!nowait)
1661         {
1662           p = string;
1663         }
1664       else
1665         {
1666           printf ("\'%s\' expected\n" , string);
1667           printf ("char %d is %d", p - string, c);
1668           error ("\n" );
1669         }
1670     }
1671 }
1672
1673 /* Keep discarding input until we see the prompt.  */
1674
1675 static void
1676 expect_prompt ()
1677 {
1678   expect (">", 0);
1679 }
1680
1681
1682 /* Read one character */
1683
1684 #ifdef DEBUG_STDIN
1685
1686 /* read from stdin */
1687
1688 static int
1689 readchar ()
1690 {
1691   char buf[1];
1692
1693   buf[0] = '\0';
1694   printf ("readchar, give one character\n");
1695   read (0, buf, 1);
1696
1697 #if defined (LOG_FILE)
1698   putc (buf[0] & 0x7f, log_file);
1699 #endif
1700
1701   return (buf[0] & 0x7f);
1702 }
1703
1704 #else   /* !DEBUG_STDIN */
1705
1706 /* Read a character from the remote system, doing all the fancy
1707    timeout stuff.  */
1708
1709 static int
1710 readchar ()
1711 {
1712   char buf[1];
1713
1714   buf[0] = '\0';
1715
1716 #ifdef HAVE_TERMIO
1717
1718   /* termio does the timeout for us.  */
1719   read (es1800_desc, buf, 1);
1720
1721 #else
1722
1723   alarm (timeout);
1724   while (read (es1800_desc, buf, 1) != 1)
1725     {
1726       if (errno == EINTR)
1727         {
1728           error ("Timeout reading from remote system.");
1729         }
1730       else if (errno != EWOULDBLOCK)
1731         {
1732           perror_with_name ("remote read");
1733         }
1734     }
1735   alarm (0);
1736 #endif
1737
1738 #if defined (LOG_FILE)
1739   putc (buf[0] & 0x7f, log_file);
1740   fflush (log_file);
1741 #endif
1742
1743   return (buf[0] & 0x7f);
1744 }
1745
1746 #endif  /* DEBUG_STDIN */
1747
1748
1749 /* Send a command to the emulator and save the reply.
1750    Report an error if we get an error reply.
1751    string - the es1800 command
1752    buf    - containing the emulator reply on return
1753    len    - size of buf  */
1754
1755 static void
1756 send_with_reply (string, buf, len)
1757     char *string, *buf;
1758     int len;
1759 {
1760   send (string);
1761   write (es1800_desc, "\r", 1);
1762
1763 #ifndef DEBUG_STDIN
1764   expect (string, 1);
1765   expect ("\r\n", 0);
1766 #endif
1767
1768   getmessage (buf, len);
1769 }
1770
1771
1772 /* Send the command in STR to the emulator adding \r. check
1773    the echo for consistency.
1774    string - the es1800 command  */
1775
1776 static void
1777 send_command (string)
1778      char *string;
1779 {
1780   send (string);
1781   write (es1800_desc, "\r", 1);
1782
1783 #ifndef DEBUG_STDIN
1784   expect (string, 0);
1785   expect_prompt ();
1786 #endif
1787
1788 }
1789
1790 /* Send a string
1791    string - the es1800 command  */
1792
1793 static void
1794 send (string)
1795      char *string;
1796 {
1797   if (kiodebug)
1798     {
1799       fprintf (stderr, "Sending: %s\n", string);
1800     }
1801   write (es1800_desc, string, strlen (string));
1802 }
1803
1804
1805 /* Read a message from the emulator and store it in BUF.
1806    buf    - containing the emulator reply on return
1807    len    - size of buf  */
1808
1809 static void
1810 getmessage (buf, len)
1811      char *buf;
1812      int len;
1813 {
1814   char *bp;
1815   int c;
1816   int prompt_found = 0;
1817   extern kiodebug;
1818
1819 #if defined (LOG_FILE)
1820   /* This is a convenient place to do this.  The idea is to do it often
1821      enough that we never lose much data if we terminate abnormally.  */
1822   fflush (log_file);
1823 #endif
1824
1825   bp = buf;
1826   c = readchar ();
1827   do
1828     {
1829       if (c)
1830         {
1831           if (len-- < 2) /* char and terminaling NULL */
1832             {
1833               error ("input buffer overrun\n");
1834             }
1835           *bp++ = c;
1836         }
1837       c = readchar ();
1838       if ((c == '>') && (*(bp - 1) == ' '))
1839         {
1840           prompt_found = 1;
1841         }
1842     }
1843   while (!prompt_found);
1844   *bp = 0;
1845
1846   if (kiodebug)
1847     {
1848       fprintf (stderr,"message received :%s\n", buf);
1849     }
1850 }
1851
1852 static void
1853 download (instream, from_tty, format)
1854 FILE *instream;
1855      int from_tty;
1856      int format;
1857 {
1858   char c;
1859   char buf[160];
1860   int i = 0;
1861
1862   send_command ("SET #2,$1A");                  /* reset char = ^Z */
1863   send_command ("SET #3,$11,$13");              /* XON  XOFF */
1864   if (format == 2)
1865     {
1866       send_command ("SET #26,#2");
1867     }
1868   else
1869     {
1870       send_command ("SET #26,#5");              /* Format=Extended Tekhex */
1871     }
1872   send_command ("DFB = $10");
1873   send_command ("PUR");
1874   send_command ("CES");
1875   send ("DNL\r");
1876   expect ("DNL", 1);
1877   if (from_tty)
1878     {
1879       printf ("    0 records loaded...\r");
1880     }
1881   while (fgets (buf, 160, instream))
1882       {
1883         send (buf);
1884         if (from_tty)
1885           {
1886             printf ("%5d\b\b\b\b\b",++i);
1887             fflush (stdout);
1888           }
1889         if ((c = readchar ()) != 006)
1890           {
1891             error ("expected ACK");
1892           }
1893       }
1894   if (from_tty)
1895     {
1896       printf ("- All");
1897     }
1898 }
1899
1900 /* Additional commands */
1901
1902 /* Talk directly to the emulator
1903    FIXME, uses busy wait, and is SUNOS (or at least BSD) specific  */
1904
1905 /*ARGSUSED*/
1906 static void
1907 es1800_transparent (args, from_tty)
1908      char *args;
1909      int from_tty;
1910 {
1911   int console;
1912   struct sgttyb modebl;
1913   int fcflag;
1914   int cc;
1915   struct sgttyb console_mode_save;
1916   int console_fc_save;
1917   int es1800_fc_save;
1918   int inputcnt = 80;
1919   char inputbuf[80];
1920   int consolecnt = 0;
1921   char consolebuf[80];
1922   int es1800_cnt = 0;
1923   char es1800_buf[80];
1924   int i;
1925
1926   dont_repeat ();
1927   if (es1800_desc < 0)
1928     {
1929       printf ("No emulator attached, type emulator-command first\n");
1930       return;
1931     }
1932
1933   printf ("\n");
1934   printf ("You are now communicating directly with the ES 1800 emulator.\n");
1935   printf ("To leave this mode (transparent mode), press ^E.\n");
1936   printf ("\n");
1937   printf (" >");
1938   fflush (stdout);
1939
1940   if ((console = open ("/dev/tty", O_RDWR)) == -1)
1941     {
1942       perror_with_name ("/dev/tty:");
1943     }
1944
1945   if ((fcflag = fcntl (console, F_GETFL, 0)) == -1)
1946     {
1947       perror_with_name ("fcntl console");
1948     }
1949
1950   console_fc_save = fcflag;
1951   fcflag = fcflag | FNDELAY;
1952
1953   if (fcntl (console, F_SETFL, fcflag) == -1)
1954     {
1955       perror_with_name ("fcntl console");
1956     }
1957
1958   if (ioctl (console, TIOCGETP, &modebl))
1959     {
1960       perror_with_name ("ioctl console");
1961     }
1962
1963   console_mode_save = modebl;
1964   modebl.sg_flags = RAW;
1965
1966   if (ioctl (console, TIOCSETP, &modebl))
1967     {
1968       perror_with_name ("ioctl console");
1969     }
1970
1971   if ((fcflag = fcntl (es1800_desc, F_GETFL, 0)) == -1)
1972     {
1973       perror_with_name ("fcntl serial");
1974     }
1975
1976   es1800_fc_save = fcflag;
1977   fcflag = fcflag | FNDELAY;
1978
1979   if (fcntl (es1800_desc, F_SETFL, fcflag) == -1)
1980     {
1981       perror_with_name ("fcntl serial");
1982     }
1983
1984   while (1)
1985     {
1986       cc = read (console, inputbuf, inputcnt);
1987       if (cc != -1)
1988         {
1989           if ((*inputbuf & 0x7f) == 0x05)
1990             {
1991               break;
1992             }
1993           for (i = 0; i < cc; )
1994             {
1995               es1800_buf[es1800_cnt++] = inputbuf[i++];
1996             }
1997           if ((cc = write (es1800_desc, es1800_buf, es1800_cnt)) == -1)
1998             {
1999               perror_with_name ("FEL! read:");
2000             }
2001           es1800_cnt -= cc;
2002           if (es1800_cnt && cc)
2003             {
2004               for (i = 0; i < es1800_cnt; i++)
2005                 {
2006                   es1800_buf[i] = es1800_buf[cc+i];
2007                 }
2008             }
2009         }
2010       else if (errno != EWOULDBLOCK)
2011         {
2012           perror_with_name ("FEL! read:");
2013         }
2014
2015       cc = read (es1800_desc,inputbuf,inputcnt);
2016       if (cc != -1)
2017         {
2018           for (i = 0; i < cc; )
2019             {
2020               consolebuf[consolecnt++] = inputbuf[i++];
2021             }
2022           if ((cc = write (console,consolebuf,consolecnt)) == -1)
2023             {
2024               perror_with_name ("FEL! write:");
2025             }
2026           consolecnt -= cc;
2027           if (consolecnt && cc)
2028             {
2029               for (i = 0; i < consolecnt; i++)
2030                 {
2031                   consolebuf[i] = consolebuf[cc+i];
2032                 }
2033             }
2034         }
2035       else if (errno != EWOULDBLOCK)
2036         {
2037           perror_with_name ("FEL! read:");
2038         }
2039     }
2040
2041   console_fc_save = console_fc_save & !FNDELAY;
2042   if (fcntl (console, F_SETFL, console_fc_save) == -1)
2043     {
2044       perror_with_name ("FEL! fcntl");
2045     }
2046
2047   if (ioctl (console, TIOCSETP, &console_mode_save))
2048     {
2049       perror_with_name ("FEL! ioctl");
2050     }
2051
2052   close (console);
2053
2054   if (fcntl (es1800_desc, F_SETFL, es1800_fc_save) == -1)
2055     {
2056       perror_with_name ("FEL! fcntl");
2057     }
2058
2059   printf ("\n");
2060
2061 }
2062
2063 static void
2064 es1800_init_break (args, from_tty)
2065      char *args;
2066      int from_tty;
2067 {
2068   CORE_ADDR memaddress = 0;
2069   char buf[PBUFSIZ];
2070   char base_addr[4];
2071   char *space_index;
2072   char *p;
2073   int k;
2074
2075   if (args == NULL)
2076     {
2077       error_no_arg ("a trap vector");
2078     }
2079
2080   if (!(space_index = strchr (args, ' ')))
2081     {
2082       error ("Two arguments needed (trap vector and address of break routine).\n");
2083     }
2084
2085   *space_index = '\0';
2086
2087   es1800_break_vec = strtol (args, (char **) NULL, 0);
2088   es1800_break_address = parse_and_eval_address (space_index + 1);
2089
2090   es1800_create_break_insn (es1800_break_insn, es1800_break_vec);
2091
2092   if (m68020)
2093     {
2094       send_with_reply ("VBR ", buf, sizeof (buf));
2095       p = buf;
2096       for (k = 0; k < 4; k++)
2097         {
2098           if ((p[k*2 + 1] == 0) || (p[k*2 + 2] == 0))
2099             {
2100               error ("Emulator reply is too short: %s", buf);
2101             }
2102           base_addr[k] = (fromhex (p[k*2 + 1]) * 16) + fromhex (p[k*2 + 2]);
2103         }
2104       /* base addr of exception vector table */
2105       memaddress =  *((CORE_ADDR *) base_addr);
2106     }
2107
2108   memaddress += (es1800_break_vec + 32) * 4;     /* address of trap vector */
2109
2110   sprintf (buf, "@.L%lx=$%lx", memaddress, es1800_break_address);
2111   send_command (buf);   /* set the address of the break routine in the */
2112                        /* trap vector */
2113
2114   sprintf (buf, "@.L%lx=$4E714E71", es1800_break_address);      /* NOP; NOP */
2115   send_command (buf);
2116   sprintf (buf, "@.L%lx=$4E714E73", es1800_break_address + 4);  /* NOP; RTE */
2117   send_command (buf);
2118
2119   sprintf (buf, "AC2=$%lx", es1800_break_address + 4);
2120   /* breakpoint at es1800-break_address */
2121   send_command (buf);
2122   send_command ("WHEN AC2 THEN BRK");          /* ie in exception routine */
2123
2124   if (from_tty)
2125     {
2126       printf ("Breakpoint (trap $%x) routine at address: %lx\n",
2127               es1800_break_vec, es1800_break_address);
2128     }
2129 }
2130
2131 static void
2132 es1800_child_open (arg, from_tty)
2133      char *arg;
2134      int from_tty;
2135 {
2136   error ("Use the \"run\" command to start a child process.");
2137 }
2138
2139 static void
2140 es1800_child_detach (args, from_tty)
2141      char *args;
2142      int from_tty;
2143 {
2144   if (args)
2145     {
2146       error ("Argument given to \"detach\" when remotely debugging.");
2147     }
2148
2149   pop_target ();
2150   if (from_tty)
2151     {
2152       printf ("Ending debugging the process %d.\n", inferior_pid);
2153     }
2154 }
2155
2156
2157 /* Define the target subroutine names  */
2158
2159 static struct target_ops es1800_ops =
2160 {
2161   "es1800",                     /* to_shortname */
2162                                 /* to_longname */
2163   "Remote serial target in ES1800-emulator protocol",
2164                                 /* to_doc */
2165   "Remote debugging on the es1800 emulator via a serial line.\n\
2166 Specify the serial device it is connected to (e.g. /dev/ttya).",
2167   es1800_open,                  /* to_open */
2168   es1800_close,                 /* to_close */
2169   es1800_attach,                /* to_attach */
2170   es1800_detach,                /* to_detach */
2171   es1800_resume,                /* to_resume */
2172   NULL,                         /* to_wait */
2173   NULL,                         /* to_fetch_registers */
2174   NULL,                         /* to_store_registers */
2175   es1800_prepare_to_store,      /* to_prepare_to_store */
2176   es1800_xfer_inferior_memory,  /* to_xfer_memory */
2177   es1800_files_info,            /* to_files_info */
2178   es1800_insert_breakpoint,     /* to_insert_breakpoint */
2179   es1800_remove_breakpoint,     /* to_remove_breakpoint */
2180   NULL,                         /* to_terminal_init */
2181   NULL,                         /* to_terminal_inferior */
2182   NULL,                         /* to_terminal_ours_for_output */
2183   NULL,                         /* to_terminal_ours */
2184   NULL,                         /* to_terminal_info */
2185   NULL,                         /* to_kill */
2186   es1800_load,                  /* to_load */
2187   NULL,                         /* to_lookup_symbol */
2188   es1800_create_inferior,       /* to_create_inferior */
2189   NULL,                         /* to_mourn_inferior */
2190   0,                            /* to_can_run */
2191   0,                            /* notice_signals */
2192   core_stratum,                 /* to_stratum */
2193   0,                            /* to_next */
2194   0,                            /* to_has_all_memory */
2195   1,                            /* to_has_memory */
2196   0,                            /* to_has_stack */
2197   0,                            /* to_has_registers */
2198   0,                            /* to_has_execution */
2199   NULL,                         /* to_sections */
2200   NULL,                         /* to_sections_end */
2201   OPS_MAGIC                     /* to_magic (always last) */
2202 };
2203
2204 /* Define the target subroutine names  */
2205
2206 static struct target_ops es1800_child_ops =
2207 {
2208   "es1800_process",             /* to_shortname */
2209                                 /* to_longname */
2210   "Remote serial target in ES1800-emulator protocol",
2211                                 /* to_doc */
2212   "Remote debugging on the es1800 emulator via a serial line.\n\
2213 Specify the serial device it is connected to (e.g. /dev/ttya).",
2214   es1800_child_open,            /* to_open */
2215   NULL,                         /* to_close */
2216   es1800_attach,                /* to_attach */
2217   es1800_child_detach,          /* to_detach */
2218   es1800_resume,                /* to_resume */
2219   es1800_wait,                  /* to_wait */
2220   es1800_fetch_register,        /* to_fetch_registers */
2221   es1800_store_register,        /* to_store_registers */
2222   es1800_prepare_to_store,      /* to_prepare_to_store */
2223   es1800_xfer_inferior_memory,  /* to_xfer_memory */
2224   es1800_files_info,            /* to_files_info */
2225   es1800_insert_breakpoint,     /* to_insert_breakpoint */
2226   es1800_remove_breakpoint,     /* to_remove_breakpoint */
2227   NULL,                         /* to_terminal_init */
2228   NULL,                         /* to_terminal_inferior */
2229   NULL,                         /* to_terminal_ours_for_output */
2230   NULL,                         /* to_terminal_ours */
2231   NULL,                         /* to_terminal_info */
2232   es1800_kill,                  /* to_kill */
2233   es1800_load,                  /* to_load */
2234   NULL,                         /* to_lookup_symbol */
2235   es1800_create_inferior,       /* to_create_inferior */
2236   es1800_mourn_inferior,        /* to_mourn_inferior */
2237   0,                            /* to_can_run */
2238   0,                            /* notice_signals */
2239   process_stratum,              /* to_stratum */
2240   0,                            /* to_next */
2241   1,                            /* to_has_all_memory */
2242   1,                            /* to_has_memory */
2243   1,                            /* to_has_stack */
2244   1,                            /* to_has_registers */
2245   1,                            /* to_has_execution */
2246   NULL,                         /* to_sections */
2247   NULL,                         /* to_sections_end */
2248   OPS_MAGIC                     /* to_magic (always last) */
2249 };
2250
2251 /* _initialize_es1800 ()  */
2252
2253 void
2254 _initialize_es1800 ()
2255 {
2256   add_target (&es1800_ops);
2257   add_target (&es1800_child_ops);
2258   add_com ("transparent", class_support, es1800_transparent,
2259            "Start transparent communication with the ES 1800 emulator.");
2260   add_com ("init_break", class_support, es1800_init_break,
2261            "Download break routine and initialize break facility on ES 1800");
2262 }