gdb/remote-bug.c

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