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, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 5 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 6 2011 Free Software Foundation, Inc. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #if !defined (INFERIOR_H) 24 #define INFERIOR_H 1 25 26 struct target_waitstatus; 27 struct frame_info; 28 struct ui_file; 29 struct type; 30 struct gdbarch; 31 struct regcache; 32 struct ui_out; 33 struct terminal_info; 34 35 #define FAKE_PROCESS_ID -777 36 37 /* For bpstat. */ 38 #include "breakpoint.h" 39 40 /* For enum target_signal. */ 41 #include "target.h" 42 43 /* For struct frame_id. */ 44 #include "frame.h" 45 46 #include "progspace.h" 47 48 struct infcall_suspend_state; 49 struct infcall_control_state; 50 51 extern struct infcall_suspend_state *save_infcall_suspend_state (void); 52 extern struct infcall_control_state *save_infcall_control_state (void); 53 54 extern void restore_infcall_suspend_state (struct infcall_suspend_state *); 55 extern void restore_infcall_control_state (struct infcall_control_state *); 56 57 extern struct cleanup *make_cleanup_restore_infcall_suspend_state 58 (struct infcall_suspend_state *); 59 extern struct cleanup *make_cleanup_restore_infcall_control_state 60 (struct infcall_control_state *); 61 62 extern void discard_infcall_suspend_state (struct infcall_suspend_state *); 63 extern void discard_infcall_control_state (struct infcall_control_state *); 64 65 extern struct regcache * 66 get_infcall_suspend_state_regcache (struct infcall_suspend_state *); 67 68 /* The -1 ptid, often used to indicate either an error condition 69 or a "don't care" condition, i.e, "run all threads." */ 70 extern ptid_t minus_one_ptid; 71 72 /* The null or zero ptid, often used to indicate no process. */ 73 extern ptid_t null_ptid; 74 75 /* Attempt to find and return an existing ptid with the given PID, LWP, 76 and TID components. If none exists, create a new one and return 77 that. */ 78 ptid_t ptid_build (int pid, long lwp, long tid); 79 80 /* Find/Create a ptid from just a pid. */ 81 ptid_t pid_to_ptid (int pid); 82 83 /* Fetch the pid (process id) component from a ptid. */ 84 int ptid_get_pid (ptid_t ptid); 85 86 /* Fetch the lwp (lightweight process) component from a ptid. */ 87 long ptid_get_lwp (ptid_t ptid); 88 89 /* Fetch the tid (thread id) component from a ptid. */ 90 long ptid_get_tid (ptid_t ptid); 91 92 /* Compare two ptids to see if they are equal. */ 93 extern int ptid_equal (ptid_t p1, ptid_t p2); 94 95 /* Return true if PTID represents a process id. */ 96 extern int ptid_is_pid (ptid_t ptid); 97 98 /* Returns true if PTID matches filter FILTER. FILTER can be the wild 99 card MINUS_ONE_PTID (all ptid match it); can be a ptid representing 100 a process (ptid_is_pid returns true), in which case, all lwps and 101 threads of that given process match, lwps and threads of other 102 processes do not; or, it can represent a specific thread, in which 103 case, only that thread will match true. PTID must represent a 104 specific LWP or THREAD, it can never be a wild card. */ 105 106 extern int ptid_match (ptid_t ptid, ptid_t filter); 107 108 /* Save value of inferior_ptid so that it may be restored by 109 a later call to do_cleanups(). Returns the struct cleanup 110 pointer needed for later doing the cleanup. */ 111 extern struct cleanup * save_inferior_ptid (void); 112 113 extern void set_sigint_trap (void); 114 115 extern void clear_sigint_trap (void); 116 117 /* Set/get file name for default use for standard in/out in the inferior. */ 118 119 extern void set_inferior_io_terminal (const char *terminal_name); 120 extern const char *get_inferior_io_terminal (void); 121 122 /* Collected pid, tid, etc. of the debugged inferior. When there's 123 no inferior, PIDGET (inferior_ptid) will be 0. */ 124 125 extern ptid_t inferior_ptid; 126 127 /* Are we simulating synchronous execution? This is used in async gdb 128 to implement the 'run', 'continue' etc commands, which will not 129 redisplay the prompt until the execution is actually over. */ 130 extern int sync_execution; 131 132 /* Inferior environment. */ 133 134 extern void clear_proceed_status (void); 135 136 extern void proceed (CORE_ADDR, enum target_signal, int); 137 138 extern int sched_multi; 139 140 /* When set, stop the 'step' command if we enter a function which has 141 no line number information. The normal behavior is that we step 142 over such function. */ 143 extern int step_stop_if_no_debug; 144 145 /* If set, the inferior should be controlled in non-stop mode. In 146 this mode, each thread is controlled independently. Execution 147 commands apply only to the selected thread by default, and stop 148 events stop only the thread that had the event -- the other threads 149 are kept running freely. */ 150 extern int non_stop; 151 152 /* If set (default), when following a fork, GDB will detach from one 153 the fork branches, child or parent. Exactly which branch is 154 detached depends on 'set follow-fork-mode' setting. */ 155 extern int detach_fork; 156 157 extern void generic_mourn_inferior (void); 158 159 extern void terminal_save_ours (void); 160 161 extern void terminal_ours (void); 162 163 extern CORE_ADDR unsigned_pointer_to_address (struct gdbarch *gdbarch, 164 struct type *type, 165 const gdb_byte *buf); 166 extern void unsigned_address_to_pointer (struct gdbarch *gdbarch, 167 struct type *type, gdb_byte *buf, 168 CORE_ADDR addr); 169 extern CORE_ADDR signed_pointer_to_address (struct gdbarch *gdbarch, 170 struct type *type, 171 const gdb_byte *buf); 172 extern void address_to_signed_pointer (struct gdbarch *gdbarch, 173 struct type *type, gdb_byte *buf, 174 CORE_ADDR addr); 175 176 extern void wait_for_inferior (int treat_exec_as_sigtrap); 177 178 extern void prepare_for_detach (void); 179 180 extern void fetch_inferior_event (void *); 181 182 extern void init_wait_for_inferior (void); 183 184 extern void close_exec_file (void); 185 186 extern void reopen_exec_file (void); 187 188 /* The `resume' routine should only be called in special circumstances. 189 Normally, use `proceed', which handles a lot of bookkeeping. */ 190 191 extern void resume (int, enum target_signal); 192 193 /* From misc files */ 194 195 extern void default_print_registers_info (struct gdbarch *gdbarch, 196 struct ui_file *file, 197 struct frame_info *frame, 198 int regnum, int all); 199 200 extern void child_terminal_info (char *, int); 201 202 extern void term_info (char *, int); 203 204 extern void terminal_ours_for_output (void); 205 206 extern void terminal_inferior (void); 207 208 extern void terminal_init_inferior (void); 209 210 extern void terminal_init_inferior_with_pgrp (int pgrp); 211 212 /* From fork-child.c */ 213 214 extern int fork_inferior (char *, char *, char **, 215 void (*)(void), 216 void (*)(int), void (*)(void), char *); 217 218 219 extern void startup_inferior (int); 220 221 extern char *construct_inferior_arguments (int, char **); 222 223 /* From infrun.c */ 224 225 extern int debug_infrun; 226 227 extern int stop_on_solib_events; 228 229 extern void start_remote (int from_tty); 230 231 extern void normal_stop (void); 232 233 extern int signal_stop_state (int); 234 235 extern int signal_print_state (int); 236 237 extern int signal_pass_state (int); 238 239 extern int signal_stop_update (int, int); 240 241 extern int signal_print_update (int, int); 242 243 extern int signal_pass_update (int, int); 244 245 extern void get_last_target_status(ptid_t *ptid, 246 struct target_waitstatus *status); 247 248 extern void follow_inferior_reset_breakpoints (void); 249 250 /* Throw an error indicating the current thread is running. */ 251 extern void error_is_running (void); 252 253 /* Calls error_is_running if the current thread is running. */ 254 extern void ensure_not_running (void); 255 256 void set_step_info (struct frame_info *frame, struct symtab_and_line sal); 257 258 /* From infcmd.c */ 259 260 extern void post_create_inferior (struct target_ops *, int); 261 262 extern void attach_command (char *, int); 263 264 extern char *get_inferior_args (void); 265 266 extern void set_inferior_args (char *); 267 268 extern void set_inferior_args_vector (int, char **); 269 270 extern void registers_info (char *, int); 271 272 extern void nexti_command (char *, int); 273 274 extern void stepi_command (char *, int); 275 276 extern void continue_1 (int all_threads); 277 278 extern void continue_command (char *, int); 279 280 extern void interrupt_target_command (char *args, int from_tty); 281 282 extern void interrupt_target_1 (int all_threads); 283 284 extern void delete_longjmp_breakpoint_cleanup (void *arg); 285 286 extern void detach_command (char *, int); 287 288 extern void notice_new_inferior (ptid_t, int, int); 289 290 /* Address at which inferior stopped. */ 291 292 extern CORE_ADDR stop_pc; 293 294 /* Nonzero if stopped due to completion of a stack dummy routine. */ 295 296 extern enum stop_stack_kind stop_stack_dummy; 297 298 /* Nonzero if program stopped due to a random (unexpected) signal in 299 inferior process. */ 300 301 extern int stopped_by_random_signal; 302 303 /* STEP_OVER_ALL means step over all subroutine calls. 304 STEP_OVER_UNDEBUGGABLE means step over calls to undebuggable functions. 305 STEP_OVER_NONE means don't step over any subroutine calls. */ 306 307 enum step_over_calls_kind 308 { 309 STEP_OVER_NONE, 310 STEP_OVER_ALL, 311 STEP_OVER_UNDEBUGGABLE 312 }; 313 314 /* Anything but NO_STOP_QUIETLY means we expect a trap and the caller 315 will handle it themselves. STOP_QUIETLY is used when running in 316 the shell before the child program has been exec'd and when running 317 through shared library loading. STOP_QUIETLY_REMOTE is used when 318 setting up a remote connection; it is like STOP_QUIETLY_NO_SIGSTOP 319 except that there is no need to hide a signal. */ 320 321 /* It is also used after attach, due to attaching to a process. This 322 is a bit trickier. When doing an attach, the kernel stops the 323 debuggee with a SIGSTOP. On newer GNU/Linux kernels (>= 2.5.61) 324 the handling of SIGSTOP for a ptraced process has changed. Earlier 325 versions of the kernel would ignore these SIGSTOPs, while now 326 SIGSTOP is treated like any other signal, i.e. it is not muffled. 327 328 If the gdb user does a 'continue' after the 'attach', gdb passes 329 the global variable stop_signal (which stores the signal from the 330 attach, SIGSTOP) to the ptrace(PTRACE_CONT,...) call. This is 331 problematic, because the kernel doesn't ignore such SIGSTOP 332 now. I.e. it is reported back to gdb, which in turn presents it 333 back to the user. 334 335 To avoid the problem, we use STOP_QUIETLY_NO_SIGSTOP, which allows 336 gdb to clear the value of stop_signal after the attach, so that it 337 is not passed back down to the kernel. */ 338 339 enum stop_kind 340 { 341 NO_STOP_QUIETLY = 0, 342 STOP_QUIETLY, 343 STOP_QUIETLY_REMOTE, 344 STOP_QUIETLY_NO_SIGSTOP 345 }; 346 347 /* Reverse execution. */ 348 enum exec_direction_kind 349 { 350 EXEC_FORWARD, 351 EXEC_REVERSE, 352 EXEC_ERROR 353 }; 354 355 extern enum exec_direction_kind execution_direction; 356 357 /* Save register contents here when executing a "finish" command or are 358 about to pop a stack dummy frame, if-and-only-if proceed_to_finish is set. 359 Thus this contains the return value from the called function (assuming 360 values are returned in a register). */ 361 362 extern struct regcache *stop_registers; 363 364 /* True if we are debugging displaced stepping. */ 365 extern int debug_displaced; 366 367 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */ 368 void displaced_step_dump_bytes (struct ui_file *file, 369 const gdb_byte *buf, size_t len); 370 371 struct displaced_step_closure *get_displaced_step_closure_by_addr (CORE_ADDR addr); 372 373 /* Possible values for gdbarch_call_dummy_location. */ 374 #define ON_STACK 1 375 #define AT_ENTRY_POINT 4 376 #define AT_SYMBOL 5 377 378 /* If STARTUP_WITH_SHELL is set, GDB's "run" 379 will attempts to start up the debugee under a shell. 380 This is in order for argument-expansion to occur. E.g., 381 (gdb) run * 382 The "*" gets expanded by the shell into a list of files. 383 While this is a nice feature, it turns out to interact badly 384 with some of the catch-fork/catch-exec features we have added. 385 In particular, if the shell does any fork/exec's before 386 the exec of the target program, that can confuse GDB. 387 To disable this feature, set STARTUP_WITH_SHELL to 0. 388 To enable this feature, set STARTUP_WITH_SHELL to 1. 389 The catch-exec traps expected during start-up will 390 be 1 if target is not started up with a shell, 2 if it is. 391 - RT 392 If you disable this, you need to decrement 393 START_INFERIOR_TRAPS_EXPECTED in tm.h. */ 394 #define STARTUP_WITH_SHELL 1 395 #if !defined(START_INFERIOR_TRAPS_EXPECTED) 396 #define START_INFERIOR_TRAPS_EXPECTED 2 397 #endif 398 399 struct private_inferior; 400 401 /* Inferior process specific part of `struct infcall_control_state'. 402 403 Inferior thread counterpart is `struct thread_control_state'. */ 404 405 struct inferior_control_state 406 { 407 /* See the definition of stop_kind above. */ 408 enum stop_kind stop_soon; 409 }; 410 411 /* Inferior process specific part of `struct infcall_suspend_state'. 412 413 Inferior thread counterpart is `struct thread_suspend_state'. */ 414 415 struct inferior_suspend_state 416 { 417 }; 418 419 /* GDB represents the state of each program execution with an object 420 called an inferior. An inferior typically corresponds to a process 421 but is more general and applies also to targets that do not have a 422 notion of processes. Each run of an executable creates a new 423 inferior, as does each attachment to an existing process. 424 Inferiors have unique internal identifiers that are different from 425 target process ids. Each inferior may in turn have multiple 426 threads running in it. */ 427 428 struct inferior 429 { 430 /* Pointer to next inferior in singly-linked list of inferiors. */ 431 struct inferior *next; 432 433 /* Convenient handle (GDB inferior id). Unique across all 434 inferiors. */ 435 int num; 436 437 /* Actual target inferior id, usually, a process id. This matches 438 the ptid_t.pid member of threads of this inferior. */ 439 int pid; 440 441 /* State of GDB control of inferior process execution. 442 See `struct inferior_control_state'. */ 443 struct inferior_control_state control; 444 445 /* State of inferior process to restore after GDB is done with an inferior 446 call. See `struct inferior_suspend_state'. */ 447 struct inferior_suspend_state suspend; 448 449 /* True if this was an auto-created inferior, e.g. created from 450 following a fork; false, if this inferior was manually added by 451 the user, and we should not attempt to prune it 452 automatically. */ 453 int removable; 454 455 /* The address space bound to this inferior. */ 456 struct address_space *aspace; 457 458 /* The program space bound to this inferior. */ 459 struct program_space *pspace; 460 461 /* The arguments string to use when running. */ 462 char *args; 463 464 /* The size of elements in argv. */ 465 int argc; 466 467 /* The vector version of arguments. If ARGC is nonzero, 468 then we must compute ARGS from this (via the target). 469 This is always coming from main's argv and therefore 470 should never be freed. */ 471 char **argv; 472 473 /* The name of terminal device to use for I/O. */ 474 char *terminal; 475 476 /* Environment to use for running inferior, 477 in format described in environ.h. */ 478 struct gdb_environ *environment; 479 480 /* Nonzero if this child process was attached rather than 481 forked. */ 482 int attach_flag; 483 484 /* If this inferior is a vfork child, then this is the pointer to 485 its vfork parent, if GDB is still attached to it. */ 486 struct inferior *vfork_parent; 487 488 /* If this process is a vfork parent, this is the pointer to the 489 child. Since a vfork parent is left frozen by the kernel until 490 the child execs or exits, a process can only have one vfork child 491 at a given time. */ 492 struct inferior *vfork_child; 493 494 /* True if this inferior should be detached when it's vfork sibling 495 exits or execs. */ 496 int pending_detach; 497 498 /* True if this inferior is a vfork parent waiting for a vfork child 499 not under our control to be done with the shared memory region, 500 either by exiting or execing. */ 501 int waiting_for_vfork_done; 502 503 /* True if we're in the process of detaching from this inferior. */ 504 int detaching; 505 506 /* What is left to do for an execution command after any thread of 507 this inferior stops. For continuations associated with a 508 specific thread, see `struct thread_info'. */ 509 struct continuation *continuations; 510 511 /* Private data used by the target vector implementation. */ 512 struct private_inferior *private; 513 514 /* HAS_EXIT_CODE is true if the inferior exited with an exit code. 515 In this case, the EXIT_CODE field is also valid. */ 516 int has_exit_code; 517 LONGEST exit_code; 518 519 /* We keep a count of the number of times the user has requested a 520 particular syscall to be tracked, and pass this information to the 521 target. This lets capable targets implement filtering directly. */ 522 523 /* Number of times that "any" syscall is requested. */ 524 int any_syscall_count; 525 526 /* Count of each system call. */ 527 VEC(int) *syscalls_counts; 528 529 /* This counts all syscall catch requests, so we can readily determine 530 if any catching is necessary. */ 531 int total_syscalls_count; 532 533 /* Per inferior data-pointers required by other GDB modules. */ 534 void **data; 535 unsigned num_data; 536 }; 537 538 /* Keep a registry of per-inferior data-pointers required by other GDB 539 modules. */ 540 541 extern const struct inferior_data *register_inferior_data (void); 542 extern const struct inferior_data *register_inferior_data_with_cleanup 543 (void (*cleanup) (struct inferior *, void *)); 544 extern void clear_inferior_data (struct inferior *inf); 545 extern void set_inferior_data (struct inferior *inf, 546 const struct inferior_data *data, void *value); 547 extern void *inferior_data (struct inferior *inf, 548 const struct inferior_data *data); 549 550 /* Create an empty inferior list, or empty the existing one. */ 551 extern void init_inferior_list (void); 552 553 /* Add an inferior to the inferior list, print a message that a new 554 inferior is found, and return the pointer to the new inferior. 555 Caller may use this pointer to initialize the private inferior 556 data. */ 557 extern struct inferior *add_inferior (int pid); 558 559 /* Same as add_inferior, but don't print new inferior notifications to 560 the CLI. */ 561 extern struct inferior *add_inferior_silent (int pid); 562 563 /* Delete an existing inferior list entry, due to inferior exit. */ 564 extern void delete_inferior (int pid); 565 566 extern void delete_inferior_1 (struct inferior *todel, int silent); 567 568 /* Same as delete_inferior, but don't print new inferior notifications 569 to the CLI. */ 570 extern void delete_inferior_silent (int pid); 571 572 /* Delete an existing inferior list entry, due to inferior detaching. */ 573 extern void detach_inferior (int pid); 574 575 extern void exit_inferior (int pid); 576 577 extern void exit_inferior_silent (int pid); 578 579 extern void exit_inferior_num_silent (int num); 580 581 extern void inferior_appeared (struct inferior *inf, int pid); 582 583 /* Get rid of all inferiors. */ 584 extern void discard_all_inferiors (void); 585 586 /* Translate the integer inferior id (GDB's homegrown id, not the system's) 587 into a "pid" (which may be overloaded with extra inferior information). */ 588 extern int gdb_inferior_id_to_pid (int); 589 590 /* Translate a target 'pid' into the integer inferior id (GDB's 591 homegrown id, not the system's). */ 592 extern int pid_to_gdb_inferior_id (int pid); 593 594 /* Boolean test for an already-known pid. */ 595 extern int in_inferior_list (int pid); 596 597 /* Boolean test for an already-known inferior id (GDB's homegrown id, 598 not the system's). */ 599 extern int valid_gdb_inferior_id (int num); 600 601 /* Search function to lookup an inferior by target 'pid'. */ 602 extern struct inferior *find_inferior_pid (int pid); 603 604 /* Search function to lookup an inferior by GDB 'num'. */ 605 extern struct inferior *find_inferior_id (int num); 606 607 /* Find an inferior bound to PSPACE. */ 608 extern struct inferior * 609 find_inferior_for_program_space (struct program_space *pspace); 610 611 /* Inferior iterator function. 612 613 Calls a callback function once for each inferior, so long as the 614 callback function returns false. If the callback function returns 615 true, the iteration will end and the current inferior will be 616 returned. This can be useful for implementing a search for a 617 inferior with arbitrary attributes, or for applying some operation 618 to every inferior. 619 620 It is safe to delete the iterated inferior from the callback. */ 621 extern struct inferior *iterate_over_inferiors (int (*) (struct inferior *, 622 void *), 623 void *); 624 625 /* Returns true if the inferior list is not empty. */ 626 extern int have_inferiors (void); 627 628 /* Returns true if there are any live inferiors in the inferior list 629 (not cores, not executables, real live processes). */ 630 extern int have_live_inferiors (void); 631 632 /* Return a pointer to the current inferior. It is an error to call 633 this if there is no current inferior. */ 634 extern struct inferior *current_inferior (void); 635 636 extern void set_current_inferior (struct inferior *); 637 638 extern struct cleanup *save_current_inferior (void); 639 640 extern struct inferior *inferior_list; 641 642 /* Prune away automatically added inferiors that aren't required 643 anymore. */ 644 extern void prune_inferiors (void); 645 646 extern int number_of_inferiors (void); 647 648 extern struct inferior *add_inferior_with_spaces (void); 649 650 extern void update_observer_mode (void); 651 652 #endif /* !defined (INFERIOR_H) */ 653