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