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