159 _(
"Disabling randomization of debuggee's "
160 "virtual address space is %s.\n"),
164 "virtual address space is unsupported on\n"
165 "this platform.\n"), file);
173 error (
_(
"Disabling randomization of debuggee's "
174 "virtual address space is unsupported on\n"
190 error (
_(
"Cannot change this setting while the inferior is running."));
201 _(
"Controlling the inferior in non-stop mode is %s.\n"),
219 error (
_(
"Cannot change this setting while the inferior is running."));
240 non_stop = non_stop_1 = 1;
245 (observer_mode ?
"on" :
"off"));
273 if (newval != observer_mode)
275 (newval ?
"on" :
"off"));
277 observer_mode = observer_mode_1 = newval;
297 #define SET_SIGS(nsigs,sigs,flags) \
299 int signum = (nsigs); \
300 while (signum-- > 0) \
301 if ((sigs)[signum]) \
302 (flags)[signum] = 1; \
305 #define UNSET_SIGS(nsigs,sigs,flags) \
307 int signum = (nsigs); \
308 while (signum-- > 0) \
309 if ((sigs)[signum]) \
310 (flags)[signum] = 0; \
324 #define RESUME_ALL minus_one_ptid
385 _(
"Debugger response to a program "
386 "call of fork or vfork is \"%s\".\n"),
401 ptid_t parent_ptid, child_ptid;
419 Can not resume the parent process over vfork in the foreground while\n\
420 holding the child stopped. Try \"set detach-on-fork\" or \
421 \"set schedule-multiple\".\n"));
453 _(
"Detaching after %s from child %s.\n"),
454 has_vforked ?
"vfork" :
"fork",
460 struct inferior *parent_inf, *child_inf;
534 struct inferior *parent_inf, *child_inf;
541 _(
"Attaching after %s %s to child %s.\n"),
543 has_vforked ?
"vfork" :
"fork",
558 parent_pspace = parent_inf->
pspace;
580 else if (detach_fork)
589 _(
"Detaching after fork from "
609 if (has_vforked || detach_fork)
611 child_inf->
pspace = parent_pspace;
643 int should_resume = 1;
650 struct breakpoint *step_resume_breakpoint = NULL;
651 struct breakpoint *exception_resume_breakpoint = NULL;
654 struct frame_id step_frame_id = { 0 };
698 if (follow_child && should_resume)
705 exception_resume_breakpoint
759 = step_resume_breakpoint;
764 = exception_resume_breakpoint;
775 warning (
_(
"Not resuming: switched threads "
776 "before following fork child.\n"));
792 "Unexpected pending_follow.kind %d\n",
797 return should_resume;
847 int pid = * (
int *) arg;
857 "infrun: resuming vfork parent thread %s\n",
878 int resume_parent = -1;
934 _(
"Detaching vfork parent process "
935 "%d after child exec.\n"),
941 _(
"Detaching vfork parent process "
942 "%d after child exit.\n"),
1014 if (non_stop && resume_parent != -1)
1022 "infrun: resuming vfork parent process %d\n",
1140 execd_pathname = alloca (strlen (name) + 1);
1141 strcpy (execd_pathname, name);
1153 if (follow_exec_mode_string == follow_exec_mode_new)
1457 for (state = displaced_step_inferior_states;
1459 state = state->
next)
1460 if (state->
pid == pid)
1489 for (state = displaced_step_inferior_states;
1491 state = state->
next)
1492 if (state->
pid == pid)
1495 state =
xcalloc (1,
sizeof (*state));
1498 displaced_step_inferior_states = state;
1536 *prev_next_p = it->
next;
1541 prev_next_p = &it->
next;
1569 _(
"Debugger's willingness to use displaced stepping "
1570 "to step over breakpoints is %s (currently %s).\n"),
1571 value, non_stop ?
"on" :
"off");
1574 _(
"Debugger's willingness to use displaced stepping "
1575 "to step over breakpoints is %s.\n"), value);
1621 for (i = 0; i <
len; i++)
1643 struct cleanup *old_cleanups, *ignore_cleanups;
1674 if (debug_displaced)
1676 "displaced: defering step of %s\n",
1679 new_req =
xmalloc (
sizeof (*new_req));
1681 new_req->
next = NULL;
1689 req->
next = new_req;
1698 if (debug_displaced)
1700 "displaced: stepping %s now\n",
1721 _(
"Error accessing memory address %s (%s) for "
1722 "displaced-stepping scratch space."),
1724 if (debug_displaced)
1734 original, copy, regcache);
1756 if (debug_displaced)
1784 if (debug_displaced)
1799 if (displaced == NULL)
1817 if (signal == GDB_SIGNAL_TRAP
1870 if (debug_displaced)
1872 "displaced: stepping queued %s now\n",
1877 if (debug_displaced)
1912 if (debug_displaced)
1914 "displaced: breakpoint is gone: %s, step(%d)\n",
1937 for (displaced = displaced_step_inferior_states;
1939 displaced = displaced->
next)
1946 it->
ptid = new_ptid;
1978 _(
"Mode for locking scheduler "
1979 "during execution is \"%s\".\n"),
2031 else if ((scheduler_mode == schedlock_on)
2032 || (scheduler_mode == schedlock_step && step))
2145 "infrun: resume : clear step\n");
2151 "infrun: resume (step=%d, signal=%s), "
2152 "trap_expected=%d, current thread [%s] at %s\n",
2164 if (sig != GDB_SIGNAL_0)
2182 "infrun: resume: skipping permanent breakpoint, "
2183 "deliver signal first\n");
2207 "infrun: resume: skipping permanent breakpoint\n");
2255 && sig == GDB_SIGNAL_0
2311 && sig != GDB_SIGNAL_0
2404 paddress (resume_gdbarch, actual_pc));
2433 "infrun: clear_proceed_status_thread (%s)\n",
2497 stop_after_trap = 0;
2532 return (scheduler_mode == schedlock_on
2533 || (scheduler_mode == schedlock_step
2555 if (except != current
2650 if (siggnal != GDB_SIGNAL_DEFAULT)
2663 "infrun: proceed (addr=%s, signal=%s)\n",
2686 if (step_over != NULL)
2690 "infrun: need to step-over [%s] first\n",
2883 memset (ecs, 0,
sizeof (*ecs));
2934 for (displaced = displaced_step_inferior_states;
2936 displaced = displaced->
next)
2946 *prev_next_p = it->
next;
2952 prev_next_p = &it->
next;
3052 "infrun: target_wait (%d.%ld.%ld",
3061 "infrun: %d.%ld.%ld [%s],\n",
3076 xfree (status_string);
3103 "displaced-stepping in-process while detaching");
3115 memset (ecs, 0,
sizeof (*ecs));
3150 error (
_(
"Program exited while detaching"));
3168 struct cleanup *thread_state_chain;
3172 (
gdb_stdlog,
"infrun: wait_for_inferior ()\n");
3189 memset (ecs, 0,
sizeof (*ecs));
3267 memset (ecs, 0,
sizeof (*ecs));
3398 target_last_wait_ptid =
ptid;
3715 "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
3733 stop_print_frame = 0;
3781 "infrun: Treating signal as SIGTRAP\n");
3837 if (stop_on_solib_events)
3841 stop_print_frame = 1;
3874 _(
"unhandled stop_soon: %d"), (
int) stop_soon);
3891 "infrun: TARGET_WAITKIND_EXITED\n");
3894 "infrun: TARGET_WAITKIND_SIGNALLED\n");
3946 Cannot fill $_exitsignal with the correct signal number.\n"));
3954 stop_print_frame = 0;
3983 struct regcache *child_regcache;
4013 if (debug_displaced)
4015 "displaced: write child pc from %s to %s\n",
4079 if (non_stop && !detach_fork)
4114 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
4167 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
4181 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
4229 int stopped_by_watchpoint;
4268 "infrun: stopped data address = %s\n",
4272 "infrun: (no data address available)\n");
4287 stop_print_frame = 1;
4299 stop_print_frame = 0;
4329 stop_print_frame = 1;
4374 "infrun: [%s] hit another thread's "
4375 "single-step breakpoint\n",
4386 "infrun: [%s] hit its "
4387 "single-step breakpoint\n",
4397 stopped_by_watchpoint = 0;
4403 if (stopped_by_watchpoint
4443 stop_print_frame = 1;
4495 int step_through_delay
4498 if (debug_infrun && step_through_delay)
4501 && step_through_delay)
4509 else if (step_through_delay)
4529 stop_print_frame = 1;
4543 && stopped_by_watchpoint)
4545 "infrun: no user watchpoint explains "
4546 "watchpoint SIGTRAP, ignoring\n");
4603 "infrun: delayed software breakpoint "
4604 "trap, ignoring\n");
4616 "infrun: delayed hardware breakpoint/watchpoint "
4617 "trap, ignoring\n");
4634 random_signal = !stopped_by_watchpoint;
4694 "infrun: signal arrived while stepping over "
4727 "infrun: signal may take us out of "
4728 "single-step range\n");
4749 "infrun: random signal, keep going\n");
4801 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
4807 struct value *arg_value;
4820 frame, &jmp_buf_pc))
4824 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
4825 "(!gdbarch_get_longjmp_target)\n");
4862 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
4951 stop_print_frame = 1;
4964 stop_print_frame = 0;
5012 "infrun: stepped permanent breakpoint, stopped in "
5033 "infrun: step-resume breakpoint is inserted\n");
5075 (
gdb_stdlog,
"infrun: stepping inside range [%s-%s]\n",
5120 "infrun: stepped into dynsym resolve code\n");
5122 if (pc_after_resolver)
5129 sr_sal.
pc = pc_after_resolver;
5147 "infrun: stepped into signal trampoline\n");
5173 "infrun: stepped into solib return tramp\n");
5182 sr_sal.
pc = real_stop_pc;
5302 if (real_stop_pc == 0)
5304 if (real_stop_pc != 0)
5332 if (tmp_sal.line != 0
5348 && step_stop_if_no_debug)
5424 && stop_pc_sal.
line == 0)
5428 "infrun: stepped into undebuggable function\n");
5438 if (step_stop_if_no_debug
5467 if (stop_pc_sal.
line == 0)
5491 "infrun: stepped into inlined function\n");
5536 "infrun: stepping through inlined function\n");
5555 "infrun: stepped to a different line\n");
5610 "infrun: need to finish step-over of [%s]\n",
5624 "infrun: need to step [%s] over single-step "
5653 stepping_thread = NULL;
5684 stepping_thread = tp;
5699 if (step_over != NULL)
5705 "infrun: need to step-over [%s]\n",
5719 if (stepping_thread != NULL)
5724 tp = stepping_thread;
5750 "infrun: not switching back to "
5751 "stepped thread, it has vanished\n");
5760 "infrun: switching back to stepped thread\n");
5790 "infrun: expected thread advanced also\n");
5813 "infrun: expected thread still "
5814 "hasn't advanced\n");
5861 if (stop_func_sal.
end
5970 "infrun: inserting step-resume breakpoint at %s\n",
6064 "infrun: inserting longjmp-resume breakpoint at %s\n",
6079 const struct block *b,
6099 "infrun: exception resume at %lx\n",
6100 (
unsigned long) handler);
6127 struct value *arg_value;
6139 "infrun: exception resume at %s\n",
6177 const struct block *b;
6295 else if (remove_wps)
6393 ui_out_text (uiout,
"\nProgram terminated with signal ");
6404 ui_out_text (uiout,
"The program no longer exists.\n");
6457 ui_out_text (uiout,
"\nProgram received signal ");
6477 ui_out_text (uiout,
"\nNo more reverse-execution history.\n");
6490 int do_frame_printing = 1;
6524 do_frame_printing = 0;
6535 if (do_frame_printing)
6628 "program is no longer writable.\nFurther "
6629 "execution is probably impossible.\n"));
6782 return signal_stop[signo];
6788 return signal_print[signo];
6794 return signal_program[signo];
6802 for (signo = 0; signo < (
int) GDB_SIGNAL_LAST; signo++)
6808 signal_pass[signo] = (signal_stop[signo] == 0
6809 && signal_print[signo] == 0
6810 && signal_program[signo] == 1
6811 && signal_catch[signo] == 0);
6817 int ret = signal_stop[signo];
6819 signal_stop[signo] = state;
6827 int ret = signal_print[signo];
6829 signal_print[signo] = state;
6837 int ret = signal_program[signo];
6839 signal_program[signo] = state;
6852 for (i = 0; i < GDB_SIGNAL_LAST; ++i)
6853 signal_catch[i] = info[i] > 0;
6862 "to program\tDescription\n"));
6869 int name_padding = 13 - strlen (name);
6871 if (name_padding <= 0)
6888 int digits, wordlen;
6889 int sigfirst, signum, siglast;
6890 enum gdb_signal oursig;
6893 unsigned char *sigs;
6903 nsigs = (
int) GDB_SIGNAL_LAST;
6904 sigs = (
unsigned char *) alloca (nsigs);
6905 memset (sigs, 0, nsigs);
6917 while (*argv != NULL)
6919 wordlen = strlen (*argv);
6920 for (digits = 0; isdigit ((*argv)[digits]); digits++)
6924 sigfirst = siglast = -1;
6926 if (wordlen >= 1 && !strncmp (*argv,
"all", wordlen))
6932 siglast = nsigs - 1;
6934 else if (wordlen >= 1 && !strncmp (*argv,
"stop", wordlen))
6936 SET_SIGS (nsigs, sigs, signal_stop);
6937 SET_SIGS (nsigs, sigs, signal_print);
6939 else if (wordlen >= 1 && !strncmp (*argv,
"ignore", wordlen))
6943 else if (wordlen >= 2 && !strncmp (*argv,
"print", wordlen))
6945 SET_SIGS (nsigs, sigs, signal_print);
6947 else if (wordlen >= 2 && !strncmp (*argv,
"pass", wordlen))
6949 SET_SIGS (nsigs, sigs, signal_program);
6951 else if (wordlen >= 3 && !strncmp (*argv,
"nostop", wordlen))
6955 else if (wordlen >= 3 && !strncmp (*argv,
"noignore", wordlen))
6957 SET_SIGS (nsigs, sigs, signal_program);
6959 else if (wordlen >= 4 && !strncmp (*argv,
"noprint", wordlen))
6964 else if (wordlen >= 4 && !strncmp (*argv,
"nopass", wordlen))
6968 else if (digits > 0)
6976 sigfirst = siglast = (
int)
6978 if ((*argv)[digits] ==
'-')
6983 if (sigfirst > siglast)
6994 if (oursig != GDB_SIGNAL_UNKNOWN)
6996 sigfirst = siglast = (
int) oursig;
7001 error (
_(
"Unrecognized or ambiguous flag word: \"%s\"."), *argv);
7008 for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
7010 switch ((
enum gdb_signal) signum)
7012 case GDB_SIGNAL_TRAP:
7013 case GDB_SIGNAL_INT:
7014 if (!allsigs && !sigs[signum])
7016 if (
query (
_(
"%s is used by the debugger.\n\
7017 Are you sure you want to change it? "),
7030 case GDB_SIGNAL_DEFAULT:
7031 case GDB_SIGNAL_UNKNOWN:
7043 for (signum = 0; signum < nsigs; signum++)
7054 for (; signum < nsigs; signum++)
7069 const char *text,
const char *
word)
7071 VEC (
char_ptr) *vec_signals, *vec_keywords, *return_val;
7072 static const char *
const keywords[] =
7086 vec_signals = signal_completer (ignore, text, word);
7087 vec_keywords = complete_on_enum (keywords, word, word);
7098 if (num >= 1 && num <= 15)
7099 return (
enum gdb_signal) num;
7100 error (
_(
"Only signals 1-15 are valid as numeric signals.\n\
7101 Use \"info signals\" for a list of symbolic signals."));
7112 enum gdb_signal oursig;
7120 if (oursig == GDB_SIGNAL_UNKNOWN)
7133 (
int) oursig < (
int) GDB_SIGNAL_LAST;
7134 oursig = (
enum gdb_signal) ((
int) oursig + 1))
7138 if (oursig != GDB_SIGNAL_UNKNOWN
7139 && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
7144 "to change these tables.\n"));
7155 error (
_(
"No thread selected."));
7159 error (
_(
"The current thread has terminated"));
7163 error (
_(
"Selected thread is running."));
7194 error (
_(
"Unable to read siginfo"));
7215 error (
_(
"Unable to write siginfo"));
7228 static struct value *
7287 siginfo_data, 0, len) == len)
7293 siginfo_data = NULL;
7438 warning (
_(
"Unable to restore previously selected frame."));
7480 "Unable to restore previously selected frame:\n",
7562 static const char exec_forward[] =
"forward";
7563 static const char exec_reverse[] =
"reverse";
7565 static const char *
const exec_direction_names[] = {
7577 if (!strcmp (exec_direction, exec_forward))
7579 else if (!strcmp (exec_direction, exec_reverse))
7585 error (
_(
"Target does not support this operation."));
7593 switch (execution_direction) {
7602 _(
"bogus execution_direction value: %d"),
7603 (
int) execution_direction);
7612 "of all processes is %s.\n"), value);
7632 What debugger does when program gets various signals.\n\
7633 Specify a signal as argument to print info on that signal only."));
7637 Specify how to handle signals.\n\
7638 Usage: handle SIGNAL [ACTIONS]\n\
7639 Args are signals and actions to apply to those signals.\n\
7640 If no actions are specified, the current settings for the specified signals\n\
7641 will be displayed instead.\n\
7643 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7644 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7645 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7646 The special arg \"all\" is recognized to mean all signals except those\n\
7647 used by the debugger, typically SIGTRAP and SIGINT.\n\
7649 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
7650 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
7651 Stop means reenter debugger if this signal happens (implies print).\n\
7652 Print means print a message if this signal happens.\n\
7653 Pass means let program see this signal; otherwise program doesn't know.\n\
7654 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7655 Pass and Stop may be combined.\n\
7657 Multiple signals may be specified. Signal numbers and signal names\n\
7658 may be interspersed with actions, with the actions being performed for\n\
7659 all signals cumulatively specified."));
7665 There is no `stop' command, but you can set a hook on `stop'.\n\
7666 This allows you to set a list of commands to be run each time execution\n\
7667 of the program stops."), &
cmdlist);
7670 Set inferior debugging."),
_(
"\
7671 Show inferior debugging."),
_(
"\
7672 When non-zero, inferior specific debugging is enabled."),
7678 &debug_displaced,
_(
"\
7679 Set displaced stepping debugging."),
_(
"\
7680 Show displaced stepping debugging."),
_(
"\
7681 When non-zero, displaced stepping specific debugging is enabled."),
7688 Set whether gdb controls the inferior in non-stop mode."),
_(
"\
7689 Show whether gdb controls the inferior in non-stop mode."),
_(
"\
7690 When debugging a multi-threaded program and this setting is\n\
7691 off (the default, also called all-stop mode), when one thread stops\n\
7692 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
7693 all other threads in the program while you interact with the thread of\n\
7694 interest. When you continue or step a thread, you can allow the other\n\
7695 threads to run, or have them remain stopped, but while you inspect any\n\
7696 thread's state, all threads stop.\n\
7698 In non-stop mode, when one thread stops, other threads can continue\n\
7699 to run freely. You'll be able to step each thread independently,\n\
7700 leave it stopped or free to run as needed."),
7706 numsigs = (
int) GDB_SIGNAL_LAST;
7707 signal_stop = (
unsigned char *)
xmalloc (
sizeof (signal_stop[0]) * numsigs);
7708 signal_print = (
unsigned char *)
7709 xmalloc (
sizeof (signal_print[0]) * numsigs);
7710 signal_program = (
unsigned char *)
7711 xmalloc (
sizeof (signal_program[0]) * numsigs);
7712 signal_catch = (
unsigned char *)
7713 xmalloc (
sizeof (signal_catch[0]) * numsigs);
7714 signal_pass = (
unsigned char *)
7715 xmalloc (
sizeof (signal_pass[0]) * numsigs);
7716 for (i = 0; i < numsigs; i++)
7719 signal_print[i] = 1;
7720 signal_program[i] = 1;
7721 signal_catch[i] = 0;
7726 signal_program[GDB_SIGNAL_TRAP] = 0;
7727 signal_program[GDB_SIGNAL_INT] = 0;
7730 signal_stop[GDB_SIGNAL_ALRM] = 0;
7731 signal_print[GDB_SIGNAL_ALRM] = 0;
7732 signal_stop[GDB_SIGNAL_VTALRM] = 0;
7733 signal_print[GDB_SIGNAL_VTALRM] = 0;
7734 signal_stop[GDB_SIGNAL_PROF] = 0;
7735 signal_print[GDB_SIGNAL_PROF] = 0;
7736 signal_stop[GDB_SIGNAL_CHLD] = 0;
7737 signal_print[GDB_SIGNAL_CHLD] = 0;
7738 signal_stop[GDB_SIGNAL_IO] = 0;
7739 signal_print[GDB_SIGNAL_IO] = 0;
7740 signal_stop[GDB_SIGNAL_POLL] = 0;
7741 signal_print[GDB_SIGNAL_POLL] = 0;
7742 signal_stop[GDB_SIGNAL_URG] = 0;
7743 signal_print[GDB_SIGNAL_URG] = 0;
7744 signal_stop[GDB_SIGNAL_WINCH] = 0;
7745 signal_print[GDB_SIGNAL_WINCH] = 0;
7746 signal_stop[GDB_SIGNAL_PRIO] = 0;
7747 signal_print[GDB_SIGNAL_PRIO] = 0;
7753 signal_stop[GDB_SIGNAL_LWP] = 0;
7754 signal_print[GDB_SIGNAL_LWP] = 0;
7755 signal_stop[GDB_SIGNAL_WAITING] = 0;
7756 signal_print[GDB_SIGNAL_WAITING] = 0;
7757 signal_stop[GDB_SIGNAL_CANCEL] = 0;
7758 signal_print[GDB_SIGNAL_CANCEL] = 0;
7764 &stop_on_solib_events,
_(
"\
7765 Set stopping for shared library events."),
_(
"\
7766 Show stopping for shared library events."),
_(
"\
7767 If nonzero, gdb will give control to the user when the dynamic linker\n\
7768 notifies gdb of shared library events. The most common event of interest\n\
7769 to the user would be loading/unloading of a new library."),
7775 follow_fork_mode_kind_names,
7776 &follow_fork_mode_string,
_(
"\
7777 Set debugger response to a program call of fork or vfork."),
_(
"\
7778 Show debugger response to a program call of fork or vfork."),
_(
"\
7779 A fork or vfork creates a new process. follow-fork-mode can be:\n\
7780 parent - the original process is debugged after a fork\n\
7781 child - the new process is debugged after a fork\n\
7782 The unfollowed process will continue to run.\n\
7783 By default, the debugger will follow the parent process."),
7789 follow_exec_mode_names,
7790 &follow_exec_mode_string,
_(
"\
7791 Set debugger response to a program call of exec."),
_(
"\
7792 Show debugger response to a program call of exec."),
_(
"\
7793 An exec call replaces the program image of a process.\n\
7795 follow-exec-mode can be:\n\
7797 new - the debugger creates a new inferior and rebinds the process\n\
7798 to this new inferior. The program the process was running before\n\
7799 the exec call can be restarted afterwards by restarting the original\n\
7802 same - the debugger keeps the process bound to the same inferior.\n\
7803 The new executable image replaces the previous executable loaded in\n\
7804 the inferior. Restarting the inferior after the exec call restarts\n\
7805 the executable the process was running after the exec call.\n\
7807 By default, the debugger will use the same inferior."),
7813 scheduler_enums, &scheduler_mode,
_(
"\
7814 Set mode for locking scheduler during execution."),
_(
"\
7815 Show mode for locking scheduler during execution."),
_(
"\
7816 off == no locking (threads may preempt at any time)\n\
7817 on == full locking (no thread except the current thread may run)\n\
7818 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
7819 In this mode, other threads may run during other commands."),
7825 Set mode for resuming threads of all processes."),
_(
"\
7826 Show mode for resuming threads of all processes."),
_(
"\
7827 When on, execution commands (such as 'continue' or 'next') resume all\n\
7828 threads of all processes. When off (which is the default), execution\n\
7829 commands only resume the threads of the current process. The set of\n\
7830 threads that are resumed is further refined by the scheduler-locking\n\
7831 mode (see help set scheduler-locking)."),
7837 Set mode of the step operation."),
_(
"\
7838 Show mode of the step operation."),
_(
"\
7839 When set, doing a step over a function without debug line information\n\
7840 will stop at the first instruction of that function. Otherwise, the\n\
7841 function is skipped and the step command stops at a different source line."),
7847 &can_use_displaced_stepping,
_(
"\
7848 Set debugger's willingness to use displaced stepping."),
_(
"\
7849 Show debugger's willingness to use displaced stepping."),
_(
"\
7850 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
7851 supported by the target architecture. If off, gdb will not use displaced\n\
7852 stepping to step over breakpoints, even if such is supported by the target\n\
7853 architecture. If auto (which is the default), gdb will use displaced stepping\n\
7854 if the target architecture supports it and non-stop mode is active, but will not\n\
7855 use it in all-stop mode (see help set non-stop)."),
7861 &exec_direction,
_(
"Set direction of execution.\n\
7862 Options are 'forward' or 'reverse'."),
7863 _(
"Show direction of execution (forward/reverse)."),
7864 _(
"Tells gdb whether to execute forward or backward."),
7871 Set whether gdb will detach the child of a fork."),
_(
"\
7872 Show whether gdb will detach the child of a fork."),
_(
"\
7873 Tells gdb whether to detach the child of a fork."),
7879 &disable_randomization,
_(
"\
7880 Set disabling of debuggee's virtual address space randomization."),
_(
"\
7881 Show disabling of debuggee's virtual address space randomization."),
_(
"\
7882 When this mode is on (which is the default), randomization of the virtual\n\
7883 address space is disabled. Standalone programs run with the randomization\n\
7884 enabled by default on some platforms."),
7905 &observer_mode_1,
_(
"\
7906 Set whether gdb controls the inferior in observer mode."),
_(
"\
7907 Show whether gdb controls the inferior in observer mode."),
_(
"\
7908 In observer mode, GDB can get data from the inferior, but not\n\
7909 affect its execution. Registers and memory may not be changed,\n\
7910 breakpoints may not be set, and the program cannot be interrupted\n\
char * target_waitstatus_to_string(const struct target_waitstatus *ws)
void error_no_arg(const char *why)
void get_last_target_status(ptid_t *ptidp, struct target_waitstatus *status)
struct frame_id step_stack_frame_id
int target_supports_disable_randomization(void)
int frame_id_p(struct frame_id l)
struct frame_info * frame_find_by_id(struct frame_id id)
struct cleanup * make_cleanup_freeargv(char **arg)
void annotate_signalled(void)
#define target_can_async_p()
int gdbarch_software_single_step_p(struct gdbarch *gdbarch)
static void handle_step_into_function(struct gdbarch *gdbarch, struct execution_control_state *ecs)
static struct value * siginfo_make_value(struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
void target_terminal_ours(void)
int target_thread_alive(ptid_t ptid)
struct gdbarch * siginfo_gdbarch
int in_solib_dynsym_resolve_code(CORE_ADDR pc)
#define VEC_merge(T, V1, V2)
struct value * value_mark(void)
int moribund_breakpoint_here_p(struct address_space *aspace, CORE_ADDR pc)
static void show_stop_on_solib_events(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
ptid_t user_visible_resume_ptid(int step)
struct thread_info * add_thread(ptid_t ptid)
#define target_can_execute_reverse
struct address_space * maybe_new_address_space(void)
void handle_solib_event(void)
void do_all_intermediate_continuations_thread(struct thread_info *thread, int err)
int pc_in_thread_step_range(CORE_ADDR pc, struct thread_info *thread)
struct thread_info * find_thread_ptid(ptid_t ptid)
static void handle_inferior_event(struct execution_control_state *ecs)
struct thread_control_state thread_control
struct observer * observer_attach_thread_exit(observer_thread_exit_ftype *f)
int catch_syscall_enabled(void)
static const char schedlock_off[]
int function_name_is_marked_for_skip(const char *function_name, const struct symtab_and_line *function_sal)
static int handle_syscall_event(struct execution_control_state *ecs)
struct frame_info * get_selected_frame(const char *message)
static int step_over_info_valid_p(void)
static const char *const follow_fork_mode_kind_names[]
CORE_ADDR step_range_start
CORE_ADDR get_frame_pc(struct frame_info *frame)
int ptid_is_pid(ptid_t ptid)
void value_free_to_mark(struct value *mark)
void execute_cmd_pre_hook(struct cmd_list_element *c)
int gdbarch_displaced_step_copy_insn_p(struct gdbarch *gdbarch)
void add_setshow_zinteger_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
static int proceed_after_vfork_done(struct thread_info *thread, void *arg)
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
int single_step_breakpoint_inserted_here_p(struct address_space *aspace, CORE_ADDR pc)
struct frame_info * get_current_frame(void)
void post_create_inferior(struct target_ops *target, int from_tty)
void signal_catch_update(const unsigned int *info)
void clear_inline_frame_state(ptid_t ptid)
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
void print_signal_received_reason(struct ui_out *uiout, enum gdb_signal siggnal)
void gdb_rl_callback_handler_reinstall(void)
void displaced_step_dump_bytes(struct ui_file *file, const gdb_byte *buf, size_t len)
struct address_space * aspace
void insert_breakpoints(void)
void fputs_unfiltered(const char *buf, struct ui_file *file)
struct cleanup * make_cleanup_restore_current_traceframe(void)
struct cleanup * save_inferior_ptid(void)
struct regcache * get_thread_regcache(ptid_t ptid)
static void validate_siginfo_access(void)
enum gdb_signal gdb_signal_from_command(int num)
void delete_thread(ptid_t)
void bpstat_clear(bpstat *bsp)
int may_insert_fast_tracepoints
void set_running(ptid_t ptid, int running)
void clear_exit_convenience_vars(void)
int value_offset(const struct value *value)
int gdbarch_get_longjmp_target(struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
static int switch_back_to_stepped_thread(struct execution_control_state *ecs)
struct target_waitstatus pending_follow
void print_no_history_reason(struct ui_out *uiout)
void annotate_stopped(void)
enum print_stop_action bpstat_print(bpstat bs, int kind)
struct frame_info * get_prev_frame(struct frame_info *this_frame)
int gdbarch_single_step_through_delay(struct gdbarch *gdbarch, struct frame_info *frame)
void no_shared_libraries(char *ignored, int from_tty)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
void frame_pop(struct frame_info *this_frame)
CORE_ADDR frame_unwind_caller_pc(struct frame_info *this_frame)
struct displaced_step_inferior_state * next
void copy_inferior_target_desc_info(struct inferior *destinf, struct inferior *srcinf)
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
struct gdbarch * frame_unwind_caller_arch(struct frame_info *next_frame)
static void insert_step_resume_breakpoint_at_sal_1(struct gdbarch *gdbarch, struct symtab_and_line sr_sal, struct frame_id sr_id, enum bptype sr_type)
void warning(const char *fmt,...)
#define target_stopped_by_hw_breakpoint()
struct breakpoint * set_momentary_breakpoint_at_pc(struct gdbarch *gdbarch, CORE_ADDR pc, enum bptype type)
struct thread_info * event_thread
int query(const char *ctlstr,...)
void discard_infcall_control_state(struct infcall_control_state *inf_status)
void init_wait_for_inferior(void)
LONGEST target_write(struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len)
void async_enable_stdin(void)
int disable_randomization
void breakpoint_auto_delete(bpstat bs)
char * ui_file_xstrdup(struct ui_file *file, long *length)
char * plongest(LONGEST l)
struct symtab * current_symtab
void ui_file_delete(struct ui_file *file)
static void resume_cleanups(void *)
void target_detach(const char *args, int from_tty)
struct ui_file * gdb_stdout
static void show_schedule_multiple(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
int gdbarch_gdb_signal_to_target_p(struct gdbarch *gdbarch)
static void infrun_thread_ptid_changed(ptid_t old_ptid, ptid_t new_ptid)
void select_frame(struct frame_info *fi)
#define target_supports_stopped_by_sw_breakpoint()
static void check_exception_resume(struct execution_control_state *, struct frame_info *)
struct frame_id get_stack_frame_id(struct frame_info *next_frame)
void _initialize_infrun(void)
int ptid_match(ptid_t ptid, ptid_t filter)
enum breakpoint_here breakpoint_here_p(struct address_space *aspace, CORE_ADDR pc)
void internal_error(const char *file, int line, const char *fmt,...)
const struct frame_id null_frame_id
struct thread_info * inferior_thread(void)
struct inferior_control_state inferior_control
void target_pass_signals(int numsigs, unsigned char *pass_signals)
void init_sal(struct symtab_and_line *sal)
struct regcache * registers
CORE_ADDR gdbarch_deprecated_function_start_offset(struct gdbarch *gdbarch)
static void show_observer_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
void observer_notify_normal_stop(struct bpstats *bs, int print_frame)
int ui_out_is_mi_like_p(struct ui_out *uiout)
int hit_singlestep_breakpoint
void restore_infcall_control_state(struct infcall_control_state *inf_status)
void print_exited_reason(struct ui_out *uiout, int exitstatus)
struct frame_id selected_frame_id
void switch_to_thread(ptid_t ptid)
static const char *const scheduler_enums[]
static void insert_exception_resume_breakpoint(struct thread_info *tp, const struct block *b, struct frame_info *frame, struct symbol *sym)
static const char follow_fork_mode_parent[]
int stepping_over_watchpoint
void nullify_last_target_wait_ptid(void)
static void delete_just_stopped_threads_infrun_breakpoints(void)
int breakpoints_not_allowed
static const char exec_reverse[]
struct value * read_var_value(struct symbol *var, struct frame_info *frame)
static void fill_in_stop_func(struct gdbarch *gdbarch, struct execution_control_state *ecs)
int thread_has_single_step_breakpoint_here(struct thread_info *tp, struct address_space *aspace, CORE_ADDR addr)
void annotate_signal(void)
static void context_switch(ptid_t ptid)
void set_initial_language(void)
int catch_errors(catch_errors_ftype *func, void *func_args, char *errstring, return_mask mask)
void(* deprecated_context_hook)(int)
struct infcall_control_state * save_infcall_control_state(void)
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
static void siginfo_value_write(struct value *v, struct value *fromval)
struct inferior * find_inferior_ptid(ptid_t ptid)
struct displaced_step_request * next
struct obj_section * section
struct cmd_list_element * cmdlist
int gdbarch_software_single_step(struct gdbarch *gdbarch, struct frame_info *frame)
struct address_space * get_frame_address_space(struct frame_info *frame)
static void keep_going(struct execution_control_state *ecs)
char * target_pid_to_str(ptid_t ptid)
struct internalvar * lookup_internalvar(const char *name)
int step_after_step_resume_breakpoint
static void displaced_step_clear(struct displaced_step_inferior_state *displaced)
static void set_schedlock_func(char *args, int from_tty, struct cmd_list_element *c)
enum gdb_signal stop_signal
static ptid_t target_last_wait_ptid
struct value * probe_safe_evaluate_at_pc(struct frame_info *frame, unsigned n)
void set_current_sal_from_frame(struct frame_info *)
int bpstat_causes_stop(bpstat bs)
int gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch)
int signal_print_state(int signo)
void observer_notify_sync_execution_done(void)
int program_breakpoint_here_p(struct gdbarch *gdbarch, CORE_ADDR address)
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
ptid_t(* deprecated_target_wait_hook)(ptid_t ptid, struct target_waitstatus *status, int options)
#define target_stopped_by_watchpoint()
static int displaced_step_prepare(ptid_t ptid)
int record_full_is_used(void)
#define SET_SIGS(nsigs, sigs, flags)
void(* for_each_just_stopped_thread_callback_func)(struct thread_info *tp)
int stepping_past_instruction_at(struct address_space *aspace, CORE_ADDR address)
void ui_out_field_fmt(struct ui_out *uiout, const char *fldname, const char *format,...)
void target_program_signals(int numsigs, unsigned char *program_signals)
struct value * allocate_value(struct type *type)
static void follow_inferior_reset_breakpoints(void)
struct displaced_step_request * step_request_queue
struct regcache * get_current_regcache(void)
#define target_stopped_data_address(target, addr_p)
void ui_out_text(struct ui_out *uiout, const char *string)
struct cleanup * save_current_inferior(void)
CORE_ADDR gdbarch_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
int may_insert_tracepoints
struct observer * observer_attach_thread_stop_requested(observer_thread_stop_requested_ftype *f)
static void handle_step_into_function_backward(struct gdbarch *gdbarch, struct execution_control_state *ecs)
void printf_filtered(const char *format,...)
static int maybe_software_singlestep(struct gdbarch *gdbarch, CORE_ADDR pc)
CORE_ADDR stop_func_start
int breakpoint_inserted_here_p(struct address_space *aspace, CORE_ADDR pc)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
struct obj_section * find_pc_overlay(CORE_ADDR pc)
struct gdbarch * step_gdbarch
struct program_space * add_program_space(struct address_space *aspace)
void restore_infcall_suspend_state(struct infcall_suspend_state *inf_state)
void set_current_program_space(struct program_space *pspace)
struct regcache * regcache_dup(struct regcache *src)
#define UNSET_SIGS(nsigs, sigs, flags)
int bpstat_should_step(void)
void gdbarch_displaced_step_free_closure(struct gdbarch *gdbarch, struct displaced_step_closure *closure)
static void signal_cache_update(int signo)
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
int signal_stop_state(int signo)
static int restore_selected_frame(void *)
void null_cleanup(void *arg)
struct thread_info * iterate_over_threads(thread_callback_func, void *)
int frame_id_eq(struct frame_id l, struct frame_id r)
void annotate_signal_name_end(void)
void find_frame_sal(struct frame_info *frame, struct symtab_and_line *sal)
void print_signal_exited_reason(struct ui_out *uiout, enum gdb_signal siggnal)
struct cmd_list_element * setlist
#define target_stopped_by_sw_breakpoint()
enum stop_stack_kind call_dummy
static void signals_info(char *, int)
void add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
#define target_execution_direction()
enum frame_type get_frame_type(struct frame_info *frame)
struct objfile * symbol_file_add(const char *name, int add_flags, struct section_addr_info *addrs, int flags)
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
static int stop_print_frame
void observer_notify_about_to_proceed(void)
const char * stop_func_name
struct frame_id get_frame_id(struct frame_info *fi)
void breakpoint_re_set(void)
struct infcall_suspend_state * save_infcall_suspend_state(void)
ULONGEST gdbarch_max_insn_length(struct gdbarch *gdbarch)
void target_dcache_invalidate(void)
#define CATCH(EXCEPTION, MASK)
struct address_space * aspace
struct cleanup * make_cleanup_restore_integer(int *variable)
static const char * scheduler_mode
void annotate_exited(int exitstatus)
struct cleanup * make_cleanup_restore_infcall_control_state(struct infcall_control_state *inf_status)
static void clear_proceed_status_thread(struct thread_info *tp)
int gdbarch_single_step_through_delay_p(struct gdbarch *gdbarch)
void update_signals_program_target(void)
struct target_ops current_target
void inferior_event_handler(enum inferior_event_type event_type, gdb_client_data client_data)
int detach_breakpoints(ptid_t ptid)
void do_all_continuations_thread(struct thread_info *thread, int err)
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
static void insert_exception_resume_from_probe(struct thread_info *tp, const struct bound_probe *probe, struct frame_info *frame)
static struct thread_info * find_thread_needs_step_over(struct thread_info *except)
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
struct breakpoint * exception_resume_breakpoint
struct value * allocate_computed_value(struct type *type, const struct lval_funcs *funcs, void *closure)
static int infrun_thread_stop_requested_callback(struct thread_info *info, void *arg)
int inline_skipped_frames(ptid_t ptid)
struct frame_id step_frame_id
void target_clear_description(void)
struct program_space * pspace
static void insert_longjmp_resume_breakpoint(struct gdbarch *, CORE_ADDR)
static void delete_thread_infrun_breakpoints(struct thread_info *tp)
void fprintf_filtered(struct ui_file *stream, const char *format,...)
void jit_inferior_created_hook(void)
struct symbol * find_pc_function(CORE_ADDR pc)
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
void update_target_permissions(void)
static void for_each_just_stopped_thread(for_each_just_stopped_thread_callback_func func)
static enum auto_boolean can_use_displaced_stepping
struct inferior * add_inferior(int pid)
struct displaced_step_closure * gdbarch_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
static void infrun_thread_stop_requested(ptid_t ptid)
int gdbarch_displaced_step_hw_singlestep(struct gdbarch *gdbarch, struct displaced_step_closure *closure)
void annotate_starting(void)
struct thread_info * any_live_thread_of_process(int pid)
int stepping_past_nonsteppable_watchpoint(void)
int signal_pass_update(int signo, int state)
static void insert_hp_step_resume_breakpoint_at_frame(struct frame_info *)
void target_terminal_inferior(void)
void target_resume(ptid_t ptid, int step, enum gdb_signal signal)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
static void print_target_wait_results(ptid_t waiton_ptid, ptid_t result_ptid, const struct target_waitstatus *ws)
struct cleanup * make_cleanup_restore_infcall_suspend_state(struct infcall_suspend_state *inf_state)
struct cmd_list_element * showlist
void exception_print(struct ui_file *file, struct gdb_exception e)
static const char schedlock_on[]
struct inferior_control_state control
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
struct breakpoint * clone_momentary_breakpoint(struct breakpoint *orig)
gdb_byte * step_saved_copy
void insert_single_step_breakpoint(struct gdbarch *gdbarch, struct address_space *aspace, CORE_ADDR next_pc)
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
void free_current_contents(void *ptr)
void update_observer_mode(void)
struct symbol * get_frame_function(struct frame_info *frame)
ptid_t pid_to_ptid(int pid)
int async_command_editing_p
static void displaced_step_clear_cleanup(void *arg)
int nonsteppable_watchpoint_p
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
int catching_syscall_number(int syscall_number)
union target_waitstatus::@161 value
static void do_restore_infcall_suspend_state_cleanup(void *state)
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
void prune_inferiors(void)
struct address_space * aspace
static void handle_command(char *, int)
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
struct thread_control_state control
static void adjust_pc_after_break(struct execution_control_state *ecs)
static unsigned char * signal_stop
struct target_ops * find_record_target(void)
static void show_follow_fork_mode_string(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
int step_stop_if_no_debug
struct cmd_list_element * add_info(const char *name, cmd_cfunc_ftype *fun, const char *doc)
static void end_stepping_range(struct execution_control_state *ecs)
CORE_ADDR gdbarch_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR ip)
void target_mourn_inferior(void)
static void remove_displaced_stepping_state(int pid)
void regcache_cpy(struct regcache *dst, struct regcache *src)
int overlay_cache_invalid
int gdbarch_cannot_step_breakpoint(struct gdbarch *gdbarch)
#define SYMBOL_LINKAGE_NAME(symbol)
void gdbarch_skip_permanent_breakpoint(struct gdbarch *gdbarch, struct regcache *regcache)
int waiting_for_vfork_done
struct program_space * frame_unwind_program_space(struct frame_info *this_frame)
#define target_is_async_p()
struct regcache * get_infcall_suspend_state_regcache(struct infcall_suspend_state *inf_state)
static void show_disable_randomization(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static void clear_step_over_info(void)
static void siginfo_value_read(struct value *v)
const char * gdb_signal_to_name(enum gdb_signal)
void print_stop_event(struct target_waitstatus *ws)
#define target_has_execution
gdb_byte * value_contents_all_raw(struct value *value)
#define target_can_lock_scheduler
static struct target_waitstatus target_last_waitstatus
static void set_step_over_info(struct address_space *aspace, CORE_ADDR address, int nonsteppable_watchpoint_p)
static void delete_just_stopped_threads_single_step_breakpoints(void)
void printf_unfiltered(const char *format,...)
struct cmd_list_element * setdebuglist
ptid_t target_wait(ptid_t ptid, struct target_waitstatus *status, int options)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
struct frame_id frame_unwind_caller_id(struct frame_info *next_frame)
void delete_step_resume_breakpoint(struct thread_info *)
void annotate_thread_changed(void)
int software_breakpoint_inserted_here_p(struct address_space *aspace, CORE_ADDR pc)
int gdbarch_in_solib_return_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
struct ui_file * gdb_stdlog
CORE_ADDR gdbarch_adjust_breakpoint_address(struct gdbarch *gdbarch, CORE_ADDR bpaddr)
static const char follow_exec_mode_same[]
struct observer * observer_attach_thread_ptid_changed(observer_thread_ptid_changed_ftype *f)
struct ui_file * mem_fileopen(void)
static void prepare_to_wait(struct execution_control_state *ecs)
static void displaced_step_restore(struct displaced_step_inferior_state *displaced, ptid_t ptid)
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
static void displaced_step_fixup(ptid_t event_ptid, enum gdb_signal signal)
static void infrun_thread_thread_exit(struct thread_info *tp, int silent)
struct inferior * vfork_child
void skip_inline_frames(ptid_t ptid)
struct breakpoint * set_momentary_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line sal, struct frame_id frame_id, enum bptype type)
void fetch_inferior_event(void *client_data)
static const char *const follow_exec_mode_names[]
static void handle_inferior_event_1(struct execution_control_state *ecs)
struct program_space * clone_program_space(struct program_space *dest, struct program_space *src)
static void infrun_inferior_exit(struct inferior *inf)
struct symbol * step_start_function
static void show_exec_direction_func(struct ui_file *out, int from_tty, struct cmd_list_element *cmd, const char *value)
void init_thread_stepping_state(struct thread_info *tss)
void finish_thread_state_cleanup(void *ptid_p)
int ptid_get_pid(ptid_t ptid)
int stopped_by_random_signal
static const char schedlock_step[]
void annotate_signal_name(void)
void discard_infcall_suspend_state(struct infcall_suspend_state *inf_state)
int signal_pass_state(int signo)
static ptid_t previous_inferior_ptid
enum gdb_signal gdb_signal_from_name(const char *)
bpstat bpstat_copy(bpstat bs)
static void set_exec_direction_func(char *args, int from_tty, struct cmd_list_element *cmd)
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
static void reinstall_readline_callback_handler_cleanup(void *arg)
enum stop_stack_kind stop_stack_dummy
static unsigned char * signal_program
void disable_current_display(void)
const char const char int
void exec_file_attach(const char *filename, int from_tty)
static void process_event_stop_test(struct execution_control_state *ecs)
void start_remote(int from_tty)
static struct displaced_step_inferior_state * get_displaced_stepping_state(int pid)
void discard_cleanups(struct cleanup *old_chain)
void print_end_stepping_range_reason(struct ui_out *uiout)
void annotate_signal_string_end(void)
void observer_notify_no_history(void)
int value_optimized_out(struct value *value)
static void show_follow_exec_mode_string(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static int follow_fork_inferior(int follow_child, int detach_fork)
long ptid_get_tid(ptid_t ptid)
static unsigned char * signal_catch
static void show_step_stop_if_no_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
#define ALL_NON_EXITED_THREADS(T)
static void set_disable_randomization(char *args, int from_tty, struct cmd_list_element *c)
struct cleanup * make_bpstat_clear_actions_cleanup(void)
static void set_non_stop(char *args, int from_tty, struct cmd_list_element *c)
int may_insert_breakpoints
void proceed(CORE_ADDR addr, enum gdb_signal siggnal)
static const char follow_exec_mode_new[]
void update_thread_list(void)
const char * async_reason_lookup(enum async_reply_reason reason)
void not_just_help_class_command(char *args, int from_tty)
void prepare_for_detach(void)
#define SYMBOL_BLOCK_VALUE(symbol)
static int currently_stepping(struct thread_info *tp)
void set_step_info(struct frame_info *frame, struct symtab_and_line sal)
void clear_proceed_status(int step)
enum target_waitkind kind
static struct displaced_step_inferior_state * displaced_step_inferior_states
void delete_exception_resume_breakpoint(struct thread_info *)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
int gdbarch_get_siginfo_type_p(struct gdbarch *gdbarch)
struct ui_file * gdb_stderr
void breakpoint_init_inferior(enum inf_context context)
static int use_displaced_stepping(struct gdbarch *gdbarch)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
char * safe_strerror(int)
void set_internalvar_integer(struct internalvar *var, LONGEST l)
struct cleanup * make_cleanup_restore_current_thread(void)
void observer_notify_signal_received(enum gdb_signal siggnal)
static struct displaced_step_inferior_state * add_displaced_stepping_state(int pid)
static void show_can_use_displaced_stepping(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
int remove_breakpoints(void)
void solib_create_inferior_hook(int from_tty)
struct interp * command_interp(void)
struct symbol * lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
struct program_space * pspace
void set_current_traceframe(int num)
static void sig_print_info(enum gdb_signal)
void observer_notify_exited(int exitstatus)
int bpstat_explains_signal(bpstat bsp, enum gdb_signal sig)
static void handle_vfork_child_exec_or_exit(int exec)
enum language compunit_language(const struct compunit_symtab *cust)
struct frame_id initiating_frame
struct address_space * new_address_space(void)
char ** gdb_buildargv(const char *s)
char * exec_file_find(char *in_pathname, int *fd)
struct regcache * get_thread_arch_aspace_regcache(ptid_t ptid, struct gdbarch *gdbarch, struct address_space *aspace)
int gdbarch_adjust_breakpoint_address_p(struct gdbarch *gdbarch)
static void do_target_resume(ptid_t resume_ptid, int step, enum gdb_signal sig)
void clear_internalvar(struct internalvar *var)
struct thread_suspend_state suspend
const char * gdb_signal_to_symbol_string(enum gdb_signal sig)
struct address_space * get_regcache_aspace(const struct regcache *regcache)
struct bpstat_what bpstat_what(bpstat bs_head)
struct bound_probe find_probe_by_pc(CORE_ADDR pc)
struct breakpoint * single_step_breakpoints
void exit_inferior_num_silent(int num)
static void restore_inferior_ptid(void *arg)
void regcache_xfree(struct regcache *regcache)
static void stop_waiting(struct execution_control_state *ecs)
struct inferior * current_inferior(void)
struct cmd_list_element * add_info_alias(const char *name, const char *oldname, int abbrev_flag)
static int stepped_in_from(struct frame_info *frame, struct frame_id step_frame_id)
static void show_debug_displaced(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
int is_exited(ptid_t ptid)
int breakpoints_should_be_inserted_now(void)
struct interp * command_interp
static void insert_step_resume_breakpoint_at_caller(struct frame_info *)
static void show_non_stop(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
struct program_space * current_program_space
static void follow_exec(ptid_t ptid, char *execd_pathname)
void delete_single_step_breakpoints(struct thread_info *tp)
unsigned long long ULONGEST
static const char follow_fork_mode_child[]
void gdbarch_displaced_step_fixup(struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
struct cleanup * save_current_program_space(void)
const struct frame_id outer_frame_id
int pid_to_thread_id(ptid_t ptid)
static int hook_stop_stub(void *)
int stepping_over_breakpoint
struct cleanup * record_full_gdb_operation_disable_set(void)
static int observer_mode_1
static void set_last_target_status(ptid_t ptid, struct target_waitstatus status)
#define target_supports_multi_process()
struct cleanup * save_current_space_and_thread(void)
void update_breakpoints_after_exec(void)
void resume(enum gdb_signal sig)
long ptid_get_lwp(ptid_t ptid)
struct type * value_type(const struct value *value)
int watchpoints_triggered(struct target_waitstatus *ws)
void update_solib_breakpoints(void)
const char * gdb_signal_to_string(enum gdb_signal)
static unsigned char * signal_print
static void write_memory_ptid(ptid_t ptid, CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
unsigned int debug_infrun
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
static void set_observer_mode(char *args, int from_tty, struct cmd_list_element *c)
CORE_ADDR gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
static void show_scheduler_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
struct cmd_list_element * showdebuglist
int target_follow_fork(int follow_child, int detach_fork)
int stopped_by_random_signal
void annotate_signal_string(void)
static const char exec_forward[]
CORE_ADDR value_as_address(struct value *val)
int signal_print_update(int signo, int state)
static int follow_fork(void)
void ui_out_field_string(struct ui_out *uiout, const char *fldname, const char *string)
void target_terminal_ours_for_output(void)
int pc_at_non_inline_function(struct address_space *aspace, CORE_ADDR pc, const struct target_waitstatus *ws)
int gdbarch_skip_entrypoint_p(struct gdbarch *gdbarch)
void wait_for_inferior(void)
CORE_ADDR gdbarch_displaced_step_location(struct gdbarch *gdbarch)
enum step_over_calls_kind step_over_calls
void breakpoint_retire_moribund(void)
#define TYPE_LENGTH(thistype)
struct breakpoint * step_resume_breakpoint
enum stop_stack_kind stop_stack_dummy
static int thread_still_needs_step_over(struct thread_info *tp)
CORE_ADDR gdbarch_skip_entrypoint(struct gdbarch *gdbarch, CORE_ADDR ip)
int signal_stop_update(int signo, int state)
CORE_ADDR skip_language_trampoline(struct frame_info *frame, CORE_ADDR pc)
static enum stop_kind get_inferior_stop_soon(ptid_t ptid)
void reinit_frame_cache(void)
#define target_have_steppable_watchpoint
int remove_breakpoints_pid(int pid)
void gdb_flush(struct ui_file *file)
static void set_stop_on_solib_events(char *args, int from_tty, struct cmd_list_element *c)
static const char * follow_exec_mode_string
static unsigned char * signal_pass
static void show_debug_infrun(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static int displaced_step_in_progress(int pid)
int is_running(ptid_t ptid)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
static void do_restore_infcall_control_state_cleanup(void *sts)
bpstat bpstat_stop_status(struct address_space *aspace, CORE_ADDR bp_addr, ptid_t ptid, const struct target_waitstatus *ws)
static const char * follow_fork_mode_string
void target_find_description(void)
struct inferior * vfork_parent
struct target_waitstatus ws
int gdbarch_gdb_signal_to_target(struct gdbarch *gdbarch, enum gdb_signal signal)
PTR xcalloc(size_t number, size_t size)
struct displaced_step_closure * get_displaced_step_closure_by_addr(CORE_ADDR addr)
static struct cmd_list_element * stop_command
void insert_step_resume_breakpoint_at_sal(struct gdbarch *gdbarch, struct symtab_and_line sr_sal, struct frame_id sr_id)
struct type * gdbarch_get_siginfo_type(struct gdbarch *gdbarch)
int has_stack_frames(void)
struct program_space * get_frame_program_space(struct frame_info *frame)
void observer_notify_end_stepping_range(void)
static void delete_just_stopped_threads_infrun_breakpoints_cleanup(void *arg)
void breakpoint_re_set_thread(struct breakpoint *b)
struct internalvar * create_internalvar_type_lazy(const char *name, const struct internalvar_funcs *funcs, void *data)
struct thread_suspend_state thread_suspend
void set_executing(ptid_t ptid, int executing)
static void handle_signal_stop(struct execution_control_state *ecs)
void error(const char *fmt,...)
int return_child_result_value
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
int breakpoint_address_match(struct address_space *aspace1, CORE_ADDR addr1, struct address_space *aspace2, CORE_ADDR addr2)
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
#define ALL_BLOCK_SYMBOLS(block, iter, sym)
void copy_terminal_info(struct inferior *to, struct inferior *from)
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
void set_current_inferior(struct inferior *inf)
void throw_error(enum errors error, const char *fmt,...)
static void sig_print_header(void)
void do_cleanups(struct cleanup *old_chain)
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
int is_executing(ptid_t ptid)
void observer_notify_signal_exited(enum gdb_signal siggnal)
#define SYMBOL_IS_ARGUMENT(symbol)
static int schedlock_applies(struct thread_info *tp)
void step_into_inline_frame(ptid_t ptid)
void check_longjmp_breakpoint_for_call_dummy(struct thread_info *tp)
#define ALL_THREADS_SAFE(T, TMP)
void mark_breakpoints_out(void)
const ULONGEST const LONGEST len
struct displaced_step_closure * step_closure
int gdbarch_get_longjmp_target_p(struct gdbarch *gdbarch)
enum bpstat_what_main_action main_action
LONGEST parse_and_eval_long(const char *exp)