This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

PATCH: Fork event updates, part the seventh


As promised, part seven.  This patch removes the now-unnecessary
target_require_attach and target_require_detach methods; they were an
HP-ism, so let's confine them to hppah-nat.c.

I think I'm done removing target methods for a bit now.  Committed.

-- 
Daniel Jacobowitz
MontaVista Software                         Debian GNU/Linux Developer

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.

Index: corelow.c
===================================================================
RCS file: /cvs/src/src/gdb/corelow.c,v
retrieving revision 1.27
diff -u -p -r1.27 corelow.c
--- corelow.c	9 Dec 2002 00:59:26 -0000	1.27
+++ corelow.c	12 Dec 2002 00:41:40 -0000
@@ -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;
Index: exec.c
===================================================================
RCS file: /cvs/src/src/gdb/exec.c,v
retrieving revision 1.22
diff -u -p -r1.22 exec.c
--- exec.c	9 Dec 2002 00:59:26 -0000	1.22
+++ exec.c	12 Dec 2002 00:41:40 -0000
@@ -715,8 +715,6 @@ Specify the filename of the executable f
   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;
Index: hppah-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppah-nat.c,v
retrieving revision 1.19
diff -u -p -r1.19 hppah-nat.c
--- hppah-nat.c	11 Dec 2002 02:04:44 -0000	1.19
+++ hppah-nat.c	12 Dec 2002 00:41:41 -0000
@@ -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
Index: inferior.h
===================================================================
RCS file: /cvs/src/src/gdb/inferior.h,v
retrieving revision 1.38
diff -u -p -r1.38 inferior.h
--- inferior.h	11 Dec 2002 02:04:44 -0000	1.38
+++ inferior.h	12 Dec 2002 00:41:41 -0000
@@ -237,14 +237,6 @@ extern void terminal_init_inferior_with_
 
 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.  */
Index: inftarg.c
===================================================================
RCS file: /cvs/src/src/gdb/inftarg.c,v
retrieving revision 1.13
diff -u -p -r1.13 inftarg.c
--- inftarg.c	11 Dec 2002 02:04:44 -0000	1.13
+++ inftarg.c	12 Dec 2002 00:41:41 -0000
@@ -61,20 +61,12 @@ static void child_files_info (struct tar
 
 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
       {
 	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
 	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
 #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;
Index: infttrace.c
===================================================================
RCS file: /cvs/src/src/gdb/infttrace.c,v
retrieving revision 1.23
diff -u -p -r1.23 infttrace.c
--- infttrace.c	11 Dec 2002 02:02:03 -0000	1.23
+++ infttrace.c	12 Dec 2002 00:41:42 -0000
@@ -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
Index: target.c
===================================================================
RCS file: /cvs/src/src/gdb/target.c,v
retrieving revision 1.46
diff -u -p -r1.46 target.c
--- target.c	11 Dec 2002 02:04:44 -0000	1.46
+++ target.c	12 Dec 2002 00:41:43 -0000
@@ -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 fro
 }
 
 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_tt
 }
 
 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;
Index: target.h
===================================================================
RCS file: /cvs/src/src/gdb/target.h,v
retrieving revision 1.32
diff -u -p -r1.32 target.h
--- target.h	11 Dec 2002 02:04:44 -0000	1.32
+++ target.h	12 Dec 2002 00:41:43 -0000
@@ -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_
 #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_
 
 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
@@ -1160,10 +1132,6 @@ extern void initialize_targets (void);
 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 **);
 
Index: config/pa/nm-hppah.h
===================================================================
RCS file: /cvs/src/src/gdb/config/pa/nm-hppah.h,v
retrieving revision 1.9
diff -u -p -r1.9 nm-hppah.h
--- config/pa/nm-hppah.h	11 Dec 2002 02:04:44 -0000	1.9
+++ config/pa/nm-hppah.h	12 Dec 2002 00:41:43 -0000
@@ -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.  */


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]