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