#if !defined (TARGET_H)
#define TARGET_H
+struct objfile;
+struct ui_file;
+struct mem_attrib;
+
/* This include file defines the interface between the main part
of the debugger, and the part which is target-specific, or
specific to the communications interface between us and the
void (*to_close) (int);
void (*to_attach) (char *, int);
void (*to_post_attach) (int);
- void (*to_require_attach) (char *, int);
void (*to_detach) (char *, int);
- void (*to_require_detach) (int, char *, int);
+ void (*to_disconnect) (char *, int);
void (*to_resume) (ptid_t, int, enum target_signal);
ptid_t (*to_wait) (ptid_t, struct target_waitstatus *);
void (*to_post_wait) (ptid_t, int);
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_continuable_watchpoint;
CORE_ADDR (*to_stopped_data_address) (void);
int (*to_region_size_ok_for_hw_watchpoint) (int);
void (*to_terminal_init) (void);
struct exception_event_record *(*to_get_current_exception_event) (void);
char *(*to_pid_to_exec_file) (int pid);
enum strata to_stratum;
- struct target_ops
- *DONT_USE; /* formerly to_next */
int to_has_all_memory;
int to_has_memory;
int to_has_stack;
#define target_post_attach(pid) \
(*current_target.to_post_attach) (pid)
-/* Attaches to a process on the target side, if not already attached.
- (If already attached, takes no action.)
-
- This operation can be used to follow the child process of a fork.
- On some targets, such child processes of an original inferior process
- are automatically under debugger control, and thus do not require an
- actual attach operation. */
-
-#define target_require_attach(args, from_tty) \
- (*current_target.to_require_attach) (args, from_tty)
-
/* Takes a program previously attached to and detaches it.
The program may resume execution (some targets do, some don't) and will
no longer stop on signals, etc. We better not have left any breakpoints
extern void target_detach (char *, int);
-/* Detaches from a process on the target side, if not already dettached.
- (If already detached, takes no action.)
-
- This operation can be used to follow the parent process of a fork.
- On some targets, such child processes of an original inferior process
- are automatically under debugger control, and thus do require an actual
- detach operation.
+/* Disconnect from the current target without resuming it (leaving it
+ waiting for a debugger). */
- PID is the process id of the child to detach from.
- ARGS is arguments typed by the user (e.g. a signal to send the process).
- FROM_TTY says whether to be verbose or not. */
-
-#define target_require_detach(pid, args, from_tty) \
- (*current_target.to_require_detach) (pid, args, from_tty)
+extern void target_disconnect (char *, int);
/* Resume execution of the target process PTID. STEP says whether to
single-step or to run free; SIGGNAL is the signal to be given to
of bytes actually transfered is not defined) and ERR is set to a
non-zero error indication. */
-extern int
-target_read_memory_partial (CORE_ADDR addr, char *buf, int len, int *err);
+extern int target_read_memory_partial (CORE_ADDR addr, char *buf, int len,
+ int *err);
-extern int
-target_write_memory_partial (CORE_ADDR addr, char *buf, int len, int *err);
+extern int target_write_memory_partial (CORE_ADDR addr, char *buf, int len,
+ int *err);
extern char *child_pid_to_exec_file (int);
#define target_files_info() \
(*current_target.to_files_info) (¤t_target)
-/* Insert a breakpoint at address ADDR in the target machine.
- SAVE is a pointer to memory allocated for saving the
- target contents. It is guaranteed by the caller to be long enough
- to save "sizeof BREAKPOINT" bytes. Result is 0 for success, or
- an errno value. */
+/* Insert a breakpoint at address ADDR in the target machine. SAVE is
+ a pointer to memory allocated for saving the target contents. It
+ is guaranteed by the caller to be long enough to save the number of
+ breakpoint bytes indicated by BREAKPOINT_FROM_PC. Result is 0 for
+ success, or an errno value. */
#define target_insert_breakpoint(addr, save) \
(*current_target.to_insert_breakpoint) (addr, save)
#define target_get_current_exception_event() \
(*current_target.to_get_current_exception_event) ()
-/* Pointer to next target in the chain, e.g. a core file and an exec file. */
-
-#define target_next \
- (current_target.to_next)
-
/* 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. */
#define target_async(CALLBACK,CONTEXT) \
(current_target.to_async((CALLBACK), (CONTEXT)))
-/* This is to be used ONLY within run_stack_dummy(). It
- provides a workaround, to have inferior function calls done in
- sychronous mode, even though the target is asynchronous. After
+/* This is to be used ONLY within call_function_by_hand(). It provides
+ a workaround, to have inferior function calls done in sychronous
+ mode, even though the target is asynchronous. After
target_async_mask(0) is called, calls to target_can_async_p() will
return FALSE , so that target_resume() will not try to start the
target asynchronously. After the inferior stops, we IMMEDIATELY
restore the previous nature of the target, by calling
target_async_mask(1). After that, target_can_async_p() will return
- TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED.
+ TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED.
FIXME ezannoni 1999-12-13: we won't need this once we move
the turning async on and off to the single execution commands,
#define target_get_thread_local_address_p() \
(target_get_thread_local_address != NULL)
-/* Hook to call target-dependent code after reading in a new symbol table. */
-
-#ifndef TARGET_SYMFILE_POSTREAD
-#define TARGET_SYMFILE_POSTREAD(OBJFILE)
-#endif
-
/* Hook to call target dependent code just after inferior target process has
started. */
(*current_target.to_stopped_by_watchpoint) ()
#endif
+/* Non-zero if we have continuable watchpoints */
+
+#ifndef HAVE_CONTINUABLE_WATCHPOINT
+#define HAVE_CONTINUABLE_WATCHPOINT \
+ (current_target.to_have_continuable_watchpoint)
+#endif
+
/* HP-UX supplies these operations, which respectively disable and enable
the memory page-protections that are used to implement hardware watchpoints
on that platform. See wait_for_inferior's use of these. */
/* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
Returns 0 if OK, 1 on error. */
-extern int
-build_section_table (bfd *, struct section_table **, struct section_table **);
+extern int build_section_table (bfd *, struct section_table **,
+ struct section_table **);
/* From mem-break.c */
extern int default_memory_insert_breakpoint (CORE_ADDR, char *);
-extern const unsigned char *memory_breakpoint_from_pc (CORE_ADDR *pcptr,
- int *lenptr);
-
/* From target.c */
extern void find_default_attach (char *, int);
-extern void find_default_require_attach (char *, int);
-
-extern void find_default_require_detach (int, char *, int);
-
extern void find_default_create_inferior (char *, char *, char **);
extern struct target_ops *find_run_target (void);
extern struct target_ops *find_target_beneath (struct target_ops *);
-extern int
-target_resize_to_sections (struct target_ops *target, int num_added);
+extern int target_resize_to_sections (struct target_ops *target,
+ int num_added);
extern void remove_target_sections (bfd *abfd);
projects / deliverable / binutils-gdb.git / blobdiff