Subversion Repositories or1k

// OBSOLETE /* Remote debugging interface for Motorola's MVME187BUG monitor, an embedded

// OBSOLETE    monitor for the m88k.

// OBSOLETE 

// OBSOLETE    Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,

// OBSOLETE    2002 Free Software Foundation, Inc.

// OBSOLETE 

// OBSOLETE    Contributed by Cygnus Support.  Written by K. Richard Pixley.

// OBSOLETE 

// OBSOLETE    This file is part of GDB.

// OBSOLETE 

// OBSOLETE    This program is free software; you can redistribute it and/or modify

// OBSOLETE    it under the terms of the GNU General Public License as published by

// OBSOLETE    the Free Software Foundation; either version 2 of the License, or

// OBSOLETE    (at your option) any later version.

// OBSOLETE 

// OBSOLETE    This program is distributed in the hope that it will be useful,

// OBSOLETE    but WITHOUT ANY WARRANTY; without even the implied warranty of

// OBSOLETE    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// OBSOLETE    GNU General Public License for more details.

// OBSOLETE 

// OBSOLETE    You should have received a copy of the GNU General Public License

// OBSOLETE    along with this program; if not, write to the Free Software

// OBSOLETE    Foundation, Inc., 59 Temple Place - Suite 330,

// OBSOLETE    Boston, MA 02111-1307, USA.  */

// OBSOLETE 

// OBSOLETE #include "defs.h"

// OBSOLETE #include "inferior.h"

// OBSOLETE #include "gdb_string.h"

// OBSOLETE #include "regcache.h"

// OBSOLETE #include <ctype.h>

// OBSOLETE #include <fcntl.h>

// OBSOLETE #include <setjmp.h>

// OBSOLETE #include <errno.h>

// OBSOLETE 

// OBSOLETE #include "terminal.h"

// OBSOLETE #include "gdbcore.h"

// OBSOLETE #include "gdbcmd.h"

// OBSOLETE 

// OBSOLETE #include "serial.h"

// OBSOLETE #include "remote-utils.h"

// OBSOLETE 

// OBSOLETE /* External data declarations */

// OBSOLETE extern int stop_soon_quietly;       /* for wait_for_inferior */

// OBSOLETE 

// OBSOLETE /* Forward data declarations */

// OBSOLETE extern struct target_ops bug_ops;   /* Forward declaration */

// OBSOLETE 

// OBSOLETE /* Forward function declarations */

// OBSOLETE static int bug_clear_breakpoints (void);

// OBSOLETE 

// OBSOLETE static int bug_read_memory (CORE_ADDR memaddr,

// OBSOLETE                         unsigned char *myaddr, int len);

// OBSOLETE 

// OBSOLETE static int bug_write_memory (CORE_ADDR memaddr,

// OBSOLETE                          unsigned char *myaddr, int len);

// OBSOLETE 

// OBSOLETE /* This variable is somewhat arbitrary.  It's here so that it can be

// OBSOLETE    set from within a running gdb.  */

// OBSOLETE 

// OBSOLETE static int srec_max_retries = 3;

// OBSOLETE 

// OBSOLETE /* Each S-record download to the target consists of an S0 header

// OBSOLETE    record, some number of S3 data records, and one S7 termination

// OBSOLETE    record.  I call this download a "frame".  Srec_frame says how many

// OBSOLETE    bytes will be represented in each frame.  */

// OBSOLETE 

// OBSOLETE #define SREC_SIZE 160

// OBSOLETE static int srec_frame = SREC_SIZE;

// OBSOLETE 

// OBSOLETE /* This variable determines how many bytes will be represented in each

// OBSOLETE    S3 s-record.  */

// OBSOLETE 

// OBSOLETE static int srec_bytes = 40;

// OBSOLETE 

// OBSOLETE /* At one point it appeared to me as though the bug monitor could not

// OBSOLETE    really be expected to receive two sequential characters at 9600

// OBSOLETE    baud reliably.  Echo-pacing is an attempt to force data across the

// OBSOLETE    line even in this condition.  Specifically, in echo-pace mode, each

// OBSOLETE    character is sent one at a time and we look for the echo before

// OBSOLETE    sending the next.  This is excruciatingly slow.  */

// OBSOLETE 

// OBSOLETE static int srec_echo_pace = 0;

// OBSOLETE 

// OBSOLETE /* How long to wait after an srec for a possible error message.

// OBSOLETE    Similar to the above, I tried sleeping after sending each S3 record

// OBSOLETE    in hopes that I might actually see error messages from the bug

// OBSOLETE    monitor.  This might actually work if we were to use sleep

// OBSOLETE    intervals smaller than 1 second.  */

// OBSOLETE 

// OBSOLETE static int srec_sleep = 0;

// OBSOLETE 

// OBSOLETE /* Every srec_noise records, flub the checksum.  This is a debugging

// OBSOLETE    feature.  Set the variable to something other than 1 in order to

// OBSOLETE    inject *deliberate* checksum errors.  One might do this if one

// OBSOLETE    wanted to test error handling and recovery.  */

// OBSOLETE 

// OBSOLETE static int srec_noise = 0;

// OBSOLETE 

// OBSOLETE /* Called when SIGALRM signal sent due to alarm() timeout.  */

// OBSOLETE 

// OBSOLETE /* Number of SIGTRAPs we need to simulate.  That is, the next

// OBSOLETE    NEED_ARTIFICIAL_TRAP calls to bug_wait should just return

// OBSOLETE    SIGTRAP without actually waiting for anything.  */

// OBSOLETE 

// OBSOLETE static int need_artificial_trap = 0;

// OBSOLETE 

// OBSOLETE /*

// OBSOLETE  * Download a file specified in 'args', to the bug.

// OBSOLETE  */

// OBSOLETE 

// OBSOLETE static void

// OBSOLETE bug_load (char *args, int fromtty)

// OBSOLETE {

// OBSOLETE   bfd *abfd;

// OBSOLETE   asection *s;

// OBSOLETE   char buffer[1024];

// OBSOLETE 

// OBSOLETE   sr_check_open ();

// OBSOLETE 

// OBSOLETE   inferior_ptid = null_ptid;

// OBSOLETE   abfd = bfd_openr (args, 0);

// OBSOLETE   if (!abfd)

// OBSOLETE     {

// OBSOLETE       printf_filtered ("Unable to open file %s\n", args);

// OBSOLETE       return;

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE   if (bfd_check_format (abfd, bfd_object) == 0)

// OBSOLETE     {

// OBSOLETE       printf_filtered ("File is not an object file\n");

// OBSOLETE       return;

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE   s = abfd->sections;

// OBSOLETE   while (s != (asection *) NULL)

// OBSOLETE     {

// OBSOLETE       srec_frame = SREC_SIZE;

// OBSOLETE       if (s->flags & SEC_LOAD)

// OBSOLETE     {

// OBSOLETE       int i;

// OBSOLETE 

// OBSOLETE       char *buffer = xmalloc (srec_frame);

// OBSOLETE 

// OBSOLETE       printf_filtered ("%s\t: 0x%4lx .. 0x%4lx  ", s->name, s->vma, s->vma + s->_raw_size);

// OBSOLETE       gdb_flush (gdb_stdout);

// OBSOLETE       for (i = 0; i < s->_raw_size; i += srec_frame)

// OBSOLETE         {

// OBSOLETE           if (srec_frame > s->_raw_size - i)

// OBSOLETE             srec_frame = s->_raw_size - i;

// OBSOLETE 

// OBSOLETE           bfd_get_section_contents (abfd, s, buffer, i, srec_frame);

// OBSOLETE           bug_write_memory (s->vma + i, buffer, srec_frame);

// OBSOLETE           printf_filtered ("*");

// OBSOLETE           gdb_flush (gdb_stdout);

// OBSOLETE         }

// OBSOLETE       printf_filtered ("\n");

// OBSOLETE       xfree (buffer);

// OBSOLETE     }

// OBSOLETE       s = s->next;

// OBSOLETE     }

// OBSOLETE   sprintf (buffer, "rs ip %lx", (unsigned long) abfd->start_address);

// OBSOLETE   sr_write_cr (buffer);

// OBSOLETE   gr_expect_prompt ();

// OBSOLETE }

// OBSOLETE 

// OBSOLETE #if 0

// OBSOLETE static char *

// OBSOLETE get_word (char **p)

// OBSOLETE {

// OBSOLETE   char *s = *p;

// OBSOLETE   char *word;

// OBSOLETE   char *copy;

// OBSOLETE   size_t len;

// OBSOLETE 

// OBSOLETE   while (isspace (*s))

// OBSOLETE     s++;

// OBSOLETE 

// OBSOLETE   word = s;

// OBSOLETE 

// OBSOLETE   len = 0;

// OBSOLETE 

// OBSOLETE   while (*s && !isspace (*s))

// OBSOLETE     {

// OBSOLETE       s++;

// OBSOLETE       len++;

// OBSOLETE 

// OBSOLETE     }

// OBSOLETE   copy = xmalloc (len + 1);

// OBSOLETE   memcpy (copy, word, len);

// OBSOLETE   copy[len] = 0;

// OBSOLETE   *p = s;

// OBSOLETE   return copy;

// OBSOLETE }

// OBSOLETE #endif

// OBSOLETE 

// OBSOLETE static struct gr_settings bug_settings =

// OBSOLETE {

// OBSOLETE   "Bug>",                   /* prompt */

// OBSOLETE   &bug_ops,                 /* ops */

// OBSOLETE   bug_clear_breakpoints,    /* clear_all_breakpoints */

// OBSOLETE   gr_generic_checkin,               /* checkin */

// OBSOLETE };

// OBSOLETE 

// OBSOLETE static char *cpu_check_strings[] =

// OBSOLETE {

// OBSOLETE   "=",

// OBSOLETE   "Invalid Register",

// OBSOLETE };

// OBSOLETE 

// OBSOLETE static void

// OBSOLETE bug_open (char *args, int from_tty)

// OBSOLETE {

// OBSOLETE   if (args == NULL)

// OBSOLETE     args = "";

// OBSOLETE 

// OBSOLETE   gr_open (args, from_tty, &bug_settings);

// OBSOLETE   /* decide *now* whether we are on an 88100 or an 88110 */

// OBSOLETE   sr_write_cr ("rs cr06");

// OBSOLETE   sr_expect ("rs cr06");

// OBSOLETE 

// OBSOLETE   switch (gr_multi_scan (cpu_check_strings, 0))

// OBSOLETE     {

// OBSOLETE     case 0:                 /* this is an m88100 */

// OBSOLETE       target_is_m88110 = 0;

// OBSOLETE       break;

// OBSOLETE     case 1:                 /* this is an m88110 */

// OBSOLETE       target_is_m88110 = 1;

// OBSOLETE       break;

// OBSOLETE     default:

// OBSOLETE       internal_error (__FILE__, __LINE__, "failed internal consistency check");

// OBSOLETE     }

// OBSOLETE }

// OBSOLETE 

// OBSOLETE /* Tell the remote machine to resume.  */

// OBSOLETE 

// OBSOLETE void

// OBSOLETE bug_resume (ptid_t ptid, int step, enum target_signal sig)

// OBSOLETE {

// OBSOLETE   if (step)

// OBSOLETE     {

// OBSOLETE       sr_write_cr ("t");

// OBSOLETE 

// OBSOLETE       /* Force the next bug_wait to return a trap.  Not doing anything

// OBSOLETE          about I/O from the target means that the user has to type

// OBSOLETE          "continue" to see any.  FIXME, this should be fixed.  */

// OBSOLETE       need_artificial_trap = 1;

// OBSOLETE     }

// OBSOLETE   else

// OBSOLETE     sr_write_cr ("g");

// OBSOLETE 

// OBSOLETE   return;

// OBSOLETE }

// OBSOLETE 

// OBSOLETE /* Wait until the remote machine stops, then return,

// OBSOLETE    storing status in STATUS just as `wait' would.  */

// OBSOLETE 

// OBSOLETE static char *wait_strings[] =

// OBSOLETE {

// OBSOLETE   "At Breakpoint",

// OBSOLETE   "Exception: Data Access Fault (Local Bus Timeout)",

// OBSOLETE   "\r8??\?-Bug>",           /* The '\?' avoids creating a trigraph */

// OBSOLETE   "\r197-Bug>",

// OBSOLETE   NULL,

// OBSOLETE };

// OBSOLETE 

// OBSOLETE ptid_t

// OBSOLETE bug_wait (ptid_t ptid, struct target_waitstatus *status)

// OBSOLETE {

// OBSOLETE   int old_timeout = sr_get_timeout ();

// OBSOLETE   int old_immediate_quit = immediate_quit;

// OBSOLETE 

// OBSOLETE   status->kind = TARGET_WAITKIND_EXITED;

// OBSOLETE   status->value.integer = 0;

// OBSOLETE 

// OBSOLETE   /* read off leftovers from resume so that the rest can be passed

// OBSOLETE      back out as stdout.  */

// OBSOLETE   if (need_artificial_trap == 0)

// OBSOLETE     {

// OBSOLETE       sr_expect ("Effective address: ");

// OBSOLETE       (void) sr_get_hex_word ();

// OBSOLETE       sr_expect ("\r\n");

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE   sr_set_timeout (-1);              /* Don't time out -- user program is running. */

// OBSOLETE   immediate_quit = 1;               /* Helps ability to QUIT */

// OBSOLETE 

// OBSOLETE   switch (gr_multi_scan (wait_strings, need_artificial_trap == 0))

// OBSOLETE     {

// OBSOLETE     case 0:                 /* breakpoint case */

// OBSOLETE       status->kind = TARGET_WAITKIND_STOPPED;

// OBSOLETE       status->value.sig = TARGET_SIGNAL_TRAP;

// OBSOLETE       /* user output from the target can be discarded here. (?) */

// OBSOLETE       gr_expect_prompt ();

// OBSOLETE       break;

// OBSOLETE 

// OBSOLETE     case 1:                 /* bus error */

// OBSOLETE       status->kind = TARGET_WAITKIND_STOPPED;

// OBSOLETE       status->value.sig = TARGET_SIGNAL_BUS;

// OBSOLETE       /* user output from the target can be discarded here. (?) */

// OBSOLETE       gr_expect_prompt ();

// OBSOLETE       break;

// OBSOLETE 

// OBSOLETE     case 2:                 /* normal case */

// OBSOLETE     case 3:

// OBSOLETE       if (need_artificial_trap != 0)

// OBSOLETE     {

// OBSOLETE       /* stepping */

// OBSOLETE       status->kind = TARGET_WAITKIND_STOPPED;

// OBSOLETE       status->value.sig = TARGET_SIGNAL_TRAP;

// OBSOLETE       need_artificial_trap--;

// OBSOLETE       break;

// OBSOLETE     }

// OBSOLETE       else

// OBSOLETE     {

// OBSOLETE       /* exit case */

// OBSOLETE       status->kind = TARGET_WAITKIND_EXITED;

// OBSOLETE       status->value.integer = 0;

// OBSOLETE       break;

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE     case -1:                        /* trouble */

// OBSOLETE     default:

// OBSOLETE       fprintf_filtered (gdb_stderr,

// OBSOLETE                     "Trouble reading target during wait\n");

// OBSOLETE       break;

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE   sr_set_timeout (old_timeout);

// OBSOLETE   immediate_quit = old_immediate_quit;

// OBSOLETE   return inferior_ptid;

// OBSOLETE }

// OBSOLETE 

// OBSOLETE /* Return the name of register number REGNO

// OBSOLETE    in the form input and output by bug.

// OBSOLETE 

// OBSOLETE    Returns a pointer to a static buffer containing the answer.  */

// OBSOLETE static char *

// OBSOLETE get_reg_name (int regno)

// OBSOLETE {

// OBSOLETE   static char *rn[] =

// OBSOLETE   {

// OBSOLETE     "r00", "r01", "r02", "r03", "r04", "r05", "r06", "r07",

// OBSOLETE     "r08", "r09", "r10", "r11", "r12", "r13", "r14", "r15",

// OBSOLETE     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",

// OBSOLETE     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",

// OBSOLETE 

// OBSOLETE   /* these get confusing because we omit a few and switch some ordering around. */

// OBSOLETE 

// OBSOLETE     "cr01",                 /* 32 = psr */

// OBSOLETE     "fcr62",                        /* 33 = fpsr */

// OBSOLETE     "fcr63",                        /* 34 = fpcr */

// OBSOLETE     "ip",                   /* this is something of a cheat. */

// OBSOLETE   /* 35 = sxip */

// OBSOLETE     "cr05",                 /* 36 = snip */

// OBSOLETE     "cr06",                 /* 37 = sfip */

// OBSOLETE 

// OBSOLETE     "x00", "x01", "x02", "x03", "x04", "x05", "x06", "x07",

// OBSOLETE     "x08", "x09", "x10", "x11", "x12", "x13", "x14", "x15",

// OBSOLETE     "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",

// OBSOLETE     "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",

// OBSOLETE   };

// OBSOLETE 

// OBSOLETE   return rn[regno];

// OBSOLETE }

// OBSOLETE 

// OBSOLETE #if 0                               /* not currently used */

// OBSOLETE /* Read from remote while the input matches STRING.  Return zero on

// OBSOLETE    success, -1 on failure.  */

// OBSOLETE 

// OBSOLETE static int

// OBSOLETE bug_scan (char *s)

// OBSOLETE {

// OBSOLETE   int c;

// OBSOLETE 

// OBSOLETE   while (*s)

// OBSOLETE     {

// OBSOLETE       c = sr_readchar ();

// OBSOLETE       if (c != *s++)

// OBSOLETE     {

// OBSOLETE       fflush (stdout);

// OBSOLETE       printf ("\nNext character is '%c' - %d and s is \"%s\".\n", c, c, --s);

// OBSOLETE       return (-1);

// OBSOLETE     }

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE   return (0);

// OBSOLETE }

// OBSOLETE #endif /* never */

// OBSOLETE 

// OBSOLETE static int

// OBSOLETE bug_srec_write_cr (char *s)

// OBSOLETE {

// OBSOLETE   char *p = s;

// OBSOLETE 

// OBSOLETE   if (srec_echo_pace)

// OBSOLETE     for (p = s; *p; ++p)

// OBSOLETE       {

// OBSOLETE     if (sr_get_debug () > 0)

// OBSOLETE       printf ("%c", *p);

// OBSOLETE 

// OBSOLETE     do

// OBSOLETE       serial_write (sr_get_desc (), p, 1);

// OBSOLETE     while (sr_pollchar () != *p);

// OBSOLETE       }

// OBSOLETE   else

// OBSOLETE     {

// OBSOLETE       sr_write_cr (s);

// OBSOLETE /*       return(bug_scan (s) || bug_scan ("\n")); */

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE   return (0);

// OBSOLETE }

// OBSOLETE 

// OBSOLETE /* Store register REGNO, or all if REGNO == -1. */

// OBSOLETE 

// OBSOLETE static void

// OBSOLETE bug_fetch_register (int regno)

// OBSOLETE {

// OBSOLETE   sr_check_open ();

// OBSOLETE 

// OBSOLETE   if (regno == -1)

// OBSOLETE     {

// OBSOLETE       int i;

// OBSOLETE 

// OBSOLETE       for (i = 0; i < NUM_REGS; ++i)

// OBSOLETE     bug_fetch_register (i);

// OBSOLETE     }

// OBSOLETE   else if (target_is_m88110 && regno == SFIP_REGNUM)

// OBSOLETE     {

// OBSOLETE       /* m88110 has no sfip. */

// OBSOLETE       long l = 0;

// OBSOLETE       supply_register (regno, (char *) &l);

// OBSOLETE     }

// OBSOLETE   else if (regno < XFP_REGNUM)

// OBSOLETE     {

// OBSOLETE       char buffer[MAX_REGISTER_RAW_SIZE];

// OBSOLETE 

// OBSOLETE       sr_write ("rs ", 3);

// OBSOLETE       sr_write_cr (get_reg_name (regno));

// OBSOLETE       sr_expect ("=");

// OBSOLETE       store_unsigned_integer (buffer, REGISTER_RAW_SIZE (regno),

// OBSOLETE                           sr_get_hex_word ());

// OBSOLETE       gr_expect_prompt ();

// OBSOLETE       supply_register (regno, buffer);

// OBSOLETE     }

// OBSOLETE   else

// OBSOLETE     {

// OBSOLETE       /* Float register so we need to parse a strange data format. */

// OBSOLETE       long p;

// OBSOLETE       unsigned char fpreg_buf[10];

// OBSOLETE 

// OBSOLETE       sr_write ("rs ", 3);

// OBSOLETE       sr_write (get_reg_name (regno), strlen (get_reg_name (regno)));

// OBSOLETE       sr_write_cr (";d");

// OBSOLETE       sr_expect ("rs");

// OBSOLETE       sr_expect (get_reg_name (regno));

// OBSOLETE       sr_expect (";d");

// OBSOLETE       sr_expect ("=");

// OBSOLETE 

// OBSOLETE       /* sign */

// OBSOLETE       p = sr_get_hex_digit (1);

// OBSOLETE       fpreg_buf[0] = p << 7;

// OBSOLETE 

// OBSOLETE       /* exponent */

// OBSOLETE       sr_expect ("_");

// OBSOLETE       p = sr_get_hex_digit (1);

// OBSOLETE       fpreg_buf[0] += (p << 4);

// OBSOLETE       fpreg_buf[0] += sr_get_hex_digit (1);

// OBSOLETE 

// OBSOLETE       fpreg_buf[1] = sr_get_hex_digit (1) << 4;

// OBSOLETE 

// OBSOLETE       /* fraction */

// OBSOLETE       sr_expect ("_");

// OBSOLETE       fpreg_buf[1] += sr_get_hex_digit (1);

// OBSOLETE 

// OBSOLETE       fpreg_buf[2] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);

// OBSOLETE       fpreg_buf[3] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);

// OBSOLETE       fpreg_buf[4] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);

// OBSOLETE       fpreg_buf[5] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);

// OBSOLETE       fpreg_buf[6] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);

// OBSOLETE       fpreg_buf[7] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);

// OBSOLETE       fpreg_buf[8] = 0;

// OBSOLETE       fpreg_buf[9] = 0;

// OBSOLETE 

// OBSOLETE       gr_expect_prompt ();

// OBSOLETE       supply_register (regno, fpreg_buf);

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE   return;

// OBSOLETE }

// OBSOLETE 

// OBSOLETE /* Store register REGNO, or all if REGNO == -1. */

// OBSOLETE 

// OBSOLETE static void

// OBSOLETE bug_store_register (int regno)

// OBSOLETE {

// OBSOLETE   char buffer[1024];

// OBSOLETE   sr_check_open ();

// OBSOLETE 

// OBSOLETE   if (regno == -1)

// OBSOLETE     {

// OBSOLETE       int i;

// OBSOLETE 

// OBSOLETE       for (i = 0; i < NUM_REGS; ++i)

// OBSOLETE     bug_store_register (i);

// OBSOLETE     }

// OBSOLETE   else

// OBSOLETE     {

// OBSOLETE       char *regname;

// OBSOLETE 

// OBSOLETE       regname = get_reg_name (regno);

// OBSOLETE 

// OBSOLETE       if (target_is_m88110 && regno == SFIP_REGNUM)

// OBSOLETE     return;

// OBSOLETE       else if (regno < XFP_REGNUM)

// OBSOLETE     sprintf (buffer, "rs %s %08lx",

// OBSOLETE              regname,

// OBSOLETE              (long) read_register (regno));

// OBSOLETE       else

// OBSOLETE     {

// OBSOLETE       unsigned char *fpreg_buf =

// OBSOLETE       (unsigned char *) &registers[REGISTER_BYTE (regno)];

// OBSOLETE 

// OBSOLETE       sprintf (buffer, "rs %s %1x_%02x%1x_%1x%02x%02x%02x%02x%02x%02x;d",

// OBSOLETE                regname,

// OBSOLETE       /* sign */

// OBSOLETE                (fpreg_buf[0] >> 7) & 0xf,

// OBSOLETE       /* exponent */

// OBSOLETE                fpreg_buf[0] & 0x7f,

// OBSOLETE                (fpreg_buf[1] >> 8) & 0xf,

// OBSOLETE       /* fraction */

// OBSOLETE                fpreg_buf[1] & 0xf,

// OBSOLETE                fpreg_buf[2],

// OBSOLETE                fpreg_buf[3],

// OBSOLETE                fpreg_buf[4],

// OBSOLETE                fpreg_buf[5],

// OBSOLETE                fpreg_buf[6],

// OBSOLETE                fpreg_buf[7]);

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE       sr_write_cr (buffer);

// OBSOLETE       gr_expect_prompt ();

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE   return;

// OBSOLETE }

// OBSOLETE 

// OBSOLETE /* Transfer LEN bytes between GDB address MYADDR and target address

// OBSOLETE    MEMADDR.  If WRITE is non-zero, transfer them to the target,

// OBSOLETE    otherwise transfer them from the target.  TARGET is unused.

// OBSOLETE 

// OBSOLETE    Returns the number of bytes transferred. */

// OBSOLETE 

// OBSOLETE int

// OBSOLETE bug_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,

// OBSOLETE              struct mem_attrib *attrib, struct target_ops *target)

// OBSOLETE {

// OBSOLETE   int res;

// OBSOLETE 

// OBSOLETE   if (len <= 0)

// OBSOLETE     return 0;

// OBSOLETE 

// OBSOLETE   if (write)

// OBSOLETE     res = bug_write_memory (memaddr, myaddr, len);

// OBSOLETE   else

// OBSOLETE     res = bug_read_memory (memaddr, myaddr, len);

// OBSOLETE 

// OBSOLETE   return res;

// OBSOLETE }

// OBSOLETE 

// OBSOLETE static void

// OBSOLETE start_load (void)

// OBSOLETE {

// OBSOLETE   char *command;

// OBSOLETE 

// OBSOLETE   command = (srec_echo_pace ? "lo 0 ;x" : "lo 0");

// OBSOLETE 

// OBSOLETE   sr_write_cr (command);

// OBSOLETE   sr_expect (command);

// OBSOLETE   sr_expect ("\r\n");

// OBSOLETE   bug_srec_write_cr ("S0030000FC");

// OBSOLETE   return;

// OBSOLETE }

// OBSOLETE 

// OBSOLETE /* This is an extremely vulnerable and fragile function.  I've made

// OBSOLETE    considerable attempts to make this deterministic, but I've

// OBSOLETE    certainly forgotten something.  The trouble is that S-records are

// OBSOLETE    only a partial file format, not a protocol.  Worse, apparently the

// OBSOLETE    m88k bug monitor does not run in real time while receiving

// OBSOLETE    S-records.  Hence, we must pay excruciating attention to when and

// OBSOLETE    where error messages are returned, and what has actually been sent.

// OBSOLETE 

// OBSOLETE    Each call represents a chunk of memory to be sent to the target.

// OBSOLETE    We break that chunk into an S0 header record, some number of S3

// OBSOLETE    data records each containing srec_bytes, and an S7 termination

// OBSOLETE    record.  */

// OBSOLETE 

// OBSOLETE static char *srecord_strings[] =

// OBSOLETE {

// OBSOLETE   "S-RECORD",

// OBSOLETE   "-Bug>",

// OBSOLETE   NULL,

// OBSOLETE };

// OBSOLETE 

// OBSOLETE static int

// OBSOLETE bug_write_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)

// OBSOLETE {

// OBSOLETE   int done;

// OBSOLETE   int checksum;

// OBSOLETE   int x;

// OBSOLETE   int retries;

// OBSOLETE   char *buffer = alloca ((srec_bytes + 8) << 1);

// OBSOLETE 

// OBSOLETE   retries = 0;

// OBSOLETE 

// OBSOLETE   do

// OBSOLETE     {

// OBSOLETE       done = 0;

// OBSOLETE 

// OBSOLETE       if (retries > srec_max_retries)

// OBSOLETE     return (-1);

// OBSOLETE 

// OBSOLETE       if (retries > 0)

// OBSOLETE     {

// OBSOLETE       if (sr_get_debug () > 0)

// OBSOLETE         printf ("\n<retrying...>\n");

// OBSOLETE 

// OBSOLETE       /* This gr_expect_prompt call is extremely important.  Without

// OBSOLETE          it, we will tend to resend our packet so fast that it

// OBSOLETE          will arrive before the bug monitor is ready to receive

// OBSOLETE          it.  This would lead to a very ugly resend loop.  */

// OBSOLETE 

// OBSOLETE       gr_expect_prompt ();

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE       start_load ();

// OBSOLETE 

// OBSOLETE       while (done < len)

// OBSOLETE     {

// OBSOLETE       int thisgo;

// OBSOLETE       int idx;

// OBSOLETE       char *buf = buffer;

// OBSOLETE       CORE_ADDR address;

// OBSOLETE 

// OBSOLETE       checksum = 0;

// OBSOLETE       thisgo = len - done;

// OBSOLETE       if (thisgo > srec_bytes)

// OBSOLETE         thisgo = srec_bytes;

// OBSOLETE 

// OBSOLETE       address = memaddr + done;

// OBSOLETE       sprintf (buf, "S3%02X%08lX", thisgo + 4 + 1, (long) address);

// OBSOLETE       buf += 12;

// OBSOLETE 

// OBSOLETE       checksum += (thisgo + 4 + 1

// OBSOLETE                    + (address & 0xff)

// OBSOLETE                    + ((address >> 8) & 0xff)

// OBSOLETE                    + ((address >> 16) & 0xff)

// OBSOLETE                    + ((address >> 24) & 0xff));

// OBSOLETE 

// OBSOLETE       for (idx = 0; idx < thisgo; idx++)

// OBSOLETE         {

// OBSOLETE           sprintf (buf, "%02X", myaddr[idx + done]);

// OBSOLETE           checksum += myaddr[idx + done];

// OBSOLETE           buf += 2;

// OBSOLETE         }

// OBSOLETE 

// OBSOLETE       if (srec_noise > 0)

// OBSOLETE         {

// OBSOLETE           /* FIXME-NOW: insert a deliberate error every now and then.

// OBSOLETE              This is intended for testing/debugging the error handling

// OBSOLETE              stuff.  */

// OBSOLETE           static int counter = 0;

// OBSOLETE           if (++counter > srec_noise)

// OBSOLETE             {

// OBSOLETE               counter = 0;

// OBSOLETE               ++checksum;

// OBSOLETE             }

// OBSOLETE         }

// OBSOLETE 

// OBSOLETE       sprintf (buf, "%02X", ~checksum & 0xff);

// OBSOLETE       bug_srec_write_cr (buffer);

// OBSOLETE 

// OBSOLETE       if (srec_sleep != 0)

// OBSOLETE         sleep (srec_sleep);

// OBSOLETE 

// OBSOLETE       /* This pollchar is probably redundant to the gr_multi_scan

// OBSOLETE          below.  Trouble is, we can't be sure when or where an

// OBSOLETE          error message will appear.  Apparently, when running at

// OBSOLETE          full speed from a typical sun4, error messages tend to

// OBSOLETE          appear to arrive only *after* the s7 record.   */

// OBSOLETE 

// OBSOLETE       if ((x = sr_pollchar ()) != 0)

// OBSOLETE         {

// OBSOLETE           if (sr_get_debug () > 0)

// OBSOLETE             printf ("\n<retrying...>\n");

// OBSOLETE 

// OBSOLETE           ++retries;

// OBSOLETE 

// OBSOLETE           /* flush any remaining input and verify that we are back

// OBSOLETE              at the prompt level. */

// OBSOLETE           gr_expect_prompt ();

// OBSOLETE           /* start all over again. */

// OBSOLETE           start_load ();

// OBSOLETE           done = 0;

// OBSOLETE           continue;

// OBSOLETE         }

// OBSOLETE 

// OBSOLETE       done += thisgo;

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE       bug_srec_write_cr ("S7060000000000F9");

// OBSOLETE       ++retries;

// OBSOLETE 

// OBSOLETE       /* Having finished the load, we need to figure out whether we

// OBSOLETE          had any errors.  */

// OBSOLETE     }

// OBSOLETE   while (gr_multi_scan (srecord_strings, 0) == 0);;

// OBSOLETE 

// OBSOLETE   return (0);

// OBSOLETE }

// OBSOLETE 

// OBSOLETE /* Copy LEN bytes of data from debugger memory at MYADDR

// OBSOLETE    to inferior's memory at MEMADDR.  Returns errno value.

// OBSOLETE    * sb/sh instructions don't work on unaligned addresses, when TU=1.

// OBSOLETE  */

// OBSOLETE 

// OBSOLETE /* Read LEN bytes from inferior memory at MEMADDR.  Put the result

// OBSOLETE    at debugger address MYADDR.  Returns errno value.  */

// OBSOLETE static int

// OBSOLETE bug_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)

// OBSOLETE {

// OBSOLETE   char request[100];

// OBSOLETE   char *buffer;

// OBSOLETE   char *p;

// OBSOLETE   char type;

// OBSOLETE   char size;

// OBSOLETE   unsigned char c;

// OBSOLETE   unsigned int inaddr;

// OBSOLETE   unsigned int checksum;

// OBSOLETE 

// OBSOLETE   sprintf (request, "du 0 %lx:&%d", (long) memaddr, len);

// OBSOLETE   sr_write_cr (request);

// OBSOLETE 

// OBSOLETE   p = buffer = alloca (len);

// OBSOLETE 

// OBSOLETE   /* scan up through the header */

// OBSOLETE   sr_expect ("S0030000FC");

// OBSOLETE 

// OBSOLETE   while (p < buffer + len)

// OBSOLETE     {

// OBSOLETE       /* scan off any white space. */

// OBSOLETE       while (sr_readchar () != 'S');;

// OBSOLETE 

// OBSOLETE       /* what kind of s-rec? */

// OBSOLETE       type = sr_readchar ();

// OBSOLETE 

// OBSOLETE       /* scan record size */

// OBSOLETE       sr_get_hex_byte (&size);

// OBSOLETE       checksum = size;

// OBSOLETE       --size;

// OBSOLETE       inaddr = 0;

// OBSOLETE 

// OBSOLETE       switch (type)

// OBSOLETE     {

// OBSOLETE     case '7':

// OBSOLETE     case '8':

// OBSOLETE     case '9':

// OBSOLETE       goto done;

// OBSOLETE 

// OBSOLETE     case '3':

// OBSOLETE       sr_get_hex_byte (&c);

// OBSOLETE       inaddr = (inaddr << 8) + c;

// OBSOLETE       checksum += c;

// OBSOLETE       --size;

// OBSOLETE       /* intentional fall through */

// OBSOLETE     case '2':

// OBSOLETE       sr_get_hex_byte (&c);

// OBSOLETE       inaddr = (inaddr << 8) + c;

// OBSOLETE       checksum += c;

// OBSOLETE       --size;

// OBSOLETE       /* intentional fall through */

// OBSOLETE     case '1':

// OBSOLETE       sr_get_hex_byte (&c);

// OBSOLETE       inaddr = (inaddr << 8) + c;

// OBSOLETE       checksum += c;

// OBSOLETE       --size;

// OBSOLETE       sr_get_hex_byte (&c);

// OBSOLETE       inaddr = (inaddr << 8) + c;

// OBSOLETE       checksum += c;

// OBSOLETE       --size;

// OBSOLETE       break;

// OBSOLETE 

// OBSOLETE     default:

// OBSOLETE       /* bonk */

// OBSOLETE       error ("reading s-records.");

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE       if (inaddr < memaddr

// OBSOLETE       || (memaddr + len) < (inaddr + size))

// OBSOLETE     error ("srec out of memory range.");

// OBSOLETE 

// OBSOLETE       if (p != buffer + inaddr - memaddr)

// OBSOLETE     error ("srec out of sequence.");

// OBSOLETE 

// OBSOLETE       for (; size; --size, ++p)

// OBSOLETE     {

// OBSOLETE       sr_get_hex_byte (p);

// OBSOLETE       checksum += *p;

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE       sr_get_hex_byte (&c);

// OBSOLETE       if (c != (~checksum & 0xff))

// OBSOLETE     error ("bad s-rec checksum");

// OBSOLETE     }

// OBSOLETE 

// OBSOLETE done:

// OBSOLETE   gr_expect_prompt ();

// OBSOLETE   if (p != buffer + len)

// OBSOLETE     return (1);

// OBSOLETE 

// OBSOLETE   memcpy (myaddr, buffer, len);

// OBSOLETE   return (0);