it goes into the file stratum, which is always below the process
stratum. */
+#include "target/target.h"
#include "target/resume.h"
#include "target/wait.h"
#include "target/waitstatus.h"
command, and (if successful) pushes a new target onto the
stack. Targets should supply this routine, if only to provide
an error message. */
- void (*to_open) (char *, int);
+ void (*to_open) (const char *, int);
/* Old targets with a static target vector provide "to_close".
New re-entrant targets provide "to_xclose" and that is expected
to xfree everything (including the "struct target_ops"). */
TARGET_DEFAULT_IGNORE ();
void (*to_terminal_ours) (struct target_ops *)
TARGET_DEFAULT_IGNORE ();
- void (*to_terminal_save_ours) (struct target_ops *)
- TARGET_DEFAULT_IGNORE ();
void (*to_terminal_info) (struct target_ops *, const char *, int)
TARGET_DEFAULT_FUNC (default_terminal_info);
void (*to_kill) (struct target_ops *)
int (*to_thread_alive) (struct target_ops *, ptid_t ptid)
TARGET_DEFAULT_RETURN (0);
- void (*to_find_new_threads) (struct target_ops *)
+ void (*to_update_thread_list) (struct target_ops *)
TARGET_DEFAULT_IGNORE ();
char *(*to_pid_to_str) (struct target_ops *, ptid_t)
TARGET_DEFAULT_FUNC (default_pid_to_str);
extern int target_read_string (CORE_ADDR, char **, int, int *);
-extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
- ssize_t len);
+/* For target_read_memory see target/target.h. */
extern int target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
ssize_t len);
extern int target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len);
-extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
- ssize_t len);
+/* For target_write_memory see target/target.h. */
extern int target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
ssize_t len);
extern int target_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt);
+/* Returns true if the terminal settings of the inferior are in
+ effect. */
+
+extern int target_terminal_is_inferior (void);
+
/* Initialize the terminal settings we record for the inferior,
before we actually run the inferior. */
-#define target_terminal_init() \
- (*current_target.to_terminal_init) (¤t_target)
+extern void target_terminal_init (void);
/* Put the inferior's terminal settings into effect.
This is preparation for starting or resuming the inferior. */
extern void target_terminal_inferior (void);
-/* Put some of our terminal settings into effect,
- enough to get proper results from our output,
- but do not change into or out of RAW mode
- so that no input is discarded.
+/* Put some of our terminal settings into effect, enough to get proper
+ results from our output, but do not change into or out of RAW mode
+ so that no input is discarded. This is a no-op if terminal_ours
+ was most recently called. */
- After doing this, either terminal_ours or terminal_inferior
- should be called to get back to a normal state of affairs. */
-
-#define target_terminal_ours_for_output() \
- (*current_target.to_terminal_ours_for_output) (¤t_target)
+extern void target_terminal_ours_for_output (void);
/* Put our terminal settings into effect.
First record the inferior's terminal settings
so they can be restored properly later. */
-#define target_terminal_ours() \
- (*current_target.to_terminal_ours) (¤t_target)
+extern void target_terminal_ours (void);
/* Return true if the target stack has a non-default
"to_terminal_ours" method. */
extern int target_supports_terminal_ours (void);
-/* Save our terminal settings.
- This is called from TUI after entering or leaving the curses
- mode. Since curses modifies our terminal this call is here
- to take this change into account. */
-
-#define target_terminal_save_ours() \
- (*current_target.to_terminal_save_ours) (¤t_target)
-
/* Print useful information about our terminal status, if such a thing
exists. */
extern int target_thread_alive (ptid_t ptid);
-/* Query for new threads and add them to the thread list. */
+/* Sync the target's threads with GDB's thread list. */
-extern void target_find_new_threads (void);
+extern void target_update_thread_list (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. */
+ Unix, this should act like SIGSTOP). Note that this function is
+ asynchronous: it does not wait for the target to become stopped
+ before returning. If this is the behavior you want please use
+ target_stop_and_wait. */
extern void target_stop (ptid_t ptid);
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)
+ (*(target)->to_stopped_data_address) (target, addr_p)
/* Return non-zero if ADDR is within the range of a watchpoint spanning
LENGTH bytes beginning at START. */
#define target_watchpoint_addr_within_range(target, addr, start, length) \
- (*target.to_watchpoint_addr_within_range) (target, addr, start, length)
+ (*(target)->to_watchpoint_addr_within_range) (target, addr, start, length)
/* Return non-zero if the target is capable of using hardware to evaluate
the condition expression. In this case, if the condition is false when