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 (pid, status)
 277      int pid;
 278      WAITTYPE *status;
 279 {
 280   int old_timeout = sr_get_timeout();
 281   int old_immediate_quit = immediate_quit;
 282
 283   WSETEXIT ((*status), 0);
 284
 285   /* read off leftovers from resume so that the rest can be passed
 286      back out as stdout.  */
 287   if (need_artificial_trap == 0)
 288     {
 289       sr_expect("Effective address: ");
 290       (void) sr_get_hex_word();
 291       sr_expect ("\r\n");
 292     }
 293
 294   sr_set_timeout(-1); /* Don't time out -- user program is running. */
 295   immediate_quit = 1; /* Helps ability to QUIT */
 296
 297   switch (gr_multi_scan(wait_strings, need_artificial_trap == 0))
 298     {
 299     case 0: /* breakpoint case */
 300       WSETSTOP ((*status), SIGTRAP);
 301       /* user output from the target can be discarded here. (?) */
 302       gr_expect_prompt();
 303       break;
 304
 305     case 1: /* bus error */
 306       WSETSTOP ((*status), SIGBUS);
 307       /* user output from the target can be discarded here. (?) */
 308       gr_expect_prompt();
 309       break;
 310
 311     case 2: /* normal case */
 312     case 3:
 313       if (need_artificial_trap != 0)
 314         {
 315           /* stepping */
 316           WSETSTOP ((*status), SIGTRAP);
 317           need_artificial_trap--;
 318           break;
 319         }
 320       else
 321         {
 322           /* exit case */
 323           WSETEXIT ((*status), 0);
 324           break;
 325         }
 326
 327     case -1: /* trouble */
 328     default:
 329       fprintf_filtered (stderr,
 330                         "Trouble reading target during wait\n");
 331       break;
 332     }
 333
 334   sr_set_timeout(old_timeout);
 335   immediate_quit = old_immediate_quit;
 336   return 0;
 337 }
 338
 339 /* Return the name of register number REGNO
 340    in the form input and output by bug.
 341
 342    Returns a pointer to a static buffer containing the answer.  */
 343 static char *
 344 get_reg_name (regno)
 345      int regno;
 346 {
 347   static char *rn[] = {
 348     "r00", "r01", "r02", "r03", "r04", "r05", "r06", "r07",
 349     "r08", "r09", "r10", "r11", "r12", "r13", "r14", "r15",
 350     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 351     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 352
 353     /* these get confusing because we omit a few and switch some ordering around. */
 354
 355     "cr01",  /* 32 = psr */
 356     "fcr62", /* 33 = fpsr*/
 357     "fcr63", /* 34 = fpcr */
 358     "ip",                       /* this is something of a cheat. */
 359   /* 35 = sxip */
 360     "cr05", /* 36 = snip */
 361     "cr06", /* 37 = sfip */
 362
 363     "x00", "x01", "x02", "x03", "x04", "x05", "x06", "x07",
 364     "x08", "x09", "x10", "x11", "x12", "x13", "x14", "x15",
 365     "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
 366     "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
 367   };
 368
 369   return rn[regno];
 370 }
 371
 372 #if 0 /* not currently used */
 373 /* Read from remote while the input matches STRING.  Return zero on
 374    success, -1 on failure.  */
 375
 376 static int
 377 bug_scan (s)
 378      char *s;
 379 {
 380   int c;
 381
 382   while (*s)
 383     {
 384       c = sr_readchar();
 385       if (c != *s++)
 386         {
 387           fflush(stdout);
 388           printf("\nNext character is '%c' - %d and s is \"%s\".\n", c, c, --s);
 389           return(-1);
 390         }
 391     }
 392
 393   return(0);
 394 }
 395 #endif /* never */
 396
 397 static int
 398 bug_srec_write_cr (s)
 399      char *s;
 400 {
 401   char *p = s;
 402
 403   if (srec_echo_pace)
 404     for (p = s; *p; ++p)
 405       {
 406         if (sr_get_debug() > 0)
 407           printf ("%c", *p);
 408
 409         do
 410           SERIAL_WRITE(sr_get_desc(), p, 1);
 411         while (sr_pollchar() != *p);
 412       }
 413   else
 414     {
 415       sr_write_cr (s);
 416 /*       return(bug_scan (s) || bug_scan ("\n")); */
 417     }
 418
 419   return(0);
 420 }
 421
 422 /* Store register REGNO, or all if REGNO == -1. */
 423
 424 static void
 425 bug_fetch_register(regno)
 426      int regno;
 427 {
 428   sr_check_open();
 429
 430   if (regno == -1)
 431     {
 432       int i;
 433
 434       for (i = 0; i < NUM_REGS; ++i)
 435         bug_fetch_register(i);
 436     }
 437   else if (target_is_m88110 && regno == SFIP_REGNUM)
 438     {
 439       /* m88110 has no sfip. */
 440       long l = 0;
 441       supply_register(regno, (char *) &l);
 442     }
 443   else if (regno < XFP_REGNUM)
 444     {
 445       char buffer[MAX_REGISTER_RAW_SIZE];
 446
 447       sr_write ("rs ", 3);
 448       sr_write_cr (get_reg_name(regno));
 449       sr_expect ("=");
 450       store_unsigned_integer (buffer, REGISTER_RAW_SIZE (regno),
 451                               sr_get_hex_word());
 452       gr_expect_prompt ();
 453       supply_register (regno, buffer);
 454     }
 455   else
 456     {
 457       /* Float register so we need to parse a strange data format. */
 458       long p;
 459       unsigned char value[10];
 460
 461       sr_write("rs ", 3);
 462       sr_write(get_reg_name(regno), strlen(get_reg_name(regno)));
 463       sr_write_cr(";d");
 464       sr_expect("rs");
 465       sr_expect(get_reg_name(regno));
 466       sr_expect(";d");
 467       sr_expect("=");
 468
 469       /* sign */
 470       p = sr_get_hex_digit(1);
 471       value[0] = p << 7;
 472
 473       /* exponent */
 474       sr_expect("_");
 475       p = sr_get_hex_digit(1);
 476       value[0] += (p << 4);
 477       value[0] += sr_get_hex_digit(1);
 478
 479       value[1] = sr_get_hex_digit(1) << 4;
 480
 481       /* fraction */
 482       sr_expect("_");
 483       value[1] += sr_get_hex_digit(1);
 484
 485       value[2] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
 486       value[3] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
 487       value[4] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
 488       value[5] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
 489       value[6] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
 490       value[7] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
 491       value[8] = 0;
 492       value[9] = 0;
 493
 494       gr_expect_prompt();
 495       supply_register(regno, value);
 496     }
 497
 498   return;
 499 }
 500
 501 /* Store register REGNO, or all if REGNO == -1. */
 502
 503 static void
 504 bug_store_register (regno)
 505      int regno;
 506 {
 507   char buffer[1024];
 508   sr_check_open();
 509
 510   if (regno == -1)
 511     {
 512       int i;
 513
 514       for (i = 0; i < NUM_REGS; ++i)
 515         bug_store_register(i);
 516     }
 517   else
 518     {
 519       char *regname;
 520
 521       regname = get_reg_name(regno);
 522
 523       if (target_is_m88110 && regno == SFIP_REGNUM)
 524         return;
 525       else if (regno < XFP_REGNUM)
 526         sprintf(buffer, "rs %s %08x",
 527                 regname,
 528                 read_register(regno));
 529       else
 530         {
 531           unsigned char *value = &registers[REGISTER_BYTE(regno)];
 532
 533           sprintf(buffer, "rs %s %1x_%02x%1x_%1x%02x%02x%02x%02x%02x%02x;d",
 534                   regname,
 535                   /* sign */
 536                   (value[0] >> 7) & 0xf,
 537                   /* exponent */
 538                   value[0] & 0x7f,
 539                   (value[1] >> 8) & 0xf,
 540                   /* fraction */
 541                   value[1] & 0xf,
 542                   value[2],
 543                   value[3],
 544                   value[4],
 545                   value[5],
 546                   value[6],
 547                   value[7]);
 548         }
 549
 550       sr_write_cr(buffer);
 551       gr_expect_prompt();
 552     }
 553
 554   return;
 555 }
 556
 557 int
 558 bug_xfer_memory (memaddr, myaddr, len, write, target)
 559      CORE_ADDR memaddr;
 560      char *myaddr;
 561      int len;
 562      int write;
 563      struct target_ops *target; /* ignored */
 564 {
 565   register int i;
 566
 567   /* Round starting address down to longword boundary.  */
 568   register CORE_ADDR addr;
 569
 570   /* Round ending address up; get number of longwords that makes.  */
 571   register int count;
 572
 573   /* Allocate buffer of that many longwords.  */
 574   register int *buffer;
 575
 576   addr = memaddr & -sizeof (int);
 577   count = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 578
 579   buffer = (int *) alloca (count * sizeof (int));
 580
 581   if (write)
 582     {
 583       /* Fill start and end extra bytes of buffer with existing memory data.  */
 584
 585       if (addr != memaddr || len < (int) sizeof (int))
 586         {
 587           /* Need part of initial word -- fetch it.  */
 588           buffer[0] = gr_fetch_word (addr);
 589         }
 590
 591       if (count > 1)            /* FIXME, avoid if even boundary */
 592         {
 593           buffer[count - 1]
 594             = gr_fetch_word (addr + (count - 1) * sizeof (int));
 595         }
 596
 597       /* Copy data to be written over corresponding part of buffer */
 598
 599       memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 600
 601       /* Write the entire buffer.  */
 602
 603       for (i = 0; i < count; i++, addr += sizeof (int))
 604         {
 605           errno = 0;
 606           gr_store_word (addr, buffer[i]);
 607           if (errno)
 608             {
 609
 610               return 0;
 611             }
 612
 613         }
 614     }
 615   else
 616     {
 617       /* Read all the longwords */
 618       for (i = 0; i < count; i++, addr += sizeof (int))
 619         {
 620           errno = 0;
 621           buffer[i] = gr_fetch_word (addr);
 622           if (errno)
 623             {
 624               return 0;
 625             }
 626           QUIT;
 627         }
 628
 629       /* Copy appropriate bytes out of the buffer.  */
 630       memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 631     }
 632
 633   return len;
 634 }
 635
 636 static void
 637 start_load()
 638 {
 639   char *command;
 640
 641   command = (srec_echo_pace ? "lo 0 ;x" : "lo 0");
 642
 643   sr_write_cr (command);
 644   sr_expect (command);
 645   sr_expect ("\r\n");
 646   bug_srec_write_cr ("S0030000FC");
 647   return;
 648 }
 649
 650 /* This is an extremely vulnerable and fragile function.  I've made
 651    considerable attempts to make this deterministic, but I've
 652    certainly forgotten something.  The trouble is that S-records are
 653    only a partial file format, not a protocol.  Worse, apparently the
 654    m88k bug monitor does not run in real time while receiving
 655    S-records.  Hence, we must pay excruciating attention to when and
 656    where error messages are returned, and what has actually been sent.
 657
 658    Each call represents a chunk of memory to be sent to the target.
 659    We break that chunk into an S0 header record, some number of S3
 660    data records each containing srec_bytes, and an S7 termination
 661    record.  */
 662
 663 static char *srecord_strings[] = {
 664   "S-RECORD",
 665   "-Bug>",
 666   NULL,
 667 };
 668
 669 static int
 670 bug_write_memory (memaddr, myaddr, len)
 671      CORE_ADDR memaddr;
 672      unsigned char *myaddr;
 673      int len;
 674 {
 675   int done;
 676   int checksum;
 677   int x;
 678   int retries;
 679   char buffer[(srec_bytes + 8) << 1];
 680
 681   retries = 0;
 682
 683   do
 684     {
 685       done = 0;
 686
 687       if (retries > srec_max_retries)
 688         return(-1);
 689
 690       if (retries > 0)
 691         {
 692           if (sr_get_debug() > 0)
 693             printf("\n<retrying...>\n");
 694
 695           /* This gr_expect_prompt call is extremely important.  Without
 696              it, we will tend to resend our packet so fast that it
 697              will arrive before the bug monitor is ready to receive
 698              it.  This would lead to a very ugly resend loop.  */
 699
 700           gr_expect_prompt();
 701         }
 702
 703       start_load();
 704
 705       while (done < len)
 706         {
 707           int thisgo;
 708           int idx;
 709           char *buf = buffer;
 710           CORE_ADDR address;
 711
 712           checksum = 0;
 713           thisgo = len - done;
 714           if (thisgo > srec_bytes)
 715             thisgo = srec_bytes;
 716
 717           address = memaddr + done;
 718           sprintf (buf, "S3%02X%08X", thisgo + 4 + 1, address);
 719           buf += 12;
 720
 721           checksum += (thisgo + 4 + 1
 722                        + (address & 0xff)
 723                        + ((address >>  8) & 0xff)
 724                        + ((address >> 16) & 0xff)
 725                        + ((address >> 24) & 0xff));
 726
 727           for (idx = 0; idx < thisgo; idx++)
 728             {
 729               sprintf (buf, "%02X", myaddr[idx + done]);
 730               checksum += myaddr[idx + done];
 731               buf += 2;
 732             }
 733
 734           if (srec_noise > 0)
 735             {
 736               /* FIXME-NOW: insert a deliberate error every now and then.
 737                  This is intended for testing/debugging the error handling
 738                  stuff.  */
 739               static int counter = 0;
 740               if (++counter > srec_noise)
 741                 {
 742                   counter = 0;
 743                   ++checksum;
 744                 }
 745             }
 746
 747           sprintf(buf, "%02X", ~checksum & 0xff);
 748           bug_srec_write_cr (buffer);
 749
 750           if (srec_sleep != 0)
 751             sleep(srec_sleep);
 752
 753           /* This pollchar is probably redundant to the gr_multi_scan
 754              below.  Trouble is, we can't be sure when or where an
 755              error message will appear.  Apparently, when running at
 756              full speed from a typical sun4, error messages tend to
 757              appear to arrive only *after* the s7 record.   */
 758
 759           if ((x = sr_pollchar()) != 0)
 760             {
 761               if (sr_get_debug() > 0)
 762                 printf("\n<retrying...>\n");
 763
 764               ++retries;
 765
 766               /* flush any remaining input and verify that we are back
 767                  at the prompt level. */
 768               gr_expect_prompt();
 769               /* start all over again. */
 770               start_load();
 771               done = 0;
 772               continue;
 773             }
 774
 775           done += thisgo;
 776         }
 777
 778       bug_srec_write_cr("S7060000000000F9");
 779       ++retries;
 780
 781       /* Having finished the load, we need to figure out whether we
 782          had any errors.  */
 783     } while (gr_multi_scan(srecord_strings, 0) == 0);;
 784
 785   return(0);
 786 }
 787
 788 /* Copy LEN bytes of data from debugger memory at MYADDR
 789    to inferior's memory at MEMADDR.  Returns errno value.
 790  * sb/sh instructions don't work on unaligned addresses, when TU=1.
 791  */
 792
 793 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
 794    at debugger address MYADDR.  Returns errno value.  */
 795 static int
 796 bug_read_memory (memaddr, myaddr, len)
 797      CORE_ADDR memaddr;
 798      unsigned char *myaddr;
 799      int len;
 800 {
 801   char request[100];
 802   char *buffer;
 803   char *p;
 804   char type;
 805   char size;
 806   unsigned char c;
 807   unsigned int inaddr;
 808   unsigned int checksum;
 809
 810   sprintf(request, "du 0 %x:&%d", memaddr, len);
 811   sr_write_cr(request);
 812
 813   p = buffer = alloca(len);
 814
 815   /* scan up through the header */
 816   sr_expect("S0030000FC");
 817
 818   while (p < buffer + len)
 819     {
 820       /* scan off any white space. */
 821       while (sr_readchar() != 'S') ;;
 822
 823       /* what kind of s-rec? */
 824       type = sr_readchar();
 825
 826       /* scan record size */
 827       sr_get_hex_byte(&size);
 828       checksum = size;
 829       --size;
 830       inaddr = 0;
 831
 832       switch (type)
 833         {
 834         case '7':
 835         case '8':
 836         case '9':
 837           goto done;
 838
 839         case '3':
 840           sr_get_hex_byte(&c);
 841           inaddr = (inaddr << 8) + c;
 842           checksum += c;
 843           --size;
 844           /* intentional fall through */
 845         case '2':
 846           sr_get_hex_byte(&c);
 847           inaddr = (inaddr << 8) + c;
 848           checksum += c;
 849           --size;
 850           /* intentional fall through */
 851         case '1':
 852           sr_get_hex_byte(&c);
 853           inaddr = (inaddr << 8) + c;
 854           checksum += c;
 855           --size;
 856           sr_get_hex_byte(&c);
 857           inaddr = (inaddr << 8) + c;
 858           checksum += c;
 859           --size;
 860           break;
 861
 862         default:
 863           /* bonk */
 864           error("reading s-records.");
 865         }
 866
 867       if (inaddr < memaddr
 868           || (memaddr + len) < (inaddr + size))
 869         error("srec out of memory range.");
 870
 871       if (p != buffer + inaddr - memaddr)
 872         error("srec out of sequence.");
 873
 874       for (; size; --size, ++p)
 875         {
 876           sr_get_hex_byte(p);
 877           checksum += *p;
 878         }
 879
 880       sr_get_hex_byte(&c);
 881       if (c != (~checksum & 0xff))
 882         error("bad s-rec checksum");
 883     }
 884
 885  done:
 886   gr_expect_prompt();
 887   if (p != buffer + len)
 888     return(1);
 889
 890   memcpy(myaddr, buffer, len);
 891   return(0);
 892 }
 893
 894 #define MAX_BREAKS      16
 895 static int num_brkpts = 0;
 896 static int
 897 bug_insert_breakpoint (addr, save)
 898      CORE_ADDR addr;
 899      char *save;                /* Throw away, let bug save instructions */
 900 {
 901   sr_check_open ();
 902
 903   if (num_brkpts < MAX_BREAKS)
 904     {
 905       char buffer[100];
 906
 907       num_brkpts++;
 908       sprintf (buffer, "br %x", addr);
 909       sr_write_cr (buffer);
 910       gr_expect_prompt ();
 911       return(0);
 912     }
 913   else
 914     {
 915       fprintf_filtered (stderr,
 916                       "Too many break points, break point not installed\n");
 917       return(1);
 918     }
 919
 920 }
 921 static int
 922 bug_remove_breakpoint (addr, save)
 923      CORE_ADDR addr;
 924      char *save;                /* Throw away, let bug save instructions */
 925 {
 926   if (num_brkpts > 0)
 927     {
 928       char buffer[100];
 929
 930       num_brkpts--;
 931       sprintf (buffer, "nobr %x", addr);
 932       sr_write_cr (buffer);
 933       gr_expect_prompt ();
 934
 935     }
 936   return (0);
 937 }
 938
 939 /* Clear the bugs notion of what the break points are */
 940 static int
 941 bug_clear_breakpoints ()
 942 {
 943
 944   if (sr_is_open())
 945     {
 946       sr_write_cr ("nobr");
 947       sr_expect("nobr");
 948       gr_expect_prompt ();
 949     }
 950   num_brkpts = 0;
 951   return(0);
 952 }
 953
 954 struct target_ops bug_ops =
 955 {
 956   "bug", "Remote BUG monitor",
 957   "Use the mvme187 board running the BUG monitor connected\n\
 958 by a serial line.",
 959
 960   bug_open, gr_close,
 961   0, gr_detach, bug_resume, bug_wait,   /* attach */
 962   bug_fetch_register, bug_store_register,
 963   gr_prepare_to_store,
 964   bug_xfer_memory,
 965   gr_files_info,
 966   bug_insert_breakpoint, bug_remove_breakpoint, /* Breakpoints */
 967   0, 0, 0, 0, 0,                /* Terminal handling */
 968   gr_kill,                      /* FIXME, kill */
 969   bug_load,
 970   0,                            /* lookup_symbol */
 971   gr_create_inferior,           /* create_inferior */
 972   gr_mourn,                     /* mourn_inferior FIXME */
 973   0,                            /* can_run */
 974   0,                            /* notice_signals */
 975   process_stratum, 0,           /* next */
 976   1, 1, 1, 1, 1,                /* all mem, mem, stack, regs, exec */
 977   0, 0,                         /* Section pointers */
 978   OPS_MAGIC,                    /* Always the last thing */
 979 };
 980
 981 void
 982 _initialize_remote_bug ()
 983 {
 984   add_target (&bug_ops);
 985
 986   add_show_from_set
 987     (add_set_cmd ("srec-bytes", class_support, var_uinteger,
 988                   (char *) &srec_bytes,
 989                   "\
 990 Set the number of bytes represented in each S-record.\n\
 991 This affects the communication protocol with the remote target.",
 992                   &setlist),
 993      &showlist);
 994
 995   add_show_from_set
 996     (add_set_cmd ("srec-max-retries", class_support, var_uinteger,
 997                   (char *) &srec_max_retries,
 998                   "\
 999 Set the number of retries for shipping S-records.\n\
1000 This affects the communication protocol with the remote target.",
1001                   &setlist),
1002      &showlist);
1003
1004   add_show_from_set
1005     (add_set_cmd ("srec-frame", class_support, var_uinteger,
1006                   (char *) &srec_frame,
1007                   "\
1008 Set the number of bytes in an S-record frame.\n\
1009 This affects the communication protocol with the remote target.",
1010                   &setlist),
1011      &showlist);
1012
1013   add_show_from_set
1014     (add_set_cmd ("srec-noise", class_support, var_zinteger,
1015                   (char *) &srec_noise,
1016                   "\
1017 Set number of S-record to send before deliberately flubbing a checksum.\n\
1018 Zero means flub none at all.  This affects the communication protocol\n\
1019 with the remote target.",
1020                   &setlist),
1021      &showlist);
1022
1023   add_show_from_set
1024     (add_set_cmd ("srec-sleep", class_support, var_zinteger,
1025                   (char *) &srec_sleep,
1026                   "\
1027 Set number of seconds to sleep after an S-record for a possible error message to arrive.\n\
1028 This affects the communication protocol with the remote target.",
1029                   &setlist),
1030      &showlist);
1031
1032   add_show_from_set
1033     (add_set_cmd ("srec-echo-pace", class_support, var_boolean,
1034                   (char *) &srec_echo_pace,
1035                   "\
1036 Set echo-verification.\n\
1037 When on, use verification by echo when downloading S-records.  This is\n\
1038 much slower, but generally more reliable.",
1039                   &setlist),
1040      &showlist);
1041 }