* corelow.c (init_core_ops): Delete references to to_require_attach

	and to_require_detach.
	* exec.c (init_exec_ops): Likewise.
	* hppah-nat.c (child_follow_fork): Call hppa_require_attach and
	hppa_require_detach directly.
	* inferior.h (REQUIRE_ATTACH, REQUIRE_DETACH): Delete.
	* inftarg.c (child_detach): Remove.
	(child_detach_from_process): Rename to child_detach, remove
	after_fork argument.
	(child_attach): Remove.
	(child_attach_to_process): Rename to child_attach, remove after_fork
	argument.
	(init_child_ops): Delete references to to_require_attach
	and to_require_detach.
	* infttrace.c (hppa_require_attach): Update comment.
	* target.c (cleanup_target, update_current_target)
	(init_dummy_target, setup_target_debug): Delete references to
	to_require_attach and to_require_detach.
	(find_default_require_detach, find_default_require_attach)
	(debug_to_require_attach, debug_to_require_detach): Remove
	functions.
	* target.h (struct target_ops): Remove to_require_attach
	and to_require_detach.
	(target_require_attach, target_require_detach): Delete macros.
	(find_default_require_detach, find_default_require_attach): Delete
	prototypes.
	* config/pa/nm-hppah.h (REQUIRE_ATTACH, REQUIRE_DETACH): Delete.

10 files changed, 58 insertions, 173 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index d76023e..a2e61ad 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,33 @@
+2002-12-11  Daniel Jacobowitz  <drow@mvista.com>
+
+	* corelow.c (init_core_ops): Delete references to to_require_attach
+	and to_require_detach.
+	* exec.c (init_exec_ops): Likewise.
+	* hppah-nat.c (child_follow_fork): Call hppa_require_attach and
+	hppa_require_detach directly.
+	* inferior.h (REQUIRE_ATTACH, REQUIRE_DETACH): Delete.
+	* inftarg.c (child_detach): Remove.
+	(child_detach_from_process): Rename to child_detach, remove
+	after_fork argument.
+	(child_attach): Remove.
+	(child_attach_to_process): Rename to child_attach, remove after_fork
+	argument.
+	(init_child_ops): Delete references to to_require_attach
+	and to_require_detach.
+	* infttrace.c (hppa_require_attach): Update comment.
+	* target.c (cleanup_target, update_current_target)
+	(init_dummy_target, setup_target_debug): Delete references to
+	to_require_attach and to_require_detach.
+	(find_default_require_detach, find_default_require_attach)
+	(debug_to_require_attach, debug_to_require_detach): Remove
+	functions.
+	* target.h (struct target_ops): Remove to_require_attach
+	and to_require_detach.
+	(target_require_attach, target_require_detach): Delete macros.
+	(find_default_require_detach, find_default_require_attach): Delete
+	prototypes.
+	* config/pa/nm-hppah.h (REQUIRE_ATTACH, REQUIRE_DETACH): Delete.
+
 2002-12-11  Andrew Cagney  <ac131313@redhat.com>
 
 	* frame.c (get_frame_extra_info): New function.
diff --git a/gdb/config/pa/nm-hppah.h b/gdb/config/pa/nm-hppah.h
index 54fe806..9c150ee 100644
--- a/gdb/config/pa/nm-hppah.h
+++ b/gdb/config/pa/nm-hppah.h
@@ -90,10 +90,7 @@ extern int hppa_prepare_to_proceed (void);
 struct target_waitstatus;
 extern ptid_t child_wait (ptid_t, struct target_waitstatus *);
 
-#define REQUIRE_ATTACH(pid) hppa_require_attach(pid)
 extern int hppa_require_attach (int);
-
-#define REQUIRE_DETACH(pid,signal) hppa_require_detach(pid,signal)
 extern int hppa_require_detach (int, int);
 
 /* So we can cleanly use code in infptrace.c.  */
diff --git a/gdb/corelow.c b/gdb/corelow.c
index 90ac062..ff758b8 100644
--- a/gdb/corelow.c
+++ b/gdb/corelow.c
@@ -510,9 +510,7 @@ init_core_ops (void)
   core_ops.to_open = core_open;
   core_ops.to_close = core_close;
   core_ops.to_attach = find_default_attach;
-  core_ops.to_require_attach = find_default_require_attach;
   core_ops.to_detach = core_detach;
-  core_ops.to_require_detach = find_default_require_detach;
   core_ops.to_fetch_registers = get_core_registers;
   core_ops.to_xfer_memory = xfer_memory;
   core_ops.to_files_info = core_files_info;
diff --git a/gdb/exec.c b/gdb/exec.c
index bc9c22b..e55fd42 100644
--- a/gdb/exec.c
+++ b/gdb/exec.c
@@ -715,8 +715,6 @@ Specify the filename of the executable file.";
   exec_ops.to_open = exec_open;
   exec_ops.to_close = exec_close;
   exec_ops.to_attach = find_default_attach;
-  exec_ops.to_require_attach = find_default_require_attach;
-  exec_ops.to_require_detach = find_default_require_detach;
   exec_ops.to_xfer_memory = xfer_memory;
   exec_ops.to_files_info = exec_files_info;
   exec_ops.to_insert_breakpoint = ignore;
diff --git a/gdb/hppah-nat.c b/gdb/hppah-nat.c
index 8ff6c28..84d1f3f 100644
--- a/gdb/hppah-nat.c
+++ b/gdb/hppah-nat.c
@@ -423,7 +423,9 @@ child_follow_fork (int follow_child)
 	}
 
       /* Detach from the child. */
-      target_require_detach (child_pid, "", 1);
+      printf_unfiltered ("Detaching after fork from %s\n",
+			 target_pid_to_str (pid_to_ptid (child_pid)));
+      hppa_require_detach (child_pid, 0);
 
       /* The parent and child of a vfork share the same address space.
 	 Also, on some targets the order in which vfork and exec events
@@ -465,8 +467,6 @@ child_follow_fork (int follow_child)
     }
   else
     {
-      char child_pid_spelling[40];
-
       /* Needed to keep the breakpoint lists in sync.  */
       if (! has_vforked)
 	detach_breakpoints (child_pid);
@@ -483,10 +483,10 @@ child_follow_fork (int follow_child)
       target_detach (NULL, 1);
 
       /* Attach to the child. */
+      printf_unfiltered ("Attaching after fork to %s\n",
+			 target_pid_to_str (pid_to_ptid (child_pid)));
+      hppa_require_attach (child_pid);
       inferior_ptid = pid_to_ptid (child_pid);
-      sprintf (child_pid_spelling, "%d", child_pid);
-
-      target_require_attach (child_pid_spelling, 1);
 
       /* If we vforked, then we've also execed by now.  The exec will be
 	 reported momentarily.  follow_exec () will handle breakpoints, so
diff --git a/gdb/inferior.h b/gdb/inferior.h
index a9bbd59..09cd7ff 100644
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -237,14 +237,6 @@ extern void terminal_init_inferior_with_pgrp (int pgrp);
 
 extern int attach (int);
 
-#if !defined(REQUIRE_ATTACH)
-#define REQUIRE_ATTACH attach
-#endif
-
-#if !defined(REQUIRE_DETACH)
-#define REQUIRE_DETACH(pid,siggnal) detach (siggnal)
-#endif
-
 extern void detach (int);
 
 /* PTRACE method of waiting for inferior process.  */
diff --git a/gdb/inftarg.c b/gdb/inftarg.c
index 137407d..471eb3c 100644
--- a/gdb/inftarg.c
+++ b/gdb/inftarg.c
@@ -61,20 +61,12 @@ static void child_files_info (struct target_ops *);
 
 static void child_detach (char *, int);
 
-static void child_detach_from_process (int, char *, int, int);
-
 static void child_attach (char *, int);
 
-static void child_attach_to_process (char *, int, int);
-
 #if !defined(CHILD_POST_ATTACH)
 extern void child_post_attach (int);
 #endif
 
-static void child_require_attach (char *, int);
-
-static void child_require_detach (int, char *, int);
-
 static void ptrace_me (void);
 
 static void ptrace_him (int);
@@ -195,8 +187,10 @@ child_thread_alive (ptid_t ptid)
 
 #endif
 
+/* Attach to process PID, then initialize for debugging it.  */
+
 static void
-child_attach_to_process (char *args, int from_tty, int after_fork)
+child_attach (char *args, int from_tty)
 {
   if (!args)
     error_no_arg ("process-id to attach");
@@ -222,10 +216,7 @@ child_attach_to_process (char *args, int from_tty, int after_fork)
       {
 	exec_file = (char *) get_exec_file (0);
 
-	if (after_fork)
-	  printf_unfiltered ("Attaching after fork to %s\n",
-			     target_pid_to_str (pid_to_ptid (pid)));
-	else if (exec_file)
+	if (exec_file)
 	  printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
 			     target_pid_to_str (pid_to_ptid (pid)));
 	else
@@ -235,10 +226,7 @@ child_attach_to_process (char *args, int from_tty, int after_fork)
 	gdb_flush (gdb_stdout);
       }
 
-    if (!after_fork)
-      attach (pid);
-    else
-      REQUIRE_ATTACH (pid);
+    attach (pid);
 
     inferior_ptid = pid_to_ptid (pid);
     push_target (&child_ops);
@@ -246,15 +234,6 @@ child_attach_to_process (char *args, int from_tty, int after_fork)
 #endif /* ATTACH_DETACH */
 }
 
-
-/* Attach to process PID, then initialize for debugging it.  */
-
-static void
-child_attach (char *args, int from_tty)
-{
-  child_attach_to_process (args, from_tty, 0);
-}
-
 #if !defined(CHILD_POST_ATTACH)
 void
 child_post_attach (int pid)
@@ -264,68 +243,44 @@ child_post_attach (int pid)
 }
 #endif
 
-static void
-child_require_attach (char *args, int from_tty)
-{
-  child_attach_to_process (args, from_tty, 1);
-}
+/* Take a program previously attached to and detaches it.
+   The program resumes execution and will no longer stop
+   on signals, etc.  We'd better not have left any breakpoints
+   in the program or it'll die when it hits one.  For this
+   to work, it may be necessary for the process to have been
+   previously attached.  It *might* work if the program was
+   started via the normal ptrace (PTRACE_TRACEME).  */
 
 static void
-child_detach_from_process (int pid, char *args, int from_tty, int after_fork)
+child_detach (char *args, int from_tty)
 {
 #ifdef ATTACH_DETACH
   {
     int siggnal = 0;
+    int pid = PIDGET (inferior_ptid);
 
     if (from_tty)
       {
 	char *exec_file = get_exec_file (0);
 	if (exec_file == 0)
 	  exec_file = "";
-	if (after_fork)
-	  printf_unfiltered ("Detaching after fork from %s\n",
-			     target_pid_to_str (pid_to_ptid (pid)));
-	else
-	  printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
-			     target_pid_to_str (pid_to_ptid (pid)));
+	printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
+			   target_pid_to_str (pid_to_ptid (pid)));
 	gdb_flush (gdb_stdout);
       }
     if (args)
       siggnal = atoi (args);
 
-    if (!after_fork)
-      detach (siggnal);
-    else
-      REQUIRE_DETACH (pid, siggnal);
+    detach (siggnal);
+
+    inferior_ptid = null_ptid;
+    unpush_target (&child_ops);
   }
 #else
   error ("This version of Unix does not support detaching a process.");
 #endif
 }
 
-/* Take a program previously attached to and detaches it.
-   The program resumes execution and will no longer stop
-   on signals, etc.  We'd better not have left any breakpoints
-   in the program or it'll die when it hits one.  For this
-   to work, it may be necessary for the process to have been
-   previously attached.  It *might* work if the program was
-   started via the normal ptrace (PTRACE_TRACEME).  */
-
-static void
-child_detach (char *args, int from_tty)
-{
-  child_detach_from_process (PIDGET (inferior_ptid), args, from_tty, 0);
-  inferior_ptid = null_ptid;
-  unpush_target (&child_ops);
-}
-
-static void
-child_require_detach (int pid, char *args, int from_tty)
-{
-  child_detach_from_process (pid, args, from_tty, 1);
-}
-
-
 /* Get ready to modify the registers array.  On machines which store
    individual registers, this doesn't need to do anything.  On machines
    which store all the registers in one fell swoop, this makes sure
@@ -616,9 +571,7 @@ init_child_ops (void)
   child_ops.to_open = child_open;
   child_ops.to_attach = child_attach;
   child_ops.to_post_attach = child_post_attach;
-  child_ops.to_require_attach = child_require_attach;
   child_ops.to_detach = child_detach;
-  child_ops.to_require_detach = child_require_detach;
   child_ops.to_resume = child_resume;
   child_ops.to_wait = child_wait;
   child_ops.to_post_wait = child_post_wait;
diff --git a/gdb/infttrace.c b/gdb/infttrace.c
index 69a67df..589a0e2 100644
--- a/gdb/infttrace.c
+++ b/gdb/infttrace.c
@@ -5050,9 +5050,7 @@ pre_fork_inferior (void)
     }
 }
 
-/* Called via #define REQUIRE_ATTACH from inftarg.c,
- * ultimately from "follow_inferior_fork" in infrun.c,
- * itself called from "resume".
+/* Called from child_follow_fork in hppah-nat.c.
  *
  * This seems to be intended to attach after a fork or
  * vfork, while "attach" is used to attach to a pid
diff --git a/gdb/target.c b/gdb/target.c
index 2adea95..25ed830 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -368,14 +368,9 @@ cleanup_target (struct target_ops *t)
   de_fault (to_post_attach, 
 	    (void (*) (int)) 
 	    target_ignore);
-  de_fault (to_require_attach, 
-	    maybe_kill_then_attach);
   de_fault (to_detach, 
 	    (void (*) (char *, int)) 
 	    target_ignore);
-  de_fault (to_require_detach, 
-	    (void (*) (int, char *, int)) 
-	    target_ignore);
   de_fault (to_resume, 
 	    (void (*) (ptid_t, int, enum target_signal)) 
 	    noprocess);
@@ -473,7 +468,7 @@ cleanup_target (struct target_ops *t)
   de_fault (to_remove_vfork_catchpoint, 
 	    (int (*) (int)) 
 	    tcomplain);
-  de_fault (to_follow_fork, 
+  de_fault (to_follow_fork,
 	    (int (*) (int)) 
 	    target_ignore);
   de_fault (to_insert_exec_catchpoint, 
@@ -560,9 +555,7 @@ update_current_target (void)
       INHERIT (to_close, t);
       INHERIT (to_attach, t);
       INHERIT (to_post_attach, t);
-      INHERIT (to_require_attach, t);
       INHERIT (to_detach, t);
-      INHERIT (to_require_detach, t);
       INHERIT (to_resume, t);
       INHERIT (to_wait, t);
       INHERIT (to_post_wait, t);
@@ -1210,26 +1203,6 @@ find_default_attach (char *args, int from_tty)
 }
 
 void
-find_default_require_attach (char *args, int from_tty)
-{
-  struct target_ops *t;
-
-  t = find_default_run_target ("require_attach");
-  (t->to_require_attach) (args, from_tty);
-  return;
-}
-
-void
-find_default_require_detach (int pid, char *args, int from_tty)
-{
-  struct target_ops *t;
-
-  t = find_default_run_target ("require_detach");
-  (t->to_require_detach) (pid, args, from_tty);
-  return;
-}
-
-void
 find_default_create_inferior (char *exec_file, char *allargs, char **env)
 {
   struct target_ops *t;
@@ -1536,8 +1509,6 @@ init_dummy_target (void)
   dummy_target.to_longname = "None";
   dummy_target.to_doc = "";
   dummy_target.to_attach = find_default_attach;
-  dummy_target.to_require_attach = find_default_require_attach;
-  dummy_target.to_require_detach = find_default_require_detach;
   dummy_target.to_create_inferior = find_default_create_inferior;
   dummy_target.to_pid_to_str = normal_pid_to_str;
   dummy_target.to_stratum = dummy_stratum;
@@ -1583,15 +1554,6 @@ debug_to_post_attach (int pid)
 }
 
 static void
-debug_to_require_attach (char *args, int from_tty)
-{
-  debug_target.to_require_attach (args, from_tty);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_require_attach (%s, %d)\n", args, from_tty);
-}
-
-static void
 debug_to_detach (char *args, int from_tty)
 {
   debug_target.to_detach (args, from_tty);
@@ -1600,15 +1562,6 @@ debug_to_detach (char *args, int from_tty)
 }
 
 static void
-debug_to_require_detach (int pid, char *args, int from_tty)
-{
-  debug_target.to_require_detach (pid, args, from_tty);
-
-  fprintf_unfiltered (gdb_stdlog,
-	       "target_require_detach (%d, %s, %d)\n", pid, args, from_tty);
-}
-
-static void
 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
 {
   debug_target.to_resume (ptid, step, siggnal);
@@ -2248,9 +2201,7 @@ setup_target_debug (void)
   current_target.to_close = debug_to_close;
   current_target.to_attach = debug_to_attach;
   current_target.to_post_attach = debug_to_post_attach;
-  current_target.to_require_attach = debug_to_require_attach;
   current_target.to_detach = debug_to_detach;
-  current_target.to_require_detach = debug_to_require_detach;
   current_target.to_resume = debug_to_resume;
   current_target.to_wait = debug_to_wait;
   current_target.to_post_wait = debug_to_post_wait;
diff --git a/gdb/target.h b/gdb/target.h
index e56207d..afe1fc5 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -193,9 +193,7 @@ struct target_ops
     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_resume) (ptid_t, int, enum target_signal);
     ptid_t (*to_wait) (ptid_t, struct target_waitstatus *);
     void (*to_post_wait) (ptid_t, int);
@@ -404,17 +402,6 @@ extern struct target_stack_item *target_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
@@ -424,21 +411,6 @@ extern struct target_stack_item *target_stack;
 
 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.
-
-   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)
-
 /* 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
    the target, or TARGET_SIGNAL_0 for no signal.  The caller may not
@@ -1161,10 +1133,6 @@ extern void noprocess (void);
 
 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);