#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. */
extern void get_target_memory (struct target_ops *ops, CORE_ADDR addr,
gdb_byte *buf, LONGEST len);
extern ULONGEST get_target_memory_unsigned (struct target_ops *ops,
- CORE_ADDR addr, int len);
+ CORE_ADDR addr, int len,
+ enum bfd_endian byte_order);
\f
struct thread_info; /* fwd decl for parameter list below: */
struct target_ops *target);
void (*to_files_info) (struct target_ops *);
- int (*to_insert_breakpoint) (struct bp_target_info *);
- int (*to_remove_breakpoint) (struct bp_target_info *);
+ int (*to_insert_breakpoint) (struct gdbarch *, struct bp_target_info *);
+ int (*to_remove_breakpoint) (struct gdbarch *, struct bp_target_info *);
int (*to_can_use_hw_breakpoint) (int, int, int);
- int (*to_insert_hw_breakpoint) (struct bp_target_info *);
- int (*to_remove_hw_breakpoint) (struct bp_target_info *);
+ int (*to_insert_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
+ int (*to_remove_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
int (*to_remove_watchpoint) (CORE_ADDR, int, int);
int (*to_insert_watchpoint) (CORE_ADDR, int, int);
int (*to_stopped_by_watchpoint) (void);
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
simultaneously? */
int (*to_supports_multi_process) (void);
+ /* Determine current architecture of thread PTID.
+
+ The target is supposed to determine the architecture of the code where
+ the target is currently stopped at (on Cell, if a target is in spu_run,
+ to_thread_architecture would return SPU, otherwise PPC32 or PPC64).
+ This is architecture used to perform decr_pc_after_break adjustment,
+ and also determines the frame architecture of the innermost frame.
+ ptrace operations need to operate according to target_gdbarch.
+
+ 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);
+
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() \
/* Insert a breakpoint at address BP_TGT->placed_address in the target
machine. Result is 0 for success, or an errno value. */
-#define target_insert_breakpoint(bp_tgt) \
- (*current_target.to_insert_breakpoint) (bp_tgt)
+#define target_insert_breakpoint(gdbarch, bp_tgt) \
+ (*current_target.to_insert_breakpoint) (gdbarch, bp_tgt)
/* Remove a breakpoint at address BP_TGT->placed_address in the target
machine. Result is 0 for success, or an errno value. */
-#define target_remove_breakpoint(bp_tgt) \
- (*current_target.to_remove_breakpoint) (bp_tgt)
+#define target_remove_breakpoint(gdbarch, bp_tgt) \
+ (*current_target.to_remove_breakpoint) (gdbarch, bp_tgt)
/* Initialize the terminal settings we record for the inferior,
before we actually run the inferior. */
#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_pid_to_exec_file(pid) \
(current_target.to_pid_to_exec_file) (pid)
+/* See the to_thread_architecture description in struct target_ops. */
+
+#define target_thread_architecture(ptid) \
+ (current_target.to_thread_architecture (¤t_target, ptid))
+
/*
* Iterator function for target memory regions.
* Calls a callback function once for each memory region 'mapped'
#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_watchpoint(addr, len, type) \
(*current_target.to_remove_watchpoint) (addr, len, type)
-#define target_insert_hw_breakpoint(bp_tgt) \
- (*current_target.to_insert_hw_breakpoint) (bp_tgt)
+#define target_insert_hw_breakpoint(gdbarch, bp_tgt) \
+ (*current_target.to_insert_hw_breakpoint) (gdbarch, bp_tgt)
-#define target_remove_hw_breakpoint(bp_tgt) \
- (*current_target.to_remove_hw_breakpoint) (bp_tgt)
+#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)
/* From mem-break.c */
-extern int memory_remove_breakpoint (struct bp_target_info *);
+extern int memory_remove_breakpoint (struct gdbarch *, struct bp_target_info *);
-extern int memory_insert_breakpoint (struct bp_target_info *);
+extern int memory_insert_breakpoint (struct gdbarch *, struct bp_target_info *);
extern int default_memory_remove_breakpoint (struct gdbarch *, struct bp_target_info *);