1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/* Subroutines for handling an "inferior" (child) process as a target
for debugging, in GDB.
Copyright 1990, 1991 Free Software Foundation, Inc.
Contributed by Cygnus Support.
This file is part of GDB.
GDB is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
GDB is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GDB; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stdio.h>
#include "defs.h"
#include "param.h"
#include "frame.h" /* required by inferior.h */
#include "inferior.h"
#include "target.h"
#include "wait.h"
#include "gdbcore.h"
#include "ieee-float.h" /* Required by REGISTER_CONVERT_TO_XXX */
extern int fetch_inferior_registers();
extern int store_inferior_registers();
extern int child_xfer_memory();
extern int memory_insert_breakpoint(), memory_remove_breakpoint();
extern void terminal_init_inferior(), terminal_ours(), terminal_inferior();
extern void terminal_ours_for_output(), child_terminal_info();
extern void kill_inferior(), add_syms_addr_command();
extern struct value *call_function_by_hand();
extern void child_resume();
extern void child_create_inferior();
extern void child_mourn_inferior();
extern void child_attach ();
/* Forward declaration */
extern struct target_ops child_ops;
/* Wait for child to do something. Return pid of child, or -1 in case
of error; store status through argument pointer STATUS. */
int
child_wait (status)
int *status;
{
int pid;
do {
pid = wait (status);
if (pid == -1) /* No more children to wait for */
{
fprintf (stderr, "Child process unexpectedly missing.\n");
*status = 42; /* Claim it exited with signal 42 */
return -1;
}
} while (pid != inferior_pid); /* Some other child died or stopped */
return pid;
}
/*
* child_detach()
* takes a program previously attached to and detaches it.
* The program resumes execution and will no longer stop
* on signals, etc. We 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 (args, from_tty)
char *args;
int from_tty;
{
int siggnal = 0;
#ifdef ATTACH_DETACH
if (from_tty)
{
char *exec_file = get_exec_file (0);
if (exec_file == 0)
exec_file = "";
printf ("Detaching program: %s pid %d\n",
exec_file, inferior_pid);
fflush (stdout);
}
if (args)
siggnal = atoi (args);
detach (siggnal);
inferior_pid = 0;
unpush_target (&child_ops); /* Pop out of handling an inferior */
#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
which store all the registers in one fell swoop, this makes sure
that registers contains all the registers from the program being
debugged. */
void
child_prepare_to_store ()
{
#ifdef CHILD_PREPARE_TO_STORE
CHILD_PREPARE_TO_STORE ();
#endif
}
/* Convert data from raw format for register REGNUM
to virtual format for register REGNUM. */
void
host_convert_to_virtual (regnum, from, to)
int regnum;
char *from;
char *to;
{
REGISTER_CONVERT_TO_VIRTUAL (regnum, from, to);
}
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
void
host_convert_from_virtual (regnum, from, to)
int regnum;
char *from;
char *to;
{
REGISTER_CONVERT_TO_RAW (regnum, from, to);
}
/* Print status information about what we're accessing. */
static void
child_files_info ()
{
printf ("\tUsing the running image of %s process %d.\n",
attach_flag? "attached": "child", inferior_pid);
}
struct target_ops child_ops = {
"child", "Unix child process",
0, 0, /* open, close */
child_attach, child_detach,
child_resume,
child_wait,
fetch_inferior_registers, store_inferior_registers,
child_prepare_to_store,
host_convert_to_virtual, host_convert_from_virtual,
child_xfer_memory, child_files_info,
memory_insert_breakpoint, memory_remove_breakpoint,
terminal_init_inferior, terminal_inferior,
terminal_ours_for_output, terminal_ours, child_terminal_info,
kill_inferior, 0, add_syms_addr_command, /* load */
call_function_by_hand,
0, /* lookup_symbol */
child_create_inferior, child_mourn_inferior,
process_stratum, 0, /* next */
1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
OPS_MAGIC, /* Always the last thing */
};
void
_initialize_inftarg ()
{
add_target (&child_ops);
}
|
