darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source 
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.
This commit is contained in:
Daniel Jacobowitz 2002-12-12 01:39:34 +00:00
parent 0394eb2acb
commit 4c9ba7e0a6
10 changed files with 67 additions and 182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
gdb/ChangeLog
View file

@ -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.

3
gdb/config/pa/nm-hppah.h
View file

@ -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. */

2
gdb/corelow.c
View file

@ -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;

2
gdb/exec.c
View file

@ -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;

12
gdb/hppah-nat.c
View file

@ -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

8
gdb/inferior.h
View file

@ -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. */

105
gdb/inftarg.c
View file

@ -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,45 +243,6 @@ child_post_attach (int pid)
}
#endif
static void
child_require_attach (char *args, int from_tty)
{
child_attach_to_process (args, from_tty, 1);
}
static void
child_detach_from_process (int pid, char *args, int from_tty, int after_fork)
{
#ifdef ATTACH_DETACH
{
int siggnal = 0;
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)));
gdb_flush (gdb_stdout);
}
if (args)
siggnal = atoi (args);
if (!after_fork)
detach (siggnal);
else
REQUIRE_DETACH (pid, siggnal);
}
#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
@ -314,17 +254,32 @@ child_detach_from_process (int pid, char *args, int from_tty, int after_fork)
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);
}
#ifdef ATTACH_DETACH
{
int siggnal = 0;
int pid = PIDGET (inferior_ptid);
static void
child_require_detach (int pid, char *args, int from_tty)
{
child_detach_from_process (pid, args, from_tty, 1);
}
if (from_tty)
{
char *exec_file = get_exec_file (0);
if (exec_file == 0)
exec_file = "";
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);
detach (siggnal);
inferior_ptid = null_ptid;
unpush_target (&child_ops);
}
#else
error ("This version of Unix does not support detaching a process.");
#endif
}
/* Get ready to modify the registers array. On machines which store
individual registers, this doesn't need to do anything. On machines
@ -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;

4
gdb/infttrace.c
View file

@ -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

51
gdb/target.c
View file

@ -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;

32
gdb/target.h
View file

@ -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);