2003-05-19 David Carlton <carlton@bactrian.org>

[deliverable/binutils-gdb.git] / gdb / target.h

diff --git a/gdb/target.h b/gdb/target.h
index afe1fc5d8abfaf09491158e96a37417dd25a75f2..cd822799ed6b84ce3660dd6d4e38b36e52798c74 100644 (file)
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -23,6 +23,10 @@
 #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
@@ -256,6 +260,7 @@ struct target_ops
     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);
@@ -295,8 +300,6 @@ struct target_ops
     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;
@@ -490,11 +493,11 @@ extern int child_xfer_memory (CORE_ADDR, char *, int, int,
    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);
 
@@ -549,11 +552,11 @@ extern void print_section_info (struct target_ops *, bfd *);
 #define        target_files_info()     \
      (*current_target.to_files_info) (&current_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)
@@ -780,11 +783,6 @@ extern void target_load (char *arg, int from_tty);
 #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.  */
@@ -838,15 +836,15 @@ extern void target_load (char *arg, int from_tty);
 #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,
@@ -970,6 +968,13 @@ extern void (*target_new_objfile_hook) (struct objfile *);
    (*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.  */
@@ -1108,8 +1113,8 @@ struct section_table
 /* 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 */
 
@@ -1121,9 +1126,6 @@ extern int default_memory_remove_breakpoint (CORE_ADDR, char *);
 
 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 */
 
@@ -1141,8 +1143,8 @@ extern struct target_ops *find_core_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);