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