/* Interface between GDB and target environments, including files and processes
Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by John Gilmore.
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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
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., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#if !defined (TARGET_H)
#define TARGET_H
struct mem_attrib;
struct target_ops;
struct bp_target_info;
+struct regcache;
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
#include "dcache.h"
#include "memattr.h"
#include "vec.h"
+#include "gdb_signals.h"
enum strata
{
dummy_stratum, /* The lowest of the low */
file_stratum, /* Executable files, etc */
core_stratum, /* Core dump files */
- download_stratum, /* Downloading of remote targets */
process_stratum, /* Executing processes */
thread_stratum /* Executing threads */
};
{
tc_none = 0, /* Default: can't control thread execution. */
tc_schedlock = 1, /* Can lock the thread scheduler. */
- tc_switch = 2 /* Can switch the running thread on demand. */
};
/* Stuff for target_wait. */
(e.g. it called load(2) on AIX). */
TARGET_WAITKIND_LOADED,
- /* The program has forked. A "related" process' ID is in
+ /* The program has forked. A "related" process' PTID is in
value.related_pid. I.e., if the child forks, value.related_pid
is the parent's ID. */
TARGET_WAITKIND_FORKED,
- /* The program has vforked. A "related" process's ID is in
+ /* The program has vforked. A "related" process's PTID is in
value.related_pid. */
TARGET_WAITKIND_VFORKED,
inferior, rather than being stuck in the remote_async_wait()
function. This way the event loop is responsive to other events,
like for instance the user typing. */
- TARGET_WAITKIND_IGNORE
+ TARGET_WAITKIND_IGNORE,
+
+ /* The target has run out of history information,
+ and cannot run backward any further. */
+ TARGET_WAITKIND_NO_HISTORY
};
struct target_waitstatus
{
int integer;
enum target_signal sig;
- int related_pid;
+ ptid_t related_pid;
char *execd_pathname;
int syscall_id;
}
value;
};
+/* Return a pretty printed form of target_waitstatus.
+ Space for the result is malloc'd, caller must free. */
+extern char *target_waitstatus_to_string (const struct target_waitstatus *);
+
/* Possible types of events that the inferior handler will have to
deal with. */
enum inferior_event_type
'step n' like commands. */
INF_EXEC_CONTINUE
};
-
-/* Return the string for a signal. */
-extern char *target_signal_to_string (enum target_signal);
-
-/* Return the name (SIGHUP, etc.) for a signal. */
-extern char *target_signal_to_name (enum target_signal);
-
-/* Given a name (SIGHUP, etc.), return its signal. */
-enum target_signal target_signal_from_name (char *);
\f
/* Target objects which can be transfered using target_read,
target_write, et cetera. */
{
/* AVR target specific transfer. See "avr-tdep.c" and "remote.c". */
TARGET_OBJECT_AVR,
+ /* SPU target specific transfer. See "spu-tdep.c". */
+ TARGET_OBJECT_SPU,
/* Transfer up-to LEN bytes of memory starting at OFFSET. */
TARGET_OBJECT_MEMORY,
/* Memory, avoiding GDB's data cache and trusting the executable.
TARGET_OBJECT_FLASH,
/* Available target-specific features, e.g. registers and coprocessors.
See "target-descriptions.c". ANNEX should never be empty. */
- TARGET_OBJECT_AVAILABLE_FEATURES
- /* Possible future objects: TARGET_OBJECT_FILE, TARGET_OBJECT_PROC, ... */
+ TARGET_OBJECT_AVAILABLE_FEATURES,
+ /* Currently loaded libraries, in XML format. */
+ TARGET_OBJECT_LIBRARIES,
+ /* Get OS specific data. The ANNEX specifies the type (running
+ processes, etc.). */
+ TARGET_OBJECT_OSDATA,
+ /* Extra signal info. Usually the contents of `siginfo_t' on unix
+ platforms. */
+ TARGET_OBJECT_SIGNAL_INFO,
+ /* Possible future objects: TARGET_OBJECT_FILE, ... */
};
/* Request that OPS transfer up to LEN 8-bit bytes of the target's
const char *annex, gdb_byte *buf,
ULONGEST offset, LONGEST len);
+extern LONGEST target_read_until_error (struct target_ops *ops,
+ enum target_object object,
+ const char *annex, gdb_byte *buf,
+ ULONGEST offset, LONGEST len);
+
extern LONGEST target_write (struct target_ops *ops,
enum target_object object,
const char *annex, const gdb_byte *buf,
extern ULONGEST get_target_memory_unsigned (struct target_ops *ops,
CORE_ADDR addr, int len);
\f
-
-/* If certain kinds of activity happen, target_wait should perform
- callbacks. */
-/* Right now we just call (*TARGET_ACTIVITY_FUNCTION) if I/O is possible
- on TARGET_ACTIVITY_FD. */
-extern int target_activity_fd;
-/* Returns zero to leave the inferior alone, one to interrupt it. */
-extern int (*target_activity_function) (void);
-\f
struct thread_info; /* fwd decl for parameter list below: */
struct target_ops
to xfree everything (including the "struct target_ops"). */
void (*to_xclose) (struct target_ops *targ, int quitting);
void (*to_close) (int);
- void (*to_attach) (char *, int);
+ void (*to_attach) (struct target_ops *ops, char *, int);
void (*to_post_attach) (int);
- void (*to_detach) (char *, int);
+ void (*to_detach) (struct target_ops *ops, char *, int);
void (*to_disconnect) (struct target_ops *, char *, int);
- void (*to_resume) (ptid_t, int, enum target_signal);
- ptid_t (*to_wait) (ptid_t, struct target_waitstatus *);
- void (*to_fetch_registers) (int);
- void (*to_store_registers) (int);
- void (*to_prepare_to_store) (void);
+ void (*to_resume) (struct target_ops *, ptid_t, int, enum target_signal);
+ ptid_t (*to_wait) (struct target_ops *,
+ ptid_t, struct target_waitstatus *);
+ void (*to_fetch_registers) (struct target_ops *, struct regcache *, int);
+ void (*to_store_registers) (struct target_ops *, struct regcache *, int);
+ void (*to_prepare_to_store) (struct regcache *);
/* Transfer LEN bytes of memory between GDB address MYADDR and
target address MEMADDR. If WRITE, transfer them to the target, else
int (*to_remove_watchpoint) (CORE_ADDR, int, int);
int (*to_insert_watchpoint) (CORE_ADDR, int, int);
int (*to_stopped_by_watchpoint) (void);
+ int to_have_steppable_watchpoint;
int to_have_continuable_watchpoint;
int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *);
+ int (*to_watchpoint_addr_within_range) (struct target_ops *,
+ CORE_ADDR, CORE_ADDR, int);
int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, int);
void (*to_terminal_init) (void);
void (*to_terminal_inferior) (void);
void (*to_terminal_ours) (void);
void (*to_terminal_save_ours) (void);
void (*to_terminal_info) (char *, int);
- void (*to_kill) (void);
+ void (*to_kill) (struct target_ops *);
void (*to_load) (char *, int);
int (*to_lookup_symbol) (char *, CORE_ADDR *);
- void (*to_create_inferior) (char *, char *, char **, int);
+ void (*to_create_inferior) (struct target_ops *,
+ char *, char *, char **, int);
void (*to_post_startup_inferior) (ptid_t);
void (*to_acknowledge_created_inferior) (int);
void (*to_insert_fork_catchpoint) (int);
int (*to_follow_fork) (struct target_ops *, int);
void (*to_insert_exec_catchpoint) (int);
int (*to_remove_exec_catchpoint) (int);
- int (*to_reported_exec_events_per_exec_call) (void);
int (*to_has_exited) (int, int, int *);
- void (*to_mourn_inferior) (void);
+ void (*to_mourn_inferior) (struct target_ops *);
int (*to_can_run) (void);
void (*to_notice_signals) (ptid_t ptid);
- int (*to_thread_alive) (ptid_t ptid);
- void (*to_find_new_threads) (void);
- char *(*to_pid_to_str) (ptid_t);
+ int (*to_thread_alive) (struct target_ops *, ptid_t ptid);
+ void (*to_find_new_threads) (struct target_ops *);
+ char *(*to_pid_to_str) (struct target_ops *, ptid_t);
char *(*to_extra_thread_info) (struct thread_info *);
- void (*to_stop) (void);
+ void (*to_stop) (ptid_t);
void (*to_rcmd) (char *command, struct ui_file *output);
- struct symtab_and_line *(*to_enable_exception_callback) (enum
- exception_event_kind,
- int);
- struct exception_event_record *(*to_get_current_exception_event) (void);
char *(*to_pid_to_exec_file) (int pid);
+ void (*to_log_command) (const char *);
enum strata to_stratum;
int to_has_all_memory;
int to_has_memory;
int to_has_registers;
int to_has_execution;
int to_has_thread_control; /* control thread execution */
+ int to_attach_no_wait;
struct section_table
*to_sections;
struct section_table
/* ASYNC target controls */
int (*to_can_async_p) (void);
int (*to_is_async_p) (void);
- void (*to_async) (void (*cb) (enum inferior_event_type, void *context),
- void *context);
- int to_async_mask_value;
+ void (*to_async) (void (*) (enum inferior_event_type, void *), void *);
+ int (*to_async_mask) (int);
+ int (*to_supports_non_stop) (void);
int (*to_find_memory_regions) (int (*) (CORE_ADDR,
unsigned long,
int, int, int,
or executable file given by OBJFILE. If that block of
thread-local storage hasn't been allocated yet, this function
may return an error. */
- CORE_ADDR (*to_get_thread_local_address) (ptid_t ptid,
+ CORE_ADDR (*to_get_thread_local_address) (struct target_ops *ops,
+ ptid_t ptid,
CORE_ADDR load_module_addr,
CORE_ADDR offset);
was available. */
const struct target_desc *(*to_read_description) (struct target_ops *ops);
+ /* Build the PTID of the thread on which a given task is running,
+ based on LWP and THREAD. These values are extracted from the
+ task Private_Data section of the Ada Task Control Block, and
+ their interpretation depends on the target. */
+ ptid_t (*to_get_ada_task_ptid) (long lwp, long thread);
+
+ /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
+ Return 0 if *READPTR is already at the end of the buffer.
+ Return -1 if there is insufficient buffer for a whole entry.
+ Return 1 if an entry was read into *TYPEP and *VALP. */
+ int (*to_auxv_parse) (struct target_ops *ops, gdb_byte **readptr,
+ gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp);
+
+ /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
+ sequence of bytes in PATTERN with length PATTERN_LEN.
+
+ The result is 1 if found, 0 if not found, and -1 if there was an error
+ requiring halting of the search (e.g. memory read error).
+ If the pattern is found the address is recorded in FOUND_ADDRP. */
+ int (*to_search_memory) (struct target_ops *ops,
+ CORE_ADDR start_addr, ULONGEST search_space_len,
+ const gdb_byte *pattern, ULONGEST pattern_len,
+ CORE_ADDR *found_addrp);
+
+ /* Can target execute in reverse? */
+ int (*to_can_execute_reverse) (void);
+
+ /* Does this target support debugging multiple processes
+ simultaneously? */
+ int (*to_supports_multi_process) (void);
+
int to_magic;
/* Need sub-structure for target machine related rather than comm related?
*/
should be ready to deliver the status of the process immediately
(without waiting) to an upcoming target_wait call. */
-#define target_attach(args, from_tty) \
- (*current_target.to_attach) (args, from_tty)
+void target_attach (char *, int);
+
+/* Some targets don't generate traps when attaching to the inferior,
+ or their target_attach implementation takes care of the waiting.
+ These targets must set to_attach_no_wait. */
+
+#define target_attach_no_wait \
+ (current_target.to_attach_no_wait)
/* The target_attach operation places a process under debugger control,
and stops the process.
the target, or TARGET_SIGNAL_0 for no signal. The caller may not
pass TARGET_SIGNAL_DEFAULT. */
-#define target_resume(ptid, step, siggnal) \
- do { \
- dcache_invalidate(target_dcache); \
- (*current_target.to_resume) (ptid, step, siggnal); \
- } while (0)
+extern void target_resume (ptid_t ptid, int step, enum target_signal signal);
/* Wait for process pid to do something. PTID = -1 to wait for any
pid to do something. Return pid of child, or -1 in case of error;
to the prompt with a debugging target but without the frame cache,
stop_pc, etc., set up. */
-#define target_wait(ptid, status) \
- (*current_target.to_wait) (ptid, status)
+extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status);
/* Fetch at least register REGNO, or all regs if regno == -1. No result. */
-#define target_fetch_registers(regno) \
- (*current_target.to_fetch_registers) (regno)
+extern void target_fetch_registers (struct regcache *regcache, int regno);
/* Store at least register REGNO, or all regs if REGNO == -1.
It can store as many registers as it wants to, so target_prepare_to_store
must have been previously called. Calls error() if there are problems. */
-#define target_store_registers(regs) \
- (*current_target.to_store_registers) (regs)
+extern void target_store_registers (struct regcache *regcache, int regs);
/* Get ready to modify the registers array. On machines which store
individual registers, this doesn't need to do anything. On machines
that REGISTERS contains all the registers from the program being
debugged. */
-#define target_prepare_to_store() \
- (*current_target.to_prepare_to_store) ()
+#define target_prepare_to_store(regcache) \
+ (*current_target.to_prepare_to_store) (regcache)
+
+/* Returns true if this target can debug multiple processes
+ simultaneously. */
+
+#define target_supports_multi_process() \
+ (*current_target.to_supports_multi_process) ()
extern DCACHE *target_dcache;
extern int xfer_memory (CORE_ADDR, gdb_byte *, int, int,
struct mem_attrib *, struct target_ops *);
-extern int child_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
- struct mem_attrib *, struct target_ops *);
-
/* Fetches the target's memory map. If one is found it is sorted
and returned, after some consistency checking. Otherwise, NULL
is returned. */
enum flash_preserve_mode preserve_flash_p,
void (*progress_cb) (ULONGEST, void *));
-
-extern char *child_pid_to_exec_file (int);
-
-extern char *child_core_file_to_sym_file (char *);
-
-#if defined(CHILD_POST_ATTACH)
-extern void child_post_attach (int);
-#endif
-
-extern void child_post_startup_inferior (ptid_t);
-
-extern void child_acknowledge_created_inferior (int);
-
-extern void child_insert_fork_catchpoint (int);
-
-extern int child_remove_fork_catchpoint (int);
-
-extern void child_insert_vfork_catchpoint (int);
-
-extern int child_remove_vfork_catchpoint (int);
-
-extern void child_acknowledge_created_inferior (int);
-
-extern int child_follow_fork (struct target_ops *, int);
-
-extern void child_insert_exec_catchpoint (int);
-
-extern int child_remove_exec_catchpoint (int);
-
-extern int child_reported_exec_events_per_exec_call (void);
-
-extern int child_has_exited (int, int, int *);
-
-extern int child_thread_alive (ptid_t);
-
/* From infrun.c. */
-extern int inferior_has_forked (int pid, int *child_pid);
+extern int inferior_has_forked (ptid_t pid, ptid_t *child_pid);
-extern int inferior_has_vforked (int pid, int *child_pid);
+extern int inferior_has_vforked (ptid_t pid, ptid_t *child_pid);
-extern int inferior_has_execd (int pid, char **execd_pathname);
+extern int inferior_has_execd (ptid_t pid, char **execd_pathname);
/* From exec.c */
/* Kill the inferior process. Make it go away. */
-#define target_kill() \
- (*current_target.to_kill) ()
+extern void target_kill (void);
/* Load an executable file into the target process. This is expected
to not only bring new code into the target process, but also to
ENV is the environment vector to pass. Errors reported with error().
On VxWorks and various standalone systems, we ignore exec_file. */
-#define target_create_inferior(exec_file, args, env, FROM_TTY) \
- (*current_target.to_create_inferior) (exec_file, args, env, (FROM_TTY))
-
+void target_create_inferior (char *exec_file, char *args,
+ char **env, int from_tty);
/* Some targets (such as ttrace-based HPUX) don't allow us to request
notification of inferior events such as fork and vork immediately
#define target_remove_exec_catchpoint(pid) \
(*current_target.to_remove_exec_catchpoint) (pid)
-/* Returns the number of exec events that are reported when a process
- invokes a flavor of the exec() system call on this target, if exec
- events are being reported. */
-
-#define target_reported_exec_events_per_exec_call() \
- (*current_target.to_reported_exec_events_per_exec_call) ()
-
/* Returns TRUE if PID has exited. And, also sets EXIT_STATUS to the
exit code of PID, if any. */
/* The inferior process has died. Do what is right. */
-#define target_mourn_inferior() \
- (*current_target.to_mourn_inferior) ()
+void target_mourn_inferior (void);
/* Does target have enough data to do a run or attach command? */
/* Check to see if a thread is still alive. */
-#define target_thread_alive(ptid) \
- (*current_target.to_thread_alive) (ptid)
+extern int target_thread_alive (ptid_t ptid);
/* Query for new threads and add them to the thread list. */
-#define target_find_new_threads() \
- (*current_target.to_find_new_threads) (); \
+extern void target_find_new_threads (void);
/* Make target stop in a continuable fashion. (For instance, under
Unix, this should act like SIGSTOP). This function is normally
used by GUIs to implement a stop button. */
-#define target_stop current_target.to_stop
+#define target_stop(ptid) (*current_target.to_stop) (ptid)
/* Send the specified COMMAND to the target's monitor
(shell,interpreter) for execution. The result of the query is
(*current_target.to_rcmd) (command, outbuf)
-/* Get the symbol information for a breakpointable routine called when
- an exception event occurs.
- Intended mainly for C++, and for those
- platforms/implementations where such a callback mechanism is available,
- e.g. HP-UX with ANSI C++ (aCC). Some compilers (e.g. g++) support
- different mechanisms for debugging exceptions. */
-
-#define target_enable_exception_callback(kind, enable) \
- (*current_target.to_enable_exception_callback) (kind, enable)
-
-/* Get the current exception event kind -- throw or catch, etc. */
-
-#define target_get_current_exception_event() \
- (*current_target.to_get_current_exception_event) ()
-
/* Does the target include all of memory, or only part of it? This
determines whether we look up the target chain for other parts of
memory if this target can't satisfy a request. */
(current_target.to_has_execution)
/* Can the target support the debugger control of thread execution?
- a) Can it lock the thread scheduler?
- b) Can it switch the currently running thread? */
+ Can it lock the thread scheduler? */
#define target_can_lock_scheduler \
(current_target.to_has_thread_control & tc_schedlock)
-#define target_can_switch_threads \
- (current_target.to_has_thread_control & tc_switch)
+/* Should the target enable async mode if it is supported? Temporary
+ cludge until async mode is a strict superset of sync mode. */
+extern int target_async_permitted;
/* Can the target support asynchronous execution? */
#define target_can_async_p() (current_target.to_can_async_p ())
/* Is the target in asynchronous execution mode? */
-#define target_is_async_p() (current_target.to_is_async_p())
+#define target_is_async_p() (current_target.to_is_async_p ())
+
+int target_supports_non_stop (void);
/* Put the target in async mode with the specified callback function. */
#define target_async(CALLBACK,CONTEXT) \
- (current_target.to_async((CALLBACK), (CONTEXT)))
+ (current_target.to_async ((CALLBACK), (CONTEXT)))
/* This is to be used ONLY within call_function_by_hand(). It provides
a workaround, to have inferior function calls done in sychronous
the turning async on and off to the single execution commands,
from where it is done currently, in remote_resume(). */
-#define target_async_mask_value \
- (current_target.to_async_mask_value)
-
-extern int target_async_mask (int mask);
+#define target_async_mask(MASK) \
+ (current_target.to_async_mask (MASK))
/* Converts a process id to a string. Usually, the string just contains
`process xyz', but on some systems it may contain
`process xyz thread abc'. */
-#undef target_pid_to_str
-#define target_pid_to_str(PID) current_target.to_pid_to_str (PID)
+extern char *target_pid_to_str (ptid_t ptid);
-#ifndef target_tid_to_str
-#define target_tid_to_str(PID) \
- target_pid_to_str (PID)
extern char *normal_pid_to_str (ptid_t ptid);
-#endif
/* Return a short string describing extra information about PID,
e.g. "sleeping", "runnable", "running on LWP 3". Null return value
#define target_extra_thread_info(TP) \
(current_target.to_extra_thread_info (TP))
-/*
- * New Objfile Event Hook:
- *
- * Sometimes a GDB component wants to get notified whenever a new
- * objfile is loaded. Mainly this is used by thread-debugging
- * implementations that need to know when symbols for the target
- * thread implemenation are available.
- *
- * The old way of doing this is to define a macro 'target_new_objfile'
- * that points to the function that you want to be called on every
- * objfile/shlib load.
-
- The new way is to grab the function pointer,
- 'deprecated_target_new_objfile_hook', and point it to the function
- that you want to be called on every objfile/shlib load.
-
- If multiple clients are willing to be cooperative, they can each
- save a pointer to the previous value of
- deprecated_target_new_objfile_hook before modifying it, and arrange
- for their function to call the previous function in the chain. In
- that way, multiple clients can receive this notification (something
- like with signal handlers). */
-
-extern void (*deprecated_target_new_objfile_hook) (struct objfile *);
-
-#ifndef target_pid_or_tid_to_str
-#define target_pid_or_tid_to_str(ID) \
- target_pid_to_str (ID)
-#endif
-
/* Attempts to find the pathname of the executable file
that was run to create a specified process.
#define target_make_corefile_notes(BFD, SIZE_P) \
(current_target.to_make_corefile_notes) (BFD, SIZE_P)
-/* Thread-local values. */
-#define target_get_thread_local_address \
- (current_target.to_get_thread_local_address)
-#define target_get_thread_local_address_p() \
- (target_get_thread_local_address != NULL)
-
-/* Hook to call target dependent code just after inferior target process has
- started. */
-
-#ifndef TARGET_CREATE_INFERIOR_HOOK
-#define TARGET_CREATE_INFERIOR_HOOK(PID)
-#endif
-
/* Hardware watchpoint interfaces. */
/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
(*current_target.to_stopped_by_watchpoint) ()
#endif
+/* Non-zero if we have steppable watchpoints */
+
+#ifndef HAVE_STEPPABLE_WATCHPOINT
+#define HAVE_STEPPABLE_WATCHPOINT \
+ (current_target.to_have_steppable_watchpoint)
+#endif
+
/* Non-zero if we have continuable watchpoints */
#ifndef HAVE_CONTINUABLE_WATCHPOINT
(*current_target.to_remove_hw_breakpoint) (bp_tgt)
#endif
-extern int target_stopped_data_address_p (struct target_ops *);
-
#ifndef target_stopped_data_address
#define target_stopped_data_address(target, x) \
(*target.to_stopped_data_address) (target, x)
-#else
-/* Horrible hack to get around existing macros :-(. */
-#define target_stopped_data_address_p(CURRENT_TARGET) (1)
#endif
+#define target_watchpoint_addr_within_range(target, addr, start, length) \
+ (*target.to_watchpoint_addr_within_range) (target, addr, start, length)
+
+/* Target can execute in reverse? */
+#define target_can_execute_reverse \
+ (current_target.to_can_execute_reverse ? \
+ current_target.to_can_execute_reverse () : 0)
+
extern const struct target_desc *target_read_description (struct target_ops *);
+#define target_get_ada_task_ptid(lwp, tid) \
+ (*current_target.to_get_ada_task_ptid) (lwp,tid)
+
+/* Utility implementation of searching memory. */
+extern int simple_search_memory (struct target_ops* ops,
+ CORE_ADDR start_addr,
+ ULONGEST search_space_len,
+ const gdb_byte *pattern,
+ ULONGEST pattern_len,
+ CORE_ADDR *found_addrp);
+
+/* Main entry point for searching memory. */
+extern int target_search_memory (CORE_ADDR start_addr,
+ ULONGEST search_space_len,
+ const gdb_byte *pattern,
+ ULONGEST pattern_len,
+ CORE_ADDR *found_addrp);
+
+/* Command logging facility. */
+
+#define target_log_command(p) \
+ do \
+ if (current_target.to_log_command) \
+ (*current_target.to_log_command) (p); \
+ while (0)
+
/* Routines for maintenance of the target structures...
add_target: Add a target to the list of all possible targets.
extern void pop_target (void);
+/* Does whatever cleanup is required to get rid of all pushed targets.
+ QUITTING is propagated to target_close; it indicates that GDB is
+ exiting and should not get hung on an error (otherwise it is
+ important to perform clean termination, even if it takes a
+ while). */
+extern void pop_all_targets (int quitting);
+
+/* Like pop_all_targets, but pops only targets whose stratum is
+ strictly above ABOVE_STRATUM. */
+extern void pop_all_targets_above (enum strata above_stratum, int quitting);
+
extern CORE_ADDR target_translate_tls_address (struct objfile *objfile,
CORE_ADDR offset);
extern int memory_insert_breakpoint (struct bp_target_info *);
-extern int default_memory_remove_breakpoint (struct bp_target_info *);
+extern int default_memory_remove_breakpoint (struct gdbarch *, struct bp_target_info *);
-extern int default_memory_insert_breakpoint (struct bp_target_info *);
+extern int default_memory_insert_breakpoint (struct gdbarch *, struct bp_target_info *);
/* From target.c */
extern void initialize_targets (void);
-extern void noprocess (void);
+extern NORETURN void noprocess (void) ATTR_NORETURN;
+
+extern void target_require_runnable (void);
-extern void find_default_attach (char *, int);
+extern void find_default_attach (struct target_ops *, char *, int);
-extern void find_default_create_inferior (char *, char *, char **, int);
+extern void find_default_create_inferior (struct target_ops *,
+ char *, char *, char **, int);
extern struct target_ops *find_run_target (void);
extern void remove_target_sections (bfd *abfd);
+/* Read OS data object of type TYPE from the target, and return it in
+ XML format. The result is NUL-terminated and returned as a string,
+ allocated using xmalloc. If an error occurs or the transfer is
+ unsupported, NULL is returned. Empty objects are returned as
+ allocated but empty strings. */
+
+extern char *target_get_osdata (const char *type);
+
\f
/* Stuff that should be shared among the various remote targets. */
/* This is for native targets which use a unix/POSIX-style waitstatus. */
extern void store_waitstatus (struct target_waitstatus *, int);
-/* Predicate to target_signal_to_host(). Return non-zero if the enum
- targ_signal SIGNO has an equivalent ``host'' representation. */
-/* FIXME: cagney/1999-11-22: The name below was chosen in preference
- to the shorter target_signal_p() because it is far less ambigious.
- In this context ``target_signal'' refers to GDB's internal
- representation of the target's set of signals while ``host signal''
- refers to the target operating system's signal. Confused? */
-
-extern int target_signal_to_host_p (enum target_signal signo);
-
-/* Convert between host signal numbers and enum target_signal's.
- target_signal_to_host() returns 0 and prints a warning() on GDB's
- console if SIGNO has no equivalent host representation. */
-/* FIXME: cagney/1999-11-22: Here ``host'' is used incorrectly, it is
- refering to the target operating system's signal numbering.
- Similarly, ``enum target_signal'' is named incorrectly, ``enum
- gdb_signal'' would probably be better as it is refering to GDB's
- internal representation of a target operating system's signal. */
-
-extern enum target_signal target_signal_from_host (int);
-extern int target_signal_to_host (enum target_signal);
+/* These are in common/signals.c, but they're only used by gdb. */
+extern enum target_signal default_target_signal_from_host (struct gdbarch *,
+ int);
+extern int default_target_signal_to_host (struct gdbarch *,
+ enum target_signal);
/* Convert from a number used in a GDB command to an enum target_signal. */
extern enum target_signal target_signal_from_command (int);
+/* End of files in common/signals.c. */
+
+/* Set the show memory breakpoints mode to show, and installs a cleanup
+ to restore it back to the current value. */
+extern struct cleanup *make_show_memory_breakpoints_cleanup (int show);
-/* Any target can call this to switch to remote protocol (in remote.c). */
-extern void push_remote_target (char *name, int from_tty);
\f
/* Imported from machine dependent code */