* breakpoint.c, target.h: Move defaults of watchpoint related

	macros back to breakpoint.c.  Required to get GDB compiling
	on Solaris again.

3 files changed, 195 insertions, 109 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ad8360e..cdb7422 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,22 @@
+Mon May 22 06:47:30 1995  Jim Kingdon  (kingdon@lioth.cygnus.com)
+
+	* breakpoint.c, target.h: Move defaults of watchpoint related
+	macros back to breakpoint.c.  Required to get GDB compiling
+	on Solaris again.
+
+Fri May 19 14:49:37 1995  J.T. Conklin  <jtc@rtl.cygnus.com>
+
+	* defs.h (ATTR_FORMAT): New macro, expands to gcc's format
+	  attribute when compiled by gcc.  
+	* defs.h, language.h, monitor.h: Changed many function
+	  declarations to use ATTR_FORMAT.
+
+	* breakpoint.c (delete_command); source.c (directory_command);
+	  top.c (define_command): Changed call to query() that had too
+	  many arguments.
+	* printcmd.c (address_info): Changed call to printf_filtered()
+	  that had too many arguments.
+
 Fri May 19 09:52:07 1995  Jim Kingdon  (kingdon@lioth.cygnus.com)
 
 	* infrun.c (wait_for_inferior): Move assignments to stop_signal
@@ -24,7 +43,7 @@ Thu May 18 15:58:46 1995  J.T. Conklin  <jtc@rtl.cygnus.com>
 	  printf_filtered, printf_unfiltered, printfi_filtered, query, warning,
 	  error, fatal, fatal_dump_core): Use stdarg.h macros when compiling 
 	  with an ANSI compiler.
-	* complain.c (complain): Likewise.
+	* complaints.c (complain): Likewise.
 	* language.c (type_error, range_error): Likewise.
 	* monitor.c (monitor_printf, monitor_printf_noecho): Likewise.
 	* remote-array.c (printf_monitor, debuglogs): Likewise.
@@ -35,7 +54,7 @@ start-sanitize-gdbtk
         * gdbtk.c (gdbtk_query): Likewise.
 end-sanitize-gdbtk
 
-	* defs.h, complain.h, language.h, monitor.h: Add prototypes to
+	* defs.h, complaints.h, language.h, monitor.h: Add prototypes to
 	  match above changes.
 
 	* printcmd.c: Remove uneeded #include <varargs.h>.
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 629a53b..94e1dd5 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -1,5 +1,5 @@
 /* Everything about breakpoints, for GDB.
-   Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994
+   Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995
              Free Software Foundation, Inc.
 
 This file is part of GDB.
@@ -59,15 +59,9 @@ static void
 disable_command PARAMS ((char *, int));
 
 static void
-disable_breakpoint PARAMS ((struct breakpoint *));
-
-static void
 enable_command PARAMS ((char *, int));
 
 static void
-enable_breakpoint PARAMS ((struct breakpoint *));
-
-static void
 map_breakpoint_numbers PARAMS ((char *,	void (*)(struct breakpoint *)));
 
 static void
@@ -158,9 +152,21 @@ static int executing_breakpoint_commands;
 	     b? (tmp=b->next, 1): 0;	\
 	     b = tmp)
 
-/* By default no support for hardware watchpoints is assumed.  */
+/* Provide defaults for systems that don't support hardware watchpoints. */
+
 #ifndef TARGET_CAN_USE_HARDWARE_WATCHPOINT
+
+/* Returns non-zero if we can set a hardware watchpoint of type TYPE.  TYPE is
+   one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, or
+   bp_hardware_breakpoint.  CNT is the number of such watchpoints used so far
+   (including this one?).  OTHERTYPE is who knows what...  */
+
 #define TARGET_CAN_USE_HARDWARE_WATCHPOINT(TYPE,CNT,OTHERTYPE) 0
+
+/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes.  TYPE is 1
+   for read and 2 for read/write accesses.  Returns 0 for success, non-zero for
+   failure.  */
+
 #define target_remove_watchpoint(ADDR,LEN,TYPE) -1
 #define target_insert_watchpoint(ADDR,LEN,TYPE) -1
 #endif
@@ -180,7 +186,7 @@ int show_breakpoint_hit_counts = 1;
 
 /* Chain of all breakpoints defined.  */
 
-static struct breakpoint *breakpoint_chain;
+struct breakpoint *breakpoint_chain;
 
 /* Number of last breakpoint made.  */
 
@@ -935,6 +941,7 @@ bpstat_do_actions (bsp)
 {
   bpstat bs;
   struct cleanup *old_chain;
+  struct command_line *cmd;
 
   executing_breakpoint_commands = 1;
   old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
@@ -945,18 +952,20 @@ top:
   breakpoint_proceeded = 0;
   for (; bs != NULL; bs = bs->next)
     {
-      while (bs->commands)
+      cmd = bs->commands;
+      while (cmd != NULL)
 	{
-	  struct command_line *cmd = bs->commands;
-	  bs->commands = bs->commands->next;
 	  execute_control_command (cmd);
-	  /* If the inferior is proceeded by the command, bomb out now.
-	     The bpstat chain has been blown away by wait_for_inferior.
-	     But since execution has stopped again, there is a new bpstat
-	     to look at, so start over.  */
-	  if (breakpoint_proceeded)
-	    goto top;
+	  cmd = cmd->next;
 	}
+      if (breakpoint_proceeded)
+	/* The inferior is proceeded by the command; bomb out now.
+	   The bpstat chain has been blown away by wait_for_inferior.
+	   But since execution has stopped again, there is a new bpstat
+	   to look at, so start over.  */
+	goto top;
+      else
+	bs->commands = NULL;
     }
 
   executing_breakpoint_commands = 0;
@@ -1094,6 +1103,9 @@ bpstat_alloc (b, cbs)
 /* The value has not changed.  */
 #define WP_VALUE_NOT_CHANGED 3
 
+#define BP_TEMPFLAG 1
+#define BP_HARDWAREFLAG 2
+
 /* Check watchpoint condition.  */
 
 static int
@@ -1223,7 +1235,7 @@ bpstat_stop_status (pc, not_a_breakpoint)
   int real_breakpoint = 0;
 #endif
   /* Root of the chain of bpstat's */
-  struct bpstat root_bs[1];
+  struct bpstats root_bs[1];
   /* Pointer to the last thing in the chain currently.  */
   bpstat bs = root_bs;
   static char message1[] =
@@ -1246,9 +1258,14 @@ bpstat_stop_status (pc, not_a_breakpoint)
 	  && b->address != bp_addr)
 	continue;
 
+/* If defined, then we need to decr pc by this much after a hardware break-
+   point.  Presumably should override DECR_PC_AFTER_BREAK, though it doesn't
+   now...  */
+
 #ifndef DECR_PC_AFTER_HW_BREAK
 #define DECR_PC_AFTER_HW_BREAK 0
 #endif
+
       if (b->type == bp_hardware_breakpoint
 	  && b->address != (bp_addr - DECR_PC_AFTER_HW_BREAK))
 	continue;
@@ -1983,7 +2000,7 @@ create_longjmp_breakpoint(func_name)
     {
       struct minimal_symbol *m;
 
-      m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
+      m = lookup_minimal_symbol_text (func_name, NULL, (struct objfile *)NULL);
       if (m)
 	sal.pc = SYMBOL_VALUE_ADDRESS (m);
       else
@@ -2270,8 +2287,8 @@ break_command_1 (arg, flag, from_tty)
   int i;
   int thread;
 
-  hardwareflag = flag & 2;
-  tempflag = flag & 1;
+  hardwareflag = flag & BP_HARDWAREFLAG;
+  tempflag = flag & BP_TEMPFLAG;
 
   sals.sals = NULL;
   sals.nelts = 0;
@@ -2422,7 +2439,7 @@ break_command_1 (arg, flag, from_tty)
 	b->cond_string = savestring (cond_start, cond_end - cond_start);
 				     
       b->enable = enabled;
-      b->disposition = tempflag ? delete : donttouch;
+      b->disposition = tempflag ? del : donttouch;
 
       mention (b);
     }
@@ -2453,8 +2470,6 @@ resolve_sal_pc (sal)
     }
 }
 
-#define BP_TEMPFLAG 1
-#define BP_HARDWAREFLAG 2
 void
 break_command (arg, from_tty)
      char *arg;
@@ -2615,7 +2630,7 @@ watch_command_1 (arg, accessflag, from_tty)
 	  scope_breakpoint->enable = enabled;
 
 	  /* Automatically delete the breakpoint when it hits.  */
-	  scope_breakpoint->disposition = delete;
+	  scope_breakpoint->disposition = del;
 
 	  /* Only break in the proper frame (help with recursion).  */
 	  scope_breakpoint->frame = prev_frame->frame;
@@ -3019,7 +3034,7 @@ catch_command_1 (arg, tempflag, from_tty)
       b->type = bp_breakpoint;
       b->cond = cond;
       b->enable = enabled;
-      b->disposition = tempflag ? delete : donttouch;
+      b->disposition = tempflag ? del : donttouch;
 
       mention (b);
     }
@@ -3032,6 +3047,22 @@ catch_command_1 (arg, tempflag, from_tty)
   free ((PTR)sals.sals);
 }
 
+/* Used by the gui, could be made a worker for other things. */
+
+struct breakpoint *
+set_breakpoint_sal (sal)
+struct symtab_and_line sal;
+{
+  struct breakpoint *b;
+  b = set_raw_breakpoint (sal);
+  set_breakpoint_count (breakpoint_count + 1);
+  b->number = breakpoint_count;
+  b->type = bp_breakpoint;
+  b->cond = 0;
+  b->thread = -1;
+  return b;
+}
+
 #if 0
 /* These aren't used; I don't know what they were for.  */
 /* Disable breakpoints on all catch clauses described in ARGS.  */
@@ -3166,7 +3197,7 @@ breakpoint_auto_delete (bs)
      bpstat bs;
 {
   for (; bs; bs = bs->next)
-    if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete
+    if (bs->breakpoint_at && bs->breakpoint_at->disposition == del 
 	&& bs->stop)
       delete_breakpoint (bs->breakpoint_at);
 }
@@ -3253,7 +3284,7 @@ delete_command (arg, from_tty)
     {
       /* Ask user only if there are some breakpoints to delete.  */
       if (!from_tty
-	  || (breakpoint_chain && query ("Delete all breakpoints? ", 0, 0)))
+	  || (breakpoint_chain && query ("Delete all breakpoints? ")))
 	{
 	  /* No arg; clear all breakpoints.  */
 	  while (breakpoint_chain)
@@ -3538,7 +3569,7 @@ map_breakpoint_numbers (args, function)
     }
 }
 
-static void
+void
 enable_breakpoint (bpt)
      struct breakpoint *bpt;
 {
@@ -3547,9 +3578,6 @@ enable_breakpoint (bpt)
   int target_resources_ok, other_type_used;
   struct value *mark;
   
-  if (enable_breakpoint_hook)
-    enable_breakpoint_hook (bpt);
-
   if (bpt->type == bp_hardware_breakpoint)
     {
       int i;
@@ -3618,6 +3646,9 @@ have been allocated for other watchpoints.\n", bpt->number);
 	select_frame (save_selected_frame, save_selected_frame_level);
       value_free_to_mark (mark);
     }
+
+  if (modify_breakpoint_hook)
+    modify_breakpoint_hook (bpt);
 }
 
 /* ARGSUSED */
@@ -3645,7 +3676,7 @@ enable_command (args, from_tty)
     map_breakpoint_numbers (args, enable_breakpoint);
 }
 
-static void
+void
 disable_breakpoint (bpt)
      struct breakpoint *bpt;
 {
@@ -3655,12 +3686,12 @@ disable_breakpoint (bpt)
   if (bpt->type == bp_watchpoint_scope)
     return;
 
-  if (disable_breakpoint_hook)
-    disable_breakpoint_hook (bpt);
-
   bpt->enable = disabled;
 
   check_duplicates (bpt->address);
+
+  if (modify_breakpoint_hook)
+    modify_breakpoint_hook (bpt);
 }
 
 /* ARGSUSED */
@@ -3782,7 +3813,7 @@ enable_delete_breakpoint (bpt)
      struct breakpoint *bpt;
 {
   bpt->enable = enabled;
-  bpt->disposition = delete;
+  bpt->disposition = del;
 
   check_duplicates (bpt->address);
   breakpoints_changed ();
@@ -4026,39 +4057,3 @@ an expression is either read or written.");
 	    "Synonym for ``info breakpoints''.");
 
 }
-
-/* OK, when we call objfile_relocate, we need to relocate breakpoints
-   too.  breakpoint_re_set is not a good choice--for example, if
-   addr_string contains just a line number without a file name the
-   breakpoint might get set in a different file.  In general, there is
-   no need to go all the way back to the user's string (though this might
-   work if some effort were made to canonicalize it), since symtabs and
-   everything except addresses are still valid.
-
-   Probably the best way to solve this is to have each breakpoint save
-   the objfile and the section number that was used to set it (if set
-   by "*addr", probably it is best to use find_pc_line to get a symtab
-   and use the objfile and block_line_section for that symtab).  Then
-   objfile_relocate can call fixup_breakpoints with the objfile and
-   the new_offsets, and it can relocate only the appropriate breakpoints.  */
-
-#ifdef IBM6000_TARGET
-/* But for now, just kludge it based on the concept that before an
-   objfile is relocated the breakpoint is below 0x10000000, and afterwards
-   it is higher, so that way we only relocate each breakpoint once.  */
-
-void
-fixup_breakpoints (low, high, delta)
-  CORE_ADDR low;
-  CORE_ADDR high;
-  CORE_ADDR delta;
-{
-  struct breakpoint *b;
-
-  ALL_BREAKPOINTS (b)
-    {
-     if (b->address >= low && b->address <= high)
-       b->address += delta;
-    }
-}
-#endif
diff --git a/gdb/target.h b/gdb/target.h
index 42c3575..4ef430e 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -46,6 +46,7 @@ enum strata {
 	dummy_stratum,		/* The lowest of the low */
 	file_stratum,		/* Executable files, etc */
 	core_stratum,		/* Core dump files */
+	download_stratum,	/* Downloading of remote targets */
 	process_stratum		/* Executing processes */
 };
 
@@ -144,6 +145,38 @@ enum target_signal {
   TARGET_SIGNAL_MSG = 41,
   TARGET_SIGNAL_SOUND = 42,
   TARGET_SIGNAL_SAK = 43,
+  TARGET_SIGNAL_PRIO = 44,
+  TARGET_SIGNAL_REALTIME_33 = 45,
+  TARGET_SIGNAL_REALTIME_34 = 46,
+  TARGET_SIGNAL_REALTIME_35 = 47,
+  TARGET_SIGNAL_REALTIME_36 = 48,
+  TARGET_SIGNAL_REALTIME_37 = 49,
+  TARGET_SIGNAL_REALTIME_38 = 50,
+  TARGET_SIGNAL_REALTIME_39 = 51,
+  TARGET_SIGNAL_REALTIME_40 = 52,
+  TARGET_SIGNAL_REALTIME_41 = 53,
+  TARGET_SIGNAL_REALTIME_42 = 54,
+  TARGET_SIGNAL_REALTIME_43 = 55,
+  TARGET_SIGNAL_REALTIME_44 = 56,
+  TARGET_SIGNAL_REALTIME_45 = 57,
+  TARGET_SIGNAL_REALTIME_46 = 58,
+  TARGET_SIGNAL_REALTIME_47 = 59,
+  TARGET_SIGNAL_REALTIME_48 = 60,
+  TARGET_SIGNAL_REALTIME_49 = 61,
+  TARGET_SIGNAL_REALTIME_50 = 62,
+  TARGET_SIGNAL_REALTIME_51 = 63,
+  TARGET_SIGNAL_REALTIME_52 = 64,
+  TARGET_SIGNAL_REALTIME_53 = 65,
+  TARGET_SIGNAL_REALTIME_54 = 66,
+  TARGET_SIGNAL_REALTIME_55 = 67,
+  TARGET_SIGNAL_REALTIME_56 = 68,
+  TARGET_SIGNAL_REALTIME_57 = 69,
+  TARGET_SIGNAL_REALTIME_58 = 70,
+  TARGET_SIGNAL_REALTIME_59 = 71,
+  TARGET_SIGNAL_REALTIME_60 = 72,
+  TARGET_SIGNAL_REALTIME_61 = 73,
+  TARGET_SIGNAL_REALTIME_62 = 74,
+  TARGET_SIGNAL_REALTIME_63 = 75,
 
   /* Some signal we don't know about.  */
   TARGET_SIGNAL_UNKNOWN,
@@ -175,6 +208,14 @@ extern char *target_signal_to_name PARAMS ((enum target_signal));
 /* Given a name (SIGHUP, etc.), return its signal.  */
 enum target_signal target_signal_from_name PARAMS ((char *));
 
+/* If certain kinds of activity happen, target_wait should perform
+   callbacks.  */
+/* Right now we just call (*TARGET_ACTIVITY_FUNCTION) if I/O is possible
+   on TARGET_ACTIVITY_FD.   */
+extern int target_activity_fd;
+/* Returns zero to leave the inferior alone, one to interrupt it.  */
+extern int (*target_activity_function) PARAMS ((void));
+
 struct target_ops
 {
   char	       *to_shortname;	/* Name this target type */
@@ -231,7 +272,7 @@ struct target_ops
 			     CORE_ADDR *addr_found, char *data_found));
 
 #define	target_search(len, data, mask, startaddr, increment, lorange, hirange, addr_found, data_found)	\
-  (*current_target->to_search) (len, data, mask, startaddr, increment, \
+  (*current_target.to_search) (len, data, mask, startaddr, increment, \
 				lorange, hirange, addr_found, data_found)
 #endif /* 0 */
 
@@ -250,9 +291,10 @@ struct target_ops
   void 	      (*to_mourn_inferior) PARAMS ((void));
   int	      (*to_can_run) PARAMS ((void));
   void	      (*to_notice_signals) PARAMS ((int pid));
+  void	      (*to_stop) PARAMS ((void));
   enum strata   to_stratum;
   struct target_ops
-    	       *to_next;
+		*DONT_USE;	/* formerly to_next */
   int		to_has_all_memory;
   int		to_has_memory;
   int		to_has_stack;
@@ -275,18 +317,30 @@ struct target_ops
 /* The ops structure for our "current" target process.  This should
    never be NULL.  If there is no target, it points to the dummy_target.  */
 
-extern struct target_ops	*current_target;
+extern struct target_ops	current_target;
+
+/* An item on the target stack.  */
+
+struct target_stack_item
+{
+  struct target_stack_item *next;
+  struct target_ops *target_ops;
+};
+
+/* The target stack.  */
+
+extern struct target_stack_item *target_stack;
 
 /* Define easy words for doing these operations on our current target.  */
 
-#define	target_shortname	(current_target->to_shortname)
-#define	target_longname		(current_target->to_longname)
+#define	target_shortname	(current_target.to_shortname)
+#define	target_longname		(current_target.to_longname)
 
 /* The open routine takes the rest of the parameters from the command,
    and (if successful) pushes a new target onto the stack.
    Targets should supply this routine, if only to provide an error message.  */
 #define	target_open(name, from_tty)	\
-	(*current_target->to_open) (name, from_tty)
+	(*current_target.to_open) (name, from_tty)
 
 /* Does whatever cleanup is required for a target that we are no longer
    going to be calling.  Argument says whether we are quitting gdb and
@@ -297,7 +351,7 @@ extern struct target_ops	*current_target;
    do.  */
 
 #define	target_close(quitting)	\
-	(*current_target->to_close) (quitting)
+	(*current_target.to_close) (quitting)
 
 /* Attaches to a process on the target side.  Arguments are as passed
    to the `attach' command by the user.  This routine can be called
@@ -308,7 +362,7 @@ extern struct target_ops	*current_target;
    (without waiting) to an upcoming target_wait call.  */
 
 #define	target_attach(args, from_tty)	\
-	(*current_target->to_attach) (args, from_tty)
+	(*current_target.to_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
@@ -326,7 +380,7 @@ target_detach PARAMS ((char *, int));
    pass TARGET_SIGNAL_DEFAULT.  */
 
 #define	target_resume(pid, step, siggnal)	\
-	(*current_target->to_resume) (pid, step, siggnal)
+	(*current_target.to_resume) (pid, step, siggnal)
 
 /* Wait for process pid to do something.  Pid = -1 to wait for any pid
    to do something.  Return pid of child, or -1 in case of error;
@@ -337,19 +391,19 @@ target_detach PARAMS ((char *, int));
    stop_pc, etc., set up.  */
 
 #define	target_wait(pid, status)		\
-	(*current_target->to_wait) (pid, status)
+	(*current_target.to_wait) (pid, status)
 
 /* Fetch register REGNO, or all regs if regno == -1.  No result.  */
 
 #define	target_fetch_registers(regno)	\
-	(*current_target->to_fetch_registers) (regno)
+	(*current_target.to_fetch_registers) (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(regs)	\
-	(*current_target->to_store_registers) (regs)
+	(*current_target.to_store_registers) (regs)
 
 /* Get ready to modify the registers array.  On machines which store
    individual registers, this doesn't need to do anything.  On machines
@@ -358,7 +412,7 @@ target_detach PARAMS ((char *, int));
    debugged.  */
 
 #define	target_prepare_to_store()	\
-	(*current_target->to_prepare_to_store) ()
+	(*current_target.to_prepare_to_store) ()
 
 extern int target_read_string PARAMS ((CORE_ADDR, char **, int, int *));
 
@@ -393,7 +447,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
 /* Print a line about the current target.  */
 
 #define	target_files_info()	\
-	(*current_target->to_files_info) (current_target)
+	(*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
@@ -402,7 +456,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    an errno value.  */
 
 #define	target_insert_breakpoint(addr, save)	\
-	(*current_target->to_insert_breakpoint) (addr, save)
+	(*current_target.to_insert_breakpoint) (addr, save)
 
 /* Remove a breakpoint at address ADDR in the target machine.
    SAVE is a pointer to the same save area 
@@ -410,19 +464,19 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    Result is 0 for success, or an errno value.  */
 
 #define	target_remove_breakpoint(addr, save)	\
-	(*current_target->to_remove_breakpoint) (addr, save)
+	(*current_target.to_remove_breakpoint) (addr, save)
 
 /* Initialize the terminal settings we record for the inferior,
    before we actually run the inferior.  */
 
 #define target_terminal_init() \
-	(*current_target->to_terminal_init) ()
+	(*current_target.to_terminal_init) ()
 
 /* 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) ()
+	(*current_target.to_terminal_inferior) ()
 
 /* Put some of our terminal settings into effect,
    enough to get proper results from our output,
@@ -433,32 +487,32 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    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) ()
+	(*current_target.to_terminal_ours_for_output) ()
 
 /* 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) ()
+	(*current_target.to_terminal_ours) ()
 
 /* Print useful information about our terminal status, if such a thing
    exists.  */
 
 #define target_terminal_info(arg, from_tty) \
-	(*current_target->to_terminal_info) (arg, from_tty)
+	(*current_target.to_terminal_info) (arg, from_tty)
 
 /* Kill the inferior process.   Make it go away.  */
 
 #define target_kill() \
-	(*current_target->to_kill) ()
+	(*current_target.to_kill) ()
 
 /* Load an executable file into the target process.  This is expected to
    not only bring new code into the target process, but also to update
    GDB's symbol tables to match.  */
 
 #define target_load(arg, from_tty) \
-	(*current_target->to_load) (arg, from_tty)
+	(*current_target.to_load) (arg, from_tty)
 
 /* Look up a symbol in the target's symbol table.  NAME is the symbol
    name.  ADDRP is a CORE_ADDR * pointing to where the value of the symbol
@@ -469,7 +523,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    doing a complain().  */
 
 #define target_lookup_symbol(name, addrp) 	\
-  (*current_target->to_lookup_symbol) (name, addrp)
+  (*current_target.to_lookup_symbol) (name, addrp)
 
 /* Start an inferior process and set inferior_pid to its pid.
    EXEC_FILE is the file to run.
@@ -478,12 +532,12 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    On VxWorks and various standalone systems, we ignore exec_file.  */
  
 #define	target_create_inferior(exec_file, args, env)	\
-	(*current_target->to_create_inferior) (exec_file, args, env)
+	(*current_target.to_create_inferior) (exec_file, args, env)
 
 /* The inferior process has died.  Do what is right.  */
 
 #define	target_mourn_inferior()	\
-	(*current_target->to_mourn_inferior) ()
+	(*current_target.to_mourn_inferior) ()
 
 /* Does target have enough data to do a run or attach command? */
 
@@ -493,35 +547,41 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
 /* post process changes to signal handling in the inferior.  */
 
 #define target_notice_signals(pid) \
-  	(*current_target->to_notice_signals) (pid)
+  	(*current_target.to_notice_signals) (pid)
+
+/* 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.  */
+
+#define target_stop() current_target.to_stop ()
 
 /* Pointer to next target in the chain, e.g. a core file and an exec file.  */
 
 #define	target_next \
-	(current_target->to_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_has_all_memory	\
-	(current_target->to_has_all_memory)
+	(current_target.to_has_all_memory)
 
 /* Does the target include memory?  (Dummy targets don't.)  */
 
 #define	target_has_memory	\
-	(current_target->to_has_memory)
+	(current_target.to_has_memory)
 
 /* 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)
+	(current_target.to_has_stack)
 
 /* Does the target have registers?  (Exec files don't.)  */
 
 #define	target_has_registers	\
-	(current_target->to_has_registers)
+	(current_target.to_has_registers)
 
 /* Does the target have execution?  Can we make it jump (through
    hoops), or pop its stack a few times?  FIXME: If this is to work that
@@ -531,7 +591,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    this just tells us whether this target is *capable* of execution.  */
 
 #define	target_has_execution	\
-	(current_target->to_has_execution)
+	(current_target.to_has_execution)
 
 extern void target_link PARAMS ((char *, CORE_ADDR *));
 
@@ -545,6 +605,15 @@ extern void target_link PARAMS ((char *, CORE_ADDR *));
 extern char *normal_pid_to_str PARAMS ((int pid));
 #endif
 
+/* Hardware watchpoint interfaces.  */
+
+/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
+   write).  */
+
+#ifndef STOPPED_BY_WATCHPOINT
+#define STOPPED_BY_WATCHPOINT(w) 0
+#endif
+
 /* Routines for maintenance of the target structures...
 
    add_target:   Add a target to the list of all possible targets.
@@ -635,4 +704,7 @@ extern void store_waitstatus PARAMS ((struct target_waitstatus *, int));
 extern enum target_signal target_signal_from_host PARAMS ((int));
 extern int target_signal_to_host PARAMS ((enum target_signal));
 
+/* Convert from a number used in a GDB command to an enum target_signal.  */
+extern enum target_signal target_signal_from_command PARAMS ((int));
+
 #endif	/* !defined (TARGET_H) */