/* Select target systems and architectures at runtime for GDB.
Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
Contributed by Cygnus Support.
static void debug_to_open (char *, int);
-static void debug_to_close (int);
-
-static void debug_to_attach (char *, int);
-
-static void debug_to_detach (char *, int);
-
-static void debug_to_resume (ptid_t, int, enum target_signal);
-
-static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
-
-static void debug_to_fetch_registers (struct regcache *, int);
-
-static void debug_to_store_registers (struct regcache *, int);
-
static void debug_to_prepare_to_store (struct regcache *);
static void debug_to_files_info (struct target_ops *);
static void debug_to_terminal_info (char *, int);
-static void debug_to_kill (void);
-
static void debug_to_load (char *, int);
static int debug_to_lookup_symbol (char *, CORE_ADDR *);
-static void debug_to_mourn_inferior (void);
-
static int debug_to_can_run (void);
static void debug_to_notice_signals (ptid_t);
-static int debug_to_thread_alive (ptid_t);
-
static void debug_to_stop (ptid_t);
/* NOTE: cagney/2004-09-29: Many targets reference this variable in
{
}
+void
+target_kill (void)
+{
+ struct target_ops *t;
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ if (t->to_kill != NULL)
+ {
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
+
+ t->to_kill (t);
+ return;
+ }
+
+ noprocess ();
+}
+
void
target_load (char *arg, int from_tty)
{
(*current_target.to_load) (arg, from_tty);
}
+void
+target_create_inferior (char *exec_file, char *args,
+ char **env, int from_tty)
+{
+ struct target_ops *t;
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_create_inferior != NULL)
+ {
+ t->to_create_inferior (t, exec_file, args, env, from_tty);
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog,
+ "target_create_inferior (%s, %s, xxx, %d)\n",
+ exec_file, args, from_tty);
+ return;
+ }
+ }
+
+ internal_error (__FILE__, __LINE__,
+ "could not find a target to create inferior");
+}
+
+
static int
nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
struct target_ops *t)
{
printf_unfiltered (_("You are already running a program:\n"));
target_files_info ();
- if (query ("Kill it? "))
+ if (query (_("Kill it? ")))
{
target_kill ();
if (target_has_execution)
the PTID lwp and tid elements. The pid used is the pid of the
inferior_ptid. */
-ptid_t
+static ptid_t
default_get_ada_task_ptid (long lwp, long tid)
{
return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
INHERIT (to_doc, t);
/* Do not inherit to_open. */
/* Do not inherit to_close. */
- INHERIT (to_attach, t);
+ /* Do not inherit to_attach. */
INHERIT (to_post_attach, t);
INHERIT (to_attach_no_wait, t);
- INHERIT (to_detach, t);
+ /* Do not inherit to_detach. */
/* Do not inherit to_disconnect. */
- INHERIT (to_resume, t);
- INHERIT (to_wait, t);
- INHERIT (to_fetch_registers, t);
- INHERIT (to_store_registers, t);
+ /* Do not inherit to_resume. */
+ /* Do not inherit to_wait. */
+ /* Do not inherit to_fetch_registers. */
+ /* Do not inherit to_store_registers. */
INHERIT (to_prepare_to_store, t);
INHERIT (deprecated_xfer_memory, t);
INHERIT (to_files_info, t);
INHERIT (to_terminal_ours, t);
INHERIT (to_terminal_save_ours, t);
INHERIT (to_terminal_info, t);
- INHERIT (to_kill, t);
+ /* Do not inherit to_kill. */
INHERIT (to_load, t);
INHERIT (to_lookup_symbol, t);
- INHERIT (to_create_inferior, t);
+ /* Do no inherit to_create_inferior. */
INHERIT (to_post_startup_inferior, t);
INHERIT (to_acknowledge_created_inferior, t);
INHERIT (to_insert_fork_catchpoint, t);
INHERIT (to_insert_exec_catchpoint, t);
INHERIT (to_remove_exec_catchpoint, t);
INHERIT (to_has_exited, t);
- INHERIT (to_mourn_inferior, t);
+ /* Do not inherit to_mourn_inferiour. */
INHERIT (to_can_run, t);
INHERIT (to_notice_signals, t);
- INHERIT (to_thread_alive, t);
- INHERIT (to_find_new_threads, t);
- INHERIT (to_pid_to_str, t);
+ /* Do not inherit to_thread_alive. */
+ /* Do not inherit to_find_new_threads. */
+ /* Do not inherit to_pid_to_str. */
INHERIT (to_extra_thread_info, t);
INHERIT (to_stop, t);
/* Do not inherit to_xfer_partial. */
INHERIT (to_async_mask, t);
INHERIT (to_find_memory_regions, t);
INHERIT (to_make_corefile_notes, t);
- INHERIT (to_get_thread_local_address, t);
+ /* Do not inherit to_get_thread_local_address. */
INHERIT (to_can_execute_reverse, t);
/* Do not inherit to_read_description. */
INHERIT (to_get_ada_task_ptid, t);
de_fault (to_post_attach,
(void (*) (int))
target_ignore);
- de_fault (to_detach,
- (void (*) (char *, int))
- target_ignore);
- de_fault (to_resume,
- (void (*) (ptid_t, int, enum target_signal))
- noprocess);
- de_fault (to_wait,
- (ptid_t (*) (ptid_t, struct target_waitstatus *))
- noprocess);
- de_fault (to_fetch_registers,
- (void (*) (struct regcache *, int))
- target_ignore);
- de_fault (to_store_registers,
- (void (*) (struct regcache *, int))
- noprocess);
de_fault (to_prepare_to_store,
(void (*) (struct regcache *))
noprocess);
target_ignore);
de_fault (to_terminal_info,
default_terminal_info);
- de_fault (to_kill,
- (void (*) (void))
- noprocess);
de_fault (to_load,
(void (*) (char *, int))
tcomplain);
de_fault (to_has_exited,
(int (*) (int, int, int *))
return_zero);
- de_fault (to_mourn_inferior,
- (void (*) (void))
- noprocess);
de_fault (to_can_run,
return_zero);
de_fault (to_notice_signals,
(void (*) (ptid_t))
target_ignore);
- de_fault (to_thread_alive,
- (int (*) (ptid_t))
- return_zero);
- de_fault (to_find_new_threads,
- (void (*) (void))
- target_ignore);
de_fault (to_extra_thread_info,
(char *(*) (struct thread_info *))
return_zero);
target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
{
volatile CORE_ADDR addr = 0;
+ struct target_ops *target;
+
+ for (target = current_target.beneath;
+ target != NULL;
+ target = target->beneath)
+ {
+ if (target->to_get_thread_local_address != NULL)
+ break;
+ }
- if (target_get_thread_local_address_p ()
+ if (target != NULL
&& gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
{
ptid_t ptid = inferior_ptid;
throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
_("TLS load module not found"));
- addr = target_get_thread_local_address (ptid, lm_addr, offset);
+ addr = target->to_get_thread_local_address (target, ptid, lm_addr, offset);
}
/* If an error occurred, print TLS related messages here. Otherwise,
throw the error to some higher catcher. */
const unsigned char *myaddr = NULL;
fprintf_unfiltered (gdb_stdlog,
- "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, %s, %s) = %s",
+ "%s:target_xfer_partial (%d, %s, %s, %s, %s, %s) = %s",
ops->to_shortname,
(int) object,
(annex ? annex : "(null)"),
- (long) readbuf, (long) writebuf,
+ host_address_to_string (readbuf),
+ host_address_to_string (writebuf),
core_addr_to_string_nz (offset),
plongest (len), plongest (retval));
fputs_unfiltered (", bytes =", gdb_stdlog);
for (i = 0; i < retval; i++)
{
- if ((((long) &(myaddr[i])) & 0xf) == 0)
+ if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
{
if (targetdebug < 2 && i > 0)
{
tcomplain ();
}
-#ifndef target_stopped_data_address_p
-int
-target_stopped_data_address_p (struct target_ops *target)
-{
- if (target->to_stopped_data_address
- == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
- return 0;
- if (target->to_stopped_data_address == debug_to_stopped_data_address
- && (debug_target.to_stopped_data_address
- == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
- return 0;
- return 1;
-}
-#endif
-
static void
show_trust_readonly (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
void
target_detach (char *args, int from_tty)
{
+ struct target_ops* t;
+
if (gdbarch_has_global_solist (target_gdbarch))
/* Don't remove global breakpoints here. They're removed on
disconnection from the target. */
them before detaching. */
remove_breakpoints ();
- (current_target.to_detach) (args, from_tty);
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_detach != NULL)
+ {
+ t->to_detach (t, args, from_tty);
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
+ args, from_tty);
+ return;
+ }
+ }
+
+ internal_error (__FILE__, __LINE__, "could not find a target to detach");
}
void
tcomplain ();
}
+ptid_t
+target_wait (ptid_t ptid, struct target_waitstatus *status)
+{
+ struct target_ops *t;
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_wait != NULL)
+ {
+ ptid_t retval = (*t->to_wait) (t, ptid, status);
+
+ if (targetdebug)
+ {
+ char *status_string;
+
+ status_string = target_waitstatus_to_string (status);
+ fprintf_unfiltered (gdb_stdlog,
+ "target_wait (%d, status) = %d, %s\n",
+ PIDGET (ptid), PIDGET (retval),
+ status_string);
+ xfree (status_string);
+ }
+
+ return retval;
+ }
+ }
+
+ noprocess ();
+}
+
+char *
+target_pid_to_str (ptid_t ptid)
+{
+ struct target_ops *t;
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_pid_to_str != NULL)
+ return (*t->to_pid_to_str) (t, ptid);
+ }
+
+ return normal_pid_to_str (ptid);
+}
+
void
target_resume (ptid_t ptid, int step, enum target_signal signal)
{
+ struct target_ops *t;
+
dcache_invalidate (target_dcache);
- (*current_target.to_resume) (ptid, step, signal);
- set_executing (ptid, 1);
- set_running (ptid, 1);
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_resume != NULL)
+ {
+ t->to_resume (t, ptid, step, signal);
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
+ PIDGET (ptid),
+ step ? "step" : "continue",
+ target_signal_to_name (signal));
+
+ set_executing (ptid, 1);
+ set_running (ptid, 1);
+ return;
+ }
+ }
+
+ noprocess ();
}
/* Look through the list of possible targets for a target that can
follow forks. */
"could not find a target to follow fork");
}
+void
+target_mourn_inferior (void)
+{
+ struct target_ops *t;
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_mourn_inferior != NULL)
+ {
+ t->to_mourn_inferior (t);
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
+
+ /* We no longer need to keep handles on any of the object files.
+ Make sure to release them to avoid unnecessarily locking any
+ of them while we're not actually debugging. */
+ bfd_cache_close_all ();
+
+ return;
+ }
+ }
+
+ internal_error (__FILE__, __LINE__,
+ "could not find a target to follow mourn inferiour");
+}
+
/* Look for a target which can describe architectural features, starting
from TARGET. If we find one, return its description. */
}
void
-find_default_attach (char *args, int from_tty)
+find_default_attach (struct target_ops *ops, char *args, int from_tty)
{
struct target_ops *t;
t = find_default_run_target ("attach");
- (t->to_attach) (args, from_tty);
+ (t->to_attach) (t, args, from_tty);
return;
}
void
-find_default_create_inferior (char *exec_file, char *allargs, char **env,
+find_default_create_inferior (struct target_ops *ops,
+ char *exec_file, char *allargs, char **env,
int from_tty)
{
struct target_ops *t;
t = find_default_run_target ("run");
- (t->to_create_inferior) (exec_file, allargs, env, from_tty);
+ (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
return;
}
-int
+static int
find_default_can_async_p (void)
{
struct target_ops *t;
return 0;
}
-int
+static int
find_default_is_async_p (void)
{
struct target_ops *t;
return 0;
}
-int
+static int
find_default_supports_non_stop (void)
{
struct target_ops *t;
}
int
-target_supports_non_stop ()
+target_supports_non_stop (void)
{
struct target_ops *t;
for (t = ¤t_target; t != NULL; t = t->beneath)
}
+char *
+target_get_osdata (const char *type)
+{
+ char *document;
+ struct target_ops *t;
+
+ /* If we're already connected to something that can get us OS
+ related data, use it. Otherwise, try using the native
+ target. */
+ if (current_target.to_stratum >= process_stratum)
+ t = current_target.beneath;
+ else
+ t = find_default_run_target ("get OS data");
+
+ if (!t)
+ return NULL;
+
+ return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
+}
+
static int
default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
{
}
}
\f
-/* Returns zero to leave the inferior alone, one to interrupt it. */
-int (*target_activity_function) (void);
-int target_activity_fd;
-\f
/* Convert a normal process ID to a string. Returns the string in a
static buffer. */
return buf;
}
+static char *
+dummy_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+ return normal_pid_to_str (ptid);
+}
+
/* Error-catcher for target_find_memory_regions */
static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
{
dummy_target.to_longname = "None";
dummy_target.to_doc = "";
dummy_target.to_attach = find_default_attach;
+ dummy_target.to_detach =
+ (void (*)(struct target_ops *, char *, int))target_ignore;
dummy_target.to_create_inferior = find_default_create_inferior;
dummy_target.to_can_async_p = find_default_can_async_p;
dummy_target.to_is_async_p = find_default_is_async_p;
dummy_target.to_supports_non_stop = find_default_supports_non_stop;
- dummy_target.to_pid_to_str = normal_pid_to_str;
+ dummy_target.to_pid_to_str = dummy_pid_to_str;
dummy_target.to_stratum = dummy_stratum;
dummy_target.to_find_memory_regions = dummy_find_memory_regions;
dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
}
-static void
-debug_to_close (int quitting)
-{
- target_close (&debug_target, quitting);
- fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
-}
-
void
target_close (struct target_ops *targ, int quitting)
{
targ->to_xclose (targ, quitting);
else if (targ->to_close != NULL)
targ->to_close (quitting);
+
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
}
-static void
-debug_to_attach (char *args, int from_tty)
+void
+target_attach (char *args, int from_tty)
{
- debug_target.to_attach (args, from_tty);
+ struct target_ops *t;
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_attach != NULL)
+ {
+ t->to_attach (t, args, from_tty);
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n",
+ args, from_tty);
+ return;
+ }
+ }
- fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
+ internal_error (__FILE__, __LINE__,
+ "could not find a target to attach");
}
-
-static void
-debug_to_post_attach (int pid)
+int
+target_thread_alive (ptid_t ptid)
{
- debug_target.to_post_attach (pid);
+ struct target_ops *t;
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_thread_alive != NULL)
+ {
+ int retval;
- fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
+ retval = t->to_thread_alive (t, ptid);
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
+ PIDGET (ptid), retval);
+
+ return retval;
+ }
+ }
+
+ return 0;
}
-static void
-debug_to_detach (char *args, int from_tty)
+void
+target_find_new_threads (void)
{
- debug_target.to_detach (args, from_tty);
+ struct target_ops *t;
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_find_new_threads != NULL)
+ {
+ t->to_find_new_threads (t);
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
- fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
+ return;
+ }
+ }
}
static void
-debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
+debug_to_post_attach (int pid)
{
- debug_target.to_resume (ptid, step, siggnal);
+ debug_target.to_post_attach (pid);
- fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
- step ? "step" : "continue",
- target_signal_to_name (siggnal));
+ fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
}
-static ptid_t
-debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
-{
- ptid_t retval;
+/* Return a pretty printed form of target_waitstatus.
+ Space for the result is malloc'd, caller must free. */
- retval = debug_target.to_wait (ptid, status);
+char *
+target_waitstatus_to_string (const struct target_waitstatus *ws)
+{
+ const char *kind_str = "status->kind = ";
- fprintf_unfiltered (gdb_stdlog,
- "target_wait (%d, status) = %d, ", PIDGET (ptid),
- PIDGET (retval));
- fprintf_unfiltered (gdb_stdlog, "status->kind = ");
- switch (status->kind)
+ switch (ws->kind)
{
case TARGET_WAITKIND_EXITED:
- fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
- status->value.integer);
- break;
+ return xstrprintf ("%sexited, status = %d",
+ kind_str, ws->value.integer);
case TARGET_WAITKIND_STOPPED:
- fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
- target_signal_to_name (status->value.sig));
- break;
+ return xstrprintf ("%sstopped, signal = %s",
+ kind_str, target_signal_to_name (ws->value.sig));
case TARGET_WAITKIND_SIGNALLED:
- fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
- target_signal_to_name (status->value.sig));
- break;
+ return xstrprintf ("%ssignalled, signal = %s",
+ kind_str, target_signal_to_name (ws->value.sig));
case TARGET_WAITKIND_LOADED:
- fprintf_unfiltered (gdb_stdlog, "loaded\n");
- break;
+ return xstrprintf ("%sloaded", kind_str);
case TARGET_WAITKIND_FORKED:
- fprintf_unfiltered (gdb_stdlog, "forked\n");
- break;
+ return xstrprintf ("%sforked", kind_str);
case TARGET_WAITKIND_VFORKED:
- fprintf_unfiltered (gdb_stdlog, "vforked\n");
- break;
+ return xstrprintf ("%svforked", kind_str);
case TARGET_WAITKIND_EXECD:
- fprintf_unfiltered (gdb_stdlog, "execd\n");
- break;
+ return xstrprintf ("%sexecd", kind_str);
+ case TARGET_WAITKIND_SYSCALL_ENTRY:
+ return xstrprintf ("%ssyscall-entry", kind_str);
+ case TARGET_WAITKIND_SYSCALL_RETURN:
+ return xstrprintf ("%ssyscall-return", kind_str);
case TARGET_WAITKIND_SPURIOUS:
- fprintf_unfiltered (gdb_stdlog, "spurious\n");
- break;
+ return xstrprintf ("%sspurious", kind_str);
+ case TARGET_WAITKIND_IGNORE:
+ return xstrprintf ("%signore", kind_str);
+ case TARGET_WAITKIND_NO_HISTORY:
+ return xstrprintf ("%sno-history", kind_str);
default:
- fprintf_unfiltered (gdb_stdlog, "unknown???\n");
- break;
+ return xstrprintf ("%sunknown???", kind_str);
}
-
- return retval;
}
static void
fprintf_unfiltered (gdb_stdlog, "\n");
}
-static void
-debug_to_fetch_registers (struct regcache *regcache, int regno)
+void
+target_fetch_registers (struct regcache *regcache, int regno)
{
- debug_target.to_fetch_registers (regcache, regno);
- debug_print_register ("target_fetch_registers", regcache, regno);
+ struct target_ops *t;
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_fetch_registers != NULL)
+ {
+ t->to_fetch_registers (t, regcache, regno);
+ if (targetdebug)
+ debug_print_register ("target_fetch_registers", regcache, regno);
+ return;
+ }
+ }
}
-static void
-debug_to_store_registers (struct regcache *regcache, int regno)
+void
+target_store_registers (struct regcache *regcache, int regno)
{
- debug_target.to_store_registers (regcache, regno);
- debug_print_register ("target_store_registers", regcache, regno);
- fprintf_unfiltered (gdb_stdlog, "\n");
+
+ struct target_ops *t;
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_store_registers != NULL)
+ {
+ t->to_store_registers (t, regcache, regno);
+ if (targetdebug)
+ {
+ debug_print_register ("target_store_registers", regcache, regno);
+ }
+ return;
+ }
+ }
+
+ noprocess ();
}
static void
attrib, target);
fprintf_unfiltered (gdb_stdlog,
- "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
- (unsigned int) memaddr, /* possable truncate long long */
- len, write ? "write" : "read", retval);
+ "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
+ paddress (memaddr), len, write ? "write" : "read",
+ retval);
if (retval > 0)
{
fputs_unfiltered (", bytes =", gdb_stdlog);
for (i = 0; i < retval; i++)
{
- if ((((long) &(myaddr[i])) & 0xf) == 0)
+ if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
{
if (targetdebug < 2 && i > 0)
{
retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
fprintf_unfiltered (gdb_stdlog,
- "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
+ "target_region_ok_for_hw_watchpoint (%ld, %ld) = 0x%lx\n",
(unsigned long) addr,
(unsigned long) len,
(unsigned long) retval);
retval = debug_target.to_stopped_by_watchpoint ();
fprintf_unfiltered (gdb_stdlog,
- "STOPPED_BY_WATCHPOINT () = %ld\n",
+ "target_stopped_by_watchpoint () = %ld\n",
(unsigned long) retval);
return retval;
}
from_tty);
}
-static void
-debug_to_kill (void)
-{
- debug_target.to_kill ();
-
- fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
-}
-
static void
debug_to_load (char *args, int from_tty)
{
return retval;
}
-static void
-debug_to_create_inferior (char *exec_file, char *args, char **env,
- int from_tty)
-{
- debug_target.to_create_inferior (exec_file, args, env, from_tty);
-
- fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
- exec_file, args, from_tty);
-}
-
static void
debug_to_post_startup_inferior (ptid_t ptid)
{
return has_exited;
}
-static void
-debug_to_mourn_inferior (void)
-{
- debug_target.to_mourn_inferior ();
-
- fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
-}
-
static int
debug_to_can_run (void)
{
PIDGET (ptid));
}
-static int
-debug_to_thread_alive (ptid_t ptid)
-{
- int retval;
-
- retval = debug_target.to_thread_alive (ptid);
-
- fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
- PIDGET (ptid), retval);
-
- return retval;
-}
-
-static void
-debug_to_find_new_threads (void)
-{
- debug_target.to_find_new_threads ();
-
- fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
-}
-
static void
debug_to_stop (ptid_t ptid)
{
memcpy (&debug_target, ¤t_target, sizeof debug_target);
current_target.to_open = debug_to_open;
- current_target.to_close = debug_to_close;
- current_target.to_attach = debug_to_attach;
current_target.to_post_attach = debug_to_post_attach;
- current_target.to_detach = debug_to_detach;
- current_target.to_resume = debug_to_resume;
- current_target.to_wait = debug_to_wait;
- current_target.to_fetch_registers = debug_to_fetch_registers;
- current_target.to_store_registers = debug_to_store_registers;
current_target.to_prepare_to_store = debug_to_prepare_to_store;
current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
current_target.to_files_info = debug_to_files_info;
current_target.to_terminal_ours = debug_to_terminal_ours;
current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
current_target.to_terminal_info = debug_to_terminal_info;
- current_target.to_kill = debug_to_kill;
current_target.to_load = debug_to_load;
current_target.to_lookup_symbol = debug_to_lookup_symbol;
- current_target.to_create_inferior = debug_to_create_inferior;
current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
current_target.to_has_exited = debug_to_has_exited;
- current_target.to_mourn_inferior = debug_to_mourn_inferior;
current_target.to_can_run = debug_to_can_run;
current_target.to_notice_signals = debug_to_notice_signals;
- current_target.to_thread_alive = debug_to_thread_alive;
- current_target.to_find_new_threads = debug_to_find_new_threads;
current_target.to_stop = debug_to_stop;
current_target.to_rcmd = debug_to_rcmd;
current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
projects / deliverable / binutils-gdb.git / blobdiff