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