gdb/remote-bug.c

   1 /* Remote debugging interface for Motorola's MVME187BUG monitor, an embedded
   2    monitor for the m88k.
   3
   4    Copyright 1992, 1993 Free Software Foundation, Inc.
   5    Contributed by Cygnus Support.  Written by K. Richard Pixley.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "inferior.h"
  26 #include "gdb_wait.h"
  27
  28 #include "gdb_string.h"
  29 #include <ctype.h>
  30 #include <fcntl.h>
  31 #include <signal.h>
  32 #include <setjmp.h>
  33 #include <errno.h>
  34
  35 #include "terminal.h"
  36 #include "gdbcore.h"
  37 #include "gdbcmd.h"
  38
  39 #include "remote-utils.h"
  40
  41
  42 extern int sleep ();
  43
  44 /* External data declarations */
  45 extern int stop_soon_quietly;   /* for wait_for_inferior */
  46
  47 /* Forward data declarations */
  48 extern struct target_ops bug_ops;       /* Forward declaration */
  49
  50 /* Forward function declarations */
  51 static int bug_clear_breakpoints (void);
  52
  53 static int bug_read_memory (CORE_ADDR memaddr,
  54                             unsigned char *myaddr, int len);
  55
  56 static int bug_write_memory (CORE_ADDR memaddr,
  57                              unsigned char *myaddr, int len);
  58
  59 /* This variable is somewhat arbitrary.  It's here so that it can be
  60    set from within a running gdb.  */
  61
  62 static int srec_max_retries = 3;
  63
  64 /* Each S-record download to the target consists of an S0 header
  65    record, some number of S3 data records, and one S7 termination
  66    record.  I call this download a "frame".  Srec_frame says how many
  67    bytes will be represented in each frame.  */
  68
  69 #define SREC_SIZE 160
  70 static int srec_frame = SREC_SIZE;
  71
  72 /* This variable determines how many bytes will be represented in each
  73    S3 s-record.  */
  74
  75 static int srec_bytes = 40;
  76
  77 /* At one point it appeared to me as though the bug monitor could not
  78    really be expected to receive two sequential characters at 9600
  79    baud reliably.  Echo-pacing is an attempt to force data across the
  80    line even in this condition.  Specifically, in echo-pace mode, each
  81    character is sent one at a time and we look for the echo before
  82    sending the next.  This is excruciatingly slow.  */
  83
  84 static int srec_echo_pace = 0;
  85
  86 /* How long to wait after an srec for a possible error message.
  87    Similar to the above, I tried sleeping after sending each S3 record
  88    in hopes that I might actually see error messages from the bug
  89    monitor.  This might actually work if we were to use sleep
  90    intervals smaller than 1 second.  */
  91
  92 static int srec_sleep = 0;
  93
  94 /* Every srec_noise records, flub the checksum.  This is a debugging
  95    feature.  Set the variable to something other than 1 in order to
  96    inject *deliberate* checksum errors.  One might do this if one
  97    wanted to test error handling and recovery.  */
  98
  99 static int srec_noise = 0;
 100
 101 /* Called when SIGALRM signal sent due to alarm() timeout.  */
 102
 103 /* Number of SIGTRAPs we need to simulate.  That is, the next
 104    NEED_ARTIFICIAL_TRAP calls to bug_wait should just return
 105    SIGTRAP without actually waiting for anything.  */
 106
 107 static int need_artificial_trap = 0;
 108
 109 /*
 110  * Download a file specified in 'args', to the bug.
 111  */
 112
 113 static void
 114 bug_load (char *args, int fromtty)
 115 {
 116   bfd *abfd;
 117   asection *s;
 118   char buffer[1024];
 119
 120   sr_check_open ();
 121
 122   inferior_pid = 0;
 123   abfd = bfd_openr (args, 0);
 124   if (!abfd)
 125     {
 126       printf_filtered ("Unable to open file %s\n", args);
 127       return;
 128     }
 129
 130   if (bfd_check_format (abfd, bfd_object) == 0)
 131     {
 132       printf_filtered ("File is not an object file\n");
 133       return;
 134     }
 135
 136   s = abfd->sections;
 137   while (s != (asection *) NULL)
 138     {
 139       srec_frame = SREC_SIZE;
 140       if (s->flags & SEC_LOAD)
 141         {
 142           int i;
 143
 144           char *buffer = xmalloc (srec_frame);
 145
 146           printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, s->vma, s->vma + s->_raw_size);
 147           gdb_flush (gdb_stdout);
 148           for (i = 0; i < s->_raw_size; i += srec_frame)
 149             {
 150               if (srec_frame > s->_raw_size - i)
 151                 srec_frame = s->_raw_size - i;
 152
 153               bfd_get_section_contents (abfd, s, buffer, i, srec_frame);
 154               bug_write_memory (s->vma + i, buffer, srec_frame);
 155               printf_filtered ("*");
 156               gdb_flush (gdb_stdout);
 157             }
 158           printf_filtered ("\n");
 159           free (buffer);
 160         }
 161       s = s->next;
 162     }
 163   sprintf (buffer, "rs ip %lx", (unsigned long) abfd->start_address);
 164   sr_write_cr (buffer);
 165   gr_expect_prompt ();
 166 }
 167
 168 #if 0
 169 static char *
 170 get_word (char **p)
 171 {
 172   char *s = *p;
 173   char *word;
 174   char *copy;
 175   size_t len;
 176
 177   while (isspace (*s))
 178     s++;
 179
 180   word = s;
 181
 182   len = 0;
 183
 184   while (*s && !isspace (*s))
 185     {
 186       s++;
 187       len++;
 188
 189     }
 190   copy = xmalloc (len + 1);
 191   memcpy (copy, word, len);
 192   copy[len] = 0;
 193   *p = s;
 194   return copy;
 195 }
 196 #endif
 197
 198 static struct gr_settings bug_settings =
 199 {
 200   "Bug>",                       /* prompt */
 201   &bug_ops,                     /* ops */
 202   bug_clear_breakpoints,        /* clear_all_breakpoints */
 203   gr_generic_checkin,           /* checkin */
 204 };
 205
 206 static char *cpu_check_strings[] =
 207 {
 208   "=",
 209   "Invalid Register",
 210 };
 211
 212 static void
 213 bug_open (char *args, int from_tty)
 214 {
 215   if (args == NULL)
 216     args = "";
 217
 218   gr_open (args, from_tty, &bug_settings);
 219   /* decide *now* whether we are on an 88100 or an 88110 */
 220   sr_write_cr ("rs cr06");
 221   sr_expect ("rs cr06");
 222
 223   switch (gr_multi_scan (cpu_check_strings, 0))
 224     {
 225     case 0:                     /* this is an m88100 */
 226       target_is_m88110 = 0;
 227       break;
 228     case 1:                     /* this is an m88110 */
 229       target_is_m88110 = 1;
 230       break;
 231     default:
 232       abort ();
 233     }
 234 }
 235
 236 /* Tell the remote machine to resume.  */
 237
 238 void
 239 bug_resume (int pid, int step, enum target_signal sig)
 240 {
 241   if (step)
 242     {
 243       sr_write_cr ("t");
 244
 245       /* Force the next bug_wait to return a trap.  Not doing anything
 246          about I/O from the target means that the user has to type
 247          "continue" to see any.  FIXME, this should be fixed.  */
 248       need_artificial_trap = 1;
 249     }
 250   else
 251     sr_write_cr ("g");
 252
 253   return;
 254 }
 255
 256 /* Wait until the remote machine stops, then return,
 257    storing status in STATUS just as `wait' would.  */
 258
 259 static char *wait_strings[] =
 260 {
 261   "At Breakpoint",
 262   "Exception: Data Access Fault (Local Bus Timeout)",
 263   "\r8??\?-Bug>",               /* The '\?' avoids creating a trigraph */
 264   "\r197-Bug>",
 265   NULL,
 266 };
 267
 268 int
 269 bug_wait (int pid, struct target_waitstatus *status)
 270 {
 271   int old_timeout = sr_get_timeout ();
 272   int old_immediate_quit = immediate_quit;
 273
 274   status->kind = TARGET_WAITKIND_EXITED;
 275   status->value.integer = 0;
 276
 277   /* read off leftovers from resume so that the rest can be passed
 278      back out as stdout.  */
 279   if (need_artificial_trap == 0)
 280     {
 281       sr_expect ("Effective address: ");
 282       (void) sr_get_hex_word ();
 283       sr_expect ("\r\n");
 284     }
 285
 286   sr_set_timeout (-1);          /* Don't time out -- user program is running. */
 287   immediate_quit = 1;           /* Helps ability to QUIT */
 288
 289   switch (gr_multi_scan (wait_strings, need_artificial_trap == 0))
 290     {
 291     case 0:                     /* breakpoint case */
 292       status->kind = TARGET_WAITKIND_STOPPED;
 293       status->value.sig = TARGET_SIGNAL_TRAP;
 294       /* user output from the target can be discarded here. (?) */
 295       gr_expect_prompt ();
 296       break;
 297
 298     case 1:                     /* bus error */
 299       status->kind = TARGET_WAITKIND_STOPPED;
 300       status->value.sig = TARGET_SIGNAL_BUS;
 301       /* user output from the target can be discarded here. (?) */
 302       gr_expect_prompt ();
 303       break;
 304
 305     case 2:                     /* normal case */
 306     case 3:
 307       if (need_artificial_trap != 0)
 308         {
 309           /* stepping */
 310           status->kind = TARGET_WAITKIND_STOPPED;
 311           status->value.sig = TARGET_SIGNAL_TRAP;
 312           need_artificial_trap--;
 313           break;
 314         }
 315       else
 316         {
 317           /* exit case */
 318           status->kind = TARGET_WAITKIND_EXITED;
 319           status->value.integer = 0;
 320           break;
 321         }
 322
 323     case -1:                    /* trouble */
 324     default:
 325       fprintf_filtered (gdb_stderr,
 326                         "Trouble reading target during wait\n");
 327       break;
 328     }
 329
 330   sr_set_timeout (old_timeout);
 331   immediate_quit = old_immediate_quit;
 332   return 0;
 333 }
 334
 335 /* Return the name of register number REGNO
 336    in the form input and output by bug.
 337
 338    Returns a pointer to a static buffer containing the answer.  */
 339 static char *
 340 get_reg_name (int regno)
 341 {
 342   static char *rn[] =
 343   {
 344     "r00", "r01", "r02", "r03", "r04", "r05", "r06", "r07",
 345     "r08", "r09", "r10", "r11", "r12", "r13", "r14", "r15",
 346     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 347     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 348
 349   /* these get confusing because we omit a few and switch some ordering around. */
 350
 351     "cr01",                     /* 32 = psr */
 352     "fcr62",                    /* 33 = fpsr */
 353     "fcr63",                    /* 34 = fpcr */
 354     "ip",                       /* this is something of a cheat. */
 355   /* 35 = sxip */
 356     "cr05",                     /* 36 = snip */
 357     "cr06",                     /* 37 = sfip */
 358
 359     "x00", "x01", "x02", "x03", "x04", "x05", "x06", "x07",
 360     "x08", "x09", "x10", "x11", "x12", "x13", "x14", "x15",
 361     "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
 362     "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
 363   };
 364
 365   return rn[regno];
 366 }
 367
 368 #if 0                           /* not currently used */
 369 /* Read from remote while the input matches STRING.  Return zero on
 370    success, -1 on failure.  */
 371
 372 static int
 373 bug_scan (char *s)
 374 {
 375   int c;
 376
 377   while (*s)
 378     {
 379       c = sr_readchar ();
 380       if (c != *s++)
 381         {
 382           fflush (stdout);
 383           printf ("\nNext character is '%c' - %d and s is \"%s\".\n", c, c, --s);
 384           return (-1);
 385         }
 386     }
 387
 388   return (0);
 389 }
 390 #endif /* never */
 391
 392 static int
 393 bug_srec_write_cr (char *s)
 394 {
 395   char *p = s;
 396
 397   if (srec_echo_pace)
 398     for (p = s; *p; ++p)
 399       {
 400         if (sr_get_debug () > 0)
 401           printf ("%c", *p);
 402
 403         do
 404           SERIAL_WRITE (sr_get_desc (), p, 1);
 405         while (sr_pollchar () != *p);
 406       }
 407   else
 408     {
 409       sr_write_cr (s);
 410 /*       return(bug_scan (s) || bug_scan ("\n")); */
 411     }
 412
 413   return (0);
 414 }
 415
 416 /* Store register REGNO, or all if REGNO == -1. */
 417
 418 static void
 419 bug_fetch_register (int regno)
 420 {
 421   sr_check_open ();
 422
 423   if (regno == -1)
 424     {
 425       int i;
 426
 427       for (i = 0; i < NUM_REGS; ++i)
 428         bug_fetch_register (i);
 429     }
 430   else if (target_is_m88110 && regno == SFIP_REGNUM)
 431     {
 432       /* m88110 has no sfip. */
 433       long l = 0;
 434       supply_register (regno, (char *) &l);
 435     }
 436   else if (regno < XFP_REGNUM)
 437     {
 438       char buffer[MAX_REGISTER_RAW_SIZE];
 439
 440       sr_write ("rs ", 3);
 441       sr_write_cr (get_reg_name (regno));
 442       sr_expect ("=");
 443       store_unsigned_integer (buffer, REGISTER_RAW_SIZE (regno),
 444                               sr_get_hex_word ());
 445       gr_expect_prompt ();
 446       supply_register (regno, buffer);
 447     }
 448   else
 449     {
 450       /* Float register so we need to parse a strange data format. */
 451       long p;
 452       unsigned char fpreg_buf[10];
 453
 454       sr_write ("rs ", 3);
 455       sr_write (get_reg_name (regno), strlen (get_reg_name (regno)));
 456       sr_write_cr (";d");
 457       sr_expect ("rs");
 458       sr_expect (get_reg_name (regno));
 459       sr_expect (";d");
 460       sr_expect ("=");
 461
 462       /* sign */
 463       p = sr_get_hex_digit (1);
 464       fpreg_buf[0] = p << 7;
 465
 466       /* exponent */
 467       sr_expect ("_");
 468       p = sr_get_hex_digit (1);
 469       fpreg_buf[0] += (p << 4);
 470       fpreg_buf[0] += sr_get_hex_digit (1);
 471
 472       fpreg_buf[1] = sr_get_hex_digit (1) << 4;
 473
 474       /* fraction */
 475       sr_expect ("_");
 476       fpreg_buf[1] += sr_get_hex_digit (1);
 477
 478       fpreg_buf[2] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
 479       fpreg_buf[3] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
 480       fpreg_buf[4] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
 481       fpreg_buf[5] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
 482       fpreg_buf[6] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
 483       fpreg_buf[7] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
 484       fpreg_buf[8] = 0;
 485       fpreg_buf[9] = 0;
 486
 487       gr_expect_prompt ();
 488       supply_register (regno, fpreg_buf);
 489     }
 490
 491   return;
 492 }
 493
 494 /* Store register REGNO, or all if REGNO == -1. */
 495
 496 static void
 497 bug_store_register (int regno)
 498 {
 499   char buffer[1024];
 500   sr_check_open ();
 501
 502   if (regno == -1)
 503     {
 504       int i;
 505
 506       for (i = 0; i < NUM_REGS; ++i)
 507         bug_store_register (i);
 508     }
 509   else
 510     {
 511       char *regname;
 512
 513       regname = get_reg_name (regno);
 514
 515       if (target_is_m88110 && regno == SFIP_REGNUM)
 516         return;
 517       else if (regno < XFP_REGNUM)
 518         sprintf (buffer, "rs %s %08x",
 519                  regname,
 520                  read_register (regno));
 521       else
 522         {
 523           unsigned char *fpreg_buf =
 524           (unsigned char *) &registers[REGISTER_BYTE (regno)];
 525
 526           sprintf (buffer, "rs %s %1x_%02x%1x_%1x%02x%02x%02x%02x%02x%02x;d",
 527                    regname,
 528           /* sign */
 529                    (fpreg_buf[0] >> 7) & 0xf,
 530           /* exponent */
 531                    fpreg_buf[0] & 0x7f,
 532                    (fpreg_buf[1] >> 8) & 0xf,
 533           /* fraction */
 534                    fpreg_buf[1] & 0xf,
 535                    fpreg_buf[2],
 536                    fpreg_buf[3],
 537                    fpreg_buf[4],
 538                    fpreg_buf[5],
 539                    fpreg_buf[6],
 540                    fpreg_buf[7]);
 541         }
 542
 543       sr_write_cr (buffer);
 544       gr_expect_prompt ();
 545     }
 546
 547   return;
 548 }
 549
 550 /* Transfer LEN bytes between GDB address MYADDR and target address
 551    MEMADDR.  If WRITE is non-zero, transfer them to the target,
 552    otherwise transfer them from the target.  TARGET is unused.
 553
 554    Returns the number of bytes transferred. */
 555
 556 int
 557 bug_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 558                  struct target_ops *target)
 559 {
 560   int res;
 561
 562   if (len <= 0)
 563     return 0;
 564
 565   if (write)
 566     res = bug_write_memory (memaddr, myaddr, len);
 567   else
 568     res = bug_read_memory (memaddr, myaddr, len);
 569
 570   return res;
 571 }
 572
 573 static void
 574 start_load (void)
 575 {
 576   char *command;
 577
 578   command = (srec_echo_pace ? "lo 0 ;x" : "lo 0");
 579
 580   sr_write_cr (command);
 581   sr_expect (command);
 582   sr_expect ("\r\n");
 583   bug_srec_write_cr ("S0030000FC");
 584   return;
 585 }
 586
 587 /* This is an extremely vulnerable and fragile function.  I've made
 588    considerable attempts to make this deterministic, but I've
 589    certainly forgotten something.  The trouble is that S-records are
 590    only a partial file format, not a protocol.  Worse, apparently the
 591    m88k bug monitor does not run in real time while receiving
 592    S-records.  Hence, we must pay excruciating attention to when and
 593    where error messages are returned, and what has actually been sent.
 594
 595    Each call represents a chunk of memory to be sent to the target.
 596    We break that chunk into an S0 header record, some number of S3
 597    data records each containing srec_bytes, and an S7 termination
 598    record.  */
 599
 600 static char *srecord_strings[] =
 601 {
 602   "S-RECORD",
 603   "-Bug>",
 604   NULL,
 605 };
 606
 607 static int
 608 bug_write_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 609 {
 610   int done;
 611   int checksum;
 612   int x;
 613   int retries;
 614   char *buffer = alloca ((srec_bytes + 8) << 1);
 615
 616   retries = 0;
 617
 618   do
 619     {
 620       done = 0;
 621
 622       if (retries > srec_max_retries)
 623         return (-1);
 624
 625       if (retries > 0)
 626         {
 627           if (sr_get_debug () > 0)
 628             printf ("\n<retrying...>\n");
 629
 630           /* This gr_expect_prompt call is extremely important.  Without
 631              it, we will tend to resend our packet so fast that it
 632              will arrive before the bug monitor is ready to receive
 633              it.  This would lead to a very ugly resend loop.  */
 634
 635           gr_expect_prompt ();
 636         }
 637
 638       start_load ();
 639
 640       while (done < len)
 641         {
 642           int thisgo;
 643           int idx;
 644           char *buf = buffer;
 645           CORE_ADDR address;
 646
 647           checksum = 0;
 648           thisgo = len - done;
 649           if (thisgo > srec_bytes)
 650             thisgo = srec_bytes;
 651
 652           address = memaddr + done;
 653           sprintf (buf, "S3%02X%08X", thisgo + 4 + 1, address);
 654           buf += 12;
 655
 656           checksum += (thisgo + 4 + 1
 657                        + (address & 0xff)
 658                        + ((address >> 8) & 0xff)
 659                        + ((address >> 16) & 0xff)
 660                        + ((address >> 24) & 0xff));
 661
 662           for (idx = 0; idx < thisgo; idx++)
 663             {
 664               sprintf (buf, "%02X", myaddr[idx + done]);
 665               checksum += myaddr[idx + done];
 666               buf += 2;
 667             }
 668
 669           if (srec_noise > 0)
 670             {
 671               /* FIXME-NOW: insert a deliberate error every now and then.
 672                  This is intended for testing/debugging the error handling
 673                  stuff.  */
 674               static int counter = 0;
 675               if (++counter > srec_noise)
 676                 {
 677                   counter = 0;
 678                   ++checksum;
 679                 }
 680             }
 681
 682           sprintf (buf, "%02X", ~checksum & 0xff);
 683           bug_srec_write_cr (buffer);
 684
 685           if (srec_sleep != 0)
 686             sleep (srec_sleep);
 687
 688           /* This pollchar is probably redundant to the gr_multi_scan
 689              below.  Trouble is, we can't be sure when or where an
 690              error message will appear.  Apparently, when running at
 691              full speed from a typical sun4, error messages tend to
 692              appear to arrive only *after* the s7 record.   */
 693
 694           if ((x = sr_pollchar ()) != 0)
 695             {
 696               if (sr_get_debug () > 0)
 697                 printf ("\n<retrying...>\n");
 698
 699               ++retries;
 700
 701               /* flush any remaining input and verify that we are back
 702                  at the prompt level. */
 703               gr_expect_prompt ();
 704               /* start all over again. */
 705               start_load ();
 706               done = 0;
 707               continue;
 708             }
 709
 710           done += thisgo;
 711         }
 712
 713       bug_srec_write_cr ("S7060000000000F9");
 714       ++retries;
 715
 716       /* Having finished the load, we need to figure out whether we
 717          had any errors.  */
 718     }
 719   while (gr_multi_scan (srecord_strings, 0) == 0);;
 720
 721   return (0);
 722 }
 723
 724 /* Copy LEN bytes of data from debugger memory at MYADDR
 725    to inferior's memory at MEMADDR.  Returns errno value.
 726    * sb/sh instructions don't work on unaligned addresses, when TU=1.
 727  */
 728
 729 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
 730    at debugger address MYADDR.  Returns errno value.  */
 731 static int
 732 bug_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 733 {
 734   char request[100];
 735   char *buffer;
 736   char *p;
 737   char type;
 738   char size;
 739   unsigned char c;
 740   unsigned int inaddr;
 741   unsigned int checksum;
 742
 743   sprintf (request, "du 0 %x:&%d", memaddr, len);
 744   sr_write_cr (request);
 745
 746   p = buffer = alloca (len);
 747
 748   /* scan up through the header */
 749   sr_expect ("S0030000FC");
 750
 751   while (p < buffer + len)
 752     {
 753       /* scan off any white space. */
 754       while (sr_readchar () != 'S');;
 755
 756       /* what kind of s-rec? */
 757       type = sr_readchar ();
 758
 759       /* scan record size */
 760       sr_get_hex_byte (&size);
 761       checksum = size;
 762       --size;
 763       inaddr = 0;
 764
 765       switch (type)
 766         {
 767         case '7':
 768         case '8':
 769         case '9':
 770           goto done;
 771
 772         case '3':
 773           sr_get_hex_byte (&c);
 774           inaddr = (inaddr << 8) + c;
 775           checksum += c;
 776           --size;
 777           /* intentional fall through */
 778         case '2':
 779           sr_get_hex_byte (&c);
 780           inaddr = (inaddr << 8) + c;
 781           checksum += c;
 782           --size;
 783           /* intentional fall through */
 784         case '1':
 785           sr_get_hex_byte (&c);
 786           inaddr = (inaddr << 8) + c;
 787           checksum += c;
 788           --size;
 789           sr_get_hex_byte (&c);
 790           inaddr = (inaddr << 8) + c;
 791           checksum += c;
 792           --size;
 793           break;
 794
 795         default:
 796           /* bonk */
 797           error ("reading s-records.");
 798         }
 799
 800       if (inaddr < memaddr
 801           || (memaddr + len) < (inaddr + size))
 802         error ("srec out of memory range.");
 803
 804       if (p != buffer + inaddr - memaddr)
 805         error ("srec out of sequence.");
 806
 807       for (; size; --size, ++p)
 808         {
 809           sr_get_hex_byte (p);
 810           checksum += *p;
 811         }
 812
 813       sr_get_hex_byte (&c);
 814       if (c != (~checksum & 0xff))
 815         error ("bad s-rec checksum");
 816     }
 817
 818 done:
 819   gr_expect_prompt ();
 820   if (p != buffer + len)
 821     return (1);
 822
 823   memcpy (myaddr, buffer, len);
 824   return (0);
 825 }
 826
 827 #define MAX_BREAKS      16
 828 static int num_brkpts = 0;
 829
 830 /* Insert a breakpoint at ADDR.  SAVE is normally the address of the
 831    pattern buffer where the instruction that the breakpoint overwrites
 832    is saved.  It is unused here since the bug is responsible for
 833    saving/restoring the original instruction. */
 834
 835 static int
 836 bug_insert_breakpoint (CORE_ADDR addr, char *save)
 837 {
 838   sr_check_open ();
 839
 840   if (num_brkpts < MAX_BREAKS)
 841     {
 842       char buffer[100];
 843
 844       num_brkpts++;
 845       sprintf (buffer, "br %x", addr);
 846       sr_write_cr (buffer);
 847       gr_expect_prompt ();
 848       return (0);
 849     }
 850   else
 851     {
 852       fprintf_filtered (gdb_stderr,
 853                       "Too many break points, break point not installed\n");
 854       return (1);
 855     }
 856
 857 }
 858
 859 /* Remove a breakpoint at ADDR.  SAVE is normally the previously
 860    saved pattern, but is unused here since the bug is responsible
 861    for saving/restoring instructions. */
 862
 863 static int
 864 bug_remove_breakpoint (CORE_ADDR addr, char *save)
 865 {
 866   if (num_brkpts > 0)
 867     {
 868       char buffer[100];
 869
 870       num_brkpts--;
 871       sprintf (buffer, "nobr %x", addr);
 872       sr_write_cr (buffer);
 873       gr_expect_prompt ();
 874
 875     }
 876   return (0);
 877 }
 878
 879 /* Clear the bugs notion of what the break points are */
 880 static int
 881 bug_clear_breakpoints (void)
 882 {
 883
 884   if (sr_is_open ())
 885     {
 886       sr_write_cr ("nobr");
 887       sr_expect ("nobr");
 888       gr_expect_prompt ();
 889     }
 890   num_brkpts = 0;
 891   return (0);
 892 }
 893
 894 struct target_ops bug_ops;
 895
 896 static void
 897 init_bug_ops (void)
 898 {
 899   bug_ops.to_shortname = "bug";
 900   "Remote BUG monitor",
 901     bug_ops.to_longname = "Use the mvme187 board running the BUG monitor connected by a serial line.";
 902   bug_ops.to_doc = " ";
 903   bug_ops.to_open = bug_open;
 904   bug_ops.to_close = gr_close;
 905   bug_ops.to_attach = 0;
 906   bug_ops.to_post_attach = NULL;
 907   bug_ops.to_require_attach = NULL;
 908   bug_ops.to_detach = gr_detach;
 909   bug_ops.to_require_detach = NULL;
 910   bug_ops.to_resume = bug_resume;
 911   bug_ops.to_wait = bug_wait;
 912   bug_ops.to_post_wait = NULL;
 913   bug_ops.to_fetch_registers = bug_fetch_register;
 914   bug_ops.to_store_registers = bug_store_register;
 915   bug_ops.to_prepare_to_store = gr_prepare_to_store;
 916   bug_ops.to_xfer_memory = bug_xfer_memory;
 917   bug_ops.to_files_info = gr_files_info;
 918   bug_ops.to_insert_breakpoint = bug_insert_breakpoint;
 919   bug_ops.to_remove_breakpoint = bug_remove_breakpoint;
 920   bug_ops.to_terminal_init = 0;
 921   bug_ops.to_terminal_inferior = 0;
 922   bug_ops.to_terminal_ours_for_output = 0;
 923   bug_ops.to_terminal_ours = 0;
 924   bug_ops.to_terminal_info = 0;
 925   bug_ops.to_kill = gr_kill;
 926   bug_ops.to_load = bug_load;
 927   bug_ops.to_lookup_symbol = 0;
 928   bug_ops.to_create_inferior = gr_create_inferior;
 929   bug_ops.to_post_startup_inferior = NULL;
 930   bug_ops.to_acknowledge_created_inferior = NULL;
 931   bug_ops.to_clone_and_follow_inferior = NULL;
 932   bug_ops.to_post_follow_inferior_by_clone = NULL;
 933   bug_ops.to_insert_fork_catchpoint = NULL;
 934   bug_ops.to_remove_fork_catchpoint = NULL;
 935   bug_ops.to_insert_vfork_catchpoint = NULL;
 936   bug_ops.to_remove_vfork_catchpoint = NULL;
 937   bug_ops.to_has_forked = NULL;
 938   bug_ops.to_has_vforked = NULL;
 939   bug_ops.to_can_follow_vfork_prior_to_exec = NULL;
 940   bug_ops.to_post_follow_vfork = NULL;
 941   bug_ops.to_insert_exec_catchpoint = NULL;
 942   bug_ops.to_remove_exec_catchpoint = NULL;
 943   bug_ops.to_has_execd = NULL;
 944   bug_ops.to_reported_exec_events_per_exec_call = NULL;
 945   bug_ops.to_has_exited = NULL;
 946   bug_ops.to_mourn_inferior = gr_mourn;
 947   bug_ops.to_can_run = 0;
 948   bug_ops.to_notice_signals = 0;
 949   bug_ops.to_thread_alive = 0;
 950   bug_ops.to_stop = 0;
 951   bug_ops.to_pid_to_exec_file = NULL;
 952   bug_ops.to_core_file_to_sym_file = NULL;
 953   bug_ops.to_stratum = process_stratum;
 954   bug_ops.DONT_USE = 0;
 955   bug_ops.to_has_all_memory = 1;
 956   bug_ops.to_has_memory = 1;
 957   bug_ops.to_has_stack = 1;
 958   bug_ops.to_has_registers = 0;
 959   bug_ops.to_has_execution = 0;
 960   bug_ops.to_sections = 0;
 961   bug_ops.to_sections_end = 0;
 962   bug_ops.to_magic = OPS_MAGIC; /* Always the last thing */
 963 }                               /* init_bug_ops */
 964
 965 void
 966 _initialize_remote_bug (void)
 967 {
 968   init_bug_ops ();
 969   add_target (&bug_ops);
 970
 971   add_show_from_set
 972     (add_set_cmd ("srec-bytes", class_support, var_uinteger,
 973                   (char *) &srec_bytes,
 974                   "\
 975 Set the number of bytes represented in each S-record.\n\
 976 This affects the communication protocol with the remote target.",
 977                   &setlist),
 978      &showlist);
 979
 980   add_show_from_set
 981     (add_set_cmd ("srec-max-retries", class_support, var_uinteger,
 982                   (char *) &srec_max_retries,
 983                   "\
 984 Set the number of retries for shipping S-records.\n\
 985 This affects the communication protocol with the remote target.",
 986                   &setlist),
 987      &showlist);
 988
 989 #if 0
 990   /* This needs to set SREC_SIZE, not srec_frame which gets changed at the
 991      end of a download.  But do we need the option at all?  */
 992   add_show_from_set
 993     (add_set_cmd ("srec-frame", class_support, var_uinteger,
 994                   (char *) &srec_frame,
 995                   "\
 996 Set the number of bytes in an S-record frame.\n\
 997 This affects the communication protocol with the remote target.",
 998                   &setlist),
 999      &showlist);
1000 #endif /* 0 */
1001
1002   add_show_from_set
1003     (add_set_cmd ("srec-noise", class_support, var_zinteger,
1004                   (char *) &srec_noise,
1005                   "\
1006 Set number of S-record to send before deliberately flubbing a checksum.\n\
1007 Zero means flub none at all.  This affects the communication protocol\n\
1008 with the remote target.",
1009                   &setlist),
1010      &showlist);
1011
1012   add_show_from_set
1013     (add_set_cmd ("srec-sleep", class_support, var_zinteger,
1014                   (char *) &srec_sleep,
1015                   "\
1016 Set number of seconds to sleep after an S-record for a possible error message to arrive.\n\
1017 This affects the communication protocol with the remote target.",
1018                   &setlist),
1019      &showlist);
1020
1021   add_show_from_set
1022     (add_set_cmd ("srec-echo-pace", class_support, var_boolean,
1023                   (char *) &srec_echo_pace,
1024                   "\
1025 Set echo-verification.\n\
1026 When on, use verification by echo when downloading S-records.  This is\n\
1027 much slower, but generally more reliable.",
1028                   &setlist),
1029      &showlist);
1030 }