GDB (xrefs)

/tmp/gdb-8.1/gdb/infrun.c
Go to the documentation of this file.
1 /* Target-struct-independent code to start (run) and stop an inferior
2 process.
3
4 Copyright (C) 1986-2018 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 #include "defs.h"
22 #include "infrun.h"
23 #include <ctype.h>
24 #include "symtab.h"
25 #include "frame.h"
26 #include "inferior.h"
27 #include "breakpoint.h"
28 #include "gdb_wait.h"
29 #include "gdbcore.h"
30 #include "gdbcmd.h"
31 #include "cli/cli-script.h"
32 #include "target.h"
33 #include "gdbthread.h"
34 #include "annotate.h"
35 #include "symfile.h"
36 #include "top.h"
37 #include <signal.h>
38 #include "inf-loop.h"
39 #include "regcache.h"
40 #include "value.h"
41 #include "observer.h"
42 #include "language.h"
43 #include "solib.h"
44 #include "main.h"
45 #include "dictionary.h"
46 #include "block.h"
47 #include "mi/mi-common.h"
48 #include "event-top.h"
49 #include "record.h"
50 #include "record-full.h"
51 #include "inline-frame.h"
52 #include "jit.h"
53 #include "tracepoint.h"
54 #include "continuations.h"
55 #include "interps.h"
56 #include "skip.h"
57 #include "probe.h"
58 #include "objfiles.h"
59 #include "completer.h"
60 #include "target-descriptions.h"
61 #include "target-dcache.h"
62 #include "terminal.h"
63 #include "solist.h"
64 #include "event-loop.h"
65 #include "thread-fsm.h"
66 #include "common/enum-flags.h"
67 #include "progspace-and-thread.h"
68 #include "common/gdb_optional.h"
69 #include "arch-utils.h"
70
71 /* Prototypes for local functions */
72
73 static void sig_print_info (enum gdb_signal);
74
75 static void sig_print_header (void);
76
77 static int follow_fork (void);
78
79 static int follow_fork_inferior (int follow_child, int detach_fork);
80
81 static void follow_inferior_reset_breakpoints (void);
82
83 static int currently_stepping (struct thread_info *tp);
84
85 void nullify_last_target_wait_ptid (void);
86
87 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
88
89 static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
90
91 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
92
93 static int maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc);
94
95 /* Asynchronous signal handler registered as event loop source for
96 when we have pending events ready to be passed to the core. */
97 static struct async_event_handler *infrun_async_inferior_event_token;
98
99 /* Stores whether infrun_async was previously enabled or disabled.
100 Starts off as -1, indicating "never enabled/disabled". */
101 static int infrun_is_async = -1;
102
103 /* See infrun.h. */
104
105 void
106 infrun_async (int enable)
107 {
108 if (infrun_is_async != enable)
109 {
110 infrun_is_async = enable;
111
112 if (debug_infrun)
113 fprintf_unfiltered (gdb_stdlog,
114 "infrun: infrun_async(%d)\n",
115 enable);
116
117 if (enable)
118 mark_async_event_handler (infrun_async_inferior_event_token);
119 else
120 clear_async_event_handler (infrun_async_inferior_event_token);
121 }
122 }
123
124 /* See infrun.h. */
125
126 void
127 mark_infrun_async_event_handler (void)
128 {
129 mark_async_event_handler (infrun_async_inferior_event_token);
130 }
131
132 /* When set, stop the 'step' command if we enter a function which has
133 no line number information. The normal behavior is that we step
134 over such function. */
135 int step_stop_if_no_debug = 0;
136 static void
137 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
138 struct cmd_list_element *c, const char *value)
139 {
140 fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
141 }
142
143 /* proceed and normal_stop use this to notify the user when the
144 inferior stopped in a different thread than it had been running
145 in. */
146
147 static ptid_t previous_inferior_ptid;
148
149 /* If set (default for legacy reasons), when following a fork, GDB
150 will detach from one of the fork branches, child or parent.
151 Exactly which branch is detached depends on 'set follow-fork-mode'
152 setting. */
153
154 static int detach_fork = 1;
155
156 int debug_displaced = 0;
157 static void
158 show_debug_displaced (struct ui_file *file, int from_tty,
159 struct cmd_list_element *c, const char *value)
160 {
161 fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
162 }
163
164 unsigned int debug_infrun = 0;
165 static void
166 show_debug_infrun (struct ui_file *file, int from_tty,
167 struct cmd_list_element *c, const char *value)
168 {
169 fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
170 }
171
172
173 /* Support for disabling address space randomization. */
174
175 int disable_randomization = 1;
176
177 static void
178 show_disable_randomization (struct ui_file *file, int from_tty,
179 struct cmd_list_element *c, const char *value)
180 {
181 if (target_supports_disable_randomization ())
182 fprintf_filtered (file,
183 _("Disabling randomization of debuggee's "
184 "virtual address space is %s.\n"),
185 value);
186 else
187 fputs_filtered (_("Disabling randomization of debuggee's "
188 "virtual address space is unsupported on\n"
189 "this platform.\n"), file);
190 }
191
192 static void
193 set_disable_randomization (const char *args, int from_tty,
194 struct cmd_list_element *c)
195 {
196 if (!target_supports_disable_randomization ())
197 error (_("Disabling randomization of debuggee's "
198 "virtual address space is unsupported on\n"
199 "this platform."));
200 }
201
202 /* User interface for non-stop mode. */
203
204 int non_stop = 0;
205 static int non_stop_1 = 0;
206
207 static void
208 set_non_stop (const char *args, int from_tty,
209 struct cmd_list_element *c)
210 {
211 if (target_has_execution)
212 {
213 non_stop_1 = non_stop;
214 error (_("Cannot change this setting while the inferior is running."));
215 }
216
217 non_stop = non_stop_1;
218 }
219
220 static void
221 show_non_stop (struct ui_file *file, int from_tty,
222 struct cmd_list_element *c, const char *value)
223 {
224 fprintf_filtered (file,
225 _("Controlling the inferior in non-stop mode is %s.\n"),
226 value);
227 }
228
229 /* "Observer mode" is somewhat like a more extreme version of
230 non-stop, in which all GDB operations that might affect the
231 target's execution have been disabled. */
232
233 int observer_mode = 0;
234 static int observer_mode_1 = 0;
235
236 static void
237 set_observer_mode (const char *args, int from_tty,
238 struct cmd_list_element *c)
239 {
240 if (target_has_execution)
241 {
242 observer_mode_1 = observer_mode;
243 error (_("Cannot change this setting while the inferior is running."));
244 }
245
246 observer_mode = observer_mode_1;
247
248 may_write_registers = !observer_mode;
249 may_write_memory = !observer_mode;
250 may_insert_breakpoints = !observer_mode;
251 may_insert_tracepoints = !observer_mode;
252 /* We can insert fast tracepoints in or out of observer mode,
253 but enable them if we're going into this mode. */
254 if (observer_mode)
255 may_insert_fast_tracepoints = 1;
256 may_stop = !observer_mode;
257 update_target_permissions ();
258
259 /* Going *into* observer mode we must force non-stop, then
260 going out we leave it that way. */
261 if (observer_mode)
262 {
263 pagination_enabled = 0;
264 non_stop = non_stop_1 = 1;
265 }
266
267 if (from_tty)
268 printf_filtered (_("Observer mode is now %s.\n"),
269 (observer_mode ? "on" : "off"));
270 }
271
272 static void
273 show_observer_mode (struct ui_file *file, int from_tty,
274 struct cmd_list_element *c, const char *value)
275 {
276 fprintf_filtered (file, _("Observer mode is %s.\n"), value);
277 }
278
279 /* This updates the value of observer mode based on changes in
280 permissions. Note that we are deliberately ignoring the values of
281 may-write-registers and may-write-memory, since the user may have
282 reason to enable these during a session, for instance to turn on a
283 debugging-related global. */
284
285 void
286 update_observer_mode (void)
287 {
288 int newval;
289
290 newval = (!may_insert_breakpoints
291 && !may_insert_tracepoints
292 && may_insert_fast_tracepoints
293 && !may_stop
294 && non_stop);
295
296 /* Let the user know if things change. */
297 if (newval != observer_mode)
298 printf_filtered (_("Observer mode is now %s.\n"),
299 (newval ? "on" : "off"));
300
301 observer_mode = observer_mode_1 = newval;
302 }
303
304 /* Tables of how to react to signals; the user sets them. */
305
306 static unsigned char *signal_stop;
307 static unsigned char *signal_print;
308 static unsigned char *signal_program;
309
310 /* Table of signals that are registered with "catch signal". A
311 non-zero entry indicates that the signal is caught by some "catch
312 signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
313 signals. */
314 static unsigned char *signal_catch;
315
316 /* Table of signals that the target may silently handle.
317 This is automatically determined from the flags above,
318 and simply cached here. */
319 static unsigned char *signal_pass;
320
321 #define SET_SIGS(nsigs,sigs,flags) \
322 do { \
323 int signum = (nsigs); \
324 while (signum-- > 0) \
325 if ((sigs)[signum]) \
326 (flags)[signum] = 1; \
327 } while (0)
328
329 #define UNSET_SIGS(nsigs,sigs,flags) \
330 do { \
331 int signum = (nsigs); \
332 while (signum-- > 0) \
333 if ((sigs)[signum]) \
334 (flags)[signum] = 0; \
335 } while (0)
336
337 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
338 this function is to avoid exporting `signal_program'. */
339
340 void
341 update_signals_program_target (void)
342 {
343 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
344 }
345
346 /* Value to pass to target_resume() to cause all threads to resume. */
347
348 #define RESUME_ALL minus_one_ptid
349
350 /* Command list pointer for the "stop" placeholder. */
351
352 static struct cmd_list_element *stop_command;
353
354 /* Nonzero if we want to give control to the user when we're notified
355 of shared library events by the dynamic linker. */
356 int stop_on_solib_events;
357
358 /* Enable or disable optional shared library event breakpoints
359 as appropriate when the above flag is changed. */
360
361 static void
362 set_stop_on_solib_events (const char *args,
363 int from_tty, struct cmd_list_element *c)
364 {
365 update_solib_breakpoints ();
366 }
367
368 static void
369 show_stop_on_solib_events (struct ui_file *file, int from_tty,
370 struct cmd_list_element *c, const char *value)
371 {
372 fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
373 value);
374 }
375
376 /* Nonzero after stop if current stack frame should be printed. */
377
378 static int stop_print_frame;
379
380 /* This is a cached copy of the pid/waitstatus of the last event
381 returned by target_wait()/deprecated_target_wait_hook(). This
382 information is returned by get_last_target_status(). */
383 static ptid_t target_last_wait_ptid;
384 static struct target_waitstatus target_last_waitstatus;
385
386 static void context_switch (ptid_t ptid);
387
388 void init_thread_stepping_state (struct thread_info *tss);
389
390 static const char follow_fork_mode_child[] = "child";
391 static const char follow_fork_mode_parent[] = "parent";
392
393 static const char *const follow_fork_mode_kind_names[] = {
394 follow_fork_mode_child,
395 follow_fork_mode_parent,
396 NULL
397 };
398
399 static const char *follow_fork_mode_string = follow_fork_mode_parent;
400 static void
401 show_follow_fork_mode_string (struct ui_file *file, int from_tty,
402 struct cmd_list_element *c, const char *value)
403 {
404 fprintf_filtered (file,
405 _("Debugger response to a program "
406 "call of fork or vfork is \"%s\".\n"),
407 value);
408 }
409
410
411 /* Handle changes to the inferior list based on the type of fork,
412 which process is being followed, and whether the other process
413 should be detached. On entry inferior_ptid must be the ptid of
414 the fork parent. At return inferior_ptid is the ptid of the
415 followed inferior. */
416
417 static int
418 follow_fork_inferior (int follow_child, int detach_fork)
419 {
420 int has_vforked;
421 ptid_t parent_ptid, child_ptid;
422
423 has_vforked = (inferior_thread ()->pending_follow.kind
424 == TARGET_WAITKIND_VFORKED);
425 parent_ptid = inferior_ptid;
426 child_ptid = inferior_thread ()->pending_follow.value.related_pid;
427
428 if (has_vforked
429 && !non_stop /* Non-stop always resumes both branches. */
430 && current_ui->prompt_state == PROMPT_BLOCKED
431 && !(follow_child || detach_fork || sched_multi))
432 {
433 /* The parent stays blocked inside the vfork syscall until the
434 child execs or exits. If we don't let the child run, then
435 the parent stays blocked. If we're telling the parent to run
436 in the foreground, the user will not be able to ctrl-c to get
437 back the terminal, effectively hanging the debug session. */
438 fprintf_filtered (gdb_stderr, _("\
439 Can not resume the parent process over vfork in the foreground while\n\
440 holding the child stopped. Try \"set detach-on-fork\" or \
441 \"set schedule-multiple\".\n"));
442 /* FIXME output string > 80 columns. */
443 return 1;
444 }
445
446 if (!follow_child)
447 {
448 /* Detach new forked process? */
449 if (detach_fork)
450 {
451 /* Before detaching from the child, remove all breakpoints
452 from it. If we forked, then this has already been taken
453 care of by infrun.c. If we vforked however, any
454 breakpoint inserted in the parent is visible in the
455 child, even those added while stopped in a vfork
456 catchpoint. This will remove the breakpoints from the
457 parent also, but they'll be reinserted below. */
458 if (has_vforked)
459 {
460 /* Keep breakpoints list in sync. */
461 remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
462 }
463
464 if (info_verbose || debug_infrun)
465 {
466 /* Ensure that we have a process ptid. */
467 ptid_t process_ptid = pid_to_ptid (ptid_get_pid (child_ptid));
468
469 target_terminal::ours_for_output ();
470 fprintf_filtered (gdb_stdlog,
471 _("Detaching after %s from child %s.\n"),
472 has_vforked ? "vfork" : "fork",
473 target_pid_to_str (process_ptid));
474 }
475 }
476 else
477 {
478 struct inferior *parent_inf, *child_inf;
479
480 /* Add process to GDB's tables. */
481 child_inf = add_inferior (ptid_get_pid (child_ptid));
482
483 parent_inf = current_inferior ();
484 child_inf->attach_flag = parent_inf->attach_flag;
485 copy_terminal_info (child_inf, parent_inf);
486 child_inf->gdbarch = parent_inf->gdbarch;
487 copy_inferior_target_desc_info (child_inf, parent_inf);
488
489 scoped_restore_current_pspace_and_thread restore_pspace_thread;
490
491 inferior_ptid = child_ptid;
492 add_thread (inferior_ptid);
493 set_current_inferior (child_inf);
494 child_inf->symfile_flags = SYMFILE_NO_READ;
495
496 /* If this is a vfork child, then the address-space is
497 shared with the parent. */
498 if (has_vforked)
499 {
500 child_inf->pspace = parent_inf->pspace;
501 child_inf->aspace = parent_inf->aspace;
502
503 /* The parent will be frozen until the child is done
504 with the shared region. Keep track of the
505 parent. */
506 child_inf->vfork_parent = parent_inf;
507 child_inf->pending_detach = 0;
508 parent_inf->vfork_child = child_inf;
509 parent_inf->pending_detach = 0;
510 }
511 else
512 {
513 child_inf->aspace = new_address_space ();
514 child_inf->pspace = add_program_space (child_inf->aspace);
515 child_inf->removable = 1;
516 set_current_program_space (child_inf->pspace);
517 clone_program_space (child_inf->pspace, parent_inf->pspace);
518
519 /* Let the shared library layer (e.g., solib-svr4) learn
520 about this new process, relocate the cloned exec, pull
521 in shared libraries, and install the solib event
522 breakpoint. If a "cloned-VM" event was propagated
523 better throughout the core, this wouldn't be
524 required. */
525 solib_create_inferior_hook (0);
526 }
527 }
528
529 if (has_vforked)
530 {
531 struct inferior *parent_inf;
532
533 parent_inf = current_inferior ();
534
535 /* If we detached from the child, then we have to be careful
536 to not insert breakpoints in the parent until the child
537 is done with the shared memory region. However, if we're
538 staying attached to the child, then we can and should
539 insert breakpoints, so that we can debug it. A
540 subsequent child exec or exit is enough to know when does
541 the child stops using the parent's address space. */
542 parent_inf->waiting_for_vfork_done = detach_fork;
543 parent_inf->pspace->breakpoints_not_allowed = detach_fork;
544 }
545 }
546 else
547 {
548 /* Follow the child. */
549 struct inferior *parent_inf, *child_inf;
550 struct program_space *parent_pspace;
551
552 if (info_verbose || debug_infrun)
553 {
554 target_terminal::ours_for_output ();
555 fprintf_filtered (gdb_stdlog,
556 _("Attaching after %s %s to child %s.\n"),
557 target_pid_to_str (parent_ptid),
558 has_vforked ? "vfork" : "fork",
559 target_pid_to_str (child_ptid));
560 }
561
562 /* Add the new inferior first, so that the target_detach below
563 doesn't unpush the target. */
564
565 child_inf = add_inferior (ptid_get_pid (child_ptid));
566
567 parent_inf = current_inferior ();
568 child_inf->attach_flag = parent_inf->attach_flag;
569 copy_terminal_info (child_inf, parent_inf);
570 child_inf->gdbarch = parent_inf->gdbarch;
571 copy_inferior_target_desc_info (child_inf, parent_inf);
572
573 parent_pspace = parent_inf->pspace;
574
575 /* If we're vforking, we want to hold on to the parent until the
576 child exits or execs. At child exec or exit time we can
577 remove the old breakpoints from the parent and detach or
578 resume debugging it. Otherwise, detach the parent now; we'll
579 want to reuse it's program/address spaces, but we can't set
580 them to the child before removing breakpoints from the
581 parent, otherwise, the breakpoints module could decide to
582 remove breakpoints from the wrong process (since they'd be
583 assigned to the same address space). */
584
585 if (has_vforked)
586 {
587 gdb_assert (child_inf->vfork_parent == NULL);
588 gdb_assert (parent_inf->vfork_child == NULL);
589 child_inf->vfork_parent = parent_inf;
590 child_inf->pending_detach = 0;
591 parent_inf->vfork_child = child_inf;
592 parent_inf->pending_detach = detach_fork;
593 parent_inf->waiting_for_vfork_done = 0;
594 }
595 else if (detach_fork)
596 {
597 if (info_verbose || debug_infrun)
598 {
599 /* Ensure that we have a process ptid. */
600 ptid_t process_ptid = pid_to_ptid (ptid_get_pid (child_ptid));
601
602 target_terminal::ours_for_output ();
603 fprintf_filtered (gdb_stdlog,
604 _("Detaching after fork from "
605 "child %s.\n"),
606 target_pid_to_str (process_ptid));
607 }
608
609 target_detach (NULL, 0);
610 }
611
612 /* Note that the detach above makes PARENT_INF dangling. */
613
614 /* Add the child thread to the appropriate lists, and switch to
615 this new thread, before cloning the program space, and
616 informing the solib layer about this new process. */
617
618 inferior_ptid = child_ptid;
619 add_thread (inferior_ptid);
620 set_current_inferior (child_inf);
621
622 /* If this is a vfork child, then the address-space is shared
623 with the parent. If we detached from the parent, then we can
624 reuse the parent's program/address spaces. */
625 if (has_vforked || detach_fork)
626 {
627 child_inf->pspace = parent_pspace;
628 child_inf->aspace = child_inf->pspace->aspace;
629 }
630 else
631 {
632 child_inf->aspace = new_address_space ();
633 child_inf->pspace = add_program_space (child_inf->aspace);
634 child_inf->removable = 1;
635 child_inf->symfile_flags = SYMFILE_NO_READ;
636 set_current_program_space (child_inf->pspace);
637 clone_program_space (child_inf->pspace, parent_pspace);
638
639 /* Let the shared library layer (e.g., solib-svr4) learn
640 about this new process, relocate the cloned exec, pull in
641 shared libraries, and install the solib event breakpoint.
642 If a "cloned-VM" event was propagated better throughout
643 the core, this wouldn't be required. */
644 solib_create_inferior_hook (0);
645 }
646 }
647
648 return target_follow_fork (follow_child, detach_fork);
649 }
650
651 /* Tell the target to follow the fork we're stopped at. Returns true
652 if the inferior should be resumed; false, if the target for some
653 reason decided it's best not to resume. */
654
655 static int
656 follow_fork (void)
657 {
658 int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
659 int should_resume = 1;
660 struct thread_info *tp;
661
662 /* Copy user stepping state to the new inferior thread. FIXME: the
663 followed fork child thread should have a copy of most of the
664 parent thread structure's run control related fields, not just these.
665 Initialized to avoid "may be used uninitialized" warnings from gcc. */
666 struct breakpoint *step_resume_breakpoint = NULL;
667 struct breakpoint *exception_resume_breakpoint = NULL;
668 CORE_ADDR step_range_start = 0;
669 CORE_ADDR step_range_end = 0;
670 struct frame_id step_frame_id = { 0 };
671 struct thread_fsm *thread_fsm = NULL;
672
673 if (!non_stop)
674 {
675 ptid_t wait_ptid;
676 struct target_waitstatus wait_status;
677
678 /* Get the last target status returned by target_wait(). */
679 get_last_target_status (&wait_ptid, &wait_status);
680
681 /* If not stopped at a fork event, then there's nothing else to
682 do. */
683 if (wait_status.kind != TARGET_WAITKIND_FORKED
684 && wait_status.kind != TARGET_WAITKIND_VFORKED)
685 return 1;
686
687 /* Check if we switched over from WAIT_PTID, since the event was
688 reported. */
689 if (!ptid_equal (wait_ptid, minus_one_ptid)
690 && !ptid_equal (inferior_ptid, wait_ptid))
691 {
692 /* We did. Switch back to WAIT_PTID thread, to tell the
693 target to follow it (in either direction). We'll
694 afterwards refuse to resume, and inform the user what
695 happened. */
696 switch_to_thread (wait_ptid);
697 should_resume = 0;
698 }
699 }
700
701 tp = inferior_thread ();
702
703 /* If there were any forks/vforks that were caught and are now to be
704 followed, then do so now. */
705 switch (tp->pending_follow.kind)
706 {
707 case TARGET_WAITKIND_FORKED:
708 case TARGET_WAITKIND_VFORKED:
709 {
710 ptid_t parent, child;
711
712 /* If the user did a next/step, etc, over a fork call,
713 preserve the stepping state in the fork child. */
714 if (follow_child && should_resume)
715 {
716 step_resume_breakpoint = clone_momentary_breakpoint
717 (tp->control.step_resume_breakpoint);
718 step_range_start = tp->control.step_range_start;
719 step_range_end = tp->control.step_range_end;
720 step_frame_id = tp->control.step_frame_id;
721 exception_resume_breakpoint
722 = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint);
723 thread_fsm = tp->thread_fsm;
724
725 /* For now, delete the parent's sr breakpoint, otherwise,
726 parent/child sr breakpoints are considered duplicates,
727 and the child version will not be installed. Remove
728 this when the breakpoints module becomes aware of
729 inferiors and address spaces. */
730 delete_step_resume_breakpoint (tp);
731 tp->control.step_range_start = 0;
732 tp->control.step_range_end = 0;
733 tp->control.step_frame_id = null_frame_id;
734 delete_exception_resume_breakpoint (tp);
735 tp->thread_fsm = NULL;
736 }
737
738 parent = inferior_ptid;
739 child = tp->pending_follow.value.related_pid;
740
741 /* Set up inferior(s) as specified by the caller, and tell the
742 target to do whatever is necessary to follow either parent
743 or child. */
744 if (follow_fork_inferior (follow_child, detach_fork))
745 {
746 /* Target refused to follow, or there's some other reason
747 we shouldn't resume. */
748 should_resume = 0;
749 }
750 else
751 {
752 /* This pending follow fork event is now handled, one way
753 or another. The previous selected thread may be gone
754 from the lists by now, but if it is still around, need
755 to clear the pending follow request. */
756 tp = find_thread_ptid (parent);
757 if (tp)
758 tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
759
760 /* This makes sure we don't try to apply the "Switched
761 over from WAIT_PID" logic above. */
762 nullify_last_target_wait_ptid ();
763
764 /* If we followed the child, switch to it... */
765 if (follow_child)
766 {
767 switch_to_thread (child);
768
769 /* ... and preserve the stepping state, in case the
770 user was stepping over the fork call. */
771 if (should_resume)
772 {
773 tp = inferior_thread ();
774 tp->control.step_resume_breakpoint
775 = step_resume_breakpoint;
776 tp->control.step_range_start = step_range_start;
777 tp->control.step_range_end = step_range_end;
778 tp->control.step_frame_id = step_frame_id;
779 tp->control.exception_resume_breakpoint
780 = exception_resume_breakpoint;
781 tp->thread_fsm = thread_fsm;
782 }
783 else
784 {
785 /* If we get here, it was because we're trying to
786 resume from a fork catchpoint, but, the user
787 has switched threads away from the thread that
788 forked. In that case, the resume command
789 issued is most likely not applicable to the
790 child, so just warn, and refuse to resume. */
791 warning (_("Not resuming: switched threads "
792 "before following fork child."));
793 }
794
795 /* Reset breakpoints in the child as appropriate. */
796 follow_inferior_reset_breakpoints ();
797 }
798 else
799 switch_to_thread (parent);
800 }
801 }
802 break;
803 case TARGET_WAITKIND_SPURIOUS:
804 /* Nothing to follow. */
805 break;
806 default:
807 internal_error (__FILE__, __LINE__,
808 "Unexpected pending_follow.kind %d\n",
809 tp->pending_follow.kind);
810 break;
811 }
812
813 return should_resume;
814 }
815
816 static void
817 follow_inferior_reset_breakpoints (void)
818 {
819 struct thread_info *tp = inferior_thread ();
820
821 /* Was there a step_resume breakpoint? (There was if the user
822 did a "next" at the fork() call.) If so, explicitly reset its
823 thread number. Cloned step_resume breakpoints are disabled on
824 creation, so enable it here now that it is associated with the
825 correct thread.
826
827 step_resumes are a form of bp that are made to be per-thread.
828 Since we created the step_resume bp when the parent process
829 was being debugged, and now are switching to the child process,
830 from the breakpoint package's viewpoint, that's a switch of
831 "threads". We must update the bp's notion of which thread
832 it is for, or it'll be ignored when it triggers. */
833
834 if (tp->control.step_resume_breakpoint)
835 {
836 breakpoint_re_set_thread (tp->control.step_resume_breakpoint);
837 tp->control.step_resume_breakpoint->loc->enabled = 1;
838 }
839
840 /* Treat exception_resume breakpoints like step_resume breakpoints. */
841 if (tp->control.exception_resume_breakpoint)
842 {
843 breakpoint_re_set_thread (tp->control.exception_resume_breakpoint);
844 tp->control.exception_resume_breakpoint->loc->enabled = 1;
845 }
846
847 /* Reinsert all breakpoints in the child. The user may have set
848 breakpoints after catching the fork, in which case those
849 were never set in the child, but only in the parent. This makes
850 sure the inserted breakpoints match the breakpoint list. */
851
852 breakpoint_re_set ();
853 insert_breakpoints ();
854 }
855
856 /* The child has exited or execed: resume threads of the parent the
857 user wanted to be executing. */
858
859 static int
860 proceed_after_vfork_done (struct thread_info *thread,
861 void *arg)
862 {
863 int pid = * (int *) arg;
864
865 if (ptid_get_pid (thread->ptid) == pid
866 && is_running (thread->ptid)
867 && !is_executing (thread->ptid)
868 && !thread->stop_requested
869 && thread->suspend.stop_signal == GDB_SIGNAL_0)
870 {
871 if (debug_infrun)
872 fprintf_unfiltered (gdb_stdlog,
873 "infrun: resuming vfork parent thread %s\n",
874 target_pid_to_str (thread->ptid));
875
876 switch_to_thread (thread->ptid);
877 clear_proceed_status (0);
878 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
879 }
880
881 return 0;
882 }
883
884 /* Save/restore inferior_ptid, current program space and current
885 inferior. Only use this if the current context points at an exited
886 inferior (and therefore there's no current thread to save). */
887 class scoped_restore_exited_inferior
888 {
889 public:
890 scoped_restore_exited_inferior ()
891 : m_saved_ptid (&inferior_ptid)
892 {}
893
894 private:
895 scoped_restore_tmpl<ptid_t> m_saved_ptid;
896 scoped_restore_current_program_space m_pspace;
897 scoped_restore_current_inferior m_inferior;
898 };
899
900 /* Called whenever we notice an exec or exit event, to handle
901 detaching or resuming a vfork parent. */
902
903 static void
904 handle_vfork_child_exec_or_exit (int exec)
905 {
906 struct inferior *inf = current_inferior ();
907
908 if (inf->vfork_parent)
909 {
910 int resume_parent = -1;
911
912 /* This exec or exit marks the end of the shared memory region
913 between the parent and the child. If the user wanted to
914 detach from the parent, now is the time. */
915
916 if (inf->vfork_parent->pending_detach)
917 {
918 struct thread_info *tp;
919 struct program_space *pspace;
920 struct address_space *aspace;
921
922 /* follow-fork child, detach-on-fork on. */
923
924 inf->vfork_parent->pending_detach = 0;
925
926 gdb::optional<scoped_restore_exited_inferior>
927 maybe_restore_inferior;
928 gdb::optional<scoped_restore_current_pspace_and_thread>
929 maybe_restore_thread;
930
931 /* If we're handling a child exit, then inferior_ptid points
932 at the inferior's pid, not to a thread. */
933 if (!exec)
934 maybe_restore_inferior.emplace ();
935 else
936 maybe_restore_thread.emplace ();
937
938 /* We're letting loose of the parent. */
939 tp = any_live_thread_of_process (inf->vfork_parent->pid);
940 switch_to_thread (tp->ptid);
941
942 /* We're about to detach from the parent, which implicitly
943 removes breakpoints from its address space. There's a
944 catch here: we want to reuse the spaces for the child,
945 but, parent/child are still sharing the pspace at this
946 point, although the exec in reality makes the kernel give
947 the child a fresh set of new pages. The problem here is
948 that the breakpoints module being unaware of this, would
949 likely chose the child process to write to the parent
950 address space. Swapping the child temporarily away from
951 the spaces has the desired effect. Yes, this is "sort
952 of" a hack. */
953
954 pspace = inf->pspace;
955 aspace = inf->aspace;
956 inf->aspace = NULL;
957 inf->pspace = NULL;
958
959 if (debug_infrun || info_verbose)
960 {
961 target_terminal::ours_for_output ();
962
963 if (exec)
964 {
965 fprintf_filtered (gdb_stdlog,
966 _("Detaching vfork parent process "
967 "%d after child exec.\n"),
968 inf->vfork_parent->pid);
969 }
970 else
971 {
972 fprintf_filtered (gdb_stdlog,
973 _("Detaching vfork parent process "
974 "%d after child exit.\n"),
975 inf->vfork_parent->pid);
976 }
977 }
978
979 target_detach (NULL, 0);
980
981 /* Put it back. */
982 inf->pspace = pspace;
983 inf->aspace = aspace;
984 }
985 else if (exec)
986 {
987 /* We're staying attached to the parent, so, really give the
988 child a new address space. */
989 inf->pspace = add_program_space (maybe_new_address_space ());
990 inf->aspace = inf->pspace->aspace;
991 inf->removable = 1;
992 set_current_program_space (inf->pspace);
993
994 resume_parent = inf->vfork_parent->pid;
995
996 /* Break the bonds. */
997 inf->vfork_parent->vfork_child = NULL;
998 }
999 else
1000 {
1001 struct program_space *pspace;
1002
1003 /* If this is a vfork child exiting, then the pspace and
1004 aspaces were shared with the parent. Since we're
1005 reporting the process exit, we'll be mourning all that is
1006 found in the address space, and switching to null_ptid,
1007 preparing to start a new inferior. But, since we don't
1008 want to clobber the parent's address/program spaces, we
1009 go ahead and create a new one for this exiting
1010 inferior. */
1011
1012 /* Switch to null_ptid while running clone_program_space, so
1013 that clone_program_space doesn't want to read the
1014 selected frame of a dead process. */
1015 scoped_restore restore_ptid
1016 = make_scoped_restore (&inferior_ptid, null_ptid);
1017
1018 /* This inferior is dead, so avoid giving the breakpoints
1019 module the option to write through to it (cloning a
1020 program space resets breakpoints). */
1021 inf->aspace = NULL;
1022 inf->pspace = NULL;
1023 pspace = add_program_space (maybe_new_address_space ());
1024 set_current_program_space (pspace);
1025 inf->removable = 1;
1026 inf->symfile_flags = SYMFILE_NO_READ;
1027 clone_program_space (pspace, inf->vfork_parent->pspace);
1028 inf->pspace = pspace;
1029 inf->aspace = pspace->aspace;
1030
1031 resume_parent = inf->vfork_parent->pid;
1032 /* Break the bonds. */
1033 inf->vfork_parent->vfork_child = NULL;
1034 }
1035
1036 inf->vfork_parent = NULL;
1037
1038 gdb_assert (current_program_space == inf->pspace);
1039
1040 if (non_stop && resume_parent != -1)
1041 {
1042 /* If the user wanted the parent to be running, let it go
1043 free now. */
1044 scoped_restore_current_thread restore_thread;
1045
1046 if (debug_infrun)
1047 fprintf_unfiltered (gdb_stdlog,
1048 "infrun: resuming vfork parent process %d\n",
1049 resume_parent);
1050
1051 iterate_over_threads (proceed_after_vfork_done, &resume_parent);
1052 }
1053 }
1054 }
1055
1056 /* Enum strings for "set|show follow-exec-mode". */
1057
1058 static const char follow_exec_mode_new[] = "new";
1059 static const char follow_exec_mode_same[] = "same";
1060 static const char *const follow_exec_mode_names[] =
1061 {
1062 follow_exec_mode_new,
1063 follow_exec_mode_same,
1064 NULL,
1065 };
1066
1067 static const char *follow_exec_mode_string = follow_exec_mode_same;
1068 static void
1069 show_follow_exec_mode_string (struct ui_file *file, int from_tty,
1070 struct cmd_list_element *c, const char *value)
1071 {
1072 fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"), value);
1073 }
1074
1075 /* EXEC_FILE_TARGET is assumed to be non-NULL. */
1076
1077 static void
1078 follow_exec (ptid_t ptid, char *exec_file_target)
1079 {
1080 struct thread_info *th, *tmp;
1081 struct inferior *inf = current_inferior ();
1082 int pid = ptid_get_pid (ptid);
1083 ptid_t process_ptid;
1084 char *exec_file_host;
1085 struct cleanup *old_chain;
1086
1087 /* This is an exec event that we actually wish to pay attention to.
1088 Refresh our symbol table to the newly exec'd program, remove any
1089 momentary bp's, etc.
1090
1091 If there are breakpoints, they aren't really inserted now,
1092 since the exec() transformed our inferior into a fresh set
1093 of instructions.
1094
1095 We want to preserve symbolic breakpoints on the list, since
1096 we have hopes that they can be reset after the new a.out's
1097 symbol table is read.
1098
1099 However, any "raw" breakpoints must be removed from the list
1100 (e.g., the solib bp's), since their address is probably invalid
1101 now.
1102
1103 And, we DON'T want to call delete_breakpoints() here, since
1104 that may write the bp's "shadow contents" (the instruction
1105 value that was overwritten witha TRAP instruction). Since
1106 we now have a new a.out, those shadow contents aren't valid. */
1107
1108 mark_breakpoints_out ();
1109
1110 /* The target reports the exec event to the main thread, even if
1111 some other thread does the exec, and even if the main thread was
1112 stopped or already gone. We may still have non-leader threads of
1113 the process on our list. E.g., on targets that don't have thread
1114 exit events (like remote); or on native Linux in non-stop mode if
1115 there were only two threads in the inferior and the non-leader
1116 one is the one that execs (and nothing forces an update of the
1117 thread list up to here). When debugging remotely, it's best to
1118 avoid extra traffic, when possible, so avoid syncing the thread
1119 list with the target, and instead go ahead and delete all threads
1120 of the process but one that reported the event. Note this must
1121 be done before calling update_breakpoints_after_exec, as
1122 otherwise clearing the threads' resources would reference stale
1123 thread breakpoints -- it may have been one of these threads that
1124 stepped across the exec. We could just clear their stepping
1125 states, but as long as we're iterating, might as well delete
1126 them. Deleting them now rather than at the next user-visible
1127 stop provides a nicer sequence of events for user and MI
1128 notifications. */
1129 ALL_THREADS_SAFE (th, tmp)
1130 if (ptid_get_pid (th->ptid) == pid && !ptid_equal (th->ptid, ptid))
1131 delete_thread (th->ptid);
1132
1133 /* We also need to clear any left over stale state for the
1134 leader/event thread. E.g., if there was any step-resume
1135 breakpoint or similar, it's gone now. We cannot truly
1136 step-to-next statement through an exec(). */
1137 th = inferior_thread ();
1138 th->control.step_resume_breakpoint = NULL;
1139 th->control.exception_resume_breakpoint = NULL;
1140 th->control.single_step_breakpoints = NULL;
1141 th->control.step_range_start = 0;
1142 th->control.step_range_end = 0;
1143
1144 /* The user may have had the main thread held stopped in the
1145 previous image (e.g., schedlock on, or non-stop). Release
1146 it now. */
1147 th->stop_requested = 0;
1148
1149 update_breakpoints_after_exec ();
1150
1151 /* What is this a.out's name? */
1152 process_ptid = pid_to_ptid (pid);
1153 printf_unfiltered (_("%s is executing new program: %s\n"),
1154 target_pid_to_str (process_ptid),
1155 exec_file_target);
1156
1157 /* We've followed the inferior through an exec. Therefore, the
1158 inferior has essentially been killed & reborn. */
1159
1160 gdb_flush (gdb_stdout);
1161
1162 breakpoint_init_inferior (inf_execd);
1163
1164 exec_file_host = exec_file_find (exec_file_target, NULL);
1165 old_chain = make_cleanup (xfree, exec_file_host);
1166
1167 /* If we were unable to map the executable target pathname onto a host
1168 pathname, tell the user that. Otherwise GDB's subsequent behavior
1169 is confusing. Maybe it would even be better to stop at this point
1170 so that the user can specify a file manually before continuing. */
1171 if (exec_file_host == NULL)
1172 warning (_("Could not load symbols for executable %s.\n"
1173 "Do you need \"set sysroot\"?"),
1174 exec_file_target);
1175
1176 /* Reset the shared library package. This ensures that we get a
1177 shlib event when the child reaches "_start", at which point the
1178 dld will have had a chance to initialize the child. */
1179 /* Also, loading a symbol file below may trigger symbol lookups, and
1180 we don't want those to be satisfied by the libraries of the
1181 previous incarnation of this process. */
1182 no_shared_libraries (NULL, 0);
1183
1184 if (follow_exec_mode_string == follow_exec_mode_new)
1185 {
1186 /* The user wants to keep the old inferior and program spaces
1187 around. Create a new fresh one, and switch to it. */
1188
1189 /* Do exit processing for the original inferior before adding
1190 the new inferior so we don't have two active inferiors with
1191 the same ptid, which can confuse find_inferior_ptid. */
1192 exit_inferior_num_silent (current_inferior ()->num);
1193
1194 inf = add_inferior_with_spaces ();
1195 inf->pid = pid;
1196 target_follow_exec (inf, exec_file_target);
1197
1198 set_current_inferior (inf);
1199 set_current_program_space (inf->pspace);
1200 }
1201 else
1202 {
1203 /* The old description may no longer be fit for the new image.
1204 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1205 old description; we'll read a new one below. No need to do
1206 this on "follow-exec-mode new", as the old inferior stays
1207 around (its description is later cleared/refetched on
1208 restart). */
1209 target_clear_description ();
1210 }
1211
1212 gdb_assert (current_program_space == inf->pspace);
1213
1214 /* Attempt to open the exec file. SYMFILE_DEFER_BP_RESET is used
1215 because the proper displacement for a PIE (Position Independent
1216 Executable) main symbol file will only be computed by
1217 solib_create_inferior_hook below. breakpoint_re_set would fail
1218 to insert the breakpoints with the zero displacement. */
1219 try_open_exec_file (exec_file_host, inf, SYMFILE_DEFER_BP_RESET);
1220
1221 do_cleanups (old_chain);
1222
1223 /* If the target can specify a description, read it. Must do this
1224 after flipping to the new executable (because the target supplied
1225 description must be compatible with the executable's
1226 architecture, and the old executable may e.g., be 32-bit, while
1227 the new one 64-bit), and before anything involving memory or
1228 registers. */
1229 target_find_description ();
1230
1231 /* The add_thread call ends up reading registers, so do it after updating the
1232 target description. */
1233 if (follow_exec_mode_string == follow_exec_mode_new)
1234 add_thread (ptid);
1235
1236 solib_create_inferior_hook (0);
1237
1238 jit_inferior_created_hook ();
1239
1240 breakpoint_re_set ();
1241
1242 /* Reinsert all breakpoints. (Those which were symbolic have
1243 been reset to the proper address in the new a.out, thanks
1244 to symbol_file_command...). */
1245 insert_breakpoints ();
1246
1247 /* The next resume of this inferior should bring it to the shlib
1248 startup breakpoints. (If the user had also set bp's on
1249 "main" from the old (parent) process, then they'll auto-
1250 matically get reset there in the new process.). */
1251 }
1252
1253 /* The queue of threads that need to do a step-over operation to get
1254 past e.g., a breakpoint. What technique is used to step over the
1255 breakpoint/watchpoint does not matter -- all threads end up in the
1256 same queue, to maintain rough temporal order of execution, in order
1257 to avoid starvation, otherwise, we could e.g., find ourselves
1258 constantly stepping the same couple threads past their breakpoints
1259 over and over, if the single-step finish fast enough. */
1260 struct thread_info *step_over_queue_head;
1261
1262 /* Bit flags indicating what the thread needs to step over. */
1263
1264 enum step_over_what_flag
1265 {
1266 /* Step over a breakpoint. */
1267 STEP_OVER_BREAKPOINT = 1,
1268
1269 /* Step past a non-continuable watchpoint, in order to let the
1270 instruction execute so we can evaluate the watchpoint
1271 expression. */
1272 STEP_OVER_WATCHPOINT = 2
1273 };
1274 DEF_ENUM_FLAGS_TYPE (enum step_over_what_flag, step_over_what);
1275
1276 /* Info about an instruction that is being stepped over. */
1277
1278 struct step_over_info
1279 {
1280 /* If we're stepping past a breakpoint, this is the address space
1281 and address of the instruction the breakpoint is set at. We'll
1282 skip inserting all breakpoints here. Valid iff ASPACE is
1283 non-NULL. */
1284 const address_space *aspace;
1285 CORE_ADDR address;
1286
1287 /* The instruction being stepped over triggers a nonsteppable
1288 watchpoint. If true, we'll skip inserting watchpoints. */
1289 int nonsteppable_watchpoint_p;
1290
1291 /* The thread's global number. */
1292 int thread;
1293 };
1294
1295 /* The step-over info of the location that is being stepped over.
1296
1297 Note that with async/breakpoint always-inserted mode, a user might
1298 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1299 being stepped over. As setting a new breakpoint inserts all
1300 breakpoints, we need to make sure the breakpoint being stepped over
1301 isn't inserted then. We do that by only clearing the step-over
1302 info when the step-over is actually finished (or aborted).
1303
1304 Presently GDB can only step over one breakpoint at any given time.
1305 Given threads that can't run code in the same address space as the
1306 breakpoint's can't really miss the breakpoint, GDB could be taught
1307 to step-over at most one breakpoint per address space (so this info
1308 could move to the address space object if/when GDB is extended).
1309 The set of breakpoints being stepped over will normally be much
1310 smaller than the set of all breakpoints, so a flag in the
1311 breakpoint location structure would be wasteful. A separate list
1312 also saves complexity and run-time, as otherwise we'd have to go
1313 through all breakpoint locations clearing their flag whenever we
1314 start a new sequence. Similar considerations weigh against storing
1315 this info in the thread object. Plus, not all step overs actually
1316 have breakpoint locations -- e.g., stepping past a single-step
1317 breakpoint, or stepping to complete a non-continuable
1318 watchpoint. */
1319 static struct step_over_info step_over_info;
1320
1321 /* Record the address of the breakpoint/instruction we're currently
1322 stepping over.
1323 N.B. We record the aspace and address now, instead of say just the thread,
1324 because when we need the info later the thread may be running. */
1325
1326 static void
1327 set_step_over_info (const address_space *aspace, CORE_ADDR address,
1328 int nonsteppable_watchpoint_p,
1329 int thread)
1330 {
1331 step_over_info.aspace = aspace;
1332 step_over_info.address = address;
1333 step_over_info.nonsteppable_watchpoint_p = nonsteppable_watchpoint_p;
1334 step_over_info.thread = thread;
1335 }
1336
1337 /* Called when we're not longer stepping over a breakpoint / an
1338 instruction, so all breakpoints are free to be (re)inserted. */
1339
1340 static void
1341 clear_step_over_info (void)
1342 {
1343 if (debug_infrun)
1344 fprintf_unfiltered (gdb_stdlog,
1345 "infrun: clear_step_over_info\n");
1346 step_over_info.aspace = NULL;
1347 step_over_info.address = 0;
1348 step_over_info.nonsteppable_watchpoint_p = 0;
1349 step_over_info.thread = -1;
1350 }
1351
1352 /* See infrun.h. */
1353
1354 int
1355 stepping_past_instruction_at (struct address_space *aspace,
1356 CORE_ADDR address)
1357 {
1358 return (step_over_info.aspace != NULL
1359 && breakpoint_address_match (aspace, address,
1360 step_over_info.aspace,
1361 step_over_info.address));
1362 }
1363
1364 /* See infrun.h. */
1365
1366 int
1367 thread_is_stepping_over_breakpoint (int thread)
1368 {
1369 return (step_over_info.thread != -1
1370 && thread == step_over_info.thread);
1371 }
1372
1373 /* See infrun.h. */
1374
1375 int
1376 stepping_past_nonsteppable_watchpoint (void)
1377 {
1378 return step_over_info.nonsteppable_watchpoint_p;
1379 }
1380
1381 /* Returns true if step-over info is valid. */
1382
1383 static int
1384 step_over_info_valid_p (void)
1385 {
1386 return (step_over_info.aspace != NULL
1387 || stepping_past_nonsteppable_watchpoint ());
1388 }
1389
1390
1391 /* Displaced stepping. */
1392
1393 /* In non-stop debugging mode, we must take special care to manage
1394 breakpoints properly; in particular, the traditional strategy for
1395 stepping a thread past a breakpoint it has hit is unsuitable.
1396 'Displaced stepping' is a tactic for stepping one thread past a
1397 breakpoint it has hit while ensuring that other threads running
1398 concurrently will hit the breakpoint as they should.
1399
1400 The traditional way to step a thread T off a breakpoint in a
1401 multi-threaded program in all-stop mode is as follows:
1402
1403 a0) Initially, all threads are stopped, and breakpoints are not
1404 inserted.
1405 a1) We single-step T, leaving breakpoints uninserted.
1406 a2) We insert breakpoints, and resume all threads.
1407
1408 In non-stop debugging, however, this strategy is unsuitable: we
1409 don't want to have to stop all threads in the system in order to
1410 continue or step T past a breakpoint. Instead, we use displaced
1411 stepping:
1412
1413 n0) Initially, T is stopped, other threads are running, and
1414 breakpoints are inserted.
1415 n1) We copy the instruction "under" the breakpoint to a separate
1416 location, outside the main code stream, making any adjustments
1417 to the instruction, register, and memory state as directed by
1418 T's architecture.
1419 n2) We single-step T over the instruction at its new location.
1420 n3) We adjust the resulting register and memory state as directed
1421 by T's architecture. This includes resetting T's PC to point
1422 back into the main instruction stream.
1423 n4) We resume T.
1424
1425 This approach depends on the following gdbarch methods:
1426
1427 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1428 indicate where to copy the instruction, and how much space must
1429 be reserved there. We use these in step n1.
1430
1431 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1432 address, and makes any necessary adjustments to the instruction,
1433 register contents, and memory. We use this in step n1.
1434
1435 - gdbarch_displaced_step_fixup adjusts registers and memory after
1436 we have successfuly single-stepped the instruction, to yield the
1437 same effect the instruction would have had if we had executed it
1438 at its original address. We use this in step n3.
1439
1440 The gdbarch_displaced_step_copy_insn and
1441 gdbarch_displaced_step_fixup functions must be written so that
1442 copying an instruction with gdbarch_displaced_step_copy_insn,
1443 single-stepping across the copied instruction, and then applying
1444 gdbarch_displaced_insn_fixup should have the same effects on the
1445 thread's memory and registers as stepping the instruction in place
1446 would have. Exactly which responsibilities fall to the copy and
1447 which fall to the fixup is up to the author of those functions.
1448
1449 See the comments in gdbarch.sh for details.
1450
1451 Note that displaced stepping and software single-step cannot
1452 currently be used in combination, although with some care I think
1453 they could be made to. Software single-step works by placing
1454 breakpoints on all possible subsequent instructions; if the
1455 displaced instruction is a PC-relative jump, those breakpoints
1456 could fall in very strange places --- on pages that aren't
1457 executable, or at addresses that are not proper instruction
1458 boundaries. (We do generally let other threads run while we wait
1459 to hit the software single-step breakpoint, and they might
1460 encounter such a corrupted instruction.) One way to work around
1461 this would be to have gdbarch_displaced_step_copy_insn fully
1462 simulate the effect of PC-relative instructions (and return NULL)
1463 on architectures that use software single-stepping.
1464
1465 In non-stop mode, we can have independent and simultaneous step
1466 requests, so more than one thread may need to simultaneously step
1467 over a breakpoint. The current implementation assumes there is
1468 only one scratch space per process. In this case, we have to
1469 serialize access to the scratch space. If thread A wants to step
1470 over a breakpoint, but we are currently waiting for some other
1471 thread to complete a displaced step, we leave thread A stopped and
1472 place it in the displaced_step_request_queue. Whenever a displaced
1473 step finishes, we pick the next thread in the queue and start a new
1474 displaced step operation on it. See displaced_step_prepare and
1475 displaced_step_fixup for details. */
1476
1477 /* Default destructor for displaced_step_closure. */
1478
1479 displaced_step_closure::~displaced_step_closure () = default;
1480
1481 /* Per-inferior displaced stepping state. */
1482 struct displaced_step_inferior_state
1483 {
1484 /* Pointer to next in linked list. */
1485 struct displaced_step_inferior_state *next;
1486
1487 /* The process this displaced step state refers to. */
1488 int pid;
1489
1490 /* True if preparing a displaced step ever failed. If so, we won't
1491 try displaced stepping for this inferior again. */
1492 int failed_before;
1493
1494 /* If this is not null_ptid, this is the thread carrying out a
1495 displaced single-step in process PID. This thread's state will
1496 require fixing up once it has completed its step. */
1497 ptid_t step_ptid;
1498
1499 /* The architecture the thread had when we stepped it. */
1500 struct gdbarch *step_gdbarch;
1501
1502 /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1503 for post-step cleanup. */
1504 struct displaced_step_closure *step_closure;
1505
1506 /* The address of the original instruction, and the copy we
1507 made. */
1508 CORE_ADDR step_original, step_copy;
1509
1510 /* Saved contents of copy area. */
1511 gdb_byte *step_saved_copy;
1512 };
1513
1514 /* The list of states of processes involved in displaced stepping
1515 presently. */
1516 static struct displaced_step_inferior_state *displaced_step_inferior_states;
1517
1518 /* Get the displaced stepping state of process PID. */
1519
1520 static struct displaced_step_inferior_state *
1521 get_displaced_stepping_state (int pid)
1522 {
1523 struct displaced_step_inferior_state *state;
1524
1525 for (state = displaced_step_inferior_states;
1526 state != NULL;
1527 state = state->next)
1528 if (state->pid == pid)
1529 return state;
1530
1531 return NULL;
1532 }
1533
1534 /* Returns true if any inferior has a thread doing a displaced
1535 step. */
1536
1537 static int
1538 displaced_step_in_progress_any_inferior (void)
1539 {
1540 struct displaced_step_inferior_state *state;
1541
1542 for (state = displaced_step_inferior_states;
1543 state != NULL;
1544 state = state->next)
1545 if (!ptid_equal (state->step_ptid, null_ptid))
1546 return 1;
1547
1548 return 0;
1549 }
1550
1551 /* Return true if thread represented by PTID is doing a displaced
1552 step. */
1553
1554 static int
1555 displaced_step_in_progress_thread (ptid_t ptid)
1556 {
1557 struct displaced_step_inferior_state *displaced;
1558
1559 gdb_assert (!ptid_equal (ptid, null_ptid));
1560
1561 displaced = get_displaced_stepping_state (ptid_get_pid (ptid));
1562
1563 return (displaced != NULL && ptid_equal (displaced->step_ptid, ptid));
1564 }
1565
1566 /* Return true if process PID has a thread doing a displaced step. */
1567
1568 static int
1569 displaced_step_in_progress (int pid)
1570 {
1571 struct displaced_step_inferior_state *displaced;
1572
1573 displaced = get_displaced_stepping_state (pid);
1574 if (displaced != NULL && !ptid_equal (displaced->step_ptid, null_ptid))
1575 return 1;
1576
1577 return 0;
1578 }
1579
1580 /* Add a new displaced stepping state for process PID to the displaced
1581 stepping state list, or return a pointer to an already existing
1582 entry, if it already exists. Never returns NULL. */
1583
1584 static struct displaced_step_inferior_state *
1585 add_displaced_stepping_state (int pid)
1586 {
1587 struct displaced_step_inferior_state *state;
1588
1589 for (state = displaced_step_inferior_states;
1590 state != NULL;
1591 state = state->next)
1592 if (state->pid == pid)
1593 return state;
1594
1595 state = XCNEW (struct displaced_step_inferior_state);
1596 state->pid = pid;
1597 state->next = displaced_step_inferior_states;
1598 displaced_step_inferior_states = state;
1599
1600 return state;
1601 }
1602
1603 /* If inferior is in displaced stepping, and ADDR equals to starting address
1604 of copy area, return corresponding displaced_step_closure. Otherwise,
1605 return NULL. */
1606
1607 struct displaced_step_closure*
1608 get_displaced_step_closure_by_addr (CORE_ADDR addr)
1609 {
1610 struct displaced_step_inferior_state *displaced
1611 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
1612
1613 /* If checking the mode of displaced instruction in copy area. */
1614 if (displaced && !ptid_equal (displaced->step_ptid, null_ptid)
1615 && (displaced->step_copy == addr))
1616 return displaced->step_closure;
1617
1618 return NULL;
1619 }
1620
1621 /* Remove the displaced stepping state of process PID. */
1622
1623 static void
1624 remove_displaced_stepping_state (int pid)
1625 {
1626 struct displaced_step_inferior_state *it, **prev_next_p;
1627
1628 gdb_assert (pid != 0);
1629
1630 it = displaced_step_inferior_states;
1631 prev_next_p = &displaced_step_inferior_states;
1632 while (it)
1633 {
1634 if (it->pid == pid)
1635 {
1636 *prev_next_p = it->next;
1637 xfree (it);
1638 return;
1639 }
1640
1641 prev_next_p = &it->next;
1642 it = *prev_next_p;
1643 }
1644 }
1645
1646 static void
1647 infrun_inferior_exit (struct inferior *inf)
1648 {
1649 remove_displaced_stepping_state (inf->pid);
1650 }
1651
1652 /* If ON, and the architecture supports it, GDB will use displaced
1653 stepping to step over breakpoints. If OFF, or if the architecture
1654 doesn't support it, GDB will instead use the traditional
1655 hold-and-step approach. If AUTO (which is the default), GDB will
1656 decide which technique to use to step over breakpoints depending on
1657 which of all-stop or non-stop mode is active --- displaced stepping
1658 in non-stop mode; hold-and-step in all-stop mode. */
1659
1660 static enum auto_boolean can_use_displaced_stepping = AUTO_BOOLEAN_AUTO;
1661
1662 static void
1663 show_can_use_displaced_stepping (struct ui_file *file, int from_tty,
1664 struct cmd_list_element *c,
1665 const char *value)
1666 {
1667 if (can_use_displaced_stepping == AUTO_BOOLEAN_AUTO)
1668 fprintf_filtered (file,
1669 _("Debugger's willingness to use displaced stepping "
1670 "to step over breakpoints is %s (currently %s).\n"),
1671 value, target_is_non_stop_p () ? "on" : "off");
1672 else
1673 fprintf_filtered (file,
1674 _("Debugger's willingness to use displaced stepping "
1675 "to step over breakpoints is %s.\n"), value);
1676 }
1677
1678 /* Return non-zero if displaced stepping can/should be used to step
1679 over breakpoints of thread TP. */
1680
1681 static int
1682 use_displaced_stepping (struct thread_info *tp)
1683 {
1684 struct regcache *regcache = get_thread_regcache (tp->ptid);
1685 struct gdbarch *gdbarch = regcache->arch ();
1686 struct displaced_step_inferior_state *displaced_state;
1687
1688 displaced_state = get_displaced_stepping_state (ptid_get_pid (tp->ptid));
1689
1690 return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO
1691 && target_is_non_stop_p ())
1692 || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1693 && gdbarch_displaced_step_copy_insn_p (gdbarch)
1694 && find_record_target () == NULL
1695 && (displaced_state == NULL
1696 || !displaced_state->failed_before));
1697 }
1698
1699 /* Clean out any stray displaced stepping state. */
1700 static void
1701 displaced_step_clear (struct displaced_step_inferior_state *displaced)
1702 {
1703 /* Indicate that there is no cleanup pending. */
1704 displaced->step_ptid = null_ptid;
1705
1706 delete displaced->step_closure;
1707 displaced->step_closure = NULL;
1708 }
1709
1710 static void
1711 displaced_step_clear_cleanup (void *arg)
1712 {
1713 struct displaced_step_inferior_state *state
1714 = (struct displaced_step_inferior_state *) arg;
1715
1716 displaced_step_clear (state);
1717 }
1718
1719 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1720 void
1721 displaced_step_dump_bytes (struct ui_file *file,
1722 const gdb_byte *buf,
1723 size_t len)
1724 {
1725 int i;
1726
1727 for (i = 0; i < len; i++)
1728 fprintf_unfiltered (file, "%02x ", buf[i]);
1729 fputs_unfiltered ("\n", file);
1730 }
1731
1732 /* Prepare to single-step, using displaced stepping.
1733
1734 Note that we cannot use displaced stepping when we have a signal to
1735 deliver. If we have a signal to deliver and an instruction to step
1736 over, then after the step, there will be no indication from the
1737 target whether the thread entered a signal handler or ignored the
1738 signal and stepped over the instruction successfully --- both cases
1739 result in a simple SIGTRAP. In the first case we mustn't do a
1740 fixup, and in the second case we must --- but we can't tell which.
1741 Comments in the code for 'random signals' in handle_inferior_event
1742 explain how we handle this case instead.
1743
1744 Returns 1 if preparing was successful -- this thread is going to be
1745 stepped now; 0 if displaced stepping this thread got queued; or -1
1746 if this instruction can't be displaced stepped. */
1747
1748 static int
1749 displaced_step_prepare_throw (ptid_t ptid)
1750 {
1751 struct cleanup *ignore_cleanups;
1752 struct thread_info *tp = find_thread_ptid (ptid);
1753 struct regcache *regcache = get_thread_regcache (ptid);
1754 struct gdbarch *gdbarch = regcache->arch ();
1755 const address_space *aspace = regcache->aspace ();
1756 CORE_ADDR original, copy;
1757 ULONGEST len;
1758 struct displaced_step_closure *closure;
1759 struct displaced_step_inferior_state *displaced;
1760 int status;
1761
1762 /* We should never reach this function if the architecture does not
1763 support displaced stepping. */
1764 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch));
1765
1766 /* Nor if the thread isn't meant to step over a breakpoint. */
1767 gdb_assert (tp->control.trap_expected);
1768
1769 /* Disable range stepping while executing in the scratch pad. We
1770 want a single-step even if executing the displaced instruction in
1771 the scratch buffer lands within the stepping range (e.g., a
1772 jump/branch). */
1773 tp->control.may_range_step = 0;
1774
1775 /* We have to displaced step one thread at a time, as we only have
1776 access to a single scratch space per inferior. */
1777
1778 displaced = add_displaced_stepping_state (ptid_get_pid (ptid));
1779
1780 if (!ptid_equal (displaced->step_ptid, null_ptid))
1781 {
1782 /* Already waiting for a displaced step to finish. Defer this
1783 request and place in queue. */
1784
1785 if (debug_displaced)
1786 fprintf_unfiltered (gdb_stdlog,
1787 "displaced: deferring step of %s\n",
1788 target_pid_to_str (ptid));
1789
1790 thread_step_over_chain_enqueue (tp);
1791 return 0;
1792 }
1793 else
1794 {
1795 if (debug_displaced)
1796 fprintf_unfiltered (gdb_stdlog,
1797 "displaced: stepping %s now\n",
1798 target_pid_to_str (ptid));
1799 }
1800
1801 displaced_step_clear (displaced);
1802
1803 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1804 inferior_ptid = ptid;
1805
1806 original = regcache_read_pc (regcache);
1807
1808 copy = gdbarch_displaced_step_location (gdbarch);
1809 len = gdbarch_max_insn_length (gdbarch);
1810
1811 if (breakpoint_in_range_p (aspace, copy, len))
1812 {
1813 /* There's a breakpoint set in the scratch pad location range
1814 (which is usually around the entry point). We'd either
1815 install it before resuming, which would overwrite/corrupt the
1816 scratch pad, or if it was already inserted, this displaced
1817 step would overwrite it. The latter is OK in the sense that
1818 we already assume that no thread is going to execute the code
1819 in the scratch pad range (after initial startup) anyway, but
1820 the former is unacceptable. Simply punt and fallback to
1821 stepping over this breakpoint in-line. */
1822 if (debug_displaced)
1823 {
1824 fprintf_unfiltered (gdb_stdlog,
1825 "displaced: breakpoint set in scratch pad. "
1826 "Stepping over breakpoint in-line instead.\n");
1827 }
1828
1829 return -1;
1830 }
1831
1832 /* Save the original contents of the copy area. */
1833 displaced->step_saved_copy = (gdb_byte *) xmalloc (len);
1834 ignore_cleanups = make_cleanup (free_current_contents,
1835 &displaced->step_saved_copy);
1836 status = target_read_memory (copy, displaced->step_saved_copy, len);
1837 if (status != 0)
1838 throw_error (MEMORY_ERROR,
1839 _("Error accessing memory address %s (%s) for "
1840 "displaced-stepping scratch space."),
1841 paddress (gdbarch, copy), safe_strerror (status));
1842 if (debug_displaced)
1843 {
1844 fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
1845 paddress (gdbarch, copy));
1846 displaced_step_dump_bytes (gdb_stdlog,
1847 displaced->step_saved_copy,
1848 len);
1849 };
1850
1851 closure = gdbarch_displaced_step_copy_insn (gdbarch,
1852 original, copy, regcache);
1853 if (closure == NULL)
1854 {
1855 /* The architecture doesn't know how or want to displaced step
1856 this instruction or instruction sequence. Fallback to
1857 stepping over the breakpoint in-line. */
1858 do_cleanups (ignore_cleanups);
1859 return -1;
1860 }
1861
1862 /* Save the information we need to fix things up if the step
1863 succeeds. */
1864 displaced->step_ptid = ptid;
1865 displaced->step_gdbarch = gdbarch;
1866 displaced->step_closure = closure;
1867 displaced->step_original = original;
1868 displaced->step_copy = copy;
1869
1870 make_cleanup (displaced_step_clear_cleanup, displaced);
1871
1872 /* Resume execution at the copy. */
1873 regcache_write_pc (regcache, copy);
1874
1875 discard_cleanups (ignore_cleanups);
1876
1877 if (debug_displaced)
1878 fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
1879 paddress (gdbarch, copy));
1880
1881 return 1;
1882 }
1883
1884 /* Wrapper for displaced_step_prepare_throw that disabled further
1885 attempts at displaced stepping if we get a memory error. */
1886
1887 static int
1888 displaced_step_prepare (ptid_t ptid)
1889 {
1890 int prepared = -1;
1891
1892 TRY
1893 {
1894 prepared = displaced_step_prepare_throw (ptid);
1895 }
1896 CATCH (ex, RETURN_MASK_ERROR)
1897 {
1898 struct displaced_step_inferior_state *displaced_state;
1899
1900 if (ex.error != MEMORY_ERROR
1901 && ex.error != NOT_SUPPORTED_ERROR)
1902 throw_exception (ex);
1903
1904 if (debug_infrun)
1905 {
1906 fprintf_unfiltered (gdb_stdlog,
1907 "infrun: disabling displaced stepping: %s\n",
1908 ex.message);
1909 }
1910
1911 /* Be verbose if "set displaced-stepping" is "on", silent if
1912 "auto". */
1913 if (can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1914 {
1915 warning (_("disabling displaced stepping: %s"),
1916 ex.message);
1917 }
1918
1919 /* Disable further displaced stepping attempts. */
1920 displaced_state
1921 = get_displaced_stepping_state (ptid_get_pid (ptid));
1922 displaced_state->failed_before = 1;
1923 }
1924 END_CATCH
1925
1926 return prepared;
1927 }
1928
1929 static void
1930 write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr,
1931 const gdb_byte *myaddr, int len)
1932 {
1933 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1934
1935 inferior_ptid = ptid;
1936 write_memory (memaddr, myaddr, len);
1937 }
1938
1939 /* Restore the contents of the copy area for thread PTID. */
1940
1941 static void
1942 displaced_step_restore (struct displaced_step_inferior_state *displaced,
1943 ptid_t ptid)
1944 {
1945 ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
1946
1947 write_memory_ptid (ptid, displaced->step_copy,
1948 displaced->step_saved_copy, len);
1949 if (debug_displaced)
1950 fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
1951 target_pid_to_str (ptid),
1952 paddress (displaced->step_gdbarch,
1953 displaced->step_copy));
1954 }
1955
1956 /* If we displaced stepped an instruction successfully, adjust
1957 registers and memory to yield the same effect the instruction would
1958 have had if we had executed it at its original address, and return
1959 1. If the instruction didn't complete, relocate the PC and return
1960 -1. If the thread wasn't displaced stepping, return 0. */
1961
1962 static int
1963 displaced_step_fixup (ptid_t event_ptid, enum gdb_signal signal)
1964 {
1965 struct cleanup *old_cleanups;
1966 struct displaced_step_inferior_state *displaced
1967 = get_displaced_stepping_state (ptid_get_pid (event_ptid));
1968 int ret;
1969
1970 /* Was any thread of this process doing a displaced step? */
1971 if (displaced == NULL)
1972 return 0;
1973
1974 /* Was this event for the pid we displaced? */
1975 if (ptid_equal (displaced->step_ptid, null_ptid)
1976 || ! ptid_equal (displaced->step_ptid, event_ptid))
1977 return 0;
1978
1979 old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
1980
1981 displaced_step_restore (displaced, displaced->step_ptid);
1982
1983 /* Fixup may need to read memory/registers. Switch to the thread
1984 that we're fixing up. Also, target_stopped_by_watchpoint checks
1985 the current thread. */
1986 switch_to_thread (event_ptid);
1987
1988 /* Did the instruction complete successfully? */
1989 if (signal == GDB_SIGNAL_TRAP
1990 && !(target_stopped_by_watchpoint ()
1991 && (gdbarch_have_nonsteppable_watchpoint (displaced->step_gdbarch)
1992 || target_have_steppable_watchpoint)))
1993 {
1994 /* Fix up the resulting state. */
1995 gdbarch_displaced_step_fixup (displaced->step_gdbarch,
1996 displaced->step_closure,
1997 displaced->step_original,
1998 displaced->step_copy,
1999 get_thread_regcache (displaced->step_ptid));
2000 ret = 1;
2001 }
2002 else
2003 {
2004 /* Since the instruction didn't complete, all we can do is
2005 relocate the PC. */
2006 struct regcache *regcache = get_thread_regcache (event_ptid);
2007 CORE_ADDR pc = regcache_read_pc (regcache);
2008
2009 pc = displaced->step_original + (pc - displaced->step_copy);
2010 regcache_write_pc (regcache, pc);
2011 ret = -1;
2012 }
2013
2014 do_cleanups (old_cleanups);
2015
2016 displaced->step_ptid = null_ptid;
2017
2018 return ret;
2019 }
2020
2021 /* Data to be passed around while handling an event. This data is
2022 discarded between events. */
2023 struct execution_control_state
2024 {
2025 ptid_t ptid;
2026 /* The thread that got the event, if this was a thread event; NULL
2027 otherwise. */
2028 struct thread_info *event_thread;
2029
2030 struct target_waitstatus ws;
2031 int stop_func_filled_in;
2032 CORE_ADDR stop_func_start;
2033 CORE_ADDR stop_func_end;
2034 const char *stop_func_name;
2035 int wait_some_more;
2036
2037 /* True if the event thread hit the single-step breakpoint of
2038 another thread. Thus the event doesn't cause a stop, the thread
2039 needs to be single-stepped past the single-step breakpoint before
2040 we can switch back to the original stepping thread. */
2041 int hit_singlestep_breakpoint;
2042 };
2043
2044 /* Clear ECS and set it to point at TP. */
2045
2046 static void
2047 reset_ecs (struct execution_control_state *ecs, struct thread_info *tp)
2048 {
2049 memset (ecs, 0, sizeof (*ecs));
2050 ecs->event_thread = tp;
2051 ecs->ptid = tp->ptid;
2052 }
2053
2054 static void keep_going_pass_signal (struct execution_control_state *ecs);
2055 static void prepare_to_wait (struct execution_control_state *ecs);
2056 static int keep_going_stepped_thread (struct thread_info *tp);
2057 static step_over_what thread_still_needs_step_over (struct thread_info *tp);
2058
2059 /* Are there any pending step-over requests? If so, run all we can
2060 now and return true. Otherwise, return false. */
2061
2062 static int
2063 start_step_over (void)
2064 {
2065 struct thread_info *tp, *next;
2066
2067 /* Don't start a new step-over if we already have an in-line
2068 step-over operation ongoing. */
2069 if (step_over_info_valid_p ())
2070 return 0;
2071
2072 for (tp = step_over_queue_head; tp != NULL; tp = next)
2073 {
2074 struct execution_control_state ecss;
2075 struct execution_control_state *ecs = &ecss;
2076 step_over_what step_what;
2077 int must_be_in_line;
2078
2079 gdb_assert (!tp->stop_requested);
2080
2081 next = thread_step_over_chain_next (tp);
2082
2083 /* If this inferior already has a displaced step in process,
2084 don't start a new one. */
2085 if (displaced_step_in_progress (ptid_get_pid (tp->ptid)))
2086 continue;
2087
2088 step_what = thread_still_needs_step_over (tp);
2089 must_be_in_line = ((step_what & STEP_OVER_WATCHPOINT)
2090 || ((step_what & STEP_OVER_BREAKPOINT)
2091 && !use_displaced_stepping (tp)));
2092
2093 /* We currently stop all threads of all processes to step-over
2094 in-line. If we need to start a new in-line step-over, let
2095 any pending displaced steps finish first. */
2096 if (must_be_in_line && displaced_step_in_progress_any_inferior ())
2097 return 0;
2098
2099 thread_step_over_chain_remove (tp);
2100
2101 if (step_over_queue_head == NULL)
2102 {
2103 if (debug_infrun)
2104 fprintf_unfiltered (gdb_stdlog,
2105 "infrun: step-over queue now empty\n");
2106 }
2107
2108 if (tp->control.trap_expected
2109 || tp->resumed
2110 || tp->executing)
2111 {
2112 internal_error (__FILE__, __LINE__,
2113 "[%s] has inconsistent state: "
2114 "trap_expected=%d, resumed=%d, executing=%d\n",
2115 target_pid_to_str (tp->ptid),
2116 tp->control.trap_expected,
2117 tp->resumed,
2118 tp->executing);
2119 }
2120
2121 if (debug_infrun)
2122 fprintf_unfiltered (gdb_stdlog,
2123 "infrun: resuming [%s] for step-over\n",
2124 target_pid_to_str (tp->ptid));
2125
2126 /* keep_going_pass_signal skips the step-over if the breakpoint
2127 is no longer inserted. In all-stop, we want to keep looking
2128 for a thread that needs a step-over instead of resuming TP,
2129 because we wouldn't be able to resume anything else until the
2130 target stops again. In non-stop, the resume always resumes
2131 only TP, so it's OK to let the thread resume freely. */
2132 if (!target_is_non_stop_p () && !step_what)
2133 continue;
2134
2135 switch_to_thread (tp->ptid);
2136 reset_ecs (ecs, tp);
2137 keep_going_pass_signal (ecs);
2138
2139 if (!ecs->wait_some_more)
2140 error (_("Command aborted."));
2141
2142 gdb_assert (tp->resumed);
2143
2144 /* If we started a new in-line step-over, we're done. */
2145 if (step_over_info_valid_p ())
2146 {
2147 gdb_assert (tp->control.trap_expected);
2148 return 1;
2149 }
2150
2151 if (!target_is_non_stop_p ())
2152 {
2153 /* On all-stop, shouldn't have resumed unless we needed a
2154 step over. */
2155 gdb_assert (tp->control.trap_expected
2156 || tp->step_after_step_resume_breakpoint);
2157
2158 /* With remote targets (at least), in all-stop, we can't
2159 issue any further remote commands until the program stops
2160 again. */
2161 return 1;
2162 }
2163
2164 /* Either the thread no longer needed a step-over, or a new
2165 displaced stepping sequence started. Even in the latter
2166 case, continue looking. Maybe we can also start another
2167 displaced step on a thread of other process. */
2168 }
2169
2170 return 0;
2171 }
2172
2173 /* Update global variables holding ptids to hold NEW_PTID if they were
2174 holding OLD_PTID. */
2175 static void
2176 infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
2177 {
2178 struct displaced_step_inferior_state *displaced;
2179
2180 if (ptid_equal (inferior_ptid, old_ptid))
2181 inferior_ptid = new_ptid;
2182
2183 for (displaced = displaced_step_inferior_states;
2184 displaced;
2185 displaced = displaced->next)
2186 {
2187 if (ptid_equal (displaced->step_ptid, old_ptid))
2188 displaced->step_ptid = new_ptid;
2189 }
2190 }
2191
2192
2193
2194 static const char schedlock_off[] = "off";
2195 static const char schedlock_on[] = "on";
2196 static const char schedlock_step[] = "step";
2197 static const char schedlock_replay[] = "replay";
2198 static const char *const scheduler_enums[] = {
2199 schedlock_off,
2200 schedlock_on,
2201 schedlock_step,
2202 schedlock_replay,
2203 NULL
2204 };
2205 static const char *scheduler_mode = schedlock_replay;
2206 static void
2207 show_scheduler_mode (struct ui_file *file, int from_tty,
2208 struct cmd_list_element *c, const char *value)
2209 {
2210 fprintf_filtered (file,
2211 _("Mode for locking scheduler "
2212 "during execution is \"%s\".\n"),
2213 value);
2214 }
2215
2216 static void
2217 set_schedlock_func (const char *args, int from_tty, struct cmd_list_element *c)
2218 {
2219 if (!target_can_lock_scheduler)
2220 {
2221 scheduler_mode = schedlock_off;
2222 error (_("Target '%s' cannot support this command."), target_shortname);
2223 }
2224 }
2225
2226 /* True if execution commands resume all threads of all processes by
2227 default; otherwise, resume only threads of the current inferior
2228 process. */
2229 int sched_multi = 0;
2230
2231 /* Try to setup for software single stepping over the specified location.
2232 Return 1 if target_resume() should use hardware single step.
2233
2234 GDBARCH the current gdbarch.
2235 PC the location to step over. */
2236
2237 static int
2238 maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc)
2239 {
2240 int hw_step = 1;
2241
2242 if (execution_direction == EXEC_FORWARD
2243 && gdbarch_software_single_step_p (gdbarch))
2244 hw_step = !insert_single_step_breakpoints (gdbarch);
2245
2246 return hw_step;
2247 }
2248
2249 /* See infrun.h. */
2250
2251 ptid_t
2252 user_visible_resume_ptid (int step)
2253 {
2254 ptid_t resume_ptid;
2255
2256 if (non_stop)
2257 {
2258 /* With non-stop mode on, threads are always handled
2259 individually. */
2260 resume_ptid = inferior_ptid;
2261 }
2262 else if ((scheduler_mode == schedlock_on)
2263 || (scheduler_mode == schedlock_step && step))
2264 {
2265 /* User-settable 'scheduler' mode requires solo thread
2266 resume. */
2267 resume_ptid = inferior_ptid;
2268 }
2269 else if ((scheduler_mode == schedlock_replay)
2270 && target_record_will_replay (minus_one_ptid, execution_direction))
2271 {
2272 /* User-settable 'scheduler' mode requires solo thread resume in replay
2273 mode. */
2274 resume_ptid = inferior_ptid;
2275 }
2276 else if (!sched_multi && target_supports_multi_process ())
2277 {
2278 /* Resume all threads of the current process (and none of other
2279 processes). */
2280 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
2281 }
2282 else
2283 {
2284 /* Resume all threads of all processes. */
2285 resume_ptid = RESUME_ALL;
2286 }
2287
2288 return resume_ptid;
2289 }
2290
2291 /* Return a ptid representing the set of threads that we will resume,
2292 in the perspective of the target, assuming run control handling
2293 does not require leaving some threads stopped (e.g., stepping past
2294 breakpoint). USER_STEP indicates whether we're about to start the
2295 target for a stepping command. */
2296
2297 static ptid_t
2298 internal_resume_ptid (int user_step)
2299 {
2300 /* In non-stop, we always control threads individually. Note that
2301 the target may always work in non-stop mode even with "set
2302 non-stop off", in which case user_visible_resume_ptid could
2303 return a wildcard ptid. */
2304 if (target_is_non_stop_p ())
2305 return inferior_ptid;
2306 else
2307 return user_visible_resume_ptid (user_step);
2308 }
2309
2310 /* Wrapper for target_resume, that handles infrun-specific
2311 bookkeeping. */
2312
2313 static void
2314 do_target_resume (ptid_t resume_ptid, int step, enum gdb_signal sig)
2315 {
2316 struct thread_info *tp = inferior_thread ();
2317
2318 gdb_assert (!tp->stop_requested);
2319
2320 /* Install inferior's terminal modes. */
2321 target_terminal::inferior ();
2322
2323 /* Avoid confusing the next resume, if the next stop/resume
2324 happens to apply to another thread. */
2325 tp->suspend.stop_signal = GDB_SIGNAL_0;
2326
2327 /* Advise target which signals may be handled silently.
2328
2329 If we have removed breakpoints because we are stepping over one
2330 in-line (in any thread), we need to receive all signals to avoid
2331 accidentally skipping a breakpoint during execution of a signal
2332 handler.
2333
2334 Likewise if we're displaced stepping, otherwise a trap for a
2335 breakpoint in a signal handler might be confused with the
2336 displaced step finishing. We don't make the displaced_step_fixup
2337 step distinguish the cases instead, because:
2338
2339 - a backtrace while stopped in the signal handler would show the
2340 scratch pad as frame older than the signal handler, instead of
2341 the real mainline code.
2342
2343 - when the thread is later resumed, the signal handler would
2344 return to the scratch pad area, which would no longer be
2345 valid. */
2346 if (step_over_info_valid_p ()
2347 || displaced_step_in_progress (ptid_get_pid (tp->ptid)))
2348 target_pass_signals (0, NULL);
2349 else
2350 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
2351
2352 target_resume (resume_ptid, step, sig);
2353
2354 target_commit_resume ();
2355 }
2356
2357 /* Resume the inferior. SIG is the signal to give the inferior
2358 (GDB_SIGNAL_0 for none). Note: don't call this directly; instead
2359 call 'resume', which handles exceptions. */
2360
2361 static void
2362 resume_1 (enum gdb_signal sig)
2363 {
2364 struct regcache *regcache = get_current_regcache ();
2365 struct gdbarch *gdbarch = regcache->arch ();
2366 struct thread_info *tp = inferior_thread ();
2367 CORE_ADDR pc = regcache_read_pc (regcache);
2368 const address_space *aspace = regcache->aspace ();
2369 ptid_t resume_ptid;
2370 /* This represents the user's step vs continue request. When
2371 deciding whether "set scheduler-locking step" applies, it's the
2372 user's intention that counts. */
2373 const int user_step = tp->control.stepping_command;
2374 /* This represents what we'll actually request the target to do.
2375 This can decay from a step to a continue, if e.g., we need to
2376 implement single-stepping with breakpoints (software
2377 single-step). */
2378 int step;
2379
2380 gdb_assert (!tp->stop_requested);
2381 gdb_assert (!thread_is_in_step_over_chain (tp));
2382
2383 if (tp->suspend.waitstatus_pending_p)
2384 {
2385 if (debug_infrun)
2386 {
2387 std::string statstr
2388 = target_waitstatus_to_string (&tp->suspend.waitstatus);
2389
2390 fprintf_unfiltered (gdb_stdlog,
2391 "infrun: resume: thread %s has pending wait "
2392 "status %s (currently_stepping=%d).\n",
2393 target_pid_to_str (tp->ptid), statstr.c_str (),
2394 currently_stepping (tp));
2395 }
2396
2397 tp->resumed = 1;
2398
2399 /* FIXME: What should we do if we are supposed to resume this
2400 thread with a signal? Maybe we should maintain a queue of
2401 pending signals to deliver. */
2402 if (sig != GDB_SIGNAL_0)
2403 {
2404 warning (_("Couldn't deliver signal %s to %s."),
2405 gdb_signal_to_name (sig), target_pid_to_str (tp->ptid));
2406 }
2407
2408 tp->suspend.stop_signal = GDB_SIGNAL_0;
2409
2410 if (target_can_async_p ())
2411 target_async (1);
2412 return;
2413 }
2414
2415 tp->stepped_breakpoint = 0;
2416
2417 /* Depends on stepped_breakpoint. */
2418 step = currently_stepping (tp);
2419
2420 if (current_inferior ()->waiting_for_vfork_done)
2421 {
2422 /* Don't try to single-step a vfork parent that is waiting for
2423 the child to get out of the shared memory region (by exec'ing
2424 or exiting). This is particularly important on software
2425 single-step archs, as the child process would trip on the
2426 software single step breakpoint inserted for the parent
2427 process. Since the parent will not actually execute any
2428 instruction until the child is out of the shared region (such
2429 are vfork's semantics), it is safe to simply continue it.
2430 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2431 the parent, and tell it to `keep_going', which automatically
2432 re-sets it stepping. */
2433 if (debug_infrun)
2434 fprintf_unfiltered (gdb_stdlog,
2435 "infrun: resume : clear step\n");
2436 step = 0;
2437 }
2438
2439 if (debug_infrun)
2440 fprintf_unfiltered (gdb_stdlog,
2441 "infrun: resume (step=%d, signal=%s), "
2442 "trap_expected=%d, current thread [%s] at %s\n",
2443 step, gdb_signal_to_symbol_string (sig),
2444 tp->control.trap_expected,
2445 target_pid_to_str (inferior_ptid),
2446 paddress (gdbarch, pc));
2447
2448 /* Normally, by the time we reach `resume', the breakpoints are either
2449 removed or inserted, as appropriate. The exception is if we're sitting
2450 at a permanent breakpoint; we need to step over it, but permanent
2451 breakpoints can't be removed. So we have to test for it here. */
2452 if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here)
2453 {
2454 if (sig != GDB_SIGNAL_0)
2455 {
2456 /* We have a signal to pass to the inferior. The resume
2457 may, or may not take us to the signal handler. If this
2458 is a step, we'll need to stop in the signal handler, if
2459 there's one, (if the target supports stepping into
2460 handlers), or in the next mainline instruction, if
2461 there's no handler. If this is a continue, we need to be
2462 sure to run the handler with all breakpoints inserted.
2463 In all cases, set a breakpoint at the current address
2464 (where the handler returns to), and once that breakpoint
2465 is hit, resume skipping the permanent breakpoint. If
2466 that breakpoint isn't hit, then we've stepped into the
2467 signal handler (or hit some other event). We'll delete
2468 the step-resume breakpoint then. */
2469
2470 if (debug_infrun)
2471 fprintf_unfiltered (gdb_stdlog,
2472 "infrun: resume: skipping permanent breakpoint, "
2473 "deliver signal first\n");
2474
2475 clear_step_over_info ();
2476 tp->control.trap_expected = 0;
2477
2478 if (tp->control.step_resume_breakpoint == NULL)
2479 {
2480 /* Set a "high-priority" step-resume, as we don't want
2481 user breakpoints at PC to trigger (again) when this
2482 hits. */
2483 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2484 gdb_assert (tp->control.step_resume_breakpoint->loc->permanent);
2485
2486 tp->step_after_step_resume_breakpoint = step;
2487 }
2488
2489 insert_breakpoints ();
2490 }
2491 else
2492 {
2493 /* There's no signal to pass, we can go ahead and skip the
2494 permanent breakpoint manually. */
2495 if (debug_infrun)
2496 fprintf_unfiltered (gdb_stdlog,
2497 "infrun: resume: skipping permanent breakpoint\n");
2498 gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
2499 /* Update pc to reflect the new address from which we will
2500 execute instructions. */
2501 pc = regcache_read_pc (regcache);
2502
2503 if (step)
2504 {
2505 /* We've already advanced the PC, so the stepping part
2506 is done. Now we need to arrange for a trap to be
2507 reported to handle_inferior_event. Set a breakpoint
2508 at the current PC, and run to it. Don't update
2509 prev_pc, because if we end in
2510 switch_back_to_stepped_thread, we want the "expected
2511 thread advanced also" branch to be taken. IOW, we
2512 don't want this thread to step further from PC
2513 (overstep). */
2514 gdb_assert (!step_over_info_valid_p ());
2515 insert_single_step_breakpoint (gdbarch, aspace, pc);
2516 insert_breakpoints ();
2517
2518 resume_ptid = internal_resume_ptid (user_step);
2519 do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
2520 tp->resumed = 1;
2521 return;
2522 }
2523 }
2524 }
2525
2526 /* If we have a breakpoint to step over, make sure to do a single
2527 step only. Same if we have software watchpoints. */
2528 if (tp->control.trap_expected || bpstat_should_step ())
2529 tp->control.may_range_step = 0;
2530
2531 /* If enabled, step over breakpoints by executing a copy of the
2532 instruction at a different address.
2533
2534 We can't use displaced stepping when we have a signal to deliver;
2535 the comments for displaced_step_prepare explain why. The
2536 comments in the handle_inferior event for dealing with 'random
2537 signals' explain what we do instead.
2538
2539 We can't use displaced stepping when we are waiting for vfork_done
2540 event, displaced stepping breaks the vfork child similarly as single
2541 step software breakpoint. */
2542 if (tp->control.trap_expected
2543 && use_displaced_stepping (tp)
2544 && !step_over_info_valid_p ()
2545 && sig == GDB_SIGNAL_0
2546 && !current_inferior ()->waiting_for_vfork_done)
2547 {
2548 int prepared = displaced_step_prepare (inferior_ptid);
2549
2550 if (prepared == 0)
2551 {
2552 if (debug_infrun)
2553 fprintf_unfiltered (gdb_stdlog,
2554 "Got placed in step-over queue\n");
2555
2556 tp->control.trap_expected = 0;
2557 return;
2558 }
2559 else if (prepared < 0)
2560 {
2561 /* Fallback to stepping over the breakpoint in-line. */
2562
2563 if (target_is_non_stop_p ())
2564 stop_all_threads ();
2565
2566 set_step_over_info (regcache->aspace (),
2567 regcache_read_pc (regcache), 0, tp->global_num);
2568
2569 step = maybe_software_singlestep (gdbarch, pc);
2570
2571 insert_breakpoints ();
2572 }
2573 else if (prepared > 0)
2574 {
2575 struct displaced_step_inferior_state *displaced;
2576
2577 /* Update pc to reflect the new address from which we will
2578 execute instructions due to displaced stepping. */
2579 pc = regcache_read_pc (get_thread_regcache (inferior_ptid));
2580
2581 displaced = get_displaced_stepping_state (ptid_get_pid (inferior_ptid));
2582 step = gdbarch_displaced_step_hw_singlestep (gdbarch,
2583 displaced->step_closure);
2584 }
2585 }
2586
2587 /* Do we need to do it the hard way, w/temp breakpoints? */
2588 else if (step)
2589 step = maybe_software_singlestep (gdbarch, pc);
2590
2591 /* Currently, our software single-step implementation leads to different
2592 results than hardware single-stepping in one situation: when stepping
2593 into delivering a signal which has an associated signal handler,
2594 hardware single-step will stop at the first instruction of the handler,
2595 while software single-step will simply skip execution of the handler.
2596
2597 For now, this difference in behavior is accepted since there is no
2598 easy way to actually implement single-stepping into a signal handler
2599 without kernel support.
2600
2601 However, there is one scenario where this difference leads to follow-on
2602 problems: if we're stepping off a breakpoint by removing all breakpoints
2603 and then single-stepping. In this case, the software single-step
2604 behavior means that even if there is a *breakpoint* in the signal
2605 handler, GDB still would not stop.
2606
2607 Fortunately, we can at least fix this particular issue. We detect
2608 here the case where we are about to deliver a signal while software
2609 single-stepping with breakpoints removed. In this situation, we
2610 revert the decisions to remove all breakpoints and insert single-
2611 step breakpoints, and instead we install a step-resume breakpoint
2612 at the current address, deliver the signal without stepping, and
2613 once we arrive back at the step-resume breakpoint, actually step
2614 over the breakpoint we originally wanted to step over. */
2615 if (thread_has_single_step_breakpoints_set (tp)
2616 && sig != GDB_SIGNAL_0
2617 && step_over_info_valid_p ())
2618 {
2619 /* If we have nested signals or a pending signal is delivered
2620 immediately after a handler returns, might might already have
2621 a step-resume breakpoint set on the earlier handler. We cannot
2622 set another step-resume breakpoint; just continue on until the
2623 original breakpoint is hit. */
2624 if (tp->control.step_resume_breakpoint == NULL)
2625 {
2626 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ());
2627 tp->step_after_step_resume_breakpoint = 1;
2628 }
2629
2630 delete_single_step_breakpoints (tp);
2631
2632 clear_step_over_info ();
2633 tp->control.trap_expected = 0;
2634
2635 insert_breakpoints ();
2636 }
2637
2638 /* If STEP is set, it's a request to use hardware stepping
2639 facilities. But in that case, we should never
2640 use singlestep breakpoint. */
2641 gdb_assert (!(thread_has_single_step_breakpoints_set (tp) && step));
2642
2643 /* Decide the set of threads to ask the target to resume. */
2644 if (tp->control.trap_expected)
2645 {
2646 /* We're allowing a thread to run past a breakpoint it has
2647 hit, either by single-stepping the thread with the breakpoint
2648 removed, or by displaced stepping, with the breakpoint inserted.
2649 In the former case, we need to single-step only this thread,
2650 and keep others stopped, as they can miss this breakpoint if
2651 allowed to run. That's not really a problem for displaced
2652 stepping, but, we still keep other threads stopped, in case
2653 another thread is also stopped for a breakpoint waiting for
2654 its turn in the displaced stepping queue. */
2655 resume_ptid = inferior_ptid;
2656 }
2657 else
2658 resume_ptid = internal_resume_ptid (user_step);
2659
2660 if (execution_direction != EXEC_REVERSE
2661 && step && breakpoint_inserted_here_p (aspace, pc))
2662 {
2663 /* There are two cases where we currently need to step a
2664 breakpoint instruction when we have a signal to deliver:
2665
2666 - See handle_signal_stop where we handle random signals that
2667 could take out us out of the stepping range. Normally, in
2668 that case we end up continuing (instead of stepping) over the
2669 signal handler with a breakpoint at PC, but there are cases
2670 where we should _always_ single-step, even if we have a
2671 step-resume breakpoint, like when a software watchpoint is
2672 set. Assuming single-stepping and delivering a signal at the
2673 same time would takes us to the signal handler, then we could
2674 have removed the breakpoint at PC to step over it. However,
2675 some hardware step targets (like e.g., Mac OS) can't step
2676 into signal handlers, and for those, we need to leave the
2677 breakpoint at PC inserted, as otherwise if the handler
2678 recurses and executes PC again, it'll miss the breakpoint.
2679 So we leave the breakpoint inserted anyway, but we need to
2680 record that we tried to step a breakpoint instruction, so
2681 that adjust_pc_after_break doesn't end up confused.
2682
2683 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2684 in one thread after another thread that was stepping had been
2685 momentarily paused for a step-over. When we re-resume the
2686 stepping thread, it may be resumed from that address with a
2687 breakpoint that hasn't trapped yet. Seen with
2688 gdb.threads/non-stop-fair-events.exp, on targets that don't
2689 do displaced stepping. */
2690
2691 if (debug_infrun)
2692 fprintf_unfiltered (gdb_stdlog,
2693 "infrun: resume: [%s] stepped breakpoint\n",
2694 target_pid_to_str (tp->ptid));
2695
2696 tp->stepped_breakpoint = 1;
2697
2698 /* Most targets can step a breakpoint instruction, thus
2699 executing it normally. But if this one cannot, just
2700 continue and we will hit it anyway. */
2701 if (gdbarch_cannot_step_breakpoint (gdbarch))
2702 step = 0;
2703 }
2704
2705 if (debug_displaced
2706 && tp->control.trap_expected
2707 && use_displaced_stepping (tp)
2708 && !step_over_info_valid_p ())
2709 {
2710 struct regcache *resume_regcache = get_thread_regcache (tp->ptid);
2711 struct gdbarch *resume_gdbarch = resume_regcache->arch ();
2712 CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
2713 gdb_byte buf[4];
2714
2715 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
2716 paddress (resume_gdbarch, actual_pc));
2717 read_memory (actual_pc, buf, sizeof (buf));
2718 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
2719 }
2720
2721 if (tp->control.may_range_step)
2722 {
2723 /* If we're resuming a thread with the PC out of the step
2724 range, then we're doing some nested/finer run control
2725 operation, like stepping the thread out of the dynamic
2726 linker or the displaced stepping scratch pad. We
2727 shouldn't have allowed a range step then. */
2728 gdb_assert (pc_in_thread_step_range (pc, tp));
2729 }
2730
2731 do_target_resume (resume_ptid, step, sig);
2732 tp->resumed = 1;
2733 }
2734
2735 /* Resume the inferior. SIG is the signal to give the inferior
2736 (GDB_SIGNAL_0 for none). This is a wrapper around 'resume_1' that
2737 rolls back state on error. */
2738
2739 void
2740 resume (gdb_signal sig)
2741 {
2742 TRY
2743 {
2744 resume_1 (sig);
2745 }
2746 CATCH (ex, RETURN_MASK_ALL)
2747 {
2748 /* If resuming is being aborted for any reason, delete any
2749 single-step breakpoint resume_1 may have created, to avoid
2750 confusing the following resumption, and to avoid leaving
2751 single-step breakpoints perturbing other threads, in case
2752 we're running in non-stop mode. */
2753 if (inferior_ptid != null_ptid)
2754 delete_single_step_breakpoints (inferior_thread ());
2755 throw_exception (ex);
2756 }
2757 END_CATCH
2758 }
2759
2760
2761 /* Proceeding. */
2762
2763 /* See infrun.h. */
2764
2765 /* Counter that tracks number of user visible stops. This can be used
2766 to tell whether a command has proceeded the inferior past the
2767 current location. This allows e.g., inferior function calls in
2768 breakpoint commands to not interrupt the command list. When the
2769 call finishes successfully, the inferior is standing at the same
2770 breakpoint as if nothing happened (and so we don't call
2771 normal_stop). */
2772 static ULONGEST current_stop_id;
2773
2774 /* See infrun.h. */
2775
2776 ULONGEST
2777 get_stop_id (void)
2778 {
2779 return current_stop_id;
2780 }
2781
2782 /* Called when we report a user visible stop. */
2783
2784 static void
2785 new_stop_id (void)
2786 {
2787 current_stop_id++;
2788 }
2789
2790 /* Clear out all variables saying what to do when inferior is continued.
2791 First do this, then set the ones you want, then call `proceed'. */
2792
2793 static void
2794 clear_proceed_status_thread (struct thread_info *tp)
2795 {
2796 if (debug_infrun)
2797 fprintf_unfiltered (gdb_stdlog,
2798 "infrun: clear_proceed_status_thread (%s)\n",
2799 target_pid_to_str (tp->ptid));
2800
2801 /* If we're starting a new sequence, then the previous finished
2802 single-step is no longer relevant. */
2803 if (tp->suspend.waitstatus_pending_p)
2804 {
2805 if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SINGLE_STEP)
2806 {
2807 if (debug_infrun)
2808 fprintf_unfiltered (gdb_stdlog,
2809 "infrun: clear_proceed_status: pending "
2810 "event of %s was a finished step. "
2811 "Discarding.\n",
2812 target_pid_to_str (tp->ptid));
2813
2814 tp->suspend.waitstatus_pending_p = 0;
2815 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
2816 }
2817 else if (debug_infrun)
2818 {
2819 std::string statstr
2820 = target_waitstatus_to_string (&tp->suspend.waitstatus);
2821
2822 fprintf_unfiltered (gdb_stdlog,
2823 "infrun: clear_proceed_status_thread: thread %s "
2824 "has pending wait status %s "
2825 "(currently_stepping=%d).\n",
2826 target_pid_to_str (tp->ptid), statstr.c_str (),
2827 currently_stepping (tp));
2828 }
2829 }
2830
2831 /* If this signal should not be seen by program, give it zero.
2832 Used for debugging signals. */
2833 if (!signal_pass_state (tp->suspend.stop_signal))
2834 tp->suspend.stop_signal = GDB_SIGNAL_0;
2835
2836 thread_fsm_delete (tp->thread_fsm);
2837 tp->thread_fsm = NULL;
2838
2839 tp->control.trap_expected = 0;
2840 tp->control.step_range_start = 0;
2841 tp->control.step_range_end = 0;
2842 tp->control.may_range_step = 0;
2843 tp->control.step_frame_id = null_frame_id;
2844 tp->control.step_stack_frame_id = null_frame_id;
2845 tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE;
2846 tp->control.step_start_function = NULL;
2847 tp->stop_requested = 0;
2848
2849 tp->control.stop_step = 0;
2850
2851 tp->control.proceed_to_finish = 0;
2852
2853 tp->control.stepping_command = 0;
2854
2855 /* Discard any remaining commands or status from previous stop. */
2856 bpstat_clear (&tp->control.stop_bpstat);
2857 }
2858
2859 void
2860 clear_proceed_status (int step)
2861 {
2862 /* With scheduler-locking replay, stop replaying other threads if we're
2863 not replaying the user-visible resume ptid.
2864
2865 This is a convenience feature to not require the user to explicitly
2866 stop replaying the other threads. We're assuming that the user's
2867 intent is to resume tracing the recorded process. */
2868 if (!non_stop && scheduler_mode == schedlock_replay
2869 && target_record_is_replaying (minus_one_ptid)
2870 && !target_record_will_replay (user_visible_resume_ptid (step),
2871 execution_direction))
2872 target_record_stop_replaying ();
2873
2874 if (!non_stop)
2875 {
2876 struct thread_info *tp;
2877 ptid_t resume_ptid;
2878
2879 resume_ptid = user_visible_resume_ptid (step);
2880
2881 /* In all-stop mode, delete the per-thread status of all threads
2882 we're about to resume, implicitly and explicitly. */
2883 ALL_NON_EXITED_THREADS (tp)
2884 {
2885 if (!ptid_match (tp->ptid, resume_ptid))
2886 continue;
2887 clear_proceed_status_thread (tp);
2888 }
2889 }
2890
2891 if (!ptid_equal (inferior_ptid, null_ptid))
2892 {
2893 struct inferior *inferior;
2894
2895 if (non_stop)
2896 {
2897 /* If in non-stop mode, only delete the per-thread status of
2898 the current thread. */
2899 clear_proceed_status_thread (inferior_thread ());
2900 }
2901
2902 inferior = current_inferior ();
2903 inferior->control.stop_soon = NO_STOP_QUIETLY;
2904 }
2905
2906 observer_notify_about_to_proceed ();
2907 }
2908
2909 /* Returns true if TP is still stopped at a breakpoint that needs
2910 stepping-over in order to make progress. If the breakpoint is gone
2911 meanwhile, we can skip the whole step-over dance. */
2912
2913 static int
2914 thread_still_needs_step_over_bp (struct thread_info *tp)
2915 {
2916 if (tp->stepping_over_breakpoint)
2917 {
2918 struct regcache *regcache = get_thread_regcache (tp->ptid);
2919
2920 if (breakpoint_here_p (regcache->aspace (),
2921 regcache_read_pc (regcache))
2922 == ordinary_breakpoint_here)
2923 return 1;
2924
2925 tp->stepping_over_breakpoint = 0;
2926 }
2927
2928 return 0;
2929 }
2930
2931 /* Check whether thread TP still needs to start a step-over in order
2932 to make progress when resumed. Returns an bitwise or of enum
2933 step_over_what bits, indicating what needs to be stepped over. */
2934
2935 static step_over_what
2936 thread_still_needs_step_over (struct thread_info *tp)
2937 {
2938 step_over_what what = 0;
2939
2940 if (thread_still_needs_step_over_bp (tp))
2941 what |= STEP_OVER_BREAKPOINT;
2942
2943 if (tp->stepping_over_watchpoint
2944 && !target_have_steppable_watchpoint)
2945 what |= STEP_OVER_WATCHPOINT;
2946
2947 return what;
2948 }
2949
2950 /* Returns true if scheduler locking applies. STEP indicates whether
2951 we're about to do a step/next-like command to a thread. */
2952
2953 static int
2954 schedlock_applies (struct thread_info *tp)
2955 {
2956 return (scheduler_mode == schedlock_on
2957 || (scheduler_mode == schedlock_step
2958 && tp->control.stepping_command)
2959 || (scheduler_mode == schedlock_replay
2960 && target_record_will_replay (minus_one_ptid,
2961 execution_direction)));
2962 }
2963
2964 /* Basic routine for continuing the program in various fashions.
2965
2966 ADDR is the address to resume at, or -1 for resume where stopped.
2967 SIGGNAL is the signal to give it, or 0 for none,
2968 or -1 for act according to how it stopped.
2969 STEP is nonzero if should trap after one instruction.
2970 -1 means return after that and print nothing.
2971 You should probably set various step_... variables
2972 before calling here, if you are stepping.
2973
2974 You should call clear_proceed_status before calling proceed. */
2975
2976 void
2977 proceed (CORE_ADDR addr, enum gdb_signal siggnal)
2978 {
2979 struct regcache *regcache;
2980 struct gdbarch *gdbarch;
2981 struct thread_info *tp;
2982 CORE_ADDR pc;
2983 ptid_t resume_ptid;
2984 struct execution_control_state ecss;
2985 struct execution_control_state *ecs = &ecss;
2986 struct cleanup *old_chain;
2987 int started;
2988
2989 /* If we're stopped at a fork/vfork, follow the branch set by the
2990 "set follow-fork-mode" command; otherwise, we'll just proceed
2991 resuming the current thread. */
2992 if (!follow_fork ())
2993 {
2994 /* The target for some reason decided not to resume. */
2995 normal_stop ();
2996 if (target_can_async_p ())
2997 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
2998 return;
2999 }
3000
3001 /* We'll update this if & when we switch to a new thread. */
3002 previous_inferior_ptid = inferior_ptid;
3003
3004 regcache = get_current_regcache ();
3005 gdbarch = regcache->arch ();
3006 const address_space *aspace = regcache->aspace ();
3007
3008 pc = regcache_read_pc (regcache);
3009 tp = inferior_thread ();
3010
3011 /* Fill in with reasonable starting values. */
3012 init_thread_stepping_state (tp);
3013
3014 gdb_assert (!thread_is_in_step_over_chain (tp));
3015
3016 if (addr == (CORE_ADDR) -1)
3017 {
3018 if (pc == stop_pc
3019 && breakpoint_here_p (aspace, pc) == ordinary_breakpoint_here
3020 && execution_direction != EXEC_REVERSE)
3021 /* There is a breakpoint at the address we will resume at,
3022 step one instruction before inserting breakpoints so that
3023 we do not stop right away (and report a second hit at this
3024 breakpoint).
3025
3026 Note, we don't do this in reverse, because we won't
3027 actually be executing the breakpoint insn anyway.
3028 We'll be (un-)executing the previous instruction. */
3029 tp->stepping_over_breakpoint = 1;
3030 else if (gdbarch_single_step_through_delay_p (gdbarch)
3031 && gdbarch_single_step_through_delay (gdbarch,
3032 get_current_frame ()))
3033 /* We stepped onto an instruction that needs to be stepped
3034 again before re-inserting the breakpoint, do so. */
3035 tp->stepping_over_breakpoint = 1;
3036 }
3037 else
3038 {
3039 regcache_write_pc (regcache, addr);
3040 }
3041
3042 if (siggnal != GDB_SIGNAL_DEFAULT)
3043 tp->suspend.stop_signal = siggnal;
3044
3045 resume_ptid = user_visible_resume_ptid (tp->control.stepping_command);
3046
3047 /* If an exception is thrown from this point on, make sure to
3048 propagate GDB's knowledge of the executing state to the
3049 frontend/user running state. */
3050 old_chain = make_cleanup (finish_thread_state_cleanup, &resume_ptid);
3051
3052 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
3053 threads (e.g., we might need to set threads stepping over
3054 breakpoints first), from the user/frontend's point of view, all
3055 threads in RESUME_PTID are now running. Unless we're calling an
3056 inferior function, as in that case we pretend the inferior
3057 doesn't run at all. */
3058 if (!tp->control.in_infcall)
3059 set_running (resume_ptid, 1);
3060
3061 if (debug_infrun)
3062 fprintf_unfiltered (gdb_stdlog,
3063 "infrun: proceed (addr=%s, signal=%s)\n",
3064 paddress (gdbarch, addr),
3065 gdb_signal_to_symbol_string (siggnal));
3066
3067 annotate_starting ();
3068
3069 /* Make sure that output from GDB appears before output from the
3070 inferior. */
3071 gdb_flush (gdb_stdout);
3072
3073 /* Since we've marked the inferior running, give it the terminal. A
3074 QUIT/Ctrl-C from here on is forwarded to the target (which can
3075 still detect attempts to unblock a stuck connection with repeated
3076 Ctrl-C from within target_pass_ctrlc). */
3077 target_terminal::inferior ();
3078
3079 /* In a multi-threaded task we may select another thread and
3080 then continue or step.
3081
3082 But if a thread that we're resuming had stopped at a breakpoint,
3083 it will immediately cause another breakpoint stop without any
3084 execution (i.e. it will report a breakpoint hit incorrectly). So
3085 we must step over it first.
3086
3087 Look for threads other than the current (TP) that reported a
3088 breakpoint hit and haven't been resumed yet since. */
3089
3090 /* If scheduler locking applies, we can avoid iterating over all
3091 threads. */
3092 if (!non_stop && !schedlock_applies (tp))
3093 {
3094 struct thread_info *current = tp;
3095
3096 ALL_NON_EXITED_THREADS (tp)
3097 {
3098 /* Ignore the current thread here. It's handled
3099 afterwards. */
3100 if (tp == current)
3101 continue;
3102
3103 /* Ignore threads of processes we're not resuming. */
3104 if (!ptid_match (tp->ptid, resume_ptid))
3105 continue;
3106
3107 if (!thread_still_needs_step_over (tp))
3108 continue;
3109
3110 gdb_assert (!thread_is_in_step_over_chain (tp));
3111
3112 if (debug_infrun)
3113 fprintf_unfiltered (gdb_stdlog,
3114 "infrun: need to step-over [%s] first\n",
3115 target_pid_to_str (tp->ptid));
3116
3117 thread_step_over_chain_enqueue (tp);
3118 }
3119
3120 tp = current;
3121 }
3122
3123 /* Enqueue the current thread last, so that we move all other
3124 threads over their breakpoints first. */
3125 if (tp->stepping_over_breakpoint)
3126 thread_step_over_chain_enqueue (tp);
3127
3128 /* If the thread isn't started, we'll still need to set its prev_pc,
3129 so that switch_back_to_stepped_thread knows the thread hasn't
3130 advanced. Must do this before resuming any thread, as in
3131 all-stop/remote, once we resume we can't send any other packet
3132 until the target stops again. */
3133 tp->prev_pc = regcache_read_pc (regcache);
3134
3135 {
3136 scoped_restore save_defer_tc = make_scoped_defer_target_commit_resume ();
3137
3138 started = start_step_over ();
3139
3140 if (step_over_info_valid_p ())
3141 {
3142 /* Either this thread started a new in-line step over, or some
3143 other thread was already doing one. In either case, don't
3144 resume anything else until the step-over is finished. */
3145 }
3146 else if (started && !target_is_non_stop_p ())
3147 {
3148 /* A new displaced stepping sequence was started. In all-stop,
3149 we can't talk to the target anymore until it next stops. */
3150 }
3151 else if (!non_stop && target_is_non_stop_p ())
3152 {
3153 /* In all-stop, but the target is always in non-stop mode.
3154 Start all other threads that are implicitly resumed too. */
3155 ALL_NON_EXITED_THREADS (tp)
3156 {
3157 /* Ignore threads of processes we're not resuming. */
3158 if (!ptid_match (tp->ptid, resume_ptid))
3159 continue;
3160
3161 if (tp->resumed)
3162 {
3163 if (debug_infrun)
3164 fprintf_unfiltered (gdb_stdlog,
3165 "infrun: proceed: [%s] resumed\n",
3166 target_pid_to_str (tp->ptid));
3167 gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
3168 continue;
3169 }
3170
3171 if (thread_is_in_step_over_chain (tp))
3172 {
3173 if (debug_infrun)
3174 fprintf_unfiltered (gdb_stdlog,
3175 "infrun: proceed: [%s] needs step-over\n",
3176 target_pid_to_str (tp->ptid));
3177 continue;
3178 }
3179
3180 if (debug_infrun)
3181 fprintf_unfiltered (gdb_stdlog,
3182 "infrun: proceed: resuming %s\n",
3183 target_pid_to_str (tp->ptid));
3184
3185 reset_ecs (ecs, tp);
3186 switch_to_thread (tp->ptid);
3187 keep_going_pass_signal (ecs);
3188 if (!ecs->wait_some_more)
3189 error (_("Command aborted."));
3190 }
3191 }
3192 else if (!tp->resumed && !thread_is_in_step_over_chain (tp))
3193 {
3194 /* The thread wasn't started, and isn't queued, run it now. */
3195 reset_ecs (ecs, tp);
3196 switch_to_thread (tp->ptid);
3197 keep_going_pass_signal (ecs);
3198 if (!ecs->wait_some_more)
3199 error (_("Command aborted."));
3200 }
3201 }
3202
3203 target_commit_resume ();
3204
3205 discard_cleanups (old_chain);
3206
3207 /* Tell the event loop to wait for it to stop. If the target
3208 supports asynchronous execution, it'll do this from within
3209 target_resume. */
3210 if (!target_can_async_p ())
3211 mark_async_event_handler (infrun_async_inferior_event_token);
3212 }
3213
3214
3215 /* Start remote-debugging of a machine over a serial link. */
3216
3217 void
3218 start_remote (int from_tty)
3219 {
3220 struct inferior *inferior;
3221
3222 inferior = current_inferior ();
3223 inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
3224
3225 /* Always go on waiting for the target, regardless of the mode. */
3226 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3227 indicate to wait_for_inferior that a target should timeout if
3228 nothing is returned (instead of just blocking). Because of this,
3229 targets expecting an immediate response need to, internally, set
3230 things up so that the target_wait() is forced to eventually
3231 timeout. */
3232 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3233 differentiate to its caller what the state of the target is after
3234 the initial open has been performed. Here we're assuming that
3235 the target has stopped. It should be possible to eventually have
3236 target_open() return to the caller an indication that the target
3237 is currently running and GDB state should be set to the same as
3238 for an async run. */
3239 wait_for_inferior ();
3240
3241 /* Now that the inferior has stopped, do any bookkeeping like
3242 loading shared libraries. We want to do this before normal_stop,
3243 so that the displayed frame is up to date. */
3244 post_create_inferior (&current_target, from_tty);
3245
3246 normal_stop ();
3247 }
3248
3249 /* Initialize static vars when a new inferior begins. */
3250
3251 void
3252 init_wait_for_inferior (void)
3253 {
3254 /* These are meaningless until the first time through wait_for_inferior. */
3255
3256 breakpoint_init_inferior (inf_starting);
3257
3258 clear_proceed_status (0);
3259
3260 target_last_wait_ptid = minus_one_ptid;
3261
3262 previous_inferior_ptid = inferior_ptid;
3263
3264 /* Discard any skipped inlined frames. */
3265 clear_inline_frame_state (minus_one_ptid);
3266 }
3267
3268
3269
3270 static void handle_inferior_event (struct execution_control_state *ecs);
3271
3272 static void handle_step_into_function (struct gdbarch *gdbarch,
3273 struct execution_control_state *ecs);
3274 static void handle_step_into_function_backward (struct gdbarch *gdbarch,
3275 struct execution_control_state *ecs);
3276 static void handle_signal_stop (struct execution_control_state *ecs);
3277 static void check_exception_resume (struct execution_control_state *,
3278 struct frame_info *);
3279
3280 static void end_stepping_range (struct execution_control_state *ecs);
3281 static void stop_waiting (struct execution_control_state *ecs);
3282 static void keep_going (struct execution_control_state *ecs);
3283 static void process_event_stop_test (struct execution_control_state *ecs);
3284 static int switch_back_to_stepped_thread (struct execution_control_state *ecs);
3285
3286 /* This function is attached as a "thread_stop_requested" observer.
3287 Cleanup local state that assumed the PTID was to be resumed, and
3288 report the stop to the frontend. */
3289
3290 static void
3291 infrun_thread_stop_requested (ptid_t ptid)
3292 {
3293 struct thread_info *tp;
3294
3295 /* PTID was requested to stop. If the thread was already stopped,
3296 but the user/frontend doesn't know about that yet (e.g., the
3297 thread had been temporarily paused for some step-over), set up
3298 for reporting the stop now. */
3299 ALL_NON_EXITED_THREADS (tp)
3300 if (ptid_match (tp->ptid, ptid))
3301 {
3302 if (tp->state != THREAD_RUNNING)
3303 continue;
3304 if (tp->executing)
3305 continue;
3306
3307 /* Remove matching threads from the step-over queue, so
3308 start_step_over doesn't try to resume them
3309 automatically. */
3310 if (thread_is_in_step_over_chain (tp))
3311 thread_step_over_chain_remove (tp);
3312
3313 /* If the thread is stopped, but the user/frontend doesn't
3314 know about that yet, queue a pending event, as if the
3315 thread had just stopped now. Unless the thread already had
3316 a pending event. */
3317 if (!tp->suspend.waitstatus_pending_p)
3318 {
3319 tp->suspend.waitstatus_pending_p = 1;
3320 tp->suspend.waitstatus.kind = TARGET_WAITKIND_STOPPED;
3321 tp->suspend.waitstatus.value.sig = GDB_SIGNAL_0;
3322 }
3323
3324 /* Clear the inline-frame state, since we're re-processing the
3325 stop. */
3326 clear_inline_frame_state (tp->ptid);
3327
3328 /* If this thread was paused because some other thread was
3329 doing an inline-step over, let that finish first. Once
3330 that happens, we'll restart all threads and consume pending
3331 stop events then. */
3332 if (step_over_info_valid_p ())
3333 continue;
3334
3335 /* Otherwise we can process the (new) pending event now. Set
3336 it so this pending event is considered by
3337 do_target_wait. */
3338 tp->resumed = 1;
3339 }
3340 }
3341
3342 static void
3343 infrun_thread_thread_exit (struct thread_info *tp, int silent)
3344 {
3345 if (ptid_equal (target_last_wait_ptid, tp->ptid))
3346 nullify_last_target_wait_ptid ();
3347 }
3348
3349 /* Delete the step resume, single-step and longjmp/exception resume
3350 breakpoints of TP. */
3351
3352 static void
3353 delete_thread_infrun_breakpoints (struct thread_info *tp)
3354 {
3355 delete_step_resume_breakpoint (tp);
3356 delete_exception_resume_breakpoint (tp);
3357 delete_single_step_breakpoints (tp);
3358 }
3359
3360 /* If the target still has execution, call FUNC for each thread that
3361 just stopped. In all-stop, that's all the non-exited threads; in
3362 non-stop, that's the current thread, only. */
3363
3364 typedef void (*for_each_just_stopped_thread_callback_func)
3365 (struct thread_info *tp);
3366
3367 static void
3368 for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func)
3369 {
3370 if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid))
3371 return;
3372
3373 if (target_is_non_stop_p ())
3374 {
3375 /* If in non-stop mode, only the current thread stopped. */
3376 func (inferior_thread ());
3377 }
3378 else
3379 {
3380 struct thread_info *tp;
3381
3382 /* In all-stop mode, all threads have stopped. */
3383 ALL_NON_EXITED_THREADS (tp)
3384 {
3385 func (tp);
3386 }
3387 }
3388 }
3389
3390 /* Delete the step resume and longjmp/exception resume breakpoints of
3391 the threads that just stopped. */
3392
3393 static void
3394 delete_just_stopped_threads_infrun_breakpoints (void)
3395 {
3396 for_each_just_stopped_thread (delete_thread_infrun_breakpoints);
3397 }
3398
3399 /* Delete the single-step breakpoints of the threads that just
3400 stopped. */
3401
3402 static void
3403 delete_just_stopped_threads_single_step_breakpoints (void)
3404 {
3405 for_each_just_stopped_thread (delete_single_step_breakpoints);
3406 }
3407
3408 /* A cleanup wrapper. */
3409
3410 static void
3411 delete_just_stopped_threads_infrun_breakpoints_cleanup (void *arg)
3412 {
3413 delete_just_stopped_threads_infrun_breakpoints ();
3414 }
3415
3416 /* See infrun.h. */
3417
3418 void
3419 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
3420 const struct target_waitstatus *ws)
3421 {
3422 std::string status_string = target_waitstatus_to_string (ws);
3423 string_file stb;
3424
3425 /* The text is split over several lines because it was getting too long.
3426 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3427 output as a unit; we want only one timestamp printed if debug_timestamp
3428 is set. */
3429
3430 stb.printf ("infrun: target_wait (%d.%ld.%ld",
3431 ptid_get_pid (waiton_ptid),
3432 ptid_get_lwp (waiton_ptid),
3433 ptid_get_tid (waiton_ptid));
3434 if (ptid_get_pid (waiton_ptid) != -1)
3435 stb.printf (" [%s]", target_pid_to_str (waiton_ptid));
3436 stb.printf (", status) =\n");
3437 stb.printf ("infrun: %d.%ld.%ld [%s],\n",
3438 ptid_get_pid (result_ptid),
3439 ptid_get_lwp (result_ptid),
3440 ptid_get_tid (result_ptid),
3441 target_pid_to_str (result_ptid));
3442 stb.printf ("infrun: %s\n", status_string.c_str ());
3443
3444 /* This uses %s in part to handle %'s in the text, but also to avoid
3445 a gcc error: the format attribute requires a string literal. */
3446 fprintf_unfiltered (gdb_stdlog, "%s", stb.c_str ());
3447 }
3448
3449 /* Select a thread at random, out of those which are resumed and have
3450 had events. */
3451
3452 static struct thread_info *
3453 random_pending_event_thread (ptid_t waiton_ptid)
3454 {
3455 struct thread_info *event_tp;
3456 int num_events = 0;
3457 int random_selector;
3458
3459 /* First see how many events we have. Count only resumed threads
3460 that have an event pending. */
3461 ALL_NON_EXITED_THREADS (event_tp)
3462 if (ptid_match (event_tp->ptid, waiton_ptid)
3463 && event_tp->resumed
3464 && event_tp->suspend.waitstatus_pending_p)
3465 num_events++;
3466
3467 if (num_events == 0)
3468 return NULL;
3469
3470 /* Now randomly pick a thread out of those that have had events. */
3471 random_selector = (int)
3472 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
3473
3474 if (debug_infrun && num_events > 1)
3475 fprintf_unfiltered (gdb_stdlog,
3476 "infrun: Found %d events, selecting #%d\n",
3477 num_events, random_selector);
3478
3479 /* Select the Nth thread that has had an event. */
3480 ALL_NON_EXITED_THREADS (event_tp)
3481 if (ptid_match (event_tp->ptid, waiton_ptid)
3482 && event_tp->resumed
3483 && event_tp->suspend.waitstatus_pending_p)
3484 if (random_selector-- == 0)
3485 break;
3486
3487 return event_tp;
3488 }
3489
3490 /* Wrapper for target_wait that first checks whether threads have
3491 pending statuses to report before actually asking the target for
3492 more events. */
3493
3494 static ptid_t
3495 do_target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
3496 {
3497 ptid_t event_ptid;
3498 struct thread_info *tp;
3499
3500 /* First check if there is a resumed thread with a wait status
3501 pending. */
3502 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3503 {
3504 tp = random_pending_event_thread (ptid);
3505 }
3506 else
3507 {
3508 if (debug_infrun)
3509 fprintf_unfiltered (gdb_stdlog,
3510 "infrun: Waiting for specific thread %s.\n",
3511 target_pid_to_str (ptid));
3512
3513 /* We have a specific thread to check. */
3514 tp = find_thread_ptid (ptid);
3515 gdb_assert (tp != NULL);
3516 if (!tp->suspend.waitstatus_pending_p)
3517 tp = NULL;
3518 }
3519
3520 if (tp != NULL
3521 && (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3522 || tp->suspend.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
3523 {
3524 struct regcache *regcache = get_thread_regcache (tp->ptid);
3525 struct gdbarch *gdbarch = regcache->arch ();
3526 CORE_ADDR pc;
3527 int discard = 0;
3528
3529 pc = regcache_read_pc (regcache);
3530
3531 if (pc != tp->suspend.stop_pc)
3532 {
3533 if (debug_infrun)
3534 fprintf_unfiltered (gdb_stdlog,
3535 "infrun: PC of %s changed. was=%s, now=%s\n",
3536 target_pid_to_str (tp->ptid),
3537 paddress (gdbarch, tp->prev_pc),
3538 paddress (gdbarch, pc));
3539 discard = 1;
3540 }
3541 else if (!breakpoint_inserted_here_p (regcache->aspace (), pc))
3542 {
3543 if (debug_infrun)
3544 fprintf_unfiltered (gdb_stdlog,
3545 "infrun: previous breakpoint of %s, at %s gone\n",
3546 target_pid_to_str (tp->ptid),
3547 paddress (gdbarch, pc));
3548
3549 discard = 1;
3550 }
3551
3552 if (discard)
3553 {
3554 if (debug_infrun)
3555 fprintf_unfiltered (gdb_stdlog,
3556 "infrun: pending event of %s cancelled.\n",
3557 target_pid_to_str (tp->ptid));
3558
3559 tp->suspend.waitstatus.kind = TARGET_WAITKIND_SPURIOUS;
3560 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3561 }
3562 }
3563
3564 if (tp != NULL)
3565 {
3566 if (debug_infrun)
3567 {
3568 std::string statstr
3569 = target_waitstatus_to_string (&tp->suspend.waitstatus);
3570
3571 fprintf_unfiltered (gdb_stdlog,
3572 "infrun: Using pending wait status %s for %s.\n",
3573 statstr.c_str (),
3574 target_pid_to_str (tp->ptid));
3575 }
3576
3577 /* Now that we've selected our final event LWP, un-adjust its PC
3578 if it was a software breakpoint (and the target doesn't
3579 always adjust the PC itself). */
3580 if (tp->suspend.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3581 && !target_supports_stopped_by_sw_breakpoint ())
3582 {
3583 struct regcache *regcache;
3584 struct gdbarch *gdbarch;
3585 int decr_pc;
3586
3587 regcache = get_thread_regcache (tp->ptid);
3588 gdbarch = regcache->arch ();
3589
3590 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
3591 if (decr_pc != 0)
3592 {
3593 CORE_ADDR pc;
3594
3595 pc = regcache_read_pc (regcache);
3596 regcache_write_pc (regcache, pc + decr_pc);
3597 }
3598 }
3599
3600 tp->suspend.stop_reason = TARGET_STOPPED_BY_NO_REASON;
3601 *status = tp->suspend.waitstatus;
3602 tp->suspend.waitstatus_pending_p = 0;
3603
3604 /* Wake up the event loop again, until all pending events are
3605 processed. */
3606 if (target_is_async_p ())
3607 mark_async_event_handler (infrun_async_inferior_event_token);
3608 return tp->ptid;
3609 }
3610
3611 /* But if we don't find one, we'll have to wait. */
3612
3613 if (deprecated_target_wait_hook)
3614 event_ptid = deprecated_target_wait_hook (ptid, status, options);
3615 else
3616 event_ptid = target_wait (ptid, status, options);
3617
3618 return event_ptid;
3619 }
3620
3621 /* Prepare and stabilize the inferior for detaching it. E.g.,
3622 detaching while a thread is displaced stepping is a recipe for
3623 crashing it, as nothing would readjust the PC out of the scratch
3624 pad. */
3625
3626 void
3627 prepare_for_detach (void)
3628 {
3629 struct inferior *inf = current_inferior ();
3630 ptid_t pid_ptid = pid_to_ptid (inf->pid);
3631 struct displaced_step_inferior_state *displaced;
3632
3633 displaced = get_displaced_stepping_state (inf->pid);
3634
3635 /* Is any thread of this process displaced stepping? If not,
3636 there's nothing else to do. */
3637 if (displaced == NULL || ptid_equal (displaced->step_ptid, null_ptid))
3638 return;
3639
3640 if (debug_infrun)
3641 fprintf_unfiltered (gdb_stdlog,
3642 "displaced-stepping in-process while detaching");
3643
3644 scoped_restore restore_detaching = make_scoped_restore (&inf->detaching, true);
3645
3646 while (!ptid_equal (displaced->step_ptid, null_ptid))
3647 {
3648 struct cleanup *old_chain_2;
3649 struct execution_control_state ecss;
3650 struct execution_control_state *ecs;
3651
3652 ecs = &ecss;
3653 memset (ecs, 0, sizeof (*ecs));
3654
3655 overlay_cache_invalid = 1;
3656 /* Flush target cache before starting to handle each event.
3657 Target was running and cache could be stale. This is just a
3658 heuristic. Running threads may modify target memory, but we
3659 don't get any event. */
3660 target_dcache_invalidate ();
3661
3662 ecs->ptid = do_target_wait (pid_ptid, &ecs->ws, 0);
3663
3664 if (debug_infrun)
3665 print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
3666
3667 /* If an error happens while handling the event, propagate GDB's
3668 knowledge of the executing state to the frontend/user running
3669 state. */
3670 old_chain_2 = make_cleanup (finish_thread_state_cleanup,
3671 &minus_one_ptid);
3672
3673 /* Now figure out what to do with the result of the result. */
3674 handle_inferior_event (ecs);
3675
3676 /* No error, don't finish the state yet. */
3677 discard_cleanups (old_chain_2);
3678
3679 /* Breakpoints and watchpoints are not installed on the target
3680 at this point, and signals are passed directly to the
3681 inferior, so this must mean the process is gone. */
3682 if (!ecs->wait_some_more)
3683 {
3684 restore_detaching.release ();
3685 error (_("Program exited while detaching"));
3686 }
3687 }
3688
3689 restore_detaching.release ();
3690 }
3691
3692 /* Wait for control to return from inferior to debugger.
3693
3694 If inferior gets a signal, we may decide to start it up again
3695 instead of returning. That is why there is a loop in this function.
3696 When this function actually returns it means the inferior
3697 should be left stopped and GDB should read more commands. */
3698
3699 void
3700 wait_for_inferior (void)
3701 {
3702 struct cleanup *old_cleanups;
3703 struct cleanup *thread_state_chain;
3704
3705 if (debug_infrun)
3706 fprintf_unfiltered
3707 (gdb_stdlog, "infrun: wait_for_inferior ()\n");
3708
3709 old_cleanups
3710 = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup,
3711 NULL);
3712
3713 /* If an error happens while handling the event, propagate GDB's
3714 knowledge of the executing state to the frontend/user running
3715 state. */
3716 thread_state_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3717
3718 while (1)
3719 {
3720 struct execution_control_state ecss;
3721 struct execution_control_state *ecs = &ecss;
3722 ptid_t waiton_ptid = minus_one_ptid;
3723
3724 memset (ecs, 0, sizeof (*ecs));
3725
3726 overlay_cache_invalid = 1;
3727
3728 /* Flush target cache before starting to handle each event.
3729 Target was running and cache could be stale. This is just a
3730 heuristic. Running threads may modify target memory, but we
3731 don't get any event. */
3732 target_dcache_invalidate ();
3733
3734 ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws, 0);
3735
3736 if (debug_infrun)
3737 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3738
3739 /* Now figure out what to do with the result of the result. */
3740 handle_inferior_event (ecs);
3741
3742 if (!ecs->wait_some_more)
3743 break;
3744 }
3745
3746 /* No error, don't finish the state yet. */
3747 discard_cleanups (thread_state_chain);
3748
3749 do_cleanups (old_cleanups);
3750 }
3751
3752 /* Cleanup that reinstalls the readline callback handler, if the
3753 target is running in the background. If while handling the target
3754 event something triggered a secondary prompt, like e.g., a
3755 pagination prompt, we'll have removed the callback handler (see
3756 gdb_readline_wrapper_line). Need to do this as we go back to the
3757 event loop, ready to process further input. Note this has no
3758 effect if the handler hasn't actually been removed, because calling
3759 rl_callback_handler_install resets the line buffer, thus losing
3760 input. */
3761
3762 static void
3763 reinstall_readline_callback_handler_cleanup (void *arg)
3764 {
3765 struct ui *ui = current_ui;
3766
3767 if (!ui->async)
3768 {
3769 /* We're not going back to the top level event loop yet. Don't
3770 install the readline callback, as it'd prep the terminal,
3771 readline-style (raw, noecho) (e.g., --batch). We'll install
3772 it the next time the prompt is displayed, when we're ready
3773 for input. */
3774 return;
3775 }
3776
3777 if (ui->command_editing && ui->prompt_state != PROMPT_BLOCKED)
3778 gdb_rl_callback_handler_reinstall ();
3779 }
3780
3781 /* Clean up the FSMs of threads that are now stopped. In non-stop,
3782 that's just the event thread. In all-stop, that's all threads. */
3783
3784 static void
3785 clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs)
3786 {
3787 struct thread_info *thr = ecs->event_thread;
3788
3789 if (thr != NULL && thr->thread_fsm != NULL)
3790 thread_fsm_clean_up (thr->thread_fsm, thr);
3791
3792 if (!non_stop)
3793 {
3794 ALL_NON_EXITED_THREADS (thr)
3795 {
3796 if (thr->thread_fsm == NULL)
3797 continue;
3798 if (thr == ecs->event_thread)
3799 continue;
3800
3801 switch_to_thread (thr->ptid);
3802 thread_fsm_clean_up (thr->thread_fsm, thr);
3803 }
3804
3805 if (ecs->event_thread != NULL)
3806 switch_to_thread (ecs->event_thread->ptid);
3807 }
3808 }
3809
3810 /* Helper for all_uis_check_sync_execution_done that works on the
3811 current UI. */
3812
3813 static void
3814 check_curr_ui_sync_execution_done (void)
3815 {
3816 struct ui *ui = current_ui;
3817
3818 if (ui->prompt_state == PROMPT_NEEDED
3819 && ui->async
3820 && !gdb_in_secondary_prompt_p (ui))
3821 {
3822 target_terminal::ours ();
3823 observer_notify_sync_execution_done ();
3824 ui_register_input_event_handler (ui);
3825 }
3826 }
3827
3828 /* See infrun.h. */
3829
3830 void
3831 all_uis_check_sync_execution_done (void)
3832 {
3833 SWITCH_THRU_ALL_UIS ()
3834 {
3835 check_curr_ui_sync_execution_done ();
3836 }
3837 }
3838
3839 /* See infrun.h. */
3840
3841 void
3842 all_uis_on_sync_execution_starting (void)
3843 {
3844 SWITCH_THRU_ALL_UIS ()
3845 {
3846 if (current_ui->prompt_state == PROMPT_NEEDED)
3847 async_disable_stdin ();
3848 }
3849 }
3850
3851 /* Asynchronous version of wait_for_inferior. It is called by the
3852 event loop whenever a change of state is detected on the file
3853 descriptor corresponding to the target. It can be called more than
3854 once to complete a single execution command. In such cases we need
3855 to keep the state in a global variable ECSS. If it is the last time
3856 that this function is called for a single execution command, then
3857 report to the user that the inferior has stopped, and do the
3858 necessary cleanups. */
3859
3860 void
3861 fetch_inferior_event (void *client_data)
3862 {
3863 struct execution_control_state ecss;
3864 struct execution_control_state *ecs = &ecss;
3865 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3866 struct cleanup *ts_old_chain;
3867 int cmd_done = 0;
3868 ptid_t waiton_ptid = minus_one_ptid;
3869
3870 memset (ecs, 0, sizeof (*ecs));
3871
3872 /* Events are always processed with the main UI as current UI. This
3873 way, warnings, debug output, etc. are always consistently sent to
3874 the main console. */
3875 scoped_restore save_ui = make_scoped_restore (&current_ui, main_ui);
3876
3877 /* End up with readline processing input, if necessary. */
3878 make_cleanup (reinstall_readline_callback_handler_cleanup, NULL);
3879
3880 /* We're handling a live event, so make sure we're doing live
3881 debugging. If we're looking at traceframes while the target is
3882 running, we're going to need to get back to that mode after
3883 handling the event. */
3884 if (non_stop)
3885 {
3886 make_cleanup_restore_current_traceframe ();
3887 set_current_traceframe (-1);
3888 }
3889
3890 gdb::optional<scoped_restore_current_thread> maybe_restore_thread;
3891
3892 if (non_stop)
3893 /* In non-stop mode, the user/frontend should not notice a thread
3894 switch due to internal events. Make sure we reverse to the
3895 user selected thread and frame after handling the event and
3896 running any breakpoint commands. */
3897 maybe_restore_thread.emplace ();
3898
3899 overlay_cache_invalid = 1;
3900 /* Flush target cache before starting to handle each event. Target
3901 was running and cache could be stale. This is just a heuristic.
3902 Running threads may modify target memory, but we don't get any
3903 event. */
3904 target_dcache_invalidate ();
3905
3906 scoped_restore save_exec_dir
3907 = make_scoped_restore (&execution_direction, target_execution_direction ());
3908
3909 ecs->ptid = do_target_wait (waiton_ptid, &ecs->ws,
3910 target_can_async_p () ? TARGET_WNOHANG : 0);
3911
3912 if (debug_infrun)
3913 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3914
3915 /* If an error happens while handling the event, propagate GDB's
3916 knowledge of the executing state to the frontend/user running
3917 state. */
3918 if (!target_is_non_stop_p ())
3919 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3920 else
3921 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid);
3922
3923 /* Get executed before make_cleanup_restore_current_thread above to apply
3924 still for the thread which has thrown the exception. */
3925 make_bpstat_clear_actions_cleanup ();
3926
3927 make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup, NULL);
3928
3929 /* Now figure out what to do with the result of the result. */
3930 handle_inferior_event (ecs);
3931
3932 if (!ecs->wait_some_more)
3933 {
3934 struct inferior *inf = find_inferior_ptid (ecs->ptid);
3935 int should_stop = 1;
3936 struct thread_info *thr = ecs->event_thread;
3937 int should_notify_stop = 1;
3938
3939 delete_just_stopped_threads_infrun_breakpoints ();
3940
3941 if (thr != NULL)
3942 {
3943 struct thread_fsm *thread_fsm = thr->thread_fsm;
3944
3945 if (thread_fsm != NULL)
3946 should_stop = thread_fsm_should_stop (thread_fsm, thr);
3947 }
3948
3949 if (!should_stop)
3950 {
3951 keep_going (ecs);
3952 }
3953 else
3954 {
3955 clean_up_just_stopped_threads_fsms (ecs);
3956
3957 if (thr != NULL && thr->thread_fsm != NULL)
3958 {
3959 should_notify_stop
3960 = thread_fsm_should_notify_stop (thr->thread_fsm);
3961 }
3962
3963 if (should_notify_stop)
3964 {
3965 int proceeded = 0;
3966
3967 /* We may not find an inferior if this was a process exit. */
3968 if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
3969 proceeded = normal_stop ();
3970
3971 if (!proceeded)
3972 {
3973 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
3974 cmd_done = 1;
3975 }
3976 }
3977 }
3978 }
3979
3980 /* No error, don't finish the thread states yet. */
3981 discard_cleanups (ts_old_chain);
3982
3983 /* Revert thread and frame. */
3984 do_cleanups (old_chain);
3985
3986 /* If a UI was in sync execution mode, and now isn't, restore its
3987 prompt (a synchronous execution command has finished, and we're
3988 ready for input). */
3989 all_uis_check_sync_execution_done ();
3990
3991 if (cmd_done
3992 && exec_done_display_p
3993 && (ptid_equal (inferior_ptid, null_ptid)
3994 || !is_running (inferior_ptid)))
3995 printf_unfiltered (_("completed.\n"));
3996 }
3997
3998 /* Record the frame and location we're currently stepping through. */
3999 void
4000 set_step_info (struct frame_info *frame, struct symtab_and_line sal)
4001 {
4002 struct thread_info *tp = inferior_thread ();
4003
4004 tp->control.step_frame_id = get_frame_id (frame);
4005 tp->control.step_stack_frame_id = get_stack_frame_id (frame);
4006
4007 tp->current_symtab = sal.symtab;
4008 tp->current_line = sal.line;
4009 }
4010
4011 /* Clear context switchable stepping state. */
4012
4013 void
4014 init_thread_stepping_state (struct thread_info *tss)
4015 {
4016 tss->stepped_breakpoint = 0;
4017 tss->stepping_over_breakpoint = 0;
4018 tss->stepping_over_watchpoint = 0;
4019 tss->step_after_step_resume_breakpoint = 0;
4020 }
4021
4022 /* Set the cached copy of the last ptid/waitstatus. */
4023
4024 void
4025 set_last_target_status (ptid_t ptid, struct target_waitstatus status)
4026 {
4027 target_last_wait_ptid = ptid;
4028 target_last_waitstatus = status;
4029 }
4030
4031 /* Return the cached copy of the last pid/waitstatus returned by
4032 target_wait()/deprecated_target_wait_hook(). The data is actually
4033 cached by handle_inferior_event(), which gets called immediately
4034 after target_wait()/deprecated_target_wait_hook(). */
4035
4036 void
4037 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
4038 {
4039 *ptidp = target_last_wait_ptid;
4040 *status = target_last_waitstatus;
4041 }
4042
4043 void
4044 nullify_last_target_wait_ptid (void)
4045 {
4046 target_last_wait_ptid = minus_one_ptid;
4047 }
4048
4049 /* Switch thread contexts. */
4050
4051 static void
4052 context_switch (ptid_t ptid)
4053 {
4054 if (debug_infrun && !ptid_equal (ptid, inferior_ptid))
4055 {
4056 fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
4057 target_pid_to_str (inferior_ptid));
4058 fprintf_unfiltered (gdb_stdlog, "to %s\n",
4059 target_pid_to_str (ptid));
4060 }
4061
4062 switch_to_thread (ptid);
4063 }
4064
4065 /* If the target can't tell whether we've hit breakpoints
4066 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4067 check whether that could have been caused by a breakpoint. If so,
4068 adjust the PC, per gdbarch_decr_pc_after_break. */
4069
4070 static void
4071 adjust_pc_after_break (struct thread_info *thread,
4072 struct target_waitstatus *ws)
4073 {
4074 struct regcache *regcache;
4075 struct gdbarch *gdbarch;
4076 CORE_ADDR breakpoint_pc, decr_pc;
4077
4078 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4079 we aren't, just return.
4080
4081 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
4082 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4083 implemented by software breakpoints should be handled through the normal
4084 breakpoint layer.
4085
4086 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4087 different signals (SIGILL or SIGEMT for instance), but it is less
4088 clear where the PC is pointing afterwards. It may not match
4089 gdbarch_decr_pc_after_break. I don't know any specific target that
4090 generates these signals at breakpoints (the code has been in GDB since at
4091 least 1992) so I can not guess how to handle them here.
4092
4093 In earlier versions of GDB, a target with
4094 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
4095 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4096 target with both of these set in GDB history, and it seems unlikely to be
4097 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4098
4099 if (ws->kind != TARGET_WAITKIND_STOPPED)
4100 return;
4101
4102 if (ws->value.sig != GDB_SIGNAL_TRAP)
4103 return;
4104
4105 /* In reverse execution, when a breakpoint is hit, the instruction
4106 under it has already been de-executed. The reported PC always
4107 points at the breakpoint address, so adjusting it further would
4108 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4109 architecture:
4110
4111 B1 0x08000000 : INSN1
4112 B2 0x08000001 : INSN2
4113 0x08000002 : INSN3
4114 PC -> 0x08000003 : INSN4
4115
4116 Say you're stopped at 0x08000003 as above. Reverse continuing
4117 from that point should hit B2 as below. Reading the PC when the
4118 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4119 been de-executed already.
4120
4121 B1 0x08000000 : INSN1
4122 B2 PC -> 0x08000001 : INSN2
4123 0x08000002 : INSN3
4124 0x08000003 : INSN4
4125
4126 We can't apply the same logic as for forward execution, because
4127 we would wrongly adjust the PC to 0x08000000, since there's a
4128 breakpoint at PC - 1. We'd then report a hit on B1, although
4129 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4130 behaviour. */
4131 if (execution_direction == EXEC_REVERSE)
4132 return;
4133
4134 /* If the target can tell whether the thread hit a SW breakpoint,
4135 trust it. Targets that can tell also adjust the PC
4136 themselves. */
4137 if (target_supports_stopped_by_sw_breakpoint ())
4138 return;
4139
4140 /* Note that relying on whether a breakpoint is planted in memory to
4141 determine this can fail. E.g,. the breakpoint could have been
4142 removed since. Or the thread could have been told to step an
4143 instruction the size of a breakpoint instruction, and only
4144 _after_ was a breakpoint inserted at its address. */
4145
4146 /* If this target does not decrement the PC after breakpoints, then
4147 we have nothing to do. */
4148 regcache = get_thread_regcache (thread->ptid);
4149 gdbarch = regcache->arch ();
4150
4151 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
4152 if (decr_pc == 0)
4153 return;
4154
4155 const address_space *aspace = regcache->aspace ();
4156
4157 /* Find the location where (if we've hit a breakpoint) the
4158 breakpoint would be. */
4159 breakpoint_pc = regcache_read_pc (regcache) - decr_pc;
4160
4161 /* If the target can't tell whether a software breakpoint triggered,
4162 fallback to figuring it out based on breakpoints we think were
4163 inserted in the target, and on whether the thread was stepped or
4164 continued. */
4165
4166 /* Check whether there actually is a software breakpoint inserted at
4167 that location.
4168
4169 If in non-stop mode, a race condition is possible where we've
4170 removed a breakpoint, but stop events for that breakpoint were
4171 already queued and arrive later. To suppress those spurious
4172 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4173 and retire them after a number of stop events are reported. Note
4174 this is an heuristic and can thus get confused. The real fix is
4175 to get the "stopped by SW BP and needs adjustment" info out of
4176 the target/kernel (and thus never reach here; see above). */
4177 if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
4178 || (target_is_non_stop_p ()
4179 && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
4180 {
4181 gdb::optional<scoped_restore_tmpl<int>> restore_operation_disable;
4182
4183 if (record_full_is_used ())
4184 restore_operation_disable.emplace
4185 (record_full_gdb_operation_disable_set ());
4186
4187 /* When using hardware single-step, a SIGTRAP is reported for both
4188 a completed single-step and a software breakpoint. Need to
4189 differentiate between the two, as the latter needs adjusting
4190 but the former does not.
4191
4192 The SIGTRAP can be due to a completed hardware single-step only if
4193 - we didn't insert software single-step breakpoints
4194 - this thread is currently being stepped
4195
4196 If any of these events did not occur, we must have stopped due
4197 to hitting a software breakpoint, and have to back up to the
4198 breakpoint address.
4199
4200 As a special case, we could have hardware single-stepped a
4201 software breakpoint. In this case (prev_pc == breakpoint_pc),
4202 we also need to back up to the breakpoint address. */
4203
4204 if (thread_has_single_step_breakpoints_set (thread)
4205 || !currently_stepping (thread)
4206 || (thread->stepped_breakpoint
4207 && thread->prev_pc == breakpoint_pc))
4208 regcache_write_pc (regcache, breakpoint_pc);
4209 }
4210 }
4211
4212 static int
4213 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
4214 {
4215 for (frame = get_prev_frame (frame);
4216 frame != NULL;
4217 frame = get_prev_frame (frame))
4218 {
4219 if (frame_id_eq (get_frame_id (frame), step_frame_id))
4220 return 1;
4221 if (get_frame_type (frame) != INLINE_FRAME)
4222 break;
4223 }
4224
4225 return 0;
4226 }
4227
4228 /* If the event thread has the stop requested flag set, pretend it
4229 stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
4230 target_stop). */
4231
4232 static bool
4233 handle_stop_requested (struct execution_control_state *ecs)
4234 {
4235 if (ecs->event_thread->stop_requested)
4236 {
4237 ecs->ws.kind = TARGET_WAITKIND_STOPPED;
4238 ecs->ws.value.sig = GDB_SIGNAL_0;
4239 handle_signal_stop (ecs);
4240 return true;
4241 }
4242 return false;
4243 }
4244
4245 /* Auxiliary function that handles syscall entry/return events.
4246 It returns 1 if the inferior should keep going (and GDB
4247 should ignore the event), or 0 if the event deserves to be
4248 processed. */
4249
4250 static int
4251 handle_syscall_event (struct execution_control_state *ecs)
4252 {
4253 struct regcache *regcache;
4254 int syscall_number;
4255
4256 if (!ptid_equal (ecs->ptid, inferior_ptid))
4257 context_switch (ecs->ptid);
4258
4259 regcache = get_thread_regcache (ecs->ptid);
4260 syscall_number = ecs->ws.value.syscall_number;
4261 stop_pc = regcache_read_pc (regcache);
4262
4263 if (catch_syscall_enabled () > 0
4264 && catching_syscall_number (syscall_number) > 0)
4265 {
4266 if (debug_infrun)
4267 fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
4268 syscall_number);
4269
4270 ecs->event_thread->control.stop_bpstat
4271 = bpstat_stop_status (regcache->aspace (),
4272 stop_pc, ecs->ptid, &ecs->ws);
4273
4274 if (handle_stop_requested (ecs))
4275 return 0;
4276
4277 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
4278 {
4279 /* Catchpoint hit. */
4280 return 0;
4281 }
4282 }
4283
4284 if (handle_stop_requested (ecs))
4285 return 0;
4286
4287 /* If no catchpoint triggered for this, then keep going. */
4288 keep_going (ecs);
4289 return 1;
4290 }
4291
4292 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4293
4294 static void
4295 fill_in_stop_func (struct gdbarch *gdbarch,
4296 struct execution_control_state *ecs)
4297 {
4298 if (!ecs->stop_func_filled_in)
4299 {
4300 /* Don't care about return value; stop_func_start and stop_func_name
4301 will both be 0 if it doesn't work. */
4302 find_pc_partial_function (stop_pc, &ecs->stop_func_name,
4303 &ecs->stop_func_start, &ecs->stop_func_end);
4304 ecs->stop_func_start
4305 += gdbarch_deprecated_function_start_offset (gdbarch);
4306
4307 if (gdbarch_skip_entrypoint_p (gdbarch))
4308 ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
4309 ecs->stop_func_start);
4310
4311 ecs->stop_func_filled_in = 1;
4312 }
4313 }
4314
4315
4316 /* Return the STOP_SOON field of the inferior pointed at by PTID. */
4317
4318 static enum stop_kind
4319 get_inferior_stop_soon (ptid_t ptid)
4320 {
4321 struct inferior *inf = find_inferior_ptid (ptid);
4322
4323 gdb_assert (inf != NULL);
4324 return inf->control.stop_soon;
4325 }
4326
4327 /* Wait for one event. Store the resulting waitstatus in WS, and
4328 return the event ptid. */
4329
4330 static ptid_t
4331 wait_one (struct target_waitstatus *ws)
4332 {
4333 ptid_t event_ptid;
4334 ptid_t wait_ptid = minus_one_ptid;
4335
4336 overlay_cache_invalid = 1;
4337
4338 /* Flush target cache before starting to handle each event.
4339 Target was running and cache could be stale. This is just a
4340 heuristic. Running threads may modify target memory, but we
4341 don't get any event. */
4342 target_dcache_invalidate ();
4343
4344 if (deprecated_target_wait_hook)
4345 event_ptid = deprecated_target_wait_hook (wait_ptid, ws, 0);
4346 else
4347 event_ptid = target_wait (wait_ptid, ws, 0);
4348
4349 if (debug_infrun)
4350 print_target_wait_results (wait_ptid, event_ptid, ws);
4351
4352 return event_ptid;
4353 }
4354
4355 /* Generate a wrapper for target_stopped_by_REASON that works on PTID
4356 instead of the current thread. */
4357 #define THREAD_STOPPED_BY(REASON) \
4358 static int \
4359 thread_stopped_by_ ## REASON (ptid_t ptid) \
4360 { \
4361 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); \
4362 inferior_ptid = ptid; \
4363 \
4364 return target_stopped_by_ ## REASON (); \
4365 }
4366
4367 /* Generate thread_stopped_by_watchpoint. */
4368 THREAD_STOPPED_BY (watchpoint)
4369 /* Generate thread_stopped_by_sw_breakpoint. */
4370 THREAD_STOPPED_BY (sw_breakpoint)
4371 /* Generate thread_stopped_by_hw_breakpoint. */
4372 THREAD_STOPPED_BY (hw_breakpoint)
4373
4374 /* Cleanups that switches to the PTID pointed at by PTID_P. */
4375
4376 static void
4377 switch_to_thread_cleanup (void *ptid_p)
4378 {
4379 ptid_t ptid = *(ptid_t *) ptid_p;
4380
4381 switch_to_thread (ptid);
4382 }
4383
4384 /* Save the thread's event and stop reason to process it later. */
4385
4386 static void
4387 save_waitstatus (struct thread_info *tp, struct target_waitstatus *ws)
4388 {
4389 struct regcache *regcache;
4390
4391 if (debug_infrun)
4392 {
4393 std::string statstr = target_waitstatus_to_string (ws);
4394
4395 fprintf_unfiltered (gdb_stdlog,
4396 "infrun: saving status %s for %d.%ld.%ld\n",
4397 statstr.c_str (),
4398 ptid_get_pid (tp->ptid),
4399 ptid_get_lwp (tp->ptid),
4400 ptid_get_tid (tp->ptid));
4401 }
4402
4403 /* Record for later. */
4404 tp->suspend.waitstatus = *ws;
4405 tp->suspend.waitstatus_pending_p = 1;
4406
4407 regcache = get_thread_regcache (tp->ptid);
4408 const address_space *aspace = regcache->aspace ();
4409
4410 if (ws->kind == TARGET_WAITKIND_STOPPED
4411 && ws->value.sig == GDB_SIGNAL_TRAP)
4412 {
4413 CORE_ADDR pc = regcache_read_pc (regcache);
4414
4415 adjust_pc_after_break (tp, &tp->suspend.waitstatus);
4416
4417 if (thread_stopped_by_watchpoint (tp->ptid))
4418 {
4419 tp->suspend.stop_reason
4420 = TARGET_STOPPED_BY_WATCHPOINT;
4421 }
4422 else if (target_supports_stopped_by_sw_breakpoint ()
4423 && thread_stopped_by_sw_breakpoint (tp->ptid))
4424 {
4425 tp->suspend.stop_reason
4426 = TARGET_STOPPED_BY_SW_BREAKPOINT;
4427 }
4428 else if (target_supports_stopped_by_hw_breakpoint ()
4429 && thread_stopped_by_hw_breakpoint (tp->ptid))
4430 {
4431 tp->suspend.stop_reason
4432 = TARGET_STOPPED_BY_HW_BREAKPOINT;
4433 }
4434 else if (!target_supports_stopped_by_hw_breakpoint ()
4435 && hardware_breakpoint_inserted_here_p (aspace,
4436 pc))
4437 {
4438 tp->suspend.stop_reason
4439 = TARGET_STOPPED_BY_HW_BREAKPOINT;
4440 }
4441 else if (!target_supports_stopped_by_sw_breakpoint ()
4442 && software_breakpoint_inserted_here_p (aspace,
4443 pc))
4444 {
4445 tp->suspend.stop_reason
4446 = TARGET_STOPPED_BY_SW_BREAKPOINT;
4447 }
4448 else if (!thread_has_single_step_breakpoints_set (tp)
4449 && currently_stepping (tp))
4450 {
4451 tp->suspend.stop_reason
4452 = TARGET_STOPPED_BY_SINGLE_STEP;
4453 }
4454 }
4455 }
4456
4457 /* A cleanup that disables thread create/exit events. */
4458
4459 static void
4460 disable_thread_events (void *arg)
4461 {
4462 target_thread_events (0);
4463 }
4464
4465 /* See infrun.h. */
4466
4467 void
4468 stop_all_threads (void)
4469 {
4470 /* We may need multiple passes to discover all threads. */
4471 int pass;
4472 int iterations = 0;
4473 ptid_t entry_ptid;
4474 struct cleanup *old_chain;
4475
4476 gdb_assert (target_is_non_stop_p ());
4477
4478 if (debug_infrun)
4479 fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads\n");
4480
4481 entry_ptid = inferior_ptid;
4482 old_chain = make_cleanup (switch_to_thread_cleanup, &entry_ptid);
4483
4484 target_thread_events (1);
4485 make_cleanup (disable_thread_events, NULL);
4486
4487 /* Request threads to stop, and then wait for the stops. Because
4488 threads we already know about can spawn more threads while we're
4489 trying to stop them, and we only learn about new threads when we
4490 update the thread list, do this in a loop, and keep iterating
4491 until two passes find no threads that need to be stopped. */
4492 for (pass = 0; pass < 2; pass++, iterations++)
4493 {
4494 if (debug_infrun)
4495 fprintf_unfiltered (gdb_stdlog,
4496 "infrun: stop_all_threads, pass=%d, "
4497 "iterations=%d\n", pass, iterations);
4498 while (1)
4499 {
4500 ptid_t event_ptid;
4501 struct target_waitstatus ws;
4502 int need_wait = 0;
4503 struct thread_info *t;
4504
4505 update_thread_list ();
4506
4507 /* Go through all threads looking for threads that we need
4508 to tell the target to stop. */
4509 ALL_NON_EXITED_THREADS (t)
4510 {
4511 if (t->executing)
4512 {
4513 /* If already stopping, don't request a stop again.
4514 We just haven't seen the notification yet. */
4515 if (!t->stop_requested)
4516 {
4517 if (debug_infrun)
4518 fprintf_unfiltered (gdb_stdlog,
4519 "infrun: %s executing, "
4520 "need stop\n",
4521 target_pid_to_str (t->ptid));
4522 target_stop (t->ptid);
4523 t->stop_requested = 1;
4524 }
4525 else
4526 {
4527 if (debug_infrun)
4528 fprintf_unfiltered (gdb_stdlog,
4529 "infrun: %s executing, "
4530 "already stopping\n",
4531 target_pid_to_str (t->ptid));
4532 }
4533
4534 if (t->stop_requested)
4535 need_wait = 1;
4536 }
4537 else
4538 {
4539 if (debug_infrun)
4540 fprintf_unfiltered (gdb_stdlog,
4541 "infrun: %s not executing\n",
4542 target_pid_to_str (t->ptid));
4543
4544 /* The thread may be not executing, but still be
4545 resumed with a pending status to process. */
4546 t->resumed = 0;
4547 }
4548 }
4549
4550 if (!need_wait)
4551 break;
4552
4553 /* If we find new threads on the second iteration, restart
4554 over. We want to see two iterations in a row with all
4555 threads stopped. */
4556 if (pass > 0)
4557 pass = -1;
4558
4559 event_ptid = wait_one (&ws);
4560 if (ws.kind == TARGET_WAITKIND_NO_RESUMED)
4561 {
4562 /* All resumed threads exited. */
4563 }
4564 else if (ws.kind == TARGET_WAITKIND_THREAD_EXITED
4565 || ws.kind == TARGET_WAITKIND_EXITED
4566 || ws.kind == TARGET_WAITKIND_SIGNALLED)
4567 {
4568 if (debug_infrun)
4569 {
4570 ptid_t ptid = pid_to_ptid (ws.value.integer);
4571
4572 fprintf_unfiltered (gdb_stdlog,
4573 "infrun: %s exited while "
4574 "stopping threads\n",
4575 target_pid_to_str (ptid));
4576 }
4577 }
4578 else
4579 {
4580 struct inferior *inf;
4581
4582 t = find_thread_ptid (event_ptid);
4583 if (t == NULL)
4584 t = add_thread (event_ptid);
4585
4586 t->stop_requested = 0;
4587 t->executing = 0;
4588 t->resumed = 0;
4589 t->control.may_range_step = 0;
4590
4591 /* This may be the first time we see the inferior report
4592 a stop. */
4593 inf = find_inferior_ptid (event_ptid);
4594 if (inf->needs_setup)
4595 {
4596 switch_to_thread_no_regs (t);
4597 setup_inferior (0);
4598 }
4599
4600 if (ws.kind == TARGET_WAITKIND_STOPPED
4601 && ws.value.sig == GDB_SIGNAL_0)
4602 {
4603 /* We caught the event that we intended to catch, so
4604 there's no event pending. */
4605 t->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
4606 t->suspend.waitstatus_pending_p = 0;
4607
4608 if (displaced_step_fixup (t->ptid, GDB_SIGNAL_0) < 0)
4609 {
4610 /* Add it back to the step-over queue. */
4611 if (debug_infrun)
4612 {
4613 fprintf_unfiltered (gdb_stdlog,
4614 "infrun: displaced-step of %s "
4615 "canceled: adding back to the "
4616 "step-over queue\n",
4617 target_pid_to_str (t->ptid));
4618 }
4619 t->control.trap_expected = 0;
4620 thread_step_over_chain_enqueue (t);
4621 }
4622 }
4623 else
4624 {
4625 enum gdb_signal sig;
4626 struct regcache *regcache;
4627
4628 if (debug_infrun)
4629 {
4630 std::string statstr = target_waitstatus_to_string (&ws);
4631
4632 fprintf_unfiltered (gdb_stdlog,
4633 "infrun: target_wait %s, saving "
4634 "status for %d.%ld.%ld\n",
4635 statstr.c_str (),
4636 ptid_get_pid (t->ptid),
4637 ptid_get_lwp (t->ptid),
4638 ptid_get_tid (t->ptid));
4639 }
4640
4641 /* Record for later. */
4642 save_waitstatus (t, &ws);
4643
4644 sig = (ws.kind == TARGET_WAITKIND_STOPPED
4645 ? ws.value.sig : GDB_SIGNAL_0);
4646
4647 if (displaced_step_fixup (t->ptid, sig) < 0)
4648 {
4649 /* Add it back to the step-over queue. */
4650 t->control.trap_expected = 0;
4651 thread_step_over_chain_enqueue (t);
4652 }
4653
4654 regcache = get_thread_regcache (t->ptid);
4655 t->suspend.stop_pc = regcache_read_pc (regcache);
4656
4657 if (debug_infrun)
4658 {
4659 fprintf_unfiltered (gdb_stdlog,
4660 "infrun: saved stop_pc=%s for %s "
4661 "(currently_stepping=%d)\n",
4662 paddress (target_gdbarch (),
4663 t->suspend.stop_pc),
4664 target_pid_to_str (t->ptid),
4665 currently_stepping (t));
4666 }
4667 }
4668 }
4669 }
4670 }
4671
4672 do_cleanups (old_chain);
4673
4674 if (debug_infrun)
4675 fprintf_unfiltered (gdb_stdlog, "infrun: stop_all_threads done\n");
4676 }
4677
4678 /* Handle a TARGET_WAITKIND_NO_RESUMED event. */
4679
4680 static int
4681 handle_no_resumed (struct execution_control_state *ecs)
4682 {
4683 struct inferior *inf;
4684 struct thread_info *thread;
4685
4686 if (target_can_async_p ())
4687 {
4688 struct ui *ui;
4689 int any_sync = 0;
4690
4691 ALL_UIS (ui)
4692 {
4693 if (ui->prompt_state == PROMPT_BLOCKED)
4694 {
4695 any_sync = 1;
4696 break;
4697 }
4698 }
4699 if (!any_sync)
4700 {
4701 /* There were no unwaited-for children left in the target, but,
4702 we're not synchronously waiting for events either. Just
4703 ignore. */
4704
4705 if (debug_infrun)
4706 fprintf_unfiltered (gdb_stdlog,
4707 "infrun: TARGET_WAITKIND_NO_RESUMED "
4708 "(ignoring: bg)\n");
4709 prepare_to_wait (ecs);
4710 return 1;
4711 }
4712 }
4713
4714 /* Otherwise, if we were running a synchronous execution command, we
4715 may need to cancel it and give the user back the terminal.
4716
4717 In non-stop mode, the target can't tell whether we've already
4718 consumed previous stop events, so it can end up sending us a
4719 no-resumed event like so:
4720
4721 #0 - thread 1 is left stopped
4722
4723 #1 - thread 2 is resumed and hits breakpoint
4724 -> TARGET_WAITKIND_STOPPED
4725
4726 #2 - thread 3 is resumed and exits
4727 this is the last resumed thread, so
4728 -> TARGET_WAITKIND_NO_RESUMED
4729
4730 #3 - gdb processes stop for thread 2 and decides to re-resume
4731 it.
4732
4733 #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
4734 thread 2 is now resumed, so the event should be ignored.
4735
4736 IOW, if the stop for thread 2 doesn't end a foreground command,
4737 then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
4738 event. But it could be that the event meant that thread 2 itself
4739 (or whatever other thread was the last resumed thread) exited.
4740
4741 To address this we refresh the thread list and check whether we
4742 have resumed threads _now_. In the example above, this removes
4743 thread 3 from the thread list. If thread 2 was re-resumed, we
4744 ignore this event. If we find no thread resumed, then we cancel
4745 the synchronous command show "no unwaited-for " to the user. */
4746 update_thread_list ();
4747
4748 ALL_NON_EXITED_THREADS (thread)
4749 {
4750 if (thread->executing
4751 || thread->suspend.waitstatus_pending_p)
4752 {
4753 /* There were no unwaited-for children left in the target at
4754 some point, but there are now. Just ignore. */
4755 if (debug_infrun)
4756 fprintf_unfiltered (gdb_stdlog,
4757 "infrun: TARGET_WAITKIND_NO_RESUMED "
4758 "(ignoring: found resumed)\n");
4759 prepare_to_wait (ecs);
4760 return 1;
4761 }
4762 }
4763
4764 /* Note however that we may find no resumed thread because the whole
4765 process exited meanwhile (thus updating the thread list results
4766 in an empty thread list). In this case we know we'll be getting
4767 a process exit event shortly. */
4768 ALL_INFERIORS (inf)
4769 {
4770 if (inf->pid == 0)
4771 continue;
4772
4773 thread = any_live_thread_of_process (inf->pid);
4774 if (thread == NULL)
4775 {
4776 if (debug_infrun)
4777 fprintf_unfiltered (gdb_stdlog,
4778 "infrun: TARGET_WAITKIND_NO_RESUMED "
4779 "(expect process exit)\n");
4780 prepare_to_wait (ecs);
4781 return 1;
4782 }
4783 }
4784
4785 /* Go ahead and report the event. */
4786 return 0;
4787 }
4788
4789 /* Given an execution control state that has been freshly filled in by
4790 an event from the inferior, figure out what it means and take
4791 appropriate action.
4792
4793 The alternatives are:
4794
4795 1) stop_waiting and return; to really stop and return to the
4796 debugger.
4797
4798 2) keep_going and return; to wait for the next event (set
4799 ecs->event_thread->stepping_over_breakpoint to 1 to single step
4800 once). */
4801
4802 static void
4803 handle_inferior_event_1 (struct execution_control_state *ecs)
4804 {
4805 enum stop_kind stop_soon;
4806
4807 if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
4808 {
4809 /* We had an event in the inferior, but we are not interested in
4810 handling it at this level. The lower layers have already
4811 done what needs to be done, if anything.
4812
4813 One of the possible circumstances for this is when the
4814 inferior produces output for the console. The inferior has
4815 not stopped, and we are ignoring the event. Another possible
4816 circumstance is any event which the lower level knows will be
4817 reported multiple times without an intervening resume. */
4818 if (debug_infrun)
4819 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
4820 prepare_to_wait (ecs);
4821 return;
4822 }
4823
4824 if (ecs->ws.kind == TARGET_WAITKIND_THREAD_EXITED)
4825 {
4826 if (debug_infrun)
4827 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_EXITED\n");
4828 prepare_to_wait (ecs);
4829 return;
4830 }
4831
4832 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED
4833 && handle_no_resumed (ecs))
4834 return;
4835
4836 /* Cache the last pid/waitstatus. */
4837 set_last_target_status (ecs->ptid, ecs->ws);
4838
4839 /* Always clear state belonging to the previous time we stopped. */
4840 stop_stack_dummy = STOP_NONE;
4841
4842 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED)
4843 {
4844 /* No unwaited-for children left. IOW, all resumed children
4845 have exited. */
4846 if (debug_infrun)
4847 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
4848
4849 stop_print_frame = 0;
4850 stop_waiting (ecs);
4851 return;
4852 }
4853
4854 if (ecs->ws.kind != TARGET_WAITKIND_EXITED
4855 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
4856 {
4857 ecs->event_thread = find_thread_ptid (ecs->ptid);
4858 /* If it's a new thread, add it to the thread database. */
4859 if (ecs->event_thread == NULL)
4860 ecs->event_thread = add_thread (ecs->ptid);
4861
4862 /* Disable range stepping. If the next step request could use a
4863 range, this will be end up re-enabled then. */
4864 ecs->event_thread->control.may_range_step = 0;
4865 }
4866
4867 /* Dependent on valid ECS->EVENT_THREAD. */
4868 adjust_pc_after_break (ecs->event_thread, &ecs->ws);
4869
4870 /* Dependent on the current PC value modified by adjust_pc_after_break. */
4871 reinit_frame_cache ();
4872
4873 breakpoint_retire_moribund ();
4874
4875 /* First, distinguish signals caused by the debugger from signals
4876 that have to do with the program's own actions. Note that
4877 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
4878 on the operating system version. Here we detect when a SIGILL or
4879 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
4880 something similar for SIGSEGV, since a SIGSEGV will be generated
4881 when we're trying to execute a breakpoint instruction on a
4882 non-executable stack. This happens for call dummy breakpoints
4883 for architectures like SPARC that place call dummies on the
4884 stack. */
4885 if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
4886 && (ecs->ws.value.sig == GDB_SIGNAL_ILL
4887 || ecs->ws.value.sig == GDB_SIGNAL_SEGV
4888 || ecs->ws.value.sig == GDB_SIGNAL_EMT))
4889 {
4890 struct regcache *regcache = get_thread_regcache (ecs->ptid);
4891
4892 if (breakpoint_inserted_here_p (regcache->aspace (),
4893 regcache_read_pc (regcache)))
4894 {
4895 if (debug_infrun)
4896 fprintf_unfiltered (gdb_stdlog,
4897 "infrun: Treating signal as SIGTRAP\n");
4898 ecs->ws.value.sig = GDB_SIGNAL_TRAP;
4899 }
4900 }
4901
4902 /* Mark the non-executing threads accordingly. In all-stop, all
4903 threads of all processes are stopped when we get any event
4904 reported. In non-stop mode, only the event thread stops. */
4905 {
4906 ptid_t mark_ptid;
4907
4908 if (!target_is_non_stop_p ())
4909 mark_ptid = minus_one_ptid;
4910 else if (ecs->ws.kind == TARGET_WAITKIND_SIGNALLED
4911 || ecs->ws.kind == TARGET_WAITKIND_EXITED)
4912 {
4913 /* If we're handling a process exit in non-stop mode, even
4914 though threads haven't been deleted yet, one would think
4915 that there is nothing to do, as threads of the dead process
4916 will be soon deleted, and threads of any other process were
4917 left running. However, on some targets, threads survive a
4918 process exit event. E.g., for the "checkpoint" command,
4919 when the current checkpoint/fork exits, linux-fork.c
4920 automatically switches to another fork from within
4921 target_mourn_inferior, by associating the same
4922 inferior/thread to another fork. We haven't mourned yet at
4923 this point, but we must mark any threads left in the
4924 process as not-executing so that finish_thread_state marks
4925 them stopped (in the user's perspective) if/when we present
4926 the stop to the user. */
4927 mark_ptid = pid_to_ptid (ptid_get_pid (ecs->ptid));
4928 }
4929 else
4930 mark_ptid = ecs->ptid;
4931
4932 set_executing (mark_ptid, 0);
4933
4934 /* Likewise the resumed flag. */
4935 set_resumed (mark_ptid, 0);
4936 }
4937
4938 switch (ecs->ws.kind)
4939 {
4940 case TARGET_WAITKIND_LOADED:
4941 if (debug_infrun)
4942 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
4943 if (!ptid_equal (ecs->ptid, inferior_ptid))
4944 context_switch (ecs->ptid);
4945 /* Ignore gracefully during startup of the inferior, as it might
4946 be the shell which has just loaded some objects, otherwise
4947 add the symbols for the newly loaded objects. Also ignore at
4948 the beginning of an attach or remote session; we will query
4949 the full list of libraries once the connection is
4950 established. */
4951
4952 stop_soon = get_inferior_stop_soon (ecs->ptid);
4953 if (stop_soon == NO_STOP_QUIETLY)
4954 {
4955 struct regcache *regcache;
4956
4957 regcache = get_thread_regcache (ecs->ptid);
4958
4959 handle_solib_event ();
4960
4961 ecs->event_thread->control.stop_bpstat
4962 = bpstat_stop_status (regcache->aspace (),
4963 stop_pc, ecs->ptid, &ecs->ws);
4964
4965 if (handle_stop_requested (ecs))
4966 return;
4967
4968 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
4969 {
4970 /* A catchpoint triggered. */
4971 process_event_stop_test (ecs);
4972 return;
4973 }
4974
4975 /* If requested, stop when the dynamic linker notifies
4976 gdb of events. This allows the user to get control
4977 and place breakpoints in initializer routines for
4978 dynamically loaded objects (among other things). */
4979 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4980 if (stop_on_solib_events)
4981 {
4982 /* Make sure we print "Stopped due to solib-event" in
4983 normal_stop. */
4984 stop_print_frame = 1;
4985
4986 stop_waiting (ecs);
4987 return;
4988 }
4989 }
4990
4991 /* If we are skipping through a shell, or through shared library
4992 loading that we aren't interested in, resume the program. If
4993 we're running the program normally, also resume. */
4994 if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
4995 {
4996 /* Loading of shared libraries might have changed breakpoint
4997 addresses. Make sure new breakpoints are inserted. */
4998 if (stop_soon == NO_STOP_QUIETLY)
4999 insert_breakpoints ();
5000 resume (GDB_SIGNAL_0);
5001 prepare_to_wait (ecs);
5002 return;
5003 }
5004
5005 /* But stop if we're attaching or setting up a remote
5006 connection. */
5007 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
5008 || stop_soon == STOP_QUIETLY_REMOTE)
5009 {
5010 if (debug_infrun)
5011 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
5012 stop_waiting (ecs);
5013 return;
5014 }
5015
5016 internal_error (__FILE__, __LINE__,
5017 _("unhandled stop_soon: %d"), (int) stop_soon);
5018
5019 case TARGET_WAITKIND_SPURIOUS:
5020 if (debug_infrun)
5021 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
5022 if (handle_stop_requested (ecs))
5023 return;
5024 if (!ptid_equal (ecs->ptid, inferior_ptid))
5025 context_switch (ecs->ptid);
5026 resume (GDB_SIGNAL_0);
5027 prepare_to_wait (ecs);
5028 return;
5029
5030 case TARGET_WAITKIND_THREAD_CREATED:
5031 if (debug_infrun)
5032 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_THREAD_CREATED\n");
5033 if (handle_stop_requested (ecs))
5034 return;
5035 if (!ptid_equal (ecs->ptid, inferior_ptid))
5036 context_switch (ecs->ptid);
5037 if (!switch_back_to_stepped_thread (ecs))
5038 keep_going (ecs);
5039 return;
5040
5041 case TARGET_WAITKIND_EXITED:
5042 case TARGET_WAITKIND_SIGNALLED:
5043 if (debug_infrun)
5044 {
5045 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
5046 fprintf_unfiltered (gdb_stdlog,
5047 "infrun: TARGET_WAITKIND_EXITED\n");
5048 else
5049 fprintf_unfiltered (gdb_stdlog,
5050 "infrun: TARGET_WAITKIND_SIGNALLED\n");
5051 }
5052
5053 inferior_ptid = ecs->ptid;
5054 set_current_inferior (find_inferior_ptid (ecs->ptid));
5055 set_current_program_space (current_inferior ()->pspace);
5056 handle_vfork_child_exec_or_exit (0);
5057 target_terminal::ours (); /* Must do this before mourn anyway. */
5058
5059 /* Clearing any previous state of convenience variables. */
5060 clear_exit_convenience_vars ();
5061
5062 if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
5063 {
5064 /* Record the exit code in the convenience variable $_exitcode, so
5065 that the user can inspect this again later. */
5066 set_internalvar_integer (lookup_internalvar ("_exitcode"),
5067 (LONGEST) ecs->ws.value.integer);
5068
5069 /* Also record this in the inferior itself. */
5070 current_inferior ()->has_exit_code = 1;
5071 current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer;
5072
5073 /* Support the --return-child-result option. */
5074 return_child_result_value = ecs->ws.value.integer;
5075
5076 observer_notify_exited (ecs->ws.value.integer);
5077 }
5078 else
5079 {
5080 struct regcache *regcache = get_thread_regcache (ecs->ptid);
5081 struct gdbarch *gdbarch = regcache->arch ();
5082
5083 if (gdbarch_gdb_signal_to_target_p (gdbarch))
5084 {
5085 /* Set the value of the internal variable $_exitsignal,
5086 which holds the signal uncaught by the inferior. */
5087 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
5088 gdbarch_gdb_signal_to_target (gdbarch,
5089 ecs->ws.value.sig));
5090 }
5091 else
5092 {
5093 /* We don't have access to the target's method used for
5094 converting between signal numbers (GDB's internal
5095 representation <-> target's representation).
5096 Therefore, we cannot do a good job at displaying this
5097 information to the user. It's better to just warn
5098 her about it (if infrun debugging is enabled), and
5099 give up. */
5100 if (debug_infrun)
5101 fprintf_filtered (gdb_stdlog, _("\
5102 Cannot fill $_exitsignal with the correct signal number.\n"));
5103 }
5104
5105 observer_notify_signal_exited (ecs->ws.value.sig);
5106 }
5107
5108 gdb_flush (gdb_stdout);
5109 target_mourn_inferior (inferior_ptid);
5110 stop_print_frame = 0;
5111 stop_waiting (ecs);
5112 return;
5113
5114 /* The following are the only cases in which we keep going;
5115 the above cases end in a continue or goto. */
5116 case TARGET_WAITKIND_FORKED:
5117 case TARGET_WAITKIND_VFORKED:
5118 if (debug_infrun)
5119 {
5120 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
5121 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
5122 else
5123 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n");
5124 }
5125
5126 /* Check whether the inferior is displaced stepping. */
5127 {
5128 struct regcache *regcache = get_thread_regcache (ecs->ptid);
5129 struct gdbarch *gdbarch = regcache->arch ();
5130
5131 /* If checking displaced stepping is supported, and thread
5132 ecs->ptid is displaced stepping. */
5133 if (displaced_step_in_progress_thread (ecs->ptid))
5134 {
5135 struct inferior *parent_inf
5136 = find_inferior_ptid (ecs->ptid);
5137 struct regcache *child_regcache;
5138 CORE_ADDR parent_pc;
5139
5140 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
5141 indicating that the displaced stepping of syscall instruction
5142 has been done. Perform cleanup for parent process here. Note
5143 that this operation also cleans up the child process for vfork,
5144 because their pages are shared. */
5145 displaced_step_fixup (ecs->ptid, GDB_SIGNAL_TRAP);
5146 /* Start a new step-over in another thread if there's one
5147 that needs it. */
5148 start_step_over ();
5149
5150 if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
5151 {
5152 struct displaced_step_inferior_state *displaced
5153 = get_displaced_stepping_state (ptid_get_pid (ecs->ptid));
5154
5155 /* Restore scratch pad for child process. */
5156 displaced_step_restore (displaced, ecs->ws.value.related_pid);
5157 }
5158
5159 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
5160 the child's PC is also within the scratchpad. Set the child's PC
5161 to the parent's PC value, which has already been fixed up.
5162 FIXME: we use the parent's aspace here, although we're touching
5163 the child, because the child hasn't been added to the inferior
5164 list yet at this point. */
5165
5166 child_regcache
5167 = get_thread_arch_aspace_regcache (ecs->ws.value.related_pid,
5168 gdbarch,
5169 parent_inf->aspace);
5170 /* Read PC value of parent process. */
5171 parent_pc = regcache_read_pc (regcache);
5172
5173 if (debug_displaced)
5174 fprintf_unfiltered (gdb_stdlog,
5175 "displaced: write child pc from %s to %s\n",
5176 paddress (gdbarch,
5177 regcache_read_pc (child_regcache)),
5178 paddress (gdbarch, parent_pc));
5179
5180 regcache_write_pc (child_regcache, parent_pc);
5181 }
5182 }
5183
5184 if (!ptid_equal (ecs->ptid, inferior_ptid))
5185 context_switch (ecs->ptid);
5186
5187 /* Immediately detach breakpoints from the child before there's
5188 any chance of letting the user delete breakpoints from the
5189 breakpoint lists. If we don't do this early, it's easy to
5190 leave left over traps in the child, vis: "break foo; catch
5191 fork; c; <fork>; del; c; <child calls foo>". We only follow
5192 the fork on the last `continue', and by that time the
5193 breakpoint at "foo" is long gone from the breakpoint table.
5194 If we vforked, then we don't need to unpatch here, since both
5195 parent and child are sharing the same memory pages; we'll
5196 need to unpatch at follow/detach time instead to be certain
5197 that new breakpoints added between catchpoint hit time and
5198 vfork follow are detached. */
5199 if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
5200 {
5201 /* This won't actually modify the breakpoint list, but will
5202 physically remove the breakpoints from the child. */
5203 detach_breakpoints (ecs->ws.value.related_pid);
5204 }
5205
5206 delete_just_stopped_threads_single_step_breakpoints ();
5207
5208 /* In case the event is caught by a catchpoint, remember that
5209 the event is to be followed at the next resume of the thread,
5210 and not immediately. */
5211 ecs->event_thread->pending_follow = ecs->ws;
5212
5213 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
5214
5215 ecs->event_thread->control.stop_bpstat
5216 = bpstat_stop_status (get_current_regcache ()->aspace (),
5217 stop_pc, ecs->ptid, &ecs->ws);
5218
5219 if (handle_stop_requested (ecs))
5220 return;
5221
5222 /* If no catchpoint triggered for this, then keep going. Note
5223 that we're interested in knowing the bpstat actually causes a
5224 stop, not just if it may explain the signal. Software
5225 watchpoints, for example, always appear in the bpstat. */
5226 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
5227 {
5228 ptid_t parent;
5229 ptid_t child;
5230 int should_resume;
5231 int follow_child
5232 = (follow_fork_mode_string == follow_fork_mode_child);
5233
5234 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5235
5236 should_resume = follow_fork ();
5237
5238 parent = ecs->ptid;
5239 child = ecs->ws.value.related_pid;
5240
5241 /* At this point, the parent is marked running, and the
5242 child is marked stopped. */
5243
5244 /* If not resuming the parent, mark it stopped. */
5245 if (follow_child && !detach_fork && !non_stop && !sched_multi)
5246 set_running (parent, 0);
5247
5248 /* If resuming the child, mark it running. */
5249 if (follow_child || (!detach_fork && (non_stop || sched_multi)))
5250 set_running (child, 1);
5251
5252 /* In non-stop mode, also resume the other branch. */
5253 if (!detach_fork && (non_stop
5254 || (sched_multi && target_is_non_stop_p ())))
5255 {
5256 if (follow_child)
5257 switch_to_thread (parent);
5258 else
5259 switch_to_thread (child);
5260
5261 ecs->event_thread = inferior_thread ();
5262 ecs->ptid = inferior_ptid;
5263 keep_going (ecs);
5264 }
5265
5266 if (follow_child)
5267 switch_to_thread (child);
5268 else
5269 switch_to_thread (parent);
5270
5271 ecs->event_thread = inferior_thread ();
5272 ecs->ptid = inferior_ptid;
5273
5274 if (should_resume)
5275 keep_going (ecs);
5276 else
5277 stop_waiting (ecs);
5278 return;
5279 }
5280 process_event_stop_test (ecs);
5281 return;
5282
5283 case TARGET_WAITKIND_VFORK_DONE:
5284 /* Done with the shared memory region. Re-insert breakpoints in
5285 the parent, and keep going. */
5286
5287 if (debug_infrun)
5288 fprintf_unfiltered (gdb_stdlog,
5289 "infrun: TARGET_WAITKIND_VFORK_DONE\n");
5290
5291 if (!ptid_equal (ecs->ptid, inferior_ptid))
5292 context_switch (ecs->ptid);
5293
5294 current_inferior ()->waiting_for_vfork_done = 0;
5295 current_inferior ()->pspace->breakpoints_not_allowed = 0;
5296
5297 if (handle_stop_requested (ecs))
5298 return;
5299
5300 /* This also takes care of reinserting breakpoints in the
5301 previously locked inferior. */
5302 keep_going (ecs);
5303 return;
5304
5305 case TARGET_WAITKIND_EXECD:
5306 if (debug_infrun)
5307 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
5308
5309 /* Note we can't read registers yet (the stop_pc), because we
5310 don't yet know the inferior's post-exec architecture.
5311 'stop_pc' is explicitly read below instead. */
5312 if (!ptid_equal (ecs->ptid, inferior_ptid))
5313 switch_to_thread_no_regs (ecs->event_thread);
5314
5315 /* Do whatever is necessary to the parent branch of the vfork. */
5316 handle_vfork_child_exec_or_exit (1);
5317
5318 /* This causes the eventpoints and symbol table to be reset.
5319 Must do this now, before trying to determine whether to
5320 stop. */
5321 follow_exec (inferior_ptid, ecs->ws.value.execd_pathname);
5322
5323 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
5324
5325 /* In follow_exec we may have deleted the original thread and
5326 created a new one. Make sure that the event thread is the
5327 execd thread for that case (this is a nop otherwise). */
5328 ecs->event_thread = inferior_thread ();
5329
5330 ecs->event_thread->control.stop_bpstat
5331 = bpstat_stop_status (get_current_regcache ()->aspace (),
5332 stop_pc, ecs->ptid, &ecs->ws);
5333
5334 /* Note that this may be referenced from inside
5335 bpstat_stop_status above, through inferior_has_execd. */
5336 xfree (ecs->ws.value.execd_pathname);
5337 ecs->ws.value.execd_pathname = NULL;
5338
5339 if (handle_stop_requested (ecs))
5340 return;
5341
5342 /* If no catchpoint triggered for this, then keep going. */
5343 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
5344 {
5345 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5346 keep_going (ecs);
5347 return;
5348 }
5349 process_event_stop_test (ecs);
5350 return;
5351
5352 /* Be careful not to try to gather much state about a thread
5353 that's in a syscall. It's frequently a losing proposition. */
5354 case TARGET_WAITKIND_SYSCALL_ENTRY:
5355 if (debug_infrun)
5356 fprintf_unfiltered (gdb_stdlog,
5357 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
5358 /* Getting the current syscall number. */
5359 if (handle_syscall_event (ecs) == 0)
5360 process_event_stop_test (ecs);
5361 return;
5362
5363 /* Before examining the threads further, step this thread to
5364 get it entirely out of the syscall. (We get notice of the
5365 event when the thread is just on the verge of exiting a
5366 syscall. Stepping one instruction seems to get it back
5367 into user code.) */
5368 case TARGET_WAITKIND_SYSCALL_RETURN:
5369 if (debug_infrun)
5370 fprintf_unfiltered (gdb_stdlog,
5371 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
5372 if (handle_syscall_event (ecs) == 0)
5373 process_event_stop_test (ecs);
5374 return;
5375
5376 case TARGET_WAITKIND_STOPPED:
5377 if (debug_infrun)
5378 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
5379 handle_signal_stop (ecs);
5380 return;
5381
5382 case TARGET_WAITKIND_NO_HISTORY:
5383 if (debug_infrun)
5384 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
5385 /* Reverse execution: target ran out of history info. */
5386
5387 /* Switch to the stopped thread. */
5388 if (!ptid_equal (ecs->ptid, inferior_ptid))
5389 context_switch (ecs->ptid);
5390 if (debug_infrun)
5391 fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
5392
5393 delete_just_stopped_threads_single_step_breakpoints ();
5394 stop_pc = regcache_read_pc (get_thread_regcache (inferior_ptid));
5395
5396 if (handle_stop_requested (ecs))
5397 return;
5398
5399 observer_notify_no_history ();
5400 stop_waiting (ecs);
5401 return;
5402 }
5403 }
5404
5405 /* A wrapper around handle_inferior_event_1, which also makes sure
5406 that all temporary struct value objects that were created during
5407 the handling of the event get deleted at the end. */
5408
5409 static void
5410 handle_inferior_event (struct execution_control_state *ecs)
5411 {
5412 struct value *mark = value_mark ();
5413
5414 handle_inferior_event_1 (ecs);
5415 /* Purge all temporary values created during the event handling,
5416 as it could be a long time before we return to the command level
5417 where such values would otherwise be purged. */
5418 value_free_to_mark (mark);
5419 }
5420
5421 /* Restart threads back to what they were trying to do back when we
5422 paused them for an in-line step-over. The EVENT_THREAD thread is
5423 ignored. */
5424
5425 static void
5426 restart_threads (struct thread_info *event_thread)
5427 {
5428 struct thread_info *tp;
5429
5430 /* In case the instruction just stepped spawned a new thread. */
5431 update_thread_list ();
5432
5433 ALL_NON_EXITED_THREADS (tp)
5434 {
5435 if (tp == event_thread)
5436 {
5437 if (debug_infrun)
5438 fprintf_unfiltered (gdb_stdlog,
5439 "infrun: restart threads: "
5440 "[%s] is event thread\n",
5441 target_pid_to_str (tp->ptid));
5442 continue;
5443 }
5444
5445 if (!(tp->state == THREAD_RUNNING || tp->control.in_infcall))
5446 {
5447 if (debug_infrun)
5448 fprintf_unfiltered (gdb_stdlog,
5449 "infrun: restart threads: "
5450 "[%s] not meant to be running\n",
5451 target_pid_to_str (tp->ptid));
5452 continue;
5453 }
5454
5455 if (tp->resumed)
5456 {
5457 if (debug_infrun)
5458 fprintf_unfiltered (gdb_stdlog,
5459 "infrun: restart threads: [%s] resumed\n",
5460 target_pid_to_str (tp->ptid));
5461 gdb_assert (tp->executing || tp->suspend.waitstatus_pending_p);
5462 continue;
5463 }
5464
5465 if (thread_is_in_step_over_chain (tp))
5466 {
5467 if (debug_infrun)
5468 fprintf_unfiltered (gdb_stdlog,
5469 "infrun: restart threads: "
5470 "[%s] needs step-over\n",
5471 target_pid_to_str (tp->ptid));
5472 gdb_assert (!tp->resumed);
5473 continue;
5474 }
5475
5476
5477 if (tp->suspend.waitstatus_pending_p)
5478 {
5479 if (debug_infrun)
5480 fprintf_unfiltered (gdb_stdlog,
5481 "infrun: restart threads: "
5482 "[%s] has pending status\n",
5483 target_pid_to_str (tp->ptid));
5484 tp->resumed = 1;
5485 continue;
5486 }
5487
5488 gdb_assert (!tp->stop_requested);
5489
5490 /* If some thread needs to start a step-over at this point, it
5491 should still be in the step-over queue, and thus skipped
5492 above. */
5493 if (thread_still_needs_step_over (tp))
5494 {
5495 internal_error (__FILE__, __LINE__,
5496 "thread [%s] needs a step-over, but not in "
5497 "step-over queue\n",
5498 target_pid_to_str (tp->ptid));
5499 }
5500
5501 if (currently_stepping (tp))
5502 {
5503 if (debug_infrun)
5504 fprintf_unfiltered (gdb_stdlog,
5505 "infrun: restart threads: [%s] was stepping\n",
5506 target_pid_to_str (tp->ptid));
5507 keep_going_stepped_thread (tp);
5508 }
5509 else
5510 {
5511 struct execution_control_state ecss;
5512 struct execution_control_state *ecs = &ecss;
5513
5514 if (debug_infrun)
5515 fprintf_unfiltered (gdb_stdlog,
5516 "infrun: restart threads: [%s] continuing\n",
5517 target_pid_to_str (tp->ptid));
5518 reset_ecs (ecs, tp);
5519 switch_to_thread (tp->ptid);
5520 keep_going_pass_signal (ecs);
5521 }
5522 }
5523 }
5524
5525 /* Callback for iterate_over_threads. Find a resumed thread that has
5526 a pending waitstatus. */
5527
5528 static int
5529 resumed_thread_with_pending_status (struct thread_info *tp,
5530 void *arg)
5531 {
5532 return (tp->resumed
5533 && tp->suspend.waitstatus_pending_p);
5534 }
5535
5536 /* Called when we get an event that may finish an in-line or
5537 out-of-line (displaced stepping) step-over started previously.
5538 Return true if the event is processed and we should go back to the
5539 event loop; false if the caller should continue processing the
5540 event. */
5541
5542 static int
5543 finish_step_over (struct execution_control_state *ecs)
5544 {
5545 int had_step_over_info;
5546
5547 displaced_step_fixup (ecs->ptid,
5548 ecs->event_thread->suspend.stop_signal);
5549
5550 had_step_over_info = step_over_info_valid_p ();
5551
5552 if (had_step_over_info)
5553 {
5554 /* If we're stepping over a breakpoint with all threads locked,
5555 then only the thread that was stepped should be reporting
5556 back an event. */
5557 gdb_assert (ecs->event_thread->control.trap_expected);
5558
5559 clear_step_over_info ();
5560 }
5561
5562 if (!target_is_non_stop_p ())
5563 return 0;
5564
5565 /* Start a new step-over in another thread if there's one that
5566 needs it. */
5567 start_step_over ();
5568
5569 /* If we were stepping over a breakpoint before, and haven't started
5570 a new in-line step-over sequence, then restart all other threads
5571 (except the event thread). We can't do this in all-stop, as then
5572 e.g., we wouldn't be able to issue any other remote packet until
5573 these other threads stop. */
5574 if (had_step_over_info && !step_over_info_valid_p ())
5575 {
5576 struct thread_info *pending;
5577
5578 /* If we only have threads with pending statuses, the restart
5579 below won't restart any thread and so nothing re-inserts the
5580 breakpoint we just stepped over. But we need it inserted
5581 when we later process the pending events, otherwise if
5582 another thread has a pending event for this breakpoint too,
5583 we'd discard its event (because the breakpoint that
5584 originally caused the event was no longer inserted). */
5585 context_switch (ecs->ptid);
5586 insert_breakpoints ();
5587
5588 restart_threads (ecs->event_thread);
5589
5590 /* If we have events pending, go through handle_inferior_event
5591 again, picking up a pending event at random. This avoids
5592 thread starvation. */
5593
5594 /* But not if we just stepped over a watchpoint in order to let
5595 the instruction execute so we can evaluate its expression.
5596 The set of watchpoints that triggered is recorded in the
5597 breakpoint objects themselves (see bp->watchpoint_triggered).
5598 If we processed another event first, that other event could
5599 clobber this info. */
5600 if (ecs->event_thread->stepping_over_watchpoint)
5601 return 0;
5602
5603 pending = iterate_over_threads (resumed_thread_with_pending_status,
5604 NULL);
5605 if (pending != NULL)
5606 {
5607 struct thread_info *tp = ecs->event_thread;
5608 struct regcache *regcache;
5609
5610 if (debug_infrun)
5611 {
5612 fprintf_unfiltered (gdb_stdlog,
5613 "infrun: found resumed threads with "
5614 "pending events, saving status\n");
5615 }
5616
5617 gdb_assert (pending != tp);
5618
5619 /* Record the event thread's event for later. */
5620 save_waitstatus (tp, &ecs->ws);
5621 /* This was cleared early, by handle_inferior_event. Set it
5622 so this pending event is considered by
5623 do_target_wait. */
5624 tp->resumed = 1;
5625
5626 gdb_assert (!tp->executing);
5627
5628 regcache = get_thread_regcache (tp->ptid);
5629 tp->suspend.stop_pc = regcache_read_pc (regcache);
5630
5631 if (debug_infrun)
5632 {
5633 fprintf_unfiltered (gdb_stdlog,
5634 "infrun: saved stop_pc=%s for %s "
5635 "(currently_stepping=%d)\n",
5636 paddress (target_gdbarch (),
5637 tp->suspend.stop_pc),
5638 target_pid_to_str (tp->ptid),
5639 currently_stepping (tp));
5640 }
5641
5642 /* This in-line step-over finished; clear this so we won't
5643 start a new one. This is what handle_signal_stop would
5644 do, if we returned false. */
5645 tp->stepping_over_breakpoint = 0;
5646
5647 /* Wake up the event loop again. */
5648 mark_async_event_handler (infrun_async_inferior_event_token);
5649
5650 prepare_to_wait (ecs);
5651 return 1;
5652 }
5653 }
5654
5655 return 0;
5656 }
5657
5658 /* Come here when the program has stopped with a signal. */
5659
5660 static void
5661 handle_signal_stop (struct execution_control_state *ecs)
5662 {
5663 struct frame_info *frame;
5664 struct gdbarch *gdbarch;
5665 int stopped_by_watchpoint;
5666 enum stop_kind stop_soon;
5667 int random_signal;
5668
5669 gdb_assert (ecs->ws.kind == TARGET_WAITKIND_STOPPED);
5670
5671 ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
5672
5673 /* Do we need to clean up the state of a thread that has
5674 completed a displaced single-step? (Doing so usually affects
5675 the PC, so do it here, before we set stop_pc.) */
5676 if (finish_step_over (ecs))
5677 return;
5678
5679 /* If we either finished a single-step or hit a breakpoint, but
5680 the user wanted this thread to be stopped, pretend we got a
5681 SIG0 (generic unsignaled stop). */
5682 if (ecs->event_thread->stop_requested
5683 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5684 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5685
5686 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid));
5687
5688 if (debug_infrun)
5689 {
5690 struct regcache *regcache = get_thread_regcache (ecs->ptid);
5691 struct gdbarch *gdbarch = regcache->arch ();
5692 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
5693
5694 inferior_ptid = ecs->ptid;
5695
5696 fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
5697 paddress (gdbarch, stop_pc));
5698 if (target_stopped_by_watchpoint ())
5699 {
5700 CORE_ADDR addr;
5701
5702 fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
5703
5704 if (target_stopped_data_address (&current_target, &addr))
5705 fprintf_unfiltered (gdb_stdlog,
5706 "infrun: stopped data address = %s\n",
5707 paddress (gdbarch, addr));
5708 else
5709 fprintf_unfiltered (gdb_stdlog,
5710 "infrun: (no data address available)\n");
5711 }
5712 }
5713
5714 /* This is originated from start_remote(), start_inferior() and
5715 shared libraries hook functions. */
5716 stop_soon = get_inferior_stop_soon (ecs->ptid);
5717 if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
5718 {
5719 if (!ptid_equal (ecs->ptid, inferior_ptid))
5720 context_switch (ecs->ptid);
5721 if (debug_infrun)
5722 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
5723 stop_print_frame = 1;
5724 stop_waiting (ecs);
5725 return;
5726 }
5727
5728 /* This originates from attach_command(). We need to overwrite
5729 the stop_signal here, because some kernels don't ignore a
5730 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
5731 See more comments in inferior.h. On the other hand, if we
5732 get a non-SIGSTOP, report it to the user - assume the backend
5733 will handle the SIGSTOP if it should show up later.
5734
5735 Also consider that the attach is complete when we see a
5736 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
5737 target extended-remote report it instead of a SIGSTOP
5738 (e.g. gdbserver). We already rely on SIGTRAP being our
5739 signal, so this is no exception.
5740
5741 Also consider that the attach is complete when we see a
5742 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
5743 the target to stop all threads of the inferior, in case the
5744 low level attach operation doesn't stop them implicitly. If
5745 they weren't stopped implicitly, then the stub will report a
5746 GDB_SIGNAL_0, meaning: stopped for no particular reason
5747 other than GDB's request. */
5748 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
5749 && (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_STOP
5750 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5751 || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_0))
5752 {
5753 stop_print_frame = 1;
5754 stop_waiting (ecs);
5755 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5756 return;
5757 }
5758
5759 /* See if something interesting happened to the non-current thread. If
5760 so, then switch to that thread. */
5761 if (!ptid_equal (ecs->ptid, inferior_ptid))
5762 {
5763 if (debug_infrun)
5764 fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
5765
5766 context_switch (ecs->ptid);
5767
5768 if (deprecated_context_hook)
5769 deprecated_context_hook (ptid_to_global_thread_id (ecs->ptid));
5770 }
5771
5772 /* At this point, get hold of the now-current thread's frame. */
5773 frame = get_current_frame ();
5774 gdbarch = get_frame_arch (frame);
5775
5776 /* Pull the single step breakpoints out of the target. */
5777 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
5778 {
5779 struct regcache *regcache;
5780 CORE_ADDR pc;
5781
5782 regcache = get_thread_regcache (ecs->ptid);
5783 const address_space *aspace = regcache->aspace ();
5784
5785 pc = regcache_read_pc (regcache);
5786
5787 /* However, before doing so, if this single-step breakpoint was
5788 actually for another thread, set this thread up for moving
5789 past it. */
5790 if (!thread_has_single_step_breakpoint_here (ecs->event_thread,
5791 aspace, pc))
5792 {
5793 if (single_step_breakpoint_inserted_here_p (aspace, pc))
5794 {
5795 if (debug_infrun)
5796 {
5797 fprintf_unfiltered (gdb_stdlog,
5798 "infrun: [%s] hit another thread's "
5799 "single-step breakpoint\n",
5800 target_pid_to_str (ecs->ptid));
5801 }
5802 ecs->hit_singlestep_breakpoint = 1;
5803 }
5804 }
5805 else
5806 {
5807 if (debug_infrun)
5808 {
5809 fprintf_unfiltered (gdb_stdlog,
5810 "infrun: [%s] hit its "
5811 "single-step breakpoint\n",
5812 target_pid_to_str (ecs->ptid));
5813 }
5814 }
5815 }
5816 delete_just_stopped_threads_single_step_breakpoints ();
5817
5818 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5819 && ecs->event_thread->control.trap_expected
5820 && ecs->event_thread->stepping_over_watchpoint)
5821 stopped_by_watchpoint = 0;
5822 else
5823 stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
5824
5825 /* If necessary, step over this watchpoint. We'll be back to display
5826 it in a moment. */
5827 if (stopped_by_watchpoint
5828 && (target_have_steppable_watchpoint
5829 || gdbarch_have_nonsteppable_watchpoint (gdbarch)))
5830 {
5831 /* At this point, we are stopped at an instruction which has
5832 attempted to write to a piece of memory under control of
5833 a watchpoint. The instruction hasn't actually executed
5834 yet. If we were to evaluate the watchpoint expression
5835 now, we would get the old value, and therefore no change
5836 would seem to have occurred.
5837
5838 In order to make watchpoints work `right', we really need
5839 to complete the memory write, and then evaluate the
5840 watchpoint expression. We do this by single-stepping the
5841 target.
5842
5843 It may not be necessary to disable the watchpoint to step over
5844 it. For example, the PA can (with some kernel cooperation)
5845 single step over a watchpoint without disabling the watchpoint.
5846
5847 It is far more common to need to disable a watchpoint to step
5848 the inferior over it. If we have non-steppable watchpoints,
5849 we must disable the current watchpoint; it's simplest to
5850 disable all watchpoints.
5851
5852 Any breakpoint at PC must also be stepped over -- if there's
5853 one, it will have already triggered before the watchpoint
5854 triggered, and we either already reported it to the user, or
5855 it didn't cause a stop and we called keep_going. In either
5856 case, if there was a breakpoint at PC, we must be trying to
5857 step past it. */
5858 ecs->event_thread->stepping_over_watchpoint = 1;
5859 keep_going (ecs);
5860 return;
5861 }
5862
5863 ecs->event_thread->stepping_over_breakpoint = 0;
5864 ecs->event_thread->stepping_over_watchpoint = 0;
5865 bpstat_clear (&ecs->event_thread->control.stop_bpstat);
5866 ecs->event_thread->control.stop_step = 0;
5867 stop_print_frame = 1;
5868 stopped_by_random_signal = 0;
5869
5870 /* Hide inlined functions starting here, unless we just performed stepi or
5871 nexti. After stepi and nexti, always show the innermost frame (not any
5872 inline function call sites). */
5873 if (ecs->event_thread->control.step_range_end != 1)
5874 {
5875 const address_space *aspace =
5876 get_thread_regcache (ecs->ptid)->aspace ();
5877
5878 /* skip_inline_frames is expensive, so we avoid it if we can
5879 determine that the address is one where functions cannot have
5880 been inlined. This improves performance with inferiors that
5881 load a lot of shared libraries, because the solib event
5882 breakpoint is defined as the address of a function (i.e. not
5883 inline). Note that we have to check the previous PC as well
5884 as the current one to catch cases when we have just
5885 single-stepped off a breakpoint prior to reinstating it.
5886 Note that we're assuming that the code we single-step to is
5887 not inline, but that's not definitive: there's nothing
5888 preventing the event breakpoint function from containing
5889 inlined code, and the single-step ending up there. If the
5890 user had set a breakpoint on that inlined code, the missing
5891 skip_inline_frames call would break things. Fortunately
5892 that's an extremely unlikely scenario. */
5893 if (!pc_at_non_inline_function (aspace, stop_pc, &ecs->ws)
5894 && !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5895 && ecs->event_thread->control.trap_expected
5896 && pc_at_non_inline_function (aspace,
5897 ecs->event_thread->prev_pc,
5898 &ecs->ws)))
5899 {
5900 skip_inline_frames (ecs->ptid);
5901
5902 /* Re-fetch current thread's frame in case that invalidated
5903 the frame cache. */
5904 frame = get_current_frame ();
5905 gdbarch = get_frame_arch (frame);
5906 }
5907 }
5908
5909 if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5910 && ecs->event_thread->control.trap_expected
5911 && gdbarch_single_step_through_delay_p (gdbarch)
5912 && currently_stepping (ecs->event_thread))
5913 {
5914 /* We're trying to step off a breakpoint. Turns out that we're
5915 also on an instruction that needs to be stepped multiple
5916 times before it's been fully executing. E.g., architectures
5917 with a delay slot. It needs to be stepped twice, once for
5918 the instruction and once for the delay slot. */
5919 int step_through_delay
5920 = gdbarch_single_step_through_delay (gdbarch, frame);
5921
5922 if (debug_infrun && step_through_delay)
5923 fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
5924 if (ecs->event_thread->control.step_range_end == 0
5925 && step_through_delay)
5926 {
5927 /* The user issued a continue when stopped at a breakpoint.
5928 Set up for another trap and get out of here. */
5929 ecs->event_thread->stepping_over_breakpoint = 1;
5930 keep_going (ecs);
5931 return;
5932 }
5933 else if (step_through_delay)
5934 {
5935 /* The user issued a step when stopped at a breakpoint.
5936 Maybe we should stop, maybe we should not - the delay
5937 slot *might* correspond to a line of source. In any
5938 case, don't decide that here, just set
5939 ecs->stepping_over_breakpoint, making sure we
5940 single-step again before breakpoints are re-inserted. */
5941 ecs->event_thread->stepping_over_breakpoint = 1;
5942 }
5943 }
5944
5945 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
5946 handles this event. */
5947 ecs->event_thread->control.stop_bpstat
5948 = bpstat_stop_status (get_current_regcache ()->aspace (),
5949 stop_pc, ecs->ptid, &ecs->ws);
5950
5951 /* Following in case break condition called a
5952 function. */
5953 stop_print_frame = 1;
5954
5955 /* This is where we handle "moribund" watchpoints. Unlike
5956 software breakpoints traps, hardware watchpoint traps are
5957 always distinguishable from random traps. If no high-level
5958 watchpoint is associated with the reported stop data address
5959 anymore, then the bpstat does not explain the signal ---
5960 simply make sure to ignore it if `stopped_by_watchpoint' is
5961 set. */
5962
5963 if (debug_infrun
5964 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
5965 && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
5966 GDB_SIGNAL_TRAP)
5967 && stopped_by_watchpoint)
5968 fprintf_unfiltered (gdb_stdlog,
5969 "infrun: no user watchpoint explains "
5970 "watchpoint SIGTRAP, ignoring\n");
5971
5972 /* NOTE: cagney/2003-03-29: These checks for a random signal
5973 at one stage in the past included checks for an inferior
5974 function call's call dummy's return breakpoint. The original
5975 comment, that went with the test, read:
5976
5977 ``End of a stack dummy. Some systems (e.g. Sony news) give
5978 another signal besides SIGTRAP, so check here as well as
5979 above.''
5980
5981 If someone ever tries to get call dummys on a
5982 non-executable stack to work (where the target would stop
5983 with something like a SIGSEGV), then those tests might need
5984 to be re-instated. Given, however, that the tests were only
5985 enabled when momentary breakpoints were not being used, I
5986 suspect that it won't be the case.
5987
5988 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
5989 be necessary for call dummies on a non-executable stack on
5990 SPARC. */
5991
5992 /* See if the breakpoints module can explain the signal. */
5993 random_signal
5994 = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
5995 ecs->event_thread->suspend.stop_signal);
5996
5997 /* Maybe this was a trap for a software breakpoint that has since
5998 been removed. */
5999 if (random_signal && target_stopped_by_sw_breakpoint ())
6000 {
6001 if (program_breakpoint_here_p (gdbarch, stop_pc))
6002 {
6003 struct regcache *regcache;
6004 int decr_pc;
6005
6006 /* Re-adjust PC to what the program would see if GDB was not
6007 debugging it. */
6008 regcache = get_thread_regcache (ecs->event_thread->ptid);
6009 decr_pc = gdbarch_decr_pc_after_break (gdbarch);
6010 if (decr_pc != 0)
6011 {
6012 gdb::optional<scoped_restore_tmpl<int>>
6013 restore_operation_disable;
6014
6015 if (record_full_is_used ())
6016 restore_operation_disable.emplace
6017 (record_full_gdb_operation_disable_set ());
6018
6019 regcache_write_pc (regcache, stop_pc + decr_pc);
6020 }
6021 }
6022 else
6023 {
6024 /* A delayed software breakpoint event. Ignore the trap. */
6025 if (debug_infrun)
6026 fprintf_unfiltered (gdb_stdlog,
6027 "infrun: delayed software breakpoint "
6028 "trap, ignoring\n");
6029 random_signal = 0;
6030 }
6031 }
6032
6033 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
6034 has since been removed. */
6035 if (random_signal && target_stopped_by_hw_breakpoint ())
6036 {
6037 /* A delayed hardware breakpoint event. Ignore the trap. */
6038 if (debug_infrun)
6039 fprintf_unfiltered (gdb_stdlog,
6040 "infrun: delayed hardware breakpoint/watchpoint "
6041 "trap, ignoring\n");
6042 random_signal = 0;
6043 }
6044
6045 /* If not, perhaps stepping/nexting can. */
6046 if (random_signal)
6047 random_signal = !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
6048 && currently_stepping (ecs->event_thread));
6049
6050 /* Perhaps the thread hit a single-step breakpoint of _another_
6051 thread. Single-step breakpoints are transparent to the
6052 breakpoints module. */
6053 if (random_signal)
6054 random_signal = !ecs->hit_singlestep_breakpoint;
6055
6056 /* No? Perhaps we got a moribund watchpoint. */
6057 if (random_signal)
6058 random_signal = !stopped_by_watchpoint;
6059
6060 /* Always stop if the user explicitly requested this thread to
6061 remain stopped. */
6062 if (ecs->event_thread->stop_requested)
6063 {
6064 random_signal = 1;
6065 if (debug_infrun)
6066 fprintf_unfiltered (gdb_stdlog, "infrun: user-requested stop\n");
6067 }
6068
6069 /* For the program's own signals, act according to
6070 the signal handling tables. */
6071
6072 if (random_signal)
6073 {
6074 /* Signal not for debugging purposes. */
6075 struct inferior *inf = find_inferior_ptid (ecs->ptid);
6076 enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
6077
6078 if (debug_infrun)
6079 fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
6080 gdb_signal_to_symbol_string (stop_signal));
6081
6082 stopped_by_random_signal = 1;
6083
6084 /* Always stop on signals if we're either just gaining control
6085 of the program, or the user explicitly requested this thread
6086 to remain stopped. */
6087 if (stop_soon != NO_STOP_QUIETLY
6088 || ecs->event_thread->stop_requested
6089 || (!inf->detaching
6090 && signal_stop_state (ecs->event_thread->suspend.stop_signal)))
6091 {
6092 stop_waiting (ecs);
6093 return;
6094 }
6095
6096 /* Notify observers the signal has "handle print" set. Note we
6097 returned early above if stopping; normal_stop handles the
6098 printing in that case. */
6099 if (signal_print[ecs->event_thread->suspend.stop_signal])
6100 {
6101 /* The signal table tells us to print about this signal. */
6102 target_terminal::ours_for_output ();
6103 observer_notify_signal_received (ecs->event_thread->suspend.stop_signal);
6104 target_terminal::inferior ();
6105 }
6106
6107 /* Clear the signal if it should not be passed. */
6108 if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
6109 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
6110
6111 if (ecs->event_thread->prev_pc == stop_pc
6112 && ecs->event_thread->control.trap_expected
6113 && ecs->event_thread->control.step_resume_breakpoint == NULL)
6114 {
6115 /* We were just starting a new sequence, attempting to
6116 single-step off of a breakpoint and expecting a SIGTRAP.
6117 Instead this signal arrives. This signal will take us out
6118 of the stepping range so GDB needs to remember to, when
6119 the signal handler returns, resume stepping off that
6120 breakpoint. */
6121 /* To simplify things, "continue" is forced to use the same
6122 code paths as single-step - set a breakpoint at the
6123 signal return address and then, once hit, step off that
6124 breakpoint. */
6125 if (debug_infrun)
6126 fprintf_unfiltered (gdb_stdlog,
6127 "infrun: signal arrived while stepping over "
6128 "breakpoint\n");
6129
6130 insert_hp_step_resume_breakpoint_at_frame (frame);
6131 ecs->event_thread->step_after_step_resume_breakpoint = 1;
6132 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6133 ecs->event_thread->control.trap_expected = 0;
6134
6135 /* If we were nexting/stepping some other thread, switch to
6136 it, so that we don't continue it, losing control. */
6137 if (!switch_back_to_stepped_thread (ecs))
6138 keep_going (ecs);
6139 return;
6140 }
6141
6142 if (ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
6143 && (pc_in_thread_step_range (stop_pc, ecs->event_thread)
6144 || ecs->event_thread->control.step_range_end == 1)
6145 && frame_id_eq (get_stack_frame_id (frame),
6146 ecs->event_thread->control.step_stack_frame_id)
6147 && ecs->event_thread->control.step_resume_breakpoint == NULL)
6148 {
6149 /* The inferior is about to take a signal that will take it
6150 out of the single step range. Set a breakpoint at the
6151 current PC (which is presumably where the signal handler
6152 will eventually return) and then allow the inferior to
6153 run free.
6154
6155 Note that this is only needed for a signal delivered
6156 while in the single-step range. Nested signals aren't a
6157 problem as they eventually all return. */
6158 if (debug_infrun)
6159 fprintf_unfiltered (gdb_stdlog,
6160 "infrun: signal may take us out of "
6161 "single-step range\n");
6162
6163 clear_step_over_info ();
6164 insert_hp_step_resume_breakpoint_at_frame (frame);
6165 ecs->event_thread->step_after_step_resume_breakpoint = 1;
6166 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6167 ecs->event_thread->control.trap_expected = 0;
6168 keep_going (ecs);
6169 return;
6170 }
6171
6172 /* Note: step_resume_breakpoint may be non-NULL. This occures
6173 when either there's a nested signal, or when there's a
6174 pending signal enabled just as the signal handler returns
6175 (leaving the inferior at the step-resume-breakpoint without
6176 actually executing it). Either way continue until the
6177 breakpoint is really hit. */
6178
6179 if (!switch_back_to_stepped_thread (ecs))
6180 {
6181 if (debug_infrun)
6182 fprintf_unfiltered (gdb_stdlog,
6183 "infrun: random signal, keep going\n");
6184
6185 keep_going (ecs);
6186 }
6187 return;
6188 }
6189
6190 process_event_stop_test (ecs);
6191 }
6192
6193 /* Come here when we've got some debug event / signal we can explain
6194 (IOW, not a random signal), and test whether it should cause a
6195 stop, or whether we should resume the inferior (transparently).
6196 E.g., could be a breakpoint whose condition evaluates false; we
6197 could be still stepping within the line; etc. */
6198
6199 static void
6200 process_event_stop_test (struct execution_control_state *ecs)
6201 {
6202 struct symtab_and_line stop_pc_sal;
6203 struct frame_info *frame;
6204 struct gdbarch *gdbarch;
6205 CORE_ADDR jmp_buf_pc;
6206 struct bpstat_what what;
6207
6208 /* Handle cases caused by hitting a breakpoint. */
6209
6210 frame = get_current_frame ();
6211 gdbarch = get_frame_arch (frame);
6212
6213 what = bpstat_what (ecs->event_thread->control.stop_bpstat);
6214
6215 if (what.call_dummy)
6216 {
6217 stop_stack_dummy = what.call_dummy;
6218 }
6219
6220 /* A few breakpoint types have callbacks associated (e.g.,
6221 bp_jit_event). Run them now. */
6222 bpstat_run_callbacks (ecs->event_thread->control.stop_bpstat);
6223
6224 /* If we hit an internal event that triggers symbol changes, the
6225 current frame will be invalidated within bpstat_what (e.g., if we
6226 hit an internal solib event). Re-fetch it. */
6227 frame = get_current_frame ();
6228 gdbarch = get_frame_arch (frame);
6229
6230 switch (what.main_action)
6231 {
6232 case BPSTAT_WHAT_SET_LONGJMP_RESUME:
6233 /* If we hit the breakpoint at longjmp while stepping, we
6234 install a momentary breakpoint at the target of the
6235 jmp_buf. */
6236
6237 if (debug_infrun)
6238 fprintf_unfiltered (gdb_stdlog,
6239 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
6240
6241 ecs->event_thread->stepping_over_breakpoint = 1;
6242
6243 if (what.is_longjmp)
6244 {
6245 struct value *arg_value;
6246
6247 /* If we set the longjmp breakpoint via a SystemTap probe,
6248 then use it to extract the arguments. The destination PC
6249 is the third argument to the probe. */
6250 arg_value = probe_safe_evaluate_at_pc (frame, 2);
6251 if (arg_value)
6252 {
6253 jmp_buf_pc = value_as_address (arg_value);
6254 jmp_buf_pc = gdbarch_addr_bits_remove (gdbarch, jmp_buf_pc);
6255 }
6256 else if (!gdbarch_get_longjmp_target_p (gdbarch)
6257 || !gdbarch_get_longjmp_target (gdbarch,
6258 frame, &jmp_buf_pc))
6259 {
6260 if (debug_infrun)
6261 fprintf_unfiltered (gdb_stdlog,
6262 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
6263 "(!gdbarch_get_longjmp_target)\n");
6264 keep_going (ecs);
6265 return;
6266 }
6267
6268 /* Insert a breakpoint at resume address. */
6269 insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
6270 }
6271 else
6272 check_exception_resume (ecs, frame);
6273 keep_going (ecs);
6274 return;
6275
6276 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
6277 {
6278 struct frame_info *init_frame;
6279
6280 /* There are several cases to consider.
6281
6282 1. The initiating frame no longer exists. In this case we
6283 must stop, because the exception or longjmp has gone too
6284 far.
6285
6286 2. The initiating frame exists, and is the same as the
6287 current frame. We stop, because the exception or longjmp
6288 has been caught.
6289
6290 3. The initiating frame exists and is different from the
6291 current frame. This means the exception or longjmp has
6292 been caught beneath the initiating frame, so keep going.
6293
6294 4. longjmp breakpoint has been placed just to protect
6295 against stale dummy frames and user is not interested in
6296 stopping around longjmps. */
6297
6298 if (debug_infrun)
6299 fprintf_unfiltered (gdb_stdlog,
6300 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
6301
6302 gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
6303 != NULL);
6304 delete_exception_resume_breakpoint (ecs->event_thread);
6305
6306 if (what.is_longjmp)
6307 {
6308 check_longjmp_breakpoint_for_call_dummy (ecs->event_thread);
6309
6310 if (!frame_id_p (ecs->event_thread->initiating_frame))
6311 {
6312 /* Case 4. */
6313 keep_going (ecs);
6314 return;
6315 }
6316 }
6317
6318 init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
6319
6320 if (init_frame)
6321 {
6322 struct frame_id current_id
6323 = get_frame_id (get_current_frame ());
6324 if (frame_id_eq (current_id,
6325 ecs->event_thread->initiating_frame))
6326 {
6327 /* Case 2. Fall through. */
6328 }
6329 else
6330 {
6331 /* Case 3. */
6332 keep_going (ecs);
6333 return;
6334 }
6335 }
6336
6337 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6338 exists. */
6339 delete_step_resume_breakpoint (ecs->event_thread);
6340
6341 end_stepping_range (ecs);
6342 }
6343 return;
6344
6345 case BPSTAT_WHAT_SINGLE:
6346 if (debug_infrun)
6347 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
6348 ecs->event_thread->stepping_over_breakpoint = 1;
6349 /* Still need to check other stuff, at least the case where we
6350 are stepping and step out of the right range. */
6351 break;
6352
6353 case BPSTAT_WHAT_STEP_RESUME:
6354 if (debug_infrun)
6355 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
6356
6357 delete_step_resume_breakpoint (ecs->event_thread);
6358 if (ecs->event_thread->control.proceed_to_finish
6359 && execution_direction == EXEC_REVERSE)
6360 {
6361 struct thread_info *tp = ecs->event_thread;
6362
6363 /* We are finishing a function in reverse, and just hit the
6364 step-resume breakpoint at the start address of the
6365 function, and we're almost there -- just need to back up
6366 by one more single-step, which should take us back to the
6367 function call. */
6368 tp->control.step_range_start = tp->control.step_range_end = 1;
6369 keep_going (ecs);
6370 return;
6371 }
6372 fill_in_stop_func (gdbarch, ecs);
6373 if (stop_pc == ecs->stop_func_start
6374 && execution_direction == EXEC_REVERSE)
6375 {
6376 /* We are stepping over a function call in reverse, and just
6377 hit the step-resume breakpoint at the start address of
6378 the function. Go back to single-stepping, which should
6379 take us back to the function call. */
6380 ecs->event_thread->stepping_over_breakpoint = 1;
6381 keep_going (ecs);
6382 return;
6383 }
6384 break;
6385
6386 case BPSTAT_WHAT_STOP_NOISY:
6387 if (debug_infrun)
6388 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
6389 stop_print_frame = 1;
6390
6391 /* Assume the thread stopped for a breapoint. We'll still check
6392 whether a/the breakpoint is there when the thread is next
6393 resumed. */
6394 ecs->event_thread->stepping_over_breakpoint = 1;
6395
6396 stop_waiting (ecs);
6397 return;
6398
6399 case BPSTAT_WHAT_STOP_SILENT:
6400 if (debug_infrun)
6401 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
6402 stop_print_frame = 0;
6403
6404 /* Assume the thread stopped for a breapoint. We'll still check
6405 whether a/the breakpoint is there when the thread is next
6406 resumed. */
6407 ecs->event_thread->stepping_over_breakpoint = 1;
6408 stop_waiting (ecs);
6409 return;
6410
6411 case BPSTAT_WHAT_HP_STEP_RESUME:
6412 if (debug_infrun)
6413 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
6414
6415 delete_step_resume_breakpoint (ecs->event_thread);
6416 if (ecs->event_thread->step_after_step_resume_breakpoint)
6417 {
6418 /* Back when the step-resume breakpoint was inserted, we
6419 were trying to single-step off a breakpoint. Go back to
6420 doing that. */
6421 ecs->event_thread->step_after_step_resume_breakpoint = 0;
6422 ecs->event_thread->stepping_over_breakpoint = 1;
6423 keep_going (ecs);
6424 return;
6425 }
6426 break;
6427
6428 case BPSTAT_WHAT_KEEP_CHECKING:
6429 break;
6430 }
6431
6432 /* If we stepped a permanent breakpoint and we had a high priority
6433 step-resume breakpoint for the address we stepped, but we didn't
6434 hit it, then we must have stepped into the signal handler. The
6435 step-resume was only necessary to catch the case of _not_
6436 stepping into the handler, so delete it, and fall through to
6437 checking whether the step finished. */
6438 if (ecs->event_thread->stepped_breakpoint)
6439 {
6440 struct breakpoint *sr_bp
6441 = ecs->event_thread->control.step_resume_breakpoint;
6442
6443 if (sr_bp != NULL
6444 && sr_bp->loc->permanent
6445 && sr_bp->type == bp_hp_step_resume
6446 && sr_bp->loc->address == ecs->event_thread->prev_pc)
6447 {
6448 if (debug_infrun)
6449 fprintf_unfiltered (gdb_stdlog,
6450 "infrun: stepped permanent breakpoint, stopped in "
6451 "handler\n");
6452 delete_step_resume_breakpoint (ecs->event_thread);
6453 ecs->event_thread->step_after_step_resume_breakpoint = 0;
6454 }
6455 }
6456
6457 /* We come here if we hit a breakpoint but should not stop for it.
6458 Possibly we also were stepping and should stop for that. So fall
6459 through and test for stepping. But, if not stepping, do not
6460 stop. */
6461
6462 /* In all-stop mode, if we're currently stepping but have stopped in
6463 some other thread, we need to switch back to the stepped thread. */
6464 if (switch_back_to_stepped_thread (ecs))
6465 return;
6466
6467 if (ecs->event_thread->control.step_resume_breakpoint)
6468 {
6469 if (debug_infrun)
6470 fprintf_unfiltered (gdb_stdlog,
6471 "infrun: step-resume breakpoint is inserted\n");
6472
6473 /* Having a step-resume breakpoint overrides anything
6474 else having to do with stepping commands until
6475 that breakpoint is reached. */
6476 keep_going (ecs);
6477 return;
6478 }
6479
6480 if (ecs->event_thread->control.step_range_end == 0)
6481 {
6482 if (debug_infrun)
6483 fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
6484 /* Likewise if we aren't even stepping. */
6485 keep_going (ecs);
6486 return;
6487 }
6488
6489 /* Re-fetch current thread's frame in case the code above caused
6490 the frame cache to be re-initialized, making our FRAME variable
6491 a dangling pointer. */
6492 frame = get_current_frame ();
6493 gdbarch = get_frame_arch (frame);
6494 fill_in_stop_func (gdbarch, ecs);
6495
6496 /* If stepping through a line, keep going if still within it.
6497
6498 Note that step_range_end is the address of the first instruction
6499 beyond the step range, and NOT the address of the last instruction
6500 within it!
6501
6502 Note also that during reverse execution, we may be stepping
6503 through a function epilogue and therefore must detect when
6504 the current-frame changes in the middle of a line. */
6505
6506 if (pc_in_thread_step_range (stop_pc, ecs->event_thread)
6507 && (execution_direction != EXEC_REVERSE
6508 || frame_id_eq (get_frame_id (frame),
6509 ecs->event_thread->control.step_frame_id)))
6510 {
6511 if (debug_infrun)
6512 fprintf_unfiltered
6513 (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
6514 paddress (gdbarch, ecs->event_thread->control.step_range_start),
6515 paddress (gdbarch, ecs->event_thread->control.step_range_end));
6516
6517 /* Tentatively re-enable range stepping; `resume' disables it if
6518 necessary (e.g., if we're stepping over a breakpoint or we
6519 have software watchpoints). */
6520 ecs->event_thread->control.may_range_step = 1;
6521
6522 /* When stepping backward, stop at beginning of line range
6523 (unless it's the function entry point, in which case
6524 keep going back to the call point). */
6525 if (stop_pc == ecs->event_thread->control.step_range_start
6526 && stop_pc != ecs->stop_func_start
6527 && execution_direction == EXEC_REVERSE)
6528 end_stepping_range (ecs);
6529 else
6530 keep_going (ecs);
6531
6532 return;
6533 }
6534
6535 /* We stepped out of the stepping range. */
6536
6537 /* If we are stepping at the source level and entered the runtime
6538 loader dynamic symbol resolution code...
6539
6540 EXEC_FORWARD: we keep on single stepping until we exit the run
6541 time loader code and reach the callee's address.
6542
6543 EXEC_REVERSE: we've already executed the callee (backward), and
6544 the runtime loader code is handled just like any other
6545 undebuggable function call. Now we need only keep stepping
6546 backward through the trampoline code, and that's handled further
6547 down, so there is nothing for us to do here. */
6548
6549 if (execution_direction != EXEC_REVERSE
6550 && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6551 && in_solib_dynsym_resolve_code (stop_pc))
6552 {
6553 CORE_ADDR pc_after_resolver =
6554 gdbarch_skip_solib_resolver (gdbarch, stop_pc);
6555
6556 if (debug_infrun)
6557 fprintf_unfiltered (gdb_stdlog,
6558 "infrun: stepped into dynsym resolve code\n");
6559
6560 if (pc_after_resolver)
6561 {
6562 /* Set up a step-resume breakpoint at the address
6563 indicated by SKIP_SOLIB_RESOLVER. */
6564 symtab_and_line sr_sal;
6565 sr_sal.pc = pc_after_resolver;
6566 sr_sal.pspace = get_frame_program_space (frame);
6567
6568 insert_step_resume_breakpoint_at_sal (gdbarch,
6569 sr_sal, null_frame_id);
6570 }
6571
6572 keep_going (ecs);
6573 return;
6574 }
6575
6576 if (ecs->event_thread->control.step_range_end != 1
6577 && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6578 || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6579 && get_frame_type (frame) == SIGTRAMP_FRAME)
6580 {
6581 if (debug_infrun)
6582 fprintf_unfiltered (gdb_stdlog,
6583 "infrun: stepped into signal trampoline\n");
6584 /* The inferior, while doing a "step" or "next", has ended up in
6585 a signal trampoline (either by a signal being delivered or by
6586 the signal handler returning). Just single-step until the
6587 inferior leaves the trampoline (either by calling the handler
6588 or returning). */
6589 keep_going (ecs);
6590 return;
6591 }
6592
6593 /* If we're in the return path from a shared library trampoline,
6594 we want to proceed through the trampoline when stepping. */
6595 /* macro/2012-04-25: This needs to come before the subroutine
6596 call check below as on some targets return trampolines look
6597 like subroutine calls (MIPS16 return thunks). */
6598 if (gdbarch_in_solib_return_trampoline (gdbarch,
6599 stop_pc, ecs->stop_func_name)
6600 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
6601 {
6602 /* Determine where this trampoline returns. */
6603 CORE_ADDR real_stop_pc;
6604
6605 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
6606
6607 if (debug_infrun)
6608 fprintf_unfiltered (gdb_stdlog,
6609 "infrun: stepped into solib return tramp\n");
6610
6611 /* Only proceed through if we know where it's going. */
6612 if (real_stop_pc)
6613 {
6614 /* And put the step-breakpoint there and go until there. */
6615 symtab_and_line sr_sal;
6616 sr_sal.pc = real_stop_pc;
6617 sr_sal.section = find_pc_overlay (sr_sal.pc);
6618 sr_sal.pspace = get_frame_program_space (frame);
6619
6620 /* Do not specify what the fp should be when we stop since
6621 on some machines the prologue is where the new fp value
6622 is established. */
6623 insert_step_resume_breakpoint_at_sal (gdbarch,
6624 sr_sal, null_frame_id);
6625
6626 /* Restart without fiddling with the step ranges or
6627 other state. */
6628 keep_going (ecs);
6629 return;
6630 }
6631 }
6632
6633 /* Check for subroutine calls. The check for the current frame
6634 equalling the step ID is not necessary - the check of the
6635 previous frame's ID is sufficient - but it is a common case and
6636 cheaper than checking the previous frame's ID.
6637
6638 NOTE: frame_id_eq will never report two invalid frame IDs as
6639 being equal, so to get into this block, both the current and
6640 previous frame must have valid frame IDs. */
6641 /* The outer_frame_id check is a heuristic to detect stepping
6642 through startup code. If we step over an instruction which
6643 sets the stack pointer from an invalid value to a valid value,
6644 we may detect that as a subroutine call from the mythical
6645 "outermost" function. This could be fixed by marking
6646 outermost frames as !stack_p,code_p,special_p. Then the
6647 initial outermost frame, before sp was valid, would
6648 have code_addr == &_start. See the comment in frame_id_eq
6649 for more. */
6650 if (!frame_id_eq (get_stack_frame_id (frame),
6651 ecs->event_thread->control.step_stack_frame_id)
6652 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
6653 ecs->event_thread->control.step_stack_frame_id)
6654 && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
6655 outer_frame_id)
6656 || (ecs->event_thread->control.step_start_function
6657 != find_pc_function (stop_pc)))))
6658 {
6659 CORE_ADDR real_stop_pc;
6660
6661 if (debug_infrun)
6662 fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
6663
6664 if (ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
6665 {
6666 /* I presume that step_over_calls is only 0 when we're
6667 supposed to be stepping at the assembly language level
6668 ("stepi"). Just stop. */
6669 /* And this works the same backward as frontward. MVS */
6670 end_stepping_range (ecs);
6671 return;
6672 }
6673
6674 /* Reverse stepping through solib trampolines. */
6675
6676 if (execution_direction == EXEC_REVERSE
6677 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
6678 && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6679 || (ecs->stop_func_start == 0
6680 && in_solib_dynsym_resolve_code (stop_pc))))
6681 {
6682 /* Any solib trampoline code can be handled in reverse
6683 by simply continuing to single-step. We have already
6684 executed the solib function (backwards), and a few
6685 steps will take us back through the trampoline to the
6686 caller. */
6687 keep_going (ecs);
6688 return;
6689 }
6690
6691 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6692 {
6693 /* We're doing a "next".
6694
6695 Normal (forward) execution: set a breakpoint at the
6696 callee's return address (the address at which the caller
6697 will resume).
6698
6699 Reverse (backward) execution. set the step-resume
6700 breakpoint at the start of the function that we just
6701 stepped into (backwards), and continue to there. When we
6702 get there, we'll need to single-step back to the caller. */
6703
6704 if (execution_direction == EXEC_REVERSE)
6705 {
6706 /* If we're already at the start of the function, we've either
6707 just stepped backward into a single instruction function,
6708 or stepped back out of a signal handler to the first instruction
6709 of the function. Just keep going, which will single-step back
6710 to the caller. */
6711 if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
6712 {
6713 /* Normal function call return (static or dynamic). */
6714 symtab_and_line sr_sal;
6715 sr_sal.pc = ecs->stop_func_start;
6716 sr_sal.pspace = get_frame_program_space (frame);
6717 insert_step_resume_breakpoint_at_sal (gdbarch,
6718 sr_sal, null_frame_id);
6719 }
6720 }
6721 else
6722 insert_step_resume_breakpoint_at_caller (frame);
6723
6724 keep_going (ecs);
6725 return;
6726 }
6727
6728 /* If we are in a function call trampoline (a stub between the
6729 calling routine and the real function), locate the real
6730 function. That's what tells us (a) whether we want to step
6731 into it at all, and (b) what prologue we want to run to the
6732 end of, if we do step into it. */
6733 real_stop_pc = skip_language_trampoline (frame, stop_pc);
6734 if (real_stop_pc == 0)
6735 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
6736 if (real_stop_pc != 0)
6737 ecs->stop_func_start = real_stop_pc;
6738
6739 if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
6740 {
6741 symtab_and_line sr_sal;
6742 sr_sal.pc = ecs->stop_func_start;
6743 sr_sal.pspace = get_frame_program_space (frame);
6744
6745 insert_step_resume_breakpoint_at_sal (gdbarch,
6746 sr_sal, null_frame_id);
6747 keep_going (ecs);
6748 return;
6749 }
6750
6751 /* If we have line number information for the function we are
6752 thinking of stepping into and the function isn't on the skip
6753 list, step into it.
6754
6755 If there are several symtabs at that PC (e.g. with include
6756 files), just want to know whether *any* of them have line
6757 numbers. find_pc_line handles this. */
6758 {
6759 struct symtab_and_line tmp_sal;
6760
6761 tmp_sal = find_pc_line (ecs->stop_func_start, 0);
6762 if (tmp_sal.line != 0
6763 && !function_name_is_marked_for_skip (ecs->stop_func_name,
6764 tmp_sal))
6765 {
6766 if (execution_direction == EXEC_REVERSE)
6767 handle_step_into_function_backward (gdbarch, ecs);
6768 else
6769 handle_step_into_function (gdbarch, ecs);
6770 return;
6771 }
6772 }
6773
6774 /* If we have no line number and the step-stop-if-no-debug is
6775 set, we stop the step so that the user has a chance to switch
6776 in assembly mode. */
6777 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6778 && step_stop_if_no_debug)
6779 {
6780 end_stepping_range (ecs);
6781 return;
6782 }
6783
6784 if (execution_direction == EXEC_REVERSE)
6785 {
6786 /* If we're already at the start of the function, we've either just
6787 stepped backward into a single instruction function without line
6788 number info, or stepped back out of a signal handler to the first
6789 instruction of the function without line number info. Just keep
6790 going, which will single-step back to the caller. */
6791 if (ecs->stop_func_start != stop_pc)
6792 {
6793 /* Set a breakpoint at callee's start address.
6794 From there we can step once and be back in the caller. */
6795 symtab_and_line sr_sal;
6796 sr_sal.pc = ecs->stop_func_start;
6797 sr_sal.pspace = get_frame_program_space (frame);
6798 insert_step_resume_breakpoint_at_sal (gdbarch,
6799 sr_sal, null_frame_id);
6800 }
6801 }
6802 else
6803 /* Set a breakpoint at callee's return address (the address
6804 at which the caller will resume). */
6805 insert_step_resume_breakpoint_at_caller (frame);
6806
6807 keep_going (ecs);
6808 return;
6809 }
6810
6811 /* Reverse stepping through solib trampolines. */
6812
6813 if (execution_direction == EXEC_REVERSE
6814 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
6815 {
6816 if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
6817 || (ecs->stop_func_start == 0
6818 && in_solib_dynsym_resolve_code (stop_pc)))
6819 {
6820 /* Any solib trampoline code can be handled in reverse
6821 by simply continuing to single-step. We have already
6822 executed the solib function (backwards), and a few
6823 steps will take us back through the trampoline to the
6824 caller. */
6825 keep_going (ecs);
6826 return;
6827 }
6828 else if (in_solib_dynsym_resolve_code (stop_pc))
6829 {
6830 /* Stepped backward into the solib dynsym resolver.
6831 Set a breakpoint at its start and continue, then
6832 one more step will take us out. */
6833 symtab_and_line sr_sal;
6834 sr_sal.pc = ecs->stop_func_start;
6835 sr_sal.pspace = get_frame_program_space (frame);
6836 insert_step_resume_breakpoint_at_sal (gdbarch,
6837 sr_sal, null_frame_id);
6838 keep_going (ecs);
6839 return;
6840 }
6841 }
6842
6843 stop_pc_sal = find_pc_line (stop_pc, 0);
6844
6845 /* NOTE: tausq/2004-05-24: This if block used to be done before all
6846 the trampoline processing logic, however, there are some trampolines
6847 that have no names, so we should do trampoline handling first. */
6848 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
6849 && ecs->stop_func_name == NULL
6850 && stop_pc_sal.line == 0)
6851 {
6852 if (debug_infrun)
6853 fprintf_unfiltered (gdb_stdlog,
6854 "infrun: stepped into undebuggable function\n");
6855
6856 /* The inferior just stepped into, or returned to, an
6857 undebuggable function (where there is no debugging information
6858 and no line number corresponding to the address where the
6859 inferior stopped). Since we want to skip this kind of code,
6860 we keep going until the inferior returns from this
6861 function - unless the user has asked us not to (via
6862 set step-mode) or we no longer know how to get back
6863 to the call site. */
6864 if (step_stop_if_no_debug
6865 || !frame_id_p (frame_unwind_caller_id (frame)))
6866 {
6867 /* If we have no line number and the step-stop-if-no-debug
6868 is set, we stop the step so that the user has a chance to
6869 switch in assembly mode. */
6870 end_stepping_range (ecs);
6871 return;
6872 }
6873 else
6874 {
6875 /* Set a breakpoint at callee's return address (the address
6876 at which the caller will resume). */
6877 insert_step_resume_breakpoint_at_caller (frame);
6878 keep_going (ecs);
6879 return;
6880 }
6881 }
6882
6883 if (ecs->event_thread->control.step_range_end == 1)
6884 {
6885 /* It is stepi or nexti. We always want to stop stepping after
6886 one instruction. */
6887 if (debug_infrun)
6888 fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
6889 end_stepping_range (ecs);
6890 return;
6891 }
6892
6893 if (stop_pc_sal.line == 0)
6894 {
6895 /* We have no line number information. That means to stop
6896 stepping (does this always happen right after one instruction,
6897 when we do "s" in a function with no line numbers,
6898 or can this happen as a result of a return or longjmp?). */
6899 if (debug_infrun)
6900 fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
6901 end_stepping_range (ecs);
6902 return;
6903 }
6904
6905 /* Look for "calls" to inlined functions, part one. If the inline
6906 frame machinery detected some skipped call sites, we have entered
6907 a new inline function. */
6908
6909 if (frame_id_eq (get_frame_id (get_current_frame ()),
6910 ecs->event_thread->control.step_frame_id)
6911 && inline_skipped_frames (ecs->ptid))
6912 {
6913 if (debug_infrun)
6914 fprintf_unfiltered (gdb_stdlog,
6915 "infrun: stepped into inlined function\n");
6916
6917 symtab_and_line call_sal = find_frame_sal (get_current_frame ());
6918
6919 if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
6920 {
6921 /* For "step", we're going to stop. But if the call site
6922 for this inlined function is on the same source line as
6923 we were previously stepping, go down into the function
6924 first. Otherwise stop at the call site. */
6925
6926 if (call_sal.line == ecs->event_thread->current_line
6927 && call_sal.symtab == ecs->event_thread->current_symtab)
6928 step_into_inline_frame (ecs->ptid);
6929
6930 end_stepping_range (ecs);
6931 return;
6932 }
6933 else
6934 {
6935 /* For "next", we should stop at the call site if it is on a
6936 different source line. Otherwise continue through the
6937 inlined function. */
6938 if (call_sal.line == ecs->event_thread->current_line
6939 && call_sal.symtab == ecs->event_thread->current_symtab)
6940 keep_going (ecs);
6941 else
6942 end_stepping_range (ecs);
6943 return;
6944 }
6945 }
6946
6947 /* Look for "calls" to inlined functions, part two. If we are still
6948 in the same real function we were stepping through, but we have
6949 to go further up to find the exact frame ID, we are stepping
6950 through a more inlined call beyond its call site. */
6951
6952 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
6953 && !frame_id_eq (get_frame_id (get_current_frame ()),
6954 ecs->event_thread->control.step_frame_id)
6955 && stepped_in_from (get_current_frame (),
6956 ecs->event_thread->control.step_frame_id))
6957 {
6958 if (debug_infrun)
6959 fprintf_unfiltered (gdb_stdlog,
6960 "infrun: stepping through inlined function\n");
6961
6962 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
6963 keep_going (ecs);
6964 else
6965 end_stepping_range (ecs);
6966 return;
6967 }
6968
6969 if ((stop_pc == stop_pc_sal.pc)
6970 && (ecs->event_thread->current_line != stop_pc_sal.line
6971 || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
6972 {
6973 /* We are at the start of a different line. So stop. Note that
6974 we don't stop if we step into the middle of a different line.
6975 That is said to make things like for (;;) statements work
6976 better. */
6977 if (debug_infrun)
6978 fprintf_unfiltered (gdb_stdlog,
6979 "infrun: stepped to a different line\n");
6980 end_stepping_range (ecs);
6981 return;
6982 }
6983
6984 /* We aren't done stepping.
6985
6986 Optimize by setting the stepping range to the line.
6987 (We might not be in the original line, but if we entered a
6988 new line in mid-statement, we continue stepping. This makes
6989 things like for(;;) statements work better.) */
6990
6991 ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
6992 ecs->event_thread->control.step_range_end = stop_pc_sal.end;
6993 ecs->event_thread->control.may_range_step = 1;
6994 set_step_info (frame, stop_pc_sal);
6995
6996 if (debug_infrun)
6997 fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
6998 keep_going (ecs);
6999 }
7000
7001 /* In all-stop mode, if we're currently stepping but have stopped in
7002 some other thread, we may need to switch back to the stepped
7003 thread. Returns true we set the inferior running, false if we left
7004 it stopped (and the event needs further processing). */
7005
7006 static int
7007 switch_back_to_stepped_thread (struct execution_control_state *ecs)
7008 {
7009 if (!target_is_non_stop_p ())
7010 {
7011 struct thread_info *tp;
7012 struct thread_info *stepping_thread;
7013
7014 /* If any thread is blocked on some internal breakpoint, and we
7015 simply need to step over that breakpoint to get it going
7016 again, do that first. */
7017
7018 /* However, if we see an event for the stepping thread, then we
7019 know all other threads have been moved past their breakpoints
7020 already. Let the caller check whether the step is finished,
7021 etc., before deciding to move it past a breakpoint. */
7022 if (ecs->event_thread->control.step_range_end != 0)
7023 return 0;
7024
7025 /* Check if the current thread is blocked on an incomplete
7026 step-over, interrupted by a random signal. */
7027 if (ecs->event_thread->control.trap_expected
7028 && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
7029 {
7030 if (debug_infrun)
7031 {
7032 fprintf_unfiltered (gdb_stdlog,
7033 "infrun: need to finish step-over of [%s]\n",
7034 target_pid_to_str (ecs->event_thread->ptid));
7035 }
7036 keep_going (ecs);
7037 return 1;
7038 }
7039
7040 /* Check if the current thread is blocked by a single-step
7041 breakpoint of another thread. */
7042 if (ecs->hit_singlestep_breakpoint)
7043 {
7044 if (debug_infrun)
7045 {
7046 fprintf_unfiltered (gdb_stdlog,
7047 "infrun: need to step [%s] over single-step "
7048 "breakpoint\n",
7049 target_pid_to_str (ecs->ptid));
7050 }
7051 keep_going (ecs);
7052 return 1;
7053 }
7054
7055 /* If this thread needs yet another step-over (e.g., stepping
7056 through a delay slot), do it first before moving on to
7057 another thread. */
7058 if (thread_still_needs_step_over (ecs->event_thread))
7059 {
7060 if (debug_infrun)
7061 {
7062 fprintf_unfiltered (gdb_stdlog,
7063 "infrun: thread [%s] still needs step-over\n",
7064 target_pid_to_str (ecs->event_thread->ptid));
7065 }
7066 keep_going (ecs);
7067 return 1;
7068 }
7069
7070 /* If scheduler locking applies even if not stepping, there's no
7071 need to walk over threads. Above we've checked whether the
7072 current thread is stepping. If some other thread not the
7073 event thread is stepping, then it must be that scheduler
7074 locking is not in effect. */
7075 if (schedlock_applies (ecs->event_thread))
7076 return 0;
7077
7078 /* Otherwise, we no longer expect a trap in the current thread.
7079 Clear the trap_expected flag before switching back -- this is
7080 what keep_going does as well, if we call it. */
7081 ecs->event_thread->control.trap_expected = 0;
7082
7083 /* Likewise, clear the signal if it should not be passed. */
7084 if (!signal_program[ecs->event_thread->suspend.stop_signal])
7085 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
7086
7087 /* Do all pending step-overs before actually proceeding with
7088 step/next/etc. */
7089 if (start_step_over ())
7090 {
7091 prepare_to_wait (ecs);
7092 return 1;
7093 }
7094
7095 /* Look for the stepping/nexting thread. */
7096 stepping_thread = NULL;
7097
7098 ALL_NON_EXITED_THREADS (tp)
7099 {
7100 /* Ignore threads of processes the caller is not
7101 resuming. */
7102 if (!sched_multi
7103 && ptid_get_pid (tp->ptid) != ptid_get_pid (ecs->ptid))
7104 continue;
7105
7106 /* When stepping over a breakpoint, we lock all threads
7107 except the one that needs to move past the breakpoint.
7108 If a non-event thread has this set, the "incomplete
7109 step-over" check above should have caught it earlier. */
7110 if (tp->control.trap_expected)
7111 {
7112 internal_error (__FILE__, __LINE__,
7113 "[%s] has inconsistent state: "
7114 "trap_expected=%d\n",
7115 target_pid_to_str (tp->ptid),
7116 tp->control.trap_expected);
7117 }
7118
7119 /* Did we find the stepping thread? */
7120 if (tp->control.step_range_end)
7121 {
7122 /* Yep. There should only one though. */
7123 gdb_assert (stepping_thread == NULL);
7124
7125 /* The event thread is handled at the top, before we
7126 enter this loop. */
7127 gdb_assert (tp != ecs->event_thread);
7128
7129 /* If some thread other than the event thread is
7130 stepping, then scheduler locking can't be in effect,
7131 otherwise we wouldn't have resumed the current event
7132 thread in the first place. */
7133 gdb_assert (!schedlock_applies (tp));
7134
7135 stepping_thread = tp;
7136 }
7137 }
7138
7139 if (stepping_thread != NULL)
7140 {
7141 if (debug_infrun)
7142 fprintf_unfiltered (gdb_stdlog,
7143 "infrun: switching back to stepped thread\n");
7144
7145 if (keep_going_stepped_thread (stepping_thread))
7146 {
7147 prepare_to_wait (ecs);
7148 return 1;
7149 }
7150 }
7151 }
7152
7153 return 0;
7154 }
7155
7156 /* Set a previously stepped thread back to stepping. Returns true on
7157 success, false if the resume is not possible (e.g., the thread
7158 vanished). */
7159
7160 static int
7161 keep_going_stepped_thread (struct thread_info *tp)
7162 {
7163 struct frame_info *frame;
7164 struct execution_control_state ecss;
7165 struct execution_control_state *ecs = &ecss;
7166
7167 /* If the stepping thread exited, then don't try to switch back and
7168 resume it, which could fail in several different ways depending
7169 on the target. Instead, just keep going.
7170
7171 We can find a stepping dead thread in the thread list in two
7172 cases:
7173
7174 - The target supports thread exit events, and when the target
7175 tries to delete the thread from the thread list, inferior_ptid
7176 pointed at the exiting thread. In such case, calling
7177 delete_thread does not really remove the thread from the list;
7178 instead, the thread is left listed, with 'exited' state.
7179
7180 - The target's debug interface does not support thread exit
7181 events, and so we have no idea whatsoever if the previously
7182 stepping thread is still alive. For that reason, we need to
7183 synchronously query the target now. */
7184
7185 if (is_exited (tp->ptid)
7186 || !target_thread_alive (tp->ptid))
7187 {
7188 if (debug_infrun)
7189 fprintf_unfiltered (gdb_stdlog,
7190 "infrun: not resuming previously "
7191 "stepped thread, it has vanished\n");
7192
7193 delete_thread (tp->ptid);
7194 return 0;
7195 }
7196
7197 if (debug_infrun)
7198 fprintf_unfiltered (gdb_stdlog,
7199 "infrun: resuming previously stepped thread\n");
7200
7201 reset_ecs (ecs, tp);
7202 switch_to_thread (tp->ptid);
7203
7204 stop_pc = regcache_read_pc (get_thread_regcache (tp->ptid));
7205 frame = get_current_frame ();
7206
7207 /* If the PC of the thread we were trying to single-step has
7208 changed, then that thread has trapped or been signaled, but the
7209 event has not been reported to GDB yet. Re-poll the target
7210 looking for this particular thread's event (i.e. temporarily
7211 enable schedlock) by:
7212
7213 - setting a break at the current PC
7214 - resuming that particular thread, only (by setting trap
7215 expected)
7216
7217 This prevents us continuously moving the single-step breakpoint
7218 forward, one instruction at a time, overstepping. */
7219
7220 if (stop_pc != tp->prev_pc)
7221 {
7222 ptid_t resume_ptid;
7223
7224 if (debug_infrun)
7225 fprintf_unfiltered (gdb_stdlog,
7226 "infrun: expected thread advanced also (%s -> %s)\n",
7227 paddress (target_gdbarch (), tp->prev_pc),
7228 paddress (target_gdbarch (), stop_pc));
7229
7230 /* Clear the info of the previous step-over, as it's no longer
7231 valid (if the thread was trying to step over a breakpoint, it
7232 has already succeeded). It's what keep_going would do too,
7233 if we called it. Do this before trying to insert the sss
7234 breakpoint, otherwise if we were previously trying to step
7235 over this exact address in another thread, the breakpoint is
7236 skipped. */
7237 clear_step_over_info ();
7238 tp->control.trap_expected = 0;
7239
7240 insert_single_step_breakpoint (get_frame_arch (frame),
7241 get_frame_address_space (frame),
7242 stop_pc);
7243
7244 tp->resumed = 1;
7245 resume_ptid = internal_resume_ptid (tp->control.stepping_command);
7246 do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
7247 }
7248 else
7249 {
7250 if (debug_infrun)
7251 fprintf_unfiltered (gdb_stdlog,
7252 "infrun: expected thread still hasn't advanced\n");
7253
7254 keep_going_pass_signal (ecs);
7255 }
7256 return 1;
7257 }
7258
7259 /* Is thread TP in the middle of (software or hardware)
7260 single-stepping? (Note the result of this function must never be
7261 passed directly as target_resume's STEP parameter.) */
7262
7263 static int
7264 currently_stepping (struct thread_info *tp)
7265 {
7266 return ((tp->control.step_range_end
7267 && tp->control.step_resume_breakpoint == NULL)
7268 || tp->control.trap_expected
7269 || tp->stepped_breakpoint
7270 || bpstat_should_step ());
7271 }
7272
7273 /* Inferior has stepped into a subroutine call with source code that
7274 we should not step over. Do step to the first line of code in
7275 it. */
7276
7277 static void
7278 handle_step_into_function (struct gdbarch *gdbarch,
7279 struct execution_control_state *ecs)
7280 {
7281 fill_in_stop_func (gdbarch, ecs);
7282
7283 compunit_symtab *cust = find_pc_compunit_symtab (stop_pc);
7284 if (cust != NULL && compunit_language (cust) != language_asm)
7285 ecs->stop_func_start
7286 = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
7287
7288 symtab_and_line stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
7289 /* Use the step_resume_break to step until the end of the prologue,
7290 even if that involves jumps (as it seems to on the vax under
7291 4.2). */
7292 /* If the prologue ends in the middle of a source line, continue to
7293 the end of that source line (if it is still within the function).
7294 Otherwise, just go to end of prologue. */
7295 if (stop_func_sal.end
7296 && stop_func_sal.pc != ecs->stop_func_start
7297 && stop_func_sal.end < ecs->stop_func_end)
7298 ecs->stop_func_start = stop_func_sal.end;
7299
7300 /* Architectures which require breakpoint adjustment might not be able
7301 to place a breakpoint at the computed address. If so, the test
7302 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7303 ecs->stop_func_start to an address at which a breakpoint may be
7304 legitimately placed.
7305
7306 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7307 made, GDB will enter an infinite loop when stepping through
7308 optimized code consisting of VLIW instructions which contain
7309 subinstructions corresponding to different source lines. On
7310 FR-V, it's not permitted to place a breakpoint on any but the
7311 first subinstruction of a VLIW instruction. When a breakpoint is
7312 set, GDB will adjust the breakpoint address to the beginning of
7313 the VLIW instruction. Thus, we need to make the corresponding
7314 adjustment here when computing the stop address. */
7315
7316 if (gdbarch_adjust_breakpoint_address_p (gdbarch))
7317 {
7318 ecs->stop_func_start
7319 = gdbarch_adjust_breakpoint_address (gdbarch,
7320 ecs->stop_func_start);
7321 }
7322
7323 if (ecs->stop_func_start == stop_pc)
7324 {
7325 /* We are already there: stop now. */
7326 end_stepping_range (ecs);
7327 return;
7328 }
7329 else
7330 {
7331 /* Put the step-breakpoint there and go until there. */
7332 symtab_and_line sr_sal;
7333 sr_sal.pc = ecs->stop_func_start;
7334 sr_sal.section = find_pc_overlay (ecs->stop_func_start);
7335 sr_sal.pspace = get_frame_program_space (get_current_frame ());
7336
7337 /* Do not specify what the fp should be when we stop since on
7338 some machines the prologue is where the new fp value is
7339 established. */
7340 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
7341
7342 /* And make sure stepping stops right away then. */
7343 ecs->event_thread->control.step_range_end
7344 = ecs->event_thread->control.step_range_start;
7345 }
7346 keep_going (ecs);
7347 }
7348
7349 /* Inferior has stepped backward into a subroutine call with source
7350 code that we should not step over. Do step to the beginning of the
7351 last line of code in it. */
7352
7353 static void
7354 handle_step_into_function_backward (struct gdbarch *gdbarch,
7355 struct execution_control_state *ecs)
7356 {
7357 struct compunit_symtab *cust;
7358 struct symtab_and_line stop_func_sal;
7359
7360 fill_in_stop_func (gdbarch, ecs);
7361
7362 cust = find_pc_compunit_symtab (stop_pc);
7363 if (cust != NULL && compunit_language (cust) != language_asm)
7364 ecs->stop_func_start
7365 = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
7366
7367 stop_func_sal = find_pc_line (stop_pc, 0);
7368
7369 /* OK, we're just going to keep stepping here. */
7370 if (stop_func_sal.pc == stop_pc)
7371 {
7372 /* We're there already. Just stop stepping now. */
7373 end_stepping_range (ecs);
7374 }
7375 else
7376 {
7377 /* Else just reset the step range and keep going.
7378 No step-resume breakpoint, they don't work for
7379 epilogues, which can have multiple entry paths. */
7380 ecs->event_thread->control.step_range_start = stop_func_sal.pc;
7381 ecs->event_thread->control.step_range_end = stop_func_sal.end;
7382 keep_going (ecs);
7383 }
7384 return;
7385 }
7386
7387 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7388 This is used to both functions and to skip over code. */
7389
7390 static void
7391 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch,
7392 struct symtab_and_line sr_sal,
7393 struct frame_id sr_id,
7394 enum bptype sr_type)
7395 {
7396 /* There should never be more than one step-resume or longjmp-resume
7397 breakpoint per thread, so we should never be setting a new
7398 step_resume_breakpoint when one is already active. */
7399 gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
7400 gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
7401
7402 if (debug_infrun)
7403 fprintf_unfiltered (gdb_stdlog,
7404 "infrun: inserting step-resume breakpoint at %s\n",
7405 paddress (gdbarch, sr_sal.pc));
7406
7407 inferior_thread ()->control.step_resume_breakpoint
7408 = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type).release ();
7409 }
7410
7411 void
7412 insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
7413 struct symtab_and_line sr_sal,
7414 struct frame_id sr_id)
7415 {
7416 insert_step_resume_breakpoint_at_sal_1 (gdbarch,
7417 sr_sal, sr_id,
7418 bp_step_resume);
7419 }
7420
7421 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7422 This is used to skip a potential signal handler.
7423
7424 This is called with the interrupted function's frame. The signal
7425 handler, when it returns, will resume the interrupted function at
7426 RETURN_FRAME.pc. */
7427
7428 static void
7429 insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
7430 {
7431 gdb_assert (return_frame != NULL);
7432
7433 struct gdbarch *gdbarch = get_frame_arch (return_frame);
7434
7435 symtab_and_line sr_sal;
7436 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
7437 sr_sal.section = find_pc_overlay (sr_sal.pc);
7438 sr_sal.pspace = get_frame_program_space (return_frame);
7439
7440 insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
7441 get_stack_frame_id (return_frame),
7442 bp_hp_step_resume);
7443 }
7444
7445 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7446 is used to skip a function after stepping into it (for "next" or if
7447 the called function has no debugging information).
7448
7449 The current function has almost always been reached by single
7450 stepping a call or return instruction. NEXT_FRAME belongs to the
7451 current function, and the breakpoint will be set at the caller's
7452 resume address.
7453
7454 This is a separate function rather than reusing
7455 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7456 get_prev_frame, which may stop prematurely (see the implementation
7457 of frame_unwind_caller_id for an example). */
7458
7459 static void
7460 insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
7461 {
7462 /* We shouldn't have gotten here if we don't know where the call site
7463 is. */
7464 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
7465
7466 struct gdbarch *gdbarch = frame_unwind_caller_arch (next_frame);
7467
7468 symtab_and_line sr_sal;
7469 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
7470 frame_unwind_caller_pc (next_frame));
7471 sr_sal.section = find_pc_overlay (sr_sal.pc);
7472 sr_sal.pspace = frame_unwind_program_space (next_frame);
7473
7474 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
7475 frame_unwind_caller_id (next_frame));
7476 }
7477
7478 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7479 new breakpoint at the target of a jmp_buf. The handling of
7480 longjmp-resume uses the same mechanisms used for handling
7481 "step-resume" breakpoints. */
7482
7483 static void
7484 insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
7485 {
7486 /* There should never be more than one longjmp-resume breakpoint per
7487 thread, so we should never be setting a new
7488 longjmp_resume_breakpoint when one is already active. */
7489 gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
7490
7491 if (debug_infrun)
7492 fprintf_unfiltered (gdb_stdlog,
7493 "infrun: inserting longjmp-resume breakpoint at %s\n",
7494 paddress (gdbarch, pc));
7495
7496 inferior_thread ()->control.exception_resume_breakpoint =
7497 set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume).release ();
7498 }
7499
7500 /* Insert an exception resume breakpoint. TP is the thread throwing
7501 the exception. The block B is the block of the unwinder debug hook
7502 function. FRAME is the frame corresponding to the call to this
7503 function. SYM is the symbol of the function argument holding the
7504 target PC of the exception. */
7505
7506 static void
7507 insert_exception_resume_breakpoint (struct thread_info *tp,
7508 const struct block *b,
7509 struct frame_info *frame,
7510 struct symbol *sym)
7511 {
7512 TRY
7513 {
7514 struct block_symbol vsym;
7515 struct value *value;
7516 CORE_ADDR handler;
7517 struct breakpoint *bp;
7518
7519 vsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
7520 b, VAR_DOMAIN);
7521 value = read_var_value (vsym.symbol, vsym.block, frame);
7522 /* If the value was optimized out, revert to the old behavior. */
7523 if (! value_optimized_out (value))
7524 {
7525 handler = value_as_address (value);
7526
7527 if (debug_infrun)
7528 fprintf_unfiltered (gdb_stdlog,
7529 "infrun: exception resume at %lx\n",
7530 (unsigned long) handler);
7531
7532 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7533 handler,
7534 bp_exception_resume).release ();
7535
7536 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7537 frame = NULL;
7538
7539 bp->thread = tp->global_num;
7540 inferior_thread ()->control.exception_resume_breakpoint = bp;
7541 }
7542 }
7543 CATCH (e, RETURN_MASK_ERROR)
7544 {
7545 /* We want to ignore errors here. */
7546 }
7547 END_CATCH
7548 }
7549
7550 /* A helper for check_exception_resume that sets an
7551 exception-breakpoint based on a SystemTap probe. */
7552
7553 static void
7554 insert_exception_resume_from_probe (struct thread_info *tp,
7555 const struct bound_probe *probe,
7556 struct frame_info *frame)
7557 {
7558 struct value *arg_value;
7559 CORE_ADDR handler;
7560 struct breakpoint *bp;
7561
7562 arg_value = probe_safe_evaluate_at_pc (frame, 1);
7563 if (!arg_value)
7564 return;
7565
7566 handler = value_as_address (arg_value);
7567
7568 if (debug_infrun)
7569 fprintf_unfiltered (gdb_stdlog,
7570 "infrun: exception resume at %s\n",
7571 paddress (get_objfile_arch (probe->objfile),
7572 handler));
7573
7574 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame),
7575 handler, bp_exception_resume).release ();
7576 bp->thread = tp->global_num;
7577 inferior_thread ()->control.exception_resume_breakpoint = bp;
7578 }
7579
7580 /* This is called when an exception has been intercepted. Check to
7581 see whether the exception's destination is of interest, and if so,
7582 set an exception resume breakpoint there. */
7583
7584 static void
7585 check_exception_resume (struct execution_control_state *ecs,
7586 struct frame_info *frame)
7587 {
7588 struct bound_probe probe;
7589 struct symbol *func;
7590
7591 /* First see if this exception unwinding breakpoint was set via a
7592 SystemTap probe point. If so, the probe has two arguments: the
7593 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7594 set a breakpoint there. */
7595 probe = find_probe_by_pc (get_frame_pc (frame));
7596 if (probe.prob)
7597 {
7598 insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
7599 return;
7600 }
7601
7602 func = get_frame_function (frame);
7603 if (!func)
7604 return;
7605
7606 TRY
7607 {
7608 const struct block *b;
7609 struct block_iterator iter;
7610 struct symbol *sym;
7611 int argno = 0;
7612
7613 /* The exception breakpoint is a thread-specific breakpoint on
7614 the unwinder's debug hook, declared as:
7615
7616 void _Unwind_DebugHook (void *cfa, void *handler);
7617
7618 The CFA argument indicates the frame to which control is
7619 about to be transferred. HANDLER is the destination PC.
7620
7621 We ignore the CFA and set a temporary breakpoint at HANDLER.
7622 This is not extremely efficient but it avoids issues in gdb
7623 with computing the DWARF CFA, and it also works even in weird
7624 cases such as throwing an exception from inside a signal
7625 handler. */
7626
7627 b = SYMBOL_BLOCK_VALUE (func);
7628 ALL_BLOCK_SYMBOLS (b, iter, sym)
7629 {
7630 if (!SYMBOL_IS_ARGUMENT (sym))
7631 continue;
7632
7633 if (argno == 0)
7634 ++argno;
7635 else
7636 {
7637 insert_exception_resume_breakpoint (ecs->event_thread,
7638 b, frame, sym);
7639 break;
7640 }
7641 }
7642 }
7643 CATCH (e, RETURN_MASK_ERROR)
7644 {
7645 }
7646 END_CATCH
7647 }
7648
7649 static void
7650 stop_waiting (struct execution_control_state *ecs)
7651 {
7652 if (debug_infrun)
7653 fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
7654
7655 /* Let callers know we don't want to wait for the inferior anymore. */
7656 ecs->wait_some_more = 0;
7657
7658 /* If all-stop, but the target is always in non-stop mode, stop all
7659 threads now that we're presenting the stop to the user. */
7660 if (!non_stop && target_is_non_stop_p ())
7661 stop_all_threads ();
7662 }
7663
7664 /* Like keep_going, but passes the signal to the inferior, even if the
7665 signal is set to nopass. */
7666
7667 static void
7668 keep_going_pass_signal (struct execution_control_state *ecs)
7669 {
7670 gdb_assert (ptid_equal (ecs->event_thread->ptid, inferior_ptid));
7671 gdb_assert (!ecs->event_thread->resumed);
7672
7673 /* Save the pc before execution, to compare with pc after stop. */
7674 ecs->event_thread->prev_pc
7675 = regcache_read_pc (get_thread_regcache (ecs->ptid));
7676
7677 if (ecs->event_thread->control.trap_expected)
7678 {
7679 struct thread_info *tp = ecs->event_thread;
7680
7681 if (debug_infrun)
7682 fprintf_unfiltered (gdb_stdlog,
7683 "infrun: %s has trap_expected set, "
7684 "resuming to collect trap\n",
7685 target_pid_to_str (tp->ptid));
7686
7687 /* We haven't yet gotten our trap, and either: intercepted a
7688 non-signal event (e.g., a fork); or took a signal which we
7689 are supposed to pass through to the inferior. Simply
7690 continue. */
7691 resume (ecs->event_thread->suspend.stop_signal);
7692 }
7693 else if (step_over_info_valid_p ())
7694 {
7695 /* Another thread is stepping over a breakpoint in-line. If
7696 this thread needs a step-over too, queue the request. In
7697 either case, this resume must be deferred for later. */
7698 struct thread_info *tp = ecs->event_thread;
7699
7700 if (ecs->hit_singlestep_breakpoint
7701 || thread_still_needs_step_over (tp))
7702 {
7703 if (debug_infrun)
7704 fprintf_unfiltered (gdb_stdlog,
7705 "infrun: step-over already in progress: "
7706 "step-over for %s deferred\n",
7707 target_pid_to_str (tp->ptid));
7708 thread_step_over_chain_enqueue (tp);
7709 }
7710 else
7711 {
7712 if (debug_infrun)
7713 fprintf_unfiltered (gdb_stdlog,
7714 "infrun: step-over in progress: "
7715 "resume of %s deferred\n",
7716 target_pid_to_str (tp->ptid));
7717 }
7718 }
7719 else
7720 {
7721 struct regcache *regcache = get_current_regcache ();
7722 int remove_bp;
7723 int remove_wps;
7724 step_over_what step_what;
7725
7726 /* Either the trap was not expected, but we are continuing
7727 anyway (if we got a signal, the user asked it be passed to
7728 the child)
7729 -- or --
7730 We got our expected trap, but decided we should resume from
7731 it.
7732
7733 We're going to run this baby now!
7734
7735 Note that insert_breakpoints won't try to re-insert
7736 already inserted breakpoints. Therefore, we don't
7737 care if breakpoints were already inserted, or not. */
7738
7739 /* If we need to step over a breakpoint, and we're not using
7740 displaced stepping to do so, insert all breakpoints
7741 (watchpoints, etc.) but the one we're stepping over, step one
7742 instruction, and then re-insert the breakpoint when that step
7743 is finished. */
7744
7745 step_what = thread_still_needs_step_over (ecs->event_thread);
7746
7747 remove_bp = (ecs->hit_singlestep_breakpoint
7748 || (step_what & STEP_OVER_BREAKPOINT));
7749 remove_wps = (step_what & STEP_OVER_WATCHPOINT);
7750
7751 /* We can't use displaced stepping if we need to step past a
7752 watchpoint. The instruction copied to the scratch pad would
7753 still trigger the watchpoint. */
7754 if (remove_bp
7755 && (remove_wps || !use_displaced_stepping (ecs->event_thread)))
7756 {
7757 set_step_over_info (regcache->aspace (),
7758 regcache_read_pc (regcache), remove_wps,
7759 ecs->event_thread->global_num);
7760 }
7761 else if (remove_wps)
7762 set_step_over_info (NULL, 0, remove_wps, -1);
7763
7764 /* If we now need to do an in-line step-over, we need to stop
7765 all other threads. Note this must be done before
7766 insert_breakpoints below, because that removes the breakpoint
7767 we're about to step over, otherwise other threads could miss
7768 it. */
7769 if (step_over_info_valid_p () && target_is_non_stop_p ())
7770 stop_all_threads ();
7771
7772 /* Stop stepping if inserting breakpoints fails. */
7773 TRY
7774 {
7775 insert_breakpoints ();
7776 }
7777 CATCH (e, RETURN_MASK_ERROR)
7778 {
7779 exception_print (gdb_stderr, e);
7780 stop_waiting (ecs);
7781 clear_step_over_info ();
7782 return;
7783 }
7784 END_CATCH
7785
7786 ecs->event_thread->control.trap_expected = (remove_bp || remove_wps);
7787
7788 resume (ecs->event_thread->suspend.stop_signal);
7789 }
7790
7791 prepare_to_wait (ecs);
7792 }
7793
7794 /* Called when we should continue running the inferior, because the
7795 current event doesn't cause a user visible stop. This does the
7796 resuming part; waiting for the next event is done elsewhere. */
7797
7798 static void
7799 keep_going (struct execution_control_state *ecs)
7800 {
7801 if (ecs->event_thread->control.trap_expected
7802 && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
7803 ecs->event_thread->control.trap_expected = 0;
7804
7805 if (!signal_program[ecs->event_thread->suspend.stop_signal])
7806 ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
7807 keep_going_pass_signal (ecs);
7808 }
7809
7810 /* This function normally comes after a resume, before
7811 handle_inferior_event exits. It takes care of any last bits of
7812 housekeeping, and sets the all-important wait_some_more flag. */
7813
7814 static void
7815 prepare_to_wait (struct execution_control_state *ecs)
7816 {
7817 if (debug_infrun)
7818 fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
7819
7820 ecs->wait_some_more = 1;
7821
7822 if (!target_is_async_p ())
7823 mark_infrun_async_event_handler ();
7824 }
7825
7826 /* We are done with the step range of a step/next/si/ni command.
7827 Called once for each n of a "step n" operation. */
7828
7829 static void
7830 end_stepping_range (struct execution_control_state *ecs)
7831 {
7832 ecs->event_thread->control.stop_step = 1;
7833 stop_waiting (ecs);
7834 }
7835
7836 /* Several print_*_reason functions to print why the inferior has stopped.
7837 We always print something when the inferior exits, or receives a signal.
7838 The rest of the cases are dealt with later on in normal_stop and
7839 print_it_typical. Ideally there should be a call to one of these
7840 print_*_reason functions functions from handle_inferior_event each time
7841 stop_waiting is called.
7842
7843 Note that we don't call these directly, instead we delegate that to
7844 the interpreters, through observers. Interpreters then call these
7845 with whatever uiout is right. */
7846
7847 void
7848 print_end_stepping_range_reason (struct ui_out *uiout)
7849 {
7850 /* For CLI-like interpreters, print nothing. */
7851
7852 if (uiout->is_mi_like_p ())
7853 {
7854 uiout->field_string ("reason",
7855 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE));
7856 }
7857 }
7858
7859 void
7860 print_signal_exited_reason (struct ui_out *uiout, enum gdb_signal siggnal)
7861 {
7862 annotate_signalled ();
7863 if (uiout->is_mi_like_p ())
7864 uiout->field_string
7865 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
7866 uiout->text ("\nProgram terminated with signal ");
7867 annotate_signal_name ();
7868 uiout->field_string ("signal-name",
7869 gdb_signal_to_name (siggnal));
7870 annotate_signal_name_end ();
7871 uiout->text (", ");
7872 annotate_signal_string ();
7873 uiout->field_string ("signal-meaning",
7874 gdb_signal_to_string (siggnal));
7875 annotate_signal_string_end ();
7876 uiout->text (".\n");
7877 uiout->text ("The program no longer exists.\n");
7878 }
7879
7880 void
7881 print_exited_reason (struct ui_out *uiout, int exitstatus)
7882 {
7883 struct inferior *inf = current_inferior ();
7884 const char *pidstr = target_pid_to_str (pid_to_ptid (inf->pid));
7885
7886 annotate_exited (exitstatus);
7887 if (exitstatus)
7888 {
7889 if (uiout->is_mi_like_p ())
7890 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXITED));
7891 uiout->text ("[Inferior ");
7892 uiout->text (plongest (inf->num));
7893 uiout->text (" (");
7894 uiout->text (pidstr);
7895 uiout->text (") exited with code ");
7896 uiout->field_fmt ("exit-code", "0%o", (unsigned int) exitstatus);
7897 uiout->text ("]\n");
7898 }
7899 else
7900 {
7901 if (uiout->is_mi_like_p ())
7902 uiout->field_string
7903 ("reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
7904 uiout->text ("[Inferior ");
7905 uiout->text (plongest (inf->num));
7906 uiout->text (" (");
7907 uiout->text (pidstr);
7908 uiout->text (") exited normally]\n");
7909 }
7910 }
7911
7912 /* Some targets/architectures can do extra processing/display of
7913 segmentation faults. E.g., Intel MPX boundary faults.
7914 Call the architecture dependent function to handle the fault. */
7915
7916 static void
7917 handle_segmentation_fault (struct ui_out *uiout)
7918 {
7919 struct regcache *regcache = get_current_regcache ();
7920 struct gdbarch *gdbarch = regcache->arch ();
7921
7922 if (gdbarch_handle_segmentation_fault_p (gdbarch))
7923 gdbarch_handle_segmentation_fault (gdbarch, uiout);
7924 }
7925
7926 void
7927 print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
7928 {
7929 struct thread_info *thr = inferior_thread ();
7930
7931 annotate_signal ();
7932
7933 if (uiout->is_mi_like_p ())
7934 ;
7935 else if (show_thread_that_caused_stop ())
7936 {
7937 const char *name;
7938
7939 uiout->text ("\nThread ");
7940 uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
7941
7942 name = thr->name != NULL ? thr->name : target_thread_name (thr);
7943 if (name != NULL)
7944 {
7945 uiout->text (" \"");
7946 uiout->field_fmt ("name", "%s", name);
7947 uiout->text ("\"");
7948 }
7949 }
7950 else
7951 uiout->text ("\nProgram");
7952
7953 if (siggnal == GDB_SIGNAL_0 && !uiout->is_mi_like_p ())
7954 uiout->text (" stopped");
7955 else
7956 {
7957 uiout->text (" received signal ");
7958 annotate_signal_name ();
7959 if (uiout->is_mi_like_p ())
7960 uiout->field_string
7961 ("reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
7962 uiout->field_string ("signal-name", gdb_signal_to_name (siggnal));
7963 annotate_signal_name_end ();
7964 uiout->text (", ");
7965 annotate_signal_string ();
7966 uiout->field_string ("signal-meaning", gdb_signal_to_string (siggnal));
7967
7968 if (siggnal == GDB_SIGNAL_SEGV)
7969 handle_segmentation_fault (uiout);
7970
7971 annotate_signal_string_end ();
7972 }
7973 uiout->text (".\n");
7974 }
7975
7976 void
7977 print_no_history_reason (struct ui_out *uiout)
7978 {
7979 uiout->text ("\nNo more reverse-execution history.\n");
7980 }
7981
7982 /* Print current location without a level number, if we have changed
7983 functions or hit a breakpoint. Print source line if we have one.
7984 bpstat_print contains the logic deciding in detail what to print,
7985 based on the event(s) that just occurred. */
7986
7987 static void
7988 print_stop_location (struct target_waitstatus *ws)
7989 {
7990 int bpstat_ret;
7991 enum print_what source_flag;
7992 int do_frame_printing = 1;
7993 struct thread_info *tp = inferior_thread ();
7994
7995 bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
7996 switch (bpstat_ret)
7997 {
7998 case PRINT_UNKNOWN:
7999 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
8000 should) carry around the function and does (or should) use
8001 that when doing a frame comparison. */
8002 if (tp->control.stop_step
8003 && frame_id_eq (tp->control.step_frame_id,
8004 get_frame_id (get_current_frame ()))
8005 && tp->control.step_start_function == find_pc_function (stop_pc))
8006 {
8007 /* Finished step, just print source line. */
8008 source_flag = SRC_LINE;
8009 }
8010 else
8011 {
8012 /* Print location and source line. */
8013 source_flag = SRC_AND_LOC;
8014 }
8015 break;
8016 case PRINT_SRC_AND_LOC:
8017 /* Print location and source line. */
8018 source_flag = SRC_AND_LOC;
8019 break;
8020 case PRINT_SRC_ONLY:
8021 source_flag = SRC_LINE;
8022 break;
8023 case PRINT_NOTHING:
8024 /* Something bogus. */
8025 source_flag = SRC_LINE;
8026 do_frame_printing = 0;
8027 break;
8028 default:
8029 internal_error (__FILE__, __LINE__, _("Unknown value."));
8030 }
8031
8032 /* The behavior of this routine with respect to the source
8033 flag is:
8034 SRC_LINE: Print only source line
8035 LOCATION: Print only location
8036 SRC_AND_LOC: Print location and source line. */
8037 if (do_frame_printing)
8038 print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
8039 }
8040
8041 /* See infrun.h. */
8042
8043 void
8044 print_stop_event (struct ui_out *uiout)
8045 {
8046 struct target_waitstatus last;
8047 ptid_t last_ptid;
8048 struct thread_info *tp;
8049
8050 get_last_target_status (&last_ptid, &last);
8051
8052 {
8053 scoped_restore save_uiout = make_scoped_restore (&current_uiout, uiout);
8054
8055 print_stop_location (&last);
8056
8057 /* Display the auto-display expressions. */
8058 do_displays ();
8059 }
8060
8061 tp = inferior_thread ();
8062 if (tp->thread_fsm != NULL
8063 && thread_fsm_finished_p (tp->thread_fsm))
8064 {
8065 struct return_value_info *rv;
8066
8067 rv = thread_fsm_return_value (tp->thread_fsm);
8068 if (rv != NULL)
8069 print_return_value (uiout, rv);
8070 }
8071 }
8072
8073 /* See infrun.h. */
8074
8075 void
8076 maybe_remove_breakpoints (void)
8077 {
8078 if (!breakpoints_should_be_inserted_now () && target_has_execution)
8079 {
8080 if (remove_breakpoints ())
8081 {
8082 target_terminal::ours_for_output ();
8083 printf_filtered (_("Cannot remove breakpoints because "
8084 "program is no longer writable.\nFurther "
8085 "execution is probably impossible.\n"));
8086 }
8087 }
8088 }
8089
8090 /* The execution context that just caused a normal stop. */
8091
8092 struct stop_context
8093 {
8094 /* The stop ID. */
8095 ULONGEST stop_id;
8096
8097 /* The event PTID. */
8098
8099 ptid_t ptid;
8100
8101 /* If stopp for a thread event, this is the thread that caused the
8102 stop. */
8103 struct thread_info *thread;
8104
8105 /* The inferior that caused the stop. */
8106 int inf_num;
8107 };
8108
8109 /* Returns a new stop context. If stopped for a thread event, this
8110 takes a strong reference to the thread. */
8111
8112 static struct stop_context *
8113 save_stop_context (void)
8114 {
8115 struct stop_context *sc = XNEW (struct stop_context);
8116
8117 sc->stop_id = get_stop_id ();
8118 sc->ptid = inferior_ptid;
8119 sc->inf_num = current_inferior ()->num;
8120
8121 if (!ptid_equal (inferior_ptid, null_ptid))
8122 {
8123 /* Take a strong reference so that the thread can't be deleted
8124 yet. */
8125 sc->thread = inferior_thread ();
8126 sc->thread->incref ();
8127 }
8128 else
8129 sc->thread = NULL;
8130
8131 return sc;
8132 }
8133
8134 /* Release a stop context previously created with save_stop_context.
8135 Releases the strong reference to the thread as well. */
8136
8137 static void
8138 release_stop_context_cleanup (void *arg)
8139 {
8140 struct stop_context *sc = (struct stop_context *) arg;
8141
8142 if (sc->thread != NULL)
8143 sc->thread->decref ();
8144 xfree (sc);
8145 }
8146
8147 /* Return true if the current context no longer matches the saved stop
8148 context. */
8149
8150 static int
8151 stop_context_changed (struct stop_context *prev)
8152 {
8153 if (!ptid_equal (prev->ptid, inferior_ptid))
8154 return 1;
8155 if (prev->inf_num != current_inferior ()->num)
8156 return 1;
8157 if (prev->thread != NULL && prev->thread->state != THREAD_STOPPED)
8158 return 1;
8159 if (get_stop_id () != prev->stop_id)
8160 return 1;
8161 return 0;
8162 }
8163
8164 /* See infrun.h. */
8165
8166 int
8167 normal_stop (void)
8168 {
8169 struct target_waitstatus last;
8170 ptid_t last_ptid;
8171 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
8172 ptid_t pid_ptid;
8173
8174 get_last_target_status (&last_ptid, &last);
8175
8176 new_stop_id ();
8177
8178 /* If an exception is thrown from this point on, make sure to
8179 propagate GDB's knowledge of the executing state to the
8180 frontend/user running state. A QUIT is an easy exception to see
8181 here, so do this before any filtered output. */
8182 if (!non_stop)
8183 make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
8184 else if (last.kind == TARGET_WAITKIND_SIGNALLED
8185 || last.kind == TARGET_WAITKIND_EXITED)
8186 {
8187 /* On some targets, we may still have live threads in the
8188 inferior when we get a process exit event. E.g., for
8189 "checkpoint", when the current checkpoint/fork exits,
8190 linux-fork.c automatically switches to another fork from
8191 within target_mourn_inferior. */
8192 if (!ptid_equal (inferior_ptid, null_ptid))
8193 {
8194 pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
8195 make_cleanup (finish_thread_state_cleanup, &pid_ptid);
8196 }
8197 }
8198 else if (last.kind != TARGET_WAITKIND_NO_RESUMED)
8199 make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
8200
8201 /* As we're presenting a stop, and potentially removing breakpoints,
8202 update the thread list so we can tell whether there are threads
8203 running on the target. With target remote, for example, we can
8204 only learn about new threads when we explicitly update the thread
8205 list. Do this before notifying the interpreters about signal
8206 stops, end of stepping ranges, etc., so that the "new thread"
8207 output is emitted before e.g., "Program received signal FOO",
8208 instead of after. */
8209 update_thread_list ();
8210
8211 if (last.kind == TARGET_WAITKIND_STOPPED && stopped_by_random_signal)
8212 observer_notify_signal_received (inferior_thread ()->suspend.stop_signal);
8213
8214 /* As with the notification of thread events, we want to delay
8215 notifying the user that we've switched thread context until
8216 the inferior actually stops.
8217
8218 There's no point in saying anything if the inferior has exited.
8219 Note that SIGNALLED here means "exited with a signal", not
8220 "received a signal".
8221
8222 Also skip saying anything in non-stop mode. In that mode, as we
8223 don't want GDB to switch threads behind the user's back, to avoid
8224 races where the user is typing a command to apply to thread x,
8225 but GDB switches to thread y before the user finishes entering
8226 the command, fetch_inferior_event installs a cleanup to restore
8227 the current thread back to the thread the user had selected right
8228 after this event is handled, so we're not really switching, only
8229 informing of a stop. */
8230 if (!non_stop
8231 && !ptid_equal (previous_inferior_ptid, inferior_ptid)
8232 && target_has_execution
8233 && last.kind != TARGET_WAITKIND_SIGNALLED
8234 && last.kind != TARGET_WAITKIND_EXITED
8235 && last.kind != TARGET_WAITKIND_NO_RESUMED)
8236 {
8237 SWITCH_THRU_ALL_UIS ()
8238 {
8239 target_terminal::ours_for_output ();
8240 printf_filtered (_("[Switching to %s]\n"),
8241 target_pid_to_str (inferior_ptid));
8242 annotate_thread_changed ();
8243 }
8244 previous_inferior_ptid = inferior_ptid;
8245 }
8246
8247 if (last.kind == TARGET_WAITKIND_NO_RESUMED)
8248 {
8249 SWITCH_THRU_ALL_UIS ()
8250 if (current_ui->prompt_state == PROMPT_BLOCKED)
8251 {
8252 target_terminal::ours_for_output ();
8253 printf_filtered (_("No unwaited-for children left.\n"));
8254 }
8255 }
8256
8257 /* Note: this depends on the update_thread_list call above. */
8258 maybe_remove_breakpoints ();
8259
8260 /* If an auto-display called a function and that got a signal,
8261 delete that auto-display to avoid an infinite recursion. */
8262
8263 if (stopped_by_random_signal)
8264 disable_current_display ();
8265
8266 SWITCH_THRU_ALL_UIS ()
8267 {
8268 async_enable_stdin ();
8269 }
8270
8271 /* Let the user/frontend see the threads as stopped. */
8272 do_cleanups (old_chain);
8273
8274 /* Select innermost stack frame - i.e., current frame is frame 0,
8275 and current location is based on that. Handle the case where the
8276 dummy call is returning after being stopped. E.g. the dummy call
8277 previously hit a breakpoint. (If the dummy call returns
8278 normally, we won't reach here.) Do this before the stop hook is
8279 run, so that it doesn't get to see the temporary dummy frame,
8280 which is not where we'll present the stop. */
8281 if (has_stack_frames ())
8282 {
8283 if (stop_stack_dummy == STOP_STACK_DUMMY)
8284 {
8285 /* Pop the empty frame that contains the stack dummy. This
8286 also restores inferior state prior to the call (struct
8287 infcall_suspend_state). */
8288 struct frame_info *frame = get_current_frame ();
8289
8290 gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
8291 frame_pop (frame);
8292 /* frame_pop calls reinit_frame_cache as the last thing it
8293 does which means there's now no selected frame. */
8294 }
8295
8296 select_frame (get_current_frame ());
8297
8298 /* Set the current source location. */
8299 set_current_sal_from_frame (get_current_frame ());
8300 }
8301
8302 /* Look up the hook_stop and run it (CLI internally handles problem
8303 of stop_command's pre-hook not existing). */
8304 if (stop_command != NULL)
8305 {
8306 struct stop_context *saved_context = save_stop_context ();
8307 struct cleanup *old_chain
8308 = make_cleanup (release_stop_context_cleanup, saved_context);
8309
8310 TRY
8311 {
8312 execute_cmd_pre_hook (stop_command);
8313 }
8314 CATCH (ex, RETURN_MASK_ALL)
8315 {
8316 exception_fprintf (gdb_stderr, ex,
8317 "Error while running hook_stop:\n");
8318 }
8319 END_CATCH
8320
8321 /* If the stop hook resumes the target, then there's no point in
8322 trying to notify about the previous stop; its context is
8323 gone. Likewise if the command switches thread or inferior --
8324 the observers would print a stop for the wrong
8325 thread/inferior. */
8326 if (stop_context_changed (saved_context))
8327 {
8328 do_cleanups (old_chain);
8329 return 1;
8330 }
8331 do_cleanups (old_chain);
8332 }
8333
8334 /* Notify observers about the stop. This is where the interpreters
8335 print the stop event. */
8336 if (!ptid_equal (inferior_ptid, null_ptid))
8337 observer_notify_normal_stop (inferior_thread ()->control.stop_bpstat,
8338 stop_print_frame);
8339 else
8340 observer_notify_normal_stop (NULL, stop_print_frame);
8341
8342 annotate_stopped ();
8343
8344 if (target_has_execution)
8345 {
8346 if (last.kind != TARGET_WAITKIND_SIGNALLED
8347 && last.kind != TARGET_WAITKIND_EXITED)
8348 /* Delete the breakpoint we stopped at, if it wants to be deleted.
8349 Delete any breakpoint that is to be deleted at the next stop. */
8350 breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
8351 }
8352
8353 /* Try to get rid of automatically added inferiors that are no
8354 longer needed. Keeping those around slows down things linearly.
8355 Note that this never removes the current inferior. */
8356 prune_inferiors ();
8357
8358 return 0;
8359 }
8360
8361 int
8362 signal_stop_state (int signo)
8363 {
8364 return signal_stop[signo];
8365 }
8366
8367 int
8368 signal_print_state (int signo)
8369 {
8370 return signal_print[signo];
8371 }
8372
8373 int
8374 signal_pass_state (int signo)
8375 {
8376 return signal_program[signo];
8377 }
8378
8379 static void
8380 signal_cache_update (int signo)
8381 {
8382 if (signo == -1)
8383 {
8384 for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
8385 signal_cache_update (signo);
8386
8387 return;
8388 }
8389
8390 signal_pass[signo] = (signal_stop[signo] == 0
8391 && signal_print[signo] == 0
8392 && signal_program[signo] == 1
8393 && signal_catch[signo] == 0);
8394 }
8395
8396 int
8397 signal_stop_update (int signo, int state)
8398 {
8399 int ret = signal_stop[signo];
8400
8401 signal_stop[signo] = state;
8402 signal_cache_update (signo);
8403 return ret;
8404 }
8405
8406 int
8407 signal_print_update (int signo, int state)
8408 {
8409 int ret = signal_print[signo];
8410
8411 signal_print[signo] = state;
8412 signal_cache_update (signo);
8413 return ret;
8414 }
8415
8416 int
8417 signal_pass_update (int signo, int state)
8418 {
8419 int ret = signal_program[signo];
8420
8421 signal_program[signo] = state;
8422 signal_cache_update (signo);
8423 return ret;
8424 }
8425
8426 /* Update the global 'signal_catch' from INFO and notify the
8427 target. */
8428
8429 void
8430 signal_catch_update (const unsigned int *info)
8431 {
8432 int i;
8433
8434 for (i = 0; i < GDB_SIGNAL_LAST; ++i)
8435 signal_catch[i] = info[i] > 0;
8436 signal_cache_update (-1);
8437 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8438 }
8439
8440 static void
8441 sig_print_header (void)
8442 {
8443 printf_filtered (_("Signal Stop\tPrint\tPass "
8444 "to program\tDescription\n"));
8445 }
8446
8447 static void
8448 sig_print_info (enum gdb_signal oursig)
8449 {
8450 const char *name = gdb_signal_to_name (oursig);
8451 int name_padding = 13 - strlen (name);
8452
8453 if (name_padding <= 0)
8454 name_padding = 0;
8455
8456 printf_filtered ("%s", name);
8457 printf_filtered ("%*.*s ", name_padding, name_padding, " ");
8458 printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
8459 printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
8460 printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
8461 printf_filtered ("%s\n", gdb_signal_to_string (oursig));
8462 }
8463
8464 /* Specify how various signals in the inferior should be handled. */
8465
8466 static void
8467 handle_command (const char *args, int from_tty)
8468 {
8469 int digits, wordlen;
8470 int sigfirst, signum, siglast;
8471 enum gdb_signal oursig;
8472 int allsigs;
8473 int nsigs;
8474 unsigned char *sigs;
8475
8476 if (args == NULL)
8477 {
8478 error_no_arg (_("signal to handle"));
8479 }
8480
8481 /* Allocate and zero an array of flags for which signals to handle. */
8482
8483 nsigs = (int) GDB_SIGNAL_LAST;
8484 sigs = (unsigned char *) alloca (nsigs);
8485 memset (sigs, 0, nsigs);
8486
8487 /* Break the command line up into args. */
8488
8489 gdb_argv built_argv (args);
8490
8491 /* Walk through the args, looking for signal oursigs, signal names, and
8492 actions. Signal numbers and signal names may be interspersed with
8493 actions, with the actions being performed for all signals cumulatively
8494 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8495
8496 for (char *arg : built_argv)
8497 {
8498 wordlen = strlen (arg);
8499 for (digits = 0; isdigit (arg[digits]); digits++)
8500 {;
8501 }
8502 allsigs = 0;
8503 sigfirst = siglast = -1;
8504
8505 if (wordlen >= 1 && !strncmp (arg, "all", wordlen))
8506 {
8507 /* Apply action to all signals except those used by the
8508 debugger. Silently skip those. */
8509 allsigs = 1;
8510 sigfirst = 0;
8511 siglast = nsigs - 1;
8512 }
8513 else if (wordlen >= 1 && !strncmp (arg, "stop", wordlen))
8514 {
8515 SET_SIGS (nsigs, sigs, signal_stop);
8516 SET_SIGS (nsigs, sigs, signal_print);
8517 }
8518 else if (wordlen >= 1 && !strncmp (arg, "ignore", wordlen))
8519 {
8520 UNSET_SIGS (nsigs, sigs, signal_program);
8521 }
8522 else if (wordlen >= 2 && !strncmp (arg, "print", wordlen))
8523 {
8524 SET_SIGS (nsigs, sigs, signal_print);
8525 }
8526 else if (wordlen >= 2 && !strncmp (arg, "pass", wordlen))
8527 {
8528 SET_SIGS (nsigs, sigs, signal_program);
8529 }
8530 else if (wordlen >= 3 && !strncmp (arg, "nostop", wordlen))
8531 {
8532 UNSET_SIGS (nsigs, sigs, signal_stop);
8533 }
8534 else if (wordlen >= 3 && !strncmp (arg, "noignore", wordlen))
8535 {
8536 SET_SIGS (nsigs, sigs, signal_program);
8537 }
8538 else if (wordlen >= 4 && !strncmp (arg, "noprint", wordlen))
8539 {
8540 UNSET_SIGS (nsigs, sigs, signal_print);
8541 UNSET_SIGS (nsigs, sigs, signal_stop);
8542 }
8543 else if (wordlen >= 4 && !strncmp (arg, "nopass", wordlen))
8544 {
8545 UNSET_SIGS (nsigs, sigs, signal_program);
8546 }
8547 else if (digits > 0)
8548 {
8549 /* It is numeric. The numeric signal refers to our own
8550 internal signal numbering from target.h, not to host/target
8551 signal number. This is a feature; users really should be
8552 using symbolic names anyway, and the common ones like
8553 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8554
8555 sigfirst = siglast = (int)
8556 gdb_signal_from_command (atoi (arg));
8557 if (arg[digits] == '-')
8558 {
8559 siglast = (int)
8560 gdb_signal_from_command (atoi (arg + digits + 1));
8561 }
8562 if (sigfirst > siglast)
8563 {
8564 /* Bet he didn't figure we'd think of this case... */
8565 signum = sigfirst;
8566 sigfirst = siglast;
8567 siglast = signum;
8568 }
8569 }
8570 else
8571 {
8572 oursig = gdb_signal_from_name (arg);
8573 if (oursig != GDB_SIGNAL_UNKNOWN)
8574 {
8575 sigfirst = siglast = (int) oursig;
8576 }
8577 else
8578 {
8579 /* Not a number and not a recognized flag word => complain. */
8580 error (_("Unrecognized or ambiguous flag word: \"%s\"."), arg);
8581 }
8582 }
8583
8584 /* If any signal numbers or symbol names were found, set flags for
8585 which signals to apply actions to. */
8586
8587 for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
8588 {
8589 switch ((enum gdb_signal) signum)
8590 {
8591 case GDB_SIGNAL_TRAP:
8592 case GDB_SIGNAL_INT:
8593 if (!allsigs && !sigs[signum])
8594 {
8595 if (query (_("%s is used by the debugger.\n\
8596 Are you sure you want to change it? "),
8597 gdb_signal_to_name ((enum gdb_signal) signum)))
8598 {
8599 sigs[signum] = 1;
8600 }
8601 else
8602 {
8603 printf_unfiltered (_("Not confirmed, unchanged.\n"));
8604 gdb_flush (gdb_stdout);
8605 }
8606 }
8607 break;
8608 case GDB_SIGNAL_0:
8609 case GDB_SIGNAL_DEFAULT:
8610 case GDB_SIGNAL_UNKNOWN:
8611 /* Make sure that "all" doesn't print these. */
8612 break;
8613 default:
8614 sigs[signum] = 1;
8615 break;
8616 }
8617 }
8618 }
8619
8620 for (signum = 0; signum < nsigs; signum++)
8621 if (sigs[signum])
8622 {
8623 signal_cache_update (-1);
8624 target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
8625 target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
8626
8627 if (from_tty)
8628 {
8629 /* Show the results. */
8630 sig_print_header ();
8631 for (; signum < nsigs; signum++)
8632 if (sigs[signum])
8633 sig_print_info ((enum gdb_signal) signum);
8634 }
8635
8636 break;
8637 }
8638 }
8639
8640 /* Complete the "handle" command. */
8641
8642 static void
8643 handle_completer (struct cmd_list_element *ignore,
8644 completion_tracker &tracker,
8645 const char *text, const char *word)
8646 {
8647 static const char * const keywords[] =
8648 {
8649 "all",
8650 "stop",
8651 "ignore",
8652 "print",
8653 "pass",
8654 "nostop",
8655 "noignore",
8656 "noprint",
8657 "nopass",
8658 NULL,
8659 };
8660
8661 signal_completer (ignore, tracker, text, word);
8662 complete_on_enum (tracker, keywords, word, word);
8663 }
8664
8665 enum gdb_signal
8666 gdb_signal_from_command (int num)
8667 {
8668 if (num >= 1 && num <= 15)
8669 return (enum gdb_signal) num;
8670 error (_("Only signals 1-15 are valid as numeric signals.\n\
8671 Use \"info signals\" for a list of symbolic signals."));
8672 }
8673
8674 /* Print current contents of the tables set by the handle command.
8675 It is possible we should just be printing signals actually used
8676 by the current target (but for things to work right when switching
8677 targets, all signals should be in the signal tables). */
8678
8679 static void
8680 info_signals_command (const char *signum_exp, int from_tty)
8681 {
8682 enum gdb_signal oursig;
8683
8684 sig_print_header ();
8685
8686 if (signum_exp)
8687 {
8688 /* First see if this is a symbol name. */
8689 oursig = gdb_signal_from_name (signum_exp);
8690 if (oursig == GDB_SIGNAL_UNKNOWN)
8691 {
8692 /* No, try numeric. */
8693 oursig =
8694 gdb_signal_from_command (parse_and_eval_long (signum_exp));
8695 }
8696 sig_print_info (oursig);
8697 return;
8698 }
8699
8700 printf_filtered ("\n");
8701 /* These ugly casts brought to you by the native VAX compiler. */
8702 for (oursig = GDB_SIGNAL_FIRST;
8703 (int) oursig < (int) GDB_SIGNAL_LAST;
8704 oursig = (enum gdb_signal) ((int) oursig + 1))
8705 {
8706 QUIT;
8707
8708 if (oursig != GDB_SIGNAL_UNKNOWN
8709 && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
8710 sig_print_info (oursig);
8711 }
8712
8713 printf_filtered (_("\nUse the \"handle\" command "
8714 "to change these tables.\n"));
8715 }
8716
8717 /* The $_siginfo convenience variable is a bit special. We don't know
8718 for sure the type of the value until we actually have a chance to
8719 fetch the data. The type can change depending on gdbarch, so it is
8720 also dependent on which thread you have selected.
8721
8722 1. making $_siginfo be an internalvar that creates a new value on
8723 access.
8724
8725 2. making the value of $_siginfo be an lval_computed value. */
8726
8727 /* This function implements the lval_computed support for reading a
8728 $_siginfo value. */
8729
8730 static void
8731 siginfo_value_read (struct value *v)
8732 {
8733 LONGEST transferred;
8734
8735 /* If we can access registers, so can we access $_siginfo. Likewise
8736 vice versa. */
8737 validate_registers_access ();
8738
8739 transferred =
8740 target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO,
8741 NULL,
8742 value_contents_all_raw (v),
8743 value_offset (v),
8744 TYPE_LENGTH (value_type (v)));
8745
8746 if (transferred != TYPE_LENGTH (value_type (v)))
8747 error (_("Unable to read siginfo"));
8748 }
8749
8750 /* This function implements the lval_computed support for writing a
8751 $_siginfo value. */
8752
8753 static void
8754 siginfo_value_write (struct value *v, struct value *fromval)
8755 {
8756 LONGEST transferred;
8757
8758 /* If we can access registers, so can we access $_siginfo. Likewise
8759 vice versa. */
8760 validate_registers_access ();
8761
8762 transferred = target_write (&current_target,
8763 TARGET_OBJECT_SIGNAL_INFO,
8764 NULL,
8765 value_contents_all_raw (fromval),
8766 value_offset (v),
8767 TYPE_LENGTH (value_type (fromval)));
8768
8769 if (transferred != TYPE_LENGTH (value_type (fromval)))
8770 error (_("Unable to write siginfo"));
8771 }
8772
8773 static const struct lval_funcs siginfo_value_funcs =
8774 {
8775 siginfo_value_read,
8776 siginfo_value_write
8777 };
8778
8779 /* Return a new value with the correct type for the siginfo object of
8780 the current thread using architecture GDBARCH. Return a void value
8781 if there's no object available. */
8782
8783 static struct value *
8784 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
8785 void *ignore)
8786 {
8787 if (target_has_stack
8788 && !ptid_equal (inferior_ptid, null_ptid)
8789 && gdbarch_get_siginfo_type_p (gdbarch))
8790 {
8791 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8792
8793 return allocate_computed_value (type, &siginfo_value_funcs, NULL);
8794 }
8795
8796 return allocate_value (builtin_type (gdbarch)->builtin_void);
8797 }
8798
8799
8800 /* infcall_suspend_state contains state about the program itself like its
8801 registers and any signal it received when it last stopped.
8802 This state must be restored regardless of how the inferior function call
8803 ends (either successfully, or after it hits a breakpoint or signal)
8804 if the program is to properly continue where it left off. */
8805
8806 struct infcall_suspend_state
8807 {
8808 struct thread_suspend_state thread_suspend;
8809
8810 /* Other fields: */
8811 CORE_ADDR stop_pc;
8812 struct regcache *registers;
8813
8814 /* Format of SIGINFO_DATA or NULL if it is not present. */
8815 struct gdbarch *siginfo_gdbarch;
8816
8817 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
8818 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
8819 content would be invalid. */
8820 gdb_byte *siginfo_data;
8821 };
8822
8823 struct infcall_suspend_state *
8824 save_infcall_suspend_state (void)
8825 {
8826 struct infcall_suspend_state *inf_state;
8827 struct thread_info *tp = inferior_thread ();
8828 struct regcache *regcache = get_current_regcache ();
8829 struct gdbarch *gdbarch = regcache->arch ();
8830 gdb_byte *siginfo_data = NULL;
8831
8832 if (gdbarch_get_siginfo_type_p (gdbarch))
8833 {
8834 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8835 size_t len = TYPE_LENGTH (type);
8836 struct cleanup *back_to;
8837
8838 siginfo_data = (gdb_byte *) xmalloc (len);
8839 back_to = make_cleanup (xfree, siginfo_data);
8840
8841 if (target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
8842 siginfo_data, 0, len) == len)
8843 discard_cleanups (back_to);
8844 else
8845 {
8846 /* Errors ignored. */
8847 do_cleanups (back_to);
8848 siginfo_data = NULL;
8849 }
8850 }
8851
8852 inf_state = XCNEW (struct infcall_suspend_state);
8853
8854 if (siginfo_data)
8855 {
8856 inf_state->siginfo_gdbarch = gdbarch;
8857 inf_state->siginfo_data = siginfo_data;
8858 }
8859
8860 inf_state->thread_suspend = tp->suspend;
8861
8862 /* run_inferior_call will not use the signal due to its `proceed' call with
8863 GDB_SIGNAL_0 anyway. */
8864 tp->suspend.stop_signal = GDB_SIGNAL_0;
8865
8866 inf_state->stop_pc = stop_pc;
8867
8868 inf_state->registers = regcache_dup (regcache);
8869
8870 return inf_state;
8871 }
8872
8873 /* Restore inferior session state to INF_STATE. */
8874
8875 void
8876 restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
8877 {
8878 struct thread_info *tp = inferior_thread ();
8879 struct regcache *regcache = get_current_regcache ();
8880 struct gdbarch *gdbarch = regcache->arch ();
8881
8882 tp->suspend = inf_state->thread_suspend;
8883
8884 stop_pc = inf_state->stop_pc;
8885
8886 if (inf_state->siginfo_gdbarch == gdbarch)
8887 {
8888 struct type *type = gdbarch_get_siginfo_type (gdbarch);
8889
8890 /* Errors ignored. */
8891 target_write (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
8892 inf_state->siginfo_data, 0, TYPE_LENGTH (type));
8893 }
8894
8895 /* The inferior can be gone if the user types "print exit(0)"
8896 (and perhaps other times). */
8897 if (target_has_execution)
8898 /* NB: The register write goes through to the target. */
8899 regcache_cpy (regcache, inf_state->registers);
8900
8901 discard_infcall_suspend_state (inf_state);
8902 }
8903
8904 static void
8905 do_restore_infcall_suspend_state_cleanup (void *state)
8906 {
8907 restore_infcall_suspend_state ((struct infcall_suspend_state *) state);
8908 }
8909
8910 struct cleanup *
8911 make_cleanup_restore_infcall_suspend_state
8912 (struct infcall_suspend_state *inf_state)
8913 {
8914 return make_cleanup (do_restore_infcall_suspend_state_cleanup, inf_state);
8915 }
8916
8917 void
8918 discard_infcall_suspend_state (struct infcall_suspend_state *inf_state)
8919 {
8920 delete inf_state->registers;
8921 xfree (inf_state->siginfo_data);
8922 xfree (inf_state);
8923 }
8924
8925 struct regcache *
8926 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state)
8927 {
8928 return inf_state->registers;
8929 }
8930
8931 /* infcall_control_state contains state regarding gdb's control of the
8932 inferior itself like stepping control. It also contains session state like
8933 the user's currently selected frame. */
8934
8935 struct infcall_control_state
8936 {
8937 struct thread_control_state thread_control;
8938 struct inferior_control_state inferior_control;
8939
8940 /* Other fields: */
8941 enum stop_stack_kind stop_stack_dummy;
8942 int stopped_by_random_signal;
8943
8944 /* ID if the selected frame when the inferior function call was made. */
8945 struct frame_id selected_frame_id;
8946 };
8947
8948 /* Save all of the information associated with the inferior<==>gdb
8949 connection. */
8950
8951 struct infcall_control_state *
8952 save_infcall_control_state (void)
8953 {
8954 struct infcall_control_state *inf_status =
8955 XNEW (struct infcall_control_state);
8956 struct thread_info *tp = inferior_thread ();
8957 struct inferior *inf = current_inferior ();
8958
8959 inf_status->thread_control = tp->control;
8960 inf_status->inferior_control = inf->control;
8961
8962 tp->control.step_resume_breakpoint = NULL;
8963 tp->control.exception_resume_breakpoint = NULL;
8964
8965 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
8966 chain. If caller's caller is walking the chain, they'll be happier if we
8967 hand them back the original chain when restore_infcall_control_state is
8968 called. */
8969 tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat);
8970
8971 /* Other fields: */
8972 inf_status->stop_stack_dummy = stop_stack_dummy;
8973 inf_status->stopped_by_random_signal = stopped_by_random_signal;
8974
8975 inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
8976
8977 return inf_status;
8978 }
8979
8980 static void
8981 restore_selected_frame (const frame_id &fid)
8982 {
8983 frame_info *frame = frame_find_by_id (fid);
8984
8985 /* If inf_status->selected_frame_id is NULL, there was no previously
8986 selected frame. */
8987 if (frame == NULL)
8988 {
8989 warning (_("Unable to restore previously selected frame."));
8990 return;
8991 }
8992
8993 select_frame (frame);
8994 }
8995
8996 /* Restore inferior session state to INF_STATUS. */
8997
8998 void
8999 restore_infcall_control_state (struct infcall_control_state *inf_status)
9000 {
9001 struct thread_info *tp = inferior_thread ();
9002 struct inferior *inf = current_inferior ();
9003
9004 if (tp->control.step_resume_breakpoint)
9005 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
9006
9007 if (tp->control.exception_resume_breakpoint)
9008 tp->control.exception_resume_breakpoint->disposition
9009 = disp_del_at_next_stop;
9010
9011 /* Handle the bpstat_copy of the chain. */
9012 bpstat_clear (&tp->control.stop_bpstat);
9013
9014 tp->control = inf_status->thread_control;
9015 inf->control = inf_status->inferior_control;
9016
9017 /* Other fields: */
9018 stop_stack_dummy = inf_status->stop_stack_dummy;
9019 stopped_by_random_signal = inf_status->stopped_by_random_signal;
9020
9021 if (target_has_stack)
9022 {
9023 /* The point of the try/catch is that if the stack is clobbered,
9024 walking the stack might encounter a garbage pointer and
9025 error() trying to dereference it. */
9026 TRY
9027 {
9028 restore_selected_frame (inf_status->selected_frame_id);
9029 }
9030 CATCH (ex, RETURN_MASK_ERROR)
9031 {
9032 exception_fprintf (gdb_stderr, ex,
9033 "Unable to restore previously selected frame:\n");
9034 /* Error in restoring the selected frame. Select the
9035 innermost frame. */
9036 select_frame (get_current_frame ());
9037 }
9038 END_CATCH
9039 }
9040
9041 xfree (inf_status);
9042 }
9043
9044 static void
9045 do_restore_infcall_control_state_cleanup (void *sts)
9046 {
9047 restore_infcall_control_state ((struct infcall_control_state *) sts);
9048 }
9049
9050 struct cleanup *
9051 make_cleanup_restore_infcall_control_state
9052 (struct infcall_control_state *inf_status)
9053 {
9054 return make_cleanup (do_restore_infcall_control_state_cleanup, inf_status);
9055 }
9056
9057 void
9058 discard_infcall_control_state (struct infcall_control_state *inf_status)
9059 {
9060 if (inf_status->thread_control.step_resume_breakpoint)
9061 inf_status->thread_control.step_resume_breakpoint->disposition
9062 = disp_del_at_next_stop;
9063
9064 if (inf_status->thread_control.exception_resume_breakpoint)
9065 inf_status->thread_control.exception_resume_breakpoint->disposition
9066 = disp_del_at_next_stop;
9067
9068 /* See save_infcall_control_state for info on stop_bpstat. */
9069 bpstat_clear (&inf_status->thread_control.stop_bpstat);
9070
9071 xfree (inf_status);
9072 }
9073
9074 /* See infrun.h. */
9075
9076 void
9077 clear_exit_convenience_vars (void)
9078 {
9079 clear_internalvar (lookup_internalvar ("_exitsignal"));
9080 clear_internalvar (lookup_internalvar ("_exitcode"));
9081 }
9082
9083
9084 /* User interface for reverse debugging:
9085 Set exec-direction / show exec-direction commands
9086 (returns error unless target implements to_set_exec_direction method). */
9087
9088 enum exec_direction_kind execution_direction = EXEC_FORWARD;
9089 static const char exec_forward[] = "forward";
9090 static const char exec_reverse[] = "reverse";
9091 static const char *exec_direction = exec_forward;
9092 static const char *const exec_direction_names[] = {
9093 exec_forward,
9094 exec_reverse,
9095 NULL
9096 };
9097
9098 static void
9099 set_exec_direction_func (const char *args, int from_tty,
9100 struct cmd_list_element *cmd)
9101 {
9102 if (target_can_execute_reverse)
9103 {
9104 if (!strcmp (exec_direction, exec_forward))
9105 execution_direction = EXEC_FORWARD;
9106 else if (!strcmp (exec_direction, exec_reverse))
9107 execution_direction = EXEC_REVERSE;
9108 }
9109 else
9110 {
9111 exec_direction = exec_forward;
9112 error (_("Target does not support this operation."));
9113 }
9114 }
9115
9116 static void
9117 show_exec_direction_func (struct ui_file *out, int from_tty,
9118 struct cmd_list_element *cmd, const char *value)
9119 {
9120 switch (execution_direction) {
9121 case EXEC_FORWARD:
9122 fprintf_filtered (out, _("Forward.\n"));
9123 break;
9124 case EXEC_REVERSE:
9125 fprintf_filtered (out, _("Reverse.\n"));
9126 break;
9127 default:
9128 internal_error (__FILE__, __LINE__,
9129 _("bogus execution_direction value: %d"),
9130 (int) execution_direction);
9131 }
9132 }
9133
9134 static void
9135 show_schedule_multiple (struct ui_file *file, int from_tty,
9136 struct cmd_list_element *c, const char *value)
9137 {
9138 fprintf_filtered (file, _("Resuming the execution of threads "
9139 "of all processes is %s.\n"), value);
9140 }
9141
9142 /* Implementation of `siginfo' variable. */
9143
9144 static const struct internalvar_funcs siginfo_funcs =
9145 {
9146 siginfo_make_value,
9147 NULL,
9148 NULL
9149 };
9150
9151 /* Callback for infrun's target events source. This is marked when a
9152 thread has a pending status to process. */
9153
9154 static void
9155 infrun_async_inferior_event_handler (gdb_client_data data)
9156 {
9157 inferior_event_handler (INF_REG_EVENT, NULL);
9158 }
9159
9160 void
9161 _initialize_infrun (void)
9162 {
9163 int i;
9164 int numsigs;
9165 struct cmd_list_element *c;
9166
9167 /* Register extra event sources in the event loop. */
9168 infrun_async_inferior_event_token
9169 = create_async_event_handler (infrun_async_inferior_event_handler, NULL);
9170
9171 add_info ("signals", info_signals_command, _("\
9172 What debugger does when program gets various signals.\n\
9173 Specify a signal as argument to print info on that signal only."));
9174 add_info_alias ("handle", "signals", 0);
9175
9176 c = add_com ("handle", class_run, handle_command, _("\
9177 Specify how to handle signals.\n\
9178 Usage: handle SIGNAL [ACTIONS]\n\
9179 Args are signals and actions to apply to those signals.\n\
9180 If no actions are specified, the current settings for the specified signals\n\
9181 will be displayed instead.\n\
9182 \n\
9183 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
9184 from 1-15 are allowed for compatibility with old versions of GDB.\n\
9185 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
9186 The special arg \"all\" is recognized to mean all signals except those\n\
9187 used by the debugger, typically SIGTRAP and SIGINT.\n\
9188 \n\
9189 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
9190 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
9191 Stop means reenter debugger if this signal happens (implies print).\n\
9192 Print means print a message if this signal happens.\n\
9193 Pass means let program see this signal; otherwise program doesn't know.\n\
9194 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
9195 Pass and Stop may be combined.\n\
9196 \n\
9197 Multiple signals may be specified. Signal numbers and signal names\n\
9198 may be interspersed with actions, with the actions being performed for\n\
9199 all signals cumulatively specified."));
9200 set_cmd_completer (c, handle_completer);
9201
9202 if (!dbx_commands)
9203 stop_command = add_cmd ("stop", class_obscure,
9204 not_just_help_class_command, _("\
9205 There is no `stop' command, but you can set a hook on `stop'.\n\
9206 This allows you to set a list of commands to be run each time execution\n\
9207 of the program stops."), &cmdlist);
9208
9209 add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
9210 Set inferior debugging."), _("\
9211 Show inferior debugging."), _("\
9212 When non-zero, inferior specific debugging is enabled."),
9213 NULL,
9214 show_debug_infrun,
9215 &setdebuglist, &showdebuglist);
9216
9217 add_setshow_boolean_cmd ("displaced", class_maintenance,
9218 &debug_displaced, _("\
9219 Set displaced stepping debugging."), _("\
9220 Show displaced stepping debugging."), _("\
9221 When non-zero, displaced stepping specific debugging is enabled."),
9222 NULL,
9223 show_debug_displaced,
9224 &setdebuglist, &showdebuglist);
9225
9226 add_setshow_boolean_cmd ("non-stop", no_class,
9227 &non_stop_1, _("\
9228 Set whether gdb controls the inferior in non-stop mode."), _("\
9229 Show whether gdb controls the inferior in non-stop mode."), _("\
9230 When debugging a multi-threaded program and this setting is\n\
9231 off (the default, also called all-stop mode), when one thread stops\n\
9232 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
9233 all other threads in the program while you interact with the thread of\n\
9234 interest. When you continue or step a thread, you can allow the other\n\
9235 threads to run, or have them remain stopped, but while you inspect any\n\
9236 thread's state, all threads stop.\n\
9237 \n\
9238 In non-stop mode, when one thread stops, other threads can continue\n\
9239 to run freely. You'll be able to step each thread independently,\n\
9240 leave it stopped or free to run as needed."),
9241 set_non_stop,
9242 show_non_stop,
9243 &setlist,
9244 &showlist);
9245
9246 numsigs = (int) GDB_SIGNAL_LAST;
9247 signal_stop = XNEWVEC (unsigned char, numsigs);
9248 signal_print = XNEWVEC (unsigned char, numsigs);
9249 signal_program = XNEWVEC (unsigned char, numsigs);
9250 signal_catch = XNEWVEC (unsigned char, numsigs);
9251 signal_pass = XNEWVEC (unsigned char, numsigs);
9252 for (i = 0; i < numsigs; i++)
9253 {
9254 signal_stop[i] = 1;
9255 signal_print[i] = 1;
9256 signal_program[i] = 1;
9257 signal_catch[i] = 0;
9258 }
9259
9260 /* Signals caused by debugger's own actions should not be given to
9261 the program afterwards.
9262
9263 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9264 explicitly specifies that it should be delivered to the target
9265 program. Typically, that would occur when a user is debugging a
9266 target monitor on a simulator: the target monitor sets a
9267 breakpoint; the simulator encounters this breakpoint and halts
9268 the simulation handing control to GDB; GDB, noting that the stop
9269 address doesn't map to any known breakpoint, returns control back
9270 to the simulator; the simulator then delivers the hardware
9271 equivalent of a GDB_SIGNAL_TRAP to the program being
9272 debugged. */
9273 signal_program[GDB_SIGNAL_TRAP] = 0;
9274 signal_program[GDB_SIGNAL_INT] = 0;
9275
9276 /* Signals that are not errors should not normally enter the debugger. */
9277 signal_stop[GDB_SIGNAL_ALRM] = 0;
9278 signal_print[GDB_SIGNAL_ALRM] = 0;
9279 signal_stop[GDB_SIGNAL_VTALRM] = 0;
9280 signal_print[GDB_SIGNAL_VTALRM] = 0;
9281 signal_stop[GDB_SIGNAL_PROF] = 0;
9282 signal_print[GDB_SIGNAL_PROF] = 0;
9283 signal_stop[GDB_SIGNAL_CHLD] = 0;
9284 signal_print[GDB_SIGNAL_CHLD] = 0;
9285 signal_stop[GDB_SIGNAL_IO] = 0;
9286 signal_print[GDB_SIGNAL_IO] = 0;
9287 signal_stop[GDB_SIGNAL_POLL] = 0;
9288 signal_print[GDB_SIGNAL_POLL] = 0;
9289 signal_stop[GDB_SIGNAL_URG] = 0;
9290 signal_print[GDB_SIGNAL_URG] = 0;
9291 signal_stop[GDB_SIGNAL_WINCH] = 0;
9292 signal_print[GDB_SIGNAL_WINCH] = 0;
9293 signal_stop[GDB_SIGNAL_PRIO] = 0;
9294 signal_print[GDB_SIGNAL_PRIO] = 0;
9295
9296 /* These signals are used internally by user-level thread
9297 implementations. (See signal(5) on Solaris.) Like the above
9298 signals, a healthy program receives and handles them as part of
9299 its normal operation. */
9300 signal_stop[GDB_SIGNAL_LWP] = 0;
9301 signal_print[GDB_SIGNAL_LWP] = 0;
9302 signal_stop[GDB_SIGNAL_WAITING] = 0;
9303 signal_print[GDB_SIGNAL_WAITING] = 0;
9304 signal_stop[GDB_SIGNAL_CANCEL] = 0;
9305 signal_print[GDB_SIGNAL_CANCEL] = 0;
9306 signal_stop[GDB_SIGNAL_LIBRT] = 0;
9307 signal_print[GDB_SIGNAL_LIBRT] = 0;
9308
9309 /* Update cached state. */
9310 signal_cache_update (-1);
9311
9312 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
9313 &stop_on_solib_events, _("\
9314 Set stopping for shared library events."), _("\
9315 Show stopping for shared library events."), _("\
9316 If nonzero, gdb will give control to the user when the dynamic linker\n\
9317 notifies gdb of shared library events. The most common event of interest\n\
9318 to the user would be loading/unloading of a new library."),
9319 set_stop_on_solib_events,
9320 show_stop_on_solib_events,
9321 &setlist, &showlist);
9322
9323 add_setshow_enum_cmd ("follow-fork-mode", class_run,
9324 follow_fork_mode_kind_names,
9325 &follow_fork_mode_string, _("\
9326 Set debugger response to a program call of fork or vfork."), _("\
9327 Show debugger response to a program call of fork or vfork."), _("\
9328 A fork or vfork creates a new process. follow-fork-mode can be:\n\
9329 parent - the original process is debugged after a fork\n\
9330 child - the new process is debugged after a fork\n\
9331 The unfollowed process will continue to run.\n\
9332 By default, the debugger will follow the parent process."),
9333 NULL,
9334 show_follow_fork_mode_string,
9335 &setlist, &showlist);
9336
9337 add_setshow_enum_cmd ("follow-exec-mode", class_run,
9338 follow_exec_mode_names,
9339 &follow_exec_mode_string, _("\
9340 Set debugger response to a program call of exec."), _("\
9341 Show debugger response to a program call of exec."), _("\
9342 An exec call replaces the program image of a process.\n\
9343 \n\
9344 follow-exec-mode can be:\n\
9345 \n\
9346 new - the debugger creates a new inferior and rebinds the process\n\
9347 to this new inferior. The program the process was running before\n\
9348 the exec call can be restarted afterwards by restarting the original\n\
9349 inferior.\n\
9350 \n\
9351 same - the debugger keeps the process bound to the same inferior.\n\
9352 The new executable image replaces the previous executable loaded in\n\
9353 the inferior. Restarting the inferior after the exec call restarts\n\
9354 the executable the process was running after the exec call.\n\
9355 \n\
9356 By default, the debugger will use the same inferior."),
9357 NULL,
9358 show_follow_exec_mode_string,
9359 &setlist, &showlist);
9360
9361 add_setshow_enum_cmd ("scheduler-locking", class_run,
9362 scheduler_enums, &scheduler_mode, _("\
9363 Set mode for locking scheduler during execution."), _("\
9364 Show mode for locking scheduler during execution."), _("\
9365 off == no locking (threads may preempt at any time)\n\
9366 on == full locking (no thread except the current thread may run)\n\
9367 This applies to both normal execution and replay mode.\n\
9368 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
9369 In this mode, other threads may run during other commands.\n\
9370 This applies to both normal execution and replay mode.\n\
9371 replay == scheduler locked in replay mode and unlocked during normal execution."),
9372 set_schedlock_func, /* traps on target vector */
9373 show_scheduler_mode,
9374 &setlist, &showlist);
9375
9376 add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
9377 Set mode for resuming threads of all processes."), _("\
9378 Show mode for resuming threads of all processes."), _("\
9379 When on, execution commands (such as 'continue' or 'next') resume all\n\
9380 threads of all processes. When off (which is the default), execution\n\
9381 commands only resume the threads of the current process. The set of\n\
9382 threads that are resumed is further refined by the scheduler-locking\n\
9383 mode (see help set scheduler-locking)."),
9384 NULL,
9385 show_schedule_multiple,
9386 &setlist, &showlist);
9387
9388 add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
9389 Set mode of the step operation."), _("\
9390 Show mode of the step operation."), _("\
9391 When set, doing a step over a function without debug line information\n\
9392 will stop at the first instruction of that function. Otherwise, the\n\
9393 function is skipped and the step command stops at a different source line."),
9394 NULL,
9395 show_step_stop_if_no_debug,
9396 &setlist, &showlist);
9397
9398 add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
9399 &can_use_displaced_stepping, _("\
9400 Set debugger's willingness to use displaced stepping."), _("\
9401 Show debugger's willingness to use displaced stepping."), _("\
9402 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
9403 supported by the target architecture. If off, gdb will not use displaced\n\
9404 stepping to step over breakpoints, even if such is supported by the target\n\
9405 architecture. If auto (which is the default), gdb will use displaced stepping\n\
9406 if the target architecture supports it and non-stop mode is active, but will not\n\
9407 use it in all-stop mode (see help set non-stop)."),
9408 NULL,
9409 show_can_use_displaced_stepping,
9410 &setlist, &showlist);
9411
9412 add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
9413 &exec_direction, _("Set direction of execution.\n\
9414 Options are 'forward' or 'reverse'."),
9415 _("Show direction of execution (forward/reverse)."),
9416 _("Tells gdb whether to execute forward or backward."),
9417 set_exec_direction_func, show_exec_direction_func,
9418 &setlist, &showlist);
9419
9420 /* Set/show detach-on-fork: user-settable mode. */
9421
9422 add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
9423 Set whether gdb will detach the child of a fork."), _("\
9424 Show whether gdb will detach the child of a fork."), _("\
9425 Tells gdb whether to detach the child of a fork."),
9426 NULL, NULL, &setlist, &showlist);
9427
9428 /* Set/show disable address space randomization mode. */
9429
9430 add_setshow_boolean_cmd ("disable-randomization", class_support,
9431 &disable_randomization, _("\
9432 Set disabling of debuggee's virtual address space randomization."), _("\
9433 Show disabling of debuggee's virtual address space randomization."), _("\
9434 When this mode is on (which is the default), randomization of the virtual\n\
9435 address space is disabled. Standalone programs run with the randomization\n\
9436 enabled by default on some platforms."),
9437 &set_disable_randomization,
9438 &show_disable_randomization,
9439 &setlist, &showlist);
9440
9441 /* ptid initializations */
9442 inferior_ptid = null_ptid;
9443 target_last_wait_ptid = minus_one_ptid;
9444
9445 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed);
9446 observer_attach_thread_stop_requested (infrun_thread_stop_requested);
9447 observer_attach_thread_exit (infrun_thread_thread_exit);
9448 observer_attach_inferior_exit (infrun_inferior_exit);
9449
9450 /* Explicitly create without lookup, since that tries to create a
9451 value with a void typed value, and when we get here, gdbarch
9452 isn't initialized yet. At this point, we're quite sure there
9453 isn't another convenience variable of the same name. */
9454 create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
9455
9456 add_setshow_boolean_cmd ("observer", no_class,
9457 &observer_mode_1, _("\
9458 Set whether gdb controls the inferior in observer mode."), _("\
9459 Show whether gdb controls the inferior in observer mode."), _("\
9460 In observer mode, GDB can get data from the inferior, but not\n\
9461 affect its execution. Registers and memory may not be changed,\n\
9462 breakpoints may not be set, and the program cannot be interrupted\n\
9463 or signalled."),
9464 set_observer_mode,
9465 show_observer_mode,
9466 &setlist,
9467 &showlist);
9468 }
error_no_arg
void error_no_arg(const char *why)
Definition: cli-cmds.c:185
get_last_target_status
void get_last_target_status(ptid_t *ptidp, struct target_waitstatus *status)
Definition: infrun.c:4037
thread_control_state::step_stack_frame_id
struct frame_id step_stack_frame_id
Definition: gdbthread.h:98
target_supports_disable_randomization
int target_supports_disable_randomization(void)
Definition: target.c:2629
random_pending_event_thread
static struct thread_info * random_pending_event_thread(ptid_t waiton_ptid)
Definition: infrun.c:3453
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
frame_id_p
int frame_id_p(struct frame_id l)
Definition: frame.c:646
breakpoint_in_range_p
int breakpoint_in_range_p(const address_space *aspace, CORE_ADDR addr, ULONGEST len)
Definition: breakpoint.c:4022
set_exec_direction_func
static void set_exec_direction_func(const char *args, int from_tty, struct cmd_list_element *cmd)
Definition: infrun.c:9099
gdbarch
Definition: gdbarch.c:127
frame_find_by_id
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:803
top.h
annotate_signalled
void annotate_signalled(void)
Definition: annotate.c:122
target_can_async_p
#define target_can_async_p()
Definition: target.h:1778
TARGET_OBJECT_SIGNAL_INFO
Definition: target.h:179
language_asm
Definition: defs.h:214
gdbarch_software_single_step_p
int gdbarch_software_single_step_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3241
thread_control_state::stepping_command
int stepping_command
Definition: gdbthread.h:144
string
const char * string
Definition: signals.c:50
bpstat_what
Definition: breakpoint.h:1003
lookup_symbol_search_name
struct block_symbol lookup_symbol_search_name(const char *search_name, const struct block *block, domain_enum domain)
Definition: symtab.c:1905
handle_step_into_function
static void handle_step_into_function(struct gdbarch *gdbarch, struct execution_control_state *ecs)
Definition: infrun.c:7278
mi-common.h
MEMORY_ERROR
Definition: common-exceptions.h:78
probe
Definition: probe.h:112
thread_info::resumed
int resumed
Definition: gdbthread.h:280
siginfo_make_value
static struct value * siginfo_make_value(struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
Definition: infrun.c:8784
TARGET_WAITKIND_SYSCALL_RETURN
Definition: waitstatus.h:72
target_thread_alive
int target_thread_alive(ptid_t ptid)
Definition: target.c:3304
infcall_suspend_state::siginfo_gdbarch
struct gdbarch * siginfo_gdbarch
Definition: infrun.c:8815
target_record_stop_replaying
void target_record_stop_replaying(void)
Definition: target.c:3666
TARGET_STOPPED_BY_WATCHPOINT
Definition: waitstatus.h:140
in_solib_dynsym_resolve_code
int in_solib_dynsym_resolve_code(CORE_ADDR pc)
Definition: solib.c:1239
stop_context
Definition: infrun.c:8092
no_shared_libraries
void no_shared_libraries(const char *ignored, int from_tty)
Definition: solib.c:1261
breakpoint_inserted_here_p
int breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4092
value_mark
struct value * value_mark(void)
Definition: value.c:1589
target_waitstatus::related_pid
ptid_t related_pid
Definition: waitstatus.h:116
PRINT_SRC_AND_LOC
Definition: breakpoint.h:505
breakpoint::loc
bp_location * loc
Definition: breakpoint.h:702
ALL_UIS
#define ALL_UIS(UI)
Definition: top.h:210
show_stop_on_solib_events
static void show_stop_on_solib_events(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:369
completer.h
get_stop_id
ULONGEST get_stop_id(void)
Definition: infrun.c:2777
user_visible_resume_ptid
ptid_t user_visible_resume_ptid(int step)
Definition: infrun.c:2252
add_thread
struct thread_info * add_thread(ptid_t ptid)
Definition: thread.c:333
target_can_execute_reverse
#define target_can_execute_reverse
Definition: target.h:2013
THREAD_STOPPED
Definition: gdbthread.h:41
DEF_ENUM_FLAGS_TYPE
DEF_ENUM_FLAGS_TYPE(enum step_over_what_flag, step_over_what)
maybe_new_address_space
struct address_space * maybe_new_address_space(void)
Definition: progspace.c:73
handle_solib_event
void handle_solib_event(void)
Definition: solib.c:1286
pc_in_thread_step_range
int pc_in_thread_step_range(CORE_ADDR pc, struct thread_info *thread)
Definition: thread.c:1141
new_stop_id
static void new_stop_id(void)
Definition: infrun.c:2785
find_thread_ptid
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:514
handle_inferior_event
static void handle_inferior_event(struct execution_control_state *ecs)
Definition: infrun.c:5410
breakpoint_here_p
enum breakpoint_here breakpoint_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:3989
insert_single_step_breakpoints
int insert_single_step_breakpoints(struct gdbarch *gdbarch)
Definition: breakpoint.c:14623
infcall_control_state::thread_control
struct thread_control_state thread_control
Definition: infrun.c:8937
observer_attach_thread_exit
struct observer * observer_attach_thread_exit(observer_thread_exit_ftype *f)
catch_syscall_enabled
int catch_syscall_enabled(void)
Definition: break-catch-syscall.c:506
save_waitstatus
static void save_waitstatus(struct thread_info *tp, struct target_waitstatus *ws)
Definition: infrun.c:4387
schedlock_off
static const char schedlock_off[]
Definition: infrun.c:2194
thread_control_state::stop_bpstat
bpstat stop_bpstat
Definition: gdbthread.h:139
step_over_what_flag
step_over_what_flag
Definition: infrun.c:1264
dbx_commands
int dbx_commands
Definition: main.c:56
thread_info::stop_requested
int stop_requested
Definition: gdbthread.h:345
ptid_is_pid
int ptid_is_pid(const ptid_t &ptid)
Definition: ptid.c:79
handle_syscall_event
static int handle_syscall_event(struct execution_control_state *ecs)
Definition: infrun.c:4251
restore_selected_frame
static void restore_selected_frame(const frame_id &fid)
Definition: infrun.c:8981
current_ui
struct ui * current_ui
Definition: event-top.c:453
get_selected_frame
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1638
target_stop
void target_stop(ptid_t ptid)
Definition: target.c:3316
step_over_info_valid_p
static int step_over_info_valid_p(void)
Definition: infrun.c:1384
follow_fork_mode_kind_names
static const char *const follow_fork_mode_kind_names[]
Definition: infrun.c:393
thread_control_state::step_range_start
CORE_ADDR step_range_start
Definition: gdbthread.h:77
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
execute_cmd_pre_hook
void execute_cmd_pre_hook(struct cmd_list_element *c)
Definition: cli-script.c:366
gdbarch_displaced_step_copy_insn_p
int gdbarch_displaced_step_copy_insn_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3923
proceed_after_vfork_done
static int proceed_after_vfork_done(struct thread_info *thread, void *arg)
Definition: infrun.c:860
STEP_OVER_BREAKPOINT
Definition: infrun.c:1267
clean_up_just_stopped_threads_fsms
static void clean_up_just_stopped_threads_fsms(struct execution_control_state *ecs)
Definition: infrun.c:3785
target_waitstatus
Definition: waitstatus.h:104
thread_still_needs_step_over
static step_over_what thread_still_needs_step_over(struct thread_info *tp)
Definition: infrun.c:2936
check_curr_ui_sync_execution_done
static void check_curr_ui_sync_execution_done(void)
Definition: infrun.c:3814
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
post_create_inferior
void post_create_inferior(struct target_ops *target, int from_tty)
Definition: infcmd.c:435
signal_catch_update
void signal_catch_update(const unsigned int *info)
Definition: infrun.c:8430
clear_inline_frame_state
void clear_inline_frame_state(ptid_t ptid)
Definition: inline-frame.c:113
ui_out::field_string
void field_string(const char *fldname, const char *string)
Definition: ui-out.c:544
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
print_signal_received_reason
void print_signal_received_reason(struct ui_out *uiout, enum gdb_signal siggnal)
Definition: infrun.c:7927
gdb_rl_callback_handler_reinstall
void gdb_rl_callback_handler_reinstall(void)
Definition: event-top.c:323
target_shortname
#define target_shortname
Definition: target.h:1279
GDB_SIGNAL_FIRST
#define GDB_SIGNAL_FIRST
target_wait
ptid_t target_wait(ptid_t ptid, struct target_waitstatus *status, int options)
Definition: target.c:2177
displaced_step_dump_bytes
void displaced_step_dump_bytes(struct ui_file *file, const gdb_byte *buf, size_t len)
Definition: infrun.c:1721
program_space::aspace
struct address_space * aspace
Definition: progspace.h:166
RETURN_MASK_ALL
Definition: common-exceptions.h:44
thread_info::stepped_breakpoint
int stepped_breakpoint
Definition: gdbthread.h:313
insert_breakpoints
void insert_breakpoints(void)
Definition: breakpoint.c:2845
STOP_NONE
Definition: breakpoint.h:994
ui::command_editing
int command_editing
Definition: top.h:89
ptid_get_pid
int ptid_get_pid(const ptid_t &ptid)
Definition: ptid.c:47
fputs_unfiltered
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:127
make_cleanup_restore_current_traceframe
struct cleanup * make_cleanup_restore_current_traceframe(void)
Definition: tracepoint.c:3042
TARGET_WAITKIND_SYSCALL_ENTRY
Definition: waitstatus.h:71
get_thread_regcache
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:434
gdb_signal_from_command
enum gdb_signal gdb_signal_from_command(int num)
Definition: infrun.c:8666
thread_fsm
Definition: thread-fsm.h:31
delete_thread
void delete_thread(ptid_t)
Definition: thread.c:476
stop_stack_kind
stop_stack_kind
Definition: breakpoint.h:991
bpstat_clear
void bpstat_clear(bpstat *bsp)
Definition: breakpoint.c:4212
do_displays
void do_displays(void)
Definition: printcmd.c:2016
xfree
void xfree(void *)
pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1824
thread_info::initiating_frame
struct frame_id initiating_frame
Definition: gdbthread.h:351
may_insert_fast_tracepoints
int may_insert_fast_tracepoints
set_running
void set_running(ptid_t ptid, int running)
Definition: thread.c:919
ordinary_breakpoint_here
Definition: breakpoint.h:1154
do_target_wait
static ptid_t do_target_wait(ptid_t ptid, struct target_waitstatus *status, int options)
Definition: infrun.c:3495
thread_control_state::may_range_step
int may_range_step
Definition: gdbthread.h:89
clear_exit_convenience_vars
void clear_exit_convenience_vars(void)
Definition: infrun.c:9077
exec_direction_names
static const char *const exec_direction_names[]
Definition: infrun.c:9092
TARGET_STOPPED_BY_NO_REASON
Definition: waitstatus.h:131
gdbarch_get_longjmp_target
int gdbarch_get_longjmp_target(struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
Definition: gdbarch.c:2562
solist.h
execution_control_state
Definition: infrun.c:2023
target-dcache.h
no_class
Definition: command.h:41
switch_back_to_stepped_thread
static int switch_back_to_stepped_thread(struct execution_control_state *ecs)
Definition: infrun.c:7007
thread_control_state::proceed_to_finish
int proceed_to_finish
Definition: gdbthread.h:126
scoped_restore_base::release
void release() const
Definition: scoped_restore.h:29
print_no_history_reason
void print_no_history_reason(struct ui_out *uiout)
Definition: infrun.c:7977
annotate_stopped
void annotate_stopped(void)
Definition: annotate.c:108
add_setshow_auto_boolean_cmd
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_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:544
bpstat_print
enum print_stop_action bpstat_print(bpstat bs, int kind)
Definition: breakpoint.c:4686
class_support
Definition: command.h:42
target_supports_multi_process
int target_supports_multi_process(void)
Definition: target.c:2643
record-full.h
get_prev_frame
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2254
gdbarch_single_step_through_delay
int gdbarch_single_step_through_delay(struct gdbarch *gdbarch, struct frame_info *frame)
Definition: gdbarch.c:3272
disp_del_at_next_stop
Definition: breakpoint.h:220
frame_pop
void frame_pop(struct frame_info *this_frame)
Definition: frame.c:1031
cmd_list_element
Definition: cli-decode.h:46
frame_unwind_caller_pc
CORE_ADDR frame_unwind_caller_pc(struct frame_info *this_frame)
Definition: frame.c:944
BPSTAT_WHAT_SINGLE
Definition: breakpoint.h:952
displaced_step_inferior_state::next
struct displaced_step_inferior_state * next
Definition: infrun.c:1485
copy_inferior_target_desc_info
void copy_inferior_target_desc_info(struct inferior *destinf, struct inferior *srcinf)
Definition: target-descriptions.c:738
func
void(* func)(char *)
Definition: remote-fileio.c:1104
breakpoint_address_match
int breakpoint_address_match(const address_space *aspace1, CORE_ADDR addr1, const address_space *aspace2, CORE_ADDR addr2)
Definition: breakpoint.c:6838
frame_unwind_caller_arch
struct gdbarch * frame_unwind_caller_arch(struct frame_info *next_frame)
Definition: frame.c:2725
insert_step_resume_breakpoint_at_sal_1
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)
Definition: infrun.c:7391
warning
void warning(const char *fmt,...)
Definition: errors.c:26
regcache::regcache
regcache(gdbarch *gdbarch)
Definition: regcache.h:235
ui::async
int async
Definition: top.h:102
target_stopped_by_hw_breakpoint
#define target_stopped_by_hw_breakpoint()
Definition: target.h:1888
symtab_and_line::end
CORE_ADDR end
Definition: symtab.h:1760
execution_control_state::event_thread
struct thread_info * event_thread
Definition: infrun.c:2028
query
int query(const char *ctlstr,...)
Definition: utils.c:1063
discard_infcall_control_state
void discard_infcall_control_state(struct infcall_control_state *inf_status)
Definition: infrun.c:9058
bpstat_what::is_longjmp
int is_longjmp
Definition: breakpoint.h:1016
init_wait_for_inferior
void init_wait_for_inferior(void)
Definition: infrun.c:3252
bp_longjmp_resume
Definition: breakpoint.h:80
BPSTAT_WHAT_STEP_RESUME
Definition: breakpoint.h:965
bp_step_resume
Definition: breakpoint.h:97
target_write
LONGEST target_write(struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1841
enum-flags.h
async_enable_stdin
void async_enable_stdin(void)
Definition: event-top.c:538
disable_randomization
int disable_randomization
Definition: infrun.c:175
thread_fsm_delete
void thread_fsm_delete(struct thread_fsm *self)
Definition: thread-fsm.c:36
bp_location::enabled
bool enabled
Definition: breakpoint.h:385
breakpoint_auto_delete
void breakpoint_auto_delete(bpstat bs)
Definition: breakpoint.c:11624
displaced_step_inferior_state::step_copy
CORE_ADDR step_copy
Definition: infrun.c:1508
thread_fsm_should_stop
int thread_fsm_should_stop(struct thread_fsm *self, struct thread_info *thread)
Definition: thread-fsm.c:58
SRC_LINE
Definition: frame.h:663
plongest
char * plongest(LONGEST l)
Definition: print-utils.c:137
INF_EXEC_COMPLETE
Definition: target.h:126
scoped_restore_exited_inferior::scoped_restore_exited_inferior
scoped_restore_exited_inferior()
Definition: infrun.c:890
inferior_control_state::stop_soon
enum stop_kind stop_soon
Definition: inferior.h:280
target_detach
void target_detach(const char *args, int from_tty)
Definition: target.c:2147
resumed_thread_with_pending_status
static int resumed_thread_with_pending_status(struct thread_info *tp, void *arg)
Definition: infrun.c:5529
show_schedule_multiple
static void show_schedule_multiple(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:9135
gdbarch_gdb_signal_to_target_p
int gdbarch_gdb_signal_to_target_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4192
add_info
struct cmd_list_element * add_info(const char *name, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:886
infrun_thread_ptid_changed
static void infrun_thread_ptid_changed(ptid_t old_ptid, ptid_t new_ptid)
Definition: infrun.c:2176
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
select_frame
void select_frame(struct frame_info *fi)
Definition: frame.c:1677
target_supports_stopped_by_sw_breakpoint
#define target_supports_stopped_by_sw_breakpoint()
Definition: target.h:1885
check_exception_resume
static void check_exception_resume(struct execution_control_state *, struct frame_info *)
Definition: infrun.c:7585
get_stack_frame_id
struct frame_id get_stack_frame_id(struct frame_info *next_frame)
Definition: frame.c:549
_initialize_infrun
void _initialize_infrun(void)
Definition: infrun.c:9161
complete_on_enum
void complete_on_enum(completion_tracker &tracker, const char *const *enumlist, const char *text, const char *word)
Definition: cli-decode.c:1853
memset
void * memset(T *s, int c, size_t n)=delete
show_thread_that_caused_stop
int show_thread_that_caused_stop(void)
Definition: thread.c:1586
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
null_frame_id
const struct frame_id null_frame_id
Definition: frame.c:575
inferior_thread
struct thread_info * inferior_thread(void)
Definition: thread.c:90
infcall_control_state::inferior_control
struct inferior_control_state inferior_control
Definition: infrun.c:8938
target_pass_signals
void target_pass_signals(int numsigs, unsigned char *pass_signals)
Definition: target.c:2251
info_verbose
int info_verbose
Definition: top.c:1791
infcall_suspend_state::registers
struct regcache * registers
Definition: infrun.c:8812
gdbarch_deprecated_function_start_offset
CORE_ADDR gdbarch_deprecated_function_start_offset(struct gdbarch *gdbarch)
Definition: gdbarch.c:2987
show_observer_mode
static void show_observer_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:273
observer_notify_normal_stop
void observer_notify_normal_stop(struct bpstats *bs, int print_frame)
STOP_QUIETLY_NO_SIGSTOP
Definition: inferior.h:258
execution_control_state::hit_singlestep_breakpoint
int hit_singlestep_breakpoint
Definition: infrun.c:2041
step_over_info::address
CORE_ADDR address
Definition: infrun.c:1285
PRINT_UNKNOWN
Definition: breakpoint.h:501
execution_control_state::ptid
ptid_t ptid
Definition: infrun.c:2025
inferior
Definition: inferior.h:310
add_setshow_enum_cmd
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_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:515
restore_infcall_control_state
void restore_infcall_control_state(struct infcall_control_state *inf_status)
Definition: infrun.c:8999
STOP_QUIETLY_REMOTE
Definition: inferior.h:257
print_exited_reason
void print_exited_reason(struct ui_out *uiout, int exitstatus)
Definition: infrun.c:7881
infcall_control_state::selected_frame_id
struct frame_id selected_frame_id
Definition: infrun.c:8945
scheduler_enums
static const char *const scheduler_enums[]
Definition: infrun.c:2198
AUTO_BOOLEAN_AUTO
Definition: defs.h:241
insert_exception_resume_breakpoint
static void insert_exception_resume_breakpoint(struct thread_info *tp, const struct block *b, struct frame_info *frame, struct symbol *sym)
Definition: infrun.c:7507
target_waitstatus::value
union target_waitstatus::@174 value
mark_async_event_handler
void mark_async_event_handler(async_event_handler *async_handler_ptr)
Definition: event-loop.c:1036
follow_fork_mode_parent
static const char follow_fork_mode_parent[]
Definition: infrun.c:391
thread_control_state
Definition: gdbthread.h:50
set_observer_mode
static void set_observer_mode(const char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:237
nullify_last_target_wait_ptid
void nullify_last_target_wait_ptid(void)
Definition: infrun.c:4044
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
delete_just_stopped_threads_infrun_breakpoints
static void delete_just_stopped_threads_infrun_breakpoints(void)
Definition: infrun.c:3394
SIGTRAMP_FRAME
Definition: frame.h:255
program_space::breakpoints_not_allowed
int breakpoints_not_allowed
Definition: progspace.h:180
exec_reverse
static const char exec_reverse[]
Definition: infrun.c:9090
fill_in_stop_func
static void fill_in_stop_func(struct gdbarch *gdbarch, struct execution_control_state *ecs)
Definition: infrun.c:4295
annotate_signal
void annotate_signal(void)
Definition: annotate.c:160
context_switch
static void context_switch(ptid_t ptid)
Definition: infrun.c:4052
frame_info
Definition: frame.c:85
thread_fsm_clean_up
void thread_fsm_clean_up(struct thread_fsm *self, struct thread_info *thread)
Definition: thread-fsm.c:49
thread_still_needs_step_over_bp
static int thread_still_needs_step_over_bp(struct thread_info *tp)
Definition: infrun.c:2914
deprecated_context_hook
void(* deprecated_context_hook)(int)
Definition: top.c:244
target_async
void target_async(int enable)
Definition: target.c:3860
lval_funcs
Definition: value.h:220
compunit_symtab
Definition: symtab.h:1380
save_infcall_control_state
struct infcall_control_state * save_infcall_control_state(void)
Definition: infrun.c:8952
resume
void resume(gdb_signal sig)
Definition: infrun.c:2740
observer_attach_inferior_exit
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
siginfo_value_write
static void siginfo_value_write(struct value *v, struct value *fromval)
Definition: infrun.c:8754
set_stop_on_solib_events
static void set_stop_on_solib_events(const char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:362
inferior::vfork_child
inferior * vfork_child
Definition: inferior.h:385
find_inferior_ptid
struct inferior * find_inferior_ptid(ptid_t ptid)
Definition: inferior.c:321
symtab_and_line::section
struct obj_section * section
Definition: symtab.h:1753
cmdlist
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:79
thread_info::state
enum thread_state state
Definition: gdbthread.h:287
sched_multi
int sched_multi
Definition: infrun.c:2229
BPSTAT_WHAT_KEEP_CHECKING
Definition: breakpoint.h:945
keep_going
static void keep_going(struct execution_control_state *ecs)
Definition: infrun.c:7799
TARGET_WAITKIND_THREAD_CREATED
Definition: waitstatus.h:98
inferior::removable
bool removable
Definition: inferior.h:343
lookup_internalvar
struct internalvar * lookup_internalvar(const char *name)
Definition: value.c:2212
INF_REG_EVENT
Definition: target.h:124
THREAD_STOPPED_BY
#define THREAD_STOPPED_BY(REASON)
Definition: infrun.c:4357
cleanup
Definition: cleanups.c:38
step_over_info
Definition: infrun.c:1278
TARGET_WAITKIND_EXECD
Definition: waitstatus.h:56
_
#define _(String)
Definition: gdb_locale.h:35
displaced_step_clear
static void displaced_step_clear(struct displaced_step_inferior_state *displaced)
Definition: infrun.c:1701
thread_suspend_state::stop_signal
enum gdb_signal stop_signal
Definition: gdbthread.h:158
target_last_wait_ptid
static ptid_t target_last_wait_ptid
Definition: infrun.c:383
ui_file
Definition: ui-file.h:26
probe_safe_evaluate_at_pc
struct value * probe_safe_evaluate_at_pc(struct frame_info *frame, unsigned n)
Definition: probe.c:693
set_current_sal_from_frame
void set_current_sal_from_frame(struct frame_info *)
Definition: stack.c:725
NOT_SUPPORTED_ERROR
Definition: common-exceptions.h:99
bpstat_causes_stop
int bpstat_causes_stop(bpstat bs)
Definition: breakpoint.c:5780
STEP_OVER_NONE
Definition: inferior.h:223
defs.h
stop_context::thread
struct thread_info * thread
Definition: infrun.c:8103
gdbarch_have_nonsteppable_watchpoint
int gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch)
Definition: gdbarch.c:3483
builtin_type
Definition: gdbtypes.h:1495
signal_print_state
int signal_print_state(int signo)
Definition: infrun.c:8368
observer_notify_sync_execution_done
void observer_notify_sync_execution_done(void)
TARGET_WAITKIND_FORKED
Definition: waitstatus.h:48
program_breakpoint_here_p
int program_breakpoint_here_p(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:8715
thread_info::stepping_over_breakpoint
int stepping_over_breakpoint
Definition: gdbthread.h:316
make_scoped_defer_target_commit_resume
scoped_restore_tmpl< int > make_scoped_defer_target_commit_resume()
Definition: target.c:2245
internalvar
Definition: value.c:2070
THREAD_RUNNING
Definition: gdbthread.h:42
regcache_write_pc
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: regcache.c:1256
deprecated_target_wait_hook
ptid_t(* deprecated_target_wait_hook)(ptid_t ptid, struct target_waitstatus *status, int options)
Definition: top.c:232
target_stopped_by_watchpoint
#define target_stopped_by_watchpoint()
Definition: target.h:1876
displaced_step_prepare
static int displaced_step_prepare(ptid_t ptid)
Definition: infrun.c:1888
record_full_is_used
int record_full_is_used(void)
Definition: record-full.c:216
infrun_async_inferior_event_handler
static void infrun_async_inferior_event_handler(gdb_client_data data)
Definition: infrun.c:9155
exec_direction
static const char * exec_direction
Definition: infrun.c:9091
SET_SIGS
#define SET_SIGS(nsigs, sigs, flags)
Definition: infrun.c:321
displaced_step_inferior_state::step_original
CORE_ADDR step_original
Definition: infrun.c:1508
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
for_each_just_stopped_thread_callback_func
void(* for_each_just_stopped_thread_callback_func)(struct thread_info *tp)
Definition: infrun.c:3365
stepping_past_instruction_at
int stepping_past_instruction_at(struct address_space *aspace, CORE_ADDR address)
Definition: infrun.c:1355
set_schedlock_func
static void set_schedlock_func(const char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:2217
displaced_step_inferior_state
Definition: infrun.c:1482
target_program_signals
void target_program_signals(int numsigs, unsigned char *program_signals)
Definition: target.c:2257
allocate_value
struct value * allocate_value(struct type *type)
Definition: value.c:1036
infcall_control_state
Definition: infrun.c:8935
ui_out::text
void text(const char *string)
Definition: ui-out.c:581
arm-linux.inf
inf
Definition: arm-linux.py:13
follow_inferior_reset_breakpoints
static void follow_inferior_reset_breakpoints(void)
Definition: infrun.c:817
inferior::aspace
struct address_space * aspace
Definition: inferior.h:346
get_current_regcache
struct regcache * get_current_regcache(void)
Definition: regcache.c:446
moribund_breakpoint_here_p
int moribund_breakpoint_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4056
target_terminal::ours
static void ours()
Definition: target.c:483
target_terminal::inferior
static void inferior()
Definition: target.c:450
target_stopped_data_address
#define target_stopped_data_address(target, addr_p)
Definition: target.h:1984
insert_single_step_breakpoint
void insert_single_step_breakpoint(struct gdbarch *gdbarch, const address_space *aspace, CORE_ADDR next_pc)
Definition: breakpoint.c:14597
gdbarch_skip_solib_resolver
CORE_ADDR gdbarch_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: gdbarch.c:3323
thread_info::current_symtab
struct symtab * current_symtab
Definition: gdbthread.h:298
terminal.h
TARGET_WAITKIND_VFORK_DONE
Definition: waitstatus.h:65
may_insert_tracepoints
int may_insert_tracepoints
observer_attach_thread_stop_requested
struct observer * observer_attach_thread_stop_requested(observer_thread_stop_requested_ftype *f)
bpstat_stop_status
bpstat bpstat_stop_status(const address_space *aspace, CORE_ADDR bp_addr, ptid_t ptid, const struct target_waitstatus *ws)
Definition: breakpoint.c:5365
handle_step_into_function_backward
static void handle_step_into_function_backward(struct gdbarch *gdbarch, struct execution_control_state *ecs)
Definition: infrun.c:7354
progspace-and-thread.h
start_step_over
static int start_step_over(void)
Definition: infrun.c:2063
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
maybe_software_singlestep
static int maybe_software_singlestep(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: infrun.c:2238
internal_resume_ptid
static ptid_t internal_resume_ptid(int user_step)
Definition: infrun.c:2298
pagination_enabled
int pagination_enabled
Definition: utils.c:128
execution_control_state::stop_func_start
CORE_ADDR stop_func_start
Definition: infrun.c:2032
displaced_step_closure::~displaced_step_closure
virtual ~displaced_step_closure()=0
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
displaced_step_closure
Definition: infrun.h:249
objfiles.h
arch-utils.h
find_pc_overlay
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3173
displaced_step_inferior_state::step_gdbarch
struct gdbarch * step_gdbarch
Definition: infrun.c:1500
get_frame_address_space
const address_space * get_frame_address_space(struct frame_info *frame)
Definition: frame.c:2646
XNEW
#define XNEW(T)
Definition: poison.h:109
add_program_space
struct program_space * add_program_space(struct address_space *aspace)
Definition: progspace.c:113
restore_infcall_suspend_state
void restore_infcall_suspend_state(struct infcall_suspend_state *inf_state)
Definition: infrun.c:8876
async_event_handler
Definition: event-loop.c:123
release_stop_context_cleanup
static void release_stop_context_cleanup(void *arg)
Definition: infrun.c:8138
scoped_restore_exited_inferior
Definition: infrun.c:887
set_current_program_space
void set_current_program_space(struct program_space *pspace)
Definition: progspace.c:190
regcache_dup
struct regcache * regcache_dup(struct regcache *src)
Definition: regcache.c:353
observer.h
UNSET_SIGS
#define UNSET_SIGS(nsigs, sigs, flags)
Definition: infrun.c:329
thread_step_over_chain_next
struct thread_info * thread_step_over_chain_next(struct thread_info *tp)
Definition: thread.c:408
bpstat_should_step
int bpstat_should_step(void)
Definition: breakpoint.c:5769
signal_cache_update
static void signal_cache_update(int signo)
Definition: infrun.c:8380
find_pc_compunit_symtab
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
Definition: symtab.c:2988
inferior::pspace
struct program_space * pspace
Definition: inferior.h:349
handle_segmentation_fault
static void handle_segmentation_fault(struct ui_out *uiout)
Definition: infrun.c:7917
ALL_INFERIORS
#define ALL_INFERIORS(I)
Definition: inferior.h:548
event-loop.h
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
target_waitstatus_to_string
std::string target_waitstatus_to_string(const struct target_waitstatus *ws)
Definition: waitstatus.c:27
signal_completer
void signal_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1671
DUMMY_FRAME
Definition: frame.h:247
infrun_async
void infrun_async(int enable)
Definition: infrun.c:106
function_name_is_marked_for_skip
bool function_name_is_marked_for_skip(const char *function_name, const symtab_and_line &function_sal)
Definition: skip.c:574
add_setshow_zuinteger_cmd
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_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:792
signal_stop_state
int signal_stop_state(int signo)
Definition: infrun.c:8362
value_offset
LONGEST value_offset(const struct value *value)
Definition: value.c:1106
null_cleanup
void null_cleanup(void *arg)
Definition: cleanups.c:294
TRY
#define TRY
Definition: common-exceptions.h:246
symtab.h
schedlock_replay
static const char schedlock_replay[]
Definition: infrun.c:2197
iterate_over_threads
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:551
TARGET_WAITKIND_SIGNALLED
Definition: waitstatus.h:39
execution_control_state::wait_some_more
int wait_some_more
Definition: infrun.c:2035
inferior::waiting_for_vfork_done
bool waiting_for_vfork_done
Definition: inferior.h:394
frame_id_eq
int frame_id_eq(struct frame_id l, struct frame_id r)
Definition: frame.c:674
gdb_argv
Definition: utils.h:128
annotate_signal_name_end
void annotate_signal_name_end(void)
Definition: annotate.c:139
switch_to_thread
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1445
print_signal_exited_reason
void print_signal_exited_reason(struct ui_out *uiout, enum gdb_signal siggnal)
Definition: infrun.c:7860
extract_bp_kind::bp
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
target_stopped_by_sw_breakpoint
#define target_stopped_by_sw_breakpoint()
Definition: target.h:1882
main.h
bpstat_what::call_dummy
enum stop_stack_kind call_dummy
Definition: breakpoint.h:1011
name
const char *const name
Definition: aarch64-tdep.c:76
target_execution_direction
#define target_execution_direction()
Definition: target.h:1798
PRINT_NOTHING
Definition: breakpoint.h:513
get_frame_type
enum frame_type get_frame_type(struct frame_info *frame)
Definition: frame.c:2619
thread_control_state::in_infcall
int in_infcall
Definition: gdbthread.h:130
thread_info::next
struct thread_info * next
Definition: gdbthread.h:218
record_full_gdb_operation_disable_set
scoped_restore_tmpl< int > record_full_gdb_operation_disable_set(void)
Definition: record-full.c:662
gdbarch_decr_pc_after_break
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
Definition: gdbarch.c:2970
stop_print_frame
static int stop_print_frame
Definition: infrun.c:378
internalvar_funcs
Definition: value.h:946
stop_context_changed
static int stop_context_changed(struct stop_context *prev)
Definition: infrun.c:8151
inline-frame.h
observer_notify_about_to_proceed
void observer_notify_about_to_proceed(void)
gdb_optional.h
execution_control_state::stop_func_name
const char * stop_func_name
Definition: infrun.c:2034
get_frame_id
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:520
reset_ecs
static void reset_ecs(struct execution_control_state *ecs, struct thread_info *tp)
Definition: infrun.c:2047
breakpoint_re_set
void breakpoint_re_set(void)
Definition: breakpoint.c:13952
TARGET_STOPPED_BY_SINGLE_STEP
Definition: waitstatus.h:143
may_stop
int may_stop
save_stop_context
static struct stop_context * save_stop_context(void)
Definition: infrun.c:8113
stop_context::ptid
ptid_t ptid
Definition: infrun.c:8099
save_infcall_suspend_state
struct infcall_suspend_state * save_infcall_suspend_state(void)
Definition: infrun.c:8824
gdbarch_max_insn_length
ULONGEST gdbarch_max_insn_length(struct gdbarch *gdbarch)
Definition: gdbarch.c:3905
target_dcache_invalidate
void target_dcache_invalidate(void)
Definition: target-dcache.c:52
execution_direction
enum exec_direction_kind execution_direction
Definition: infrun.c:9088
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
Definition: breakpoint.h:962
breakpoint::disposition
bpdisp disposition
Definition: breakpoint.h:697
bp_hp_step_resume
Definition: breakpoint.h:101
ui::ui
ui(FILE *instream, FILE *outstream, FILE *errstream)
Definition: top.c:251
scheduler_mode
static const char * scheduler_mode
Definition: infrun.c:2205
thread_info::suspend
thread_suspend_state suspend
Definition: gdbthread.h:295
displaced_step_inferior_state::failed_before
int failed_before
Definition: infrun.c:1492
inf_starting
Definition: breakpoint.h:1143
annotate_exited
void annotate_exited(int exitstatus)
Definition: annotate.c:115
make_cleanup_restore_infcall_control_state
struct cleanup * make_cleanup_restore_infcall_control_state(struct infcall_control_state *inf_status)
Definition: infrun.c:9052
clear_proceed_status_thread
static void clear_proceed_status_thread(struct thread_info *tp)
Definition: infrun.c:2794
gdbarch_single_step_through_delay_p
int gdbarch_single_step_through_delay_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3265
breakpoint::type
bptype type
Definition: breakpoint.h:693
update_signals_program_target
void update_signals_program_target(void)
Definition: infrun.c:341
keep_going_pass_signal
static void keep_going_pass_signal(struct execution_control_state *ecs)
Definition: infrun.c:7668
current_target
struct target_ops current_target
inferior_event_handler
void inferior_event_handler(enum inferior_event_type event_type, gdb_client_data client_data)
Definition: inf-loop.c:37
detach_breakpoints
int detach_breakpoints(ptid_t ptid)
Definition: breakpoint.c:3645
gdbarch_addr_bits_remove
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:3208
insert_exception_resume_from_probe
static void insert_exception_resume_from_probe(struct thread_info *tp, const struct bound_probe *probe, struct frame_info *frame)
Definition: infrun.c:7554
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3288
bpstat_run_callbacks
void bpstat_run_callbacks(bpstat bs_head)
Definition: breakpoint.c:5739
non_stop_1
static int non_stop_1
Definition: infrun.c:205
thread_control_state::exception_resume_breakpoint
struct breakpoint * exception_resume_breakpoint
Definition: gdbthread.h:58
allocate_computed_value
struct value * allocate_computed_value(struct type *type, const struct lval_funcs *funcs, void *closure)
Definition: value.c:1061
inline_skipped_frames
int inline_skipped_frames(ptid_t ptid)
Definition: inline-frame.c:369
thread_control_state::step_frame_id
struct frame_id step_frame_id
Definition: gdbthread.h:94
target_clear_description
void target_clear_description(void)
Definition: target-descriptions.c:840
thread_is_in_step_over_chain
int thread_is_in_step_over_chain(struct thread_info *tp)
Definition: thread.c:418
print_stop_event
void print_stop_event(struct ui_out *uiout)
Definition: infrun.c:8044
target_is_non_stop_p
int target_is_non_stop_p(void)
Definition: target.c:3917
stop_all_threads
void stop_all_threads(void)
Definition: infrun.c:4468
finish_step_over
static int finish_step_over(struct execution_control_state *ecs)
Definition: infrun.c:5543
insert_longjmp_resume_breakpoint
static void insert_longjmp_resume_breakpoint(struct gdbarch *, CORE_ADDR)
Definition: infrun.c:7484
delete_thread_infrun_breakpoints
static void delete_thread_infrun_breakpoints(struct thread_info *tp)
Definition: infrun.c:3353
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
jit_inferior_created_hook
void jit_inferior_created_hook(void)
Definition: jit.c:1390
thread_info::executing
int executing
Definition: gdbthread.h:271
read_var_value
struct value * read_var_value(struct symbol *var, const struct block *var_block, struct frame_info *frame)
Definition: findvar.c:807
inferior_control_state
Definition: inferior.h:277
find_pc_function
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
infcall_suspend_state
Definition: infrun.c:8806
set_cmd_completer
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:160
print_stop_location
static void print_stop_location(struct target_waitstatus *ws)
Definition: infrun.c:7988
update_target_permissions
void update_target_permissions(void)
Definition: target.c:3978
for_each_just_stopped_thread
static void for_each_just_stopped_thread(for_each_just_stopped_thread_callback_func func)
Definition: infrun.c:3368
target_waitstatus::sig
enum gdb_signal sig
Definition: waitstatus.h:114
block_symbol::block
const struct block * block
Definition: symtab.h:1140
can_use_displaced_stepping
static enum auto_boolean can_use_displaced_stepping
Definition: infrun.c:1660
add_inferior
struct inferior * add_inferior(int pid)
Definition: inferior.c:121
regcache.h
gdbarch_displaced_step_copy_insn
struct displaced_step_closure * gdbarch_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
Definition: gdbarch.c:3930
scoped_restore_current_pspace_and_thread
Definition: progspace-and-thread.h:29
infrun_thread_stop_requested
static void infrun_thread_stop_requested(ptid_t ptid)
Definition: infrun.c:3291
gdbarch_displaced_step_hw_singlestep
int gdbarch_displaced_step_hw_singlestep(struct gdbarch *gdbarch, struct displaced_step_closure *closure)
Definition: gdbarch.c:3947
ui::prompt_state
enum prompt_state prompt_state
Definition: top.h:131
annotate_starting
void annotate_starting(void)
Definition: annotate.c:101
any_live_thread_of_process
struct thread_info * any_live_thread_of_process(int pid)
Definition: thread.c:674
debug_displaced
int debug_displaced
Definition: infrun.c:156
stepping_past_nonsteppable_watchpoint
int stepping_past_nonsteppable_watchpoint(void)
Definition: infrun.c:1376
add_setshow_zinteger_cmd
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_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:748
ptid_get_tid
long ptid_get_tid(const ptid_t &ptid)
Definition: ptid.c:63
signal_pass_update
int signal_pass_update(int signo, int state)
Definition: infrun.c:8417
insert_hp_step_resume_breakpoint_at_frame
static void insert_hp_step_resume_breakpoint_at_frame(struct frame_info *)
Definition: infrun.c:7429
ptid_t
Definition: ptid.h:35
return_value_info
Definition: infcmd.c:1664
target_resume
void target_resume(ptid_t ptid, int step, enum gdb_signal signal)
Definition: target.c:2215
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
make_cleanup_restore_infcall_suspend_state
struct cleanup * make_cleanup_restore_infcall_suspend_state(struct infcall_suspend_state *inf_state)
Definition: infrun.c:8912
print_target_wait_results
void print_target_wait_results(ptid_t waiton_ptid, ptid_t result_ptid, const struct target_waitstatus *ws)
Definition: infrun.c:3419
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
exception_print
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
inferior::inferior
inferior(int pid)
Definition: inferior.c:87
STEP_OVER_WATCHPOINT
Definition: infrun.c:1272
thread_control_state::trap_expected
int trap_expected
Definition: gdbthread.h:122
schedlock_on
static const char schedlock_on[]
Definition: infrun.c:2195
block_symbol
Definition: symtab.h:1133
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
clone_momentary_breakpoint
struct breakpoint * clone_momentary_breakpoint(struct breakpoint *orig)
Definition: breakpoint.c:8611
frame.h
displaced_step_inferior_state::step_saved_copy
gdb_byte * step_saved_copy
Definition: infrun.c:1511
restart_threads
static void restart_threads(struct thread_info *event_thread)
Definition: infrun.c:5426
thread_info::global_num
int global_num
Definition: gdbthread.h:253
inf-loop.h
infrun_async_inferior_event_token
static struct async_event_handler * infrun_async_inferior_event_token
Definition: infrun.c:97
TARGET_WNOHANG
#define TARGET_WNOHANG
Definition: wait.h:28
free_current_contents
void free_current_contents(void *ptr)
Definition: utils.c:199
update_observer_mode
void update_observer_mode(void)
Definition: infrun.c:286
get_frame_function
struct symbol * get_frame_function(struct frame_info *frame)
Definition: blockframe.c:118
pid_to_ptid
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:39
thread_suspend_state::stop_pc
CORE_ADDR stop_pc
Definition: gdbthread.h:175
target_thread_events
void target_thread_events(int enable)
Definition: target.c:3869
create_async_event_handler
async_event_handler * create_async_event_handler(async_event_handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:1013
gdbthread.h
current_uiout
#define current_uiout
Definition: ui-out.h:39
mark_infrun_async_event_handler
void mark_infrun_async_event_handler(void)
Definition: infrun.c:127
displaced_step_clear_cleanup
static void displaced_step_clear_cleanup(void *arg)
Definition: infrun.c:1711
step_over_info::nonsteppable_watchpoint_p
int nonsteppable_watchpoint_p
Definition: infrun.c:1289
breakpoint
Definition: breakpoint.h:684
inferior.h
thread_info::prev_pc
CORE_ADDR prev_pc
Definition: gdbthread.h:308
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
software_breakpoint_inserted_here_p
int software_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4114
SYMFILE_NO_READ
Definition: symfile-add-flags.h:43
cli-script.h
inferior::pending_detach
bool pending_detach
Definition: inferior.h:389
catching_syscall_number
int catching_syscall_number(int syscall_number)
Definition: break-catch-syscall.c:542
do_restore_infcall_suspend_state_cleanup
static void do_restore_infcall_suspend_state_cleanup(void *state)
Definition: infrun.c:8905
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
prune_inferiors
void prune_inferiors(void)
Definition: inferior.c:460
gdb_in_secondary_prompt_p
int gdb_in_secondary_prompt_p(struct ui *ui)
Definition: top.c:888
SYMFILE_DEFER_BP_RESET
Definition: symfile-add-flags.h:39
ptid_to_global_thread_id
int ptid_to_global_thread_id(ptid_t ptid)
Definition: thread.c:605
NO_STOP_QUIETLY
Definition: inferior.h:255
scoped_restore_base
Definition: scoped_restore.h:24
resume_1
static void resume_1(enum gdb_signal sig)
Definition: infrun.c:2362
infrun.h
scoped_restore_current_inferior
Definition: inferior.h:529
type
Definition: gdbtypes.h:749
single_step_breakpoint_inserted_here_p
int single_step_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:14665
find_pc_partial_function
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:320
inferior::exit_code
LONGEST exit_code
Definition: inferior.h:416
pending
Definition: buildsym.h:101
target_record_will_replay
int target_record_will_replay(ptid_t ptid, int dir)
Definition: target.c:3658
language.h
tracepoint.h
signal_stop
static unsigned char * signal_stop
Definition: infrun.c:306
find_record_target
struct target_ops * find_record_target(void)
Definition: record.c:63
show_follow_fork_mode_string
static void show_follow_fork_mode_string(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:401
SRC_AND_LOC
Definition: frame.h:668
STEP_OVER_UNDEBUGGABLE
Definition: inferior.h:225
not_just_help_class_command
void not_just_help_class_command(const char *args, int from_tty)
Definition: cli-decode.c:412
stop_context::stop_id
ULONGEST stop_id
Definition: infrun.c:8095
step_stop_if_no_debug
int step_stop_if_no_debug
Definition: infrun.c:135
gdbarch_handle_segmentation_fault_p
int gdbarch_handle_segmentation_fault_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2122
thread_info::pending_follow
struct target_waitstatus pending_follow
Definition: gdbthread.h:342
main_ui
struct ui * main_ui
Definition: event-top.c:452
enable
#define enable()
Definition: ser-go32.c:239
inf
Definition: gnu-nat.c:174
exec_direction_kind
exec_direction_kind
Definition: infrun.h:67
end_stepping_range
static void end_stepping_range(struct execution_control_state *ecs)
Definition: infrun.c:7830
skip.h
target_mourn_inferior
void target_mourn_inferior(ptid_t ptid)
Definition: target.c:2298
saved_context
static CONTEXT saved_context
Definition: windows-nat.c:149
remove_displaced_stepping_state
static void remove_displaced_stepping_state(int pid)
Definition: infrun.c:1624
regcache_cpy
void regcache_cpy(struct regcache *dst, struct regcache *src)
Definition: regcache.c:342
overlay_cache_invalid
int overlay_cache_invalid
Definition: symfile.c:2971
ui
Definition: top.h:56
gdbarch_cannot_step_breakpoint
int gdbarch_cannot_step_breakpoint(struct gdbarch *gdbarch)
Definition: gdbarch.c:3466
maybe_remove_breakpoints
void maybe_remove_breakpoints(void)
Definition: infrun.c:8076
solib.h
exception_fprintf
void exception_fprintf(struct ui_file *file, struct gdb_exception e, const char *prefix,...)
Definition: exceptions.c:119
scoped_restore_exited_inferior::m_saved_ptid
scoped_restore_tmpl< ptid_t > m_saved_ptid
Definition: infrun.c:895
gdbarch_skip_permanent_breakpoint
void gdbarch_skip_permanent_breakpoint(struct gdbarch *gdbarch, struct regcache *regcache)
Definition: gdbarch.c:3881
frame_unwind_program_space
struct program_space * frame_unwind_program_space(struct frame_info *this_frame)
Definition: frame.c:2635
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
inferior::symfile_flags
symfile_add_flags symfile_flags
Definition: inferior.h:420
print_thread_id
const char * print_thread_id(struct thread_info *thr)
Definition: thread.c:1602
target_is_async_p
#define target_is_async_p()
Definition: target.h:1781
get_infcall_suspend_state_regcache
struct regcache * get_infcall_suspend_state_regcache(struct infcall_suspend_state *inf_state)
Definition: infrun.c:8926
current_stop_id
static ULONGEST current_stop_id
Definition: infrun.c:2772
show_disable_randomization
static void show_disable_randomization(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:178
clear_step_over_info
static void clear_step_over_info(void)
Definition: infrun.c:1341
BPSTAT_WHAT_HP_STEP_RESUME
Definition: breakpoint.h:986
thread_info::thread_fsm
struct thread_fsm * thread_fsm
Definition: gdbthread.h:337
refcounted_object::decref
void decref()
Definition: refcounted-object.h:39
inferior::gdbarch
struct gdbarch * gdbarch
Definition: inferior.h:437
siginfo_value_read
static void siginfo_value_read(struct value *v)
Definition: infrun.c:8731
thread_fsm_finished_p
int thread_fsm_finished_p(struct thread_fsm *self)
Definition: thread-fsm.c:84
gdb_signal_to_name
const char * gdb_signal_to_name(enum gdb_signal)
Definition: signals.c:78
thread_info::ptid
ptid_t ptid
Definition: gdbthread.h:219
displaced_step_in_progress_thread
static int displaced_step_in_progress_thread(ptid_t ptid)
Definition: infrun.c:1555
siginfo_value_funcs
static const struct lval_funcs siginfo_value_funcs
Definition: infrun.c:8773
TARGET_WAITKIND_NO_HISTORY
Definition: waitstatus.h:92
target_has_execution
#define target_has_execution
Definition: target.h:1756
print_what
print_what
Definition: frame.h:660
value_contents_all_raw
gdb_byte * value_contents_all_raw(struct value *value)
Definition: value.c:1168
target_can_lock_scheduler
#define target_can_lock_scheduler
Definition: target.h:1771
scoped_restore_exited_inferior::m_inferior
scoped_restore_current_inferior m_inferior
Definition: infrun.c:897
target_last_waitstatus
static struct target_waitstatus target_last_waitstatus
Definition: infrun.c:384
breakpoint.h
delete_just_stopped_threads_single_step_breakpoints
static void delete_just_stopped_threads_single_step_breakpoints(void)
Definition: infrun.c:3403
EXEC_REVERSE
Definition: infrun.h:70
switch_to_thread_cleanup
static void switch_to_thread_cleanup(void *ptid_p)
Definition: infrun.c:4377
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
target_record_is_replaying
int target_record_is_replaying(ptid_t ptid)
Definition: target.c:3650
setdebuglist
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:153
BPSTAT_WHAT_STOP_SILENT
Definition: breakpoint.h:974
thread_has_single_step_breakpoint_here
int thread_has_single_step_breakpoint_here(struct thread_info *tp, const address_space *aspace, CORE_ADDR addr)
Definition: thread.c:156
async_disable_stdin
void async_disable_stdin(void)
Definition: event-top.c:554
read_memory
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:258
frame_unwind_caller_id
struct frame_id frame_unwind_caller_id(struct frame_info *next_frame)
Definition: frame.c:555
delete_step_resume_breakpoint
void delete_step_resume_breakpoint(struct thread_info *)
Definition: thread.c:110
step_over_queue_head
struct thread_info * step_over_queue_head
Definition: infrun.c:1260
annotate_thread_changed
void annotate_thread_changed(void)
Definition: annotate.c:236
inferior::num
int num
Definition: inferior.h:324
watchpoint
Definition: breakpoint.h:793
gdbarch_in_solib_return_trampoline
int gdbarch_in_solib_return_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
Definition: gdbarch.c:3340
xmalloc
void * xmalloc(YYSIZE_T)
symtab_and_line::symtab
struct symtab * symtab
Definition: symtab.h:1751
ptid_get_lwp
long ptid_get_lwp(const ptid_t &ptid)
Definition: ptid.c:55
gdbarch_adjust_breakpoint_address
CORE_ADDR gdbarch_adjust_breakpoint_address(struct gdbarch *gdbarch, CORE_ADDR bpaddr)
Definition: gdbarch.c:2919
wait_one
static ptid_t wait_one(struct target_waitstatus *ws)
Definition: infrun.c:4331
follow_exec_mode_same
static const char follow_exec_mode_same[]
Definition: infrun.c:1059
interps.h
observer_attach_thread_ptid_changed
struct observer * observer_attach_thread_ptid_changed(observer_thread_ptid_changed_ftype *f)
prepare_to_wait
static void prepare_to_wait(struct execution_control_state *ecs)
Definition: infrun.c:7815
use_displaced_stepping
static int use_displaced_stepping(struct thread_info *tp)
Definition: infrun.c:1682
displaced_step_restore
static void displaced_step_restore(struct displaced_step_inferior_state *displaced, ptid_t ptid)
Definition: infrun.c:1942
bound_probe
Definition: probe.h:241
thread_suspend_state::stop_reason
enum target_stop_reason stop_reason
Definition: gdbthread.h:162
thread_has_single_step_breakpoints_set
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
Definition: thread.c:148
gdb_client_data
void * gdb_client_data
Definition: event-loop.h:70
inferior::has_exit_code
bool has_exit_code
Definition: inferior.h:415
infrun_thread_thread_exit
static void infrun_thread_thread_exit(struct thread_info *tp, int silent)
Definition: infrun.c:3343
regcache::aspace
const address_space * aspace() const
Definition: regcache.h:257
bptype
bptype
Definition: breakpoint.h:67
target_terminal::ours_for_output
static void ours_for_output()
Definition: target.c:501
skip_inline_frames
void skip_inline_frames(ptid_t ptid)
Definition: inline-frame.c:304
fetch_inferior_event
void fetch_inferior_event(void *client_data)
Definition: infrun.c:3861
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
follow_exec_mode_names
static const char *const follow_exec_mode_names[]
Definition: infrun.c:1060
handle_inferior_event_1
static void handle_inferior_event_1(struct execution_control_state *ecs)
Definition: infrun.c:4803
set_last_target_status
void set_last_target_status(ptid_t ptid, struct target_waitstatus status)
Definition: infrun.c:4025
clone_program_space
struct program_space * clone_program_space(struct program_space *dest, struct program_space *src)
Definition: progspace.c:170
handle_command
static void handle_command(const char *args, int from_tty)
Definition: infrun.c:8467
SWITCH_THRU_ALL_UIS
#define SWITCH_THRU_ALL_UIS()
Definition: top.h:206
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
PRINT_SRC_ONLY
Definition: breakpoint.h:509
keep_going_stepped_thread
static int keep_going_stepped_thread(struct thread_info *tp)
Definition: infrun.c:7161
infrun_inferior_exit
static void infrun_inferior_exit(struct inferior *inf)
Definition: infrun.c:1647
thread_control_state::step_start_function
struct symbol * step_start_function
Definition: gdbthread.h:81
value
Definition: value.c:169
show_exec_direction_func
static void show_exec_direction_func(struct ui_file *out, int from_tty, struct cmd_list_element *cmd, const char *value)
Definition: infrun.c:9117
init_thread_stepping_state
void init_thread_stepping_state(struct thread_info *tss)
Definition: infrun.c:4014
find_frame_sal
symtab_and_line find_frame_sal(frame_info *frame)
Definition: frame.c:2487
stop_on_solib_events
int stop_on_solib_events
Definition: infrun.c:356
thread_info::current_line
int current_line
Definition: gdbthread.h:297
stop_context::inf_num
int inf_num
Definition: infrun.c:8106
execution_control_state::stop_func_end
CORE_ADDR stop_func_end
Definition: infrun.c:2033
gdbarch_handle_segmentation_fault
void gdbarch_handle_segmentation_fault(struct gdbarch *gdbarch, struct ui_out *uiout)
Definition: gdbarch.c:2129
ui_out
Definition: ui-out.h:77
STEP_OVER_ALL
Definition: inferior.h:224
finish_thread_state_cleanup
void finish_thread_state_cleanup(void *ptid_p)
Definition: thread.c:1089
bp_location::address
CORE_ADDR address
Definition: breakpoint.h:427
target_thread_name
const char * target_thread_name(struct thread_info *info)
Definition: target.c:2200
stopped_by_random_signal
int stopped_by_random_signal
Definition: infcmd.c:107
schedlock_step
static const char schedlock_step[]
Definition: infrun.c:2196
bp_location::permanent
bool permanent
Definition: breakpoint.h:395
annotate_signal_name
void annotate_signal_name(void)
Definition: annotate.c:132
discard_infcall_suspend_state
void discard_infcall_suspend_state(struct infcall_suspend_state *inf_state)
Definition: infrun.c:8918
signal_pass_state
int signal_pass_state(int signo)
Definition: infrun.c:8374
previous_inferior_ptid
static ptid_t previous_inferior_ptid
Definition: infrun.c:147
gdb_signal_from_name
enum gdb_signal gdb_signal_from_name(const char *)
Definition: signals.c:91
bpstat_copy
bpstat bpstat_copy(bpstat bs)
Definition: breakpoint.c:4251
all_uis_check_sync_execution_done
void all_uis_check_sync_execution_done(void)
Definition: infrun.c:3831
print_stack_frame
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:165
reinstall_readline_callback_handler_cleanup
static void reinstall_readline_callback_handler_cleanup(void *arg)
Definition: infrun.c:3763
infcall_control_state::stop_stack_dummy
enum stop_stack_kind stop_stack_dummy
Definition: infrun.c:8941
observer_mode
int observer_mode
Definition: infrun.c:233
symtab_and_line
Definition: symtab.h:1746
signal_program
static unsigned char * signal_program
Definition: infrun.c:308
thread_fsm_should_notify_stop
int thread_fsm_should_notify_stop(struct thread_fsm *self)
Definition: thread-fsm.c:104
event-top.h
ui_file::printf
void printf(const char *,...) ATTRIBUTE_PRINTF(2
Definition: ui-file.c:37
TARGET_STOPPED_BY_HW_BREAKPOINT
Definition: waitstatus.h:137
jit.h
throw_exception
void throw_exception(struct gdb_exception exception)
Definition: common-exceptions.c:312
disable_current_display
void disable_current_display(void)
Definition: printcmd.c:2042
EXEC_ASYNC_SIGNAL_RECEIVED
Definition: mi-common.h:42
target_waitstatus::execd_pathname
char * execd_pathname
Definition: waitstatus.h:118
thread_step_over_chain_enqueue
void thread_step_over_chain_enqueue(struct thread_info *tp)
Definition: thread.c:426
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
target_waitstatus::integer
int integer
Definition: waitstatus.h:112
process_event_stop_test
static void process_event_stop_test(struct execution_control_state *ecs)
Definition: infrun.c:6200
adjust_pc_after_break
static void adjust_pc_after_break(struct thread_info *thread, struct target_waitstatus *ws)
Definition: infrun.c:4071
start_remote
void start_remote(int from_tty)
Definition: infrun.c:3218
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
get_displaced_stepping_state
static struct displaced_step_inferior_state * get_displaced_stepping_state(int pid)
Definition: infrun.c:1521
gdb::optional::emplace
T & emplace(Args &&... args)
Definition: gdb_optional.h:152
discard_cleanups
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:212
non_stop
int non_stop
Definition: infrun.c:204
print_end_stepping_range_reason
void print_end_stepping_range_reason(struct ui_out *uiout)
Definition: infrun.c:7848
set_momentary_breakpoint
breakpoint_up set_momentary_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line sal, struct frame_id frame_id, enum bptype type)
Definition: breakpoint.c:8545
annotate_signal_string_end
void annotate_signal_string_end(void)
Definition: annotate.c:153
observer_notify_no_history
void observer_notify_no_history(void)
value_optimized_out
int value_optimized_out(struct value *value)
Definition: value.c:1424
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
thread_info::stepping_over_watchpoint
int stepping_over_watchpoint
Definition: gdbthread.h:321
show_follow_exec_mode_string
static void show_follow_exec_mode_string(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:1069
follow_fork_inferior
static int follow_fork_inferior(int follow_child, int detach_fork)
Definition: infrun.c:418
PROMPT_BLOCKED
Definition: top.h:37
target_has_stack
#define target_has_stack
Definition: target.h:1735
target_commit_resume
void target_commit_resume(void)
Definition: target.c:2234
EXEC_ASYNC_END_STEPPING_RANGE
Definition: mi-common.h:38
thread_control_state::stop_step
int stop_step
Definition: gdbthread.h:135
stop_kind
stop_kind
Definition: inferior.h:253
record.h
thread_fsm_return_value
struct return_value_info * thread_fsm_return_value(struct thread_fsm *self)
Definition: thread-fsm.c:66
INLINE_FRAME
Definition: frame.h:250
thread-fsm.h
signal_catch
static unsigned char * signal_catch
Definition: infrun.c:314
show_step_stop_if_no_debug
static void show_step_stop_if_no_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:137
TARGET_STOPPED_BY_SW_BREAKPOINT
Definition: waitstatus.h:134
ALL_NON_EXITED_THREADS
#define ALL_NON_EXITED_THREADS(T)
Definition: gdbthread.h:490
gdb::optional
Definition: gdb_optional.h:51
address_space
Definition: progspace.h:216
thread_info::name
char * name
Definition: gdbthread.h:265
make_bpstat_clear_actions_cleanup
struct cleanup * make_bpstat_clear_actions_cleanup(void)
Definition: utils.c:3168
set_resumed
void set_resumed(ptid_t ptid, int resumed)
Definition: thread.c:875
may_insert_breakpoints
int may_insert_breakpoints
proceed
void proceed(CORE_ADDR addr, enum gdb_signal siggnal)
Definition: infrun.c:2977
gdb_stderr
#define gdb_stderr
Definition: utils.h:344
set_disable_randomization
static void set_disable_randomization(const char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:193
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
inf::pid
pid_t pid
Definition: gnu-nat.c:187
follow_exec_mode_new
static const char follow_exec_mode_new[]
Definition: infrun.c:1058
update_thread_list
void update_thread_list(void)
Definition: thread.c:2000
async_reason_lookup
const char * async_reason_lookup(enum async_reply_reason reason)
Definition: mi-common.c:49
prepare_for_detach
void prepare_for_detach(void)
Definition: infrun.c:3627
ui_register_input_event_handler
void ui_register_input_event_handler(struct ui *ui)
Definition: event-top.c:520
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
currently_stepping
static int currently_stepping(struct thread_info *tp)
Definition: infrun.c:7264
set_step_info
void set_step_info(struct frame_info *frame, struct symtab_and_line sal)
Definition: infrun.c:4000
clear_proceed_status
void clear_proceed_status(int step)
Definition: infrun.c:2860
thread_info::control
thread_control_state control
Definition: gdbthread.h:291
bp_exception_resume
Definition: breakpoint.h:93
string_file::c_str
const char * c_str() const
Definition: ui-file.h:137
target_waitstatus::kind
enum target_waitkind kind
Definition: waitstatus.h:106
displaced_step_inferior_states
static struct displaced_step_inferior_state * displaced_step_inferior_states
Definition: infrun.c:1516
delete_exception_resume_breakpoint
void delete_exception_resume_breakpoint(struct thread_info *)
Definition: thread.c:117
TARGET_WAITKIND_SPURIOUS
Definition: waitstatus.h:77
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
gdbarch_get_siginfo_type_p
int gdbarch_get_siginfo_type_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4216
breakpoint_init_inferior
void breakpoint_init_inferior(enum inf_context context)
Definition: breakpoint.c:3872
regcache_read_pc
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1229
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
siginfo_funcs
static const struct internalvar_funcs siginfo_funcs
Definition: infrun.c:9144
set_step_over_info
static void set_step_over_info(const address_space *aspace, CORE_ADDR address, int nonsteppable_watchpoint_p, int thread)
Definition: infrun.c:1327
permanent_breakpoint_here
Definition: breakpoint.h:1155
info_signals_command
static void info_signals_command(const char *signum_exp, int from_tty)
Definition: infrun.c:8680
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
set_internalvar_integer
void set_internalvar_integer(struct internalvar *var, LONGEST l)
Definition: value.c:2442
thread_suspend_state
Definition: gdbthread.h:149
observer_notify_signal_received
void observer_notify_signal_received(enum gdb_signal siggnal)
add_displaced_stepping_state
static struct displaced_step_inferior_state * add_displaced_stepping_state(int pid)
Definition: infrun.c:1585
show_can_use_displaced_stepping
static void show_can_use_displaced_stepping(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:1663
scoped_restore_current_program_space
Definition: progspace.h:277
remove_breakpoints
int remove_breakpoints(void)
Definition: breakpoint.c:3038
solib_create_inferior_hook
void solib_create_inferior_hook(int from_tty)
Definition: solib.c:1228
target_pid_to_str
const char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2194
symtab_and_line::pspace
struct program_space * pspace
Definition: symtab.h:1749
hardware_breakpoint_inserted_here_p
int hardware_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4136
add_setshow_boolean_cmd
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_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
AUTO_BOOLEAN_TRUE
Definition: defs.h:239
set_current_traceframe
void set_current_traceframe(int num)
Definition: tracepoint.c:2991
pc_at_non_inline_function
int pc_at_non_inline_function(const address_space *aspace, CORE_ADDR pc, const struct target_waitstatus *ws)
Definition: breakpoint.c:15379
infrun_is_async
static int infrun_is_async
Definition: infrun.c:101
may_write_memory
int may_write_memory
sig_print_info
static void sig_print_info(enum gdb_signal)
Definition: infrun.c:8448
TARGET_WAITKIND_EXITED
Definition: waitstatus.h:31
exec_file_find
char * exec_file_find(const char *in_pathname, int *fd)
Definition: solib.c:382
observer_notify_exited
void observer_notify_exited(int exitstatus)
target-descriptions.h
bpstat_explains_signal
int bpstat_explains_signal(bpstat bsp, enum gdb_signal sig)
Definition: breakpoint.c:4294
may_write_registers
int may_write_registers
handle_vfork_child_exec_or_exit
static void handle_vfork_child_exec_or_exit(int exec)
Definition: infrun.c:904
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
compunit_language
enum language compunit_language(const struct compunit_symtab *cust)
Definition: symtab.c:303
stop_pc
CORE_ADDR stop_pc
Definition: infcmd.c:98
execution_control_state::stop_func_filled_in
int stop_func_filled_in
Definition: infrun.c:2031
try_open_exec_file
void try_open_exec_file(const char *exec_file_host, struct inferior *inf, symfile_add_flags add_flags)
Definition: exec.c:133
displaced_step_inferior_state::pid
int pid
Definition: infrun.c:1488
new_address_space
struct address_space * new_address_space(void)
Definition: progspace.c:57
infcall_suspend_state::stop_pc
CORE_ADDR stop_pc
Definition: infrun.c:8811
get_thread_arch_aspace_regcache
struct regcache * get_thread_arch_aspace_regcache(ptid_t ptid, struct gdbarch *gdbarch, struct address_space *aspace)
Definition: regcache.c:407
gdbarch_adjust_breakpoint_address_p
int gdbarch_adjust_breakpoint_address_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2912
do_target_resume
static void do_target_resume(ptid_t resume_ptid, int step, enum gdb_signal sig)
Definition: infrun.c:2314
clear_internalvar
void clear_internalvar(struct internalvar *var)
Definition: value.c:2475
symtab_and_line::pc
CORE_ADDR pc
Definition: symtab.h:1759
switch_to_thread_no_regs
void switch_to_thread_no_regs(struct thread_info *thread)
Definition: thread.c:1396
probe.h
target.h
gdb_signal_to_symbol_string
const char * gdb_signal_to_symbol_string(enum gdb_signal sig)
Definition: signals.c:59
BPSTAT_WHAT_STOP_NOISY
Definition: breakpoint.h:977
VAR_DOMAIN
Definition: symtab.h:739
bpstat_what
struct bpstat_what bpstat_what(bpstat bs_head)
Definition: breakpoint.c:5563
find_probe_by_pc
struct bound_probe find_probe_by_pc(CORE_ADDR pc)
Definition: probe.c:247
thread_control_state::single_step_breakpoints
struct breakpoint * single_step_breakpoints
Definition: gdbthread.h:65
value_free_to_mark
void value_free_to_mark(const struct value *mark)
Definition: value.c:1641
value.h
add_inferior_with_spaces
struct inferior * add_inferior_with_spaces(void)
Definition: inferior.c:763
exit_inferior_num_silent
void exit_inferior_num_silent(int num)
Definition: inferior.c:249
normal_stop
int normal_stop(void)
Definition: infrun.c:8167
TARGET_WAITKIND_VFORKED
Definition: waitstatus.h:52
block_iterator
Definition: block.h:197
EXEC_ASYNC_EXITED_SIGNALLED
Definition: mi-common.h:39
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
stop_waiting
static void stop_waiting(struct execution_control_state *ecs)
Definition: infrun.c:7650
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
add_info_alias
struct cmd_list_element * add_info_alias(const char *name, const char *oldname, int abbrev_flag)
Definition: cli-decode.c:894
stepped_in_from
static int stepped_in_from(struct frame_info *frame, struct frame_id step_frame_id)
Definition: infrun.c:4213
show_debug_displaced
static void show_debug_displaced(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:158
is_exited
int is_exited(ptid_t ptid)
Definition: thread.c:969
breakpoints_should_be_inserted_now
int breakpoints_should_be_inserted_now(void)
Definition: breakpoint.c:391
auto_boolean
auto_boolean
Definition: defs.h:237
displaced_step_in_progress_any_inferior
static int displaced_step_in_progress_any_inferior(void)
Definition: infrun.c:1538
insert_step_resume_breakpoint_at_caller
static void insert_step_resume_breakpoint_at_caller(struct frame_info *)
Definition: infrun.c:7460
show_non_stop
static void show_non_stop(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:221
current_program_space
struct program_space * current_program_space
Definition: progspace.c:35
set_non_stop
static void set_non_stop(const char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:208
inf_execd
Definition: breakpoint.h:1146
ptid_match
int ptid_match(const ptid_t &ptid, const ptid_t &filter)
Definition: ptid.c:103
handle_stop_requested
static bool handle_stop_requested(struct execution_control_state *ecs)
Definition: infrun.c:4233
delete_single_step_breakpoints
void delete_single_step_breakpoints(struct thread_info *tp)
Definition: thread.c:126
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
follow_fork_mode_child
static const char follow_fork_mode_child[]
Definition: infrun.c:390
gdbarch_displaced_step_fixup
void gdbarch_displaced_step_fixup(struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
Definition: gdbarch.c:3971
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
outer_frame_id
const struct frame_id outer_frame_id
Definition: frame.c:577
SYMBOL_SEARCH_NAME
#define SYMBOL_SEARCH_NAME(symbol)
Definition: symtab.h:551
print_return_value
void print_return_value(struct ui_out *uiout, struct return_value_info *rv)
Definition: infcmd.c:1715
regcache
Definition: regcache.h:232
clear_async_event_handler
void clear_async_event_handler(async_event_handler *async_handler_ptr)
Definition: event-loop.c:1044
validate_registers_access
void validate_registers_access(void)
Definition: thread.c:1101
class_run
Definition: command.h:41
thread_step_over_chain_remove
void thread_step_over_chain_remove(struct thread_info *tp)
Definition: thread.c:434
observer_mode_1
static int observer_mode_1
Definition: infrun.c:234
completion_tracker
Definition: completer.h:310
update_breakpoints_after_exec
void update_breakpoints_after_exec(void)
Definition: breakpoint.c:3523
all_uis_on_sync_execution_starting
void all_uis_on_sync_execution_starting(void)
Definition: infrun.c:3842
gdb_wait.h
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
EXEC_ASYNC_EXITED
Definition: mi-common.h:40
thread_is_stepping_over_breakpoint
int thread_is_stepping_over_breakpoint(int thread)
Definition: infrun.c:1367
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
watchpoints_triggered
int watchpoints_triggered(struct target_waitstatus *ws)
Definition: breakpoint.c:4762
update_solib_breakpoints
void update_solib_breakpoints(void)
Definition: solib.c:1275
RESUME_ALL
#define RESUME_ALL
Definition: infrun.c:348
gdb_signal_to_string
const char * gdb_signal_to_string(enum gdb_signal)
Definition: signals.c:68
signal_print
static unsigned char * signal_print
Definition: infrun.c:307
TARGET_WAITKIND_LOADED
Definition: waitstatus.h:43
write_memory_ptid
static void write_memory_ptid(ptid_t ptid, CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
Definition: infrun.c:1930
inferior::control
inferior_control_state control
Definition: inferior.h:337
debug_infrun
unsigned int debug_infrun
Definition: infrun.c:164
refcounted_object::incref
void incref()
Definition: refcounted-object.h:32
symbol
Definition: symtab.h:1049
target_read
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1562
gdbarch_skip_trampoline_code
CORE_ADDR gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
Definition: gdbarch.c:3306
show_scheduler_mode
static void show_scheduler_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:2207
displaced_step_prepare_throw
static int displaced_step_prepare_throw(ptid_t ptid)
Definition: infrun.c:1749
showdebuglist
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:155
target_follow_fork
int target_follow_fork(int follow_child, int detach_fork)
Definition: target.c:2276
infcall_control_state::stopped_by_random_signal
int stopped_by_random_signal
Definition: infrun.c:8942
annotate_signal_string
void annotate_signal_string(void)
Definition: annotate.c:146
exec_forward
static const char exec_forward[]
Definition: infrun.c:9089
value_as_address
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2762
signal_print_update
int signal_print_update(int signo, int state)
Definition: infrun.c:8407
follow_fork
static int follow_fork(void)
Definition: infrun.c:656
BPSTAT_WHAT_SET_LONGJMP_RESUME
Definition: breakpoint.h:958
TARGET_WAITKIND_NO_RESUMED
Definition: waitstatus.h:95
gdbarch_skip_entrypoint_p
int gdbarch_skip_entrypoint_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2803
wait_for_inferior
void wait_for_inferior(void)
Definition: infrun.c:3700
thread_suspend_state::waitstatus
struct target_waitstatus waitstatus
Definition: gdbthread.h:165
step_over_info::thread
int thread
Definition: infrun.c:1292
gdbarch_displaced_step_location
CORE_ADDR gdbarch_displaced_step_location(struct gdbarch *gdbarch)
Definition: gdbarch.c:3989
set_momentary_breakpoint_at_pc
breakpoint_up set_momentary_breakpoint_at_pc(struct gdbarch *gdbarch, CORE_ADDR pc, enum bptype type)
Definition: breakpoint.c:8621
symtab_and_line::line
int line
Definition: symtab.h:1757
TARGET_WAITKIND_THREAD_EXITED
Definition: waitstatus.h:101
inferior::vfork_parent
inferior * vfork_parent
Definition: inferior.h:379
thread_control_state::step_over_calls
enum step_over_calls_kind step_over_calls
Definition: gdbthread.h:132
breakpoint_retire_moribund
void breakpoint_retire_moribund(void)
Definition: breakpoint.c:12195
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
scoped_restore_exited_inferior::m_pspace
scoped_restore_current_program_space m_pspace
Definition: infrun.c:896
thread_control_state::step_resume_breakpoint
struct breakpoint * step_resume_breakpoint
Definition: gdbthread.h:55
stop_stack_dummy
enum stop_stack_kind stop_stack_dummy
Definition: infcmd.c:102
scoped_restore_tmpl< ptid_t >
gdbarch_skip_entrypoint
CORE_ADDR gdbarch_skip_entrypoint(struct gdbarch *gdbarch, CORE_ADDR ip)
Definition: gdbarch.c:2810
disable_thread_events
static void disable_thread_events(void *arg)
Definition: infrun.c:4460
signal_stop_update
int signal_stop_update(int signo, int state)
Definition: infrun.c:8397
skip_language_trampoline
CORE_ADDR skip_language_trampoline(struct frame_info *frame, CORE_ADDR pc)
Definition: language.c:599
cleanup::arg
void * arg
Definition: cleanups.c:43
handle_no_resumed
static int handle_no_resumed(struct execution_control_state *ecs)
Definition: infrun.c:4681
get_inferior_stop_soon
static enum stop_kind get_inferior_stop_soon(ptid_t ptid)
Definition: infrun.c:4319
EXEC_ASYNC_EXITED_NORMALLY
Definition: mi-common.h:41
reinit_frame_cache
void reinit_frame_cache(void)
Definition: frame.c:1809
class_maintenance
Definition: command.h:43
target_have_steppable_watchpoint
#define target_have_steppable_watchpoint
Definition: target.h:1896
remove_breakpoints_pid
int remove_breakpoints_pid(int pid)
Definition: breakpoint.c:3078
step_over_info::aspace
const address_space * aspace
Definition: infrun.c:1284
follow_exec
static void follow_exec(ptid_t ptid, char *exec_file_target)
Definition: infrun.c:1078
annotate.h
detach_fork
static int detach_fork
Definition: infrun.c:154
gdb_flush
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:93
regcache::ptid
ptid_t ptid() const
Definition: regcache.h:325
follow_exec_mode_string
static const char * follow_exec_mode_string
Definition: infrun.c:1067
signal_pass
static unsigned char * signal_pass
Definition: infrun.c:319
show_debug_infrun
static void show_debug_infrun(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:166
displaced_step_in_progress
static int displaced_step_in_progress(int pid)
Definition: infrun.c:1569
QUIT
#define QUIT
Definition: defs.h:179
is_running
int is_running(ptid_t ptid)
Definition: thread.c:975
handle_completer
static void handle_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: infrun.c:8643
write_memory
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:394
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
do_restore_infcall_control_state_cleanup
static void do_restore_infcall_control_state_cleanup(void *sts)
Definition: infrun.c:9045
follow_fork_mode_string
static const char * follow_fork_mode_string
Definition: infrun.c:399
target_find_description
void target_find_description(void)
Definition: target-descriptions.c:777
TARGET_WAITKIND_IGNORE
Definition: waitstatus.h:88
displaced_step_fixup
static int displaced_step_fixup(ptid_t event_ptid, enum gdb_signal signal)
Definition: infrun.c:1963
execution_control_state::ws
struct target_waitstatus ws
Definition: infrun.c:2030
gdbarch_gdb_signal_to_target
int gdbarch_gdb_signal_to_target(struct gdbarch *gdbarch, enum gdb_signal signal)
Definition: gdbarch.c:4199
gdbarch_skip_prologue_noexcept
CORE_ADDR gdbarch_skip_prologue_noexcept(gdbarch *gdbarch, CORE_ADDR pc) noexcept
Definition: arch-utils.c:964
target_follow_exec
void target_follow_exec(struct inferior *inf, char *execd_pathname)
Definition: target.c:2285
thread_suspend_state::waitstatus_pending_p
int waitstatus_pending_p
Definition: gdbthread.h:167
get_displaced_step_closure_by_addr
struct displaced_step_closure * get_displaced_step_closure_by_addr(CORE_ADDR addr)
Definition: infrun.c:1608
stop_command
static struct cmd_list_element * stop_command
Definition: infrun.c:352
class_obscure
Definition: command.h:43
TARGET_WAITKIND_STOPPED
Definition: waitstatus.h:35
insert_step_resume_breakpoint_at_sal
void insert_step_resume_breakpoint_at_sal(struct gdbarch *gdbarch, struct symtab_and_line sr_sal, struct frame_id sr_id)
Definition: infrun.c:7412
gdbarch_get_siginfo_type
struct type * gdbarch_get_siginfo_type(struct gdbarch *gdbarch)
Definition: gdbarch.c:4223
inferior::attach_flag
bool attach_flag
Definition: inferior.h:375
gdbcmd.h
target_waitstatus::syscall_number
int syscall_number
Definition: waitstatus.h:120
has_stack_frames
int has_stack_frames(void)
Definition: frame.c:1609
get_frame_program_space
struct program_space * get_frame_program_space(struct frame_info *frame)
Definition: frame.c:2629
delete_just_stopped_threads_infrun_breakpoints_cleanup
static void delete_just_stopped_threads_infrun_breakpoints_cleanup(void *arg)
Definition: infrun.c:3411
breakpoint_re_set_thread
void breakpoint_re_set_thread(struct breakpoint *b)
Definition: breakpoint.c:13998
create_internalvar_type_lazy
struct internalvar * create_internalvar_type_lazy(const char *name, const struct internalvar_funcs *funcs, void *data)
Definition: value.c:2177
infcall_suspend_state::thread_suspend
struct thread_suspend_state thread_suspend
Definition: infrun.c:8808
set_executing
void set_executing(ptid_t ptid, int executing)
Definition: thread.c:991
STOP_STACK_DUMMY
Definition: breakpoint.h:997
target_supports_stopped_by_hw_breakpoint
#define target_supports_stopped_by_hw_breakpoint()
Definition: target.h:1891
handle_signal_stop
static void handle_signal_stop(struct execution_control_state *ecs)
Definition: infrun.c:5661
thread_info
Definition: gdbthread.h:205
error
void error(const char *fmt,...)
Definition: errors.c:38
return_child_result_value
int return_child_result_value
Definition: main.c:88
thread_info::step_after_step_resume_breakpoint
int step_after_step_resume_breakpoint
Definition: gdbthread.h:332
minus_one_ptid
ptid_t minus_one_ptid
Definition: ptid.c:26
displaced_step_inferior_state::step_ptid
ptid_t step_ptid
Definition: infrun.c:1497
ALL_BLOCK_SYMBOLS
#define ALL_BLOCK_SYMBOLS(block, iter, sym)
Definition: block.h:310
frame_id
Definition: frame.h:111
dictionary.h
copy_terminal_info
void copy_terminal_info(struct inferior *to, struct inferior *from)
Definition: inflow.c:466
STOP_QUIETLY
Definition: inferior.h:256
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
block.h
set_current_inferior
void set_current_inferior(struct inferior *inf)
Definition: inferior.c:64
throw_error
void throw_error(enum errors error, const char *fmt,...)
Definition: common-exceptions.c:389
LONGEST
long long LONGEST
Definition: common-types.h:52
sig_print_header
static void sig_print_header(void)
Definition: infrun.c:8441
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
is_executing
int is_executing(ptid_t ptid)
Definition: thread.c:981
scoped_restore_current_thread
Definition: gdbthread.h:600
EXEC_FORWARD
Definition: infrun.h:69
program_space
Definition: progspace.h:137
observer_notify_signal_exited
void observer_notify_signal_exited(enum gdb_signal siggnal)
setup_inferior
void setup_inferior(int from_tty)
Definition: infcmd.c:2640
thread_control_state::step_range_end
CORE_ADDR step_range_end
Definition: gdbthread.h:78
ui_out::is_mi_like_p
bool is_mi_like_p()
Definition: ui-out.c:622
SYMBOL_IS_ARGUMENT
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:1157
schedlock_applies
static int schedlock_applies(struct thread_info *tp)
Definition: infrun.c:2954
symfile.h
exec_done_display_p
int exec_done_display_p
Definition: event-top.c:93
ui_out::field_fmt
void field_fmt(const char *fldname, const char *format,...) ATTRIBUTE_PRINTF(3
Definition: ui-out.c:557
step_into_inline_frame
void step_into_inline_frame(ptid_t ptid)
Definition: inline-frame.c:356
infcall_suspend_state::siginfo_data
gdb_byte * siginfo_data
Definition: infrun.c:8820
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
continuations.h
check_longjmp_breakpoint_for_call_dummy
void check_longjmp_breakpoint_for_call_dummy(struct thread_info *tp)
Definition: breakpoint.c:7392
ALL_THREADS_SAFE
#define ALL_THREADS_SAFE(T, TMP)
Definition: gdbthread.h:496
PROMPT_NEEDED
Definition: top.h:41
mark_breakpoints_out
void mark_breakpoints_out(void)
Definition: breakpoint.c:3850
displaced_step_inferior_state::step_closure
struct displaced_step_closure * step_closure
Definition: infrun.c:1504
gdbarch_get_longjmp_target_p
int gdbarch_get_longjmp_target_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2555
bpstat_what::main_action
enum bpstat_what_main_action main_action
Definition: breakpoint.h:1005
string_file
Definition: ui-file.h:106
parse_and_eval_long
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111