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