/* Remote debugging interface for Motorola's MVME187BUG monitor, an embedded
monitor for the m88k.
- Copyright 1992, 1993 Free Software Foundation, Inc.
+ Copyright 1992, 1993, 2001 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by K. Richard Pixley.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "inferior.h"
-#include "wait.h"
-
#include "gdb_string.h"
#include <ctype.h>
#include <fcntl.h>
#include "remote-utils.h"
-extern int sleep();
+extern int sleep ();
/* External data declarations */
extern int stop_soon_quietly; /* for wait_for_inferior */
extern struct target_ops bug_ops; /* Forward declaration */
/* Forward function declarations */
-static int bug_clear_breakpoints PARAMS((void));
+static int bug_clear_breakpoints (void);
-static int bug_read_memory PARAMS((CORE_ADDR memaddr,
- unsigned char *myaddr,
- int len));
+static int bug_read_memory (CORE_ADDR memaddr,
+ unsigned char *myaddr, int len);
-static int bug_write_memory PARAMS((CORE_ADDR memaddr,
- unsigned char *myaddr,
- int len));
+static int bug_write_memory (CORE_ADDR memaddr,
+ unsigned char *myaddr, int len);
/* This variable is somewhat arbitrary. It's here so that it can be
set from within a running gdb. */
*/
static void
-bug_load (args, fromtty)
- char *args;
- int fromtty;
+bug_load (char *args, int fromtty)
{
bfd *abfd;
asection *s;
sr_check_open ();
- dcache_flush (gr_get_dcache());
inferior_pid = 0;
abfd = bfd_openr (args, 0);
if (!abfd)
gdb_flush (gdb_stdout);
}
printf_filtered ("\n");
- free (buffer);
+ xfree (buffer);
}
s = s->next;
}
#if 0
static char *
-get_word (p)
- char **p;
+get_word (char **p)
{
char *s = *p;
char *word;
}
#endif
-static struct gr_settings bug_settings = {
- NULL, /* dcache */
- "Bug>", /* prompt */
- &bug_ops, /* ops */
- bug_clear_breakpoints, /* clear_all_breakpoints */
- bug_read_memory, /* readfunc */
- bug_write_memory, /* writefunc */
- gr_generic_checkin, /* checkin */
+static struct gr_settings bug_settings =
+{
+ "Bug>", /* prompt */
+ &bug_ops, /* ops */
+ bug_clear_breakpoints, /* clear_all_breakpoints */
+ gr_generic_checkin, /* checkin */
};
-static char *cpu_check_strings[] = {
+static char *cpu_check_strings[] =
+{
"=",
"Invalid Register",
};
static void
-bug_open (args, from_tty)
- char *args;
- int from_tty;
+bug_open (char *args, int from_tty)
{
if (args == NULL)
- args = "";
+ args = "";
- gr_open(args, from_tty, &bug_settings);
+ gr_open (args, from_tty, &bug_settings);
/* decide *now* whether we are on an 88100 or an 88110 */
- sr_write_cr("rs cr06");
- sr_expect("rs cr06");
+ sr_write_cr ("rs cr06");
+ sr_expect ("rs cr06");
- switch (gr_multi_scan(cpu_check_strings, 0))
+ switch (gr_multi_scan (cpu_check_strings, 0))
{
- case 0: /* this is an m88100 */
+ case 0: /* this is an m88100 */
target_is_m88110 = 0;
break;
- case 1: /* this is an m88110 */
+ case 1: /* this is an m88110 */
target_is_m88110 = 1;
break;
default:
- abort();
+ abort ();
}
}
/* Tell the remote machine to resume. */
void
-bug_resume (pid, step, sig)
- int pid, step;
- enum target_signal sig;
+bug_resume (int pid, int step, enum target_signal sig)
{
- dcache_flush (gr_get_dcache());
-
if (step)
{
- sr_write_cr("t");
+ sr_write_cr ("t");
/* Force the next bug_wait to return a trap. Not doing anything
- about I/O from the target means that the user has to type
- "continue" to see any. FIXME, this should be fixed. */
+ about I/O from the target means that the user has to type
+ "continue" to see any. FIXME, this should be fixed. */
need_artificial_trap = 1;
}
else
- sr_write_cr ("g");
+ sr_write_cr ("g");
return;
}
/* Wait until the remote machine stops, then return,
storing status in STATUS just as `wait' would. */
-static char *wait_strings[] = {
+static char *wait_strings[] =
+{
"At Breakpoint",
"Exception: Data Access Fault (Local Bus Timeout)",
- "\r8??\?-Bug>", /* The '\?' avoids creating a trigraph */
+ "\r8??\?-Bug>", /* The '\?' avoids creating a trigraph */
"\r197-Bug>",
NULL,
};
int
-bug_wait (pid, status)
- int pid;
- struct target_waitstatus *status;
+bug_wait (int pid, struct target_waitstatus *status)
{
- int old_timeout = sr_get_timeout();
+ int old_timeout = sr_get_timeout ();
int old_immediate_quit = immediate_quit;
status->kind = TARGET_WAITKIND_EXITED;
back out as stdout. */
if (need_artificial_trap == 0)
{
- sr_expect("Effective address: ");
- (void) sr_get_hex_word();
+ sr_expect ("Effective address: ");
+ (void) sr_get_hex_word ();
sr_expect ("\r\n");
}
- sr_set_timeout(-1); /* Don't time out -- user program is running. */
- immediate_quit = 1; /* Helps ability to QUIT */
+ sr_set_timeout (-1); /* Don't time out -- user program is running. */
+ immediate_quit = 1; /* Helps ability to QUIT */
- switch (gr_multi_scan(wait_strings, need_artificial_trap == 0))
+ switch (gr_multi_scan (wait_strings, need_artificial_trap == 0))
{
- case 0: /* breakpoint case */
+ case 0: /* breakpoint case */
status->kind = TARGET_WAITKIND_STOPPED;
status->value.sig = TARGET_SIGNAL_TRAP;
/* user output from the target can be discarded here. (?) */
- gr_expect_prompt();
+ gr_expect_prompt ();
break;
- case 1: /* bus error */
+ case 1: /* bus error */
status->kind = TARGET_WAITKIND_STOPPED;
status->value.sig = TARGET_SIGNAL_BUS;
/* user output from the target can be discarded here. (?) */
- gr_expect_prompt();
+ gr_expect_prompt ();
break;
- case 2: /* normal case */
+ case 2: /* normal case */
case 3:
if (need_artificial_trap != 0)
{
break;
}
- case -1: /* trouble */
+ case -1: /* trouble */
default:
fprintf_filtered (gdb_stderr,
"Trouble reading target during wait\n");
break;
}
- sr_set_timeout(old_timeout);
+ sr_set_timeout (old_timeout);
immediate_quit = old_immediate_quit;
return 0;
}
Returns a pointer to a static buffer containing the answer. */
static char *
-get_reg_name (regno)
- int regno;
+get_reg_name (int regno)
{
- static char *rn[] = {
+ static char *rn[] =
+ {
"r00", "r01", "r02", "r03", "r04", "r05", "r06", "r07",
"r08", "r09", "r10", "r11", "r12", "r13", "r14", "r15",
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
- /* these get confusing because we omit a few and switch some ordering around. */
+ /* these get confusing because we omit a few and switch some ordering around. */
- "cr01", /* 32 = psr */
- "fcr62", /* 33 = fpsr*/
- "fcr63", /* 34 = fpcr */
+ "cr01", /* 32 = psr */
+ "fcr62", /* 33 = fpsr */
+ "fcr63", /* 34 = fpcr */
"ip", /* this is something of a cheat. */
/* 35 = sxip */
- "cr05", /* 36 = snip */
- "cr06", /* 37 = sfip */
+ "cr05", /* 36 = snip */
+ "cr06", /* 37 = sfip */
"x00", "x01", "x02", "x03", "x04", "x05", "x06", "x07",
"x08", "x09", "x10", "x11", "x12", "x13", "x14", "x15",
return rn[regno];
}
-#if 0 /* not currently used */
+#if 0 /* not currently used */
/* Read from remote while the input matches STRING. Return zero on
success, -1 on failure. */
static int
-bug_scan (s)
- char *s;
+bug_scan (char *s)
{
int c;
while (*s)
{
- c = sr_readchar();
+ c = sr_readchar ();
if (c != *s++)
{
- fflush(stdout);
- printf("\nNext character is '%c' - %d and s is \"%s\".\n", c, c, --s);
- return(-1);
+ fflush (stdout);
+ printf ("\nNext character is '%c' - %d and s is \"%s\".\n", c, c, --s);
+ return (-1);
}
}
- return(0);
+ return (0);
}
#endif /* never */
static int
-bug_srec_write_cr (s)
- char *s;
+bug_srec_write_cr (char *s)
{
char *p = s;
if (srec_echo_pace)
for (p = s; *p; ++p)
{
- if (sr_get_debug() > 0)
+ if (sr_get_debug () > 0)
printf ("%c", *p);
do
- SERIAL_WRITE(sr_get_desc(), p, 1);
- while (sr_pollchar() != *p);
+ SERIAL_WRITE (sr_get_desc (), p, 1);
+ while (sr_pollchar () != *p);
}
else
- {
+ {
sr_write_cr (s);
/* return(bug_scan (s) || bug_scan ("\n")); */
}
- return(0);
+ return (0);
}
/* Store register REGNO, or all if REGNO == -1. */
static void
-bug_fetch_register(regno)
- int regno;
+bug_fetch_register (int regno)
{
- sr_check_open();
+ sr_check_open ();
if (regno == -1)
{
int i;
for (i = 0; i < NUM_REGS; ++i)
- bug_fetch_register(i);
+ bug_fetch_register (i);
}
else if (target_is_m88110 && regno == SFIP_REGNUM)
{
/* m88110 has no sfip. */
long l = 0;
- supply_register(regno, (char *) &l);
+ supply_register (regno, (char *) &l);
}
else if (regno < XFP_REGNUM)
{
char buffer[MAX_REGISTER_RAW_SIZE];
sr_write ("rs ", 3);
- sr_write_cr (get_reg_name(regno));
+ sr_write_cr (get_reg_name (regno));
sr_expect ("=");
store_unsigned_integer (buffer, REGISTER_RAW_SIZE (regno),
- sr_get_hex_word());
+ sr_get_hex_word ());
gr_expect_prompt ();
supply_register (regno, buffer);
}
long p;
unsigned char fpreg_buf[10];
- sr_write("rs ", 3);
- sr_write(get_reg_name(regno), strlen(get_reg_name(regno)));
- sr_write_cr(";d");
- sr_expect("rs");
- sr_expect(get_reg_name(regno));
- sr_expect(";d");
- sr_expect("=");
+ sr_write ("rs ", 3);
+ sr_write (get_reg_name (regno), strlen (get_reg_name (regno)));
+ sr_write_cr (";d");
+ sr_expect ("rs");
+ sr_expect (get_reg_name (regno));
+ sr_expect (";d");
+ sr_expect ("=");
/* sign */
- p = sr_get_hex_digit(1);
+ p = sr_get_hex_digit (1);
fpreg_buf[0] = p << 7;
/* exponent */
- sr_expect("_");
- p = sr_get_hex_digit(1);
+ sr_expect ("_");
+ p = sr_get_hex_digit (1);
fpreg_buf[0] += (p << 4);
- fpreg_buf[0] += sr_get_hex_digit(1);
+ fpreg_buf[0] += sr_get_hex_digit (1);
- fpreg_buf[1] = sr_get_hex_digit(1) << 4;
+ fpreg_buf[1] = sr_get_hex_digit (1) << 4;
/* fraction */
- sr_expect("_");
- fpreg_buf[1] += sr_get_hex_digit(1);
-
- fpreg_buf[2] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
- fpreg_buf[3] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
- fpreg_buf[4] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
- fpreg_buf[5] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
- fpreg_buf[6] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
- fpreg_buf[7] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
+ sr_expect ("_");
+ fpreg_buf[1] += sr_get_hex_digit (1);
+
+ fpreg_buf[2] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
+ fpreg_buf[3] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
+ fpreg_buf[4] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
+ fpreg_buf[5] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
+ fpreg_buf[6] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
+ fpreg_buf[7] = (sr_get_hex_digit (1) << 4) + sr_get_hex_digit (1);
fpreg_buf[8] = 0;
fpreg_buf[9] = 0;
- gr_expect_prompt();
- supply_register(regno, fpreg_buf);
+ gr_expect_prompt ();
+ supply_register (regno, fpreg_buf);
}
return;
/* Store register REGNO, or all if REGNO == -1. */
static void
-bug_store_register (regno)
- int regno;
+bug_store_register (int regno)
{
char buffer[1024];
- sr_check_open();
+ sr_check_open ();
if (regno == -1)
{
int i;
for (i = 0; i < NUM_REGS; ++i)
- bug_store_register(i);
+ bug_store_register (i);
}
else
{
char *regname;
- regname = get_reg_name(regno);
+ regname = get_reg_name (regno);
if (target_is_m88110 && regno == SFIP_REGNUM)
return;
else if (regno < XFP_REGNUM)
- sprintf(buffer, "rs %s %08x",
- regname,
- read_register(regno));
+ sprintf (buffer, "rs %s %08x",
+ regname,
+ read_register (regno));
else
{
unsigned char *fpreg_buf =
- (unsigned char *)®isters[REGISTER_BYTE(regno)];
-
- sprintf(buffer, "rs %s %1x_%02x%1x_%1x%02x%02x%02x%02x%02x%02x;d",
- regname,
- /* sign */
- (fpreg_buf[0] >> 7) & 0xf,
- /* exponent */
- fpreg_buf[0] & 0x7f,
- (fpreg_buf[1] >> 8) & 0xf,
- /* fraction */
- fpreg_buf[1] & 0xf,
- fpreg_buf[2],
- fpreg_buf[3],
- fpreg_buf[4],
- fpreg_buf[5],
- fpreg_buf[6],
- fpreg_buf[7]);
+ (unsigned char *) ®isters[REGISTER_BYTE (regno)];
+
+ sprintf (buffer, "rs %s %1x_%02x%1x_%1x%02x%02x%02x%02x%02x%02x;d",
+ regname,
+ /* sign */
+ (fpreg_buf[0] >> 7) & 0xf,
+ /* exponent */
+ fpreg_buf[0] & 0x7f,
+ (fpreg_buf[1] >> 8) & 0xf,
+ /* fraction */
+ fpreg_buf[1] & 0xf,
+ fpreg_buf[2],
+ fpreg_buf[3],
+ fpreg_buf[4],
+ fpreg_buf[5],
+ fpreg_buf[6],
+ fpreg_buf[7]);
}
- sr_write_cr(buffer);
- gr_expect_prompt();
+ sr_write_cr (buffer);
+ gr_expect_prompt ();
}
return;
}
-int
-bug_xfer_memory (memaddr, myaddr, len, write, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *target; /* ignored */
-{
- register int i;
-
- /* Round starting address down to longword boundary. */
- register CORE_ADDR addr;
-
- /* Round ending address up; get number of longwords that makes. */
- register int count;
+/* Transfer LEN bytes between GDB address MYADDR and target address
+ MEMADDR. If WRITE is non-zero, transfer them to the target,
+ otherwise transfer them from the target. TARGET is unused.
- /* Allocate buffer of that many longwords. */
- register int *buffer;
+ Returns the number of bytes transferred. */
- addr = memaddr & -sizeof (int);
- count = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+int
+bug_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct mem_attrib *attrib ATTRIBUTE_UNUSED,
+ struct target_ops *target ATTRIBUTE_UNUSED)
+{
+ int res;
- buffer = (int *) alloca (count * sizeof (int));
+ if (len <= 0)
+ return 0;
if (write)
- {
- /* Fill start and end extra bytes of buffer with existing memory data. */
-
- if (addr != memaddr || len < (int) sizeof (int))
- {
- /* Need part of initial word -- fetch it. */
- buffer[0] = gr_fetch_word (addr);
- }
-
- if (count > 1) /* FIXME, avoid if even boundary */
- {
- buffer[count - 1]
- = gr_fetch_word (addr + (count - 1) * sizeof (int));
- }
-
- /* Copy data to be written over corresponding part of buffer */
-
- memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
-
- /* Write the entire buffer. */
-
- for (i = 0; i < count; i++, addr += sizeof (int))
- {
- errno = 0;
- gr_store_word (addr, buffer[i]);
- if (errno)
- {
-
- return 0;
- }
-
- }
- }
+ res = bug_write_memory (memaddr, myaddr, len);
else
- {
- /* Read all the longwords */
- for (i = 0; i < count; i++, addr += sizeof (int))
- {
- errno = 0;
- buffer[i] = gr_fetch_word (addr);
- if (errno)
- {
- return 0;
- }
- QUIT;
- }
-
- /* Copy appropriate bytes out of the buffer. */
- memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
- }
+ res = bug_read_memory (memaddr, myaddr, len);
- return len;
+ return res;
}
static void
-start_load()
+start_load (void)
{
char *command;
data records each containing srec_bytes, and an S7 termination
record. */
-static char *srecord_strings[] = {
+static char *srecord_strings[] =
+{
"S-RECORD",
"-Bug>",
NULL,
};
static int
-bug_write_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- unsigned char *myaddr;
- int len;
+bug_write_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
{
int done;
int checksum;
done = 0;
if (retries > srec_max_retries)
- return(-1);
+ return (-1);
if (retries > 0)
{
- if (sr_get_debug() > 0)
- printf("\n<retrying...>\n");
+ if (sr_get_debug () > 0)
+ printf ("\n<retrying...>\n");
/* This gr_expect_prompt call is extremely important. Without
it, we will tend to resend our packet so fast that it
will arrive before the bug monitor is ready to receive
it. This would lead to a very ugly resend loop. */
- gr_expect_prompt();
+ gr_expect_prompt ();
}
- start_load();
+ start_load ();
while (done < len)
{
checksum += (thisgo + 4 + 1
+ (address & 0xff)
- + ((address >> 8) & 0xff)
+ + ((address >> 8) & 0xff)
+ ((address >> 16) & 0xff)
+ ((address >> 24) & 0xff));
if (srec_noise > 0)
{
/* FIXME-NOW: insert a deliberate error every now and then.
- This is intended for testing/debugging the error handling
- stuff. */
+ This is intended for testing/debugging the error handling
+ stuff. */
static int counter = 0;
if (++counter > srec_noise)
{
}
}
- sprintf(buf, "%02X", ~checksum & 0xff);
+ sprintf (buf, "%02X", ~checksum & 0xff);
bug_srec_write_cr (buffer);
if (srec_sleep != 0)
- sleep(srec_sleep);
+ sleep (srec_sleep);
/* This pollchar is probably redundant to the gr_multi_scan
below. Trouble is, we can't be sure when or where an
full speed from a typical sun4, error messages tend to
appear to arrive only *after* the s7 record. */
- if ((x = sr_pollchar()) != 0)
+ if ((x = sr_pollchar ()) != 0)
{
- if (sr_get_debug() > 0)
- printf("\n<retrying...>\n");
+ if (sr_get_debug () > 0)
+ printf ("\n<retrying...>\n");
++retries;
/* flush any remaining input and verify that we are back
- at the prompt level. */
- gr_expect_prompt();
+ at the prompt level. */
+ gr_expect_prompt ();
/* start all over again. */
- start_load();
+ start_load ();
done = 0;
continue;
}
done += thisgo;
}
- bug_srec_write_cr("S7060000000000F9");
+ bug_srec_write_cr ("S7060000000000F9");
++retries;
/* Having finished the load, we need to figure out whether we
- had any errors. */
- } while (gr_multi_scan(srecord_strings, 0) == 0);;
+ had any errors. */
+ }
+ while (gr_multi_scan (srecord_strings, 0) == 0);;
- return(0);
+ return (0);
}
/* Copy LEN bytes of data from debugger memory at MYADDR
to inferior's memory at MEMADDR. Returns errno value.
- * sb/sh instructions don't work on unaligned addresses, when TU=1.
+ * sb/sh instructions don't work on unaligned addresses, when TU=1.
*/
/* Read LEN bytes from inferior memory at MEMADDR. Put the result
at debugger address MYADDR. Returns errno value. */
static int
-bug_read_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- unsigned char *myaddr;
- int len;
+bug_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
{
char request[100];
char *buffer;
unsigned int inaddr;
unsigned int checksum;
- sprintf(request, "du 0 %x:&%d", memaddr, len);
- sr_write_cr(request);
+ sprintf (request, "du 0 %x:&%d", memaddr, len);
+ sr_write_cr (request);
- p = buffer = alloca(len);
+ p = buffer = alloca (len);
/* scan up through the header */
- sr_expect("S0030000FC");
+ sr_expect ("S0030000FC");
while (p < buffer + len)
{
/* scan off any white space. */
- while (sr_readchar() != 'S') ;;
+ while (sr_readchar () != 'S');;
/* what kind of s-rec? */
- type = sr_readchar();
+ type = sr_readchar ();
/* scan record size */
- sr_get_hex_byte(&size);
+ sr_get_hex_byte (&size);
checksum = size;
--size;
inaddr = 0;
goto done;
case '3':
- sr_get_hex_byte(&c);
+ sr_get_hex_byte (&c);
inaddr = (inaddr << 8) + c;
checksum += c;
--size;
/* intentional fall through */
case '2':
- sr_get_hex_byte(&c);
+ sr_get_hex_byte (&c);
inaddr = (inaddr << 8) + c;
checksum += c;
--size;
/* intentional fall through */
case '1':
- sr_get_hex_byte(&c);
+ sr_get_hex_byte (&c);
inaddr = (inaddr << 8) + c;
checksum += c;
--size;
- sr_get_hex_byte(&c);
+ sr_get_hex_byte (&c);
inaddr = (inaddr << 8) + c;
checksum += c;
--size;
default:
/* bonk */
- error("reading s-records.");
+ error ("reading s-records.");
}
if (inaddr < memaddr
|| (memaddr + len) < (inaddr + size))
- error("srec out of memory range.");
+ error ("srec out of memory range.");
if (p != buffer + inaddr - memaddr)
- error("srec out of sequence.");
+ error ("srec out of sequence.");
for (; size; --size, ++p)
{
- sr_get_hex_byte(p);
+ sr_get_hex_byte (p);
checksum += *p;
}
- sr_get_hex_byte(&c);
+ sr_get_hex_byte (&c);
if (c != (~checksum & 0xff))
- error("bad s-rec checksum");
+ error ("bad s-rec checksum");
}
- done:
- gr_expect_prompt();
+done:
+ gr_expect_prompt ();
if (p != buffer + len)
- return(1);
+ return (1);
- memcpy(myaddr, buffer, len);
- return(0);
+ memcpy (myaddr, buffer, len);
+ return (0);
}
#define MAX_BREAKS 16
static int num_brkpts = 0;
+
+/* Insert a breakpoint at ADDR. SAVE is normally the address of the
+ pattern buffer where the instruction that the breakpoint overwrites
+ is saved. It is unused here since the bug is responsible for
+ saving/restoring the original instruction. */
+
static int
-bug_insert_breakpoint (addr, save)
- CORE_ADDR addr;
- char *save; /* Throw away, let bug save instructions */
+bug_insert_breakpoint (CORE_ADDR addr, char *save)
{
sr_check_open ();
sprintf (buffer, "br %x", addr);
sr_write_cr (buffer);
gr_expect_prompt ();
- return(0);
+ return (0);
}
else
{
fprintf_filtered (gdb_stderr,
"Too many break points, break point not installed\n");
- return(1);
+ return (1);
}
}
+
+/* Remove a breakpoint at ADDR. SAVE is normally the previously
+ saved pattern, but is unused here since the bug is responsible
+ for saving/restoring instructions. */
+
static int
-bug_remove_breakpoint (addr, save)
- CORE_ADDR addr;
- char *save; /* Throw away, let bug save instructions */
+bug_remove_breakpoint (CORE_ADDR addr, char *save)
{
if (num_brkpts > 0)
{
/* Clear the bugs notion of what the break points are */
static int
-bug_clear_breakpoints ()
+bug_clear_breakpoints (void)
{
- if (sr_is_open())
+ if (sr_is_open ())
{
sr_write_cr ("nobr");
- sr_expect("nobr");
+ sr_expect ("nobr");
gr_expect_prompt ();
}
num_brkpts = 0;
- return(0);
+ return (0);
}
-struct target_ops bug_ops ;
+struct target_ops bug_ops;
-static void init_bug_ops(void)
+static void
+init_bug_ops (void)
{
- bug_ops.to_shortname = "bug"; "Remote BUG monitor",
- bug_ops.to_longname = "Use the mvme187 board running the BUG monitor connected by a serial line.";
- bug_ops.to_doc = " ";
- bug_ops.to_open = bug_open;
- bug_ops.to_close = gr_close;
- bug_ops.to_attach = 0;
+ bug_ops.to_shortname = "bug";
+ "Remote BUG monitor",
+ bug_ops.to_longname = "Use the mvme187 board running the BUG monitor connected by a serial line.";
+ bug_ops.to_doc = " ";
+ bug_ops.to_open = bug_open;
+ bug_ops.to_close = gr_close;
+ bug_ops.to_attach = 0;
bug_ops.to_post_attach = NULL;
bug_ops.to_require_attach = NULL;
- bug_ops.to_detach = gr_detach;
+ bug_ops.to_detach = gr_detach;
bug_ops.to_require_detach = NULL;
- bug_ops.to_resume = bug_resume;
- bug_ops.to_wait = bug_wait;
+ bug_ops.to_resume = bug_resume;
+ bug_ops.to_wait = bug_wait;
bug_ops.to_post_wait = NULL;
- bug_ops.to_fetch_registers = bug_fetch_register;
- bug_ops.to_store_registers = bug_store_register;
- bug_ops.to_prepare_to_store = gr_prepare_to_store;
- bug_ops.to_xfer_memory = bug_xfer_memory;
- bug_ops.to_files_info = gr_files_info;
- bug_ops.to_insert_breakpoint = bug_insert_breakpoint;
- bug_ops.to_remove_breakpoint = bug_remove_breakpoint;
- bug_ops.to_terminal_init = 0;
- bug_ops.to_terminal_inferior = 0;
- bug_ops.to_terminal_ours_for_output = 0;
- bug_ops.to_terminal_ours = 0;
- bug_ops.to_terminal_info = 0;
- bug_ops.to_kill = gr_kill;
- bug_ops.to_load = bug_load;
- bug_ops.to_lookup_symbol = 0;
- bug_ops.to_create_inferior = gr_create_inferior;
+ bug_ops.to_fetch_registers = bug_fetch_register;
+ bug_ops.to_store_registers = bug_store_register;
+ bug_ops.to_prepare_to_store = gr_prepare_to_store;
+ bug_ops.to_xfer_memory = bug_xfer_memory;
+ bug_ops.to_files_info = gr_files_info;
+ bug_ops.to_insert_breakpoint = bug_insert_breakpoint;
+ bug_ops.to_remove_breakpoint = bug_remove_breakpoint;
+ bug_ops.to_terminal_init = 0;
+ bug_ops.to_terminal_inferior = 0;
+ bug_ops.to_terminal_ours_for_output = 0;
+ bug_ops.to_terminal_ours = 0;
+ bug_ops.to_terminal_info = 0;
+ bug_ops.to_kill = gr_kill;
+ bug_ops.to_load = bug_load;
+ bug_ops.to_lookup_symbol = 0;
+ bug_ops.to_create_inferior = gr_create_inferior;
bug_ops.to_post_startup_inferior = NULL;
bug_ops.to_acknowledge_created_inferior = NULL;
- bug_ops.to_clone_and_follow_inferior = NULL;
- bug_ops.to_post_follow_inferior_by_clone = NULL;
+ bug_ops.to_clone_and_follow_inferior = NULL;
+ bug_ops.to_post_follow_inferior_by_clone = NULL;
bug_ops.to_insert_fork_catchpoint = NULL;
bug_ops.to_remove_fork_catchpoint = NULL;
bug_ops.to_insert_vfork_catchpoint = NULL;
- bug_ops.to_remove_vfork_catchpoint = NULL;
+ bug_ops.to_remove_vfork_catchpoint = NULL;
bug_ops.to_has_forked = NULL;
- bug_ops.to_has_vforked = NULL;
- bug_ops.to_can_follow_vfork_prior_to_exec = NULL;
+ bug_ops.to_has_vforked = NULL;
+ bug_ops.to_can_follow_vfork_prior_to_exec = NULL;
bug_ops.to_post_follow_vfork = NULL;
bug_ops.to_insert_exec_catchpoint = NULL;
bug_ops.to_remove_exec_catchpoint = NULL;
bug_ops.to_has_execd = NULL;
bug_ops.to_reported_exec_events_per_exec_call = NULL;
bug_ops.to_has_exited = NULL;
- bug_ops.to_mourn_inferior = gr_mourn;
- bug_ops.to_can_run = 0;
- bug_ops.to_notice_signals = 0;
- bug_ops.to_thread_alive = 0 ;
- bug_ops.to_stop = 0;
+ bug_ops.to_mourn_inferior = gr_mourn;
+ bug_ops.to_can_run = 0;
+ bug_ops.to_notice_signals = 0;
+ bug_ops.to_thread_alive = 0;
+ bug_ops.to_stop = 0;
bug_ops.to_pid_to_exec_file = NULL;
bug_ops.to_core_file_to_sym_file = NULL;
- bug_ops.to_stratum = process_stratum ;
- bug_ops.DONT_USE = 0;
- bug_ops.to_has_all_memory = 1;
- bug_ops.to_has_memory = 1;
- bug_ops.to_has_stack = 1;
- bug_ops.to_has_registers = 0;
- bug_ops.to_has_execution = 0;
- bug_ops.to_sections = 0 ;
- bug_ops.to_sections_end = 0 ;
- bug_ops.to_magic = OPS_MAGIC; /* Always the last thing */
-} /* init_bug_ops */
+ bug_ops.to_stratum = process_stratum;
+ bug_ops.DONT_USE = 0;
+ bug_ops.to_has_all_memory = 1;
+ bug_ops.to_has_memory = 1;
+ bug_ops.to_has_stack = 1;
+ bug_ops.to_has_registers = 0;
+ bug_ops.to_has_execution = 0;
+ bug_ops.to_sections = 0;
+ bug_ops.to_sections_end = 0;
+ bug_ops.to_magic = OPS_MAGIC; /* Always the last thing */
+} /* init_bug_ops */
void
-_initialize_remote_bug ()
+_initialize_remote_bug (void)
{
- init_bug_ops() ;
+ init_bug_ops ();
add_target (&bug_ops);
add_show_from_set
"\
Set echo-verification.\n\
When on, use verification by echo when downloading S-records. This is\n\
-much slower, but generally more reliable.",
+much slower, but generally more reliable.",
&setlist),
&showlist);
}