/* 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, 2008, 2009
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by John Gilmore.
struct bp_target_info;
struct regcache;
struct target_section_table;
+struct trace_state_variable;
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
#include "bfd.h"
#include "symtab.h"
-#include "dcache.h"
#include "memattr.h"
#include "vec.h"
#include "gdb_signals.h"
core_stratum, /* Core dump files */
process_stratum, /* Executing processes */
thread_stratum, /* Executing threads */
- record_stratum /* Support record debugging */
+ record_stratum, /* Support record debugging */
+ arch_stratum /* Architecture overrides */
};
enum thread_control_capabilities
TARGET_WAITKIND_EXECD,
+ /* The program had previously vforked, and now the child is done
+ with the shared memory region, because it exec'ed or exited.
+ Note that the event is reported to the vfork parent. This is
+ only used if GDB did not stay attached to the vfork child,
+ otherwise, a TARGET_WAITKIND_EXECD or
+ TARGET_WAITKIND_EXIT|SIGNALLED event associated with the child
+ has the same effect. */
+ TARGET_WAITKIND_VFORK_DONE,
+
/* The program has entered or returned from a system call. On
HP-UX, this is used in the hardware watchpoint implementation.
The syscall's unique integer ID number is in value.syscall_id */
{
enum target_waitkind kind;
- /* Forked child pid, execd pathname, exit status or signal number. */
+ /* Forked child pid, execd pathname, exit status, signal number or
+ syscall number. */
union
{
int integer;
enum target_signal sig;
ptid_t related_pid;
char *execd_pathname;
- int syscall_id;
+ int syscall_number;
}
value;
};
event. */
#define TARGET_WNOHANG 1
+/* The structure below stores information about a system call.
+ It is basically used in the "catch syscall" command, and in
+ every function that gives information about a system call.
+
+ It's also good to mention that its fields represent everything
+ that we currently know about a syscall in GDB. */
+struct syscall
+ {
+ /* The syscall number. */
+ int number;
+
+ /* The syscall name. */
+ const char *name;
+ };
+
/* 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 *);
Target implementations of to_xfer_partial never need to handle
this object, and most callers should not use it. */
TARGET_OBJECT_RAW_MEMORY,
+ /* Memory known to be part of the target's stack. This is cached even
+ if it is not in a region marked as such, since it is known to be
+ "normal" RAM. */
+ TARGET_OBJECT_STACK_MEMORY,
/* Kernel Unwind Table. See "ia64-tdep.c". */
TARGET_OBJECT_UNWIND_TABLE,
/* Transfer auxilliary vector. */
/* Possible future objects: TARGET_OBJECT_FILE, ... */
};
+/* Enumeration of the kinds of traceframe searches that a target may
+ be able to perform. */
+
+enum trace_find_type
+ {
+ tfind_number,
+ tfind_pc,
+ tfind_tp,
+ tfind_range,
+ tfind_outside,
+ };
+
/* Request that OPS transfer up to LEN 8-bit bytes of the target's
OBJECT. The OFFSET, for a seekable object, specifies the
starting point. The ANNEX can be used to provide additional
int (*to_follow_fork) (struct target_ops *, int);
void (*to_insert_exec_catchpoint) (int);
int (*to_remove_exec_catchpoint) (int);
+ int (*to_set_syscall_catchpoint) (int, int, int, int, int *);
int (*to_has_exited) (int, int, int *);
void (*to_mourn_inferior) (struct target_ops *);
int (*to_can_run) (void);
void (*to_async) (void (*) (enum inferior_event_type, void *), void *);
int (*to_async_mask) (int);
int (*to_supports_non_stop) (void);
+ /* find_memory_regions support method for gcore */
int (*to_find_memory_regions) (int (*) (CORE_ADDR,
unsigned long,
int, int, int,
void *),
void *);
+ /* make_corefile_notes support method for gcore */
char * (*to_make_corefile_notes) (bfd *, int *);
-
+ /* get_bookmark support method for bookmarks */
+ gdb_byte * (*to_get_bookmark) (char *, int);
+ /* goto_bookmark support method for bookmarks */
+ void (*to_goto_bookmark) (gdb_byte *, int);
/* Return the thread-local address at OFFSET in the
thread-local storage for the thread PTID and the shared library
or executable file given by OBJFILE. If that block of
The default implementation always returns target_gdbarch. */
struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t);
+ /* Determine current address space of thread PTID.
+
+ The default implementation always returns the inferior's
+ address space. */
+ struct address_space *(*to_thread_address_space) (struct target_ops *,
+ ptid_t);
+
+ /* Tracepoint-related operations. */
+
+ /* Prepare the target for a tracing run. */
+ void (*to_trace_init) (void);
+
+ /* Send full details of a tracepoint to the target. */
+ void (*to_download_tracepoint) (struct breakpoint *t);
+
+ /* Send full details of a trace state variable to the target. */
+ void (*to_download_trace_state_variable) (struct trace_state_variable *tsv);
+
+ /* Inform the target info of memory regions that are readonly
+ (such as text sections), and so it should return data from
+ those rather than look in the trace buffer. */
+ void (*to_trace_set_readonly_regions) (void);
+
+ /* Start a trace run. */
+ void (*to_trace_start) (void);
+
+ /* Get the current status of a tracing run. */
+ int (*to_get_trace_status) (int *stop_reason);
+
+ /* Stop a trace run. */
+ void (*to_trace_stop) (void);
+
+ /* Ask the target to find a trace frame of the given type TYPE,
+ using NUM, ADDR1, and ADDR2 as search parameters. Returns the
+ number of the trace frame, and also the tracepoint number at
+ TPP. */
+ int (*to_trace_find) (enum trace_find_type type, int num,
+ ULONGEST addr1, ULONGEST addr2, int *tpp);
+
+ /* Get the value of the trace state variable number TSV, returning
+ 1 if the value is known and writing the value itself into the
+ location pointed to by VAL, else returning 0. */
+ int (*to_get_trace_state_variable_value) (int tsv, LONGEST *val);
+
+ /* Set the target's tracing behavior in response to unexpected
+ disconnection - set VAL to 1 to keep tracing, 0 to stop. */
+ void (*to_set_disconnected_tracing) (int val);
+
int to_magic;
/* Need sub-structure for target machine related rather than comm related?
*/
#define target_prepare_to_store(regcache) \
(*current_target.to_prepare_to_store) (regcache)
+/* Determine current address space of thread PTID. */
+
+struct address_space *target_thread_address_space (ptid_t);
+
/* 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;
+/* Invalidate all target dcaches. */
+extern void target_dcache_invalidate (void);
extern int target_read_string (CORE_ADDR, char **, int, int *);
extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
+extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
+
extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
int len);
extern int inferior_has_execd (ptid_t pid, char **execd_pathname);
+extern int inferior_has_called_syscall (ptid_t pid, int *syscall_number);
+
/* Print a line about the current target. */
#define target_files_info() \
#define target_remove_exec_catchpoint(pid) \
(*current_target.to_remove_exec_catchpoint) (pid)
+/* Syscall catch.
+
+ NEEDED is nonzero if any syscall catch (of any kind) is requested.
+ If NEEDED is zero, it means the target can disable the mechanism to
+ catch system calls because there are no more catchpoints of this type.
+
+ ANY_COUNT is nonzero if a generic (filter-less) syscall catch is
+ being requested. In this case, both TABLE_SIZE and TABLE should
+ be ignored.
+
+ TABLE_SIZE is the number of elements in TABLE. It only matters if
+ ANY_COUNT is zero.
+
+ TABLE is an array of ints, indexed by syscall number. An element in
+ this array is nonzero if that syscall should be caught. This argument
+ only matters if ANY_COUNT is zero. */
+
+#define target_set_syscall_catchpoint(pid, needed, any_count, table_size, table) \
+ (*current_target.to_set_syscall_catchpoint) (pid, needed, any_count, \
+ table_size, table)
+
/* Returns TRUE if PID has exited. And, also sets EXIT_STATUS to the
exit code of PID, if any. */
#define target_make_corefile_notes(BFD, SIZE_P) \
(current_target.to_make_corefile_notes) (BFD, SIZE_P)
+/* Bookmark interfaces. */
+#define target_get_bookmark(ARGS, FROM_TTY) \
+ (current_target.to_get_bookmark) (ARGS, FROM_TTY)
+
+#define target_goto_bookmark(ARG, FROM_TTY) \
+ (current_target.to_goto_bookmark) (ARG, FROM_TTY)
+
/* Hardware watchpoint interfaces. */
/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
- write). */
+ write). Only the INFERIOR_PTID task is being queried. */
#define target_stopped_by_watchpoint \
(*current_target.to_stopped_by_watchpoint)
#define target_remove_hw_breakpoint(gdbarch, bp_tgt) \
(*current_target.to_remove_hw_breakpoint) (gdbarch, bp_tgt)
-#define target_stopped_data_address(target, x) \
- (*target.to_stopped_data_address) (target, x)
+/* Return non-zero if target knows the data address which triggered this
+ target_stopped_by_watchpoint, in such case place it to *ADDR_P. Only the
+ INFERIOR_PTID task is being queried. */
+#define target_stopped_data_address(target, addr_p) \
+ (*target.to_stopped_data_address) (target, addr_p)
#define target_watchpoint_addr_within_range(target, addr, start, length) \
(*target.to_watchpoint_addr_within_range) (target, addr, start, length)
ULONGEST pattern_len,
CORE_ADDR *found_addrp);
+/* Tracepoint-related operations. */
+
+#define target_trace_init() \
+ (*current_target.to_trace_init) ()
+
+#define target_download_tracepoint(t) \
+ (*current_target.to_download_tracepoint) (t)
+
+#define target_download_trace_state_variable(tsv) \
+ (*current_target.to_download_trace_state_variable) (tsv)
+
+#define target_trace_start() \
+ (*current_target.to_trace_start) ()
+
+#define target_trace_set_readonly_regions() \
+ (*current_target.to_trace_set_readonly_regions) ()
+
+#define target_get_trace_status(stop_reason) \
+ (*current_target.to_get_trace_status) (stop_reason)
+
+#define target_trace_stop() \
+ (*current_target.to_trace_stop) ()
+
+#define target_trace_find(type,num,addr1,addr2,tpp) \
+ (*current_target.to_trace_find) ((type), (num), (addr1), (addr2), (tpp))
+
+#define target_get_trace_state_variable_value(tsv,val) \
+ (*current_target.to_get_trace_state_variable_value) ((tsv), (val))
+
+#define target_set_disconnected_tracing(val) \
+ (*current_target.to_set_disconnected_tracing) (val)
+
/* Command logging facility. */
#define target_log_command(p) \