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