GDB (xrefs)

/tmp/gdb-8.1/gdb/inf-child.c
Go to the documentation of this file.
1 /* Base/prototype target for default child (native) targets.
2
3 Copyright (C) 1988-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* This file provides a common base class/target that all native
21 target implementations extend, by calling inf_child_target to get a
22 new prototype target and then overriding target methods as
23 necessary. */
24
25 #include "defs.h"
26 #include "regcache.h"
27 #include "memattr.h"
28 #include "symtab.h"
29 #include "target.h"
30 #include "inferior.h"
31 #include <sys/stat.h>
32 #include "inf-child.h"
33 #include "fileio.h"
34 #include "agent.h"
35 #include "gdb_wait.h"
36 #include "filestuff.h"
37
38 #include <sys/types.h>
39 #include <fcntl.h>
40 #include <unistd.h>
41
42 /* A pointer to what is returned by inf_child_target. Used by
43 inf_child_open to push the most-derived target in reaction to
44 "target native". */
45 static struct target_ops *inf_child_ops = NULL;
46
47 /* Helper function for child_wait and the derivatives of child_wait.
48 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
49 translation of that in OURSTATUS. */
50 void
51 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
52 {
53 if (WIFEXITED (hoststatus))
54 {
55 ourstatus->kind = TARGET_WAITKIND_EXITED;
56 ourstatus->value.integer = WEXITSTATUS (hoststatus);
57 }
58 else if (!WIFSTOPPED (hoststatus))
59 {
60 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
61 ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (hoststatus));
62 }
63 else
64 {
65 ourstatus->kind = TARGET_WAITKIND_STOPPED;
66 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (hoststatus));
67 }
68 }
69
70 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
71 for all registers. */
72
73 static void
74 inf_child_fetch_inferior_registers (struct target_ops *ops,
75 struct regcache *regcache, int regnum)
76 {
77 if (regnum == -1)
78 {
79 for (regnum = 0;
80 regnum < gdbarch_num_regs (regcache->arch ());
81 regnum++)
82 regcache_raw_supply (regcache, regnum, NULL);
83 }
84 else
85 regcache_raw_supply (regcache, regnum, NULL);
86 }
87
88 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
89 this for all registers (including the floating point registers). */
90
91 static void
92 inf_child_store_inferior_registers (struct target_ops *ops,
93 struct regcache *regcache, int regnum)
94 {
95 }
96
97 static void
98 inf_child_post_attach (struct target_ops *self, int pid)
99 {
100 /* This target doesn't require a meaningful "post attach" operation
101 by a debugger. */
102 }
103
104 /* Get ready to modify the registers array. On machines which store
105 individual registers, this doesn't need to do anything. On
106 machines which store all the registers in one fell swoop, this
107 makes sure that registers contains all the registers from the
108 program being debugged. */
109
110 static void
111 inf_child_prepare_to_store (struct target_ops *self,
112 struct regcache *regcache)
113 {
114 }
115
116 /* True if the user did "target native". In that case, we won't
117 unpush the child target automatically when the last inferior is
118 gone. */
119 static int inf_child_explicitly_opened;
120
121 /* See inf-child.h. */
122
123 void
124 inf_child_open_target (struct target_ops *target, const char *arg,
125 int from_tty)
126 {
127 target_preopen (from_tty);
128 push_target (target);
129 inf_child_explicitly_opened = 1;
130 if (from_tty)
131 printf_filtered ("Done. Use the \"run\" command to start a process.\n");
132 }
133
134 static void
135 inf_child_open (const char *arg, int from_tty)
136 {
137 inf_child_open_target (inf_child_ops, arg, from_tty);
138 }
139
140 /* Implement the to_disconnect target_ops method. */
141
142 static void
143 inf_child_disconnect (struct target_ops *target, const char *args, int from_tty)
144 {
145 if (args != NULL)
146 error (_("Argument given to \"disconnect\"."));
147
148 /* This offers to detach/kill current inferiors, and then pops all
149 targets. */
150 target_preopen (from_tty);
151 }
152
153 /* Implement the to_close target_ops method. */
154
155 static void
156 inf_child_close (struct target_ops *target)
157 {
158 /* In case we were forcibly closed. */
159 inf_child_explicitly_opened = 0;
160 }
161
162 void
163 inf_child_mourn_inferior (struct target_ops *ops)
164 {
165 generic_mourn_inferior ();
166 inf_child_maybe_unpush_target (ops);
167 }
168
169 /* See inf-child.h. */
170
171 void
172 inf_child_maybe_unpush_target (struct target_ops *ops)
173 {
174 if (!inf_child_explicitly_opened && !have_inferiors ())
175 unpush_target (ops);
176 }
177
178 static void
179 inf_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
180 {
181 /* This target doesn't require a meaningful "post startup inferior"
182 operation by a debugger. */
183 }
184
185 static int
186 inf_child_follow_fork (struct target_ops *ops, int follow_child,
187 int detach_fork)
188 {
189 /* This target doesn't support following fork or vfork events. */
190 return 0;
191 }
192
193 static int
194 inf_child_can_run (struct target_ops *self)
195 {
196 return 1;
197 }
198
199 static char *
200 inf_child_pid_to_exec_file (struct target_ops *self, int pid)
201 {
202 /* This target doesn't support translation of a process ID to the
203 filename of the executable file. */
204 return NULL;
205 }
206
207 /* Implementation of to_fileio_open. */
208
209 static int
210 inf_child_fileio_open (struct target_ops *self,
211 struct inferior *inf, const char *filename,
212 int flags, int mode, int warn_if_slow,
213 int *target_errno)
214 {
215 int nat_flags;
216 mode_t nat_mode;
217 int fd;
218
219 if (fileio_to_host_openflags (flags, &nat_flags) == -1
220 || fileio_to_host_mode (mode, &nat_mode) == -1)
221 {
222 *target_errno = FILEIO_EINVAL;
223 return -1;
224 }
225
226 fd = gdb_open_cloexec (filename, nat_flags, nat_mode);
227 if (fd == -1)
228 *target_errno = host_to_fileio_error (errno);
229
230 return fd;
231 }
232
233 /* Implementation of to_fileio_pwrite. */
234
235 static int
236 inf_child_fileio_pwrite (struct target_ops *self,
237 int fd, const gdb_byte *write_buf, int len,
238 ULONGEST offset, int *target_errno)
239 {
240 int ret;
241
242 #ifdef HAVE_PWRITE
243 ret = pwrite (fd, write_buf, len, (long) offset);
244 #else
245 ret = -1;
246 #endif
247 /* If we have no pwrite or it failed for this file, use lseek/write. */
248 if (ret == -1)
249 {
250 ret = lseek (fd, (long) offset, SEEK_SET);
251 if (ret != -1)
252 ret = write (fd, write_buf, len);
253 }
254
255 if (ret == -1)
256 *target_errno = host_to_fileio_error (errno);
257
258 return ret;
259 }
260
261 /* Implementation of to_fileio_pread. */
262
263 static int
264 inf_child_fileio_pread (struct target_ops *self,
265 int fd, gdb_byte *read_buf, int len,
266 ULONGEST offset, int *target_errno)
267 {
268 int ret;
269
270 #ifdef HAVE_PREAD
271 ret = pread (fd, read_buf, len, (long) offset);
272 #else
273 ret = -1;
274 #endif
275 /* If we have no pread or it failed for this file, use lseek/read. */
276 if (ret == -1)
277 {
278 ret = lseek (fd, (long) offset, SEEK_SET);
279 if (ret != -1)
280 ret = read (fd, read_buf, len);
281 }
282
283 if (ret == -1)
284 *target_errno = host_to_fileio_error (errno);
285
286 return ret;
287 }
288
289 /* Implementation of to_fileio_fstat. */
290
291 static int
292 inf_child_fileio_fstat (struct target_ops *self, int fd,
293 struct stat *sb, int *target_errno)
294 {
295 int ret;
296
297 ret = fstat (fd, sb);
298 if (ret == -1)
299 *target_errno = host_to_fileio_error (errno);
300
301 return ret;
302 }
303
304 /* Implementation of to_fileio_close. */
305
306 static int
307 inf_child_fileio_close (struct target_ops *self, int fd, int *target_errno)
308 {
309 int ret;
310
311 ret = close (fd);
312 if (ret == -1)
313 *target_errno = host_to_fileio_error (errno);
314
315 return ret;
316 }
317
318 /* Implementation of to_fileio_unlink. */
319
320 static int
321 inf_child_fileio_unlink (struct target_ops *self,
322 struct inferior *inf, const char *filename,
323 int *target_errno)
324 {
325 int ret;
326
327 ret = unlink (filename);
328 if (ret == -1)
329 *target_errno = host_to_fileio_error (errno);
330
331 return ret;
332 }
333
334 /* Implementation of to_fileio_readlink. */
335
336 static char *
337 inf_child_fileio_readlink (struct target_ops *self,
338 struct inferior *inf, const char *filename,
339 int *target_errno)
340 {
341 /* We support readlink only on systems that also provide a compile-time
342 maximum path length (PATH_MAX), at least for now. */
343 #if defined (PATH_MAX)
344 char buf[PATH_MAX];
345 int len;
346 char *ret;
347
348 len = readlink (filename, buf, sizeof buf);
349 if (len < 0)
350 {
351 *target_errno = host_to_fileio_error (errno);
352 return NULL;
353 }
354
355 ret = (char *) xmalloc (len + 1);
356 memcpy (ret, buf, len);
357 ret[len] = '\0';
358 return ret;
359 #else
360 *target_errno = FILEIO_ENOSYS;
361 return NULL;
362 #endif
363 }
364
365 static int
366 inf_child_use_agent (struct target_ops *self, int use)
367 {
368 if (agent_loaded_p ())
369 {
370 use_agent = use;
371 return 1;
372 }
373 else
374 return 0;
375 }
376
377 static int
378 inf_child_can_use_agent (struct target_ops *self)
379 {
380 return agent_loaded_p ();
381 }
382
383 /* Default implementation of the to_can_async_p and
384 to_supports_non_stop methods. */
385
386 static int
387 return_zero (struct target_ops *ignore)
388 {
389 return 0;
390 }
391
392 struct target_ops *
393 inf_child_target (void)
394 {
395 struct target_ops *t = XCNEW (struct target_ops);
396
397 t->to_shortname = "native";
398 t->to_longname = "Native process";
399 t->to_doc = "Native process (started by the \"run\" command).";
400 t->to_open = inf_child_open;
401 t->to_close = inf_child_close;
402 t->to_disconnect = inf_child_disconnect;
403 t->to_post_attach = inf_child_post_attach;
404 t->to_fetch_registers = inf_child_fetch_inferior_registers;
405 t->to_store_registers = inf_child_store_inferior_registers;
406 t->to_prepare_to_store = inf_child_prepare_to_store;
407 t->to_insert_breakpoint = memory_insert_breakpoint;
408 t->to_remove_breakpoint = memory_remove_breakpoint;
409 t->to_terminal_init = child_terminal_init;
410 t->to_terminal_inferior = child_terminal_inferior;
411 t->to_terminal_ours_for_output = child_terminal_ours_for_output;
412 t->to_terminal_ours = child_terminal_ours;
413 t->to_terminal_info = child_terminal_info;
414 t->to_post_startup_inferior = inf_child_post_startup_inferior;
415 t->to_follow_fork = inf_child_follow_fork;
416 t->to_can_run = inf_child_can_run;
417 /* We must default these because they must be implemented by any
418 target that can run. */
419 t->to_can_async_p = return_zero;
420 t->to_supports_non_stop = return_zero;
421 t->to_pid_to_exec_file = inf_child_pid_to_exec_file;
422 t->to_stratum = process_stratum;
423 t->to_has_all_memory = default_child_has_all_memory;
424 t->to_has_memory = default_child_has_memory;
425 t->to_has_stack = default_child_has_stack;
426 t->to_has_registers = default_child_has_registers;
427 t->to_has_execution = default_child_has_execution;
428 t->to_fileio_open = inf_child_fileio_open;
429 t->to_fileio_pwrite = inf_child_fileio_pwrite;
430 t->to_fileio_pread = inf_child_fileio_pread;
431 t->to_fileio_fstat = inf_child_fileio_fstat;
432 t->to_fileio_close = inf_child_fileio_close;
433 t->to_fileio_unlink = inf_child_fileio_unlink;
434 t->to_fileio_readlink = inf_child_fileio_readlink;
435 t->to_magic = OPS_MAGIC;
436 t->to_use_agent = inf_child_use_agent;
437 t->to_can_use_agent = inf_child_can_use_agent;
438
439 /* Store a pointer so we can push the most-derived target from
440 inf_child_open. */
441 inf_child_ops = t;
442
443 return t;
444 }
target_ops::to_fileio_pread
int(* to_fileio_pread)(struct target_ops *, int fd, gdb_byte *read_buf, int len, ULONGEST offset, int *target_errno)
Definition: target.h:908
inf_child_explicitly_opened
static int inf_child_explicitly_opened
Definition: inf-child.c:119
default_child_has_stack
int default_child_has_stack(struct target_ops *ops)
Definition: target.c:216
read
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
target_ops::to_longname
const char * to_longname
Definition: target.h:416
have_inferiors
int have_inferiors(void)
Definition: inferior.c:408
target_waitstatus
Definition: waitstatus.h:104
child_terminal_info
void child_terminal_info(struct target_ops *self, const char *, int)
Definition: inflow.c:494
target_ops::to_fileio_close
int(* to_fileio_close)(struct target_ops *, int fd, int *target_errno)
Definition: target.h:920
inf_child_post_startup_inferior
static void inf_child_post_startup_inferior(struct target_ops *self, ptid_t ptid)
Definition: inf-child.c:179
pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1824
target_ops::to_has_memory
int(* to_has_memory)(struct target_ops *)
Definition: target.h:658
fileio_to_host_mode
int fileio_to_host_mode(int fileio_mode, mode_t *mode_p)
Definition: fileio.c:115
target_ops::to_has_stack
int(* to_has_stack)(struct target_ops *)
Definition: target.h:659
target_ops::to_terminal_init
void(* to_terminal_init)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:560
push_target
void push_target(struct target_ops *t)
Definition: target.c:642
target_ops::to_insert_breakpoint
int(* to_insert_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_insert_breakpoint)
Definition: target.h:466
inf_child_fileio_pwrite
static int inf_child_fileio_pwrite(struct target_ops *self, int fd, const gdb_byte *write_buf, int len, ULONGEST offset, int *target_errno)
Definition: inf-child.c:236
memattr.h
unpush_target
int unpush_target(struct target_ops *t)
Definition: target.c:689
target_ops::to_follow_fork
int(* to_follow_fork)(struct target_ops *, int, int) TARGET_DEFAULT_FUNC(default_follow_fork)
Definition: target.h:592
target_ops::to_terminal_ours_for_output
void(* to_terminal_ours_for_output)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:564
generic_mourn_inferior
void generic_mourn_inferior(void)
Definition: target.c:3198
target_ops::to_close
void(* to_close)(struct target_ops *)
Definition: target.h:431
inferior
Definition: inferior.h:310
target_waitstatus::value
union target_waitstatus::@174 value
child_terminal_inferior
void child_terminal_inferior(struct target_ops *self)
Definition: inflow.c:246
child_terminal_ours_for_output
void child_terminal_ours_for_output(struct target_ops *self)
Definition: inflow.c:315
inf_child_fileio_unlink
static int inf_child_fileio_unlink(struct target_ops *self, struct inferior *inf, const char *filename, int *target_errno)
Definition: inf-child.c:321
inf_child_ops
static struct target_ops * inf_child_ops
Definition: inf-child.c:45
inf_child_follow_fork
static int inf_child_follow_fork(struct target_ops *ops, int follow_child, int detach_fork)
Definition: inf-child.c:186
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
_
#define _(String)
Definition: gdb_locale.h:35
defs.h
default_child_has_execution
int default_child_has_execution(struct target_ops *ops, ptid_t the_ptid)
Definition: target.c:236
inf_child_maybe_unpush_target
void inf_child_maybe_unpush_target(struct target_ops *ops)
Definition: inf-child.c:172
child_terminal_ours
void child_terminal_ours(struct target_ops *self)
Definition: inflow.c:329
inf_child_use_agent
static int inf_child_use_agent(struct target_ops *self, int use)
Definition: inf-child.c:366
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
fileio_to_host_openflags
int fileio_to_host_openflags(int fileio_open_flags, int *open_flags_p)
Definition: fileio.c:81
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
default_child_has_memory
int default_child_has_memory(struct target_ops *ops)
Definition: target.c:206
symtab.h
TARGET_WAITKIND_SIGNALLED
Definition: waitstatus.h:39
WSTOPSIG
#define WSTOPSIG
Definition: gdb_wait.h:75
OPS_MAGIC
#define OPS_MAGIC
Definition: target.h:1270
inf_child_fileio_fstat
static int inf_child_fileio_fstat(struct target_ops *self, int fd, struct stat *sb, int *target_errno)
Definition: inf-child.c:292
WTERMSIG
#define WTERMSIG(w)
Definition: gdb_wait.h:71
inf_child_store_inferior_registers
static void inf_child_store_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regnum)
Definition: inf-child.c:92
target_ops
Definition: target.h:412
inf_child_fetch_inferior_registers
static void inf_child_fetch_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regnum)
Definition: inf-child.c:74
target_waitstatus::sig
enum gdb_signal sig
Definition: waitstatus.h:114
WIFEXITED
#define WIFEXITED(w)
Definition: gdb_wait.h:44
regcache.h
inf_child_open
static void inf_child_open(const char *arg, int from_tty)
Definition: inf-child.c:135
ptid_t
Definition: ptid.h:35
target_ops::to_can_run
int(* to_can_run)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:611
host_to_fileio_error
int host_to_fileio_error(int error)
Definition: fileio.c:28
default_child_has_all_memory
int default_child_has_all_memory(struct target_ops *ops)
Definition: target.c:196
inferior.h
store_waitstatus
void store_waitstatus(struct target_waitstatus *ourstatus, int hoststatus)
Definition: inf-child.c:51
inf_child_fileio_open
static int inf_child_fileio_open(struct target_ops *self, struct inferior *inf, const char *filename, int flags, int mode, int warn_if_slow, int *target_errno)
Definition: inf-child.c:210
use_agent
int use_agent
Definition: agent.c:46
target_ops::to_has_execution
int(* to_has_execution)(struct target_ops *, ptid_t)
Definition: target.h:661
inf_child_open_target
void inf_child_open_target(struct target_ops *target, const char *arg, int from_tty)
Definition: inf-child.c:124
gdb_signal_from_host
enum gdb_signal gdb_signal_from_host(int)
Definition: signals.c:116
target_ops::to_fileio_fstat
int(* to_fileio_fstat)(struct target_ops *, int fd, struct stat *sb, int *target_errno)
Definition: target.h:915
process_stratum
Definition: target.h:87
inf
Definition: gnu-nat.c:174
inf_child_post_attach
static void inf_child_post_attach(struct target_ops *self, int pid)
Definition: inf-child.c:98
target_ops::to_doc
const char * to_doc
Definition: target.h:417
inf_child_disconnect
static void inf_child_disconnect(struct target_ops *target, const char *args, int from_tty)
Definition: inf-child.c:143
regnum
int regnum
Definition: aarch64-tdep.c:77
WEXITSTATUS
#define WEXITSTATUS(w)
Definition: gdb_wait.h:67
fileio.h
inf_child_mourn_inferior
void inf_child_mourn_inferior(struct target_ops *ops)
Definition: inf-child.c:163
xmalloc
void * xmalloc(YYSIZE_T)
target_ops::to_pid_to_exec_file
char *(* to_pid_to_exec_file)(struct target_ops *, int pid) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:650
inf_child_fileio_pread
static int inf_child_fileio_pread(struct target_ops *self, int fd, gdb_byte *read_buf, int len, ULONGEST offset, int *target_errno)
Definition: inf-child.c:264
return_zero
static int return_zero(struct target_ops *ignore)
Definition: inf-child.c:387
target_ops::to_disconnect
void(* to_disconnect)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:445
WIFSTOPPED
#define WIFSTOPPED(w)
Definition: gdb_wait.h:62
target_ops::to_fileio_open
int(* to_fileio_open)(struct target_ops *, struct inferior *inf, const char *filename, int flags, int mode, int warn_if_slow, int *target_errno)
Definition: target.h:893
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
inf_child_close
static void inf_child_close(struct target_ops *target)
Definition: inf-child.c:156
target_waitstatus::integer
int integer
Definition: waitstatus.h:112
inf_child_target
struct target_ops * inf_child_target(void)
Definition: inf-child.c:393
inf_child_fileio_close
static int inf_child_fileio_close(struct target_ops *self, int fd, int *target_errno)
Definition: inf-child.c:307
target_ops::to_fetch_registers
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:457
default_child_has_registers
int default_child_has_registers(struct target_ops *ops)
Definition: target.c:226
SEEK_SET
#define SEEK_SET
Definition: defs.h:93
XCNEW
#define XCNEW(T)
Definition: poison.h:121
target_ops::to_fileio_pwrite
int(* to_fileio_pwrite)(struct target_ops *, int fd, const gdb_byte *write_buf, int len, ULONGEST offset, int *target_errno)
Definition: target.h:901
target_waitstatus::kind
enum target_waitkind kind
Definition: waitstatus.h:106
inf_child_pid_to_exec_file
static char * inf_child_pid_to_exec_file(struct target_ops *self, int pid)
Definition: inf-child.c:200
target_ops::to_stratum
enum strata to_stratum
Definition: target.h:656
target_ops::to_open
void(* to_open)(const char *, int)
Definition: target.h:426
offset
int offset
Definition: agent.c:65
TARGET_WAITKIND_EXITED
Definition: waitstatus.h:31
target_ops::to_post_attach
void(* to_post_attach)(struct target_ops *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:441
target_ops::to_can_async_p
int(* to_can_async_p)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:666
inf_child_can_run
static int inf_child_can_run(struct target_ops *self)
Definition: inf-child.c:194
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
target_ops::to_remove_breakpoint
int(* to_remove_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *, enum remove_bp_reason) TARGET_DEFAULT_FUNC(memory_remove_breakpoint)
Definition: target.h:469
target.h
agent.h
target_ops::to_terminal_ours
void(* to_terminal_ours)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:566
gdb_open_cloexec
int gdb_open_cloexec(const char *filename, int flags, unsigned long mode)
Definition: filestuff.c:283
agent_loaded_p
int agent_loaded_p(void)
Definition: agent.c:77
regcache_raw_supply
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1004
inf_child_prepare_to_store
static void inf_child_prepare_to_store(struct target_ops *self, struct regcache *regcache)
Definition: inf-child.c:111
target_ops::to_terminal_inferior
void(* to_terminal_inferior)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:562
target_ops::to_shortname
const char * to_shortname
Definition: target.h:415
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
target_ops::to_magic
int to_magic
Definition: target.h:1261
regcache
Definition: regcache.h:232
gdb_wait.h
inf_child_fileio_readlink
static char * inf_child_fileio_readlink(struct target_ops *self, struct inferior *inf, const char *filename, int *target_errno)
Definition: inf-child.c:337
target_ops::to_supports_non_stop
int(* to_supports_non_stop)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:676
memory_insert_breakpoint
int memory_insert_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: mem-break.c:87
inf-child.h
target_ops::to_has_all_memory
int(* to_has_all_memory)(struct target_ops *)
Definition: target.h:657
target_ops::to_fileio_unlink
int(* to_fileio_unlink)(struct target_ops *, struct inferior *inf, const char *filename, int *target_errno)
Definition: target.h:926
child_terminal_init
void child_terminal_init(struct target_ops *self)
Definition: inflow.c:197
target_preopen
void target_preopen(int from_tty)
Definition: target.c:2121
target_ops::to_use_agent
int(* to_use_agent)(struct target_ops *, int use) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1104
filestuff.h
detach_fork
static int detach_fork
Definition: infrun.c:154
target_ops::to_prepare_to_store
void(* to_prepare_to_store)(struct target_ops *, struct regcache *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:461
target_ops::to_store_registers
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:459
memory_remove_breakpoint
int memory_remove_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt, enum remove_bp_reason reason)
Definition: mem-break.c:94
target_ops::to_has_registers
int(* to_has_registers)(struct target_ops *)
Definition: target.h:660
TARGET_WAITKIND_STOPPED
Definition: waitstatus.h:35
inf_child_can_use_agent
static int inf_child_can_use_agent(struct target_ops *self)
Definition: inf-child.c:378
error
void error(const char *fmt,...)
Definition: errors.c:38
target_ops::to_fileio_readlink
char *(* to_fileio_readlink)(struct target_ops *, struct inferior *inf, const char *filename, int *target_errno)
Definition: target.h:936
target_ops::to_terminal_info
void(* to_terminal_info)(struct target_ops *, const char *, int) TARGET_DEFAULT_FUNC(default_terminal_info)
Definition: target.h:568
target_ops::to_post_startup_inferior
void(* to_post_startup_inferior)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:582
target_ops::to_can_use_agent
int(* to_can_use_agent)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1108