gdb/inferior.h

   1 /* Variables that describe the inferior process running under GDB:
   2    Where it is, why it stopped, and how to step it.
   3
   4    Copyright (C) 1986-2021 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   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
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  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.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #if !defined (INFERIOR_H)
  22 #define INFERIOR_H 1
  23
  24 #include <exception>
  25 #include <list>
  26
  27 struct target_waitstatus;
  28 struct frame_info;
  29 struct ui_file;
  30 struct type;
  31 struct gdbarch;
  32 struct regcache;
  33 struct ui_out;
  34 struct terminal_info;
  35 struct target_desc_info;
  36 struct inferior;
  37 struct thread_info;
  38
  39 /* For bpstat.  */
  40 #include "breakpoint.h"
  41
  42 /* For enum gdb_signal.  */
  43 #include "target.h"
  44
  45 /* For struct frame_id.  */
  46 #include "frame.h"
  47
  48 /* For gdb_environ.  */
  49 #include "gdbsupport/environ.h"
  50
  51 #include "progspace.h"
  52 #include "registry.h"
  53
  54 #include "symfile-add-flags.h"
  55 #include "gdbsupport/refcounted-object.h"
  56 #include "gdbsupport/forward-scope-exit.h"
  57 #include "gdbsupport/gdb_unique_ptr.h"
  58 #include "gdbsupport/intrusive_list.h"
  59
  60 #include "gdbsupport/common-inferior.h"
  61 #include "gdbthread.h"
  62
  63 #include "process-stratum-target.h"
  64 #include "displaced-stepping.h"
  65
  66 struct infcall_suspend_state;
  67 struct infcall_control_state;
  68
  69 extern void restore_infcall_suspend_state (struct infcall_suspend_state *);
  70 extern void restore_infcall_control_state (struct infcall_control_state *);
  71
  72 /* A deleter for infcall_suspend_state that calls
  73    restore_infcall_suspend_state.  */
  74 struct infcall_suspend_state_deleter
  75 {
  76   void operator() (struct infcall_suspend_state *state) const
  77   {
  78     try
  79       {
  80         restore_infcall_suspend_state (state);
  81       }
  82     catch (const gdb_exception_error &e)
  83       {
  84         /* If we are restoring the inferior state due to an exception,
  85            some error message will be printed.  So, only warn the user
  86            when we cannot restore during normal execution.  */
  87         bool unwinding;
  88 #if __cpp_lib_uncaught_exceptions
  89         unwinding = std::uncaught_exceptions () > 0;
  90 #else
  91         unwinding = std::uncaught_exception ();
  92 #endif
  93         if (!unwinding)
  94           warning (_("Failed to restore inferior state: %s"), e.what ());
  95       }
  96   }
  97 };
  98
  99 /* A unique_ptr specialization for infcall_suspend_state.  */
 100 typedef std::unique_ptr<infcall_suspend_state, infcall_suspend_state_deleter>
 101     infcall_suspend_state_up;
 102
 103 extern infcall_suspend_state_up save_infcall_suspend_state ();
 104
 105 /* A deleter for infcall_control_state that calls
 106    restore_infcall_control_state.  */
 107 struct infcall_control_state_deleter
 108 {
 109   void operator() (struct infcall_control_state *state) const
 110   {
 111     restore_infcall_control_state (state);
 112   }
 113 };
 114
 115 /* A unique_ptr specialization for infcall_control_state.  */
 116 typedef std::unique_ptr<infcall_control_state, infcall_control_state_deleter>
 117     infcall_control_state_up;
 118
 119 extern infcall_control_state_up save_infcall_control_state ();
 120
 121 extern void discard_infcall_suspend_state (struct infcall_suspend_state *);
 122 extern void discard_infcall_control_state (struct infcall_control_state *);
 123
 124 extern readonly_detached_regcache *
 125   get_infcall_suspend_state_regcache (struct infcall_suspend_state *);
 126
 127 extern void set_sigint_trap (void);
 128
 129 extern void clear_sigint_trap (void);
 130
 131 /* Collected pid, tid, etc. of the debugged inferior.  When there's
 132    no inferior, inferior_ptid.pid () will be 0.  */
 133
 134 extern ptid_t inferior_ptid;
 135
 136 extern void generic_mourn_inferior (void);
 137
 138 extern CORE_ADDR unsigned_pointer_to_address (struct gdbarch *gdbarch,
 139                                               struct type *type,
 140                                               const gdb_byte *buf);
 141 extern void unsigned_address_to_pointer (struct gdbarch *gdbarch,
 142                                          struct type *type, gdb_byte *buf,
 143                                          CORE_ADDR addr);
 144 extern CORE_ADDR signed_pointer_to_address (struct gdbarch *gdbarch,
 145                                             struct type *type,
 146                                             const gdb_byte *buf);
 147 extern void address_to_signed_pointer (struct gdbarch *gdbarch,
 148                                        struct type *type, gdb_byte *buf,
 149                                        CORE_ADDR addr);
 150
 151 extern void reopen_exec_file (void);
 152
 153 /* From misc files */
 154
 155 extern void default_print_registers_info (struct gdbarch *gdbarch,
 156                                           struct ui_file *file,
 157                                           struct frame_info *frame,
 158                                           int regnum, int all);
 159
 160 /* Default implementation of gdbarch_print_float_info.  Print
 161    the values of all floating point registers.  */
 162
 163 extern void default_print_float_info (struct gdbarch *gdbarch,
 164                                       struct ui_file *file,
 165                                       struct frame_info *frame,
 166                                       const char *args);
 167
 168 extern void child_terminal_info (struct target_ops *self, const char *, int);
 169
 170 extern void child_terminal_ours (struct target_ops *self);
 171
 172 extern void child_terminal_ours_for_output (struct target_ops *self);
 173
 174 extern void child_terminal_inferior (struct target_ops *self);
 175
 176 extern void child_terminal_save_inferior (struct target_ops *self);
 177
 178 extern void child_terminal_init (struct target_ops *self);
 179
 180 extern void child_terminal_init_with_pgrp (int pgrp);
 181
 182 extern void child_pass_ctrlc (struct target_ops *self);
 183
 184 extern void child_interrupt (struct target_ops *self);
 185
 186 /* From fork-child.c */
 187
 188 /* Helper function to call STARTUP_INFERIOR with PID and NUM_TRAPS.
 189    This function already calls set_executing.  Return the ptid_t from
 190    STARTUP_INFERIOR.  */
 191 extern ptid_t gdb_startup_inferior (pid_t pid, int num_traps);
 192
 193 /* From infcmd.c */
 194
 195 /* Initial inferior setup.  Determines the exec file is not yet known,
 196    takes any necessary post-attaching actions, fetches the target
 197    description and syncs the shared library list.  */
 198
 199 extern void setup_inferior (int from_tty);
 200
 201 extern void post_create_inferior (int from_tty);
 202
 203 extern void attach_command (const char *, int);
 204
 205 extern const char *get_inferior_args (void);
 206
 207 extern void set_inferior_args (const char *);
 208
 209 extern void set_inferior_args_vector (int, char **);
 210
 211 extern void registers_info (const char *, int);
 212
 213 extern void continue_1 (int all_threads);
 214
 215 extern void interrupt_target_1 (bool all_threads);
 216
 217 using delete_longjmp_breakpoint_cleanup
 218   = FORWARD_SCOPE_EXIT (delete_longjmp_breakpoint);
 219
 220 extern void detach_command (const char *, int);
 221
 222 extern void notice_new_inferior (struct thread_info *, bool, int);
 223
 224 extern struct value *get_return_value (struct value *function,
 225                                        struct type *value_type);
 226
 227 /* Prepare for execution command.  TARGET is the target that will run
 228    the command.  BACKGROUND determines whether this is a foreground
 229    (synchronous) or background (asynchronous) command.  */
 230
 231 extern void prepare_execution_command (struct target_ops *target,
 232                                        int background);
 233
 234 /* Nonzero if stopped due to completion of a stack dummy routine.  */
 235
 236 extern enum stop_stack_kind stop_stack_dummy;
 237
 238 /* Nonzero if program stopped due to a random (unexpected) signal in
 239    inferior process.  */
 240
 241 extern int stopped_by_random_signal;
 242
 243 /* Print notices on inferior events (attach, detach, etc.), set with
 244    `set print inferior-events'.  */
 245 extern bool print_inferior_events;
 246
 247 /* Anything but NO_STOP_QUIETLY means we expect a trap and the caller
 248    will handle it themselves.  STOP_QUIETLY is used when running in
 249    the shell before the child program has been exec'd and when running
 250    through shared library loading.  STOP_QUIETLY_REMOTE is used when
 251    setting up a remote connection; it is like STOP_QUIETLY_NO_SIGSTOP
 252    except that there is no need to hide a signal.  */
 253
 254 /* STOP_QUIETLY_NO_SIGSTOP is used to handle a tricky situation with attach.
 255    When doing an attach, the kernel stops the debuggee with a SIGSTOP.
 256    On newer GNU/Linux kernels (>= 2.5.61) the handling of SIGSTOP for
 257    a ptraced process has changed.  Earlier versions of the kernel
 258    would ignore these SIGSTOPs, while now SIGSTOP is treated like any
 259    other signal, i.e. it is not muffled.
 260
 261    If the gdb user does a 'continue' after the 'attach', gdb passes
 262    the global variable stop_signal (which stores the signal from the
 263    attach, SIGSTOP) to the ptrace(PTRACE_CONT,...)  call.  This is
 264    problematic, because the kernel doesn't ignore such SIGSTOP
 265    now.  I.e. it is reported back to gdb, which in turn presents it
 266    back to the user.
 267
 268    To avoid the problem, we use STOP_QUIETLY_NO_SIGSTOP, which allows
 269    gdb to clear the value of stop_signal after the attach, so that it
 270    is not passed back down to the kernel.  */
 271
 272 enum stop_kind
 273   {
 274     NO_STOP_QUIETLY = 0,
 275     STOP_QUIETLY,
 276     STOP_QUIETLY_REMOTE,
 277     STOP_QUIETLY_NO_SIGSTOP
 278   };
 279
 280 \f
 281 /* Possible values for gdbarch_call_dummy_location.  */
 282 #define ON_STACK 1
 283 #define AT_ENTRY_POINT 4
 284
 285 /* Base class for target-specific inferior data.  */
 286
 287 struct private_inferior
 288 {
 289   virtual ~private_inferior () = 0;
 290 };
 291
 292 /* Inferior process specific part of `struct infcall_control_state'.
 293
 294    Inferior thread counterpart is `struct thread_control_state'.  */
 295
 296 struct inferior_control_state
 297 {
 298   inferior_control_state ()
 299     : stop_soon (NO_STOP_QUIETLY)
 300   {
 301   }
 302
 303   explicit inferior_control_state (enum stop_kind when)
 304     : stop_soon (when)
 305   {
 306   }
 307
 308   /* See the definition of stop_kind above.  */
 309   enum stop_kind stop_soon;
 310 };
 311
 312 /* Return a pointer to the current inferior.  */
 313 extern inferior *current_inferior ();
 314
 315 extern void set_current_inferior (inferior *);
 316
 317 /* Switch inferior (and program space) to INF, and switch to no thread
 318    selected.  */
 319 extern void switch_to_inferior_no_thread (inferior *inf);
 320
 321 /* GDB represents the state of each program execution with an object
 322    called an inferior.  An inferior typically corresponds to a process
 323    but is more general and applies also to targets that do not have a
 324    notion of processes.  Each run of an executable creates a new
 325    inferior, as does each attachment to an existing process.
 326    Inferiors have unique internal identifiers that are different from
 327    target process ids.  Each inferior may in turn have multiple
 328    threads running in it.
 329
 330    Inferiors are intrusively refcounted objects.  Unlike thread
 331    objects, being the user-selected inferior is considered a strong
 332    reference and is thus accounted for in the inferior object's
 333    refcount (see set_current_inferior).  When GDB needs to remember
 334    the selected inferior to later restore it, GDB temporarily bumps
 335    the inferior object's refcount, to prevent something deleting the
 336    inferior object before reverting back (e.g., due to a
 337    "remove-inferiors" command (see
 338    scoped_restore_current_inferior).  All other inferior
 339    references are considered weak references.  Inferiors are always
 340    listed exactly once in the inferior list, so placing an inferior in
 341    the inferior list is an implicit, not counted strong reference.  */
 342
 343 class inferior : public refcounted_object,
 344                  public intrusive_list_node<inferior>
 345 {
 346 public:
 347   explicit inferior (int pid);
 348   ~inferior ();
 349
 350   /* Returns true if we can delete this inferior.  */
 351   bool deletable () const { return refcount () == 0; }
 352
 353   /* Push T in this inferior's target stack.  */
 354   void push_target (struct target_ops *t)
 355   { m_target_stack.push (t); }
 356
 357   /* An overload that deletes the target on failure.  */
 358   void push_target (target_ops_up &&t)
 359   {
 360     m_target_stack.push (t.get ());
 361     t.release ();
 362   }
 363
 364   /* Unpush T from this inferior's target stack.  */
 365   int unpush_target (struct target_ops *t);
 366
 367   /* Returns true if T is pushed in this inferior's target stack.  */
 368   bool target_is_pushed (target_ops *t)
 369   { return m_target_stack.is_pushed (t); }
 370
 371   /* Find the target beneath T in this inferior's target stack.  */
 372   target_ops *find_target_beneath (const target_ops *t)
 373   { return m_target_stack.find_beneath (t); }
 374
 375   /* Return the target at the top of this inferior's target stack.  */
 376   target_ops *top_target ()
 377   { return m_target_stack.top (); }
 378
 379   /* Return the target at process_stratum level in this inferior's
 380      target stack.  */
 381   struct process_stratum_target *process_target ()
 382   { return (process_stratum_target *) m_target_stack.at (process_stratum); }
 383
 384   /* Return the target at STRATUM in this inferior's target stack.  */
 385   target_ops *target_at (enum strata stratum)
 386   { return m_target_stack.at (stratum); }
 387
 388   bool has_execution ()
 389   { return target_has_execution (this); }
 390
 391   /* This inferior's thread list, sorted by creation order.  */
 392   intrusive_list<thread_info> thread_list;
 393
 394   /* Returns a range adapter covering the inferior's threads,
 395      including exited threads.  Used like this:
 396
 397        for (thread_info *thr : inf->threads ())
 398          { .... }
 399   */
 400   inf_threads_range threads ()
 401   { return inf_threads_range (this->thread_list.begin ()); }
 402
 403   /* Returns a range adapter covering the inferior's non-exited
 404      threads.  Used like this:
 405
 406        for (thread_info *thr : inf->non_exited_threads ())
 407          { .... }
 408   */
 409   inf_non_exited_threads_range non_exited_threads ()
 410   { return inf_non_exited_threads_range (this->thread_list.begin ()); }
 411
 412   /* Like inferior::threads(), but returns a range adapter that can be
 413      used with range-for, safely.  I.e., it is safe to delete the
 414      currently-iterated thread, like this:
 415
 416      for (thread_info *t : inf->threads_safe ())
 417        if (some_condition ())
 418          delete f;
 419   */
 420   inline safe_inf_threads_range threads_safe ()
 421   { return safe_inf_threads_range (this->thread_list.begin ()); }
 422
 423   /* Delete all threads in the thread list.  If SILENT, exit threads
 424      silently.  */
 425   void clear_thread_list (bool silent);
 426
 427   /* Continuations-related methods.  A continuation is an std::function
 428      to be called to finish the execution of a command when running
 429      GDB asynchronously.  A continuation is executed after any thread
 430      of this inferior stops.  Continuations are used by the attach
 431      command and the remote target when a new inferior is detected.  */
 432   void add_continuation (std::function<void ()> &&cont);
 433   void do_all_continuations ();
 434
 435   /* Set/get file name for default use for standard in/out in the
 436      inferior.  On Unix systems, we try to make TERMINAL_NAME the
 437      inferior's controlling terminal.  If TERMINAL_NAME is nullptr or
 438      the empty string, then the inferior inherits GDB's terminal (or
 439      GDBserver's if spawning a remote process).  */
 440   void set_tty (const char *terminal_name);
 441   const char *tty ();
 442
 443   /* Convenient handle (GDB inferior id).  Unique across all
 444      inferiors.  */
 445   int num = 0;
 446
 447   /* Actual target inferior id, usually, a process id.  This matches
 448      the ptid_t.pid member of threads of this inferior.  */
 449   int pid = 0;
 450   /* True if the PID was actually faked by GDB.  */
 451   bool fake_pid_p = false;
 452
 453   /* The highest thread number this inferior ever had.  */
 454   int highest_thread_num = 0;
 455
 456   /* State of GDB control of inferior process execution.
 457      See `struct inferior_control_state'.  */
 458   inferior_control_state control;
 459
 460   /* True if this was an auto-created inferior, e.g. created from
 461      following a fork; false, if this inferior was manually added by
 462      the user, and we should not attempt to prune it
 463      automatically.  */
 464   bool removable = false;
 465
 466   /* The address space bound to this inferior.  */
 467   struct address_space *aspace = NULL;
 468
 469   /* The program space bound to this inferior.  */
 470   struct program_space *pspace = NULL;
 471
 472   /* The arguments string to use when running.  */
 473   gdb::unique_xmalloc_ptr<char> args;
 474
 475   /* The size of elements in argv.  */
 476   int argc = 0;
 477
 478   /* The vector version of arguments.  If ARGC is nonzero,
 479      then we must compute ARGS from this (via the target).
 480      This is always coming from main's argv and therefore
 481      should never be freed.  */
 482   char **argv = NULL;
 483
 484   /* The current working directory that will be used when starting
 485      this inferior.  */
 486   gdb::unique_xmalloc_ptr<char> cwd;
 487
 488   /* The terminal state as set by the last target_terminal::terminal_*
 489      call.  */
 490   target_terminal_state terminal_state = target_terminal_state::is_ours;
 491
 492   /* Environment to use for running inferior,
 493      in format described in environ.h.  */
 494   gdb_environ environment;
 495
 496   /* True if this child process was attached rather than forked.  */
 497   bool attach_flag = false;
 498
 499   /* If this inferior is a vfork child, then this is the pointer to
 500      its vfork parent, if GDB is still attached to it.  */
 501   inferior *vfork_parent = NULL;
 502
 503   /* If this process is a vfork parent, this is the pointer to the
 504      child.  Since a vfork parent is left frozen by the kernel until
 505      the child execs or exits, a process can only have one vfork child
 506      at a given time.  */
 507   inferior *vfork_child = NULL;
 508
 509   /* True if this inferior should be detached when it's vfork sibling
 510      exits or execs.  */
 511   bool pending_detach = false;
 512
 513   /* True if this inferior is a vfork parent waiting for a vfork child
 514      not under our control to be done with the shared memory region,
 515      either by exiting or execing.  */
 516   bool waiting_for_vfork_done = false;
 517
 518   /* True if we're in the process of detaching from this inferior.  */
 519   bool detaching = false;
 520
 521   /* True if setup_inferior wasn't called for this inferior yet.
 522      Until that is done, we must not access inferior memory or
 523      registers, as we haven't determined the target
 524      architecture/description.  */
 525   bool needs_setup = false;
 526
 527   /* True when we are reading the library list of the inferior during an
 528      attach or handling a fork child.  */
 529   bool in_initial_library_scan = false;
 530
 531   /* Private data used by the target vector implementation.  */
 532   std::unique_ptr<private_inferior> priv;
 533
 534   /* HAS_EXIT_CODE is true if the inferior exited with an exit code.
 535      In this case, the EXIT_CODE field is also valid.  */
 536   bool has_exit_code = false;
 537   LONGEST exit_code = 0;
 538
 539   /* Default flags to pass to the symbol reading functions.  These are
 540      used whenever a new objfile is created.  */
 541   symfile_add_flags symfile_flags = 0;
 542
 543   /* Info about an inferior's target description (if it's fetched; the
 544      user supplied description's filename, if any; etc.).  */
 545   target_desc_info *tdesc_info = NULL;
 546
 547   /* The architecture associated with the inferior through the
 548      connection to the target.
 549
 550      The architecture vector provides some information that is really
 551      a property of the inferior, accessed through a particular target:
 552      ptrace operations; the layout of certain RSP packets; the
 553      solib_ops vector; etc.  To differentiate architecture accesses to
 554      per-inferior/target properties from
 555      per-thread/per-frame/per-objfile properties, accesses to
 556      per-inferior/target properties should be made through
 557      this gdbarch.  */
 558   struct gdbarch *gdbarch = NULL;
 559
 560   /* Data related to displaced stepping.  */
 561   displaced_step_inferior_state displaced_step_state;
 562
 563   /* Per inferior data-pointers required by other GDB modules.  */
 564   REGISTRY_FIELDS;
 565
 566 private:
 567   /* The inferior's target stack.  */
 568   target_stack m_target_stack;
 569
 570   /* The name of terminal device to use for I/O.  */
 571   gdb::unique_xmalloc_ptr<char> m_terminal;
 572
 573   /* The list of continuations.  */
 574   std::list<std::function<void ()>> m_continuations;
 575 };
 576
 577 /* Keep a registry of per-inferior data-pointers required by other GDB
 578    modules.  */
 579
 580 DECLARE_REGISTRY (inferior);
 581
 582 /* Add an inferior to the inferior list, print a message that a new
 583    inferior is found, and return the pointer to the new inferior.
 584    Caller may use this pointer to initialize the private inferior
 585    data.  */
 586 extern struct inferior *add_inferior (int pid);
 587
 588 /* Same as add_inferior, but don't print new inferior notifications to
 589    the CLI.  */
 590 extern struct inferior *add_inferior_silent (int pid);
 591
 592 extern void delete_inferior (struct inferior *todel);
 593
 594 /* Delete an existing inferior list entry, due to inferior detaching.  */
 595 extern void detach_inferior (inferior *inf);
 596
 597 extern void exit_inferior (inferior *inf);
 598
 599 extern void exit_inferior_silent (inferior *inf);
 600
 601 extern void exit_inferior_num_silent (int num);
 602
 603 extern void inferior_appeared (struct inferior *inf, int pid);
 604
 605 /* Search function to lookup an inferior of TARG by target 'pid'.  */
 606 extern struct inferior *find_inferior_pid (process_stratum_target *targ,
 607                                            int pid);
 608
 609 /* Search function to lookup an inferior of TARG whose pid is equal to
 610    'ptid.pid'. */
 611 extern struct inferior *find_inferior_ptid (process_stratum_target *targ,
 612                                             ptid_t ptid);
 613
 614 /* Search function to lookup an inferior by GDB 'num'.  */
 615 extern struct inferior *find_inferior_id (int num);
 616
 617 /* Find an inferior bound to PSPACE, giving preference to the current
 618    inferior.  */
 619 extern struct inferior *
 620   find_inferior_for_program_space (struct program_space *pspace);
 621
 622 /* Returns true if the inferior list is not empty.  */
 623 extern int have_inferiors (void);
 624
 625 /* Returns the number of live inferiors running on PROC_TARGET (real
 626    live processes with execution).  */
 627 extern int number_of_live_inferiors (process_stratum_target *proc_target);
 628
 629 /* Returns true if there are any live inferiors in the inferior list
 630    (not cores, not executables, real live processes).  */
 631 extern int have_live_inferiors (void);
 632
 633 /* Save/restore the current inferior.  */
 634
 635 class scoped_restore_current_inferior
 636 {
 637 public:
 638   scoped_restore_current_inferior ()
 639     : m_saved_inf (current_inferior ())
 640   {}
 641
 642   ~scoped_restore_current_inferior ()
 643   { set_current_inferior (m_saved_inf); }
 644
 645   DISABLE_COPY_AND_ASSIGN (scoped_restore_current_inferior);
 646
 647 private:
 648   inferior *m_saved_inf;
 649 };
 650
 651
 652 /* Traverse all inferiors.  */
 653
 654 extern intrusive_list<inferior> inferior_list;
 655
 656 /* Pull in the internals of the inferiors ranges and iterators.  Must
 657    be done after struct inferior is defined.  */
 658 #include "inferior-iter.h"
 659
 660 /* Return a range that can be used to walk over all inferiors
 661    inferiors, with range-for, safely.  I.e., it is safe to delete the
 662    currently-iterated inferior.  When combined with range-for, this
 663    allow convenient patterns like this:
 664
 665      for (inferior *inf : all_inferiors_safe ())
 666        if (some_condition ())
 667          delete inf;
 668 */
 669
 670 inline all_inferiors_safe_range
 671 all_inferiors_safe ()
 672 {
 673   return {};
 674 }
 675
 676 /* Returns a range representing all inferiors, suitable to use with
 677    range-for, like this:
 678
 679    for (inferior *inf : all_inferiors ())
 680      [...]
 681 */
 682
 683 inline all_inferiors_range
 684 all_inferiors (process_stratum_target *proc_target = nullptr)
 685 {
 686   return all_inferiors_range (proc_target, inferior_list);
 687 }
 688
 689 /* Return a range that can be used to walk over all inferiors with PID
 690    not zero, with range-for.  */
 691
 692 inline all_non_exited_inferiors_range
 693 all_non_exited_inferiors (process_stratum_target *proc_target = nullptr)
 694 {
 695   return all_non_exited_inferiors_range (proc_target, inferior_list);
 696 }
 697
 698 /* Prune away automatically added inferiors that aren't required
 699    anymore.  */
 700 extern void prune_inferiors (void);
 701
 702 extern int number_of_inferiors (void);
 703
 704 extern struct inferior *add_inferior_with_spaces (void);
 705
 706 /* Print the current selected inferior.  */
 707 extern void print_selected_inferior (struct ui_out *uiout);
 708
 709 #endif /* !defined (INFERIOR_H) */