gdb/remote-eb.c

   1 /* Remote debugging interface for AMD 29000 EBMON on IBM PC, for GDB.
   2    Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.  Written by Jim Kingdon for Cygnus.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* This is like remote.c but is for an esoteric situation--
  22    having a a29k board in a PC hooked up to a unix machine with
  23    a serial line, and running ctty com1 on the PC, through which
  24    the unix machine can run ebmon.  Not to mention that the PC
  25    has PC/NFS, so it can access the same executables that gdb can,
  26    over the net in real time.  */
  27
  28 #include "defs.h"
  29 #include <string.h>
  30
  31 #include "inferior.h"
  32 #include "bfd.h"
  33 #include "symfile.h"
  34 #include "wait.h"
  35 #include "value.h"
  36 #include <ctype.h>
  37 #include <fcntl.h>
  38 #include <signal.h>
  39 #include <errno.h>
  40 #include "terminal.h"
  41 #include "target.h"
  42 #include "gdbcore.h"
  43
  44 extern struct target_ops eb_ops;                /* Forward declaration */
  45
  46 static void eb_close();
  47
  48 #define LOG_FILE "eb.log"
  49 #if defined (LOG_FILE)
  50 FILE *log_file;
  51 #endif
  52
  53 static int timeout = 24;
  54
  55 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
  56    eb_open knows that we don't have a file open when the program
  57    starts.  */
  58 int eb_desc = -1;
  59
  60 /* stream which is fdopen'd from eb_desc.  Only valid when
  61    eb_desc != -1.  */
  62 FILE *eb_stream;
  63
  64 /* Read a character from the remote system, doing all the fancy
  65    timeout stuff.  */
  66 static int
  67 readchar ()
  68 {
  69   char buf;
  70
  71   buf = '\0';
  72 #ifdef HAVE_TERMIO
  73   /* termio does the timeout for us.  */
  74   read (eb_desc, &buf, 1);
  75 #else
  76   alarm (timeout);
  77   if (read (eb_desc, &buf, 1) < 0)
  78     {
  79       if (errno == EINTR)
  80         error ("Timeout reading from remote system.");
  81       else
  82         perror_with_name ("remote");
  83     }
  84   alarm (0);
  85 #endif
  86
  87   if (buf == '\0')
  88     error ("Timeout reading from remote system.");
  89 #if defined (LOG_FILE)
  90   putc (buf & 0x7f, log_file);
  91 #endif
  92   return buf & 0x7f;
  93 }
  94
  95 /* Keep discarding input from the remote system, until STRING is found.
  96    Let the user break out immediately.  */
  97 static void
  98 expect (string)
  99      char *string;
 100 {
 101   char *p = string;
 102
 103   immediate_quit = 1;
 104   while (1)
 105     {
 106       if (readchar() == *p)
 107         {
 108           p++;
 109           if (*p == '\0')
 110             {
 111               immediate_quit = 0;
 112               return;
 113             }
 114         }
 115       else
 116         p = string;
 117     }
 118 }
 119
 120 /* Keep discarding input until we see the ebmon prompt.
 121
 122    The convention for dealing with the prompt is that you
 123    o give your command
 124    o *then* wait for the prompt.
 125
 126    Thus the last thing that a procedure does with the serial line
 127    will be an expect_prompt().  Exception:  eb_resume does not
 128    wait for the prompt, because the terminal is being handed over
 129    to the inferior.  However, the next thing which happens after that
 130    is a eb_wait which does wait for the prompt.
 131    Note that this includes abnormal exit, e.g. error().  This is
 132    necessary to prevent getting into states from which we can't
 133    recover.  */
 134 static void
 135 expect_prompt ()
 136 {
 137 #if defined (LOG_FILE)
 138   /* This is a convenient place to do this.  The idea is to do it often
 139      enough that we never lose much data if we terminate abnormally.  */
 140   fflush (log_file);
 141 #endif
 142   expect ("\n# ");
 143 }
 144
 145 /* Get a hex digit from the remote system & return its value.
 146    If ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
 147 static int
 148 get_hex_digit (ignore_space)
 149      int ignore_space;
 150 {
 151   int ch;
 152   while (1)
 153     {
 154       ch = readchar ();
 155       if (ch >= '0' && ch <= '9')
 156         return ch - '0';
 157       else if (ch >= 'A' && ch <= 'F')
 158         return ch - 'A' + 10;
 159       else if (ch >= 'a' && ch <= 'f')
 160         return ch - 'a' + 10;
 161       else if (ch == ' ' && ignore_space)
 162         ;
 163       else
 164         {
 165           expect_prompt ();
 166           error ("Invalid hex digit from remote system.");
 167         }
 168     }
 169 }
 170
 171 /* Get a byte from eb_desc and put it in *BYT.  Accept any number
 172    leading spaces.  */
 173 static void
 174 get_hex_byte (byt)
 175      char *byt;
 176 {
 177   int val;
 178
 179   val = get_hex_digit (1) << 4;
 180   val |= get_hex_digit (0);
 181   *byt = val;
 182 }
 183
 184 /* Get N 32-bit words from remote, each preceded by a space,
 185    and put them in registers starting at REGNO.  */
 186 static void
 187 get_hex_regs (n, regno)
 188      int n;
 189      int regno;
 190 {
 191   long val;
 192   int i;
 193
 194   for (i = 0; i < n; i++)
 195     {
 196       int j;
 197
 198       val = 0;
 199       for (j = 0; j < 8; j++)
 200         val = (val << 4) + get_hex_digit (j == 0);
 201       supply_register (regno++, (char *) &val);
 202     }
 203 }
 204
 205 /* Called when SIGALRM signal sent due to alarm() timeout.  */
 206 #ifndef HAVE_TERMIO
 207
 208 #ifndef __STDC__
 209 #define volatile /**/
 210 #endif
 211 volatile int n_alarms;
 212
 213 void
 214 eb_timer ()
 215 {
 216 #if 0
 217   if (kiodebug)
 218     printf ("eb_timer called\n");
 219 #endif
 220   n_alarms++;
 221 }
 222 #endif
 223
 224 /* malloc'd name of the program on the remote system.  */
 225 static char *prog_name = NULL;
 226
 227 /* Nonzero if we have loaded the file ("yc") and not yet issued a "gi"
 228    command.  "gi" is supposed to happen exactly once for each "yc".  */
 229 static int need_gi = 0;
 230
 231 /* Number of SIGTRAPs we need to simulate.  That is, the next
 232    NEED_ARTIFICIAL_TRAP calls to eb_wait should just return
 233    SIGTRAP without actually waiting for anything.  */
 234
 235 static int need_artificial_trap = 0;
 236
 237 /* This is called not only when we first attach, but also when the
 238    user types "run" after having attached.  */
 239 static void
 240 eb_create_inferior (execfile, args, env)
 241      char *execfile;
 242      char *args;
 243      char **env;
 244 {
 245   int entry_pt;
 246
 247   if (args && *args)
 248     error ("Can't pass arguments to remote EBMON process");
 249
 250   if (execfile == 0 || exec_bfd == 0)
 251     error ("No exec file specified");
 252
 253   entry_pt = (int) bfd_get_start_address (exec_bfd);
 254
 255   {
 256     /* OK, now read in the file.  Y=read, C=COFF, D=no symbols
 257        0=start address, %s=filename.  */
 258
 259     fprintf (eb_stream, "YC D,0:%s", prog_name);
 260
 261     if (args != NULL)
 262         fprintf(eb_stream, " %s", args);
 263
 264     fprintf (eb_stream, "\n");
 265     fflush (eb_stream);
 266
 267     expect_prompt ();
 268
 269     need_gi = 1;
 270   }
 271
 272 /* The "process" (board) is already stopped awaiting our commands, and
 273    the program is already downloaded.  We just set its PC and go.  */
 274
 275   clear_proceed_status ();
 276
 277   /* Tell wait_for_inferior that we've started a new process.  */
 278   init_wait_for_inferior ();
 279
 280   /* Set up the "saved terminal modes" of the inferior
 281      based on what modes we are starting it with.  */
 282   target_terminal_init ();
 283
 284   /* Install inferior's terminal modes.  */
 285   target_terminal_inferior ();
 286
 287   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 288   proceed ((CORE_ADDR)entry_pt, -1, 0);         /* Let 'er rip... */
 289 }
 290
 291 /* Translate baud rates from integers to damn B_codes.  Unix should
 292    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 293
 294 #ifndef B19200
 295 #define B19200 EXTA
 296 #endif
 297 #ifndef B38400
 298 #define B38400 EXTB
 299 #endif
 300
 301 struct {int rate, damn_b;} baudtab[] = {
 302         {0, B0},
 303         {50, B50},
 304         {75, B75},
 305         {110, B110},
 306         {134, B134},
 307         {150, B150},
 308         {200, B200},
 309         {300, B300},
 310         {600, B600},
 311         {1200, B1200},
 312         {1800, B1800},
 313         {2400, B2400},
 314         {4800, B4800},
 315         {9600, B9600},
 316         {19200, B19200},
 317         {38400, B38400},
 318         {-1, -1},
 319 };
 320
 321 int damn_b (rate)
 322      int rate;
 323 {
 324   int i;
 325
 326   for (i = 0; baudtab[i].rate != -1; i++)
 327     if (rate == baudtab[i].rate) return baudtab[i].damn_b;
 328   return B38400;        /* Random */
 329 }
 330
 331
 332 /* Open a connection to a remote debugger.
 333    NAME is the filename used for communication, then a space,
 334    then the name of the program as we should name it to EBMON.  */
 335
 336 static int baudrate = 9600;
 337 static char *dev_name;
 338 void
 339 eb_open (name, from_tty)
 340      char *name;
 341      int from_tty;
 342 {
 343   TERMINAL sg;
 344
 345   char *p;
 346
 347   target_preopen (from_tty);
 348
 349   /* Find the first whitespace character, it separates dev_name from
 350      prog_name.  */
 351   if (name == 0)
 352     goto erroid;
 353
 354   for (p = name;
 355        *p != '\0' && !isspace (*p); p++)
 356     ;
 357   if (*p == '\0')
 358 erroid:
 359     error ("\
 360 Please include the name of the device for the serial port,\n\
 361 the baud rate, and the name of the program to run on the remote system.");
 362   dev_name = alloca (p - name + 1);
 363   strncpy (dev_name, name, p - name);
 364   dev_name[p - name] = '\0';
 365
 366   /* Skip over the whitespace after dev_name */
 367   for (; isspace (*p); p++)
 368     /*EMPTY*/;
 369
 370   if (1 != sscanf (p, "%d ", &baudrate))
 371     goto erroid;
 372
 373   /* Skip the number and then the spaces */
 374   for (; isdigit (*p); p++)
 375     /*EMPTY*/;
 376   for (; isspace (*p); p++)
 377     /*EMPTY*/;
 378
 379   if (prog_name != NULL)
 380     free (prog_name);
 381   prog_name = savestring (p, strlen (p));
 382
 383   eb_close (0);
 384
 385   eb_desc = open (dev_name, O_RDWR);
 386   if (eb_desc < 0)
 387     perror_with_name (dev_name);
 388   ioctl (eb_desc, TIOCGETP, &sg);
 389 #ifdef HAVE_TERMIO
 390   sg.c_cc[VMIN] = 0;            /* read with timeout.  */
 391   sg.c_cc[VTIME] = timeout * 10;
 392   sg.c_lflag &= ~(ICANON | ECHO);
 393   sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);
 394 #else
 395   sg.sg_ispeed = damn_b (baudrate);
 396   sg.sg_ospeed = damn_b (baudrate);
 397   sg.sg_flags |= RAW | ANYP;
 398   sg.sg_flags &= ~ECHO;
 399 #endif
 400
 401   ioctl (eb_desc, TIOCSETP, &sg);
 402   eb_stream = fdopen (eb_desc, "r+");
 403
 404   push_target (&eb_ops);
 405   if (from_tty)
 406     printf ("Remote %s debugging %s using %s\n", target_shortname,
 407             prog_name, dev_name);
 408
 409 #ifndef HAVE_TERMIO
 410 #ifndef NO_SIGINTERRUPT
 411   /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
 412      the read.  */
 413   if (siginterrupt (SIGALRM, 1) != 0)
 414     perror ("eb_open: error in siginterrupt");
 415 #endif
 416
 417   /* Set up read timeout timer.  */
 418   if ((void (*)) signal (SIGALRM, eb_timer) == (void (*)) -1)
 419     perror ("eb_open: error in signal");
 420 #endif
 421
 422 #if defined (LOG_FILE)
 423   log_file = fopen (LOG_FILE, "w");
 424   if (log_file == NULL)
 425     perror_with_name (LOG_FILE);
 426 #endif
 427
 428   /* Hello?  Are you there?  */
 429   write (eb_desc, "\n", 1);
 430
 431   expect_prompt ();
 432 }
 433
 434 /* Close out all files and local state before this target loses control. */
 435
 436 static void
 437 eb_close (quitting)
 438      int quitting;
 439 {
 440
 441   /* Due to a bug in Unix, fclose closes not only the stdio stream,
 442      but also the file descriptor.  So we don't actually close
 443      eb_desc.  */
 444   if (eb_stream)
 445     fclose (eb_stream); /* This also closes eb_desc */
 446   if (eb_desc >= 0)
 447     /* close (eb_desc); */
 448
 449   /* Do not try to close eb_desc again, later in the program.  */
 450   eb_stream = NULL;
 451   eb_desc = -1;
 452
 453 #if defined (LOG_FILE)
 454   if (log_file) {
 455     if (ferror (log_file))
 456       printf ("Error writing log file.\n");
 457     if (fclose (log_file) != 0)
 458       printf ("Error closing log file.\n");
 459   }
 460 #endif
 461 }
 462
 463 /* Terminate the open connection to the remote debugger.
 464    Use this when you want to detach and do something else
 465    with your gdb.  */
 466 void
 467 eb_detach (from_tty)
 468      int from_tty;
 469 {
 470   pop_target();         /* calls eb_close to do the real work */
 471   if (from_tty)
 472     printf ("Ending remote %s debugging\n", target_shortname);
 473 }
 474
 475 /* Tell the remote machine to resume.  */
 476
 477 void
 478 eb_resume (pid, step, sig)
 479      int pid, step, sig;
 480 {
 481   if (step)
 482     {
 483       write (eb_desc, "t 1,s\n", 6);
 484       /* Wait for the echo.  */
 485       expect ("t 1,s\r");
 486       /* Then comes a line containing the instruction we stepped to.  */
 487       expect ("\n@");
 488       /* Then we get the prompt.  */
 489       expect_prompt ();
 490
 491       /* Force the next eb_wait to return a trap.  Not doing anything
 492          about I/O from the target means that the user has to type
 493          "continue" to see any.  This should be fixed.  */
 494       need_artificial_trap = 1;
 495     }
 496   else
 497     {
 498       if (need_gi)
 499         {
 500           need_gi = 0;
 501           write (eb_desc, "gi\n", 3);
 502
 503           /* Swallow the echo of "gi".  */
 504           expect ("gi\r");
 505         }
 506       else
 507         {
 508           write (eb_desc, "GR\n", 3);
 509           /* Swallow the echo.  */
 510           expect ("GR\r");
 511         }
 512     }
 513 }
 514
 515 /* Wait until the remote machine stops, then return,
 516    storing status in STATUS just as `wait' would.  */
 517
 518 int
 519 eb_wait (status)
 520      WAITTYPE *status;
 521 {
 522   /* Strings to look for.  '?' means match any single character.
 523      Note that with the algorithm we use, the initial character
 524      of the string cannot recur in the string, or we will not
 525      find some cases of the string in the input.  */
 526
 527   static char bpt[] = "Invalid interrupt taken - #0x50 - ";
 528   /* It would be tempting to look for "\n[__exit + 0x8]\n"
 529      but that requires loading symbols with "yc i" and even if
 530      we did do that we don't know that the file has symbols.  */
 531   static char exitmsg[] = "\n@????????I    JMPTI     GR121,LR0";
 532   char *bp = bpt;
 533   char *ep = exitmsg;
 534
 535   /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars.  */
 536   char swallowed[50];
 537   /* Current position in swallowed.  */
 538   char *swallowed_p = swallowed;
 539
 540   int ch;
 541   int ch_handled;
 542
 543   int old_timeout = timeout;
 544
 545   WSETEXIT ((*status), 0);
 546
 547   if (need_artificial_trap != 0)
 548     {
 549       WSETSTOP ((*status), SIGTRAP);
 550       need_artificial_trap--;
 551       return 0;
 552     }
 553
 554   timeout = 0;          /* Don't time out -- user program is running. */
 555   while (1)
 556     {
 557       ch_handled = 0;
 558       ch = readchar ();
 559       if (ch == *bp)
 560         {
 561           bp++;
 562           if (*bp == '\0')
 563             break;
 564           ch_handled = 1;
 565
 566           *swallowed_p++ = ch;
 567         }
 568       else
 569         bp = bpt;
 570
 571       if (ch == *ep || *ep == '?')
 572         {
 573           ep++;
 574           if (*ep == '\0')
 575             break;
 576
 577           if (!ch_handled)
 578             *swallowed_p++ = ch;
 579           ch_handled = 1;
 580         }
 581       else
 582         ep = exitmsg;
 583
 584       if (!ch_handled)
 585         {
 586           char *p;
 587
 588           /* Print out any characters which have been swallowed.  */
 589           for (p = swallowed; p < swallowed_p; ++p)
 590             putc (*p, stdout);
 591           swallowed_p = swallowed;
 592
 593           putc (ch, stdout);
 594         }
 595     }
 596   expect_prompt ();
 597   if (*bp== '\0')
 598     WSETSTOP ((*status), SIGTRAP);
 599   else
 600     WSETEXIT ((*status), 0);
 601   timeout = old_timeout;
 602
 603   return 0;
 604 }
 605
 606 /* Return the name of register number REGNO
 607    in the form input and output by EBMON.
 608
 609    Returns a pointer to a static buffer containing the answer.  */
 610 static char *
 611 get_reg_name (regno)
 612      int regno;
 613 {
 614   static char buf[80];
 615   if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
 616     sprintf (buf, "GR%03d", regno - GR96_REGNUM + 96);
 617   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
 618     sprintf (buf, "LR%03d", regno - LR0_REGNUM);
 619   else if (regno == Q_REGNUM)
 620     strcpy (buf, "SR131");
 621   else if (regno >= BP_REGNUM && regno <= CR_REGNUM)
 622     sprintf (buf, "SR%03d", regno - BP_REGNUM + 133);
 623   else if (regno == ALU_REGNUM)
 624     strcpy (buf, "SR132");
 625   else if (regno >= IPC_REGNUM && regno <= IPB_REGNUM)
 626     sprintf (buf, "SR%03d", regno - IPC_REGNUM + 128);
 627   else if (regno >= VAB_REGNUM && regno <= LRU_REGNUM)
 628     sprintf (buf, "SR%03d", regno - VAB_REGNUM);
 629   else if (regno == GR1_REGNUM)
 630     strcpy (buf, "GR001");
 631   return buf;
 632 }
 633
 634 /* Read the remote registers into the block REGS.  */
 635
 636 static void
 637 eb_fetch_registers ()
 638 {
 639   int reg_index;
 640   int regnum_index;
 641   char tempbuf[10];
 642   int i;
 643
 644 #if 0
 645   /* This should not be necessary, because one is supposed to read the
 646      registers only when the inferior is stopped (at least with
 647      ptrace() and why not make it the same for remote?).  */
 648   /* ^A is the "normal character" used to make sure we are talking to EBMON
 649      and not to the program being debugged.  */
 650   write (eb_desc, "\001\n");
 651   expect_prompt ();
 652 #endif
 653
 654   write (eb_desc, "dw gr96,gr127\n", 14);
 655   for (reg_index = 96, regnum_index = GR96_REGNUM;
 656        reg_index < 128;
 657        reg_index += 4, regnum_index += 4)
 658     {
 659       sprintf (tempbuf, "GR%03d ", reg_index);
 660       expect (tempbuf);
 661       get_hex_regs (4, regnum_index);
 662       expect ("\n");
 663     }
 664
 665   for (i = 0; i < 128; i += 32)
 666     {
 667       /* The PC has a tendency to hang if we get these
 668          all in one fell swoop ("dw lr0,lr127").  */
 669       sprintf (tempbuf, "dw lr%d\n", i);
 670       write (eb_desc, tempbuf, strlen (tempbuf));
 671       for (reg_index = i, regnum_index = LR0_REGNUM + i;
 672            reg_index < i + 32;
 673            reg_index += 4, regnum_index += 4)
 674         {
 675           sprintf (tempbuf, "LR%03d ", reg_index);
 676           expect (tempbuf);
 677           get_hex_regs (4, regnum_index);
 678           expect ("\n");
 679         }
 680     }
 681
 682   write (eb_desc, "dw sr133,sr133\n", 15);
 683   expect ("SR133          ");
 684   get_hex_regs (1, BP_REGNUM);
 685   expect ("\n");
 686
 687   write (eb_desc, "dw sr134,sr134\n", 15);
 688   expect ("SR134                   ");
 689   get_hex_regs (1, FC_REGNUM);
 690   expect ("\n");
 691
 692   write (eb_desc, "dw sr135,sr135\n", 15);
 693   expect ("SR135                            ");
 694   get_hex_regs (1, CR_REGNUM);
 695   expect ("\n");
 696
 697   write (eb_desc, "dw sr131,sr131\n", 15);
 698   expect ("SR131                            ");
 699   get_hex_regs (1, Q_REGNUM);
 700   expect ("\n");
 701
 702   write (eb_desc, "dw sr0,sr14\n", 12);
 703   for (reg_index = 0, regnum_index = VAB_REGNUM;
 704        regnum_index <= LRU_REGNUM;
 705        regnum_index += 4, reg_index += 4)
 706     {
 707       sprintf (tempbuf, "SR%03d ", reg_index);
 708       expect (tempbuf);
 709       get_hex_regs (reg_index == 12 ? 3 : 4, regnum_index);
 710       expect ("\n");
 711     }
 712
 713   /* There doesn't seem to be any way to get these.  */
 714   {
 715     int val = -1;
 716     supply_register (FPE_REGNUM, (char *) &val);
 717     supply_register (INTE_REGNUM, (char *) &val);
 718     supply_register (FPS_REGNUM, (char *) &val);
 719     supply_register (EXO_REGNUM, (char *) &val);
 720   }
 721
 722   write (eb_desc, "dw gr1,gr1\n", 11);
 723   expect ("GR001 ");
 724   get_hex_regs (1, GR1_REGNUM);
 725   expect_prompt ();
 726 }
 727
 728 /* Fetch register REGNO, or all registers if REGNO is -1.
 729    Returns errno value.  */
 730 void
 731 eb_fetch_register (regno)
 732      int regno;
 733 {
 734   if (regno == -1)
 735     eb_fetch_registers ();
 736   else
 737     {
 738       char *name = get_reg_name (regno);
 739       fprintf (eb_stream, "dw %s,%s\n", name, name);
 740       expect (name);
 741       expect (" ");
 742       get_hex_regs (1, regno);
 743       expect_prompt ();
 744     }
 745   return;
 746 }
 747
 748 /* Store the remote registers from the contents of the block REGS.  */
 749
 750 static void
 751 eb_store_registers ()
 752 {
 753   int i, j;
 754   fprintf (eb_stream, "s gr1,%x\n", read_register (GR1_REGNUM));
 755   expect_prompt ();
 756
 757   for (j = 0; j < 32; j += 16)
 758     {
 759       fprintf (eb_stream, "s gr%d,", j + 96);
 760       for (i = 0; i < 15; ++i)
 761         fprintf (eb_stream, "%x,", read_register (GR96_REGNUM + j + i));
 762       fprintf (eb_stream, "%x\n", read_register (GR96_REGNUM + j + 15));
 763       expect_prompt ();
 764     }
 765
 766   for (j = 0; j < 128; j += 16)
 767     {
 768       fprintf (eb_stream, "s lr%d,", j);
 769       for (i = 0; i < 15; ++i)
 770         fprintf (eb_stream, "%x,", read_register (LR0_REGNUM + j + i));
 771       fprintf (eb_stream, "%x\n", read_register (LR0_REGNUM + j + 15));
 772       expect_prompt ();
 773     }
 774
 775   fprintf (eb_stream, "s sr133,%x,%x,%x\n", read_register (BP_REGNUM),
 776            read_register (FC_REGNUM), read_register (CR_REGNUM));
 777   expect_prompt ();
 778   fprintf (eb_stream, "s sr131,%x\n", read_register (Q_REGNUM));
 779   expect_prompt ();
 780   fprintf (eb_stream, "s sr0,");
 781   for (i = 0; i < 11; ++i)
 782     fprintf (eb_stream, "%x,", read_register (VAB_REGNUM + i));
 783   fprintf (eb_stream, "%x\n", read_register (VAB_REGNUM + 11));
 784   expect_prompt ();
 785 }
 786
 787 /* Store register REGNO, or all if REGNO == 0.
 788    Return errno value.  */
 789 void
 790 eb_store_register (regno)
 791      int regno;
 792 {
 793   if (regno == -1)
 794     eb_store_registers ();
 795   else
 796     {
 797       char *name = get_reg_name (regno);
 798       fprintf (eb_stream, "s %s,%x\n", name, read_register (regno));
 799       /* Setting GR1 changes the numbers of all the locals, so
 800          invalidate the register cache.  Do this *after* calling
 801          read_register, because we want read_register to return the
 802          value that write_register has just stuffed into the registers
 803          array, not the value of the register fetched from the
 804          inferior.  */
 805       if (regno == GR1_REGNUM)
 806         registers_changed ();
 807       expect_prompt ();
 808     }
 809 }
 810
 811 /* Get ready to modify the registers array.  On machines which store
 812    individual registers, this doesn't need to do anything.  On machines
 813    which store all the registers in one fell swoop, this makes sure
 814    that registers contains all the registers from the program being
 815    debugged.  */
 816
 817 void
 818 eb_prepare_to_store ()
 819 {
 820   /* Do nothing, since we can store individual regs */
 821 }
 822
 823
 824 /* FIXME-someday!  Merge these two.  */
 825 int
 826 eb_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 827      CORE_ADDR memaddr;
 828      char *myaddr;
 829      int len;
 830      int write;
 831      struct target_ops *target;         /* ignored */
 832 {
 833   if (write)
 834     return eb_write_inferior_memory (memaddr, myaddr, len);
 835   else
 836     return eb_read_inferior_memory (memaddr, myaddr, len);
 837 }
 838
 839 void
 840 eb_files_info ()
 841 {
 842   printf ("\tAttached to %s at %d baud and running program %s.\n",
 843           dev_name, baudrate, prog_name);
 844 }
 845
 846 /* Copy LEN bytes of data from debugger memory at MYADDR
 847    to inferior's memory at MEMADDR.  Returns length moved.  */
 848 int
 849 eb_write_inferior_memory (memaddr, myaddr, len)
 850      CORE_ADDR memaddr;
 851      char *myaddr;
 852      int len;
 853 {
 854   int i;
 855
 856   for (i = 0; i < len; i++)
 857     {
 858       if ((i % 16) == 0)
 859         fprintf (eb_stream, "sb %x,", memaddr + i);
 860       if ((i % 16) == 15 || i == len - 1)
 861         {
 862           fprintf (eb_stream, "%x\n", ((unsigned char *)myaddr)[i]);
 863           expect_prompt ();
 864         }
 865       else
 866         fprintf (eb_stream, "%x,", ((unsigned char *)myaddr)[i]);
 867     }
 868   return len;
 869 }
 870
 871 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
 872    at debugger address MYADDR.  Returns length moved.  */
 873 int
 874 eb_read_inferior_memory(memaddr, myaddr, len)
 875      CORE_ADDR memaddr;
 876      char *myaddr;
 877      int len;
 878 {
 879   int i;
 880
 881   /* Number of bytes read so far.  */
 882   int count;
 883
 884   /* Starting address of this pass.  */
 885   unsigned long startaddr;
 886
 887   /* Number of bytes to read in this pass.  */
 888   int len_this_pass;
 889
 890   /* Note that this code works correctly if startaddr is just less
 891      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
 892      thing).  That is, something like
 893      eb_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
 894      works--it never adds len to memaddr and gets 0.  */
 895   /* However, something like
 896      eb_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
 897      doesn't need to work.  Detect it and give up if there's an attempt
 898      to do that.  */
 899   if (((memaddr - 1) + len) < memaddr) {
 900     errno = EIO;
 901     return 0;
 902   }
 903
 904   startaddr = memaddr;
 905   count = 0;
 906   while (count < len)
 907     {
 908       len_this_pass = 16;
 909       if ((startaddr % 16) != 0)
 910         len_this_pass -= startaddr % 16;
 911       if (len_this_pass > (len - count))
 912         len_this_pass = (len - count);
 913
 914       fprintf (eb_stream, "db %x,%x\n", startaddr,
 915                (startaddr - 1) + len_this_pass);
 916       expect ("\n");
 917
 918       /* Look for 8 hex digits.  */
 919       i = 0;
 920       while (1)
 921         {
 922           if (isxdigit (readchar ()))
 923             ++i;
 924           else
 925             {
 926               expect_prompt ();
 927               error ("Hex digit expected from remote system.");
 928             }
 929           if (i >= 8)
 930             break;
 931         }
 932
 933       expect ("  ");
 934
 935       for (i = 0; i < len_this_pass; i++)
 936         get_hex_byte (&myaddr[count++]);
 937
 938       expect_prompt ();
 939
 940       startaddr += len_this_pass;
 941     }
 942   return len;
 943 }
 944
 945 static void
 946 eb_kill (args, from_tty)
 947      char *args;
 948      int from_tty;
 949 {
 950   return;               /* Ignore attempts to kill target system */
 951 }
 952
 953 /* Clean up when a program exits.
 954
 955    The program actually lives on in the remote processor's RAM, and may be
 956    run again without a download.  Don't leave it full of breakpoint
 957    instructions.  */
 958
 959 void
 960 eb_mourn_inferior ()
 961 {
 962   remove_breakpoints ();
 963   unpush_target (&eb_ops);
 964   generic_mourn_inferior ();    /* Do all the proper things now */
 965 }
 966 /* Define the target subroutine names */
 967
 968 struct target_ops eb_ops = {
 969         "amd-eb", "Remote serial AMD EBMON target",
 970         "Use a remote computer running EBMON connected by a serial line.\n\
 971 Arguments are the name of the device for the serial line,\n\
 972 the speed to connect at in bits per second, and the filename of the\n\
 973 executable as it exists on the remote computer.  For example,\n\
 974         target amd-eb /dev/ttya 9600 demo",
 975         eb_open, eb_close,
 976         0, eb_detach, eb_resume, eb_wait,
 977         eb_fetch_register, eb_store_register,
 978         eb_prepare_to_store,
 979         eb_xfer_inferior_memory, eb_files_info,
 980         0, 0,   /* Breakpoints */
 981         0, 0, 0, 0, 0,  /* Terminal handling */
 982         eb_kill,
 983         generic_load,   /* load */
 984         0, /* lookup_symbol */
 985         eb_create_inferior,
 986         eb_mourn_inferior,
 987         0,      /* can_run */
 988         0, /* notice_signals */
 989         process_stratum, 0, /* next */
 990         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
 991         0, 0,                   /* Section pointers */
 992         OPS_MAGIC,              /* Always the last thing */
 993 };
 994
 995 void
 996 _initialize_remote_eb ()
 997 {
 998   add_target (&eb_ops);
 999 }