#include "defs.h"
#include "inferior.h"
-#include "wait.h"
+#include "gdb_wait.h"
#include "gdb_string.h"
#include <ctype.h>
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;
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 void
-bug_open (args, from_tty)
- char *args;
- int from_tty;
+bug_open (char *args, int from_tty)
{
if (args == NULL)
args = "";
/* 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");
};
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_immediate_quit = immediate_quit;
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[] =
{
success, -1 on failure. */
static int
-bug_scan (s)
- char *s;
+bug_scan (char *s)
{
int c;
#endif /* never */
static int
-bug_srec_write_cr (s)
- char *s;
+bug_srec_write_cr (char *s)
{
char *p = s;
/* Store register REGNO, or all if REGNO == -1. */
static void
-bug_fetch_register (regno)
- int regno;
+bug_fetch_register (int regno)
{
sr_check_open ();
/* 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 ();
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 target_ops *target)
+{
+ 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;
};
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;
/* 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;
#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 ();
}
}
+
+/* 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 ())
} /* init_bug_ops */
void
-_initialize_remote_bug ()
+_initialize_remote_bug (void)
{
init_bug_ops ();
add_target (&bug_ops);