gdb/remote-bug.c

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