/* Select target systems and architectures at runtime for GDB.
- Copyright 1990, 1992-1995, 1998-2000 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ 2000, 2001 Free Software Foundation, Inc.
Contributed by Cygnus Support.
This file is part of GDB.
#include "defs.h"
#include <errno.h>
-#include <ctype.h>
#include "gdb_string.h"
#include "target.h"
#include "gdbcmd.h"
#include "symfile.h"
#include "objfiles.h"
#include "gdb_wait.h"
+#include "dcache.h"
#include <signal.h>
+#include "regcache.h"
extern int errno;
static void debug_to_prepare_to_store (void);
static int
-debug_to_xfer_memory (CORE_ADDR, char *, int, int, struct target_ops *);
+debug_to_xfer_memory (CORE_ADDR, char *, int, int, struct mem_attrib *,
+ struct target_ops *);
static void debug_to_files_info (struct target_ops *);
static void setup_target_debug (void);
+DCACHE *target_dcache;
+
/* The user just typed 'target' without the name of a target. */
/* ARGSUSED */
static void
-target_command (arg, from_tty)
- char *arg;
- int from_tty;
+target_command (char *arg, int from_tty)
{
fputs_filtered ("Argument required (target name). Try `help target'\n",
gdb_stdout);
/* Add a possible target architecture to the list. */
void
-add_target (t)
- struct target_ops *t;
+add_target (struct target_ops *t)
{
if (!target_structs)
{
/* Stub functions */
void
-target_ignore ()
+target_ignore (void)
{
}
void
target_load (char *arg, int from_tty)
{
+ dcache_invalidate (target_dcache);
(*current_target.to_load) (arg, from_tty);
}
/* ARGSUSED */
static int
-nomemory (memaddr, myaddr, len, write, t)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *t;
+nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct target_ops *t)
{
errno = EIO; /* Can't read/write this location */
return 0; /* No bytes handled */
}
static void
-tcomplain ()
+tcomplain (void)
{
error ("You can't do that when your target is `%s'",
current_target.to_shortname);
}
void
-noprocess ()
+noprocess (void)
{
error ("You can't do that without a process to debug.");
}
/* ARGSUSED */
static int
-nosymbol (name, addrp)
- char *name;
- CORE_ADDR *addrp;
+nosymbol (char *name, CORE_ADDR *addrp)
{
return 1; /* Symbol does not exist in target env */
}
/* ARGSUSED */
static void
-nosupport_runtime ()
+nosupport_runtime (void)
{
if (!inferior_pid)
noprocess ();
/* ARGSUSED */
static void
-default_terminal_info (args, from_tty)
- char *args;
- int from_tty;
+default_terminal_info (char *args, int from_tty)
{
printf_unfiltered ("No saved terminal information.\n");
}
the target, and the operation should be attempted. */
static void
-kill_or_be_killed (from_tty)
- int from_tty;
+kill_or_be_killed (int from_tty)
{
if (target_has_execution)
{
}
static void
-maybe_kill_then_attach (args, from_tty)
- char *args;
- int from_tty;
+maybe_kill_then_attach (char *args, int from_tty)
{
kill_or_be_killed (from_tty);
target_attach (args, from_tty);
}
static void
-maybe_kill_then_create_inferior (exec, args, env)
- char *exec;
- char *args;
- char **env;
+maybe_kill_then_create_inferior (char *exec, char *args, char **env)
{
kill_or_be_killed (0);
target_create_inferior (exec, args, env);
}
static void
-default_clone_and_follow_inferior (child_pid, followed_child)
- int child_pid;
- int *followed_child;
+default_clone_and_follow_inferior (int child_pid, int *followed_child)
{
target_clone_and_follow_inferior (child_pid, followed_child);
}
We default entries, at least to stubs that print error messages. */
static void
-cleanup_target (t)
- struct target_ops *t;
+cleanup_target (struct target_ops *t)
{
#define de_fault(field, value) \
(void (*) (void))
noprocess);
de_fault (to_xfer_memory,
- (int (*) (CORE_ADDR, char *, int, int, struct target_ops *))
+ (int (*) (CORE_ADDR, char *, int, int, struct mem_attrib *, struct target_ops *))
nomemory);
de_fault (to_files_info,
(void (*) (struct target_ops *))
pushed target vectors. */
static void
-update_current_target ()
+update_current_target (void)
{
struct target_stack_item *item;
struct target_ops *t;
checking them. */
int
-push_target (t)
- struct target_ops *t;
+push_target (struct target_ops *t)
{
struct target_stack_item *cur, *prev, *tmp;
fprintf_unfiltered (gdb_stderr,
"Magic number of %s target struct wrong\n",
t->to_shortname);
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
/* Find the proper stratum to install this target in. */
else
target_stack = cur->next; /* Unchain first on list */
tmp = cur->next;
- free (cur);
+ xfree (cur);
cur = tmp;
}
Return how many times it was removed (0 or 1). */
int
-unpush_target (t)
- struct target_ops *t;
+unpush_target (struct target_ops *t)
{
struct target_stack_item *cur, *prev;
else
prev->next = cur->next;
- free (cur); /* Release the target_stack_item */
+ xfree (cur); /* Release the target_stack_item */
update_current_target ();
cleanup_target (¤t_target);
}
void
-pop_target ()
+pop_target (void)
{
(current_target.to_close) (0); /* Let it clean up */
if (unpush_target (target_stack->target_ops) == 1)
fprintf_unfiltered (gdb_stderr,
"pop_target couldn't find target %s\n",
current_target.to_shortname);
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
#undef MIN
read. */
int
-target_read_string (memaddr, string, len, errnop)
- CORE_ADDR memaddr;
- char **string;
- int len;
- int *errnop;
+target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
{
int tlen, origlen, offset, i;
char buf[4];
deal with partial reads should call target_read_memory_partial. */
int
-target_read_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+target_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
return target_xfer_memory (memaddr, myaddr, len, 0);
}
int
-target_write_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+target_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
return target_xfer_memory (memaddr, myaddr, len, 1);
}
-/* Move memory to or from the targets. Iterate until all of it has
- been moved, if necessary. The top target gets priority; anything
- it doesn't want, is offered to the next one down, etc. Note the
- business with curlen: if an early target says "no, but I have a
- boundary overlapping this xfer" then we shorten what we offer to
- the subsequent targets so the early guy will get a chance at the
- tail before the subsequent ones do.
+/* Move memory to or from the targets. The top target gets priority;
+ if it cannot handle it, it is offered to the next one down, etc.
- Result is 0 or errno value. */
+ Result is -1 on error, or the number of bytes transfered. */
-static int
-target_xfer_memory (memaddr, myaddr, len, write)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
+int
+do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct mem_attrib *attrib)
{
- int curlen;
int res;
+ int done = 0;
struct target_ops *t;
struct target_stack_item *item;
0. */
errno = 0;
- /* The quick case is that the top target does it all. */
+ /* The quick case is that the top target can handle the transfer. */
res = current_target.to_xfer_memory
- (memaddr, myaddr, len, write, ¤t_target);
- if (res == len)
- return 0;
-
- if (res > 0)
- goto bump;
- /* If res <= 0 then we call it again in the loop. Ah well. */
+ (memaddr, myaddr, len, write, attrib, ¤t_target);
- for (; len > 0;)
+ /* If res <= 0 then we call it again in the loop. Ah well. */
+ if (res <= 0)
{
- curlen = len; /* Want to do it all */
for (item = target_stack; item; item = item->next)
{
t = item->target_ops;
if (!t->to_has_memory)
continue;
- res = t->to_xfer_memory (memaddr, myaddr, curlen, write, t);
+ res = t->to_xfer_memory (memaddr, myaddr, len, write, attrib, t);
if (res > 0)
break; /* Handled all or part of xfer */
if (t->to_has_all_memory)
}
if (res <= 0)
+ return -1;
+ }
+
+ return res;
+}
+
+
+/* Perform a memory transfer. Iterate until the entire region has
+ been transfered.
+
+ Result is 0 or errno value. */
+
+static int
+target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
+{
+ int res;
+ int reg_len;
+ struct mem_region *region;
+
+ /* Zero length requests are ok and require no work. */
+ if (len == 0)
+ {
+ return 0;
+ }
+
+ while (len > 0)
+ {
+ region = lookup_mem_region(memaddr);
+ if (memaddr + len < region->hi)
+ reg_len = len;
+ else
+ reg_len = region->hi - memaddr;
+
+ switch (region->attrib.mode)
{
- /* If this address is for nonexistent memory,
- read zeros if reading, or do nothing if writing. Return error. */
+ case MEM_RO:
+ if (write)
+ return EIO;
+ break;
+
+ case MEM_WO:
if (!write)
- memset (myaddr, 0, len);
- if (errno == 0)
return EIO;
+ break;
+ }
+
+ while (reg_len > 0)
+ {
+ if (region->attrib.cache)
+ res = dcache_xfer_memory(target_dcache, memaddr, myaddr,
+ reg_len, write);
else
- return errno;
+ res = do_xfer_memory(memaddr, myaddr, reg_len, write,
+ ®ion->attrib);
+
+ if (res <= 0)
+ {
+ /* If this address is for nonexistent memory, read zeros
+ if reading, or do nothing if writing. Return
+ error. */
+ if (!write)
+ memset (myaddr, 0, len);
+ if (errno == 0)
+ return EIO;
+ else
+ return errno;
+ }
+
+ memaddr += res;
+ myaddr += res;
+ len -= res;
+ reg_len -= res;
}
- bump:
- memaddr += res;
- myaddr += res;
- len -= res;
}
+
return 0; /* We managed to cover it all somehow. */
}
-/* Perform a partial memory transfer. */
+/* Perform a partial memory transfer.
+
+ Result is -1 on error, or the number of bytes transfered. */
static int
-target_xfer_memory_partial (CORE_ADDR memaddr, char *buf, int len,
+target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len,
int write_p, int *err)
{
int res;
- int err_res;
- int len_res;
- struct target_ops *t;
- struct target_stack_item *item;
+ int reg_len;
+ struct mem_region *region;
/* Zero length requests are ok and require no work. */
if (len == 0)
return 0;
}
- /* The quick case is that the top target does it all. */
- res = current_target.to_xfer_memory (memaddr, buf, len, write_p, ¤t_target);
- if (res > 0)
- {
- *err = 0;
- return res;
- }
-
- /* xfer memory doesn't always reliably set errno. */
- errno = 0;
+ region = lookup_mem_region(memaddr);
+ if (memaddr + len < region->hi)
+ reg_len = len;
+ else
+ reg_len = region->hi - memaddr;
- /* Try all levels of the target stack to see one can handle it. */
- for (item = target_stack; item; item = item->next)
+ switch (region->attrib.mode)
{
- t = item->target_ops;
- if (!t->to_has_memory)
- continue;
- res = t->to_xfer_memory (memaddr, buf, len, write_p, t);
- if (res > 0)
+ case MEM_RO:
+ if (write_p)
{
- /* Handled all or part of xfer */
- *err = 0;
- return res;
+ *err = EIO;
+ return -1;
}
- if (t->to_has_all_memory)
- break;
+ break;
+
+ case MEM_WO:
+ if (write_p)
+ {
+ *err = EIO;
+ return -1;
+ }
+ break;
}
- /* Total failure. Return error. */
- if (errno != 0)
+ if (region->attrib.cache)
+ res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
+ reg_len, write_p);
+ else
+ res = do_xfer_memory (memaddr, myaddr, reg_len, write_p,
+ ®ion->attrib);
+
+ if (res <= 0)
{
- *err = errno;
- return -1;
+ if (errno != 0)
+ *err = errno;
+ else
+ *err = EIO;
+
+ return -1;
}
- *err = EIO;
- return -1;
+
+ *err = 0;
+ return res;
}
int
/* ARGSUSED */
static void
-target_info (args, from_tty)
- char *args;
- int from_tty;
+target_info (char *args, int from_tty)
{
struct target_ops *t;
struct target_stack_item *item;
anything. */
void
-target_preopen (from_tty)
- int from_tty;
+target_preopen (int from_tty)
{
dont_repeat ();
/* Detach a target after doing deferred register stores. */
void
-target_detach (args, from_tty)
- char *args;
- int from_tty;
+target_detach (char *args, int from_tty)
{
/* Handle any optimized stores to the inferior. */
#ifdef DO_DEFERRED_STORES
}
void
-target_link (modname, t_reloc)
- char *modname;
- CORE_ADDR *t_reloc;
+target_link (char *modname, CORE_ADDR *t_reloc)
{
if (STREQ (current_target.to_shortname, "rombug"))
{
Result is always valid (error() is called for errors). */
static struct target_ops *
-find_default_run_target (do_mesg)
- char *do_mesg;
+find_default_run_target (char *do_mesg)
{
struct target_ops **t;
struct target_ops *runable = NULL;
}
void
-find_default_attach (args, from_tty)
- char *args;
- int from_tty;
+find_default_attach (char *args, int from_tty)
{
struct target_ops *t;
}
void
-find_default_require_attach (args, from_tty)
- char *args;
- int from_tty;
+find_default_require_attach (char *args, int from_tty)
{
struct target_ops *t;
}
void
-find_default_require_detach (pid, args, from_tty)
- int pid;
- char *args;
- int from_tty;
+find_default_require_detach (int pid, char *args, int from_tty)
{
struct target_ops *t;
}
void
-find_default_create_inferior (exec_file, allargs, env)
- char *exec_file;
- char *allargs;
- char **env;
+find_default_create_inferior (char *exec_file, char *allargs, char **env)
{
struct target_ops *t;
}
void
-find_default_clone_and_follow_inferior (child_pid, followed_child)
- int child_pid;
- int *followed_child;
+find_default_clone_and_follow_inferior (int child_pid, int *followed_child)
{
struct target_ops *t;
}
static int
-return_zero ()
+return_zero (void)
{
return 0;
}
static int
-return_one ()
+return_one (void)
{
return 1;
}
some reason there is more than one, return NULL. */
struct target_ops *
-find_run_target ()
+find_run_target (void)
{
struct target_ops **t;
struct target_ops *runable = NULL;
If for some reason there is more than one, return NULL. */
struct target_ops *
-find_core_target ()
+find_core_target (void)
{
struct target_ops **t;
struct target_ops *runable = NULL;
*/
struct target_ops *
-find_target_beneath (t)
- struct target_ops *t;
+find_target_beneath (struct target_ops *t)
{
struct target_stack_item *cur;
/* The inferior process has died. Long live the inferior! */
void
-generic_mourn_inferior ()
+generic_mourn_inferior (void)
{
extern int show_breakpoint_hit_counts;
using hit counts. So don't clear them if we're counting hits. */
if (!show_breakpoint_hit_counts)
breakpoint_clear_ignore_counts ();
+
+ if (detach_hook)
+ detach_hook ();
}
\f
/* This table must match in order and size the signals in enum target_signal
{"SIG63", "Real-time event 63"},
{"SIGCANCEL", "LWP internal signal"},
{"SIG32", "Real-time event 32"},
+ {"SIG64", "Real-time event 64"},
#if defined(MACH) || defined(__MACH__)
/* Mach exceptions */
/* Return the string for a signal. */
char *
-target_signal_to_string (sig)
- enum target_signal sig;
+target_signal_to_string (enum target_signal sig)
{
if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST))
return signals[sig].string;
/* Return the name for a signal. */
char *
-target_signal_to_name (sig)
- enum target_signal sig;
+target_signal_to_name (enum target_signal sig)
{
if (sig == TARGET_SIGNAL_UNKNOWN)
/* I think the code which prints this will always print it along with
/* Given a name, return its signal. */
enum target_signal
-target_signal_from_name (name)
- char *name;
+target_signal_from_name (char *name)
{
enum target_signal sig;
/* Convert host signal to our signals. */
enum target_signal
-target_signal_from_host (hostsig)
- int hostsig;
+target_signal_from_host (int hostsig)
{
/* A switch statement would make sense but would require special kludges
to deal with the cases where more than one signal has the same number. */
error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
}
#endif
+
+#if defined (SIGRTMIN)
+ if (hostsig >= SIGRTMIN && hostsig <= SIGRTMAX)
+ {
+ /* This block of TARGET_SIGNAL_REALTIME value is in order. */
+ if (33 <= hostsig && hostsig <= 63)
+ return (enum target_signal)
+ (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
+ else if (hostsig == 64)
+ return TARGET_SIGNAL_REALTIME_64;
+ else
+ error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
+ }
+#endif
return TARGET_SIGNAL_UNKNOWN;
}
return 32;
}
#endif
+#endif
+
+#if defined (SIGRTMIN)
+ if (oursig >= TARGET_SIGNAL_REALTIME_33
+ && oursig <= TARGET_SIGNAL_REALTIME_63)
+ {
+ /* This block of signals is continuous, and
+ TARGET_SIGNAL_REALTIME_33 is 33 by definition. */
+ int retsig =
+ (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33;
+ if (retsig >= SIGRTMIN && retsig <= SIGRTMAX)
+ return retsig;
+ }
+ else if (oursig == TARGET_SIGNAL_REALTIME_64)
+ return 64;
#endif
*oursig_ok = 0;
return 0;
HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
translation of that in OURSTATUS. */
void
-store_waitstatus (ourstatus, hoststatus)
- struct target_waitstatus *ourstatus;
- int hoststatus;
+store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
{
#ifdef CHILD_SPECIAL_WAITSTATUS
/* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
signal. The idea is to keep these circumstances limited so that
users (and scripts) develop portable habits. For comparison,
POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
- numeric signal at all is obscelescent. We are slightly more
+ numeric signal at all is obsolescent. We are slightly more
lenient and allow 1-15 which should match host signal numbers on
most systems. Use of symbolic signal names is strongly encouraged. */
enum target_signal
-target_signal_from_command (num)
- int num;
+target_signal_from_command (int num)
{
if (num >= 1 && num <= 15)
return (enum target_signal) num;
buffer. */
char *
-normal_pid_to_str (pid)
- int pid;
+normal_pid_to_str (int pid)
{
static char buf[30];
target_acknowledge_forked_child.
*/
static void
-normal_target_post_startup_inferior (pid)
- int pid;
+normal_target_post_startup_inferior (int pid)
{
/* This space intentionally left blank. */
}
vector. */
static void
-init_dummy_target ()
+init_dummy_target (void)
{
dummy_target.to_shortname = "None";
dummy_target.to_longname = "None";
static struct target_ops debug_target;
static void
-debug_to_open (args, from_tty)
- char *args;
- int from_tty;
+debug_to_open (char *args, int from_tty)
{
debug_target.to_open (args, from_tty);
}
static void
-debug_to_close (quitting)
- int quitting;
+debug_to_close (int quitting)
{
debug_target.to_close (quitting);
}
static void
-debug_to_attach (args, from_tty)
- char *args;
- int from_tty;
+debug_to_attach (char *args, int from_tty)
{
debug_target.to_attach (args, from_tty);
static void
-debug_to_post_attach (pid)
- int pid;
+debug_to_post_attach (int pid)
{
debug_target.to_post_attach (pid);
}
static void
-debug_to_require_attach (args, from_tty)
- char *args;
- int from_tty;
+debug_to_require_attach (char *args, int from_tty)
{
debug_target.to_require_attach (args, from_tty);
}
static void
-debug_to_detach (args, from_tty)
- char *args;
- int from_tty;
+debug_to_detach (char *args, int from_tty)
{
debug_target.to_detach (args, from_tty);
}
static void
-debug_to_require_detach (pid, args, from_tty)
- int pid;
- char *args;
- int from_tty;
+debug_to_require_detach (int pid, char *args, int from_tty)
{
debug_target.to_require_detach (pid, args, from_tty);
}
static void
-debug_to_resume (pid, step, siggnal)
- int pid;
- int step;
- enum target_signal siggnal;
+debug_to_resume (int pid, int step, enum target_signal siggnal)
{
debug_target.to_resume (pid, step, siggnal);
}
static int
-debug_to_wait (pid, status)
- int pid;
- struct target_waitstatus *status;
+debug_to_wait (int pid, struct target_waitstatus *status)
{
int retval;
}
static void
-debug_to_post_wait (pid, status)
- int pid;
- int status;
+debug_to_post_wait (int pid, int status)
{
debug_target.to_post_wait (pid, status);
}
static void
-debug_to_fetch_registers (regno)
- int regno;
+debug_to_fetch_registers (int regno)
{
debug_target.to_fetch_registers (regno);
}
static void
-debug_to_store_registers (regno)
- int regno;
+debug_to_store_registers (int regno)
{
debug_target.to_store_registers (regno);
}
static void
-debug_to_prepare_to_store ()
+debug_to_prepare_to_store (void)
{
debug_target.to_prepare_to_store ();
}
static int
-debug_to_xfer_memory (memaddr, myaddr, len, write, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *target;
+debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct mem_attrib *attrib,
+ struct target_ops *target)
{
int retval;
- retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target);
+ retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write,
+ attrib, target);
fprintf_unfiltered (gdb_stdlog,
"target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
}
static void
-debug_to_files_info (target)
- struct target_ops *target;
+debug_to_files_info (struct target_ops *target)
{
debug_target.to_files_info (target);
}
static int
-debug_to_insert_breakpoint (addr, save)
- CORE_ADDR addr;
- char *save;
+debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
{
int retval;
}
static int
-debug_to_remove_breakpoint (addr, save)
- CORE_ADDR addr;
- char *save;
+debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
{
int retval;
}
static void
-debug_to_terminal_init ()
+debug_to_terminal_init (void)
{
debug_target.to_terminal_init ();
}
static void
-debug_to_terminal_inferior ()
+debug_to_terminal_inferior (void)
{
debug_target.to_terminal_inferior ();
}
static void
-debug_to_terminal_ours_for_output ()
+debug_to_terminal_ours_for_output (void)
{
debug_target.to_terminal_ours_for_output ();
}
static void
-debug_to_terminal_ours ()
+debug_to_terminal_ours (void)
{
debug_target.to_terminal_ours ();
}
static void
-debug_to_terminal_info (arg, from_tty)
- char *arg;
- int from_tty;
+debug_to_terminal_info (char *arg, int from_tty)
{
debug_target.to_terminal_info (arg, from_tty);
}
static void
-debug_to_kill ()
+debug_to_kill (void)
{
debug_target.to_kill ();
}
static void
-debug_to_load (args, from_tty)
- char *args;
- int from_tty;
+debug_to_load (char *args, int from_tty)
{
debug_target.to_load (args, from_tty);
}
static int
-debug_to_lookup_symbol (name, addrp)
- char *name;
- CORE_ADDR *addrp;
+debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
{
int retval;
}
static void
-debug_to_create_inferior (exec_file, args, env)
- char *exec_file;
- char *args;
- char **env;
+debug_to_create_inferior (char *exec_file, char *args, char **env)
{
debug_target.to_create_inferior (exec_file, args, env);
}
static void
-debug_to_post_startup_inferior (pid)
- int pid;
+debug_to_post_startup_inferior (int pid)
{
debug_target.to_post_startup_inferior (pid);
}
static void
-debug_to_acknowledge_created_inferior (pid)
- int pid;
+debug_to_acknowledge_created_inferior (int pid)
{
debug_target.to_acknowledge_created_inferior (pid);
}
static void
-debug_to_clone_and_follow_inferior (child_pid, followed_child)
- int child_pid;
- int *followed_child;
+debug_to_clone_and_follow_inferior (int child_pid, int *followed_child)
{
debug_target.to_clone_and_follow_inferior (child_pid, followed_child);
}
static void
-debug_to_post_follow_inferior_by_clone ()
+debug_to_post_follow_inferior_by_clone (void)
{
debug_target.to_post_follow_inferior_by_clone ();
}
static int
-debug_to_insert_fork_catchpoint (pid)
- int pid;
+debug_to_insert_fork_catchpoint (int pid)
{
int retval;
}
static int
-debug_to_remove_fork_catchpoint (pid)
- int pid;
+debug_to_remove_fork_catchpoint (int pid)
{
int retval;
}
static int
-debug_to_insert_vfork_catchpoint (pid)
- int pid;
+debug_to_insert_vfork_catchpoint (int pid)
{
int retval;
}
static int
-debug_to_remove_vfork_catchpoint (pid)
- int pid;
+debug_to_remove_vfork_catchpoint (int pid)
{
int retval;
}
static int
-debug_to_has_forked (pid, child_pid)
- int pid;
- int *child_pid;
+debug_to_has_forked (int pid, int *child_pid)
{
int has_forked;
}
static int
-debug_to_has_vforked (pid, child_pid)
- int pid;
- int *child_pid;
+debug_to_has_vforked (int pid, int *child_pid)
{
int has_vforked;
}
static int
-debug_to_can_follow_vfork_prior_to_exec ()
+debug_to_can_follow_vfork_prior_to_exec (void)
{
int can_immediately_follow_vfork;
}
static void
-debug_to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child)
- int parent_pid;
- int followed_parent;
- int child_pid;
- int followed_child;
+debug_to_post_follow_vfork (int parent_pid, int followed_parent, int child_pid,
+ int followed_child)
{
debug_target.to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child);
}
static int
-debug_to_insert_exec_catchpoint (pid)
- int pid;
+debug_to_insert_exec_catchpoint (int pid)
{
int retval;
}
static int
-debug_to_remove_exec_catchpoint (pid)
- int pid;
+debug_to_remove_exec_catchpoint (int pid)
{
int retval;
}
static int
-debug_to_has_execd (pid, execd_pathname)
- int pid;
- char **execd_pathname;
+debug_to_has_execd (int pid, char **execd_pathname)
{
int has_execd;
}
static int
-debug_to_reported_exec_events_per_exec_call ()
+debug_to_reported_exec_events_per_exec_call (void)
{
int reported_exec_events;
}
static int
-debug_to_has_syscall_event (pid, kind, syscall_id)
- int pid;
- enum target_waitkind *kind;
- int *syscall_id;
+debug_to_has_syscall_event (int pid, enum target_waitkind *kind,
+ int *syscall_id)
{
int has_syscall_event;
char *kind_spelling = "??";
}
static int
-debug_to_has_exited (pid, wait_status, exit_status)
- int pid;
- int wait_status;
- int *exit_status;
+debug_to_has_exited (int pid, int wait_status, int *exit_status)
{
int has_exited;
}
static void
-debug_to_mourn_inferior ()
+debug_to_mourn_inferior (void)
{
debug_target.to_mourn_inferior ();
}
static int
-debug_to_can_run ()
+debug_to_can_run (void)
{
int retval;
}
static void
-debug_to_notice_signals (pid)
- int pid;
+debug_to_notice_signals (int pid)
{
debug_target.to_notice_signals (pid);
}
static int
-debug_to_thread_alive (pid)
- int pid;
+debug_to_thread_alive (int pid)
{
int retval;
}
static void
-debug_to_find_new_threads ()
+debug_to_find_new_threads (void)
{
debug_target.to_find_new_threads ();
}
static void
-debug_to_stop ()
+debug_to_stop (void)
{
debug_target.to_stop ();
}
static int
-debug_to_query (type, req, resp, siz)
- int type;
- char *req;
- char *resp;
- int *siz;
+debug_to_query (int type, char *req, char *resp, int *siz)
{
int retval;
}
static struct symtab_and_line *
-debug_to_enable_exception_callback (kind, enable)
- enum exception_event_kind kind;
- int enable;
+debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
{
struct symtab_and_line *result;
result = debug_target.to_enable_exception_callback (kind, enable);
}
static struct exception_event_record *
-debug_to_get_current_exception_event ()
+debug_to_get_current_exception_event (void)
{
struct exception_event_record *result;
result = debug_target.to_get_current_exception_event ();
}
static char *
-debug_to_pid_to_exec_file (pid)
- int pid;
+debug_to_pid_to_exec_file (int pid)
{
char *exec_file;
}
static char *
-debug_to_core_file_to_sym_file (core)
- char *core;
+debug_to_core_file_to_sym_file (char *core)
{
char *sym_file;
}
static void
-setup_target_debug ()
+setup_target_debug (void)
{
memcpy (&debug_target, ¤t_target, sizeof debug_target);
}
void
-initialize_targets ()
+initialize_targets (void)
{
init_dummy_target ();
push_target (&dummy_target);
add_com ("monitor", class_obscure, do_monitor_command,
"Send a command to the remote monitor (remote targets only).");
+ target_dcache = dcache_init();
+
if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
projects / deliverable / binutils-gdb.git / blobdiff