struct target_ops;
struct bp_target_info;
struct regcache;
+struct target_section_table;
/* 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
{
file_stratum, /* Executable files, etc */
core_stratum, /* Core dump files */
process_stratum, /* Executing processes */
- thread_stratum /* Executing threads */
+ thread_stratum, /* Executing threads */
+ record_stratum /* Support record debugging */
};
enum thread_control_capabilities
value;
};
+/* Options that can be passed to target_wait. */
+
+/* Return immediately if there's no event already queued. If this
+ options is not requested, target_wait blocks waiting for an
+ event. */
+#define TARGET_WNOHANG 1
+
/* 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 *);
'step n' like commands. */
INF_EXEC_CONTINUE
};
-
-/* Return the string for a signal. */
-extern const char *target_signal_to_string (enum target_signal);
-
-/* Return the name (SIGHUP, etc.) for a signal. */
-extern const char *target_signal_to_name (enum target_signal);
-
-/* Given a name (SIGHUP, etc.), return its signal. */
-enum target_signal target_signal_from_name (const char *);
\f
/* Target objects which can be transfered using target_read,
target_write, et cetera. */
TARGET_OBJECT_LIBRARIES,
/* Get OS specific data. The ANNEX specifies the type (running
processes, etc.). */
- TARGET_OBJECT_OSDATA
+ 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, ... */
};
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: */
void (*to_post_attach) (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);
+ 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 regcache *, int);
- void (*to_store_registers) (struct regcache *, int);
+ ptid_t, struct target_waitstatus *, int);
+ 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
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);
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) (struct target_ops *,
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);
+ 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) (ptid_t);
void (*to_rcmd) (char *command, struct ui_file *output);
char *(*to_pid_to_exec_file) (int pid);
void (*to_log_command) (const char *);
+ struct target_section_table *(*to_get_section_table) (struct target_ops *);
enum strata to_stratum;
- int to_has_all_memory;
- int to_has_memory;
- int to_has_stack;
- int to_has_registers;
- int to_has_execution;
+ int (*to_has_all_memory) (struct target_ops *);
+ int (*to_has_memory) (struct target_ops *);
+ int (*to_has_stack) (struct target_ops *);
+ int (*to_has_registers) (struct target_ops *);
+ int (*to_has_execution) (struct target_ops *);
int to_has_thread_control; /* control thread execution */
int to_attach_no_wait;
- struct section_table
- *to_sections;
- struct section_table
- *to_sections_end;
/* ASYNC target controls */
int (*to_can_async_p) (void);
int (*to_is_async_p) (void);
CORE_ADDR *found_addrp);
/* Can target execute in reverse? */
- int (*to_can_execute_reverse) ();
+ int (*to_can_execute_reverse) (void);
/* Does this target support debugging multiple processes
simultaneously? */
int (*to_supports_multi_process) (void);
+ /* Determine current architecture of thread PTID. */
+ struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t);
+
int to_magic;
/* Need sub-structure for target machine related rather than comm related?
*/
_NOT_ OK to throw_exception() out of target_wait() without popping
the debugging target from the stack; GDB isn't prepared to get back
to the prompt with a debugging target but without the frame cache,
- stop_pc, etc., set up. */
+ stop_pc, etc., set up. OPTIONS is a bitwise OR of TARGET_W*
+ options. */
-extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status);
+extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status,
+ int options);
/* Fetch at least register REGNO, or all regs if regno == -1. No result. */
-#define target_fetch_registers(regcache, regno) \
- (*current_target.to_fetch_registers) (regcache, 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(regcache, regs) \
- (*current_target.to_store_registers) (regcache, 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
extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
int len);
-extern int 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. */
extern int inferior_has_execd (ptid_t pid, char **execd_pathname);
-/* From exec.c */
-
-extern void print_section_info (struct target_ops *, bfd *);
-
/* 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. */
/* Put the inferior's terminal settings into effect.
This is preparation for starting or resuming the inferior. */
-#define target_terminal_inferior() \
- (*current_target.to_terminal_inferior) ()
+extern void target_terminal_inferior (void);
/* Put some of our terminal settings into effect,
enough to get proper results from our output,
/* 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
/* 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
determines whether we look up the target chain for other parts of
memory if this target can't satisfy a request. */
-#define target_has_all_memory \
- (current_target.to_has_all_memory)
+extern int target_has_all_memory_1 (void);
+#define target_has_all_memory target_has_all_memory_1 ()
/* Does the target include memory? (Dummy targets don't.) */
-#define target_has_memory \
- (current_target.to_has_memory)
+extern int target_has_memory_1 (void);
+#define target_has_memory target_has_memory_1 ()
/* Does the target have a stack? (Exec files don't, VxWorks doesn't, until
we start a process.) */
-#define target_has_stack \
- (current_target.to_has_stack)
+extern int target_has_stack_1 (void);
+#define target_has_stack target_has_stack_1 ()
/* Does the target have registers? (Exec files don't.) */
-#define target_has_registers \
- (current_target.to_has_registers)
+extern int target_has_registers_1 (void);
+#define target_has_registers target_has_registers_1 ()
/* Does the target have execution? Can we make it jump (through
hoops), or pop its stack a few times? This means that the current
case this will become true after target_create_inferior or
target_attach. */
-#define target_has_execution \
- (current_target.to_has_execution)
+extern int target_has_execution_1 (void);
+#define target_has_execution target_has_execution_1 ()
+
+/* Default implementations for process_stratum targets. Return true
+ if there's a selected inferior, false otherwise. */
+
+extern int default_child_has_all_memory (struct target_ops *ops);
+extern int default_child_has_memory (struct target_ops *ops);
+extern int default_child_has_stack (struct target_ops *ops);
+extern int default_child_has_registers (struct target_ops *ops);
+extern int default_child_has_execution (struct target_ops *ops);
/* Can the target support the debugger control of thread execution?
Can it lock the thread scheduler? */
#define target_pid_to_exec_file(pid) \
(current_target.to_pid_to_exec_file) (pid)
+/* Determine current architecture of thread PTID. */
+
+#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'
/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
write). */
-#ifndef STOPPED_BY_WATCHPOINT
-#define STOPPED_BY_WATCHPOINT(w) \
- (*current_target.to_stopped_by_watchpoint) ()
-#endif
+#define target_stopped_by_watchpoint \
+ (*current_target.to_stopped_by_watchpoint)
/* Non-zero if we have steppable watchpoints */
-#ifndef HAVE_STEPPABLE_WATCHPOINT
-#define HAVE_STEPPABLE_WATCHPOINT \
+#define target_have_steppable_watchpoint \
(current_target.to_have_steppable_watchpoint)
-#endif
/* Non-zero if we have continuable watchpoints */
-#ifndef HAVE_CONTINUABLE_WATCHPOINT
-#define HAVE_CONTINUABLE_WATCHPOINT \
+#define target_have_continuable_watchpoint \
(current_target.to_have_continuable_watchpoint)
-#endif
/* Provide defaults for hardware watchpoint functions. */
bp_hardware_breakpoint. CNT is the number of such watchpoints used so far
(including this one?). OTHERTYPE is who knows what... */
-#ifndef TARGET_CAN_USE_HARDWARE_WATCHPOINT
-#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(TYPE,CNT,OTHERTYPE) \
+#define target_can_use_hardware_watchpoint(TYPE,CNT,OTHERTYPE) \
(*current_target.to_can_use_hw_breakpoint) (TYPE, CNT, OTHERTYPE);
-#endif
-#ifndef TARGET_REGION_OK_FOR_HW_WATCHPOINT
-#define TARGET_REGION_OK_FOR_HW_WATCHPOINT(addr, len) \
+#define target_region_ok_for_hw_watchpoint(addr, len) \
(*current_target.to_region_ok_for_hw_watchpoint) (addr, len)
-#endif
/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes. TYPE is 0
for write, 1 for read, and 2 for read/write accesses. Returns 0 for
success, non-zero for failure. */
-#ifndef target_insert_watchpoint
#define target_insert_watchpoint(addr, len, type) \
(*current_target.to_insert_watchpoint) (addr, len, type)
#define target_remove_watchpoint(addr, len, type) \
(*current_target.to_remove_watchpoint) (addr, len, type)
-#endif
-#ifndef target_insert_hw_breakpoint
-#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)
-#endif
+#define target_remove_hw_breakpoint(gdbarch, bp_tgt) \
+ (*current_target.to_remove_hw_breakpoint) (gdbarch, bp_tgt)
-#ifndef target_stopped_data_address
#define target_stopped_data_address(target, x) \
(*target.to_stopped_data_address) (target, x)
-#endif
#define target_watchpoint_addr_within_range(target, addr, start, length) \
(*target.to_watchpoint_addr_within_range) (target, addr, start, length)
extern CORE_ADDR target_translate_tls_address (struct objfile *objfile,
CORE_ADDR offset);
-/* Mark a pushed target as running or exited, for targets which do not
- automatically pop when not active. */
-
-void target_mark_running (struct target_ops *);
-
-void target_mark_exited (struct target_ops *);
-
-/* Struct section_table maps address ranges to file sections. It is
+/* Struct target_section maps address ranges to file sections. It is
mostly used with BFD files, but can be used without (e.g. for handling
raw disks, or files not in formats handled by BFD). */
-struct section_table
+struct target_section
{
CORE_ADDR addr; /* Lowest address in section */
CORE_ADDR endaddr; /* 1+highest address in section */
bfd *bfd; /* BFD file pointer */
};
+/* Holds an array of target sections. Defined by [SECTIONS..SECTIONS_END[. */
+
+struct target_section_table
+{
+ struct target_section *sections;
+ struct target_section *sections_end;
+};
+
/* Return the "section" containing the specified address. */
-struct section_table *target_section_by_addr (struct target_ops *target,
- CORE_ADDR addr);
+struct target_section *target_section_by_addr (struct target_ops *target,
+ CORE_ADDR addr);
+
+/* Return the target section table this target (or the targets
+ beneath) currently manipulate. */
+extern struct target_section_table *target_get_section_table
+ (struct target_ops *target);
/* 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 *);
extern struct target_ops *find_target_beneath (struct target_ops *);
-extern int target_resize_to_sections (struct target_ops *target,
- int num_added);
-
-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
/* 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 *,
/* 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. */
projects / deliverable / binutils-gdb.git / blobdiff