]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/inferior.h
Automatic date update in version.in
[thirdparty/binutils-gdb.git] / gdb / inferior.h
CommitLineData
c906108c
SS
1/* Variables that describe the inferior process running under GDB:
2 Where it is, why it stopped, and how to step it.
1bac305b 3
d01e8234 4 Copyright (C) 1986-2025 Free Software Foundation, Inc.
c906108c 5
c5aa993b 6 This file is part of GDB.
c906108c 7
c5aa993b
JM
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
a9762ec7 10 the Free Software Foundation; either version 3 of the License, or
c5aa993b 11 (at your option) any later version.
c906108c 12
c5aa993b
JM
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
c906108c 17
c5aa993b 18 You should have received a copy of the GNU General Public License
a9762ec7 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c 20
cc709640
TT
21#ifndef GDB_INFERIOR_H
22#define GDB_INFERIOR_H
c906108c 23
1e7c1b22 24#include <exception>
c4c493de 25#include <list>
1e7c1b22 26
da3331ec 27struct target_waitstatus;
bd2b40ac 28class frame_info_ptr;
da3331ec
AC
29struct ui_file;
30struct type;
67a2b77e 31struct gdbarch;
72cec141 32struct regcache;
b77209e0 33struct ui_out;
7e1789f5 34struct terminal_info;
6ecd4729 35struct target_desc_info;
3a3fd0fd 36struct inferior;
00431a78 37struct thread_info;
67a2b77e 38
c906108c
SS
39/* For bpstat. */
40#include "breakpoint.h"
41
2ea28649 42/* For enum gdb_signal. */
c906108c
SS
43#include "target.h"
44
aa0cd9c1
AC
45/* For struct frame_id. */
46#include "frame.h"
47
9a6c7d9c 48/* For gdb_environ. */
268a13a5 49#include "gdbsupport/environ.h"
9a6c7d9c 50
6c95b8df 51#include "progspace.h"
8e260fc0 52#include "registry.h"
6c95b8df 53
b15cc25c 54#include "symfile-add-flags.h"
268a13a5
TT
55#include "gdbsupport/refcounted-object.h"
56#include "gdbsupport/forward-scope-exit.h"
277474ee 57#include "gdbsupport/gdb_unique_ptr.h"
08bdefb5 58#include "gdbsupport/intrusive_list.h"
b15cc25c 59
268a13a5 60#include "gdbsupport/common-inferior.h"
08036331 61#include "gdbthread.h"
2090129c 62
5b6d1e4f 63#include "process-stratum-target.h"
c7acb87b 64#include "displaced-stepping.h"
5b6d1e4f 65
57a99efc 66#include "gdbsupport/unordered_map.h"
922cc93d 67
16c381f0
JK
68struct infcall_suspend_state;
69struct infcall_control_state;
7a292a7a 70
16c381f0
JK
71extern void restore_infcall_suspend_state (struct infcall_suspend_state *);
72extern void restore_infcall_control_state (struct infcall_control_state *);
b89667eb 73
c7c4d3fa
TT
74/* A deleter for infcall_suspend_state that calls
75 restore_infcall_suspend_state. */
76struct infcall_suspend_state_deleter
77{
78 void operator() (struct infcall_suspend_state *state) const
79 {
ee3c5f89
PW
80 try
81 {
82 restore_infcall_suspend_state (state);
83 }
84 catch (const gdb_exception_error &e)
85 {
86 /* If we are restoring the inferior state due to an exception,
87 some error message will be printed. So, only warn the user
88 when we cannot restore during normal execution. */
c1222117 89 if (std::uncaught_exceptions () == 0)
ee3c5f89
PW
90 warning (_("Failed to restore inferior state: %s"), e.what ());
91 }
c7c4d3fa
TT
92 }
93};
94
95/* A unique_ptr specialization for infcall_suspend_state. */
96typedef std::unique_ptr<infcall_suspend_state, infcall_suspend_state_deleter>
97 infcall_suspend_state_up;
98
cb524840
TT
99extern infcall_suspend_state_up save_infcall_suspend_state ();
100
c7c4d3fa
TT
101/* A deleter for infcall_control_state that calls
102 restore_infcall_control_state. */
103struct infcall_control_state_deleter
104{
105 void operator() (struct infcall_control_state *state) const
106 {
107 restore_infcall_control_state (state);
108 }
109};
110
111/* A unique_ptr specialization for infcall_control_state. */
112typedef std::unique_ptr<infcall_control_state, infcall_control_state_deleter>
113 infcall_control_state_up;
b89667eb 114
cb524840
TT
115extern infcall_control_state_up save_infcall_control_state ();
116
16c381f0
JK
117extern void discard_infcall_suspend_state (struct infcall_suspend_state *);
118extern void discard_infcall_control_state (struct infcall_control_state *);
7a292a7a 119
daf6667d 120extern readonly_detached_regcache *
16c381f0 121 get_infcall_suspend_state_regcache (struct infcall_suspend_state *);
b89667eb 122
a14ed312 123extern void set_sigint_trap (void);
c906108c 124
a14ed312 125extern void clear_sigint_trap (void);
c906108c 126
39f77062 127/* Collected pid, tid, etc. of the debugged inferior. When there's
e99b03dc 128 no inferior, inferior_ptid.pid () will be 0. */
c906108c 129
39f77062 130extern ptid_t inferior_ptid;
c906108c 131
a14ed312 132extern void generic_mourn_inferior (void);
c906108c 133
9898f801
UW
134extern CORE_ADDR unsigned_pointer_to_address (struct gdbarch *gdbarch,
135 struct type *type,
b60c417a 136 const gdb_byte *buf);
9898f801
UW
137extern void unsigned_address_to_pointer (struct gdbarch *gdbarch,
138 struct type *type, gdb_byte *buf,
ac2e2ef7 139 CORE_ADDR addr);
9898f801
UW
140extern CORE_ADDR signed_pointer_to_address (struct gdbarch *gdbarch,
141 struct type *type,
b60c417a 142 const gdb_byte *buf);
9898f801
UW
143extern void address_to_signed_pointer (struct gdbarch *gdbarch,
144 struct type *type, gdb_byte *buf,
ac2e2ef7 145 CORE_ADDR addr);
4478b372 146
a14ed312 147extern void reopen_exec_file (void);
c906108c 148
c906108c
SS
149/* From misc files */
150
0ab7a791
AC
151extern void default_print_registers_info (struct gdbarch *gdbarch,
152 struct ui_file *file,
8480a37e 153 const frame_info_ptr &frame,
0ab7a791 154 int regnum, int all);
666e11c5 155
cc86d1cb
YQ
156/* Default implementation of gdbarch_print_float_info. Print
157 the values of all floating point registers. */
158
159extern void default_print_float_info (struct gdbarch *gdbarch,
160 struct ui_file *file,
8480a37e 161 const frame_info_ptr &frame,
cc86d1cb
YQ
162 const char *args);
163
c1dc47f5
TT
164/* Try to determine whether TTY is GDB's input terminal. Returns
165 TRIBOOL_UNKNOWN if we can't tell. */
166
167extern tribool is_gdb_terminal (const char *tty);
168
169/* Helper for sharing_input_terminal. Try to determine whether pid
170 PID is using the same TTY for input as GDB is. Returns
171 TRIBOOL_UNKNOWN if we can't tell. */
172
173extern tribool sharing_input_terminal (int pid);
174
c88afe9c
TT
175/* The type of the function that is called when SIGINT is handled. */
176
177typedef void c_c_handler_ftype (int);
178
179/* Install a new SIGINT handler in a host-dependent way. The previous
180 handler is returned. It is fine to pass SIG_IGN for FN, but not
181 SIG_DFL. */
182
183extern c_c_handler_ftype *install_sigint_handler (c_c_handler_ftype *fn);
184
0a4f40a2 185extern void child_terminal_info (struct target_ops *self, const char *, int);
c906108c 186
d6b64346
PA
187extern void child_terminal_ours (struct target_ops *self);
188
189extern void child_terminal_ours_for_output (struct target_ops *self);
c906108c 190
d6b64346 191extern void child_terminal_inferior (struct target_ops *self);
c906108c 192
e671cd59
PA
193extern void child_terminal_save_inferior (struct target_ops *self);
194
d6b64346 195extern void child_terminal_init (struct target_ops *self);
c906108c 196
e671cd59
PA
197extern void child_pass_ctrlc (struct target_ops *self);
198
199extern void child_interrupt (struct target_ops *self);
200
c906108c
SS
201/* From fork-child.c */
202
2090129c
SDJ
203/* Helper function to call STARTUP_INFERIOR with PID and NUM_TRAPS.
204 This function already calls set_executing. Return the ptid_t from
205 STARTUP_INFERIOR. */
206extern ptid_t gdb_startup_inferior (pid_t pid, int num_traps);
c906108c 207
c906108c
SS
208/* From infcmd.c */
209
6efcd9a8
PA
210/* Initial inferior setup. Determines the exec file is not yet known,
211 takes any necessary post-attaching actions, fetches the target
212 description and syncs the shared library list. */
213
214extern void setup_inferior (int from_tty);
215
3cb6bc13
SM
216/* Common actions to take after creating any sort of inferior, by any
217 means (running, attaching, connecting, et cetera). The target
218 should be stopped.
219
220 If SET_PSPACE_SOLIB_OPS is true, initialize the program space's solib
221 provider using the current inferior's architecture. */
222
223extern void post_create_inferior (int from_tty, bool set_pspace_solib_ops);
281b533b 224
0b39b52e 225extern void attach_command (const char *, int);
c906108c 226
1d12d88f 227extern void registers_info (const char *, int);
36dc181b 228
77ebaa5a
VP
229extern void continue_1 (int all_threads);
230
5b6d1e4f 231extern void interrupt_target_1 (bool all_threads);
77ebaa5a 232
5419bdae
TT
233using delete_longjmp_breakpoint_cleanup
234 = FORWARD_SCOPE_EXIT (delete_longjmp_breakpoint);
186c406b 235
981a3fb3 236extern void detach_command (const char *, int);
6418d433 237
8a82de58 238extern void notice_new_inferior (struct thread_info *, bool, int);
1941c569 239
e6b36367
LS
240/* Return the value of the result of a function at the end of a 'finish'
241 command/BP. If the result's value cannot be retrieved, return NULL.
242
243 FUNC_SYMBOL is the symbol of the function being returned from. FUNCTION is
244 a value containing the address of the function. */
245
246extern struct value *get_return_value (struct symbol *func_symbol,
247 struct value *function);
cc72b2a2 248
329ea579
PA
249/* Prepare for execution command. TARGET is the target that will run
250 the command. BACKGROUND determines whether this is a foreground
251 (synchronous) or background (asynchronous) command. */
252
253extern void prepare_execution_command (struct target_ops *target,
254 int background);
255
c906108c
SS
256/* Nonzero if stopped due to completion of a stack dummy routine. */
257
aa7d318d 258extern enum stop_stack_kind stop_stack_dummy;
c906108c
SS
259
260/* Nonzero if program stopped due to a random (unexpected) signal in
261 inferior process. */
262
263extern int stopped_by_random_signal;
264
f67c0c91
SDJ
265/* Print notices on inferior events (attach, detach, etc.), set with
266 `set print inferior-events'. */
491144b5 267extern bool print_inferior_events;
f67c0c91 268
b0f4b84b
DJ
269/* Anything but NO_STOP_QUIETLY means we expect a trap and the caller
270 will handle it themselves. STOP_QUIETLY is used when running in
271 the shell before the child program has been exec'd and when running
272 through shared library loading. STOP_QUIETLY_REMOTE is used when
273 setting up a remote connection; it is like STOP_QUIETLY_NO_SIGSTOP
274 except that there is no need to hide a signal. */
c54cfec8 275
7c0bc051
DE
276/* STOP_QUIETLY_NO_SIGSTOP is used to handle a tricky situation with attach.
277 When doing an attach, the kernel stops the debuggee with a SIGSTOP.
278 On newer GNU/Linux kernels (>= 2.5.61) the handling of SIGSTOP for
279 a ptraced process has changed. Earlier versions of the kernel
280 would ignore these SIGSTOPs, while now SIGSTOP is treated like any
281 other signal, i.e. it is not muffled.
282
c54cfec8
EZ
283 If the gdb user does a 'continue' after the 'attach', gdb passes
284 the global variable stop_signal (which stores the signal from the
285 attach, SIGSTOP) to the ptrace(PTRACE_CONT,...) call. This is
286 problematic, because the kernel doesn't ignore such SIGSTOP
1777feb0 287 now. I.e. it is reported back to gdb, which in turn presents it
c54cfec8 288 back to the user.
7c0bc051 289
c54cfec8
EZ
290 To avoid the problem, we use STOP_QUIETLY_NO_SIGSTOP, which allows
291 gdb to clear the value of stop_signal after the attach, so that it
292 is not passed back down to the kernel. */
293
294enum stop_kind
295 {
296 NO_STOP_QUIETLY = 0,
297 STOP_QUIETLY,
b0f4b84b 298 STOP_QUIETLY_REMOTE,
c54cfec8
EZ
299 STOP_QUIETLY_NO_SIGSTOP
300 };
c906108c 301
c906108c 302\f
c906108c 303
089354bb
SM
304/* Base class for target-specific inferior data. */
305
306struct private_inferior
307{
308 virtual ~private_inferior () = 0;
309};
b77209e0 310
16c381f0
JK
311/* Inferior process specific part of `struct infcall_control_state'.
312
313 Inferior thread counterpart is `struct thread_control_state'. */
314
315struct inferior_control_state
316{
ee841dd8
TT
317 inferior_control_state ()
318 : stop_soon (NO_STOP_QUIETLY)
319 {
320 }
321
322 explicit inferior_control_state (enum stop_kind when)
323 : stop_soon (when)
324 {
325 }
326
16c381f0
JK
327 /* See the definition of stop_kind above. */
328 enum stop_kind stop_soon;
329};
330
7b21ae94
SM
331/* Initialize the inferior-related global state. */
332extern void initialize_inferiors ();
333
3a3fd0fd
PA
334/* Return a pointer to the current inferior. */
335extern inferior *current_inferior ();
336
337extern void set_current_inferior (inferior *);
338
db2d40f7
PA
339/* Switch inferior (and program space) to INF, and switch to no thread
340 selected. */
341extern void switch_to_inferior_no_thread (inferior *inf);
342
348da456
SM
343/* Ensure INF is the current inferior.
344
345 If the current inferior was changed, return an RAII object that will
346 restore the original current context. */
6b09f134 347extern std::optional<scoped_restore_current_thread> maybe_switch_inferior
348da456
SM
348 (inferior *inf);
349
65016032
SM
350/* Info about an inferior's target description. There's one of these
351 for each inferior. */
352
353struct target_desc_info
354{
f9b67752 355 /* Returns true if this target description information has been supplied by
5a19bfd6
SM
356 the user. */
357 bool from_user_p ()
358 { return !this->filename.empty (); }
359
65016032
SM
360 /* A flag indicating that a description has already been fetched
361 from the target, so it should not be queried again. */
362 bool fetched = false;
363
364 /* The description fetched from the target, or NULL if the target
365 did not supply any description. Only valid when
366 FETCHED is set. Only the description initialization
367 code should access this; normally, the description should be
368 accessed through the gdbarch object. */
369 const struct target_desc *tdesc = nullptr;
370
371 /* If not empty, the filename to read a target description from, as set by
372 "set tdesc filename ...".
373
374 If empty, there is not filename specified by the user. */
375 std::string filename;
376};
377
b77209e0
PA
378/* GDB represents the state of each program execution with an object
379 called an inferior. An inferior typically corresponds to a process
380 but is more general and applies also to targets that do not have a
381 notion of processes. Each run of an executable creates a new
382 inferior, as does each attachment to an existing process.
383 Inferiors have unique internal identifiers that are different from
384 target process ids. Each inferior may in turn have multiple
3a3fd0fd
PA
385 threads running in it.
386
387 Inferiors are intrusively refcounted objects. Unlike thread
388 objects, being the user-selected inferior is considered a strong
389 reference and is thus accounted for in the inferior object's
390 refcount (see set_current_inferior). When GDB needs to remember
391 the selected inferior to later restore it, GDB temporarily bumps
392 the inferior object's refcount, to prevent something deleting the
393 inferior object before reverting back (e.g., due to a
394 "remove-inferiors" command (see
09e3c4ca 395 scoped_restore_current_inferior). All other inferior
3a3fd0fd
PA
396 references are considered weak references. Inferiors are always
397 listed exactly once in the inferior list, so placing an inferior in
398 the inferior list is an implicit, not counted strong reference. */
399
08bdefb5
PA
400class inferior : public refcounted_object,
401 public intrusive_list_node<inferior>
b77209e0 402{
0550c955
PA
403public:
404 explicit inferior (int pid);
405 ~inferior ();
406
3a3fd0fd
PA
407 /* Returns true if we can delete this inferior. */
408 bool deletable () const { return refcount () == 0; }
409
5b6d1e4f
PA
410 /* Push T in this inferior's target stack. */
411 void push_target (struct target_ops *t)
412 { m_target_stack.push (t); }
413
02980c56
SM
414 /* An overload that deletes the target on failure. */
415 void push_target (target_ops_up &&t)
416 {
417 m_target_stack.push (t.get ());
418 t.release ();
419 }
420
5b6d1e4f 421 /* Unpush T from this inferior's target stack. */
a66f7298 422 int unpush_target (struct target_ops *t);
5b6d1e4f
PA
423
424 /* Returns true if T is pushed in this inferior's target stack. */
d1d3123c 425 bool target_is_pushed (const target_ops *t) const
5b6d1e4f
PA
426 { return m_target_stack.is_pushed (t); }
427
428 /* Find the target beneath T in this inferior's target stack. */
429 target_ops *find_target_beneath (const target_ops *t)
430 { return m_target_stack.find_beneath (t); }
431
432 /* Return the target at the top of this inferior's target stack. */
433 target_ops *top_target ()
434 { return m_target_stack.top (); }
435
c8181f70
AB
436 /* Unpush all targets except the dummy target from m_target_stack. As
437 targets are removed from m_target_stack their reference count is
438 decremented, which may cause a target to close. */
439 void pop_all_targets ()
440 { pop_all_targets_above (dummy_stratum); }
441
442 /* Unpush all targets above STRATUM from m_target_stack. As targets are
443 removed from m_target_stack their reference count is decremented,
444 which may cause a target to close. */
445 void pop_all_targets_above (enum strata stratum);
446
447 /* Unpush all targets at and above STRATUM from m_target_stack. As
448 targets are removed from m_target_stack their reference count is
449 decremented, which may cause a target to close. */
450 void pop_all_targets_at_and_above (enum strata stratum);
451
5b6d1e4f
PA
452 /* Return the target at process_stratum level in this inferior's
453 target stack. */
454 struct process_stratum_target *process_target ()
455 { return (process_stratum_target *) m_target_stack.at (process_stratum); }
456
457 /* Return the target at STRATUM in this inferior's target stack. */
458 target_ops *target_at (enum strata stratum)
459 { return m_target_stack.at (stratum); }
460
5018ce90 461 bool has_execution ()
55f6301a 462 { return target_has_execution (this); }
5018ce90 463
bf809310
PA
464 /* This inferior's thread list, sorted by creation order. */
465 intrusive_list<thread_info> thread_list;
08036331 466
922cc93d
SM
467 /* A map of ptid_t to thread_info*, for average O(1) ptid_t lookup.
468 Exited threads do not appear in the map. */
57a99efc 469 gdb::unordered_map<ptid_t, thread_info *> ptid_thread_map;
922cc93d 470
08036331
PA
471 /* Returns a range adapter covering the inferior's threads,
472 including exited threads. Used like this:
473
474 for (thread_info *thr : inf->threads ())
475 { .... }
476 */
477 inf_threads_range threads ()
bf809310 478 { return inf_threads_range (this->thread_list.begin ()); }
08036331
PA
479
480 /* Returns a range adapter covering the inferior's non-exited
481 threads. Used like this:
482
483 for (thread_info *thr : inf->non_exited_threads ())
484 { .... }
485 */
486 inf_non_exited_threads_range non_exited_threads ()
bf809310 487 { return inf_non_exited_threads_range (this->thread_list.begin ()); }
08036331
PA
488
489 /* Like inferior::threads(), but returns a range adapter that can be
490 used with range-for, safely. I.e., it is safe to delete the
491 currently-iterated thread, like this:
492
493 for (thread_info *t : inf->threads_safe ())
494 if (some_condition ())
495 delete f;
496 */
497 inline safe_inf_threads_range threads_safe ()
bf809310
PA
498 { return safe_inf_threads_range (this->thread_list.begin ()); }
499
3c8af02f
SM
500 /* Find (non-exited) thread PTID of this inferior. */
501 thread_info *find_thread (ptid_t ptid);
502
604fe2d9
PA
503 /* Delete all threads in the thread list, silently. */
504 void clear_thread_list ();
08036331 505
4efeb0d3
TBA
506 /* Continuations-related methods. A continuation is an std::function
507 to be called to finish the execution of a command when running
508 GDB asynchronously. A continuation is executed after any thread
509 of this inferior stops. Continuations are used by the attach
510 command and the remote target when a new inferior is detected. */
511 void add_continuation (std::function<void ()> &&cont);
512 void do_all_continuations ();
513
4e93ea6e
SM
514 /* Set/get file name for default use for standard in/out in the inferior.
515
516 On Unix systems, we try to make TERMINAL_NAME the inferior's controlling
517 terminal.
518
519 If TERMINAL_NAME is the empty string, then the inferior inherits GDB's
520 terminal (or GDBserver's if spawning a remote process). */
521 void set_tty (std::string terminal_name);
522 const std::string &tty ();
05779d57 523
e5169525
SM
524 /* Set the argument string to use when running this inferior.
525
fd2dec2a
SM
526 An empty string can be used to represent "no arguments". */
527 void set_args (std::string args)
e5169525 528 {
fd2dec2a 529 m_args = std::move (args);
e5169525
SM
530 };
531
512ca2fc
AB
532 /* Set the argument string from some strings in ARGS. When
533 ESCAPE_SHELL_CHAR is true all special shell characters in ARGS are
534 escaped, When false only the characters that GDB sees as special will
535 be escaped. See construct_inferior_arguments for more details. */
536 void set_args (gdb::array_view<char * const> args, bool escape_shell_char);
7d3b43a1 537
e5169525
SM
538 /* Get the argument string to use when running this inferior.
539
fd2dec2a
SM
540 No arguments is represented by an empty string. */
541 const std::string &args () const
e5169525 542 {
fd2dec2a 543 return m_args;
e5169525
SM
544 }
545
90cc31c9
SM
546 /* Set the inferior current working directory.
547
11bd012e
SM
548 If CWD is empty, unset the directory. */
549 void set_cwd (std::string cwd)
90cc31c9 550 {
11bd012e 551 m_cwd = std::move (cwd);
90cc31c9
SM
552 }
553
554 /* Get the inferior current working directory.
555
11bd012e
SM
556 Return an empty string if the current working directory is not
557 specified. */
558 const std::string &cwd () const
90cc31c9 559 {
11bd012e 560 return m_cwd;
90cc31c9
SM
561 }
562
27b1f19f 563 /* Set this inferior's arch. */
72c4529c 564 void set_arch (gdbarch *arch);
27b1f19f
SM
565
566 /* Get this inferior's arch. */
567 gdbarch *arch ()
568 { return m_gdbarch; }
569
b77209e0
PA
570 /* Convenient handle (GDB inferior id). Unique across all
571 inferiors. */
0550c955 572 int num = 0;
b77209e0
PA
573
574 /* Actual target inferior id, usually, a process id. This matches
575 the ptid_t.pid member of threads of this inferior. */
0550c955 576 int pid = 0;
e714e1bf 577 /* True if the PID was actually faked by GDB. */
0550c955 578 bool fake_pid_p = false;
b77209e0 579
5d5658a1 580 /* The highest thread number this inferior ever had. */
0550c955 581 int highest_thread_num = 0;
5d5658a1 582
16c381f0
JK
583 /* State of GDB control of inferior process execution.
584 See `struct inferior_control_state'. */
ee841dd8 585 inferior_control_state control;
16c381f0 586
6c95b8df
PA
587 /* True if this was an auto-created inferior, e.g. created from
588 following a fork; false, if this inferior was manually added by
589 the user, and we should not attempt to prune it
590 automatically. */
0550c955 591 bool removable = false;
6c95b8df
PA
592
593 /* The address space bound to this inferior. */
f9582a22 594 address_space_ref_ptr aspace;
6c95b8df
PA
595
596 /* The program space bound to this inferior. */
0550c955 597 struct program_space *pspace = NULL;
6c95b8df 598
e671cd59
PA
599 /* The terminal state as set by the last target_terminal::terminal_*
600 call. */
601 target_terminal_state terminal_state = target_terminal_state::is_ours;
602
3f81c18a
VP
603 /* Environment to use for running inferior,
604 in format described in environ.h. */
9a6c7d9c 605 gdb_environ environment;
3f81c18a 606
0550c955
PA
607 /* True if this child process was attached rather than forked. */
608 bool attach_flag = false;
181e7f93 609
6c95b8df
PA
610 /* If this inferior is a vfork child, then this is the pointer to
611 its vfork parent, if GDB is still attached to it. */
0550c955 612 inferior *vfork_parent = NULL;
6c95b8df
PA
613
614 /* If this process is a vfork parent, this is the pointer to the
615 child. Since a vfork parent is left frozen by the kernel until
616 the child execs or exits, a process can only have one vfork child
617 at a given time. */
0550c955 618 inferior *vfork_child = NULL;
6c95b8df
PA
619
620 /* True if this inferior should be detached when it's vfork sibling
621 exits or execs. */
0550c955 622 bool pending_detach = false;
6c95b8df 623
6f5d514f
SM
624 /* If non-nullptr, points to a thread that called vfork and is now waiting
625 for a vfork child not under our control to be done with the shared memory
626 region, either by exiting or execing. */
627 thread_info *thread_waiting_for_vfork_done = nullptr;
6c95b8df 628
24291992 629 /* True if we're in the process of detaching from this inferior. */
9bcb1f16 630 bool detaching = false;
24291992 631
6efcd9a8
PA
632 /* True if setup_inferior wasn't called for this inferior yet.
633 Until that is done, we must not access inferior memory or
634 registers, as we haven't determined the target
635 architecture/description. */
0550c955 636 bool needs_setup = false;
6efcd9a8 637
a9deee17
PA
638 /* True if the inferior is starting up (inside startup_inferior),
639 and we're nursing it along (through the shell) until it is ready
640 to execute its first instruction. Until that is done, we must
641 not access inferior memory or registers, as we haven't determined
642 the target architecture/description. */
643 bool starting_up = false;
644
122373f7
SM
645 /* True when we are reading the library list of the inferior during an
646 attach or handling a fork child. */
647 bool in_initial_library_scan = false;
648
2a3f442d 649 /* Private data used by the process_stratum target. */
089354bb 650 std::unique_ptr<private_inferior> priv;
a96d9b2e 651
8cf64490
TT
652 /* HAS_EXIT_CODE is true if the inferior exited with an exit code.
653 In this case, the EXIT_CODE field is also valid. */
0550c955
PA
654 bool has_exit_code = false;
655 LONGEST exit_code = 0;
8cf64490 656
7dcd53a0 657 /* Default flags to pass to the symbol reading functions. These are
b15cc25c 658 used whenever a new objfile is created. */
0550c955 659 symfile_add_flags symfile_flags = 0;
7dcd53a0 660
6ecd4729
PA
661 /* Info about an inferior's target description (if it's fetched; the
662 user supplied description's filename, if any; etc.). */
79846903 663 target_desc_info tdesc_info;
6ecd4729 664
d20172fc
SM
665 /* Data related to displaced stepping. */
666 displaced_step_inferior_state displaced_step_state;
667
6c95b8df 668 /* Per inferior data-pointers required by other GDB modules. */
08b8a139 669 registry<inferior> registry_fields;
5b6d1e4f
PA
670
671private:
c8181f70
AB
672
673 /* Unpush TARGET and assert that it worked. */
674 void unpush_target_and_assert (struct target_ops *target);
675
5b6d1e4f
PA
676 /* The inferior's target stack. */
677 target_stack m_target_stack;
05779d57
PA
678
679 /* The name of terminal device to use for I/O. */
4e93ea6e 680 std::string m_terminal;
4efeb0d3
TBA
681
682 /* The list of continuations. */
683 std::list<std::function<void ()>> m_continuations;
e5169525 684
fd2dec2a
SM
685 /* The arguments string to use when running. */
686 std::string m_args;
90cc31c9
SM
687
688 /* The current working directory that will be used when starting
689 this inferior. */
11bd012e 690 std::string m_cwd;
27b1f19f
SM
691
692 /* The architecture associated with the inferior through the
693 connection to the target.
694
695 The architecture vector provides some information that is really
696 a property of the inferior, accessed through a particular target:
697 ptrace operations; the layout of certain RSP packets; the
698 solib_ops vector; etc. To differentiate architecture accesses to
699 per-inferior/target properties from
700 per-thread/per-frame/per-objfile properties, accesses to
701 per-inferior/target properties should be made through
702 this gdbarch. */
703 gdbarch *m_gdbarch = nullptr;
b77209e0
PA
704};
705
b77209e0
PA
706/* Add an inferior to the inferior list, print a message that a new
707 inferior is found, and return the pointer to the new inferior.
708 Caller may use this pointer to initialize the private inferior
709 data. */
710extern struct inferior *add_inferior (int pid);
711
712/* Same as add_inferior, but don't print new inferior notifications to
713 the CLI. */
714extern struct inferior *add_inferior_silent (int pid);
715
7a41607e 716extern void delete_inferior (struct inferior *todel);
b77209e0
PA
717
718/* Delete an existing inferior list entry, due to inferior detaching. */
bc09b0c1
SM
719extern void detach_inferior (inferior *inf);
720
9324bfea
AB
721/* Notify observers and interpreters that INF has gone away. Reset the INF
722 object back to an default, empty, state. Clear register and frame
723 caches. */
00431a78 724extern void exit_inferior (inferior *inf);
b77209e0 725
6c95b8df
PA
726extern void inferior_appeared (struct inferior *inf, int pid);
727
5b6d1e4f
PA
728/* Search function to lookup an inferior of TARG by target 'pid'. */
729extern struct inferior *find_inferior_pid (process_stratum_target *targ,
730 int pid);
82f73884 731
5b6d1e4f
PA
732/* Search function to lookup an inferior of TARG whose pid is equal to
733 'ptid.pid'. */
734extern struct inferior *find_inferior_ptid (process_stratum_target *targ,
735 ptid_t ptid);
c9657e70 736
6c95b8df
PA
737/* Search function to lookup an inferior by GDB 'num'. */
738extern struct inferior *find_inferior_id (int num);
739
32990ada
PA
740/* Find an inferior bound to PSPACE, giving preference to the current
741 inferior. */
6c95b8df
PA
742extern struct inferior *
743 find_inferior_for_program_space (struct program_space *pspace);
744
b77209e0
PA
745/* Returns true if the inferior list is not empty. */
746extern int have_inferiors (void);
747
5b6d1e4f
PA
748/* Returns the number of live inferiors running on PROC_TARGET (real
749 live processes with execution). */
750extern int number_of_live_inferiors (process_stratum_target *proc_target);
8020350c 751
c35b1492
PA
752/* Returns true if there are any live inferiors in the inferior list
753 (not cores, not executables, real live processes). */
754extern int have_live_inferiors (void);
755
5ed8105e
PA
756/* Save/restore the current inferior. */
757
758class scoped_restore_current_inferior
759{
760public:
761 scoped_restore_current_inferior ()
762 : m_saved_inf (current_inferior ())
763 {}
764
765 ~scoped_restore_current_inferior ()
766 { set_current_inferior (m_saved_inf); }
767
d6541620 768 DISABLE_COPY_AND_ASSIGN (scoped_restore_current_inferior);
5ed8105e
PA
769
770private:
771 inferior *m_saved_inf;
772};
773
cb26e4bb
TT
774/* When reading memory from an inferior, the global inferior_ptid must
775 also be set. This class arranges to save and restore the necessary
776 state for reading or writing memory, but without invalidating the
777 frame cache. */
778
779class scoped_restore_current_inferior_for_memory
780{
781public:
782
783 /* Save the current globals and switch to the given inferior and the
6d30ada8
PA
784 inferior's program space. inferior_ptid is set to point to the
785 inferior's process id (and not to any particular thread). */
786 explicit scoped_restore_current_inferior_for_memory (inferior *inf)
cb26e4bb
TT
787 : m_save_ptid (&inferior_ptid)
788 {
789 set_current_inferior (inf);
790 set_current_program_space (inf->pspace);
6d30ada8 791 inferior_ptid = ptid_t (inf->pid);
cb26e4bb
TT
792 }
793
794 DISABLE_COPY_AND_ASSIGN (scoped_restore_current_inferior_for_memory);
795
796private:
797
798 scoped_restore_current_inferior m_save_inferior;
799 scoped_restore_current_program_space m_save_progspace;
800 scoped_restore_tmpl<ptid_t> m_save_ptid;
801};
802
6c95b8df 803
c65b3e0d
PA
804/* Traverse all inferiors. */
805
08bdefb5 806extern intrusive_list<inferior> inferior_list;
c65b3e0d 807
08036331
PA
808/* Pull in the internals of the inferiors ranges and iterators. Must
809 be done after struct inferior is defined. */
810#include "inferior-iter.h"
85ad3aaf 811
08036331
PA
812/* Return a range that can be used to walk over all inferiors
813 inferiors, with range-for, safely. I.e., it is safe to delete the
814 currently-iterated inferior. When combined with range-for, this
815 allow convenient patterns like this:
85ad3aaf 816
08036331
PA
817 for (inferior *inf : all_inferiors_safe ())
818 if (some_condition ())
819 delete inf;
820*/
821
822inline all_inferiors_safe_range
823all_inferiors_safe ()
824{
12be796c 825 return all_inferiors_safe_range (nullptr, inferior_list);
08036331
PA
826}
827
828/* Returns a range representing all inferiors, suitable to use with
829 range-for, like this:
830
831 for (inferior *inf : all_inferiors ())
832 [...]
833*/
834
835inline all_inferiors_range
5b6d1e4f 836all_inferiors (process_stratum_target *proc_target = nullptr)
08036331 837{
9be25986 838 return all_inferiors_range (proc_target, inferior_list);
08036331
PA
839}
840
841/* Return a range that can be used to walk over all inferiors with PID
842 not zero, with range-for. */
843
844inline all_non_exited_inferiors_range
5b6d1e4f 845all_non_exited_inferiors (process_stratum_target *proc_target = nullptr)
08036331 846{
9be25986 847 return all_non_exited_inferiors_range (proc_target, inferior_list);
08036331 848}
6c95b8df
PA
849
850/* Prune away automatically added inferiors that aren't required
851 anymore. */
852extern void prune_inferiors (void);
853
854extern int number_of_inferiors (void);
855
a79b8f6e
VP
856extern struct inferior *add_inferior_with_spaces (void);
857
4034d0ff
AT
858/* Print the current selected inferior. */
859extern void print_selected_inferior (struct ui_out *uiout);
860
d43bd54d
US
861/* Switch to inferior NEW_INF, a new inferior, and unless
862 NO_CONNECTION is true, push the process_stratum_target of ORG_INF
863 to NEW_INF. */
864
865extern void switch_to_inferior_and_push_target
866 (inferior *new_inf, bool no_connection, inferior *org_inf);
867
b080fe54
AB
868/* Return true if ID is a valid global inferior number. */
869
870inline bool
871valid_global_inferior_id (int id)
872{
873 for (inferior *inf : all_inferiors ())
874 if (inf->num == id)
875 return true;
876 return false;
877}
878
cc709640 879#endif /* GDB_INFERIOR_H */