darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2024-11-25 05:00:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
3bada2a2df
darling-gdb/gdb/remote-bug.c
Andrew Cagney 7fb623f7ad Obsolete m88k.
2002-07-24 23:51:36 +00:00

1028 lines
37 KiB
C
Raw Blame History

// 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);
// OBSOLETE }
// OBSOLETE
// OBSOLETE #define MAX_BREAKS 16
// OBSOLETE static int num_brkpts = 0;
// OBSOLETE
// OBSOLETE /* Insert a breakpoint at ADDR. SAVE is normally the address of the
// OBSOLETE pattern buffer where the instruction that the breakpoint overwrites
// OBSOLETE is saved. It is unused here since the bug is responsible for
// OBSOLETE saving/restoring the original instruction. */
// OBSOLETE
// OBSOLETE static int
// OBSOLETE bug_insert_breakpoint (CORE_ADDR addr, char *save)
// OBSOLETE {
// OBSOLETE sr_check_open ();
// OBSOLETE
// OBSOLETE if (num_brkpts < MAX_BREAKS)
// OBSOLETE {
// OBSOLETE char buffer[100];
// OBSOLETE
// OBSOLETE num_brkpts++;
// OBSOLETE sprintf (buffer, "br %lx", (long) addr);
// OBSOLETE sr_write_cr (buffer);
// OBSOLETE gr_expect_prompt ();
// OBSOLETE return (0);
// OBSOLETE }
// OBSOLETE else
// OBSOLETE {
// OBSOLETE fprintf_filtered (gdb_stderr,
// OBSOLETE "Too many break points, break point not installed\n");
// OBSOLETE return (1);
// OBSOLETE }
// OBSOLETE
// OBSOLETE }
// OBSOLETE
// OBSOLETE /* Remove a breakpoint at ADDR. SAVE is normally the previously
// OBSOLETE saved pattern, but is unused here since the bug is responsible
// OBSOLETE for saving/restoring instructions. */
// OBSOLETE
// OBSOLETE static int
// OBSOLETE bug_remove_breakpoint (CORE_ADDR addr, char *save)
// OBSOLETE {
// OBSOLETE if (num_brkpts > 0)
// OBSOLETE {
// OBSOLETE char buffer[100];
// OBSOLETE
// OBSOLETE num_brkpts--;
// OBSOLETE sprintf (buffer, "nobr %lx", (long) addr);
// OBSOLETE sr_write_cr (buffer);
// OBSOLETE gr_expect_prompt ();
// OBSOLETE
// OBSOLETE }
// OBSOLETE return (0);
// OBSOLETE }
// OBSOLETE
// OBSOLETE /* Clear the bugs notion of what the break points are */
// OBSOLETE static int
// OBSOLETE bug_clear_breakpoints (void)
// OBSOLETE {
// OBSOLETE
// OBSOLETE if (sr_is_open ())
// OBSOLETE {
// OBSOLETE sr_write_cr ("nobr");
// OBSOLETE sr_expect ("nobr");
// OBSOLETE gr_expect_prompt ();
// OBSOLETE }
// OBSOLETE num_brkpts = 0;
// OBSOLETE return (0);
// OBSOLETE }
// OBSOLETE
// OBSOLETE struct target_ops bug_ops;
// OBSOLETE
// OBSOLETE static void
// OBSOLETE init_bug_ops (void)
// OBSOLETE {
// OBSOLETE bug_ops.to_shortname = "bug";
// OBSOLETE "Remote BUG monitor",
// OBSOLETE bug_ops.to_longname = "Use the mvme187 board running the BUG monitor connected by a serial line.";
// OBSOLETE bug_ops.to_doc = " ";
// OBSOLETE bug_ops.to_open = bug_open;
// OBSOLETE bug_ops.to_close = gr_close;
// OBSOLETE bug_ops.to_attach = 0;
// OBSOLETE bug_ops.to_post_attach = NULL;
// OBSOLETE bug_ops.to_require_attach = NULL;
// OBSOLETE bug_ops.to_detach = gr_detach;
// OBSOLETE bug_ops.to_require_detach = NULL;
// OBSOLETE bug_ops.to_resume = bug_resume;
// OBSOLETE bug_ops.to_wait = bug_wait;
// OBSOLETE bug_ops.to_post_wait = NULL;
// OBSOLETE bug_ops.to_fetch_registers = bug_fetch_register;
// OBSOLETE bug_ops.to_store_registers = bug_store_register;
// OBSOLETE bug_ops.to_prepare_to_store = gr_prepare_to_store;
// OBSOLETE bug_ops.to_xfer_memory = bug_xfer_memory;
// OBSOLETE bug_ops.to_files_info = gr_files_info;
// OBSOLETE bug_ops.to_insert_breakpoint = bug_insert_breakpoint;
// OBSOLETE bug_ops.to_remove_breakpoint = bug_remove_breakpoint;
// OBSOLETE bug_ops.to_terminal_init = 0;
// OBSOLETE bug_ops.to_terminal_inferior = 0;
// OBSOLETE bug_ops.to_terminal_ours_for_output = 0;
// OBSOLETE bug_ops.to_terminal_ours = 0;
// OBSOLETE bug_ops.to_terminal_info = 0;
// OBSOLETE bug_ops.to_kill = gr_kill;
// OBSOLETE bug_ops.to_load = bug_load;
// OBSOLETE bug_ops.to_lookup_symbol = 0;
// OBSOLETE bug_ops.to_create_inferior = gr_create_inferior;
// OBSOLETE bug_ops.to_post_startup_inferior = NULL;
// OBSOLETE bug_ops.to_acknowledge_created_inferior = NULL;
// OBSOLETE bug_ops.to_clone_and_follow_inferior = NULL;
// OBSOLETE bug_ops.to_post_follow_inferior_by_clone = NULL;
// OBSOLETE bug_ops.to_insert_fork_catchpoint = NULL;
// OBSOLETE bug_ops.to_remove_fork_catchpoint = NULL;
// OBSOLETE bug_ops.to_insert_vfork_catchpoint = NULL;
// OBSOLETE bug_ops.to_remove_vfork_catchpoint = NULL;
// OBSOLETE bug_ops.to_has_forked = NULL;
// OBSOLETE bug_ops.to_has_vforked = NULL;
// OBSOLETE bug_ops.to_can_follow_vfork_prior_to_exec = NULL;
// OBSOLETE bug_ops.to_post_follow_vfork = NULL;
// OBSOLETE bug_ops.to_insert_exec_catchpoint = NULL;
// OBSOLETE bug_ops.to_remove_exec_catchpoint = NULL;
// OBSOLETE bug_ops.to_has_execd = NULL;
// OBSOLETE bug_ops.to_reported_exec_events_per_exec_call = NULL;
// OBSOLETE bug_ops.to_has_exited = NULL;
// OBSOLETE bug_ops.to_mourn_inferior = gr_mourn;
// OBSOLETE bug_ops.to_can_run = 0;
// OBSOLETE bug_ops.to_notice_signals = 0;
// OBSOLETE bug_ops.to_thread_alive = 0;
// OBSOLETE bug_ops.to_stop = 0;
// OBSOLETE bug_ops.to_pid_to_exec_file = NULL;
// OBSOLETE bug_ops.to_stratum = process_stratum;
// OBSOLETE bug_ops.DONT_USE = 0;
// OBSOLETE bug_ops.to_has_all_memory = 1;
// OBSOLETE bug_ops.to_has_memory = 1;
// OBSOLETE bug_ops.to_has_stack = 1;
// OBSOLETE bug_ops.to_has_registers = 0;
// OBSOLETE bug_ops.to_has_execution = 0;
// OBSOLETE bug_ops.to_sections = 0;
// OBSOLETE bug_ops.to_sections_end = 0;
// OBSOLETE bug_ops.to_magic = OPS_MAGIC; /* Always the last thing */
// OBSOLETE } /* init_bug_ops */
// OBSOLETE
// OBSOLETE void
// OBSOLETE _initialize_remote_bug (void)
// OBSOLETE {
// OBSOLETE init_bug_ops ();
// OBSOLETE add_target (&bug_ops);
// OBSOLETE
// OBSOLETE add_show_from_set
// OBSOLETE (add_set_cmd ("srec-bytes", class_support, var_uinteger,
// OBSOLETE (char *) &srec_bytes,
// OBSOLETE "\
// OBSOLETE Set the number of bytes represented in each S-record.\n\
// OBSOLETE This affects the communication protocol with the remote target.",
// OBSOLETE &setlist),
// OBSOLETE &showlist);
// OBSOLETE
// OBSOLETE add_show_from_set
// OBSOLETE (add_set_cmd ("srec-max-retries", class_support, var_uinteger,
// OBSOLETE (char *) &srec_max_retries,
// OBSOLETE "\
// OBSOLETE Set the number of retries for shipping S-records.\n\
// OBSOLETE This affects the communication protocol with the remote target.",
// OBSOLETE &setlist),
// OBSOLETE &showlist);
// OBSOLETE
// OBSOLETE #if 0
// OBSOLETE /* This needs to set SREC_SIZE, not srec_frame which gets changed at the
// OBSOLETE end of a download. But do we need the option at all? */
// OBSOLETE add_show_from_set
// OBSOLETE (add_set_cmd ("srec-frame", class_support, var_uinteger,
// OBSOLETE (char *) &srec_frame,
// OBSOLETE "\
// OBSOLETE Set the number of bytes in an S-record frame.\n\
// OBSOLETE This affects the communication protocol with the remote target.",
// OBSOLETE &setlist),
// OBSOLETE &showlist);
// OBSOLETE #endif /* 0 */
// OBSOLETE
// OBSOLETE add_show_from_set
// OBSOLETE (add_set_cmd ("srec-noise", class_support, var_zinteger,
// OBSOLETE (char *) &srec_noise,
// OBSOLETE "\
// OBSOLETE Set number of S-record to send before deliberately flubbing a checksum.\n\
// OBSOLETE Zero means flub none at all. This affects the communication protocol\n\
// OBSOLETE with the remote target.",
// OBSOLETE &setlist),
// OBSOLETE &showlist);
// OBSOLETE
// OBSOLETE add_show_from_set
// OBSOLETE (add_set_cmd ("srec-sleep", class_support, var_zinteger,
// OBSOLETE (char *) &srec_sleep,
// OBSOLETE "\
// OBSOLETE Set number of seconds to sleep after an S-record for a possible error message to arrive.\n\
// OBSOLETE This affects the communication protocol with the remote target.",
// OBSOLETE &setlist),
// OBSOLETE &showlist);
// OBSOLETE
// OBSOLETE add_show_from_set
// OBSOLETE (add_set_cmd ("srec-echo-pace", class_support, var_boolean,
// OBSOLETE (char *) &srec_echo_pace,
// OBSOLETE "\
// OBSOLETE Set echo-verification.\n\
// OBSOLETE When on, use verification by echo when downloading S-records. This is\n\
// OBSOLETE much slower, but generally more reliable.",
// OBSOLETE &setlist),
// OBSOLETE &showlist);
// OBSOLETE }
Reference in New Issue View Git Blame Copy Permalink