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