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