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