/* 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 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);
(*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)
tcomplain ();
}
+/* A default implementation for the to_get_ada_task_ptid target method.
+
+ This function builds the PTID by using both LWP and TID as part of
+ the PTID lwp and tid elements. The pid used is the pid of the
+ inferior_ptid. */
+
+ptid_t
+default_get_ada_task_ptid (long lwp, long tid)
+{
+ return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
+}
+
/* Go through the target stack from top to bottom, copying over zero
entries in current_target, then filling in still empty entries. In
effect, we are doing class inheritance through the pushed target
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);
+ /* Do not inherit to_wait. */
INHERIT (to_fetch_registers, t);
INHERIT (to_store_registers, t);
INHERIT (to_prepare_to_store, t);
INHERIT (to_kill, t);
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_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);
/* Do not inherit to_search_memory. */
+ INHERIT (to_supports_multi_process, t);
INHERIT (to_magic, t);
/* Do not inherit to_memory_map. */
/* Do not inherit to_flash_erase. */
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_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,
(int (*) (int))
return_one);
current_target.to_read_description = NULL;
+ de_fault (to_get_ada_task_ptid,
+ (ptid_t (*) (long, long))
+ default_get_ada_task_ptid);
+ de_fault (to_supports_multi_process,
+ (int (*) (void))
+ return_zero);
#undef de_fault
/* Finally, position the target-stack beneath the squashed
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)
(gdb) attach 4712
Cannot access memory at address 0xdeadbeef
*/
- no_shared_libraries (NULL, from_tty);
- invalidate_target_mem_regions ();
+ /* In some OSs, the shared library list is the same/global/shared
+ across inferiors. If code is shared between processes, so are
+ memory regions and features. */
+ if (!gdbarch_has_global_solist (target_gdbarch))
+ {
+ no_shared_libraries (NULL, from_tty);
- target_clear_description ();
+ invalidate_target_mem_regions ();
+
+ target_clear_description ();
+ }
}
/* This is to be called by the open routine before it does
void
target_detach (char *args, int from_tty)
{
- /* If we're in breakpoints-always-inserted mode, have to
- remove them before detaching. */
- remove_breakpoints ();
+ 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. */
+ ;
+ else
+ /* If we're in breakpoints-always-inserted mode, have to remove
+ them before detaching. */
+ remove_breakpoints ();
+
+ 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;
+ }
+ }
- (current_target.to_detach) (args, from_tty);
+ internal_error (__FILE__, __LINE__, "could not find a target to detach");
}
void
{
struct target_ops *t;
- /* If we're in breakpoints-always-inserted mode, have to
- remove them before disconnecting. */
+ /* If we're in breakpoints-always-inserted mode or if breakpoints
+ are global across processes, we have to remove them before
+ disconnecting. */
remove_breakpoints ();
for (t = current_target.beneath; t != NULL; t = t->beneath)
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)
{
"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");
+ 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;
}
}
+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;
}
+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)
{
fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
}
-static void
-debug_to_detach (char *args, int from_tty)
-{
- debug_target.to_detach (args, from_tty);
-
- fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
-}
-
static void
debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
{
target_signal_to_name (siggnal));
}
-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
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)
{
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)
{
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.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;
projects / deliverable / binutils-gdb.git / blobdiff