From: Daniel Jacobowitz Date: Thu, 12 Dec 2002 01:39:34 +0000 (+0000) Subject: * corelow.c (init_core_ops): Delete references to to_require_attach X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=4c9ba7e0a610fe6e6c9b96a493a5cf3d8cce761d;p=binutils-gdb.git * 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. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index d76023e8876..a2e61ad7832 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,33 @@ +2002-12-11 Daniel Jacobowitz + + * 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 * 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 54fe806eeec..9c150ee0218 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 90ac0627aa0..ff758b81c9d 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 bc9c22b3f0f..e55fd42a408 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 8ff6c28a7bc..84d1f3fa5e4 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 a9bbd59496d..09cd7ff4c9d 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 137407d4f8f..471eb3cc7b5 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 69a67dfa1b4..589a0e237bc 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 2adea957814..25ed8301649 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); @@ -1209,26 +1202,6 @@ find_default_attach (char *args, int from_tty) return; } -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) { @@ -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; @@ -1582,15 +1553,6 @@ debug_to_post_attach (int pid) fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", 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) { @@ -1599,15 +1561,6 @@ debug_to_detach (char *args, int from_tty) fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, 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) { @@ -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 e56207de5bc..afe1fc5d8ab 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);