GDB (xrefs)
/tmp/gdb-7.10/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-2015 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 
65 /* Prototypes for local functions */
66 
67 static void signals_info (char *, int);
68 
69 static void handle_command (char *, int);
70 
71 static void sig_print_info (enum gdb_signal);
72 
73 static void sig_print_header (void);
74 
75 static void resume_cleanups (void *);
76 
77 static int hook_stop_stub (void *);
78 
79 static int restore_selected_frame (void *);
80 
81 static int follow_fork (void);
82 
83 static int follow_fork_inferior (int follow_child, int detach_fork);
84 
85 static void follow_inferior_reset_breakpoints (void);
86 
87 static void set_schedlock_func (char *args, int from_tty,
88  struct cmd_list_element *c);
89 
90 static int currently_stepping (struct thread_info *tp);
91 
92 void _initialize_infrun (void);
93 
95 
97 
99 
100 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
101 
102 static int maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc);
103 
104 /* When set, stop the 'step' command if we enter a function which has
105  no line number information. The normal behavior is that we step
106  over such function. */
108 static void
109 show_step_stop_if_no_debug (struct ui_file *file, int from_tty,
110  struct cmd_list_element *c, const char *value)
111 {
112  fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value);
113 }
114 
115 /* In asynchronous mode, but simulating synchronous execution. */
116 
118 
119 /* proceed and normal_stop use this to notify the user when the
120  inferior stopped in a different thread than it had been running
121  in. */
122 
124 
125 /* If set (default for legacy reasons), when following a fork, GDB
126  will detach from one of the fork branches, child or parent.
127  Exactly which branch is detached depends on 'set follow-fork-mode'
128  setting. */
129 
130 static int detach_fork = 1;
131 
133 static void
134 show_debug_displaced (struct ui_file *file, int from_tty,
135  struct cmd_list_element *c, const char *value)
136 {
137  fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value);
138 }
139 
140 unsigned int debug_infrun = 0;
141 static void
142 show_debug_infrun (struct ui_file *file, int from_tty,
143  struct cmd_list_element *c, const char *value)
144 {
145  fprintf_filtered (file, _("Inferior debugging is %s.\n"), value);
146 }
147 
148 
149 /* Support for disabling address space randomization. */
150 
152 
153 static void
154 show_disable_randomization (struct ui_file *file, int from_tty,
155  struct cmd_list_element *c, const char *value)
156 {
158  fprintf_filtered (file,
159  _("Disabling randomization of debuggee's "
160  "virtual address space is %s.\n"),
161  value);
162  else
163  fputs_filtered (_("Disabling randomization of debuggee's "
164  "virtual address space is unsupported on\n"
165  "this platform.\n"), file);
166 }
167 
168 static void
169 set_disable_randomization (char *args, int from_tty,
170  struct cmd_list_element *c)
171 {
173  error (_("Disabling randomization of debuggee's "
174  "virtual address space is unsupported on\n"
175  "this platform."));
176 }
177 
178 /* User interface for non-stop mode. */
179 
180 int non_stop = 0;
181 static int non_stop_1 = 0;
182 
183 static void
184 set_non_stop (char *args, int from_tty,
185  struct cmd_list_element *c)
186 {
188  {
189  non_stop_1 = non_stop;
190  error (_("Cannot change this setting while the inferior is running."));
191  }
192 
193  non_stop = non_stop_1;
194 }
195 
196 static void
197 show_non_stop (struct ui_file *file, int from_tty,
198  struct cmd_list_element *c, const char *value)
199 {
200  fprintf_filtered (file,
201  _("Controlling the inferior in non-stop mode is %s.\n"),
202  value);
203 }
204 
205 /* "Observer mode" is somewhat like a more extreme version of
206  non-stop, in which all GDB operations that might affect the
207  target's execution have been disabled. */
208 
210 static int observer_mode_1 = 0;
211 
212 static void
213 set_observer_mode (char *args, int from_tty,
214  struct cmd_list_element *c)
215 {
217  {
218  observer_mode_1 = observer_mode;
219  error (_("Cannot change this setting while the inferior is running."));
220  }
221 
222  observer_mode = observer_mode_1;
223 
228  /* We can insert fast tracepoints in or out of observer mode,
229  but enable them if we're going into this mode. */
230  if (observer_mode)
234 
235  /* Going *into* observer mode we must force non-stop, then
236  going out we leave it that way. */
237  if (observer_mode)
238  {
239  pagination_enabled = 0;
240  non_stop = non_stop_1 = 1;
241  }
242 
243  if (from_tty)
244  printf_filtered (_("Observer mode is now %s.\n"),
245  (observer_mode ? "on" : "off"));
246 }
247 
248 static void
249 show_observer_mode (struct ui_file *file, int from_tty,
250  struct cmd_list_element *c, const char *value)
251 {
252  fprintf_filtered (file, _("Observer mode is %s.\n"), value);
253 }
254 
255 /* This updates the value of observer mode based on changes in
256  permissions. Note that we are deliberately ignoring the values of
257  may-write-registers and may-write-memory, since the user may have
258  reason to enable these during a session, for instance to turn on a
259  debugging-related global. */
260 
261 void
263 {
264  int newval;
265 
266  newval = (!may_insert_breakpoints
269  && !may_stop
270  && non_stop);
271 
272  /* Let the user know if things change. */
273  if (newval != observer_mode)
274  printf_filtered (_("Observer mode is now %s.\n"),
275  (newval ? "on" : "off"));
276 
277  observer_mode = observer_mode_1 = newval;
278 }
279 
280 /* Tables of how to react to signals; the user sets them. */
281 
282 static unsigned char *signal_stop;
283 static unsigned char *signal_print;
284 static unsigned char *signal_program;
285 
286 /* Table of signals that are registered with "catch signal". A
287  non-zero entry indicates that the signal is caught by some "catch
288  signal" command. This has size GDB_SIGNAL_LAST, to accommodate all
289  signals. */
290 static unsigned char *signal_catch;
291 
292 /* Table of signals that the target may silently handle.
293  This is automatically determined from the flags above,
294  and simply cached here. */
295 static unsigned char *signal_pass;
296 
297 #define SET_SIGS(nsigs,sigs,flags) \
298  do { \
299  int signum = (nsigs); \
300  while (signum-- > 0) \
301  if ((sigs)[signum]) \
302  (flags)[signum] = 1; \
303  } while (0)
304 
305 #define UNSET_SIGS(nsigs,sigs,flags) \
306  do { \
307  int signum = (nsigs); \
308  while (signum-- > 0) \
309  if ((sigs)[signum]) \
310  (flags)[signum] = 0; \
311  } while (0)
312 
313 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
314  this function is to avoid exporting `signal_program'. */
315 
316 void
318 {
319  target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
320 }
321 
322 /* Value to pass to target_resume() to cause all threads to resume. */
323 
324 #define RESUME_ALL minus_one_ptid
325 
326 /* Command list pointer for the "stop" placeholder. */
327 
329 
330 /* Nonzero if we want to give control to the user when we're notified
331  of shared library events by the dynamic linker. */
333 
334 /* Enable or disable optional shared library event breakpoints
335  as appropriate when the above flag is changed. */
336 
337 static void
338 set_stop_on_solib_events (char *args, int from_tty, struct cmd_list_element *c)
339 {
341 }
342 
343 static void
344 show_stop_on_solib_events (struct ui_file *file, int from_tty,
345  struct cmd_list_element *c, const char *value)
346 {
347  fprintf_filtered (file, _("Stopping for shared library events is %s.\n"),
348  value);
349 }
350 
351 /* Nonzero means expecting a trace trap
352  and should stop the inferior and return silently when it happens. */
353 
355 
356 /* Nonzero after stop if current stack frame should be printed. */
357 
358 static int stop_print_frame;
359 
360 /* This is a cached copy of the pid/waitstatus of the last event
361  returned by target_wait()/deprecated_target_wait_hook(). This
362  information is returned by get_last_target_status(). */
365 
366 static void context_switch (ptid_t ptid);
367 
368 void init_thread_stepping_state (struct thread_info *tss);
369 
370 static const char follow_fork_mode_child[] = "child";
371 static const char follow_fork_mode_parent[] = "parent";
372 
373 static const char *const follow_fork_mode_kind_names[] = {
376  NULL
377 };
378 
380 static void
381 show_follow_fork_mode_string (struct ui_file *file, int from_tty,
382  struct cmd_list_element *c, const char *value)
383 {
384  fprintf_filtered (file,
385  _("Debugger response to a program "
386  "call of fork or vfork is \"%s\".\n"),
387  value);
388 }
389 
390 
391 /* Handle changes to the inferior list based on the type of fork,
392  which process is being followed, and whether the other process
393  should be detached. On entry inferior_ptid must be the ptid of
394  the fork parent. At return inferior_ptid is the ptid of the
395  followed inferior. */
396 
397 static int
398 follow_fork_inferior (int follow_child, int detach_fork)
399 {
400  int has_vforked;
401  ptid_t parent_ptid, child_ptid;
402 
403  has_vforked = (inferior_thread ()->pending_follow.kind
405  parent_ptid = inferior_ptid;
407 
408  if (has_vforked
409  && !non_stop /* Non-stop always resumes both branches. */
410  && (!target_is_async_p () || sync_execution)
411  && !(follow_child || detach_fork || sched_multi))
412  {
413  /* The parent stays blocked inside the vfork syscall until the
414  child execs or exits. If we don't let the child run, then
415  the parent stays blocked. If we're telling the parent to run
416  in the foreground, the user will not be able to ctrl-c to get
417  back the terminal, effectively hanging the debug session. */
419 Can not resume the parent process over vfork in the foreground while\n\
420 holding the child stopped. Try \"set detach-on-fork\" or \
421 \"set schedule-multiple\".\n"));
422  /* FIXME output string > 80 columns. */
423  return 1;
424  }
425 
426  if (!follow_child)
427  {
428  /* Detach new forked process? */
429  if (detach_fork)
430  {
431  struct cleanup *old_chain;
432 
433  /* Before detaching from the child, remove all breakpoints
434  from it. If we forked, then this has already been taken
435  care of by infrun.c. If we vforked however, any
436  breakpoint inserted in the parent is visible in the
437  child, even those added while stopped in a vfork
438  catchpoint. This will remove the breakpoints from the
439  parent also, but they'll be reinserted below. */
440  if (has_vforked)
441  {
442  /* Keep breakpoints list in sync. */
444  }
445 
446  if (info_verbose || debug_infrun)
447  {
448  /* Ensure that we have a process ptid. */
449  ptid_t process_ptid = pid_to_ptid (ptid_get_pid (child_ptid));
450 
453  _("Detaching after %s from child %s.\n"),
454  has_vforked ? "vfork" : "fork",
455  target_pid_to_str (process_ptid));
456  }
457  }
458  else
459  {
460  struct inferior *parent_inf, *child_inf;
461  struct cleanup *old_chain;
462 
463  /* Add process to GDB's tables. */
464  child_inf = add_inferior (ptid_get_pid (child_ptid));
465 
466  parent_inf = current_inferior ();
467  child_inf->attach_flag = parent_inf->attach_flag;
468  copy_terminal_info (child_inf, parent_inf);
469  child_inf->gdbarch = parent_inf->gdbarch;
470  copy_inferior_target_desc_info (child_inf, parent_inf);
471 
472  old_chain = save_inferior_ptid ();
474 
475  inferior_ptid = child_ptid;
477  child_inf->symfile_flags = SYMFILE_NO_READ;
478 
479  /* If this is a vfork child, then the address-space is
480  shared with the parent. */
481  if (has_vforked)
482  {
483  child_inf->pspace = parent_inf->pspace;
484  child_inf->aspace = parent_inf->aspace;
485 
486  /* The parent will be frozen until the child is done
487  with the shared region. Keep track of the
488  parent. */
489  child_inf->vfork_parent = parent_inf;
490  child_inf->pending_detach = 0;
491  parent_inf->vfork_child = child_inf;
492  parent_inf->pending_detach = 0;
493  }
494  else
495  {
496  child_inf->aspace = new_address_space ();
497  child_inf->pspace = add_program_space (child_inf->aspace);
498  child_inf->removable = 1;
499  set_current_program_space (child_inf->pspace);
500  clone_program_space (child_inf->pspace, parent_inf->pspace);
501 
502  /* Let the shared library layer (e.g., solib-svr4) learn
503  about this new process, relocate the cloned exec, pull
504  in shared libraries, and install the solib event
505  breakpoint. If a "cloned-VM" event was propagated
506  better throughout the core, this wouldn't be
507  required. */
509  }
510 
511  do_cleanups (old_chain);
512  }
513 
514  if (has_vforked)
515  {
516  struct inferior *parent_inf;
517 
518  parent_inf = current_inferior ();
519 
520  /* If we detached from the child, then we have to be careful
521  to not insert breakpoints in the parent until the child
522  is done with the shared memory region. However, if we're
523  staying attached to the child, then we can and should
524  insert breakpoints, so that we can debug it. A
525  subsequent child exec or exit is enough to know when does
526  the child stops using the parent's address space. */
527  parent_inf->waiting_for_vfork_done = detach_fork;
529  }
530  }
531  else
532  {
533  /* Follow the child. */
534  struct inferior *parent_inf, *child_inf;
535  struct program_space *parent_pspace;
536 
537  if (info_verbose || debug_infrun)
538  {
541  _("Attaching after %s %s to child %s.\n"),
542  target_pid_to_str (parent_ptid),
543  has_vforked ? "vfork" : "fork",
544  target_pid_to_str (child_ptid));
545  }
546 
547  /* Add the new inferior first, so that the target_detach below
548  doesn't unpush the target. */
549 
550  child_inf = add_inferior (ptid_get_pid (child_ptid));
551 
552  parent_inf = current_inferior ();
553  child_inf->attach_flag = parent_inf->attach_flag;
554  copy_terminal_info (child_inf, parent_inf);
555  child_inf->gdbarch = parent_inf->gdbarch;
556  copy_inferior_target_desc_info (child_inf, parent_inf);
557 
558  parent_pspace = parent_inf->pspace;
559 
560  /* If we're vforking, we want to hold on to the parent until the
561  child exits or execs. At child exec or exit time we can
562  remove the old breakpoints from the parent and detach or
563  resume debugging it. Otherwise, detach the parent now; we'll
564  want to reuse it's program/address spaces, but we can't set
565  them to the child before removing breakpoints from the
566  parent, otherwise, the breakpoints module could decide to
567  remove breakpoints from the wrong process (since they'd be
568  assigned to the same address space). */
569 
570  if (has_vforked)
571  {
572  gdb_assert (child_inf->vfork_parent == NULL);
573  gdb_assert (parent_inf->vfork_child == NULL);
574  child_inf->vfork_parent = parent_inf;
575  child_inf->pending_detach = 0;
576  parent_inf->vfork_child = child_inf;
577  parent_inf->pending_detach = detach_fork;
578  parent_inf->waiting_for_vfork_done = 0;
579  }
580  else if (detach_fork)
581  {
582  if (info_verbose || debug_infrun)
583  {
584  /* Ensure that we have a process ptid. */
585  ptid_t process_ptid = pid_to_ptid (ptid_get_pid (child_ptid));
586 
589  _("Detaching after fork from "
590  "child %s.\n"),
591  target_pid_to_str (process_ptid));
592  }
593 
594  target_detach (NULL, 0);
595  }
596 
597  /* Note that the detach above makes PARENT_INF dangling. */
598 
599  /* Add the child thread to the appropriate lists, and switch to
600  this new thread, before cloning the program space, and
601  informing the solib layer about this new process. */
602 
603  inferior_ptid = child_ptid;
605 
606  /* If this is a vfork child, then the address-space is shared
607  with the parent. If we detached from the parent, then we can
608  reuse the parent's program/address spaces. */
609  if (has_vforked || detach_fork)
610  {
611  child_inf->pspace = parent_pspace;
612  child_inf->aspace = child_inf->pspace->aspace;
613  }
614  else
615  {
616  child_inf->aspace = new_address_space ();
617  child_inf->pspace = add_program_space (child_inf->aspace);
618  child_inf->removable = 1;
619  child_inf->symfile_flags = SYMFILE_NO_READ;
620  set_current_program_space (child_inf->pspace);
621  clone_program_space (child_inf->pspace, parent_pspace);
622 
623  /* Let the shared library layer (e.g., solib-svr4) learn
624  about this new process, relocate the cloned exec, pull in
625  shared libraries, and install the solib event breakpoint.
626  If a "cloned-VM" event was propagated better throughout
627  the core, this wouldn't be required. */
629  }
630  }
631 
632  return target_follow_fork (follow_child, detach_fork);
633 }
634 
635 /* Tell the target to follow the fork we're stopped at. Returns true
636  if the inferior should be resumed; false, if the target for some
637  reason decided it's best not to resume. */
638 
639 static int
641 {
642  int follow_child = (follow_fork_mode_string == follow_fork_mode_child);
643  int should_resume = 1;
644  struct thread_info *tp;
645 
646  /* Copy user stepping state to the new inferior thread. FIXME: the
647  followed fork child thread should have a copy of most of the
648  parent thread structure's run control related fields, not just these.
649  Initialized to avoid "may be used uninitialized" warnings from gcc. */
650  struct breakpoint *step_resume_breakpoint = NULL;
651  struct breakpoint *exception_resume_breakpoint = NULL;
652  CORE_ADDR step_range_start = 0;
653  CORE_ADDR step_range_end = 0;
654  struct frame_id step_frame_id = { 0 };
655  struct interp *command_interp = NULL;
656 
657  if (!non_stop)
658  {
659  ptid_t wait_ptid;
660  struct target_waitstatus wait_status;
661 
662  /* Get the last target status returned by target_wait(). */
663  get_last_target_status (&wait_ptid, &wait_status);
664 
665  /* If not stopped at a fork event, then there's nothing else to
666  do. */
667  if (wait_status.kind != TARGET_WAITKIND_FORKED
668  && wait_status.kind != TARGET_WAITKIND_VFORKED)
669  return 1;
670 
671  /* Check if we switched over from WAIT_PTID, since the event was
672  reported. */
673  if (!ptid_equal (wait_ptid, minus_one_ptid)
674  && !ptid_equal (inferior_ptid, wait_ptid))
675  {
676  /* We did. Switch back to WAIT_PTID thread, to tell the
677  target to follow it (in either direction). We'll
678  afterwards refuse to resume, and inform the user what
679  happened. */
680  switch_to_thread (wait_ptid);
681  should_resume = 0;
682  }
683  }
684 
685  tp = inferior_thread ();
686 
687  /* If there were any forks/vforks that were caught and are now to be
688  followed, then do so now. */
689  switch (tp->pending_follow.kind)
690  {
693  {
694  ptid_t parent, child;
695 
696  /* If the user did a next/step, etc, over a fork call,
697  preserve the stepping state in the fork child. */
698  if (follow_child && should_resume)
699  {
700  step_resume_breakpoint = clone_momentary_breakpoint
702  step_range_start = tp->control.step_range_start;
703  step_range_end = tp->control.step_range_end;
704  step_frame_id = tp->control.step_frame_id;
705  exception_resume_breakpoint
707  command_interp = tp->control.command_interp;
708 
709  /* For now, delete the parent's sr breakpoint, otherwise,
710  parent/child sr breakpoints are considered duplicates,
711  and the child version will not be installed. Remove
712  this when the breakpoints module becomes aware of
713  inferiors and address spaces. */
715  tp->control.step_range_start = 0;
716  tp->control.step_range_end = 0;
719  tp->control.command_interp = NULL;
720  }
721 
722  parent = inferior_ptid;
723  child = tp->pending_follow.value.related_pid;
724 
725  /* Set up inferior(s) as specified by the caller, and tell the
726  target to do whatever is necessary to follow either parent
727  or child. */
728  if (follow_fork_inferior (follow_child, detach_fork))
729  {
730  /* Target refused to follow, or there's some other reason
731  we shouldn't resume. */
732  should_resume = 0;
733  }
734  else
735  {
736  /* This pending follow fork event is now handled, one way
737  or another. The previous selected thread may be gone
738  from the lists by now, but if it is still around, need
739  to clear the pending follow request. */
740  tp = find_thread_ptid (parent);
741  if (tp)
743 
744  /* This makes sure we don't try to apply the "Switched
745  over from WAIT_PID" logic above. */
747 
748  /* If we followed the child, switch to it... */
749  if (follow_child)
750  {
751  switch_to_thread (child);
752 
753  /* ... and preserve the stepping state, in case the
754  user was stepping over the fork call. */
755  if (should_resume)
756  {
757  tp = inferior_thread ();
759  = step_resume_breakpoint;
760  tp->control.step_range_start = step_range_start;
761  tp->control.step_range_end = step_range_end;
762  tp->control.step_frame_id = step_frame_id;
764  = exception_resume_breakpoint;
766  }
767  else
768  {
769  /* If we get here, it was because we're trying to
770  resume from a fork catchpoint, but, the user
771  has switched threads away from the thread that
772  forked. In that case, the resume command
773  issued is most likely not applicable to the
774  child, so just warn, and refuse to resume. */
775  warning (_("Not resuming: switched threads "
776  "before following fork child.\n"));
777  }
778 
779  /* Reset breakpoints in the child as appropriate. */
781  }
782  else
783  switch_to_thread (parent);
784  }
785  }
786  break;
788  /* Nothing to follow. */
789  break;
790  default:
791  internal_error (__FILE__, __LINE__,
792  "Unexpected pending_follow.kind %d\n",
793  tp->pending_follow.kind);
794  break;
795  }
796 
797  return should_resume;
798 }
799 
800 static void
802 {
803  struct thread_info *tp = inferior_thread ();
804 
805  /* Was there a step_resume breakpoint? (There was if the user
806  did a "next" at the fork() call.) If so, explicitly reset its
807  thread number. Cloned step_resume breakpoints are disabled on
808  creation, so enable it here now that it is associated with the
809  correct thread.
810 
811  step_resumes are a form of bp that are made to be per-thread.
812  Since we created the step_resume bp when the parent process
813  was being debugged, and now are switching to the child process,
814  from the breakpoint package's viewpoint, that's a switch of
815  "threads". We must update the bp's notion of which thread
816  it is for, or it'll be ignored when it triggers. */
817 
819  {
822  }
823 
824  /* Treat exception_resume breakpoints like step_resume breakpoints. */
826  {
829  }
830 
831  /* Reinsert all breakpoints in the child. The user may have set
832  breakpoints after catching the fork, in which case those
833  were never set in the child, but only in the parent. This makes
834  sure the inserted breakpoints match the breakpoint list. */
835 
838 }
839 
840 /* The child has exited or execed: resume threads of the parent the
841  user wanted to be executing. */
842 
843 static int
845  void *arg)
846 {
847  int pid = * (int *) arg;
848 
849  if (ptid_get_pid (thread->ptid) == pid
850  && is_running (thread->ptid)
851  && !is_executing (thread->ptid)
852  && !thread->stop_requested
853  && thread->suspend.stop_signal == GDB_SIGNAL_0)
854  {
855  if (debug_infrun)
857  "infrun: resuming vfork parent thread %s\n",
858  target_pid_to_str (thread->ptid));
859 
860  switch_to_thread (thread->ptid);
862  proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
863  }
864 
865  return 0;
866 }
867 
868 /* Called whenever we notice an exec or exit event, to handle
869  detaching or resuming a vfork parent. */
870 
871 static void
873 {
874  struct inferior *inf = current_inferior ();
875 
876  if (inf->vfork_parent)
877  {
878  int resume_parent = -1;
879 
880  /* This exec or exit marks the end of the shared memory region
881  between the parent and the child. If the user wanted to
882  detach from the parent, now is the time. */
883 
884  if (inf->vfork_parent->pending_detach)
885  {
886  struct thread_info *tp;
887  struct cleanup *old_chain;
888  struct program_space *pspace;
889  struct address_space *aspace;
890 
891  /* follow-fork child, detach-on-fork on. */
892 
893  inf->vfork_parent->pending_detach = 0;
894 
895  if (!exec)
896  {
897  /* If we're handling a child exit, then inferior_ptid
898  points at the inferior's pid, not to a thread. */
899  old_chain = save_inferior_ptid ();
902  }
903  else
904  old_chain = save_current_space_and_thread ();
905 
906  /* We're letting loose of the parent. */
908  switch_to_thread (tp->ptid);
909 
910  /* We're about to detach from the parent, which implicitly
911  removes breakpoints from its address space. There's a
912  catch here: we want to reuse the spaces for the child,
913  but, parent/child are still sharing the pspace at this
914  point, although the exec in reality makes the kernel give
915  the child a fresh set of new pages. The problem here is
916  that the breakpoints module being unaware of this, would
917  likely chose the child process to write to the parent
918  address space. Swapping the child temporarily away from
919  the spaces has the desired effect. Yes, this is "sort
920  of" a hack. */
921 
922  pspace = inf->pspace;
923  aspace = inf->aspace;
924  inf->aspace = NULL;
925  inf->pspace = NULL;
926 
927  if (debug_infrun || info_verbose)
928  {
930 
931  if (exec)
932  {
934  _("Detaching vfork parent process "
935  "%d after child exec.\n"),
936  inf->vfork_parent->pid);
937  }
938  else
939  {
941  _("Detaching vfork parent process "
942  "%d after child exit.\n"),
943  inf->vfork_parent->pid);
944  }
945  }
946 
947  target_detach (NULL, 0);
948 
949  /* Put it back. */
950  inf->pspace = pspace;
951  inf->aspace = aspace;
952 
953  do_cleanups (old_chain);
954  }
955  else if (exec)
956  {
957  /* We're staying attached to the parent, so, really give the
958  child a new address space. */
960  inf->aspace = inf->pspace->aspace;
961  inf->removable = 1;
963 
964  resume_parent = inf->vfork_parent->pid;
965 
966  /* Break the bonds. */
967  inf->vfork_parent->vfork_child = NULL;
968  }
969  else
970  {
971  struct cleanup *old_chain;
972  struct program_space *pspace;
973 
974  /* If this is a vfork child exiting, then the pspace and
975  aspaces were shared with the parent. Since we're
976  reporting the process exit, we'll be mourning all that is
977  found in the address space, and switching to null_ptid,
978  preparing to start a new inferior. But, since we don't
979  want to clobber the parent's address/program spaces, we
980  go ahead and create a new one for this exiting
981  inferior. */
982 
983  /* Switch to null_ptid, so that clone_program_space doesn't want
984  to read the selected frame of a dead process. */
985  old_chain = save_inferior_ptid ();
987 
988  /* This inferior is dead, so avoid giving the breakpoints
989  module the option to write through to it (cloning a
990  program space resets breakpoints). */
991  inf->aspace = NULL;
992  inf->pspace = NULL;
994  set_current_program_space (pspace);
995  inf->removable = 1;
997  clone_program_space (pspace, inf->vfork_parent->pspace);
998  inf->pspace = pspace;
999  inf->aspace = pspace->aspace;
1000 
1001  /* Put back inferior_ptid. We'll continue mourning this
1002  inferior. */
1003  do_cleanups (old_chain);
1004 
1005  resume_parent = inf->vfork_parent->pid;
1006  /* Break the bonds. */
1007  inf->vfork_parent->vfork_child = NULL;
1008  }
1009 
1010  inf->vfork_parent = NULL;
1011 
1013 
1014  if (non_stop && resume_parent != -1)
1015  {
1016  /* If the user wanted the parent to be running, let it go
1017  free now. */
1018  struct cleanup *old_chain = make_cleanup_restore_current_thread ();
1019 
1020  if (debug_infrun)
1022  "infrun: resuming vfork parent process %d\n",
1023  resume_parent);
1024 
1026 
1027  do_cleanups (old_chain);
1028  }
1029  }
1030 }
1031 
1032 /* Enum strings for "set|show follow-exec-mode". */
1033 
1034 static const char follow_exec_mode_new[] = "new";
1035 static const char follow_exec_mode_same[] = "same";
1036 static const char *const follow_exec_mode_names[] =
1037 {
1040  NULL,
1041 };
1042 
1044 static void
1045 show_follow_exec_mode_string (struct ui_file *file, int from_tty,
1046  struct cmd_list_element *c, const char *value)
1047 {
1048  fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"), value);
1049 }
1050 
1051 /* EXECD_PATHNAME is assumed to be non-NULL. */
1052 
1053 static void
1054 follow_exec (ptid_t ptid, char *execd_pathname)
1055 {
1056  struct thread_info *th, *tmp;
1057  struct inferior *inf = current_inferior ();
1058  int pid = ptid_get_pid (ptid);
1059 
1060  /* This is an exec event that we actually wish to pay attention to.
1061  Refresh our symbol table to the newly exec'd program, remove any
1062  momentary bp's, etc.
1063 
1064  If there are breakpoints, they aren't really inserted now,
1065  since the exec() transformed our inferior into a fresh set
1066  of instructions.
1067 
1068  We want to preserve symbolic breakpoints on the list, since
1069  we have hopes that they can be reset after the new a.out's
1070  symbol table is read.
1071 
1072  However, any "raw" breakpoints must be removed from the list
1073  (e.g., the solib bp's), since their address is probably invalid
1074  now.
1075 
1076  And, we DON'T want to call delete_breakpoints() here, since
1077  that may write the bp's "shadow contents" (the instruction
1078  value that was overwritten witha TRAP instruction). Since
1079  we now have a new a.out, those shadow contents aren't valid. */
1080 
1082 
1083  /* The target reports the exec event to the main thread, even if
1084  some other thread does the exec, and even if the main thread was
1085  stopped or already gone. We may still have non-leader threads of
1086  the process on our list. E.g., on targets that don't have thread
1087  exit events (like remote); or on native Linux in non-stop mode if
1088  there were only two threads in the inferior and the non-leader
1089  one is the one that execs (and nothing forces an update of the
1090  thread list up to here). When debugging remotely, it's best to
1091  avoid extra traffic, when possible, so avoid syncing the thread
1092  list with the target, and instead go ahead and delete all threads
1093  of the process but one that reported the event. Note this must
1094  be done before calling update_breakpoints_after_exec, as
1095  otherwise clearing the threads' resources would reference stale
1096  thread breakpoints -- it may have been one of these threads that
1097  stepped across the exec. We could just clear their stepping
1098  states, but as long as we're iterating, might as well delete
1099  them. Deleting them now rather than at the next user-visible
1100  stop provides a nicer sequence of events for user and MI
1101  notifications. */
1102  ALL_THREADS_SAFE (th, tmp)
1103  if (ptid_get_pid (th->ptid) == pid && !ptid_equal (th->ptid, ptid))
1104  delete_thread (th->ptid);
1105 
1106  /* We also need to clear any left over stale state for the
1107  leader/event thread. E.g., if there was any step-resume
1108  breakpoint or similar, it's gone now. We cannot truly
1109  step-to-next statement through an exec(). */
1110  th = inferior_thread ();
1111  th->control.step_resume_breakpoint = NULL;
1113  th->control.single_step_breakpoints = NULL;
1114  th->control.step_range_start = 0;
1115  th->control.step_range_end = 0;
1116 
1117  /* The user may have had the main thread held stopped in the
1118  previous image (e.g., schedlock on, or non-stop). Release
1119  it now. */
1120  th->stop_requested = 0;
1121 
1123 
1124  /* What is this a.out's name? */
1125  printf_unfiltered (_("%s is executing new program: %s\n"),
1127  execd_pathname);
1128 
1129  /* We've followed the inferior through an exec. Therefore, the
1130  inferior has essentially been killed & reborn. */
1131 
1133 
1135 
1136  if (*gdb_sysroot != '\0')
1137  {
1138  char *name = exec_file_find (execd_pathname, NULL);
1139 
1140  execd_pathname = alloca (strlen (name) + 1);
1141  strcpy (execd_pathname, name);
1142  xfree (name);
1143  }
1144 
1145  /* Reset the shared library package. This ensures that we get a
1146  shlib event when the child reaches "_start", at which point the
1147  dld will have had a chance to initialize the child. */
1148  /* Also, loading a symbol file below may trigger symbol lookups, and
1149  we don't want those to be satisfied by the libraries of the
1150  previous incarnation of this process. */
1151  no_shared_libraries (NULL, 0);
1152 
1153  if (follow_exec_mode_string == follow_exec_mode_new)
1154  {
1155  struct program_space *pspace;
1156 
1157  /* The user wants to keep the old inferior and program spaces
1158  around. Create a new fresh one, and switch to it. */
1159 
1160  inf = add_inferior (current_inferior ()->pid);
1162  inf->pspace = pspace;
1163  inf->aspace = pspace->aspace;
1164 
1166 
1167  set_current_inferior (inf);
1168  set_current_program_space (pspace);
1169  }
1170  else
1171  {
1172  /* The old description may no longer be fit for the new image.
1173  E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1174  old description; we'll read a new one below. No need to do
1175  this on "follow-exec-mode new", as the old inferior stays
1176  around (its description is later cleared/refetched on
1177  restart). */
1179  }
1180 
1182 
1183  /* That a.out is now the one to use. */
1184  exec_file_attach (execd_pathname, 0);
1185 
1186  /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE
1187  (Position Independent Executable) main symbol file will get applied by
1188  solib_create_inferior_hook below. breakpoint_re_set would fail to insert
1189  the breakpoints with the zero displacement. */
1190 
1191  symbol_file_add (execd_pathname,
1192  (inf->symfile_flags
1194  NULL, 0);
1195 
1196  if ((inf->symfile_flags & SYMFILE_NO_READ) == 0)
1198 
1199  /* If the target can specify a description, read it. Must do this
1200  after flipping to the new executable (because the target supplied
1201  description must be compatible with the executable's
1202  architecture, and the old executable may e.g., be 32-bit, while
1203  the new one 64-bit), and before anything involving memory or
1204  registers. */
1206 
1208 
1210 
1211  breakpoint_re_set ();
1212 
1213  /* Reinsert all breakpoints. (Those which were symbolic have
1214  been reset to the proper address in the new a.out, thanks
1215  to symbol_file_command...). */
1216  insert_breakpoints ();
1217 
1218  /* The next resume of this inferior should bring it to the shlib
1219  startup breakpoints. (If the user had also set bp's on
1220  "main" from the old (parent) process, then they'll auto-
1221  matically get reset there in the new process.). */
1222 }
1223 
1224 /* Info about an instruction that is being stepped over. */
1225 
1227 {
1228  /* If we're stepping past a breakpoint, this is the address space
1229  and address of the instruction the breakpoint is set at. We'll
1230  skip inserting all breakpoints here. Valid iff ASPACE is
1231  non-NULL. */
1234 
1235  /* The instruction being stepped over triggers a nonsteppable
1236  watchpoint. If true, we'll skip inserting watchpoints. */
1238 };
1239 
1240 /* The step-over info of the location that is being stepped over.
1241 
1242  Note that with async/breakpoint always-inserted mode, a user might
1243  set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1244  being stepped over. As setting a new breakpoint inserts all
1245  breakpoints, we need to make sure the breakpoint being stepped over
1246  isn't inserted then. We do that by only clearing the step-over
1247  info when the step-over is actually finished (or aborted).
1248 
1249  Presently GDB can only step over one breakpoint at any given time.
1250  Given threads that can't run code in the same address space as the
1251  breakpoint's can't really miss the breakpoint, GDB could be taught
1252  to step-over at most one breakpoint per address space (so this info
1253  could move to the address space object if/when GDB is extended).
1254  The set of breakpoints being stepped over will normally be much
1255  smaller than the set of all breakpoints, so a flag in the
1256  breakpoint location structure would be wasteful. A separate list
1257  also saves complexity and run-time, as otherwise we'd have to go
1258  through all breakpoint locations clearing their flag whenever we
1259  start a new sequence. Similar considerations weigh against storing
1260  this info in the thread object. Plus, not all step overs actually
1261  have breakpoint locations -- e.g., stepping past a single-step
1262  breakpoint, or stepping to complete a non-continuable
1263  watchpoint. */
1265 
1266 /* Record the address of the breakpoint/instruction we're currently
1267  stepping over. */
1268 
1269 static void
1272 {
1276 }
1277 
1278 /* Called when we're not longer stepping over a breakpoint / an
1279  instruction, so all breakpoints are free to be (re)inserted. */
1280 
1281 static void
1283 {
1284  step_over_info.aspace = NULL;
1285  step_over_info.address = 0;
1287 }
1288 
1289 /* See infrun.h. */
1290 
1291 int
1294 {
1295  return (step_over_info.aspace != NULL
1296  && breakpoint_address_match (aspace, address,
1299 }
1300 
1301 /* See infrun.h. */
1302 
1303 int
1305 {
1307 }
1308 
1309 /* Returns true if step-over info is valid. */
1310 
1311 static int
1313 {
1314  return (step_over_info.aspace != NULL
1316 }
1317 
1318 
1319 /* Displaced stepping. */
1320 
1321 /* In non-stop debugging mode, we must take special care to manage
1322  breakpoints properly; in particular, the traditional strategy for
1323  stepping a thread past a breakpoint it has hit is unsuitable.
1324  'Displaced stepping' is a tactic for stepping one thread past a
1325  breakpoint it has hit while ensuring that other threads running
1326  concurrently will hit the breakpoint as they should.
1327 
1328  The traditional way to step a thread T off a breakpoint in a
1329  multi-threaded program in all-stop mode is as follows:
1330 
1331  a0) Initially, all threads are stopped, and breakpoints are not
1332  inserted.
1333  a1) We single-step T, leaving breakpoints uninserted.
1334  a2) We insert breakpoints, and resume all threads.
1335 
1336  In non-stop debugging, however, this strategy is unsuitable: we
1337  don't want to have to stop all threads in the system in order to
1338  continue or step T past a breakpoint. Instead, we use displaced
1339  stepping:
1340 
1341  n0) Initially, T is stopped, other threads are running, and
1342  breakpoints are inserted.
1343  n1) We copy the instruction "under" the breakpoint to a separate
1344  location, outside the main code stream, making any adjustments
1345  to the instruction, register, and memory state as directed by
1346  T's architecture.
1347  n2) We single-step T over the instruction at its new location.
1348  n3) We adjust the resulting register and memory state as directed
1349  by T's architecture. This includes resetting T's PC to point
1350  back into the main instruction stream.
1351  n4) We resume T.
1352 
1353  This approach depends on the following gdbarch methods:
1354 
1355  - gdbarch_max_insn_length and gdbarch_displaced_step_location
1356  indicate where to copy the instruction, and how much space must
1357  be reserved there. We use these in step n1.
1358 
1359  - gdbarch_displaced_step_copy_insn copies a instruction to a new
1360  address, and makes any necessary adjustments to the instruction,
1361  register contents, and memory. We use this in step n1.
1362 
1363  - gdbarch_displaced_step_fixup adjusts registers and memory after
1364  we have successfuly single-stepped the instruction, to yield the
1365  same effect the instruction would have had if we had executed it
1366  at its original address. We use this in step n3.
1367 
1368  - gdbarch_displaced_step_free_closure provides cleanup.
1369 
1370  The gdbarch_displaced_step_copy_insn and
1371  gdbarch_displaced_step_fixup functions must be written so that
1372  copying an instruction with gdbarch_displaced_step_copy_insn,
1373  single-stepping across the copied instruction, and then applying
1374  gdbarch_displaced_insn_fixup should have the same effects on the
1375  thread's memory and registers as stepping the instruction in place
1376  would have. Exactly which responsibilities fall to the copy and
1377  which fall to the fixup is up to the author of those functions.
1378 
1379  See the comments in gdbarch.sh for details.
1380 
1381  Note that displaced stepping and software single-step cannot
1382  currently be used in combination, although with some care I think
1383  they could be made to. Software single-step works by placing
1384  breakpoints on all possible subsequent instructions; if the
1385  displaced instruction is a PC-relative jump, those breakpoints
1386  could fall in very strange places --- on pages that aren't
1387  executable, or at addresses that are not proper instruction
1388  boundaries. (We do generally let other threads run while we wait
1389  to hit the software single-step breakpoint, and they might
1390  encounter such a corrupted instruction.) One way to work around
1391  this would be to have gdbarch_displaced_step_copy_insn fully
1392  simulate the effect of PC-relative instructions (and return NULL)
1393  on architectures that use software single-stepping.
1394 
1395  In non-stop mode, we can have independent and simultaneous step
1396  requests, so more than one thread may need to simultaneously step
1397  over a breakpoint. The current implementation assumes there is
1398  only one scratch space per process. In this case, we have to
1399  serialize access to the scratch space. If thread A wants to step
1400  over a breakpoint, but we are currently waiting for some other
1401  thread to complete a displaced step, we leave thread A stopped and
1402  place it in the displaced_step_request_queue. Whenever a displaced
1403  step finishes, we pick the next thread in the queue and start a new
1404  displaced step operation on it. See displaced_step_prepare and
1405  displaced_step_fixup for details. */
1406 
1408 {
1411 };
1412 
1413 /* Per-inferior displaced stepping state. */
1415 {
1416  /* Pointer to next in linked list. */
1418 
1419  /* The process this displaced step state refers to. */
1420  int pid;
1421 
1422  /* A queue of pending displaced stepping requests. One entry per
1423  thread that needs to do a displaced step. */
1425 
1426  /* If this is not null_ptid, this is the thread carrying out a
1427  displaced single-step in process PID. This thread's state will
1428  require fixing up once it has completed its step. */
1430 
1431  /* The architecture the thread had when we stepped it. */
1433 
1434  /* The closure provided gdbarch_displaced_step_copy_insn, to be used
1435  for post-step cleanup. */
1437 
1438  /* The address of the original instruction, and the copy we
1439  made. */
1441 
1442  /* Saved contents of copy area. */
1444 };
1445 
1446 /* The list of states of processes involved in displaced stepping
1447  presently. */
1449 
1450 /* Get the displaced stepping state of process PID. */
1451 
1452 static struct displaced_step_inferior_state *
1454 {
1455  struct displaced_step_inferior_state *state;
1456 
1457  for (state = displaced_step_inferior_states;
1458  state != NULL;
1459  state = state->next)
1460  if (state->pid == pid)
1461  return state;
1462 
1463  return NULL;
1464 }
1465 
1466 /* Return true if process PID has a thread doing a displaced step. */
1467 
1468 static int
1470 {
1471  struct displaced_step_inferior_state *displaced;
1472 
1473  displaced = get_displaced_stepping_state (pid);
1474  if (displaced != NULL && !ptid_equal (displaced->step_ptid, null_ptid))
1475  return 1;
1476 
1477  return 0;
1478 }
1479 
1480 /* Add a new displaced stepping state for process PID to the displaced
1481  stepping state list, or return a pointer to an already existing
1482  entry, if it already exists. Never returns NULL. */
1483 
1484 static struct displaced_step_inferior_state *
1486 {
1487  struct displaced_step_inferior_state *state;
1488 
1489  for (state = displaced_step_inferior_states;
1490  state != NULL;
1491  state = state->next)
1492  if (state->pid == pid)
1493  return state;
1494 
1495  state = xcalloc (1, sizeof (*state));
1496  state->pid = pid;
1498  displaced_step_inferior_states = state;
1499 
1500  return state;
1501 }
1502 
1503 /* If inferior is in displaced stepping, and ADDR equals to starting address
1504  of copy area, return corresponding displaced_step_closure. Otherwise,
1505  return NULL. */
1506 
1507 struct displaced_step_closure*
1509 {
1510  struct displaced_step_inferior_state *displaced
1512 
1513  /* If checking the mode of displaced instruction in copy area. */
1514  if (displaced && !ptid_equal (displaced->step_ptid, null_ptid)
1515  && (displaced->step_copy == addr))
1516  return displaced->step_closure;
1517 
1518  return NULL;
1519 }
1520 
1521 /* Remove the displaced stepping state of process PID. */
1522 
1523 static void
1525 {
1526  struct displaced_step_inferior_state *it, **prev_next_p;
1527 
1528  gdb_assert (pid != 0);
1529 
1531  prev_next_p = &displaced_step_inferior_states;
1532  while (it)
1533  {
1534  if (it->pid == pid)
1535  {
1536  *prev_next_p = it->next;
1537  xfree (it);
1538  return;
1539  }
1540 
1541  prev_next_p = &it->next;
1542  it = *prev_next_p;
1543  }
1544 }
1545 
1546 static void
1548 {
1550 }
1551 
1552 /* If ON, and the architecture supports it, GDB will use displaced
1553  stepping to step over breakpoints. If OFF, or if the architecture
1554  doesn't support it, GDB will instead use the traditional
1555  hold-and-step approach. If AUTO (which is the default), GDB will
1556  decide which technique to use to step over breakpoints depending on
1557  which of all-stop or non-stop mode is active --- displaced stepping
1558  in non-stop mode; hold-and-step in all-stop mode. */
1559 
1561 
1562 static void
1563 show_can_use_displaced_stepping (struct ui_file *file, int from_tty,
1564  struct cmd_list_element *c,
1565  const char *value)
1566 {
1567  if (can_use_displaced_stepping == AUTO_BOOLEAN_AUTO)
1568  fprintf_filtered (file,
1569  _("Debugger's willingness to use displaced stepping "
1570  "to step over breakpoints is %s (currently %s).\n"),
1571  value, non_stop ? "on" : "off");
1572  else
1573  fprintf_filtered (file,
1574  _("Debugger's willingness to use displaced stepping "
1575  "to step over breakpoints is %s.\n"), value);
1576 }
1577 
1578 /* Return non-zero if displaced stepping can/should be used to step
1579  over breakpoints. */
1580 
1581 static int
1583 {
1584  return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO && non_stop)
1585  || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
1587  && find_record_target () == NULL);
1588 }
1589 
1590 /* Clean out any stray displaced stepping state. */
1591 static void
1593 {
1594  /* Indicate that there is no cleanup pending. */
1595  displaced->step_ptid = null_ptid;
1596 
1597  if (displaced->step_closure)
1598  {
1600  displaced->step_closure);
1601  displaced->step_closure = NULL;
1602  }
1603 }
1604 
1605 static void
1607 {
1608  struct displaced_step_inferior_state *state = arg;
1609 
1610  displaced_step_clear (state);
1611 }
1612 
1613 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */
1614 void
1616  const gdb_byte *buf,
1617  size_t len)
1618 {
1619  int i;
1620 
1621  for (i = 0; i < len; i++)
1622  fprintf_unfiltered (file, "%02x ", buf[i]);
1623  fputs_unfiltered ("\n", file);
1624 }
1625 
1626 /* Prepare to single-step, using displaced stepping.
1627 
1628  Note that we cannot use displaced stepping when we have a signal to
1629  deliver. If we have a signal to deliver and an instruction to step
1630  over, then after the step, there will be no indication from the
1631  target whether the thread entered a signal handler or ignored the
1632  signal and stepped over the instruction successfully --- both cases
1633  result in a simple SIGTRAP. In the first case we mustn't do a
1634  fixup, and in the second case we must --- but we can't tell which.
1635  Comments in the code for 'random signals' in handle_inferior_event
1636  explain how we handle this case instead.
1637 
1638  Returns 1 if preparing was successful -- this thread is going to be
1639  stepped now; or 0 if displaced stepping this thread got queued. */
1640 static int
1642 {
1643  struct cleanup *old_cleanups, *ignore_cleanups;
1644  struct thread_info *tp = find_thread_ptid (ptid);
1645  struct regcache *regcache = get_thread_regcache (ptid);
1646  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1647  CORE_ADDR original, copy;
1648  ULONGEST len;
1649  struct displaced_step_closure *closure;
1650  struct displaced_step_inferior_state *displaced;
1651  int status;
1652 
1653  /* We should never reach this function if the architecture does not
1654  support displaced stepping. */
1656 
1657  /* Disable range stepping while executing in the scratch pad. We
1658  want a single-step even if executing the displaced instruction in
1659  the scratch buffer lands within the stepping range (e.g., a
1660  jump/branch). */
1661  tp->control.may_range_step = 0;
1662 
1663  /* We have to displaced step one thread at a time, as we only have
1664  access to a single scratch space per inferior. */
1665 
1666  displaced = add_displaced_stepping_state (ptid_get_pid (ptid));
1667 
1668  if (!ptid_equal (displaced->step_ptid, null_ptid))
1669  {
1670  /* Already waiting for a displaced step to finish. Defer this
1671  request and place in queue. */
1672  struct displaced_step_request *req, *new_req;
1673 
1674  if (debug_displaced)
1676  "displaced: defering step of %s\n",
1677  target_pid_to_str (ptid));
1678 
1679  new_req = xmalloc (sizeof (*new_req));
1680  new_req->ptid = ptid;
1681  new_req->next = NULL;
1682 
1683  if (displaced->step_request_queue)
1684  {
1685  for (req = displaced->step_request_queue;
1686  req && req->next;
1687  req = req->next)
1688  ;
1689  req->next = new_req;
1690  }
1691  else
1692  displaced->step_request_queue = new_req;
1693 
1694  return 0;
1695  }
1696  else
1697  {
1698  if (debug_displaced)
1700  "displaced: stepping %s now\n",
1701  target_pid_to_str (ptid));
1702  }
1703 
1704  displaced_step_clear (displaced);
1705 
1706  old_cleanups = save_inferior_ptid ();
1707  inferior_ptid = ptid;
1708 
1709  original = regcache_read_pc (regcache);
1710 
1711  copy = gdbarch_displaced_step_location (gdbarch);
1712  len = gdbarch_max_insn_length (gdbarch);
1713 
1714  /* Save the original contents of the copy area. */
1715  displaced->step_saved_copy = xmalloc (len);
1716  ignore_cleanups = make_cleanup (free_current_contents,
1717  &displaced->step_saved_copy);
1718  status = target_read_memory (copy, displaced->step_saved_copy, len);
1719  if (status != 0)
1721  _("Error accessing memory address %s (%s) for "
1722  "displaced-stepping scratch space."),
1723  paddress (gdbarch, copy), safe_strerror (status));
1724  if (debug_displaced)
1725  {
1726  fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
1727  paddress (gdbarch, copy));
1729  displaced->step_saved_copy,
1730  len);
1731  };
1732 
1733  closure = gdbarch_displaced_step_copy_insn (gdbarch,
1734  original, copy, regcache);
1735 
1736  /* We don't support the fully-simulated case at present. */
1737  gdb_assert (closure);
1738 
1739  /* Save the information we need to fix things up if the step
1740  succeeds. */
1741  displaced->step_ptid = ptid;
1742  displaced->step_gdbarch = gdbarch;
1743  displaced->step_closure = closure;
1744  displaced->step_original = original;
1745  displaced->step_copy = copy;
1746 
1748 
1749  /* Resume execution at the copy. */
1750  regcache_write_pc (regcache, copy);
1751 
1752  discard_cleanups (ignore_cleanups);
1753 
1754  do_cleanups (old_cleanups);
1755 
1756  if (debug_displaced)
1757  fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
1758  paddress (gdbarch, copy));
1759 
1760  return 1;
1761 }
1762 
1763 static void
1765  const gdb_byte *myaddr, int len)
1766 {
1767  struct cleanup *ptid_cleanup = save_inferior_ptid ();
1768 
1769  inferior_ptid = ptid;
1770  write_memory (memaddr, myaddr, len);
1771  do_cleanups (ptid_cleanup);
1772 }
1773 
1774 /* Restore the contents of the copy area for thread PTID. */
1775 
1776 static void
1778  ptid_t ptid)
1779 {
1781 
1782  write_memory_ptid (ptid, displaced->step_copy,
1783  displaced->step_saved_copy, len);
1784  if (debug_displaced)
1785  fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n",
1786  target_pid_to_str (ptid),
1787  paddress (displaced->step_gdbarch,
1788  displaced->step_copy));
1789 }
1790 
1791 static void
1792 displaced_step_fixup (ptid_t event_ptid, enum gdb_signal signal)
1793 {
1794  struct cleanup *old_cleanups;
1795  struct displaced_step_inferior_state *displaced
1796  = get_displaced_stepping_state (ptid_get_pid (event_ptid));
1797 
1798  /* Was any thread of this process doing a displaced step? */
1799  if (displaced == NULL)
1800  return;
1801 
1802  /* Was this event for the pid we displaced? */
1803  if (ptid_equal (displaced->step_ptid, null_ptid)
1804  || ! ptid_equal (displaced->step_ptid, event_ptid))
1805  return;
1806 
1807  old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);
1808 
1809  displaced_step_restore (displaced, displaced->step_ptid);
1810 
1811  /* Fixup may need to read memory/registers. Switch to the thread
1812  that we're fixing up. Also, target_stopped_by_watchpoint checks
1813  the current thread. */
1814  switch_to_thread (event_ptid);
1815 
1816  /* Did the instruction complete successfully? */
1817  if (signal == GDB_SIGNAL_TRAP
1821  {
1822  /* Fix up the resulting state. */
1824  displaced->step_closure,
1825  displaced->step_original,
1826  displaced->step_copy,
1827  get_thread_regcache (displaced->step_ptid));
1828  }
1829  else
1830  {
1831  /* Since the instruction didn't complete, all we can do is
1832  relocate the PC. */
1833  struct regcache *regcache = get_thread_regcache (event_ptid);
1834  CORE_ADDR pc = regcache_read_pc (regcache);
1835 
1836  pc = displaced->step_original + (pc - displaced->step_copy);
1837  regcache_write_pc (regcache, pc);
1838  }
1839 
1840  do_cleanups (old_cleanups);
1841 
1842  displaced->step_ptid = null_ptid;
1843 
1844  /* Are there any pending displaced stepping requests? If so, run
1845  one now. Leave the state object around, since we're likely to
1846  need it again soon. */
1847  while (displaced->step_request_queue)
1848  {
1849  struct displaced_step_request *head;
1850  ptid_t ptid;
1851  struct regcache *regcache;
1852  struct gdbarch *gdbarch;
1853  CORE_ADDR actual_pc;
1854  struct address_space *aspace;
1855 
1856  head = displaced->step_request_queue;
1857  ptid = head->ptid;
1858  displaced->step_request_queue = head->next;
1859  xfree (head);
1860 
1861  context_switch (ptid);
1862 
1863  regcache = get_thread_regcache (ptid);
1864  actual_pc = regcache_read_pc (regcache);
1865  aspace = get_regcache_aspace (regcache);
1866  gdbarch = get_regcache_arch (regcache);
1867 
1868  if (breakpoint_here_p (aspace, actual_pc))
1869  {
1870  if (debug_displaced)
1872  "displaced: stepping queued %s now\n",
1873  target_pid_to_str (ptid));
1874 
1875  displaced_step_prepare (ptid);
1876 
1877  if (debug_displaced)
1878  {
1879  CORE_ADDR actual_pc = regcache_read_pc (regcache);
1880  gdb_byte buf[4];
1881 
1882  fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
1883  paddress (gdbarch, actual_pc));
1884  read_memory (actual_pc, buf, sizeof (buf));
1885  displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
1886  }
1887 
1889  displaced->step_closure))
1890  target_resume (ptid, 1, GDB_SIGNAL_0);
1891  else
1892  target_resume (ptid, 0, GDB_SIGNAL_0);
1893 
1894  /* Done, we're stepping a thread. */
1895  break;
1896  }
1897  else
1898  {
1899  int step;
1900  struct thread_info *tp = inferior_thread ();
1901 
1902  /* The breakpoint we were sitting under has since been
1903  removed. */
1904  tp->control.trap_expected = 0;
1905 
1906  /* Go back to what we were trying to do. */
1907  step = currently_stepping (tp);
1908 
1909  if (step)
1910  step = maybe_software_singlestep (gdbarch, actual_pc);
1911 
1912  if (debug_displaced)
1914  "displaced: breakpoint is gone: %s, step(%d)\n",
1915  target_pid_to_str (tp->ptid), step);
1916 
1917  target_resume (ptid, step, GDB_SIGNAL_0);
1918  tp->suspend.stop_signal = GDB_SIGNAL_0;
1919 
1920  /* This request was discarded. See if there's any other
1921  thread waiting for its turn. */
1922  }
1923  }
1924 }
1925 
1926 /* Update global variables holding ptids to hold NEW_PTID if they were
1927  holding OLD_PTID. */
1928 static void
1930 {
1931  struct displaced_step_request *it;
1932  struct displaced_step_inferior_state *displaced;
1933 
1934  if (ptid_equal (inferior_ptid, old_ptid))
1935  inferior_ptid = new_ptid;
1936 
1937  for (displaced = displaced_step_inferior_states;
1938  displaced;
1939  displaced = displaced->next)
1940  {
1941  if (ptid_equal (displaced->step_ptid, old_ptid))
1942  displaced->step_ptid = new_ptid;
1943 
1944  for (it = displaced->step_request_queue; it; it = it->next)
1945  if (ptid_equal (it->ptid, old_ptid))
1946  it->ptid = new_ptid;
1947  }
1948 }
1949 
1950 
1951 /* Resuming. */
1952 
1953 /* Things to clean up if we QUIT out of resume (). */
1954 static void
1956 {
1959 
1960  normal_stop ();
1961 }
1962 
1963 static const char schedlock_off[] = "off";
1964 static const char schedlock_on[] = "on";
1965 static const char schedlock_step[] = "step";
1966 static const char *const scheduler_enums[] = {
1967  schedlock_off,
1968  schedlock_on,
1970  NULL
1971 };
1972 static const char *scheduler_mode = schedlock_off;
1973 static void
1974 show_scheduler_mode (struct ui_file *file, int from_tty,
1975  struct cmd_list_element *c, const char *value)
1976 {
1977  fprintf_filtered (file,
1978  _("Mode for locking scheduler "
1979  "during execution is \"%s\".\n"),
1980  value);
1981 }
1982 
1983 static void
1984 set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c)
1985 {
1987  {
1988  scheduler_mode = schedlock_off;
1989  error (_("Target '%s' cannot support this command."), target_shortname);
1990  }
1991 }
1992 
1993 /* True if execution commands resume all threads of all processes by
1994  default; otherwise, resume only threads of the current inferior
1995  process. */
1996 int sched_multi = 0;
1997 
1998 /* Try to setup for software single stepping over the specified location.
1999  Return 1 if target_resume() should use hardware single step.
2000 
2001  GDBARCH the current gdbarch.
2002  PC the location to step over. */
2003 
2004 static int
2006 {
2007  int hw_step = 1;
2008 
2009  if (execution_direction == EXEC_FORWARD
2010  && gdbarch_software_single_step_p (gdbarch)
2012  {
2013  hw_step = 0;
2014  }
2015  return hw_step;
2016 }
2017 
2018 /* See infrun.h. */
2019 
2020 ptid_t
2022 {
2023  ptid_t resume_ptid;
2024 
2025  if (non_stop)
2026  {
2027  /* With non-stop mode on, threads are always handled
2028  individually. */
2029  resume_ptid = inferior_ptid;
2030  }
2031  else if ((scheduler_mode == schedlock_on)
2032  || (scheduler_mode == schedlock_step && step))
2033  {
2034  /* User-settable 'scheduler' mode requires solo thread
2035  resume. */
2036  resume_ptid = inferior_ptid;
2037  }
2038  else if (!sched_multi && target_supports_multi_process ())
2039  {
2040  /* Resume all threads of the current process (and none of other
2041  processes). */
2042  resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
2043  }
2044  else
2045  {
2046  /* Resume all threads of all processes. */
2047  resume_ptid = RESUME_ALL;
2048  }
2049 
2050  return resume_ptid;
2051 }
2052 
2053 /* Wrapper for target_resume, that handles infrun-specific
2054  bookkeeping. */
2055 
2056 static void
2057 do_target_resume (ptid_t resume_ptid, int step, enum gdb_signal sig)
2058 {
2059  struct thread_info *tp = inferior_thread ();
2060 
2061  /* Install inferior's terminal modes. */
2063 
2064  /* Avoid confusing the next resume, if the next stop/resume
2065  happens to apply to another thread. */
2066  tp->suspend.stop_signal = GDB_SIGNAL_0;
2067 
2068  /* Advise target which signals may be handled silently.
2069 
2070  If we have removed breakpoints because we are stepping over one
2071  in-line (in any thread), we need to receive all signals to avoid
2072  accidentally skipping a breakpoint during execution of a signal
2073  handler.
2074 
2075  Likewise if we're displaced stepping, otherwise a trap for a
2076  breakpoint in a signal handler might be confused with the
2077  displaced step finishing. We don't make the displaced_step_fixup
2078  step distinguish the cases instead, because:
2079 
2080  - a backtrace while stopped in the signal handler would show the
2081  scratch pad as frame older than the signal handler, instead of
2082  the real mainline code.
2083 
2084  - when the thread is later resumed, the signal handler would
2085  return to the scratch pad area, which would no longer be
2086  valid. */
2087  if (step_over_info_valid_p ()
2089  target_pass_signals (0, NULL);
2090  else
2091  target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
2092 
2093  target_resume (resume_ptid, step, sig);
2094 }
2095 
2096 /* Resume the inferior, but allow a QUIT. This is useful if the user
2097  wants to interrupt some lengthy single-stepping operation
2098  (for child processes, the SIGINT goes to the inferior, and so
2099  we get a SIGINT random_signal, but for remote debugging and perhaps
2100  other targets, that's not true).
2101 
2102  SIG is the signal to give the inferior (zero for none). */
2103 void
2104 resume (enum gdb_signal sig)
2105 {
2106  struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
2107  struct regcache *regcache = get_current_regcache ();
2108  struct gdbarch *gdbarch = get_regcache_arch (regcache);
2109  struct thread_info *tp = inferior_thread ();
2110  CORE_ADDR pc = regcache_read_pc (regcache);
2111  struct address_space *aspace = get_regcache_aspace (regcache);
2112  ptid_t resume_ptid;
2113  /* This represents the user's step vs continue request. When
2114  deciding whether "set scheduler-locking step" applies, it's the
2115  user's intention that counts. */
2116  const int user_step = tp->control.stepping_command;
2117  /* This represents what we'll actually request the target to do.
2118  This can decay from a step to a continue, if e.g., we need to
2119  implement single-stepping with breakpoints (software
2120  single-step). */
2121  int step;
2122 
2123  tp->stepped_breakpoint = 0;
2124 
2125  QUIT;
2126 
2127  /* Depends on stepped_breakpoint. */
2128  step = currently_stepping (tp);
2129 
2130  if (current_inferior ()->waiting_for_vfork_done)
2131  {
2132  /* Don't try to single-step a vfork parent that is waiting for
2133  the child to get out of the shared memory region (by exec'ing
2134  or exiting). This is particularly important on software
2135  single-step archs, as the child process would trip on the
2136  software single step breakpoint inserted for the parent
2137  process. Since the parent will not actually execute any
2138  instruction until the child is out of the shared region (such
2139  are vfork's semantics), it is safe to simply continue it.
2140  Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2141  the parent, and tell it to `keep_going', which automatically
2142  re-sets it stepping. */
2143  if (debug_infrun)
2145  "infrun: resume : clear step\n");
2146  step = 0;
2147  }
2148 
2149  if (debug_infrun)
2151  "infrun: resume (step=%d, signal=%s), "
2152  "trap_expected=%d, current thread [%s] at %s\n",
2153  step, gdb_signal_to_symbol_string (sig),
2154  tp->control.trap_expected,
2156  paddress (gdbarch, pc));
2157 
2158  /* Normally, by the time we reach `resume', the breakpoints are either
2159  removed or inserted, as appropriate. The exception is if we're sitting
2160  at a permanent breakpoint; we need to step over it, but permanent
2161  breakpoints can't be removed. So we have to test for it here. */
2162  if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here)
2163  {
2164  if (sig != GDB_SIGNAL_0)
2165  {
2166  /* We have a signal to pass to the inferior. The resume
2167  may, or may not take us to the signal handler. If this
2168  is a step, we'll need to stop in the signal handler, if
2169  there's one, (if the target supports stepping into
2170  handlers), or in the next mainline instruction, if
2171  there's no handler. If this is a continue, we need to be
2172  sure to run the handler with all breakpoints inserted.
2173  In all cases, set a breakpoint at the current address
2174  (where the handler returns to), and once that breakpoint
2175  is hit, resume skipping the permanent breakpoint. If
2176  that breakpoint isn't hit, then we've stepped into the
2177  signal handler (or hit some other event). We'll delete
2178  the step-resume breakpoint then. */
2179 
2180  if (debug_infrun)
2182  "infrun: resume: skipping permanent breakpoint, "
2183  "deliver signal first\n");
2184 
2186  tp->control.trap_expected = 0;
2187 
2188  if (tp->control.step_resume_breakpoint == NULL)
2189  {
2190  /* Set a "high-priority" step-resume, as we don't want
2191  user breakpoints at PC to trigger (again) when this
2192  hits. */
2195 
2197  }
2198 
2199  insert_breakpoints ();
2200  }
2201  else
2202  {
2203  /* There's no signal to pass, we can go ahead and skip the
2204  permanent breakpoint manually. */
2205  if (debug_infrun)
2207  "infrun: resume: skipping permanent breakpoint\n");
2208  gdbarch_skip_permanent_breakpoint (gdbarch, regcache);
2209  /* Update pc to reflect the new address from which we will
2210  execute instructions. */
2211  pc = regcache_read_pc (regcache);
2212 
2213  if (step)
2214  {
2215  /* We've already advanced the PC, so the stepping part
2216  is done. Now we need to arrange for a trap to be
2217  reported to handle_inferior_event. Set a breakpoint
2218  at the current PC, and run to it. Don't update
2219  prev_pc, because if we end in
2220  switch_back_to_stepped_thread, we want the "expected
2221  thread advanced also" branch to be taken. IOW, we
2222  don't want this thread to step further from PC
2223  (overstep). */
2225  insert_single_step_breakpoint (gdbarch, aspace, pc);
2226  insert_breakpoints ();
2227 
2228  resume_ptid = user_visible_resume_ptid (user_step);
2229  do_target_resume (resume_ptid, 0, GDB_SIGNAL_0);
2230  discard_cleanups (old_cleanups);
2231  return;
2232  }
2233  }
2234  }
2235 
2236  /* If we have a breakpoint to step over, make sure to do a single
2237  step only. Same if we have software watchpoints. */
2239  tp->control.may_range_step = 0;
2240 
2241  /* If enabled, step over breakpoints by executing a copy of the
2242  instruction at a different address.
2243 
2244  We can't use displaced stepping when we have a signal to deliver;
2245  the comments for displaced_step_prepare explain why. The
2246  comments in the handle_inferior event for dealing with 'random
2247  signals' explain what we do instead.
2248 
2249  We can't use displaced stepping when we are waiting for vfork_done
2250  event, displaced stepping breaks the vfork child similarly as single
2251  step software breakpoint. */
2252  if (use_displaced_stepping (gdbarch)
2253  && tp->control.trap_expected
2254  && !step_over_info_valid_p ()
2255  && sig == GDB_SIGNAL_0
2256  && !current_inferior ()->waiting_for_vfork_done)
2257  {
2258  struct displaced_step_inferior_state *displaced;
2259 
2261  {
2262  /* Got placed in displaced stepping queue. Will be resumed
2263  later when all the currently queued displaced stepping
2264  requests finish. The thread is not executing at this
2265  point, and the call to set_executing will be made later.
2266  But we need to call set_running here, since from the
2267  user/frontend's point of view, threads were set running. */
2268  set_running (user_visible_resume_ptid (user_step), 1);
2269  discard_cleanups (old_cleanups);
2270  return;
2271  }
2272 
2273  /* Update pc to reflect the new address from which we will execute
2274  instructions due to displaced stepping. */
2276 
2278  step = gdbarch_displaced_step_hw_singlestep (gdbarch,
2279  displaced->step_closure);
2280  }
2281 
2282  /* Do we need to do it the hard way, w/temp breakpoints? */
2283  else if (step)
2284  step = maybe_software_singlestep (gdbarch, pc);
2285 
2286  /* Currently, our software single-step implementation leads to different
2287  results than hardware single-stepping in one situation: when stepping
2288  into delivering a signal which has an associated signal handler,
2289  hardware single-step will stop at the first instruction of the handler,
2290  while software single-step will simply skip execution of the handler.
2291 
2292  For now, this difference in behavior is accepted since there is no
2293  easy way to actually implement single-stepping into a signal handler
2294  without kernel support.
2295 
2296  However, there is one scenario where this difference leads to follow-on
2297  problems: if we're stepping off a breakpoint by removing all breakpoints
2298  and then single-stepping. In this case, the software single-step
2299  behavior means that even if there is a *breakpoint* in the signal
2300  handler, GDB still would not stop.
2301 
2302  Fortunately, we can at least fix this particular issue. We detect
2303  here the case where we are about to deliver a signal while software
2304  single-stepping with breakpoints removed. In this situation, we
2305  revert the decisions to remove all breakpoints and insert single-
2306  step breakpoints, and instead we install a step-resume breakpoint
2307  at the current address, deliver the signal without stepping, and
2308  once we arrive back at the step-resume breakpoint, actually step
2309  over the breakpoint we originally wanted to step over. */
2311  && sig != GDB_SIGNAL_0
2312  && step_over_info_valid_p ())
2313  {
2314  /* If we have nested signals or a pending signal is delivered
2315  immediately after a handler returns, might might already have
2316  a step-resume breakpoint set on the earlier handler. We cannot
2317  set another step-resume breakpoint; just continue on until the
2318  original breakpoint is hit. */
2319  if (tp->control.step_resume_breakpoint == NULL)
2320  {
2323  }
2324 
2326 
2328  tp->control.trap_expected = 0;
2329 
2330  insert_breakpoints ();
2331  }
2332 
2333  /* If STEP is set, it's a request to use hardware stepping
2334  facilities. But in that case, we should never
2335  use singlestep breakpoint. */
2337 
2338  /* Decide the set of threads to ask the target to resume. Start
2339  by assuming everything will be resumed, than narrow the set
2340  by applying increasingly restricting conditions. */
2341  resume_ptid = user_visible_resume_ptid (user_step);
2342 
2343  /* Even if RESUME_PTID is a wildcard, and we end up resuming less
2344  (e.g., we might need to step over a breakpoint), from the
2345  user/frontend's point of view, all threads in RESUME_PTID are now
2346  running. */
2347  set_running (resume_ptid, 1);
2348 
2349  /* Maybe resume a single thread after all. */
2350  if ((step || thread_has_single_step_breakpoints_set (tp))
2351  && tp->control.trap_expected)
2352  {
2353  /* We're allowing a thread to run past a breakpoint it has
2354  hit, by single-stepping the thread with the breakpoint
2355  removed. In which case, we need to single-step only this
2356  thread, and keep others stopped, as they can miss this
2357  breakpoint if allowed to run. */
2358  resume_ptid = inferior_ptid;
2359  }
2360 
2361  if (execution_direction != EXEC_REVERSE
2362  && step && breakpoint_inserted_here_p (aspace, pc))
2363  {
2364  /* The only case we currently need to step a breakpoint
2365  instruction is when we have a signal to deliver. See
2366  handle_signal_stop where we handle random signals that could
2367  take out us out of the stepping range. Normally, in that
2368  case we end up continuing (instead of stepping) over the
2369  signal handler with a breakpoint at PC, but there are cases
2370  where we should _always_ single-step, even if we have a
2371  step-resume breakpoint, like when a software watchpoint is
2372  set. Assuming single-stepping and delivering a signal at the
2373  same time would takes us to the signal handler, then we could
2374  have removed the breakpoint at PC to step over it. However,
2375  some hardware step targets (like e.g., Mac OS) can't step
2376  into signal handlers, and for those, we need to leave the
2377  breakpoint at PC inserted, as otherwise if the handler
2378  recurses and executes PC again, it'll miss the breakpoint.
2379  So we leave the breakpoint inserted anyway, but we need to
2380  record that we tried to step a breakpoint instruction, so
2381  that adjust_pc_after_break doesn't end up confused. */
2382  gdb_assert (sig != GDB_SIGNAL_0);
2383 
2384  tp->stepped_breakpoint = 1;
2385 
2386  /* Most targets can step a breakpoint instruction, thus
2387  executing it normally. But if this one cannot, just
2388  continue and we will hit it anyway. */
2389  if (gdbarch_cannot_step_breakpoint (gdbarch))
2390  step = 0;
2391  }
2392 
2393  if (debug_displaced
2394  && use_displaced_stepping (gdbarch)
2395  && tp->control.trap_expected
2396  && !step_over_info_valid_p ())
2397  {
2398  struct regcache *resume_regcache = get_thread_regcache (tp->ptid);
2399  struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache);
2400  CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
2401  gdb_byte buf[4];
2402 
2403  fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
2404  paddress (resume_gdbarch, actual_pc));
2405  read_memory (actual_pc, buf, sizeof (buf));
2406  displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
2407  }
2408 
2409  if (tp->control.may_range_step)
2410  {
2411  /* If we're resuming a thread with the PC out of the step
2412  range, then we're doing some nested/finer run control
2413  operation, like stepping the thread out of the dynamic
2414  linker or the displaced stepping scratch pad. We
2415  shouldn't have allowed a range step then. */
2417  }
2418 
2419  do_target_resume (resume_ptid, step, sig);
2420  discard_cleanups (old_cleanups);
2421 }
2422 
2423 /* Proceeding. */
2424 
2425 /* Clear out all variables saying what to do when inferior is continued.
2426  First do this, then set the ones you want, then call `proceed'. */
2427 
2428 static void
2430 {
2431  if (debug_infrun)
2433  "infrun: clear_proceed_status_thread (%s)\n",
2434  target_pid_to_str (tp->ptid));
2435 
2436  /* If this signal should not be seen by program, give it zero.
2437  Used for debugging signals. */
2439  tp->suspend.stop_signal = GDB_SIGNAL_0;
2440 
2441  tp->control.trap_expected = 0;
2442  tp->control.step_range_start = 0;
2443  tp->control.step_range_end = 0;
2444  tp->control.may_range_step = 0;
2448  tp->control.step_start_function = NULL;
2449  tp->stop_requested = 0;
2450 
2451  tp->control.stop_step = 0;
2452 
2453  tp->control.proceed_to_finish = 0;
2454 
2455  tp->control.command_interp = NULL;
2456  tp->control.stepping_command = 0;
2457 
2458  /* Discard any remaining commands or status from previous stop. */
2460 }
2461 
2462 void
2464 {
2465  if (!non_stop)
2466  {
2467  struct thread_info *tp;
2468  ptid_t resume_ptid;
2469 
2470  resume_ptid = user_visible_resume_ptid (step);
2471 
2472  /* In all-stop mode, delete the per-thread status of all threads
2473  we're about to resume, implicitly and explicitly. */
2475  {
2476  if (!ptid_match (tp->ptid, resume_ptid))
2477  continue;
2479  }
2480  }
2481 
2483  {
2484  struct inferior *inferior;
2485 
2486  if (non_stop)
2487  {
2488  /* If in non-stop mode, only delete the per-thread status of
2489  the current thread. */
2491  }
2492 
2493  inferior = current_inferior ();
2494  inferior->control.stop_soon = NO_STOP_QUIETLY;
2495  }
2496 
2497  stop_after_trap = 0;
2498 
2500 
2502 }
2503 
2504 /* Returns true if TP is still stopped at a breakpoint that needs
2505  stepping-over in order to make progress. If the breakpoint is gone
2506  meanwhile, we can skip the whole step-over dance. */
2507 
2508 static int
2510 {
2511  if (tp->stepping_over_breakpoint)
2512  {
2513  struct regcache *regcache = get_thread_regcache (tp->ptid);
2514 
2515  if (breakpoint_here_p (get_regcache_aspace (regcache),
2516  regcache_read_pc (regcache))
2518  return 1;
2519 
2520  tp->stepping_over_breakpoint = 0;
2521  }
2522 
2523  return 0;
2524 }
2525 
2526 /* Returns true if scheduler locking applies. STEP indicates whether
2527  we're about to do a step/next-like command to a thread. */
2528 
2529 static int
2531 {
2532  return (scheduler_mode == schedlock_on
2533  || (scheduler_mode == schedlock_step
2534  && tp->control.stepping_command));
2535 }
2536 
2537 /* Look a thread other than EXCEPT that has previously reported a
2538  breakpoint event, and thus needs a step-over in order to make
2539  progress. Returns NULL is none is found. */
2540 
2541 static struct thread_info *
2543 {
2544  struct thread_info *tp, *current;
2545 
2546  /* With non-stop mode on, threads are always handled individually. */
2547  gdb_assert (! non_stop);
2548 
2549  current = inferior_thread ();
2550 
2551  /* If scheduler locking applies, we can avoid iterating over all
2552  threads. */
2553  if (schedlock_applies (except))
2554  {
2555  if (except != current
2556  && thread_still_needs_step_over (current))
2557  return current;
2558 
2559  return NULL;
2560  }
2561 
2563  {
2564  /* Ignore the EXCEPT thread. */
2565  if (tp == except)
2566  continue;
2567  /* Ignore threads of processes we're not resuming. */
2568  if (!sched_multi
2570  continue;
2571 
2573  return tp;
2574  }
2575 
2576  return NULL;
2577 }
2578 
2579 /* Basic routine for continuing the program in various fashions.
2580 
2581  ADDR is the address to resume at, or -1 for resume where stopped.
2582  SIGGNAL is the signal to give it, or 0 for none,
2583  or -1 for act according to how it stopped.
2584  STEP is nonzero if should trap after one instruction.
2585  -1 means return after that and print nothing.
2586  You should probably set various step_... variables
2587  before calling here, if you are stepping.
2588 
2589  You should call clear_proceed_status before calling proceed. */
2590 
2591 void
2592 proceed (CORE_ADDR addr, enum gdb_signal siggnal)
2593 {
2594  struct regcache *regcache;
2595  struct gdbarch *gdbarch;
2596  struct thread_info *tp;
2597  CORE_ADDR pc;
2598  struct address_space *aspace;
2599 
2600  /* If we're stopped at a fork/vfork, follow the branch set by the
2601  "set follow-fork-mode" command; otherwise, we'll just proceed
2602  resuming the current thread. */
2603  if (!follow_fork ())
2604  {
2605  /* The target for some reason decided not to resume. */
2606  normal_stop ();
2607  if (target_can_async_p ())
2609  return;
2610  }
2611 
2612  /* We'll update this if & when we switch to a new thread. */
2613  previous_inferior_ptid = inferior_ptid;
2614 
2615  regcache = get_current_regcache ();
2616  gdbarch = get_regcache_arch (regcache);
2617  aspace = get_regcache_aspace (regcache);
2618  pc = regcache_read_pc (regcache);
2619  tp = inferior_thread ();
2620 
2621  /* Fill in with reasonable starting values. */
2623 
2624  if (addr == (CORE_ADDR) -1)
2625  {
2626  if (pc == stop_pc
2627  && breakpoint_here_p (aspace, pc) == ordinary_breakpoint_here
2628  && execution_direction != EXEC_REVERSE)
2629  /* There is a breakpoint at the address we will resume at,
2630  step one instruction before inserting breakpoints so that
2631  we do not stop right away (and report a second hit at this
2632  breakpoint).
2633 
2634  Note, we don't do this in reverse, because we won't
2635  actually be executing the breakpoint insn anyway.
2636  We'll be (un-)executing the previous instruction. */
2637  tp->stepping_over_breakpoint = 1;
2638  else if (gdbarch_single_step_through_delay_p (gdbarch)
2640  get_current_frame ()))
2641  /* We stepped onto an instruction that needs to be stepped
2642  again before re-inserting the breakpoint, do so. */
2643  tp->stepping_over_breakpoint = 1;
2644  }
2645  else
2646  {
2647  regcache_write_pc (regcache, addr);
2648  }
2649 
2650  if (siggnal != GDB_SIGNAL_DEFAULT)
2651  tp->suspend.stop_signal = siggnal;
2652 
2653  /* Record the interpreter that issued the execution command that
2654  caused this thread to resume. If the top level interpreter is
2655  MI/async, and the execution command was a CLI command
2656  (next/step/etc.), we'll want to print stop event output to the MI
2657  console channel (the stepped-to line, etc.), as if the user
2658  entered the execution command on a real GDB console. */
2660 
2661  if (debug_infrun)
2663  "infrun: proceed (addr=%s, signal=%s)\n",
2664  paddress (gdbarch, addr),
2665  gdb_signal_to_symbol_string (siggnal));
2666 
2667  if (non_stop)
2668  /* In non-stop, each thread is handled individually. The context
2669  must already be set to the right thread here. */
2670  ;
2671  else
2672  {
2673  struct thread_info *step_over;
2674 
2675  /* In a multi-threaded task we may select another thread and
2676  then continue or step.
2677 
2678  But if the old thread was stopped at a breakpoint, it will
2679  immediately cause another breakpoint stop without any
2680  execution (i.e. it will report a breakpoint hit incorrectly).
2681  So we must step over it first.
2682 
2683  Look for a thread other than the current (TP) that reported a
2684  breakpoint hit and hasn't been resumed yet since. */
2685  step_over = find_thread_needs_step_over (tp);
2686  if (step_over != NULL)
2687  {
2688  if (debug_infrun)
2690  "infrun: need to step-over [%s] first\n",
2691  target_pid_to_str (step_over->ptid));
2692 
2693  /* Store the prev_pc for the stepping thread too, needed by
2694  switch_back_to_stepped_thread. */
2696  switch_to_thread (step_over->ptid);
2697  tp = step_over;
2698  }
2699  }
2700 
2701  /* If we need to step over a breakpoint, and we're not using
2702  displaced stepping to do so, insert all breakpoints (watchpoints,
2703  etc.) but the one we're stepping over, step one instruction, and
2704  then re-insert the breakpoint when that step is finished. */
2705  if (tp->stepping_over_breakpoint && !use_displaced_stepping (gdbarch))
2706  {
2707  struct regcache *regcache = get_current_regcache ();
2708 
2710  regcache_read_pc (regcache), 0);
2711  }
2712  else
2714 
2715  insert_breakpoints ();
2716 
2718 
2719  annotate_starting ();
2720 
2721  /* Make sure that output from GDB appears before output from the
2722  inferior. */
2724 
2725  /* Refresh prev_pc value just prior to resuming. This used to be
2726  done in stop_waiting, however, setting prev_pc there did not handle
2727  scenarios such as inferior function calls or returning from
2728  a function via the return command. In those cases, the prev_pc
2729  value was not set properly for subsequent commands. The prev_pc value
2730  is used to initialize the starting line number in the ecs. With an
2731  invalid value, the gdb next command ends up stopping at the position
2732  represented by the next line table entry past our start position.
2733  On platforms that generate one line table entry per line, this
2734  is not a problem. However, on the ia64, the compiler generates
2735  extraneous line table entries that do not increase the line number.
2736  When we issue the gdb next command on the ia64 after an inferior call
2737  or a return command, we often end up a few instructions forward, still
2738  within the original line we started.
2739 
2740  An attempt was made to refresh the prev_pc at the same time the
2741  execution_control_state is initialized (for instance, just before
2742  waiting for an inferior event). But this approach did not work
2743  because of platforms that use ptrace, where the pc register cannot
2744  be read unless the inferior is stopped. At that point, we are not
2745  guaranteed the inferior is stopped and so the regcache_read_pc() call
2746  can fail. Setting the prev_pc value here ensures the value is updated
2747  correctly when the inferior is stopped. */
2749 
2750  /* Resume inferior. */
2751  resume (tp->suspend.stop_signal);
2752 
2753  /* Wait for it to stop (if not standalone)
2754  and in any case decode why it stopped, and act accordingly. */
2755  /* Do this only if we are not using the event loop, or if the target
2756  does not support asynchronous execution. */
2757  if (!target_can_async_p ())
2758  {
2759  wait_for_inferior ();
2760  normal_stop ();
2761  }
2762 }
2763 
2764 
2765 /* Start remote-debugging of a machine over a serial link. */
2766 
2767 void
2768 start_remote (int from_tty)
2769 {
2770  struct inferior *inferior;
2771 
2772  inferior = current_inferior ();
2774 
2775  /* Always go on waiting for the target, regardless of the mode. */
2776  /* FIXME: cagney/1999-09-23: At present it isn't possible to
2777  indicate to wait_for_inferior that a target should timeout if
2778  nothing is returned (instead of just blocking). Because of this,
2779  targets expecting an immediate response need to, internally, set
2780  things up so that the target_wait() is forced to eventually
2781  timeout. */
2782  /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
2783  differentiate to its caller what the state of the target is after
2784  the initial open has been performed. Here we're assuming that
2785  the target has stopped. It should be possible to eventually have
2786  target_open() return to the caller an indication that the target
2787  is currently running and GDB state should be set to the same as
2788  for an async run. */
2789  wait_for_inferior ();
2790 
2791  /* Now that the inferior has stopped, do any bookkeeping like
2792  loading shared libraries. We want to do this before normal_stop,
2793  so that the displayed frame is up to date. */
2794  post_create_inferior (&current_target, from_tty);
2795 
2796  normal_stop ();
2797 }
2798 
2799 /* Initialize static vars when a new inferior begins. */
2800 
2801 void
2803 {
2804  /* These are meaningless until the first time through wait_for_inferior. */
2805 
2807 
2809 
2810  target_last_wait_ptid = minus_one_ptid;
2811 
2812  previous_inferior_ptid = inferior_ptid;
2813 
2814  /* Discard any skipped inlined frames. */
2816 }
2817 
2818 
2819 /* Data to be passed around while handling an event. This data is
2820  discarded between events. */
2822 {
2824  /* The thread that got the event, if this was a thread event; NULL
2825  otherwise. */
2827 
2832  const char *stop_func_name;
2834 
2835  /* True if the event thread hit the single-step breakpoint of
2836  another thread. Thus the event doesn't cause a stop, the thread
2837  needs to be single-stepped past the single-step breakpoint before
2838  we can switch back to the original stepping thread. */
2840 };
2841 
2842 static void handle_inferior_event (struct execution_control_state *ecs);
2843 
2844 static void handle_step_into_function (struct gdbarch *gdbarch,
2845  struct execution_control_state *ecs);
2847  struct execution_control_state *ecs);
2848 static void handle_signal_stop (struct execution_control_state *ecs);
2849 static void check_exception_resume (struct execution_control_state *,
2850  struct frame_info *);
2851 
2852 static void end_stepping_range (struct execution_control_state *ecs);
2853 static void stop_waiting (struct execution_control_state *ecs);
2854 static void prepare_to_wait (struct execution_control_state *ecs);
2855 static void keep_going (struct execution_control_state *ecs);
2856 static void process_event_stop_test (struct execution_control_state *ecs);
2858 
2859 /* Callback for iterate over threads. If the thread is stopped, but
2860  the user/frontend doesn't know about that yet, go through
2861  normal_stop, as if the thread had just stopped now. ARG points at
2862  a ptid. If PTID is MINUS_ONE_PTID, applies to all threads. If
2863  ptid_is_pid(PTID) is true, applies to all threads of the process
2864  pointed at by PTID. Otherwise, apply only to the thread pointed by
2865  PTID. */
2866 
2867 static int
2869 {
2870  ptid_t ptid = * (ptid_t *) arg;
2871 
2872  if ((ptid_equal (info->ptid, ptid)
2873  || ptid_equal (minus_one_ptid, ptid)
2874  || (ptid_is_pid (ptid)
2875  && ptid_get_pid (ptid) == ptid_get_pid (info->ptid)))
2876  && is_running (info->ptid)
2877  && !is_executing (info->ptid))
2878  {
2879  struct cleanup *old_chain;
2880  struct execution_control_state ecss;
2881  struct execution_control_state *ecs = &ecss;
2882 
2883  memset (ecs, 0, sizeof (*ecs));
2884 
2885  old_chain = make_cleanup_restore_current_thread ();
2886 
2888  /* Flush target cache before starting to handle each event.
2889  Target was running and cache could be stale. This is just a
2890  heuristic. Running threads may modify target memory, but we
2891  don't get any event. */
2893 
2894  /* Go through handle_inferior_event/normal_stop, so we always
2895  have consistent output as if the stop event had been
2896  reported. */
2897  ecs->ptid = info->ptid;
2898  ecs->event_thread = find_thread_ptid (info->ptid);
2900  ecs->ws.value.sig = GDB_SIGNAL_0;
2901 
2902  handle_inferior_event (ecs);
2903 
2904  if (!ecs->wait_some_more)
2905  {
2906  struct thread_info *tp;
2907 
2908  normal_stop ();
2909 
2910  /* Finish off the continuations. */
2911  tp = inferior_thread ();
2914  }
2915 
2916  do_cleanups (old_chain);
2917  }
2918 
2919  return 0;
2920 }
2921 
2922 /* This function is attached as a "thread_stop_requested" observer.
2923  Cleanup local state that assumed the PTID was to be resumed, and
2924  report the stop to the frontend. */
2925 
2926 static void
2928 {
2929  struct displaced_step_inferior_state *displaced;
2930 
2931  /* PTID was requested to stop. Remove it from the displaced
2932  stepping queue, so we don't try to resume it automatically. */
2933 
2934  for (displaced = displaced_step_inferior_states;
2935  displaced;
2936  displaced = displaced->next)
2937  {
2938  struct displaced_step_request *it, **prev_next_p;
2939 
2940  it = displaced->step_request_queue;
2941  prev_next_p = &displaced->step_request_queue;
2942  while (it)
2943  {
2944  if (ptid_match (it->ptid, ptid))
2945  {
2946  *prev_next_p = it->next;
2947  it->next = NULL;
2948  xfree (it);
2949  }
2950  else
2951  {
2952  prev_next_p = &it->next;
2953  }
2954 
2955  it = *prev_next_p;
2956  }
2957  }
2958 
2960 }
2961 
2962 static void
2963 infrun_thread_thread_exit (struct thread_info *tp, int silent)
2964 {
2965  if (ptid_equal (target_last_wait_ptid, tp->ptid))
2967 }
2968 
2969 /* Delete the step resume, single-step and longjmp/exception resume
2970  breakpoints of TP. */
2971 
2972 static void
2974 {
2978 }
2979 
2980 /* If the target still has execution, call FUNC for each thread that
2981  just stopped. In all-stop, that's all the non-exited threads; in
2982  non-stop, that's the current thread, only. */
2983 
2985  (struct thread_info *tp);
2986 
2987 static void
2989 {
2991  return;
2992 
2993  if (non_stop)
2994  {
2995  /* If in non-stop mode, only the current thread stopped. */
2996  func (inferior_thread ());
2997  }
2998  else
2999  {
3000  struct thread_info *tp;
3001 
3002  /* In all-stop mode, all threads have stopped. */
3004  {
3005  func (tp);
3006  }
3007  }
3008 }
3009 
3010 /* Delete the step resume and longjmp/exception resume breakpoints of
3011  the threads that just stopped. */
3012 
3013 static void
3015 {
3017 }
3018 
3019 /* Delete the single-step breakpoints of the threads that just
3020  stopped. */
3021 
3022 static void
3024 {
3026 }
3027 
3028 /* A cleanup wrapper. */
3029 
3030 static void
3032 {
3034 }
3035 
3036 /* Pretty print the results of target_wait, for debugging purposes. */
3037 
3038 static void
3039 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
3040  const struct target_waitstatus *ws)
3041 {
3042  char *status_string = target_waitstatus_to_string (ws);
3043  struct ui_file *tmp_stream = mem_fileopen ();
3044  char *text;
3045 
3046  /* The text is split over several lines because it was getting too long.
3047  Call fprintf_unfiltered (gdb_stdlog) once so that the text is still
3048  output as a unit; we want only one timestamp printed if debug_timestamp
3049  is set. */
3050 
3051  fprintf_unfiltered (tmp_stream,
3052  "infrun: target_wait (%d.%ld.%ld",
3053  ptid_get_pid (waiton_ptid),
3054  ptid_get_lwp (waiton_ptid),
3055  ptid_get_tid (waiton_ptid));
3056  if (ptid_get_pid (waiton_ptid) != -1)
3057  fprintf_unfiltered (tmp_stream,
3058  " [%s]", target_pid_to_str (waiton_ptid));
3059  fprintf_unfiltered (tmp_stream, ", status) =\n");
3060  fprintf_unfiltered (tmp_stream,
3061  "infrun: %d.%ld.%ld [%s],\n",
3062  ptid_get_pid (result_ptid),
3063  ptid_get_lwp (result_ptid),
3064  ptid_get_tid (result_ptid),
3065  target_pid_to_str (result_ptid));
3066  fprintf_unfiltered (tmp_stream,
3067  "infrun: %s\n",
3068  status_string);
3069 
3070  text = ui_file_xstrdup (tmp_stream, NULL);
3071 
3072  /* This uses %s in part to handle %'s in the text, but also to avoid
3073  a gcc error: the format attribute requires a string literal. */
3074  fprintf_unfiltered (gdb_stdlog, "%s", text);
3075 
3076  xfree (status_string);
3077  xfree (text);
3078  ui_file_delete (tmp_stream);
3079 }
3080 
3081 /* Prepare and stabilize the inferior for detaching it. E.g.,
3082  detaching while a thread is displaced stepping is a recipe for
3083  crashing it, as nothing would readjust the PC out of the scratch
3084  pad. */
3085 
3086 void
3088 {
3089  struct inferior *inf = current_inferior ();
3090  ptid_t pid_ptid = pid_to_ptid (inf->pid);
3091  struct cleanup *old_chain_1;
3092  struct displaced_step_inferior_state *displaced;
3093 
3094  displaced = get_displaced_stepping_state (inf->pid);
3095 
3096  /* Is any thread of this process displaced stepping? If not,
3097  there's nothing else to do. */
3098  if (displaced == NULL || ptid_equal (displaced->step_ptid, null_ptid))
3099  return;
3100 
3101  if (debug_infrun)
3103  "displaced-stepping in-process while detaching");
3104 
3105  old_chain_1 = make_cleanup_restore_integer (&inf->detaching);
3106  inf->detaching = 1;
3107 
3108  while (!ptid_equal (displaced->step_ptid, null_ptid))
3109  {
3110  struct cleanup *old_chain_2;
3111  struct execution_control_state ecss;
3112  struct execution_control_state *ecs;
3113 
3114  ecs = &ecss;
3115  memset (ecs, 0, sizeof (*ecs));
3116 
3118  /* Flush target cache before starting to handle each event.
3119  Target was running and cache could be stale. This is just a
3120  heuristic. Running threads may modify target memory, but we
3121  don't get any event. */
3123 
3125  ecs->ptid = deprecated_target_wait_hook (pid_ptid, &ecs->ws, 0);
3126  else
3127  ecs->ptid = target_wait (pid_ptid, &ecs->ws, 0);
3128 
3129  if (debug_infrun)
3130  print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws);
3131 
3132  /* If an error happens while handling the event, propagate GDB's
3133  knowledge of the executing state to the frontend/user running
3134  state. */
3136  &minus_one_ptid);
3137 
3138  /* Now figure out what to do with the result of the result. */
3139  handle_inferior_event (ecs);
3140 
3141  /* No error, don't finish the state yet. */
3142  discard_cleanups (old_chain_2);
3143 
3144  /* Breakpoints and watchpoints are not installed on the target
3145  at this point, and signals are passed directly to the
3146  inferior, so this must mean the process is gone. */
3147  if (!ecs->wait_some_more)
3148  {
3149  discard_cleanups (old_chain_1);
3150  error (_("Program exited while detaching"));
3151  }
3152  }
3153 
3154  discard_cleanups (old_chain_1);
3155 }
3156 
3157 /* Wait for control to return from inferior to debugger.
3158 
3159  If inferior gets a signal, we may decide to start it up again
3160  instead of returning. That is why there is a loop in this function.
3161  When this function actually returns it means the inferior
3162  should be left stopped and GDB should read more commands. */
3163 
3164 void
3166 {
3167  struct cleanup *old_cleanups;
3168  struct cleanup *thread_state_chain;
3169 
3170  if (debug_infrun)
3172  (gdb_stdlog, "infrun: wait_for_inferior ()\n");
3173 
3174  old_cleanups
3176  NULL);
3177 
3178  /* If an error happens while handling the event, propagate GDB's
3179  knowledge of the executing state to the frontend/user running
3180  state. */
3181  thread_state_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
3182 
3183  while (1)
3184  {
3185  struct execution_control_state ecss;
3186  struct execution_control_state *ecs = &ecss;
3187  ptid_t waiton_ptid = minus_one_ptid;
3188 
3189  memset (ecs, 0, sizeof (*ecs));
3190 
3192 
3193  /* Flush target cache before starting to handle each event.
3194  Target was running and cache could be stale. This is just a
3195  heuristic. Running threads may modify target memory, but we
3196  don't get any event. */
3198 
3200  ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws, 0);
3201  else
3202  ecs->ptid = target_wait (waiton_ptid, &ecs->ws, 0);
3203 
3204  if (debug_infrun)
3205  print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3206 
3207  /* Now figure out what to do with the result of the result. */
3208  handle_inferior_event (ecs);
3209 
3210  if (!ecs->wait_some_more)
3211  break;
3212  }
3213 
3214  /* No error, don't finish the state yet. */
3215  discard_cleanups (thread_state_chain);
3216 
3217  do_cleanups (old_cleanups);
3218 }
3219 
3220 /* Cleanup that reinstalls the readline callback handler, if the
3221  target is running in the background. If while handling the target
3222  event something triggered a secondary prompt, like e.g., a
3223  pagination prompt, we'll have removed the callback handler (see
3224  gdb_readline_wrapper_line). Need to do this as we go back to the
3225  event loop, ready to process further input. Note this has no
3226  effect if the handler hasn't actually been removed, because calling
3227  rl_callback_handler_install resets the line buffer, thus losing
3228  input. */
3229 
3230 static void
3232 {
3233  if (!interpreter_async)
3234  {
3235  /* We're not going back to the top level event loop yet. Don't
3236  install the readline callback, as it'd prep the terminal,
3237  readline-style (raw, noecho) (e.g., --batch). We'll install
3238  it the next time the prompt is displayed, when we're ready
3239  for input. */
3240  return;
3241  }
3242 
3243  if (async_command_editing_p && !sync_execution)
3245 }
3246 
3247 /* Asynchronous version of wait_for_inferior. It is called by the
3248  event loop whenever a change of state is detected on the file
3249  descriptor corresponding to the target. It can be called more than
3250  once to complete a single execution command. In such cases we need
3251  to keep the state in a global variable ECSS. If it is the last time
3252  that this function is called for a single execution command, then
3253  report to the user that the inferior has stopped, and do the
3254  necessary cleanups. */
3255 
3256 void
3257 fetch_inferior_event (void *client_data)
3258 {
3259  struct execution_control_state ecss;
3260  struct execution_control_state *ecs = &ecss;
3261  struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3262  struct cleanup *ts_old_chain;
3263  int was_sync = sync_execution;
3264  int cmd_done = 0;
3265  ptid_t waiton_ptid = minus_one_ptid;
3266 
3267  memset (ecs, 0, sizeof (*ecs));
3268 
3269  /* End up with readline processing input, if necessary. */
3271 
3272  /* We're handling a live event, so make sure we're doing live
3273  debugging. If we're looking at traceframes while the target is
3274  running, we're going to need to get back to that mode after
3275  handling the event. */
3276  if (non_stop)
3277  {
3280  }
3281 
3282  if (non_stop)
3283  /* In non-stop mode, the user/frontend should not notice a thread
3284  switch due to internal events. Make sure we reverse to the
3285  user selected thread and frame after handling the event and
3286  running any breakpoint commands. */
3288 
3290  /* Flush target cache before starting to handle each event. Target
3291  was running and cache could be stale. This is just a heuristic.
3292  Running threads may modify target memory, but we don't get any
3293  event. */
3295 
3296  make_cleanup_restore_integer (&execution_direction);
3297  execution_direction = target_execution_direction ();
3298 
3300  ecs->ptid =
3301  deprecated_target_wait_hook (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
3302  else
3303  ecs->ptid = target_wait (waiton_ptid, &ecs->ws, TARGET_WNOHANG);
3304 
3305  if (debug_infrun)
3306  print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws);
3307 
3308  /* If an error happens while handling the event, propagate GDB's
3309  knowledge of the executing state to the frontend/user running
3310  state. */
3311  if (!non_stop)
3313  else
3314  ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid);
3315 
3316  /* Get executed before make_cleanup_restore_current_thread above to apply
3317  still for the thread which has thrown the exception. */
3319 
3321 
3322  /* Now figure out what to do with the result of the result. */
3323  handle_inferior_event (ecs);
3324 
3325  if (!ecs->wait_some_more)
3326  {
3327  struct inferior *inf = find_inferior_ptid (ecs->ptid);
3328 
3330 
3331  /* We may not find an inferior if this was a process exit. */
3332  if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY)
3333  normal_stop ();
3334 
3337  && ecs->ws.kind != TARGET_WAITKIND_EXITED
3338  && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
3339  && ecs->event_thread->step_multi
3340  && ecs->event_thread->control.stop_step)
3342  else
3343  {
3345  cmd_done = 1;
3346  }
3347  }
3348 
3349  /* No error, don't finish the thread states yet. */
3350  discard_cleanups (ts_old_chain);
3351 
3352  /* Revert thread and frame. */
3353  do_cleanups (old_chain);
3354 
3355  /* If the inferior was in sync execution mode, and now isn't,
3356  restore the prompt (a synchronous execution command has finished,
3357  and we're ready for input). */
3358  if (interpreter_async && was_sync && !sync_execution)
3360 
3361  if (cmd_done
3362  && !was_sync
3365  || !is_running (inferior_ptid)))
3366  printf_unfiltered (_("completed.\n"));
3367 }
3368 
3369 /* Record the frame and location we're currently stepping through. */
3370 void
3371 set_step_info (struct frame_info *frame, struct symtab_and_line sal)
3372 {
3373  struct thread_info *tp = inferior_thread ();
3374 
3375  tp->control.step_frame_id = get_frame_id (frame);
3377 
3378  tp->current_symtab = sal.symtab;
3379  tp->current_line = sal.line;
3380 }
3381 
3382 /* Clear context switchable stepping state. */
3383 
3384 void
3386 {
3387  tss->stepped_breakpoint = 0;
3388  tss->stepping_over_breakpoint = 0;
3389  tss->stepping_over_watchpoint = 0;
3391 }
3392 
3393 /* Set the cached copy of the last ptid/waitstatus. */
3394 
3395 static void
3397 {
3398  target_last_wait_ptid = ptid;
3400 }
3401 
3402 /* Return the cached copy of the last pid/waitstatus returned by
3403  target_wait()/deprecated_target_wait_hook(). The data is actually
3404  cached by handle_inferior_event(), which gets called immediately
3405  after target_wait()/deprecated_target_wait_hook(). */
3406 
3407 void
3409 {
3410  *ptidp = target_last_wait_ptid;
3411  *status = target_last_waitstatus;
3412 }
3413 
3414 void
3416 {
3417  target_last_wait_ptid = minus_one_ptid;
3418 }
3419 
3420 /* Switch thread contexts. */
3421 
3422 static void
3424 {
3425  if (debug_infrun && !ptid_equal (ptid, inferior_ptid))
3426  {
3427  fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ",
3429  fprintf_unfiltered (gdb_stdlog, "to %s\n",
3430  target_pid_to_str (ptid));
3431  }
3432 
3433  switch_to_thread (ptid);
3434 }
3435 
3436 static void
3438 {
3439  struct regcache *regcache;
3440  struct gdbarch *gdbarch;
3441  struct address_space *aspace;
3442  CORE_ADDR breakpoint_pc, decr_pc;
3443 
3444  /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
3445  we aren't, just return.
3446 
3447  We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
3448  affected by gdbarch_decr_pc_after_break. Other waitkinds which are
3449  implemented by software breakpoints should be handled through the normal
3450  breakpoint layer.
3451 
3452  NOTE drow/2004-01-31: On some targets, breakpoints may generate
3453  different signals (SIGILL or SIGEMT for instance), but it is less
3454  clear where the PC is pointing afterwards. It may not match
3455  gdbarch_decr_pc_after_break. I don't know any specific target that
3456  generates these signals at breakpoints (the code has been in GDB since at
3457  least 1992) so I can not guess how to handle them here.
3458 
3459  In earlier versions of GDB, a target with
3460  gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
3461  watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
3462  target with both of these set in GDB history, and it seems unlikely to be
3463  correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
3464 
3465  if (ecs->ws.kind != TARGET_WAITKIND_STOPPED)
3466  return;
3467 
3468  if (ecs->ws.value.sig != GDB_SIGNAL_TRAP)
3469  return;
3470 
3471  /* In reverse execution, when a breakpoint is hit, the instruction
3472  under it has already been de-executed. The reported PC always
3473  points at the breakpoint address, so adjusting it further would
3474  be wrong. E.g., consider this case on a decr_pc_after_break == 1
3475  architecture:
3476 
3477  B1 0x08000000 : INSN1
3478  B2 0x08000001 : INSN2
3479  0x08000002 : INSN3
3480  PC -> 0x08000003 : INSN4
3481 
3482  Say you're stopped at 0x08000003 as above. Reverse continuing
3483  from that point should hit B2 as below. Reading the PC when the
3484  SIGTRAP is reported should read 0x08000001 and INSN2 should have
3485  been de-executed already.
3486 
3487  B1 0x08000000 : INSN1
3488  B2 PC -> 0x08000001 : INSN2
3489  0x08000002 : INSN3
3490  0x08000003 : INSN4
3491 
3492  We can't apply the same logic as for forward execution, because
3493  we would wrongly adjust the PC to 0x08000000, since there's a
3494  breakpoint at PC - 1. We'd then report a hit on B1, although
3495  INSN1 hadn't been de-executed yet. Doing nothing is the correct
3496  behaviour. */
3497  if (execution_direction == EXEC_REVERSE)
3498  return;
3499 
3500  /* If the target can tell whether the thread hit a SW breakpoint,
3501  trust it. Targets that can tell also adjust the PC
3502  themselves. */
3504  return;
3505 
3506  /* Note that relying on whether a breakpoint is planted in memory to
3507  determine this can fail. E.g,. the breakpoint could have been
3508  removed since. Or the thread could have been told to step an
3509  instruction the size of a breakpoint instruction, and only
3510  _after_ was a breakpoint inserted at its address. */
3511 
3512  /* If this target does not decrement the PC after breakpoints, then
3513  we have nothing to do. */
3514  regcache = get_thread_regcache (ecs->ptid);
3515  gdbarch = get_regcache_arch (regcache);
3516 
3517  decr_pc = gdbarch_decr_pc_after_break (gdbarch);
3518  if (decr_pc == 0)
3519  return;
3520 
3521  aspace = get_regcache_aspace (regcache);
3522 
3523  /* Find the location where (if we've hit a breakpoint) the
3524  breakpoint would be. */
3525  breakpoint_pc = regcache_read_pc (regcache) - decr_pc;
3526 
3527  /* If the target can't tell whether a software breakpoint triggered,
3528  fallback to figuring it out based on breakpoints we think were
3529  inserted in the target, and on whether the thread was stepped or
3530  continued. */
3531 
3532  /* Check whether there actually is a software breakpoint inserted at
3533  that location.
3534 
3535  If in non-stop mode, a race condition is possible where we've
3536  removed a breakpoint, but stop events for that breakpoint were
3537  already queued and arrive later. To suppress those spurious
3538  SIGTRAPs, we keep a list of such breakpoint locations for a bit,
3539  and retire them after a number of stop events are reported. Note
3540  this is an heuristic and can thus get confused. The real fix is
3541  to get the "stopped by SW BP and needs adjustment" info out of
3542  the target/kernel (and thus never reach here; see above). */
3543  if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc)
3544  || (non_stop && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
3545  {
3546  struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
3547 
3548  if (record_full_is_used ())
3550 
3551  /* When using hardware single-step, a SIGTRAP is reported for both
3552  a completed single-step and a software breakpoint. Need to
3553  differentiate between the two, as the latter needs adjusting
3554  but the former does not.
3555 
3556  The SIGTRAP can be due to a completed hardware single-step only if
3557  - we didn't insert software single-step breakpoints
3558  - this thread is currently being stepped
3559 
3560  If any of these events did not occur, we must have stopped due
3561  to hitting a software breakpoint, and have to back up to the
3562  breakpoint address.
3563 
3564  As a special case, we could have hardware single-stepped a
3565  software breakpoint. In this case (prev_pc == breakpoint_pc),
3566  we also need to back up to the breakpoint address. */
3567 
3569  || !currently_stepping (ecs->event_thread)
3571  && ecs->event_thread->prev_pc == breakpoint_pc))
3572  regcache_write_pc (regcache, breakpoint_pc);
3573 
3574  do_cleanups (old_cleanups);
3575  }
3576 }
3577 
3578 static int
3579 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
3580 {
3581  for (frame = get_prev_frame (frame);
3582  frame != NULL;
3583  frame = get_prev_frame (frame))
3584  {
3585  if (frame_id_eq (get_frame_id (frame), step_frame_id))
3586  return 1;
3587  if (get_frame_type (frame) != INLINE_FRAME)
3588  break;
3589  }
3590 
3591  return 0;
3592 }
3593 
3594 /* Auxiliary function that handles syscall entry/return events.
3595  It returns 1 if the inferior should keep going (and GDB
3596  should ignore the event), or 0 if the event deserves to be
3597  processed. */
3598 
3599 static int
3601 {
3602  struct regcache *regcache;
3603  int syscall_number;
3604 
3605  if (!ptid_equal (ecs->ptid, inferior_ptid))
3606  context_switch (ecs->ptid);
3607 
3608  regcache = get_thread_regcache (ecs->ptid);
3609  syscall_number = ecs->ws.value.syscall_number;
3610  stop_pc = regcache_read_pc (regcache);
3611 
3612  if (catch_syscall_enabled () > 0
3613  && catching_syscall_number (syscall_number) > 0)
3614  {
3615  if (debug_infrun)
3616  fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n",
3617  syscall_number);
3618 
3621  stop_pc, ecs->ptid, &ecs->ws);
3622 
3624  {
3625  /* Catchpoint hit. */
3626  return 0;
3627  }
3628  }
3629 
3630  /* If no catchpoint triggered for this, then keep going. */
3631  keep_going (ecs);
3632  return 1;
3633 }
3634 
3635 /* Lazily fill in the execution_control_state's stop_func_* fields. */
3636 
3637 static void
3639  struct execution_control_state *ecs)
3640 {
3641  if (!ecs->stop_func_filled_in)
3642  {
3643  /* Don't care about return value; stop_func_start and stop_func_name
3644  will both be 0 if it doesn't work. */
3646  &ecs->stop_func_start, &ecs->stop_func_end);
3647  ecs->stop_func_start
3649 
3650  if (gdbarch_skip_entrypoint_p (gdbarch))
3651  ecs->stop_func_start = gdbarch_skip_entrypoint (gdbarch,
3652  ecs->stop_func_start);
3653 
3654  ecs->stop_func_filled_in = 1;
3655  }
3656 }
3657 
3658 
3659 /* Return the STOP_SOON field of the inferior pointed at by PTID. */
3660 
3661 static enum stop_kind
3663 {
3664  struct inferior *inf = find_inferior_ptid (ptid);
3665 
3666  gdb_assert (inf != NULL);
3667  return inf->control.stop_soon;
3668 }
3669 
3670 /* Given an execution control state that has been freshly filled in by
3671  an event from the inferior, figure out what it means and take
3672  appropriate action.
3673 
3674  The alternatives are:
3675 
3676  1) stop_waiting and return; to really stop and return to the
3677  debugger.
3678 
3679  2) keep_going and return; to wait for the next event (set
3680  ecs->event_thread->stepping_over_breakpoint to 1 to single step
3681  once). */
3682 
3683 static void
3685 {
3686  enum stop_kind stop_soon;
3687 
3688  if (ecs->ws.kind == TARGET_WAITKIND_IGNORE)
3689  {
3690  /* We had an event in the inferior, but we are not interested in
3691  handling it at this level. The lower layers have already
3692  done what needs to be done, if anything.
3693 
3694  One of the possible circumstances for this is when the
3695  inferior produces output for the console. The inferior has
3696  not stopped, and we are ignoring the event. Another possible
3697  circumstance is any event which the lower level knows will be
3698  reported multiple times without an intervening resume. */
3699  if (debug_infrun)
3700  fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n");
3701  prepare_to_wait (ecs);
3702  return;
3703  }
3704 
3705  if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED
3706  && target_can_async_p () && !sync_execution)
3707  {
3708  /* There were no unwaited-for children left in the target, but,
3709  we're not synchronously waiting for events either. Just
3710  ignore. Otherwise, if we were running a synchronous
3711  execution command, we need to cancel it and give the user
3712  back the terminal. */
3713  if (debug_infrun)
3715  "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n");
3716  prepare_to_wait (ecs);
3717  return;
3718  }
3719 
3720  /* Cache the last pid/waitstatus. */
3721  set_last_target_status (ecs->ptid, ecs->ws);
3722 
3723  /* Always clear state belonging to the previous time we stopped. */
3725 
3726  if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED)
3727  {
3728  /* No unwaited-for children left. IOW, all resumed children
3729  have exited. */
3730  if (debug_infrun)
3731  fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n");
3732 
3733  stop_print_frame = 0;
3734  stop_waiting (ecs);
3735  return;
3736  }
3737 
3738  if (ecs->ws.kind != TARGET_WAITKIND_EXITED
3739  && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
3740  {
3741  ecs->event_thread = find_thread_ptid (ecs->ptid);
3742  /* If it's a new thread, add it to the thread database. */
3743  if (ecs->event_thread == NULL)
3744  ecs->event_thread = add_thread (ecs->ptid);
3745 
3746  /* Disable range stepping. If the next step request could use a
3747  range, this will be end up re-enabled then. */
3749  }
3750 
3751  /* Dependent on valid ECS->EVENT_THREAD. */
3752  adjust_pc_after_break (ecs);
3753 
3754  /* Dependent on the current PC value modified by adjust_pc_after_break. */
3755  reinit_frame_cache ();
3756 
3758 
3759  /* First, distinguish signals caused by the debugger from signals
3760  that have to do with the program's own actions. Note that
3761  breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
3762  on the operating system version. Here we detect when a SIGILL or
3763  SIGEMT is really a breakpoint and change it to SIGTRAP. We do
3764  something similar for SIGSEGV, since a SIGSEGV will be generated
3765  when we're trying to execute a breakpoint instruction on a
3766  non-executable stack. This happens for call dummy breakpoints
3767  for architectures like SPARC that place call dummies on the
3768  stack. */
3769  if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
3770  && (ecs->ws.value.sig == GDB_SIGNAL_ILL
3771  || ecs->ws.value.sig == GDB_SIGNAL_SEGV
3772  || ecs->ws.value.sig == GDB_SIGNAL_EMT))
3773  {
3774  struct regcache *regcache = get_thread_regcache (ecs->ptid);
3775 
3777  regcache_read_pc (regcache)))
3778  {
3779  if (debug_infrun)
3781  "infrun: Treating signal as SIGTRAP\n");
3782  ecs->ws.value.sig = GDB_SIGNAL_TRAP;
3783  }
3784  }
3785 
3786  /* Mark the non-executing threads accordingly. In all-stop, all
3787  threads of all processes are stopped when we get any event
3788  reported. In non-stop mode, only the event thread stops. If
3789  we're handling a process exit in non-stop mode, there's nothing
3790  to do, as threads of the dead process are gone, and threads of
3791  any other process were left running. */
3792  if (!non_stop)
3794  else if (ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
3795  && ecs->ws.kind != TARGET_WAITKIND_EXITED)
3796  set_executing (ecs->ptid, 0);
3797 
3798  switch (ecs->ws.kind)
3799  {
3801  if (debug_infrun)
3802  fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n");
3803  if (!ptid_equal (ecs->ptid, inferior_ptid))
3804  context_switch (ecs->ptid);
3805  /* Ignore gracefully during startup of the inferior, as it might
3806  be the shell which has just loaded some objects, otherwise
3807  add the symbols for the newly loaded objects. Also ignore at
3808  the beginning of an attach or remote session; we will query
3809  the full list of libraries once the connection is
3810  established. */
3811 
3812  stop_soon = get_inferior_stop_soon (ecs->ptid);
3813  if (stop_soon == NO_STOP_QUIETLY)
3814  {
3815  struct regcache *regcache;
3816 
3817  regcache = get_thread_regcache (ecs->ptid);
3818 
3819  handle_solib_event ();
3820 
3823  stop_pc, ecs->ptid, &ecs->ws);
3824 
3826  {
3827  /* A catchpoint triggered. */
3829  return;
3830  }
3831 
3832  /* If requested, stop when the dynamic linker notifies
3833  gdb of events. This allows the user to get control
3834  and place breakpoints in initializer routines for
3835  dynamically loaded objects (among other things). */
3836  ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
3837  if (stop_on_solib_events)
3838  {
3839  /* Make sure we print "Stopped due to solib-event" in
3840  normal_stop. */
3841  stop_print_frame = 1;
3842 
3843  stop_waiting (ecs);
3844  return;
3845  }
3846  }
3847 
3848  /* If we are skipping through a shell, or through shared library
3849  loading that we aren't interested in, resume the program. If
3850  we're running the program normally, also resume. */
3851  if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY)
3852  {
3853  /* Loading of shared libraries might have changed breakpoint
3854  addresses. Make sure new breakpoints are inserted. */
3855  if (stop_soon == NO_STOP_QUIETLY)
3856  insert_breakpoints ();
3857  resume (GDB_SIGNAL_0);
3858  prepare_to_wait (ecs);
3859  return;
3860  }
3861 
3862  /* But stop if we're attaching or setting up a remote
3863  connection. */
3864  if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
3865  || stop_soon == STOP_QUIETLY_REMOTE)
3866  {
3867  if (debug_infrun)
3868  fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
3869  stop_waiting (ecs);
3870  return;
3871  }
3872 
3873  internal_error (__FILE__, __LINE__,
3874  _("unhandled stop_soon: %d"), (int) stop_soon);
3875 
3877  if (debug_infrun)
3878  fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n");
3879  if (!ptid_equal (ecs->ptid, inferior_ptid))
3880  context_switch (ecs->ptid);
3881  resume (GDB_SIGNAL_0);
3882  prepare_to_wait (ecs);
3883  return;
3884 
3887  if (debug_infrun)
3888  {
3889  if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
3891  "infrun: TARGET_WAITKIND_EXITED\n");
3892  else
3894  "infrun: TARGET_WAITKIND_SIGNALLED\n");
3895  }
3896 
3897  inferior_ptid = ecs->ptid;
3901  target_terminal_ours (); /* Must do this before mourn anyway. */
3902 
3903  /* Clearing any previous state of convenience variables. */
3905 
3906  if (ecs->ws.kind == TARGET_WAITKIND_EXITED)
3907  {
3908  /* Record the exit code in the convenience variable $_exitcode, so
3909  that the user can inspect this again later. */
3911  (LONGEST) ecs->ws.value.integer);
3912 
3913  /* Also record this in the inferior itself. */
3916 
3917  /* Support the --return-child-result option. */
3919 
3921  }
3922  else
3923  {
3924  struct regcache *regcache = get_thread_regcache (ecs->ptid);
3925  struct gdbarch *gdbarch = get_regcache_arch (regcache);
3926 
3927  if (gdbarch_gdb_signal_to_target_p (gdbarch))
3928  {
3929  /* Set the value of the internal variable $_exitsignal,
3930  which holds the signal uncaught by the inferior. */
3933  ecs->ws.value.sig));
3934  }
3935  else
3936  {
3937  /* We don't have access to the target's method used for
3938  converting between signal numbers (GDB's internal
3939  representation <-> target's representation).
3940  Therefore, we cannot do a good job at displaying this
3941  information to the user. It's better to just warn
3942  her about it (if infrun debugging is enabled), and
3943  give up. */
3944  if (debug_infrun)
3946 Cannot fill $_exitsignal with the correct signal number.\n"));
3947  }
3948 
3950  }
3951 
3954  stop_print_frame = 0;
3955  stop_waiting (ecs);
3956  return;
3957 
3958  /* The following are the only cases in which we keep going;
3959  the above cases end in a continue or goto. */
3962  if (debug_infrun)
3963  {
3964  if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
3965  fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n");
3966  else
3967  fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_VFORKED\n");
3968  }
3969 
3970  /* Check whether the inferior is displaced stepping. */
3971  {
3972  struct regcache *regcache = get_thread_regcache (ecs->ptid);
3973  struct gdbarch *gdbarch = get_regcache_arch (regcache);
3974  struct displaced_step_inferior_state *displaced
3976 
3977  /* If checking displaced stepping is supported, and thread
3978  ecs->ptid is displaced stepping. */
3979  if (displaced && ptid_equal (displaced->step_ptid, ecs->ptid))
3980  {
3981  struct inferior *parent_inf
3982  = find_inferior_ptid (ecs->ptid);
3983  struct regcache *child_regcache;
3984  CORE_ADDR parent_pc;
3985 
3986  /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
3987  indicating that the displaced stepping of syscall instruction
3988  has been done. Perform cleanup for parent process here. Note
3989  that this operation also cleans up the child process for vfork,
3990  because their pages are shared. */
3991  displaced_step_fixup (ecs->ptid, GDB_SIGNAL_TRAP);
3992 
3993  if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
3994  {
3995  /* Restore scratch pad for child process. */
3996  displaced_step_restore (displaced, ecs->ws.value.related_pid);
3997  }
3998 
3999  /* Since the vfork/fork syscall instruction was executed in the scratchpad,
4000  the child's PC is also within the scratchpad. Set the child's PC
4001  to the parent's PC value, which has already been fixed up.
4002  FIXME: we use the parent's aspace here, although we're touching
4003  the child, because the child hasn't been added to the inferior
4004  list yet at this point. */
4005 
4006  child_regcache
4008  gdbarch,
4009  parent_inf->aspace);
4010  /* Read PC value of parent process. */
4011  parent_pc = regcache_read_pc (regcache);
4012 
4013  if (debug_displaced)
4015  "displaced: write child pc from %s to %s\n",
4016  paddress (gdbarch,
4017  regcache_read_pc (child_regcache)),
4018  paddress (gdbarch, parent_pc));
4019 
4020  regcache_write_pc (child_regcache, parent_pc);
4021  }
4022  }
4023 
4024  if (!ptid_equal (ecs->ptid, inferior_ptid))
4025  context_switch (ecs->ptid);
4026 
4027  /* Immediately detach breakpoints from the child before there's
4028  any chance of letting the user delete breakpoints from the
4029  breakpoint lists. If we don't do this early, it's easy to
4030  leave left over traps in the child, vis: "break foo; catch
4031  fork; c; <fork>; del; c; <child calls foo>". We only follow
4032  the fork on the last `continue', and by that time the
4033  breakpoint at "foo" is long gone from the breakpoint table.
4034  If we vforked, then we don't need to unpatch here, since both
4035  parent and child are sharing the same memory pages; we'll
4036  need to unpatch at follow/detach time instead to be certain
4037  that new breakpoints added between catchpoint hit time and
4038  vfork follow are detached. */
4039  if (ecs->ws.kind != TARGET_WAITKIND_VFORKED)
4040  {
4041  /* This won't actually modify the breakpoint list, but will
4042  physically remove the breakpoints from the child. */
4044  }
4045 
4047 
4048  /* In case the event is caught by a catchpoint, remember that
4049  the event is to be followed at the next resume of the thread,
4050  and not immediately. */
4051  ecs->event_thread->pending_follow = ecs->ws;
4052 
4054 
4057  stop_pc, ecs->ptid, &ecs->ws);
4058 
4059  /* If no catchpoint triggered for this, then keep going. Note
4060  that we're interested in knowing the bpstat actually causes a
4061  stop, not just if it may explain the signal. Software
4062  watchpoints, for example, always appear in the bpstat. */
4064  {
4065  ptid_t parent;
4066  ptid_t child;
4067  int should_resume;
4068  int follow_child
4069  = (follow_fork_mode_string == follow_fork_mode_child);
4070 
4071  ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4072 
4073  should_resume = follow_fork ();
4074 
4075  parent = ecs->ptid;
4076  child = ecs->ws.value.related_pid;
4077 
4078  /* In non-stop mode, also resume the other branch. */
4079  if (non_stop && !detach_fork)
4080  {
4081  if (follow_child)
4082  switch_to_thread (parent);
4083  else
4084  switch_to_thread (child);
4085 
4086  ecs->event_thread = inferior_thread ();
4087  ecs->ptid = inferior_ptid;
4088  keep_going (ecs);
4089  }
4090 
4091  if (follow_child)
4092  switch_to_thread (child);
4093  else
4094  switch_to_thread (parent);
4095 
4096  ecs->event_thread = inferior_thread ();
4097  ecs->ptid = inferior_ptid;
4098 
4099  if (should_resume)
4100  keep_going (ecs);
4101  else
4102  stop_waiting (ecs);
4103  return;
4104  }
4106  return;
4107 
4109  /* Done with the shared memory region. Re-insert breakpoints in
4110  the parent, and keep going. */
4111 
4112  if (debug_infrun)
4114  "infrun: TARGET_WAITKIND_VFORK_DONE\n");
4115 
4116  if (!ptid_equal (ecs->ptid, inferior_ptid))
4117  context_switch (ecs->ptid);
4118 
4121  /* This also takes care of reinserting breakpoints in the
4122  previously locked inferior. */
4123  keep_going (ecs);
4124  return;
4125 
4126  case TARGET_WAITKIND_EXECD:
4127  if (debug_infrun)
4128  fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n");
4129 
4130  if (!ptid_equal (ecs->ptid, inferior_ptid))
4131  context_switch (ecs->ptid);
4132 
4134 
4135  /* Do whatever is necessary to the parent branch of the vfork. */
4137 
4138  /* This causes the eventpoints and symbol table to be reset.
4139  Must do this now, before trying to determine whether to
4140  stop. */
4142 
4145  stop_pc, ecs->ptid, &ecs->ws);
4146 
4147  /* Note that this may be referenced from inside
4148  bpstat_stop_status above, through inferior_has_execd. */
4149  xfree (ecs->ws.value.execd_pathname);
4150  ecs->ws.value.execd_pathname = NULL;
4151 
4152  /* If no catchpoint triggered for this, then keep going. */
4154  {
4155  ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4156  keep_going (ecs);
4157  return;
4158  }
4160  return;
4161 
4162  /* Be careful not to try to gather much state about a thread
4163  that's in a syscall. It's frequently a losing proposition. */
4165  if (debug_infrun)
4167  "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n");
4168  /* Getting the current syscall number. */
4169  if (handle_syscall_event (ecs) == 0)
4171  return;
4172 
4173  /* Before examining the threads further, step this thread to
4174  get it entirely out of the syscall. (We get notice of the
4175  event when the thread is just on the verge of exiting a
4176  syscall. Stepping one instruction seems to get it back
4177  into user code.) */
4179  if (debug_infrun)
4181  "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n");
4182  if (handle_syscall_event (ecs) == 0)
4184  return;
4185 
4187  if (debug_infrun)
4188  fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n");
4189  ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig;
4190  handle_signal_stop (ecs);
4191  return;
4192 
4194  if (debug_infrun)
4195  fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n");
4196  /* Reverse execution: target ran out of history info. */
4197 
4201  stop_waiting (ecs);
4202  return;
4203  }
4204 }
4205 
4206 /* A wrapper around handle_inferior_event_1, which also makes sure
4207  that all temporary struct value objects that were created during
4208  the handling of the event get deleted at the end. */
4209 
4210 static void
4212 {
4213  struct value *mark = value_mark ();
4214 
4216  /* Purge all temporary values created during the event handling,
4217  as it could be a long time before we return to the command level
4218  where such values would otherwise be purged. */
4219  value_free_to_mark (mark);
4220 }
4221 
4222 /* Come here when the program has stopped with a signal. */
4223 
4224 static void
4226 {
4227  struct frame_info *frame;
4228  struct gdbarch *gdbarch;
4229  int stopped_by_watchpoint;
4230  enum stop_kind stop_soon;
4231  int random_signal;
4232 
4234 
4235  /* Do we need to clean up the state of a thread that has
4236  completed a displaced single-step? (Doing so usually affects
4237  the PC, so do it here, before we set stop_pc.) */
4238  displaced_step_fixup (ecs->ptid,
4240 
4241  /* If we either finished a single-step or hit a breakpoint, but
4242  the user wanted this thread to be stopped, pretend we got a
4243  SIG0 (generic unsignaled stop). */
4244  if (ecs->event_thread->stop_requested
4245  && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
4246  ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4247 
4249 
4250  if (debug_infrun)
4251  {
4252  struct regcache *regcache = get_thread_regcache (ecs->ptid);
4253  struct gdbarch *gdbarch = get_regcache_arch (regcache);
4254  struct cleanup *old_chain = save_inferior_ptid ();
4255 
4256  inferior_ptid = ecs->ptid;
4257 
4258  fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
4259  paddress (gdbarch, stop_pc));
4261  {
4262  CORE_ADDR addr;
4263 
4264  fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
4265 
4268  "infrun: stopped data address = %s\n",
4269  paddress (gdbarch, addr));
4270  else
4272  "infrun: (no data address available)\n");
4273  }
4274 
4275  do_cleanups (old_chain);
4276  }
4277 
4278  /* This is originated from start_remote(), start_inferior() and
4279  shared libraries hook functions. */
4280  stop_soon = get_inferior_stop_soon (ecs->ptid);
4281  if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE)
4282  {
4283  if (!ptid_equal (ecs->ptid, inferior_ptid))
4284  context_switch (ecs->ptid);
4285  if (debug_infrun)
4286  fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n");
4287  stop_print_frame = 1;
4288  stop_waiting (ecs);
4289  return;
4290  }
4291 
4292  if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4293  && stop_after_trap)
4294  {
4295  if (!ptid_equal (ecs->ptid, inferior_ptid))
4296  context_switch (ecs->ptid);
4297  if (debug_infrun)
4298  fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n");
4299  stop_print_frame = 0;
4300  stop_waiting (ecs);
4301  return;
4302  }
4303 
4304  /* This originates from attach_command(). We need to overwrite
4305  the stop_signal here, because some kernels don't ignore a
4306  SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
4307  See more comments in inferior.h. On the other hand, if we
4308  get a non-SIGSTOP, report it to the user - assume the backend
4309  will handle the SIGSTOP if it should show up later.
4310 
4311  Also consider that the attach is complete when we see a
4312  SIGTRAP. Some systems (e.g. Windows), and stubs supporting
4313  target extended-remote report it instead of a SIGSTOP
4314  (e.g. gdbserver). We already rely on SIGTRAP being our
4315  signal, so this is no exception.
4316 
4317  Also consider that the attach is complete when we see a
4318  GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
4319  the target to stop all threads of the inferior, in case the
4320  low level attach operation doesn't stop them implicitly. If
4321  they weren't stopped implicitly, then the stub will report a
4322  GDB_SIGNAL_0, meaning: stopped for no particular reason
4323  other than GDB's request. */
4324  if (stop_soon == STOP_QUIETLY_NO_SIGSTOP
4325  && (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_STOP
4326  || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4327  || ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_0))
4328  {
4329  stop_print_frame = 1;
4330  stop_waiting (ecs);
4331  ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4332  return;
4333  }
4334 
4335  /* See if something interesting happened to the non-current thread. If
4336  so, then switch to that thread. */
4337  if (!ptid_equal (ecs->ptid, inferior_ptid))
4338  {
4339  if (debug_infrun)
4340  fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n");
4341 
4342  context_switch (ecs->ptid);
4343 
4346  }
4347 
4348  /* At this point, get hold of the now-current thread's frame. */
4349  frame = get_current_frame ();
4350  gdbarch = get_frame_arch (frame);
4351 
4352  /* Pull the single step breakpoints out of the target. */
4353  if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP)
4354  {
4355  struct regcache *regcache;
4356  struct address_space *aspace;
4357  CORE_ADDR pc;
4358 
4359  regcache = get_thread_regcache (ecs->ptid);
4360  aspace = get_regcache_aspace (regcache);
4361  pc = regcache_read_pc (regcache);
4362 
4363  /* However, before doing so, if this single-step breakpoint was
4364  actually for another thread, set this thread up for moving
4365  past it. */
4367  aspace, pc))
4368  {
4369  if (single_step_breakpoint_inserted_here_p (aspace, pc))
4370  {
4371  if (debug_infrun)
4372  {
4374  "infrun: [%s] hit another thread's "
4375  "single-step breakpoint\n",
4376  target_pid_to_str (ecs->ptid));
4377  }
4378  ecs->hit_singlestep_breakpoint = 1;
4379  }
4380  }
4381  else
4382  {
4383  if (debug_infrun)
4384  {
4386  "infrun: [%s] hit its "
4387  "single-step breakpoint\n",
4388  target_pid_to_str (ecs->ptid));
4389  }
4390  }
4391  }
4393 
4394  if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4397  stopped_by_watchpoint = 0;
4398  else
4399  stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
4400 
4401  /* If necessary, step over this watchpoint. We'll be back to display
4402  it in a moment. */
4403  if (stopped_by_watchpoint
4406  {
4407  /* At this point, we are stopped at an instruction which has
4408  attempted to write to a piece of memory under control of
4409  a watchpoint. The instruction hasn't actually executed
4410  yet. If we were to evaluate the watchpoint expression
4411  now, we would get the old value, and therefore no change
4412  would seem to have occurred.
4413 
4414  In order to make watchpoints work `right', we really need
4415  to complete the memory write, and then evaluate the
4416  watchpoint expression. We do this by single-stepping the
4417  target.
4418 
4419  It may not be necessary to disable the watchpoint to step over
4420  it. For example, the PA can (with some kernel cooperation)
4421  single step over a watchpoint without disabling the watchpoint.
4422 
4423  It is far more common to need to disable a watchpoint to step
4424  the inferior over it. If we have non-steppable watchpoints,
4425  we must disable the current watchpoint; it's simplest to
4426  disable all watchpoints.
4427 
4428  Any breakpoint at PC must also be stepped over -- if there's
4429  one, it will have already triggered before the watchpoint
4430  triggered, and we either already reported it to the user, or
4431  it didn't cause a stop and we called keep_going. In either
4432  case, if there was a breakpoint at PC, we must be trying to
4433  step past it. */
4435  keep_going (ecs);
4436  return;
4437  }
4438 
4442  ecs->event_thread->control.stop_step = 0;
4443  stop_print_frame = 1;
4445 
4446  /* Hide inlined functions starting here, unless we just performed stepi or
4447  nexti. After stepi and nexti, always show the innermost frame (not any
4448  inline function call sites). */
4449  if (ecs->event_thread->control.step_range_end != 1)
4450  {
4451  struct address_space *aspace =
4453 
4454  /* skip_inline_frames is expensive, so we avoid it if we can
4455  determine that the address is one where functions cannot have
4456  been inlined. This improves performance with inferiors that
4457  load a lot of shared libraries, because the solib event
4458  breakpoint is defined as the address of a function (i.e. not
4459  inline). Note that we have to check the previous PC as well
4460  as the current one to catch cases when we have just
4461  single-stepped off a breakpoint prior to reinstating it.
4462  Note that we're assuming that the code we single-step to is
4463  not inline, but that's not definitive: there's nothing
4464  preventing the event breakpoint function from containing
4465  inlined code, and the single-step ending up there. If the
4466  user had set a breakpoint on that inlined code, the missing
4467  skip_inline_frames call would break things. Fortunately
4468  that's an extremely unlikely scenario. */
4469  if (!pc_at_non_inline_function (aspace, stop_pc, &ecs->ws)
4470  && !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4472  && pc_at_non_inline_function (aspace,
4473  ecs->event_thread->prev_pc,
4474  &ecs->ws)))
4475  {
4476  skip_inline_frames (ecs->ptid);
4477 
4478  /* Re-fetch current thread's frame in case that invalidated
4479  the frame cache. */
4480  frame = get_current_frame ();
4481  gdbarch = get_frame_arch (frame);
4482  }
4483  }
4484 
4485  if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4488  && currently_stepping (ecs->event_thread))
4489  {
4490  /* We're trying to step off a breakpoint. Turns out that we're
4491  also on an instruction that needs to be stepped multiple
4492  times before it's been fully executing. E.g., architectures
4493  with a delay slot. It needs to be stepped twice, once for
4494  the instruction and once for the delay slot. */
4495  int step_through_delay
4496  = gdbarch_single_step_through_delay (gdbarch, frame);
4497 
4498  if (debug_infrun && step_through_delay)
4499  fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
4500  if (ecs->event_thread->control.step_range_end == 0
4501  && step_through_delay)
4502  {
4503  /* The user issued a continue when stopped at a breakpoint.
4504  Set up for another trap and get out of here. */
4506  keep_going (ecs);
4507  return;
4508  }
4509  else if (step_through_delay)
4510  {
4511  /* The user issued a step when stopped at a breakpoint.
4512  Maybe we should stop, maybe we should not - the delay
4513  slot *might* correspond to a line of source. In any
4514  case, don't decide that here, just set
4515  ecs->stepping_over_breakpoint, making sure we
4516  single-step again before breakpoints are re-inserted. */
4518  }
4519  }
4520 
4521  /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
4522  handles this event. */
4525  stop_pc, ecs->ptid, &ecs->ws);
4526 
4527  /* Following in case break condition called a
4528  function. */
4529  stop_print_frame = 1;
4530 
4531  /* This is where we handle "moribund" watchpoints. Unlike
4532  software breakpoints traps, hardware watchpoint traps are
4533  always distinguishable from random traps. If no high-level
4534  watchpoint is associated with the reported stop data address
4535  anymore, then the bpstat does not explain the signal ---
4536  simply make sure to ignore it if `stopped_by_watchpoint' is
4537  set. */
4538 
4539  if (debug_infrun
4540  && ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4542  GDB_SIGNAL_TRAP)
4543  && stopped_by_watchpoint)
4545  "infrun: no user watchpoint explains "
4546  "watchpoint SIGTRAP, ignoring\n");
4547 
4548  /* NOTE: cagney/2003-03-29: These checks for a random signal
4549  at one stage in the past included checks for an inferior
4550  function call's call dummy's return breakpoint. The original
4551  comment, that went with the test, read:
4552 
4553  ``End of a stack dummy. Some systems (e.g. Sony news) give
4554  another signal besides SIGTRAP, so check here as well as
4555  above.''
4556 
4557  If someone ever tries to get call dummys on a
4558  non-executable stack to work (where the target would stop
4559  with something like a SIGSEGV), then those tests might need
4560  to be re-instated. Given, however, that the tests were only
4561  enabled when momentary breakpoints were not being used, I
4562  suspect that it won't be the case.
4563 
4564  NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
4565  be necessary for call dummies on a non-executable stack on
4566  SPARC. */
4567 
4568  /* See if the breakpoints module can explain the signal. */
4569  random_signal
4572 
4573  /* Maybe this was a trap for a software breakpoint that has since
4574  been removed. */
4575  if (random_signal && target_stopped_by_sw_breakpoint ())
4576  {
4577  if (program_breakpoint_here_p (gdbarch, stop_pc))
4578  {
4579  struct regcache *regcache;
4580  int decr_pc;
4581 
4582  /* Re-adjust PC to what the program would see if GDB was not
4583  debugging it. */
4584  regcache = get_thread_regcache (ecs->event_thread->ptid);
4585  decr_pc = gdbarch_decr_pc_after_break (gdbarch);
4586  if (decr_pc != 0)
4587  {
4588  struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
4589 
4590  if (record_full_is_used ())
4592 
4593  regcache_write_pc (regcache, stop_pc + decr_pc);
4594 
4595  do_cleanups (old_cleanups);
4596  }
4597  }
4598  else
4599  {
4600  /* A delayed software breakpoint event. Ignore the trap. */
4601  if (debug_infrun)
4603  "infrun: delayed software breakpoint "
4604  "trap, ignoring\n");
4605  random_signal = 0;
4606  }
4607  }
4608 
4609  /* Maybe this was a trap for a hardware breakpoint/watchpoint that
4610  has since been removed. */
4611  if (random_signal && target_stopped_by_hw_breakpoint ())
4612  {
4613  /* A delayed hardware breakpoint event. Ignore the trap. */
4614  if (debug_infrun)
4616  "infrun: delayed hardware breakpoint/watchpoint "
4617  "trap, ignoring\n");
4618  random_signal = 0;
4619  }
4620 
4621  /* If not, perhaps stepping/nexting can. */
4622  if (random_signal)
4623  random_signal = !(ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
4624  && currently_stepping (ecs->event_thread));
4625 
4626  /* Perhaps the thread hit a single-step breakpoint of _another_
4627  thread. Single-step breakpoints are transparent to the
4628  breakpoints module. */
4629  if (random_signal)
4630  random_signal = !ecs->hit_singlestep_breakpoint;
4631 
4632  /* No? Perhaps we got a moribund watchpoint. */
4633  if (random_signal)
4634  random_signal = !stopped_by_watchpoint;
4635 
4636  /* For the program's own signals, act according to
4637  the signal handling tables. */
4638 
4639  if (random_signal)
4640  {
4641  /* Signal not for debugging purposes. */
4642  struct inferior *inf = find_inferior_ptid (ecs->ptid);
4643  enum gdb_signal stop_signal = ecs->event_thread->suspend.stop_signal;
4644 
4645  if (debug_infrun)
4646  fprintf_unfiltered (gdb_stdlog, "infrun: random signal (%s)\n",
4647  gdb_signal_to_symbol_string (stop_signal));
4648 
4650 
4651  /* Always stop on signals if we're either just gaining control
4652  of the program, or the user explicitly requested this thread
4653  to remain stopped. */
4654  if (stop_soon != NO_STOP_QUIETLY
4655  || ecs->event_thread->stop_requested
4656  || (!inf->detaching
4658  {
4659  stop_waiting (ecs);
4660  return;
4661  }
4662 
4663  /* Notify observers the signal has "handle print" set. Note we
4664  returned early above if stopping; normal_stop handles the
4665  printing in that case. */
4666  if (signal_print[ecs->event_thread->suspend.stop_signal])
4667  {
4668  /* The signal table tells us to print about this signal. */
4672  }
4673 
4674  /* Clear the signal if it should not be passed. */
4675  if (signal_program[ecs->event_thread->suspend.stop_signal] == 0)
4676  ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
4677 
4678  if (ecs->event_thread->prev_pc == stop_pc
4680  && ecs->event_thread->control.step_resume_breakpoint == NULL)
4681  {
4682  /* We were just starting a new sequence, attempting to
4683  single-step off of a breakpoint and expecting a SIGTRAP.
4684  Instead this signal arrives. This signal will take us out
4685  of the stepping range so GDB needs to remember to, when
4686  the signal handler returns, resume stepping off that
4687  breakpoint. */
4688  /* To simplify things, "continue" is forced to use the same
4689  code paths as single-step - set a breakpoint at the
4690  signal return address and then, once hit, step off that
4691  breakpoint. */
4692  if (debug_infrun)
4694  "infrun: signal arrived while stepping over "
4695  "breakpoint\n");
4696 
4699  /* Reset trap_expected to ensure breakpoints are re-inserted. */
4701 
4702  /* If we were nexting/stepping some other thread, switch to
4703  it, so that we don't continue it, losing control. */
4704  if (!switch_back_to_stepped_thread (ecs))
4705  keep_going (ecs);
4706  return;
4707  }
4708 
4709  if (ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_0
4711  || ecs->event_thread->control.step_range_end == 1)
4712  && frame_id_eq (get_stack_frame_id (frame),
4714  && ecs->event_thread->control.step_resume_breakpoint == NULL)
4715  {
4716  /* The inferior is about to take a signal that will take it
4717  out of the single step range. Set a breakpoint at the
4718  current PC (which is presumably where the signal handler
4719  will eventually return) and then allow the inferior to
4720  run free.
4721 
4722  Note that this is only needed for a signal delivered
4723  while in the single-step range. Nested signals aren't a
4724  problem as they eventually all return. */
4725  if (debug_infrun)
4727  "infrun: signal may take us out of "
4728  "single-step range\n");
4729 
4732  /* Reset trap_expected to ensure breakpoints are re-inserted. */
4734  keep_going (ecs);
4735  return;
4736  }
4737 
4738  /* Note: step_resume_breakpoint may be non-NULL. This occures
4739  when either there's a nested signal, or when there's a
4740  pending signal enabled just as the signal handler returns
4741  (leaving the inferior at the step-resume-breakpoint without
4742  actually executing it). Either way continue until the
4743  breakpoint is really hit. */
4744 
4745  if (!switch_back_to_stepped_thread (ecs))
4746  {
4747  if (debug_infrun)
4749  "infrun: random signal, keep going\n");
4750 
4751  keep_going (ecs);
4752  }
4753  return;
4754  }
4755 
4757 }
4758 
4759 /* Come here when we've got some debug event / signal we can explain
4760  (IOW, not a random signal), and test whether it should cause a
4761  stop, or whether we should resume the inferior (transparently).
4762  E.g., could be a breakpoint whose condition evaluates false; we
4763  could be still stepping within the line; etc. */
4764 
4765 static void
4767 {
4768  struct symtab_and_line stop_pc_sal;
4769  struct frame_info *frame;
4770  struct gdbarch *gdbarch;
4771  CORE_ADDR jmp_buf_pc;
4772  struct bpstat_what what;
4773 
4774  /* Handle cases caused by hitting a breakpoint. */
4775 
4776  frame = get_current_frame ();
4777  gdbarch = get_frame_arch (frame);
4778 
4780 
4781  if (what.call_dummy)
4782  {
4784  }
4785 
4786  /* If we hit an internal event that triggers symbol changes, the
4787  current frame will be invalidated within bpstat_what (e.g., if we
4788  hit an internal solib event). Re-fetch it. */
4789  frame = get_current_frame ();
4790  gdbarch = get_frame_arch (frame);
4791 
4792  switch (what.main_action)
4793  {
4795  /* If we hit the breakpoint at longjmp while stepping, we
4796  install a momentary breakpoint at the target of the
4797  jmp_buf. */
4798 
4799  if (debug_infrun)
4801  "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n");
4802 
4804 
4805  if (what.is_longjmp)
4806  {
4807  struct value *arg_value;
4808 
4809  /* If we set the longjmp breakpoint via a SystemTap probe,
4810  then use it to extract the arguments. The destination PC
4811  is the third argument to the probe. */
4812  arg_value = probe_safe_evaluate_at_pc (frame, 2);
4813  if (arg_value)
4814  {
4815  jmp_buf_pc = value_as_address (arg_value);
4816  jmp_buf_pc = gdbarch_addr_bits_remove (gdbarch, jmp_buf_pc);
4817  }
4818  else if (!gdbarch_get_longjmp_target_p (gdbarch)
4819  || !gdbarch_get_longjmp_target (gdbarch,
4820  frame, &jmp_buf_pc))
4821  {
4822  if (debug_infrun)
4824  "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME "
4825  "(!gdbarch_get_longjmp_target)\n");
4826  keep_going (ecs);
4827  return;
4828  }
4829 
4830  /* Insert a breakpoint at resume address. */
4831  insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
4832  }
4833  else
4834  check_exception_resume (ecs, frame);
4835  keep_going (ecs);
4836  return;
4837 
4839  {
4840  struct frame_info *init_frame;
4841 
4842  /* There are several cases to consider.
4843 
4844  1. The initiating frame no longer exists. In this case we
4845  must stop, because the exception or longjmp has gone too
4846  far.
4847 
4848  2. The initiating frame exists, and is the same as the
4849  current frame. We stop, because the exception or longjmp
4850  has been caught.
4851 
4852  3. The initiating frame exists and is different from the
4853  current frame. This means the exception or longjmp has
4854  been caught beneath the initiating frame, so keep going.
4855 
4856  4. longjmp breakpoint has been placed just to protect
4857  against stale dummy frames and user is not interested in
4858  stopping around longjmps. */
4859 
4860  if (debug_infrun)
4862  "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n");
4863 
4865  != NULL);
4867 
4868  if (what.is_longjmp)
4869  {
4871 
4873  {
4874  /* Case 4. */
4875  keep_going (ecs);
4876  return;
4877  }
4878  }
4879 
4880  init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
4881 
4882  if (init_frame)
4883  {
4884  struct frame_id current_id
4886  if (frame_id_eq (current_id,
4888  {
4889  /* Case 2. Fall through. */
4890  }
4891  else
4892  {
4893  /* Case 3. */
4894  keep_going (ecs);
4895  return;
4896  }
4897  }
4898 
4899  /* For Cases 1 and 2, remove the step-resume breakpoint, if it
4900  exists. */
4902 
4903  end_stepping_range (ecs);
4904  }
4905  return;
4906 
4907  case BPSTAT_WHAT_SINGLE:
4908  if (debug_infrun)
4909  fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n");
4911  /* Still need to check other stuff, at least the case where we
4912  are stepping and step out of the right range. */
4913  break;
4914 
4916  if (debug_infrun)
4917  fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n");
4918 
4921  && execution_direction == EXEC_REVERSE)
4922  {
4923  struct thread_info *tp = ecs->event_thread;
4924 
4925  /* We are finishing a function in reverse, and just hit the
4926  step-resume breakpoint at the start address of the
4927  function, and we're almost there -- just need to back up
4928  by one more single-step, which should take us back to the
4929  function call. */
4931  keep_going (ecs);
4932  return;
4933  }
4934  fill_in_stop_func (gdbarch, ecs);
4935  if (stop_pc == ecs->stop_func_start
4936  && execution_direction == EXEC_REVERSE)
4937  {
4938  /* We are stepping over a function call in reverse, and just
4939  hit the step-resume breakpoint at the start address of
4940  the function. Go back to single-stepping, which should
4941  take us back to the function call. */
4943  keep_going (ecs);
4944  return;
4945  }
4946  break;
4947 
4949  if (debug_infrun)
4950  fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n");
4951  stop_print_frame = 1;
4952 
4953  /* Assume the thread stopped for a breapoint. We'll still check
4954  whether a/the breakpoint is there when the thread is next
4955  resumed. */
4957 
4958  stop_waiting (ecs);
4959  return;
4960 
4962  if (debug_infrun)
4963  fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n");
4964  stop_print_frame = 0;
4965 
4966  /* Assume the thread stopped for a breapoint. We'll still check
4967  whether a/the breakpoint is there when the thread is next
4968  resumed. */
4970  stop_waiting (ecs);
4971  return;
4972 
4974  if (debug_infrun)
4975  fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n");
4976 
4979  {
4980  /* Back when the step-resume breakpoint was inserted, we
4981  were trying to single-step off a breakpoint. Go back to
4982  doing that. */
4985  keep_going (ecs);
4986  return;
4987  }
4988  break;
4989 
4991  break;
4992  }
4993 
4994  /* If we stepped a permanent breakpoint and we had a high priority
4995  step-resume breakpoint for the address we stepped, but we didn't
4996  hit it, then we must have stepped into the signal handler. The
4997  step-resume was only necessary to catch the case of _not_
4998  stepping into the handler, so delete it, and fall through to
4999  checking whether the step finished. */
5000  if (ecs->event_thread->stepped_breakpoint)
5001  {
5002  struct breakpoint *sr_bp
5004 
5005  if (sr_bp != NULL
5006  && sr_bp->loc->permanent
5007  && sr_bp->type == bp_hp_step_resume
5008  && sr_bp->loc->address == ecs->event_thread->prev_pc)
5009  {
5010  if (debug_infrun)
5012  "infrun: stepped permanent breakpoint, stopped in "
5013  "handler\n");
5016  }
5017  }
5018 
5019  /* We come here if we hit a breakpoint but should not stop for it.
5020  Possibly we also were stepping and should stop for that. So fall
5021  through and test for stepping. But, if not stepping, do not
5022  stop. */
5023 
5024  /* In all-stop mode, if we're currently stepping but have stopped in
5025  some other thread, we need to switch back to the stepped thread. */
5027  return;
5028 
5030  {
5031  if (debug_infrun)
5033  "infrun: step-resume breakpoint is inserted\n");
5034 
5035  /* Having a step-resume breakpoint overrides anything
5036  else having to do with stepping commands until
5037  that breakpoint is reached. */
5038  keep_going (ecs);
5039  return;
5040  }
5041 
5042  if (ecs->event_thread->control.step_range_end == 0)
5043  {
5044  if (debug_infrun)
5045  fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n");
5046  /* Likewise if we aren't even stepping. */
5047  keep_going (ecs);
5048  return;
5049  }
5050 
5051  /* Re-fetch current thread's frame in case the code above caused
5052  the frame cache to be re-initialized, making our FRAME variable
5053  a dangling pointer. */
5054  frame = get_current_frame ();
5055  gdbarch = get_frame_arch (frame);
5056  fill_in_stop_func (gdbarch, ecs);
5057 
5058  /* If stepping through a line, keep going if still within it.
5059 
5060  Note that step_range_end is the address of the first instruction
5061  beyond the step range, and NOT the address of the last instruction
5062  within it!
5063 
5064  Note also that during reverse execution, we may be stepping
5065  through a function epilogue and therefore must detect when
5066  the current-frame changes in the middle of a line. */
5067 
5069  && (execution_direction != EXEC_REVERSE
5070  || frame_id_eq (get_frame_id (frame),
5072  {
5073  if (debug_infrun)
5075  (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
5076  paddress (gdbarch, ecs->event_thread->control.step_range_start),
5077  paddress (gdbarch, ecs->event_thread->control.step_range_end));
5078 
5079  /* Tentatively re-enable range stepping; `resume' disables it if
5080  necessary (e.g., if we're stepping over a breakpoint or we
5081  have software watchpoints). */
5083 
5084  /* When stepping backward, stop at beginning of line range
5085  (unless it's the function entry point, in which case
5086  keep going back to the call point). */
5088  && stop_pc != ecs->stop_func_start
5089  && execution_direction == EXEC_REVERSE)
5090  end_stepping_range (ecs);
5091  else
5092  keep_going (ecs);
5093 
5094  return;
5095  }
5096 
5097  /* We stepped out of the stepping range. */
5098 
5099  /* If we are stepping at the source level and entered the runtime
5100  loader dynamic symbol resolution code...
5101 
5102  EXEC_FORWARD: we keep on single stepping until we exit the run
5103  time loader code and reach the callee's address.
5104 
5105  EXEC_REVERSE: we've already executed the callee (backward), and
5106  the runtime loader code is handled just like any other
5107  undebuggable function call. Now we need only keep stepping
5108  backward through the trampoline code, and that's handled further
5109  down, so there is nothing for us to do here. */
5110 
5111  if (execution_direction != EXEC_REVERSE
5114  {
5115  CORE_ADDR pc_after_resolver =
5117 
5118  if (debug_infrun)
5120  "infrun: stepped into dynsym resolve code\n");
5121 
5122  if (pc_after_resolver)
5123  {
5124  /* Set up a step-resume breakpoint at the address
5125  indicated by SKIP_SOLIB_RESOLVER. */
5126  struct symtab_and_line sr_sal;
5127 
5128  init_sal (&sr_sal);
5129  sr_sal.pc = pc_after_resolver;
5130  sr_sal.pspace = get_frame_program_space (frame);
5131 
5133  sr_sal, null_frame_id);
5134  }
5135 
5136  keep_going (ecs);
5137  return;
5138  }
5139 
5140  if (ecs->event_thread->control.step_range_end != 1
5143  && get_frame_type (frame) == SIGTRAMP_FRAME)
5144  {
5145  if (debug_infrun)
5147  "infrun: stepped into signal trampoline\n");
5148  /* The inferior, while doing a "step" or "next", has ended up in
5149  a signal trampoline (either by a signal being delivered or by
5150  the signal handler returning). Just single-step until the
5151  inferior leaves the trampoline (either by calling the handler
5152  or returning). */
5153  keep_going (ecs);
5154  return;
5155  }
5156 
5157  /* If we're in the return path from a shared library trampoline,
5158  we want to proceed through the trampoline when stepping. */
5159  /* macro/2012-04-25: This needs to come before the subroutine
5160  call check below as on some targets return trampolines look
5161  like subroutine calls (MIPS16 return thunks). */
5163  stop_pc, ecs->stop_func_name)
5165  {
5166  /* Determine where this trampoline returns. */
5167  CORE_ADDR real_stop_pc;
5168 
5169  real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
5170 
5171  if (debug_infrun)
5173  "infrun: stepped into solib return tramp\n");
5174 
5175  /* Only proceed through if we know where it's going. */
5176  if (real_stop_pc)
5177  {
5178  /* And put the step-breakpoint there and go until there. */
5179  struct symtab_and_line sr_sal;
5180 
5181  init_sal (&sr_sal); /* initialize to zeroes */
5182  sr_sal.pc = real_stop_pc;
5183  sr_sal.section = find_pc_overlay (sr_sal.pc);
5184  sr_sal.pspace = get_frame_program_space (frame);
5185 
5186  /* Do not specify what the fp should be when we stop since
5187  on some machines the prologue is where the new fp value
5188  is established. */
5190  sr_sal, null_frame_id);
5191 
5192  /* Restart without fiddling with the step ranges or
5193  other state. */
5194  keep_going (ecs);
5195  return;
5196  }
5197  }
5198 
5199  /* Check for subroutine calls. The check for the current frame
5200  equalling the step ID is not necessary - the check of the
5201  previous frame's ID is sufficient - but it is a common case and
5202  cheaper than checking the previous frame's ID.
5203 
5204  NOTE: frame_id_eq will never report two invalid frame IDs as
5205  being equal, so to get into this block, both the current and
5206  previous frame must have valid frame IDs. */
5207  /* The outer_frame_id check is a heuristic to detect stepping
5208  through startup code. If we step over an instruction which
5209  sets the stack pointer from an invalid value to a valid value,
5210  we may detect that as a subroutine call from the mythical
5211  "outermost" function. This could be fixed by marking
5212  outermost frames as !stack_p,code_p,special_p. Then the
5213  initial outermost frame, before sp was valid, would
5214  have code_addr == &_start. See the comment in frame_id_eq
5215  for more. */
5216  if (!frame_id_eq (get_stack_frame_id (frame),
5223  != find_pc_function (stop_pc)))))
5224  {
5225  CORE_ADDR real_stop_pc;
5226 
5227  if (debug_infrun)
5228  fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n");
5229 
5231  {
5232  /* I presume that step_over_calls is only 0 when we're
5233  supposed to be stepping at the assembly language level
5234  ("stepi"). Just stop. */
5235  /* And this works the same backward as frontward. MVS */
5236  end_stepping_range (ecs);
5237  return;
5238  }
5239 
5240  /* Reverse stepping through solib trampolines. */
5241 
5242  if (execution_direction == EXEC_REVERSE
5244  && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
5245  || (ecs->stop_func_start == 0
5247  {
5248  /* Any solib trampoline code can be handled in reverse
5249  by simply continuing to single-step. We have already
5250  executed the solib function (backwards), and a few
5251  steps will take us back through the trampoline to the
5252  caller. */
5253  keep_going (ecs);
5254  return;
5255  }
5256 
5258  {
5259  /* We're doing a "next".
5260 
5261  Normal (forward) execution: set a breakpoint at the
5262  callee's return address (the address at which the caller
5263  will resume).
5264 
5265  Reverse (backward) execution. set the step-resume
5266  breakpoint at the start of the function that we just
5267  stepped into (backwards), and continue to there. When we
5268  get there, we'll need to single-step back to the caller. */
5269 
5270  if (execution_direction == EXEC_REVERSE)
5271  {
5272  /* If we're already at the start of the function, we've either
5273  just stepped backward into a single instruction function,
5274  or stepped back out of a signal handler to the first instruction
5275  of the function. Just keep going, which will single-step back
5276  to the caller. */
5277  if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
5278  {
5279  struct symtab_and_line sr_sal;
5280 
5281  /* Normal function call return (static or dynamic). */
5282  init_sal (&sr_sal);
5283  sr_sal.pc = ecs->stop_func_start;
5284  sr_sal.pspace = get_frame_program_space (frame);
5286  sr_sal, null_frame_id);
5287  }
5288  }
5289  else
5291 
5292  keep_going (ecs);
5293  return;
5294  }
5295 
5296  /* If we are in a function call trampoline (a stub between the
5297  calling routine and the real function), locate the real
5298  function. That's what tells us (a) whether we want to step
5299  into it at all, and (b) what prologue we want to run to the
5300  end of, if we do step into it. */
5301  real_stop_pc = skip_language_trampoline (frame, stop_pc);
5302  if (real_stop_pc == 0)
5303  real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
5304  if (real_stop_pc != 0)
5305  ecs->stop_func_start = real_stop_pc;
5306 
5307  if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
5308  {
5309  struct symtab_and_line sr_sal;
5310 
5311  init_sal (&sr_sal);
5312  sr_sal.pc = ecs->stop_func_start;
5313  sr_sal.pspace = get_frame_program_space (frame);
5314 
5316  sr_sal, null_frame_id);
5317  keep_going (ecs);
5318  return;
5319  }
5320 
5321  /* If we have line number information for the function we are
5322  thinking of stepping into and the function isn't on the skip
5323  list, step into it.
5324 
5325  If there are several symtabs at that PC (e.g. with include
5326  files), just want to know whether *any* of them have line
5327  numbers. find_pc_line handles this. */
5328  {
5329  struct symtab_and_line tmp_sal;
5330 
5331  tmp_sal = find_pc_line (ecs->stop_func_start, 0);
5332  if (tmp_sal.line != 0
5334  &tmp_sal))
5335  {
5336  if (execution_direction == EXEC_REVERSE)
5337  handle_step_into_function_backward (gdbarch, ecs);
5338  else
5339  handle_step_into_function (gdbarch, ecs);
5340  return;
5341  }
5342  }
5343 
5344  /* If we have no line number and the step-stop-if-no-debug is
5345  set, we stop the step so that the user has a chance to switch
5346  in assembly mode. */
5348  && step_stop_if_no_debug)
5349  {
5350  end_stepping_range (ecs);
5351  return;
5352  }
5353 
5354  if (execution_direction == EXEC_REVERSE)
5355  {
5356  /* If we're already at the start of the function, we've either just
5357  stepped backward into a single instruction function without line
5358  number info, or stepped back out of a signal handler to the first
5359  instruction of the function without line number info. Just keep
5360  going, which will single-step back to the caller. */
5361  if (ecs->stop_func_start != stop_pc)
5362  {
5363  /* Set a breakpoint at callee's start address.
5364  From there we can step once and be back in the caller. */
5365  struct symtab_and_line sr_sal;
5366 
5367  init_sal (&sr_sal);
5368  sr_sal.pc = ecs->stop_func_start;
5369  sr_sal.pspace = get_frame_program_space (frame);
5371  sr_sal, null_frame_id);
5372  }
5373  }
5374  else
5375  /* Set a breakpoint at callee's return address (the address
5376  at which the caller will resume). */
5378 
5379  keep_going (ecs);
5380  return;
5381  }
5382 
5383  /* Reverse stepping through solib trampolines. */
5384 
5385  if (execution_direction == EXEC_REVERSE
5387  {
5388  if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc)
5389  || (ecs->stop_func_start == 0
5391  {
5392  /* Any solib trampoline code can be handled in reverse
5393  by simply continuing to single-step. We have already
5394  executed the solib function (backwards), and a few
5395  steps will take us back through the trampoline to the
5396  caller. */
5397  keep_going (ecs);
5398  return;
5399  }
5401  {
5402  /* Stepped backward into the solib dynsym resolver.
5403  Set a breakpoint at its start and continue, then
5404  one more step will take us out. */
5405  struct symtab_and_line sr_sal;
5406 
5407  init_sal (&sr_sal);
5408  sr_sal.pc = ecs->stop_func_start;
5409  sr_sal.pspace = get_frame_program_space (frame);
5411  sr_sal, null_frame_id);
5412  keep_going (ecs);
5413  return;
5414  }
5415  }
5416 
5417  stop_pc_sal = find_pc_line (stop_pc, 0);
5418 
5419  /* NOTE: tausq/2004-05-24: This if block used to be done before all
5420  the trampoline processing logic, however, there are some trampolines
5421  that have no names, so we should do trampoline handling first. */
5423  && ecs->stop_func_name == NULL
5424  && stop_pc_sal.line == 0)
5425  {
5426  if (debug_infrun)
5428  "infrun: stepped into undebuggable function\n");
5429 
5430  /* The inferior just stepped into, or returned to, an
5431  undebuggable function (where there is no debugging information
5432  and no line number corresponding to the address where the
5433  inferior stopped). Since we want to skip this kind of code,
5434  we keep going until the inferior returns from this
5435  function - unless the user has asked us not to (via
5436  set step-mode) or we no longer know how to get back
5437  to the call site. */
5438  if (step_stop_if_no_debug
5439  || !frame_id_p (frame_unwind_caller_id (frame)))
5440  {
5441  /* If we have no line number and the step-stop-if-no-debug
5442  is set, we stop the step so that the user has a chance to
5443  switch in assembly mode. */
5444  end_stepping_range (ecs);
5445  return;
5446  }
5447  else
5448  {
5449  /* Set a breakpoint at callee's return address (the address
5450  at which the caller will resume). */
5452  keep_going (ecs);
5453  return;
5454  }
5455  }
5456 
5457  if (ecs->event_thread->control.step_range_end == 1)
5458  {
5459  /* It is stepi or nexti. We always want to stop stepping after
5460  one instruction. */
5461  if (debug_infrun)
5462  fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n");
5463  end_stepping_range (ecs);
5464  return;
5465  }
5466 
5467  if (stop_pc_sal.line == 0)
5468  {
5469  /* We have no line number information. That means to stop
5470  stepping (does this always happen right after one instruction,
5471  when we do "s" in a function with no line numbers,
5472  or can this happen as a result of a return or longjmp?). */
5473  if (debug_infrun)
5474  fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n");
5475  end_stepping_range (ecs);
5476  return;
5477  }
5478 
5479  /* Look for "calls" to inlined functions, part one. If the inline
5480  frame machinery detected some skipped call sites, we have entered
5481  a new inline function. */
5482 
5485  && inline_skipped_frames (ecs->ptid))
5486  {
5487  struct symtab_and_line call_sal;
5488 
5489  if (debug_infrun)
5491  "infrun: stepped into inlined function\n");
5492 
5493  find_frame_sal (get_current_frame (), &call_sal);
5494 
5496  {
5497  /* For "step", we're going to stop. But if the call site
5498  for this inlined function is on the same source line as
5499  we were previously stepping, go down into the function
5500  first. Otherwise stop at the call site. */
5501 
5502  if (call_sal.line == ecs->event_thread->current_line
5503  && call_sal.symtab == ecs->event_thread->current_symtab)
5505 
5506  end_stepping_range (ecs);
5507  return;
5508  }
5509  else
5510  {
5511  /* For "next", we should stop at the call site if it is on a
5512  different source line. Otherwise continue through the
5513  inlined function. */
5514  if (call_sal.line == ecs->event_thread->current_line
5515  && call_sal.symtab == ecs->event_thread->current_symtab)
5516  keep_going (ecs);
5517  else
5518  end_stepping_range (ecs);
5519  return;
5520  }
5521  }
5522 
5523  /* Look for "calls" to inlined functions, part two. If we are still
5524  in the same real function we were stepping through, but we have
5525  to go further up to find the exact frame ID, we are stepping
5526  through a more inlined call beyond its call site. */
5527 
5533  {
5534  if (debug_infrun)
5536  "infrun: stepping through inlined function\n");
5537 
5539  keep_going (ecs);
5540  else
5541  end_stepping_range (ecs);
5542  return;
5543  }
5544 
5545  if ((stop_pc == stop_pc_sal.pc)
5546  && (ecs->event_thread->current_line != stop_pc_sal.line
5547  || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
5548  {
5549  /* We are at the start of a different line. So stop. Note that
5550  we don't stop if we step into the middle of a different line.
5551  That is said to make things like for (;;) statements work
5552  better. */
5553  if (debug_infrun)
5555  "infrun: stepped to a different line\n");
5556  end_stepping_range (ecs);
5557  return;
5558  }
5559 
5560  /* We aren't done stepping.
5561 
5562  Optimize by setting the stepping range to the line.
5563  (We might not be in the original line, but if we entered a
5564  new line in mid-statement, we continue stepping. This makes
5565  things like for(;;) statements work better.) */
5566 
5567  ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
5568  ecs->event_thread->control.step_range_end = stop_pc_sal.end;
5570  set_step_info (frame, stop_pc_sal);
5571 
5572  if (debug_infrun)
5573  fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n");
5574  keep_going (ecs);
5575 }
5576 
5577 /* In all-stop mode, if we're currently stepping but have stopped in
5578  some other thread, we may need to switch back to the stepped
5579  thread. Returns true we set the inferior running, false if we left
5580  it stopped (and the event needs further processing). */
5581 
5582 static int
5584 {
5585  if (!non_stop)
5586  {
5587  struct thread_info *tp;
5588  struct thread_info *stepping_thread;
5589  struct thread_info *step_over;
5590 
5591  /* If any thread is blocked on some internal breakpoint, and we
5592  simply need to step over that breakpoint to get it going
5593  again, do that first. */
5594 
5595  /* However, if we see an event for the stepping thread, then we
5596  know all other threads have been moved past their breakpoints
5597  already. Let the caller check whether the step is finished,
5598  etc., before deciding to move it past a breakpoint. */
5599  if (ecs->event_thread->control.step_range_end != 0)
5600  return 0;
5601 
5602  /* Check if the current thread is blocked on an incomplete
5603  step-over, interrupted by a random signal. */
5605  && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
5606  {
5607  if (debug_infrun)
5608  {
5610  "infrun: need to finish step-over of [%s]\n",
5612  }
5613  keep_going (ecs);
5614  return 1;
5615  }
5616 
5617  /* Check if the current thread is blocked by a single-step
5618  breakpoint of another thread. */
5619  if (ecs->hit_singlestep_breakpoint)
5620  {
5621  if (debug_infrun)
5622  {
5624  "infrun: need to step [%s] over single-step "
5625  "breakpoint\n",
5626  target_pid_to_str (ecs->ptid));
5627  }
5628  keep_going (ecs);
5629  return 1;
5630  }
5631 
5632  /* Otherwise, we no longer expect a trap in the current thread.
5633  Clear the trap_expected flag before switching back -- this is
5634  what keep_going does as well, if we call it. */
5636 
5637  /* Likewise, clear the signal if it should not be passed. */
5638  if (!signal_program[ecs->event_thread->suspend.stop_signal])
5639  ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
5640 
5641  /* If scheduler locking applies even if not stepping, there's no
5642  need to walk over threads. Above we've checked whether the
5643  current thread is stepping. If some other thread not the
5644  event thread is stepping, then it must be that scheduler
5645  locking is not in effect. */
5646  if (schedlock_applies (ecs->event_thread))
5647  return 0;
5648 
5649  /* Look for the stepping/nexting thread, and check if any other
5650  thread other than the stepping thread needs to start a
5651  step-over. Do all step-overs before actually proceeding with
5652  step/next/etc. */
5653  stepping_thread = NULL;
5654  step_over = NULL;
5656  {
5657  /* Ignore threads of processes we're not resuming. */
5658  if (!sched_multi
5660  continue;
5661 
5662  /* When stepping over a breakpoint, we lock all threads
5663  except the one that needs to move past the breakpoint.
5664  If a non-event thread has this set, the "incomplete
5665  step-over" check above should have caught it earlier. */
5667 
5668  /* Did we find the stepping thread? */
5669  if (tp->control.step_range_end)
5670  {
5671  /* Yep. There should only one though. */
5672  gdb_assert (stepping_thread == NULL);
5673 
5674  /* The event thread is handled at the top, before we
5675  enter this loop. */
5676  gdb_assert (tp != ecs->event_thread);
5677 
5678  /* If some thread other than the event thread is
5679  stepping, then scheduler locking can't be in effect,
5680  otherwise we wouldn't have resumed the current event
5681  thread in the first place. */
5682  gdb_assert (!schedlock_applies (tp));
5683 
5684  stepping_thread = tp;
5685  }
5686  else if (thread_still_needs_step_over (tp))
5687  {
5688  step_over = tp;
5689 
5690  /* At the top we've returned early if the event thread
5691  is stepping. If some other thread not the event
5692  thread is stepping, then scheduler locking can't be
5693  in effect, and we can resume this thread. No need to
5694  keep looking for the stepping thread then. */
5695  break;
5696  }
5697  }
5698 
5699  if (step_over != NULL)
5700  {
5701  tp = step_over;
5702  if (debug_infrun)
5703  {
5705  "infrun: need to step-over [%s]\n",
5706  target_pid_to_str (tp->ptid));
5707  }
5708 
5709  /* Only the stepping thread should have this set. */
5710  gdb_assert (tp->control.step_range_end == 0);
5711 
5712  ecs->ptid = tp->ptid;
5713  ecs->event_thread = tp;
5714  switch_to_thread (ecs->ptid);
5715  keep_going (ecs);
5716  return 1;
5717  }
5718 
5719  if (stepping_thread != NULL)
5720  {
5721  struct frame_info *frame;
5722  struct gdbarch *gdbarch;
5723 
5724  tp = stepping_thread;
5725 
5726  /* If the stepping thread exited, then don't try to switch
5727  back and resume it, which could fail in several different
5728  ways depending on the target. Instead, just keep going.
5729 
5730  We can find a stepping dead thread in the thread list in
5731  two cases:
5732 
5733  - The target supports thread exit events, and when the
5734  target tries to delete the thread from the thread list,
5735  inferior_ptid pointed at the exiting thread. In such
5736  case, calling delete_thread does not really remove the
5737  thread from the list; instead, the thread is left listed,
5738  with 'exited' state.
5739 
5740  - The target's debug interface does not support thread
5741  exit events, and so we have no idea whatsoever if the
5742  previously stepping thread is still alive. For that
5743  reason, we need to synchronously query the target
5744  now. */
5745  if (is_exited (tp->ptid)
5746  || !target_thread_alive (tp->ptid))
5747  {
5748  if (debug_infrun)
5750  "infrun: not switching back to "
5751  "stepped thread, it has vanished\n");
5752 
5753  delete_thread (tp->ptid);
5754  keep_going (ecs);
5755  return 1;
5756  }
5757 
5758  if (debug_infrun)
5760  "infrun: switching back to stepped thread\n");
5761 
5762  ecs->event_thread = tp;
5763  ecs->ptid = tp->ptid;
5764  context_switch (ecs->ptid);
5765 
5767  frame = get_current_frame ();
5768  gdbarch = get_frame_arch (frame);
5769 
5770  /* If the PC of the thread we were trying to single-step has
5771  changed, then that thread has trapped or been signaled,
5772  but the event has not been reported to GDB yet. Re-poll
5773  the target looking for this particular thread's event
5774  (i.e. temporarily enable schedlock) by:
5775 
5776  - setting a break at the current PC
5777  - resuming that particular thread, only (by setting
5778  trap expected)
5779 
5780  This prevents us continuously moving the single-step
5781  breakpoint forward, one instruction at a time,
5782  overstepping. */
5783 
5784  if (stop_pc != tp->prev_pc)
5785  {
5786  ptid_t resume_ptid;
5787 
5788  if (debug_infrun)
5790  "infrun: expected thread advanced also\n");
5791 
5792  /* Clear the info of the previous step-over, as it's no
5793  longer valid. It's what keep_going would do too, if
5794  we called it. Must do this before trying to insert
5795  the sss breakpoint, otherwise if we were previously
5796  trying to step over this exact address in another
5797  thread, the breakpoint ends up not installed. */
5799 
5801  get_frame_address_space (frame),
5802  stop_pc);
5803 
5805  do_target_resume (resume_ptid,
5806  currently_stepping (tp), GDB_SIGNAL_0);
5807  prepare_to_wait (ecs);
5808  }
5809  else
5810  {
5811  if (debug_infrun)
5813  "infrun: expected thread still "
5814  "hasn't advanced\n");
5815  keep_going (ecs);
5816  }
5817 
5818  return 1;
5819  }
5820  }
5821  return 0;
5822 }
5823 
5824 /* Is thread TP in the middle of single-stepping? */
5825 
5826 static int
5828 {
5829  return ((tp->control.step_range_end
5830  && tp->control.step_resume_breakpoint == NULL)
5831  || tp->control.trap_expected
5832  || tp->stepped_breakpoint
5833  || bpstat_should_step ());
5834 }
5835 
5836 /* Inferior has stepped into a subroutine call with source code that
5837  we should not step over. Do step to the first line of code in
5838  it. */
5839 
5840 static void
5842  struct execution_control_state *ecs)
5843 {
5844  struct compunit_symtab *cust;
5845  struct symtab_and_line stop_func_sal, sr_sal;
5846 
5847  fill_in_stop_func (gdbarch, ecs);
5848 
5850  if (cust != NULL && compunit_language (cust) != language_asm)
5851  ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5852  ecs->stop_func_start);
5853 
5854  stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
5855  /* Use the step_resume_break to step until the end of the prologue,
5856  even if that involves jumps (as it seems to on the vax under
5857  4.2). */
5858  /* If the prologue ends in the middle of a source line, continue to
5859  the end of that source line (if it is still within the function).
5860  Otherwise, just go to end of prologue. */
5861  if (stop_func_sal.end
5862  && stop_func_sal.pc != ecs->stop_func_start
5863  && stop_func_sal.end < ecs->stop_func_end)
5864  ecs->stop_func_start = stop_func_sal.end;
5865 
5866  /* Architectures which require breakpoint adjustment might not be able
5867  to place a breakpoint at the computed address. If so, the test
5868  ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
5869  ecs->stop_func_start to an address at which a breakpoint may be
5870  legitimately placed.
5871 
5872  Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
5873  made, GDB will enter an infinite loop when stepping through
5874  optimized code consisting of VLIW instructions which contain
5875  subinstructions corresponding to different source lines. On
5876  FR-V, it's not permitted to place a breakpoint on any but the
5877  first subinstruction of a VLIW instruction. When a breakpoint is
5878  set, GDB will adjust the breakpoint address to the beginning of
5879  the VLIW instruction. Thus, we need to make the corresponding
5880  adjustment here when computing the stop address. */
5881 
5883  {
5884  ecs->stop_func_start
5886  ecs->stop_func_start);
5887  }
5888 
5889  if (ecs->stop_func_start == stop_pc)
5890  {
5891  /* We are already there: stop now. */
5892  end_stepping_range (ecs);
5893  return;
5894  }
5895  else
5896  {
5897  /* Put the step-breakpoint there and go until there. */
5898  init_sal (&sr_sal); /* initialize to zeroes */
5899  sr_sal.pc = ecs->stop_func_start;
5900  sr_sal.section = find_pc_overlay (ecs->stop_func_start);
5902 
5903  /* Do not specify what the fp should be when we stop since on
5904  some machines the prologue is where the new fp value is
5905  established. */
5907 
5908  /* And make sure stepping stops right away then. */
5911  }
5912  keep_going (ecs);
5913 }
5914 
5915 /* Inferior has stepped backward into a subroutine call with source
5916  code that we should not step over. Do step to the beginning of the
5917  last line of code in it. */
5918 
5919 static void
5921  struct execution_control_state *ecs)
5922 {
5923  struct compunit_symtab *cust;
5924  struct symtab_and_line stop_func_sal;
5925 
5926  fill_in_stop_func (gdbarch, ecs);
5927 
5929  if (cust != NULL && compunit_language (cust) != language_asm)
5930  ecs->stop_func_start = gdbarch_skip_prologue (gdbarch,
5931  ecs->stop_func_start);
5932 
5933  stop_func_sal = find_pc_line (stop_pc, 0);
5934 
5935  /* OK, we're just going to keep stepping here. */
5936  if (stop_func_sal.pc == stop_pc)
5937  {
5938  /* We're there already. Just stop stepping now. */
5939  end_stepping_range (ecs);
5940  }
5941  else
5942  {
5943  /* Else just reset the step range and keep going.
5944  No step-resume breakpoint, they don't work for
5945  epilogues, which can have multiple entry paths. */
5946  ecs->event_thread->control.step_range_start = stop_func_sal.pc;
5947  ecs->event_thread->control.step_range_end = stop_func_sal.end;
5948  keep_going (ecs);
5949  }
5950  return;
5951 }
5952 
5953 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
5954  This is used to both functions and to skip over code. */
5955 
5956 static void
5958  struct symtab_and_line sr_sal,
5959  struct frame_id sr_id,
5960  enum bptype sr_type)
5961 {
5962  /* There should never be more than one step-resume or longjmp-resume
5963  breakpoint per thread, so we should never be setting a new
5964  step_resume_breakpoint when one is already active. */
5965  gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL);
5966  gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume);
5967 
5968  if (debug_infrun)
5970  "infrun: inserting step-resume breakpoint at %s\n",
5971  paddress (gdbarch, sr_sal.pc));
5972 
5974  = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type);
5975 }
5976 
5977 void
5979  struct symtab_and_line sr_sal,
5980  struct frame_id sr_id)
5981 {
5983  sr_sal, sr_id,
5984  bp_step_resume);
5985 }
5986 
5987 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
5988  This is used to skip a potential signal handler.
5989 
5990  This is called with the interrupted function's frame. The signal
5991  handler, when it returns, will resume the interrupted function at
5992  RETURN_FRAME.pc. */
5993 
5994 static void
5996 {
5997  struct symtab_and_line sr_sal;
5998  struct gdbarch *gdbarch;
5999 
6000  gdb_assert (return_frame != NULL);
6001  init_sal (&sr_sal); /* initialize to zeros */
6002 
6003  gdbarch = get_frame_arch (return_frame);
6004  sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
6005  sr_sal.section = find_pc_overlay (sr_sal.pc);
6006  sr_sal.pspace = get_frame_program_space (return_frame);
6007 
6008  insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal,
6009  get_stack_frame_id (return_frame),
6011 }
6012 
6013 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
6014  is used to skip a function after stepping into it (for "next" or if
6015  the called function has no debugging information).
6016 
6017  The current function has almost always been reached by single
6018  stepping a call or return instruction. NEXT_FRAME belongs to the
6019  current function, and the breakpoint will be set at the caller's
6020  resume address.
6021 
6022  This is a separate function rather than reusing
6023  insert_hp_step_resume_breakpoint_at_frame in order to avoid
6024  get_prev_frame, which may stop prematurely (see the implementation
6025  of frame_unwind_caller_id for an example). */
6026 
6027 static void
6029 {
6030  struct symtab_and_line sr_sal;
6031  struct gdbarch *gdbarch;
6032 
6033  /* We shouldn't have gotten here if we don't know where the call site
6034  is. */
6035  gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame)));
6036 
6037  init_sal (&sr_sal); /* initialize to zeros */
6038 
6039  gdbarch = frame_unwind_caller_arch (next_frame);
6040  sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
6041  frame_unwind_caller_pc (next_frame));
6042  sr_sal.section = find_pc_overlay (sr_sal.pc);
6043  sr_sal.pspace = frame_unwind_program_space (next_frame);
6044 
6045  insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
6046  frame_unwind_caller_id (next_frame));
6047 }
6048 
6049 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
6050  new breakpoint at the target of a jmp_buf. The handling of
6051  longjmp-resume uses the same mechanisms used for handling
6052  "step-resume" breakpoints. */
6053 
6054 static void
6056 {
6057  /* There should never be more than one longjmp-resume breakpoint per
6058  thread, so we should never be setting a new
6059  longjmp_resume_breakpoint when one is already active. */
6060  gdb_assert (inferior_thread ()->control.exception_resume_breakpoint == NULL);
6061 
6062  if (debug_infrun)
6064  "infrun: inserting longjmp-resume breakpoint at %s\n",
6065  paddress (gdbarch, pc));
6066 
6069 }
6070 
6071 /* Insert an exception resume breakpoint. TP is the thread throwing
6072  the exception. The block B is the block of the unwinder debug hook
6073  function. FRAME is the frame corresponding to the call to this
6074  function. SYM is the symbol of the function argument holding the
6075  target PC of the exception. */
6076 
6077 static void
6079  const struct block *b,
6080  struct frame_info *frame,
6081  struct symbol *sym)
6082 {
6083  TRY
6084  {
6085  struct symbol *vsym;
6086  struct value *value;
6087  CORE_ADDR handler;
6088  struct breakpoint *bp;
6089 
6090  vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
6091  value = read_var_value (vsym, frame);
6092  /* If the value was optimized out, revert to the old behavior. */
6093  if (! value_optimized_out (value))
6094  {
6095  handler = value_as_address (value);
6096 
6097  if (debug_infrun)
6099  "infrun: exception resume at %lx\n",
6100  (unsigned long) handler);
6101 
6103  handler, bp_exception_resume);
6104 
6105  /* set_momentary_breakpoint_at_pc invalidates FRAME. */
6106  frame = NULL;
6107 
6108  bp->thread = tp->num;
6110  }
6111  }
6113  {
6114  /* We want to ignore errors here. */
6115  }
6116  END_CATCH
6117 }
6118 
6119 /* A helper for check_exception_resume that sets an
6120  exception-breakpoint based on a SystemTap probe. */
6121 
6122 static void
6124  const struct bound_probe *probe,
6125  struct frame_info *frame)
6126 {
6127  struct value *arg_value;
6128  CORE_ADDR handler;
6129  struct breakpoint *bp;
6130 
6131  arg_value = probe_safe_evaluate_at_pc (frame, 1);
6132  if (!arg_value)
6133  return;
6134 
6135  handler = value_as_address (arg_value);
6136 
6137  if (debug_infrun)
6139  "infrun: exception resume at %s\n",
6140  paddress (get_objfile_arch (probe->objfile),
6141  handler));
6142 
6144  handler, bp_exception_resume);
6145  bp->thread = tp->num;
6147 }
6148 
6149 /* This is called when an exception has been intercepted. Check to
6150  see whether the exception's destination is of interest, and if so,
6151  set an exception resume breakpoint there. */
6152 
6153 static void
6155  struct frame_info *frame)
6156 {
6157  struct bound_probe probe;
6158  struct symbol *func;
6159 
6160  /* First see if this exception unwinding breakpoint was set via a
6161  SystemTap probe point. If so, the probe has two arguments: the
6162  CFA and the HANDLER. We ignore the CFA, extract the handler, and
6163  set a breakpoint there. */
6164  probe = find_probe_by_pc (get_frame_pc (frame));
6165  if (probe.probe)
6166  {
6167  insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
6168  return;
6169  }
6170 
6171  func = get_frame_function (frame);
6172  if (!func)
6173  return;
6174 
6175  TRY
6176  {
6177  const struct block *b;
6178  struct block_iterator iter;
6179  struct symbol *sym;
6180  int argno = 0;
6181 
6182  /* The exception breakpoint is a thread-specific breakpoint on
6183  the unwinder's debug hook, declared as:
6184 
6185  void _Unwind_DebugHook (void *cfa, void *handler);
6186 
6187  The CFA argument indicates the frame to which control is
6188  about to be transferred. HANDLER is the destination PC.
6189 
6190  We ignore the CFA and set a temporary breakpoint at HANDLER.
6191  This is not extremely efficient but it avoids issues in gdb
6192  with computing the DWARF CFA, and it also works even in weird
6193  cases such as throwing an exception from inside a signal
6194  handler. */
6195 
6196  b = SYMBOL_BLOCK_VALUE (func);
6197  ALL_BLOCK_SYMBOLS (b, iter, sym)
6198  {
6199  if (!SYMBOL_IS_ARGUMENT (sym))
6200  continue;
6201 
6202  if (argno == 0)
6203  ++argno;
6204  else
6205  {
6207  b, frame, sym);
6208  break;
6209  }
6210  }
6211  }
6213  {
6214  }
6215  END_CATCH
6216 }
6217 
6218 static void
6220 {
6221  if (debug_infrun)
6222  fprintf_unfiltered (gdb_stdlog, "infrun: stop_waiting\n");
6223 
6225 
6226  /* Let callers know we don't want to wait for the inferior anymore. */
6227  ecs->wait_some_more = 0;
6228 }
6229 
6230 /* Called when we should continue running the inferior, because the
6231  current event doesn't cause a user visible stop. This does the
6232  resuming part; waiting for the next event is done elsewhere. */
6233 
6234 static void
6236 {
6237  /* Make sure normal_stop is called if we get a QUIT handled before
6238  reaching resume. */
6239  struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0);
6240 
6241  /* Save the pc before execution, to compare with pc after stop. */
6242  ecs->event_thread->prev_pc
6244 
6246  && ecs->event_thread->suspend.stop_signal != GDB_SIGNAL_TRAP)
6247  {
6248  /* We haven't yet gotten our trap, and either: intercepted a
6249  non-signal event (e.g., a fork); or took a signal which we
6250  are supposed to pass through to the inferior. Simply
6251  continue. */
6252  discard_cleanups (old_cleanups);
6254  }
6255  else
6256  {
6257  struct regcache *regcache = get_current_regcache ();
6258  int remove_bp;
6259  int remove_wps;
6260 
6261  /* Either the trap was not expected, but we are continuing
6262  anyway (if we got a signal, the user asked it be passed to
6263  the child)
6264  -- or --
6265  We got our expected trap, but decided we should resume from
6266  it.
6267 
6268  We're going to run this baby now!
6269 
6270  Note that insert_breakpoints won't try to re-insert
6271  already inserted breakpoints. Therefore, we don't
6272  care if breakpoints were already inserted, or not. */
6273 
6274  /* If we need to step over a breakpoint, and we're not using
6275  displaced stepping to do so, insert all breakpoints
6276  (watchpoints, etc.) but the one we're stepping over, step one
6277  instruction, and then re-insert the breakpoint when that step
6278  is finished. */
6279 
6280  remove_bp = (ecs->hit_singlestep_breakpoint
6282  remove_wps = (ecs->event_thread->stepping_over_watchpoint
6284 
6285  /* We can't use displaced stepping if we need to step past a
6286  watchpoint. The instruction copied to the scratch pad would
6287  still trigger the watchpoint. */
6288  if (remove_bp
6289  && (remove_wps
6290  || !use_displaced_stepping (get_regcache_arch (regcache))))
6291  {
6293  regcache_read_pc (regcache), remove_wps);
6294  }
6295  else if (remove_wps)
6296  set_step_over_info (NULL, 0, remove_wps);
6297  else
6299 
6300  /* Stop stepping if inserting breakpoints fails. */
6301  TRY
6302  {
6303  insert_breakpoints ();
6304  }
6306  {
6308  stop_waiting (ecs);
6309  discard_cleanups (old_cleanups);
6310  return;
6311  }
6312  END_CATCH
6313 
6314  ecs->event_thread->control.trap_expected = (remove_bp || remove_wps);
6315 
6316  /* Do not deliver GDB_SIGNAL_TRAP (except when the user
6317  explicitly specifies that such a signal should be delivered
6318  to the target program). Typically, that would occur when a
6319  user is debugging a target monitor on a simulator: the target
6320  monitor sets a breakpoint; the simulator encounters this
6321  breakpoint and halts the simulation handing control to GDB;
6322  GDB, noting that the stop address doesn't map to any known
6323  breakpoint, returns control back to the simulator; the
6324  simulator then delivers the hardware equivalent of a
6325  GDB_SIGNAL_TRAP to the program being debugged. */
6326  if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP
6327  && !signal_program[ecs->event_thread->suspend.stop_signal])
6328  ecs->event_thread->suspend.stop_signal = GDB_SIGNAL_0;
6329 
6330  discard_cleanups (old_cleanups);
6332  }
6333 
6334  prepare_to_wait (ecs);
6335 }
6336 
6337 /* This function normally comes after a resume, before
6338  handle_inferior_event exits. It takes care of any last bits of
6339  housekeeping, and sets the all-important wait_some_more flag. */
6340 
6341 static void
6343 {
6344  if (debug_infrun)
6345  fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n");
6346 
6347  /* This is the old end of the while loop. Let everybody know we
6348  want to wait for the inferior some more and get called again
6349  soon. */
6350  ecs->wait_some_more = 1;
6351 }
6352 
6353 /* We are done with the step range of a step/next/si/ni command.
6354  Called once for each n of a "step n" operation. */
6355 
6356 static void
6358 {
6359  ecs->event_thread->control.stop_step = 1;
6360  stop_waiting (ecs);
6361 }
6362 
6363 /* Several print_*_reason functions to print why the inferior has stopped.
6364  We always print something when the inferior exits, or receives a signal.
6365  The rest of the cases are dealt with later on in normal_stop and
6366  print_it_typical. Ideally there should be a call to one of these
6367  print_*_reason functions functions from handle_inferior_event each time
6368  stop_waiting is called.
6369 
6370  Note that we don't call these directly, instead we delegate that to
6371  the interpreters, through observers. Interpreters then call these
6372  with whatever uiout is right. */
6373 
6374 void
6376 {
6377  /* For CLI-like interpreters, print nothing. */
6378 
6379  if (ui_out_is_mi_like_p (uiout))
6380  {
6381  ui_out_field_string (uiout, "reason",
6383  }
6384 }
6385 
6386 void
6387 print_signal_exited_reason (struct ui_out *uiout, enum gdb_signal siggnal)
6388 {
6389  annotate_signalled ();
6390  if (ui_out_is_mi_like_p (uiout))
6392  (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED));
6393  ui_out_text (uiout, "\nProgram terminated with signal ");
6395  ui_out_field_string (uiout, "signal-name",
6396  gdb_signal_to_name (siggnal));
6398  ui_out_text (uiout, ", ");
6400  ui_out_field_string (uiout, "signal-meaning",
6401  gdb_signal_to_string (siggnal));
6403  ui_out_text (uiout, ".\n");
6404  ui_out_text (uiout, "The program no longer exists.\n");
6405 }
6406 
6407 void
6408 print_exited_reason (struct ui_out *uiout, int exitstatus)
6409 {
6410  struct inferior *inf = current_inferior ();
6411  const char *pidstr = target_pid_to_str (pid_to_ptid (inf->pid));
6412 
6413  annotate_exited (exitstatus);
6414  if (exitstatus)
6415  {
6416  if (ui_out_is_mi_like_p (uiout))
6417  ui_out_field_string (uiout, "reason",
6419  ui_out_text (uiout, "[Inferior ");
6420  ui_out_text (uiout, plongest (inf->num));
6421  ui_out_text (uiout, " (");
6422  ui_out_text (uiout, pidstr);
6423  ui_out_text (uiout, ") exited with code ");
6424  ui_out_field_fmt (uiout, "exit-code", "0%o", (unsigned int) exitstatus);
6425  ui_out_text (uiout, "]\n");
6426  }
6427  else
6428  {
6429  if (ui_out_is_mi_like_p (uiout))
6431  (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY));
6432  ui_out_text (uiout, "[Inferior ");
6433  ui_out_text (uiout, plongest (inf->num));
6434  ui_out_text (uiout, " (");
6435  ui_out_text (uiout, pidstr);
6436  ui_out_text (uiout, ") exited normally]\n");
6437  }
6438 }
6439 
6440 void
6441 print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal)
6442 {
6443  annotate_signal ();
6444 
6445  if (siggnal == GDB_SIGNAL_0 && !ui_out_is_mi_like_p (uiout))
6446  {
6447  struct thread_info *t = inferior_thread ();
6448 
6449  ui_out_text (uiout, "\n[");
6450  ui_out_field_string (uiout, "thread-name",
6451  target_pid_to_str (t->ptid));
6452  ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num);
6453  ui_out_text (uiout, " stopped");
6454  }
6455  else
6456  {
6457  ui_out_text (uiout, "\nProgram received signal ");
6459  if (ui_out_is_mi_like_p (uiout))
6461  (uiout, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED));
6462  ui_out_field_string (uiout, "signal-name",
6463  gdb_signal_to_name (siggnal));
6465  ui_out_text (uiout, ", ");
6467  ui_out_field_string (uiout, "signal-meaning",
6468  gdb_signal_to_string (siggnal));
6470  }
6471  ui_out_text (uiout, ".\n");
6472 }
6473 
6474 void
6476 {
6477  ui_out_text (uiout, "\nNo more reverse-execution history.\n");
6478 }
6479 
6480 /* Print current location without a level number, if we have changed
6481  functions or hit a breakpoint. Print source line if we have one.
6482  bpstat_print contains the logic deciding in detail what to print,
6483  based on the event(s) that just occurred. */
6484 
6485 void
6487 {
6488  int bpstat_ret;
6489  int source_flag;
6490  int do_frame_printing = 1;
6491  struct thread_info *tp = inferior_thread ();
6492 
6493  bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind);
6494  switch (bpstat_ret)
6495  {
6496  case PRINT_UNKNOWN:
6497  /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
6498  should) carry around the function and does (or should) use
6499  that when doing a frame comparison. */
6500  if (tp->control.stop_step
6504  {
6505  /* Finished step, just print source line. */
6506  source_flag = SRC_LINE;
6507  }
6508  else
6509  {
6510  /* Print location and source line. */
6511  source_flag = SRC_AND_LOC;
6512  }
6513  break;
6514  case PRINT_SRC_AND_LOC:
6515  /* Print location and source line. */
6516  source_flag = SRC_AND_LOC;
6517  break;
6518  case PRINT_SRC_ONLY:
6519  source_flag = SRC_LINE;
6520  break;
6521  case PRINT_NOTHING:
6522  /* Something bogus. */
6523  source_flag = SRC_LINE;
6524  do_frame_printing = 0;
6525  break;
6526  default:
6527  internal_error (__FILE__, __LINE__, _("Unknown value."));
6528  }
6529 
6530  /* The behavior of this routine with respect to the source
6531  flag is:
6532  SRC_LINE: Print only source line
6533  LOCATION: Print only location
6534  SRC_AND_LOC: Print location and source line. */
6535  if (do_frame_printing)
6536  print_stack_frame (get_selected_frame (NULL), 0, source_flag, 1);
6537 
6538  /* Display the auto-display expressions. */
6539  do_displays ();
6540 }
6541 
6542 /* Here to return control to GDB when the inferior stops for real.
6543  Print appropriate messages, remove breakpoints, give terminal our modes.
6544 
6545  STOP_PRINT_FRAME nonzero means print the executing frame
6546  (pc, function, args, file, line number and line text).
6547  BREAKPOINTS_FAILED nonzero means stop was due to error
6548  attempting to insert breakpoints. */
6549 
6550 void
6552 {
6553  struct target_waitstatus last;
6554  ptid_t last_ptid;
6555  struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
6556 
6557  get_last_target_status (&last_ptid, &last);
6558 
6559  /* If an exception is thrown from this point on, make sure to
6560  propagate GDB's knowledge of the executing state to the
6561  frontend/user running state. A QUIT is an easy exception to see
6562  here, so do this before any filtered output. */
6563  if (!non_stop)
6565  else if (last.kind != TARGET_WAITKIND_SIGNALLED
6566  && last.kind != TARGET_WAITKIND_EXITED
6567  && last.kind != TARGET_WAITKIND_NO_RESUMED)
6569 
6570  /* As we're presenting a stop, and potentially removing breakpoints,
6571  update the thread list so we can tell whether there are threads
6572  running on the target. With target remote, for example, we can
6573  only learn about new threads when we explicitly update the thread
6574  list. Do this before notifying the interpreters about signal
6575  stops, end of stepping ranges, etc., so that the "new thread"
6576  output is emitted before e.g., "Program received signal FOO",
6577  instead of after. */
6578  update_thread_list ();
6579 
6581  observer_notify_signal_received (inferior_thread ()->suspend.stop_signal);
6582 
6583  /* As with the notification of thread events, we want to delay
6584  notifying the user that we've switched thread context until
6585  the inferior actually stops.
6586 
6587  There's no point in saying anything if the inferior has exited.
6588  Note that SIGNALLED here means "exited with a signal", not
6589  "received a signal".
6590 
6591  Also skip saying anything in non-stop mode. In that mode, as we
6592  don't want GDB to switch threads behind the user's back, to avoid
6593  races where the user is typing a command to apply to thread x,
6594  but GDB switches to thread y before the user finishes entering
6595  the command, fetch_inferior_event installs a cleanup to restore
6596  the current thread back to the thread the user had selected right
6597  after this event is handled, so we're not really switching, only
6598  informing of a stop. */
6599  if (!non_stop
6600  && !ptid_equal (previous_inferior_ptid, inferior_ptid)
6602  && last.kind != TARGET_WAITKIND_SIGNALLED
6603  && last.kind != TARGET_WAITKIND_EXITED
6604  && last.kind != TARGET_WAITKIND_NO_RESUMED)
6605  {
6607  printf_filtered (_("[Switching to %s]\n"),
6610  previous_inferior_ptid = inferior_ptid;
6611  }
6612 
6613  if (last.kind == TARGET_WAITKIND_NO_RESUMED)
6614  {
6615  gdb_assert (sync_execution || !target_can_async_p ());
6616 
6618  printf_filtered (_("No unwaited-for children left.\n"));
6619  }
6620 
6621  /* Note: this depends on the update_thread_list call above. */
6623  {
6624  if (remove_breakpoints ())
6625  {
6627  printf_filtered (_("Cannot remove breakpoints because "
6628  "program is no longer writable.\nFurther "
6629  "execution is probably impossible.\n"));
6630  }
6631  }
6632 
6633  /* If an auto-display called a function and that got a signal,
6634  delete that auto-display to avoid an infinite recursion. */
6635 
6638 
6639  /* Notify observers if we finished a "step"-like command, etc. */
6641  && last.kind != TARGET_WAITKIND_SIGNALLED
6642  && last.kind != TARGET_WAITKIND_EXITED
6643  && inferior_thread ()->control.stop_step)
6644  {
6645  /* But not if in the middle of doing a "step n" operation for
6646  n > 1 */
6647  if (inferior_thread ()->step_multi)
6648  goto done;
6649 
6651  }
6652 
6654  async_enable_stdin ();
6655 
6656  /* Set the current source location. This will also happen if we
6657  display the frame below, but the current SAL will be incorrect
6658  during a user hook-stop function. */
6661 
6662  /* Let the user/frontend see the threads as stopped, but defer to
6663  call_function_by_hand if the thread finished an infcall
6664  successfully. We may be e.g., evaluating a breakpoint condition.
6665  In that case, the thread had state THREAD_RUNNING before the
6666  infcall, and shall remain marked running, all without informing
6667  the user/frontend about state transition changes. */
6669  && inferior_thread ()->control.in_infcall
6671  discard_cleanups (old_chain);
6672  else
6673  do_cleanups (old_chain);
6674 
6675  /* Look up the hook_stop and run it (CLI internally handles problem
6676  of stop_command's pre-hook not existing). */
6677  if (stop_command)
6678  catch_errors (hook_stop_stub, stop_command,
6679  "Error while running hook_stop:\n", RETURN_MASK_ALL);
6680 
6681  if (!has_stack_frames ())
6682  goto done;
6683 
6684  if (last.kind == TARGET_WAITKIND_SIGNALLED
6685  || last.kind == TARGET_WAITKIND_EXITED)
6686  goto done;
6687 
6688  /* Select innermost stack frame - i.e., current frame is frame 0,
6689  and current location is based on that.
6690  Don't do this on return from a stack dummy routine,
6691  or if the program has exited. */
6692 
6693  if (!stop_stack_dummy)
6694  {
6696 
6697  /* If --batch-silent is enabled then there's no need to print the current
6698  source location, and to try risks causing an error message about
6699  missing source files. */
6700  if (stop_print_frame && !batch_silent)
6701  print_stop_event (&last);
6702  }
6703 
6705  {
6706  /* Pop the empty frame that contains the stack dummy.
6707  This also restores inferior state prior to the call
6708  (struct infcall_suspend_state). */
6709  struct frame_info *frame = get_current_frame ();
6710 
6711  gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
6712  frame_pop (frame);
6713  /* frame_pop() calls reinit_frame_cache as the last thing it
6714  does which means there's currently no selected frame. We
6715  don't need to re-establish a selected frame if the dummy call
6716  returns normally, that will be done by
6717  restore_infcall_control_state. However, we do have to handle
6718  the case where the dummy call is returning after being
6719  stopped (e.g. the dummy call previously hit a breakpoint).
6720  We can't know which case we have so just always re-establish
6721  a selected frame here. */
6723  }
6724 
6725 done:
6726  annotate_stopped ();
6727 
6728  /* Suppress the stop observer if we're in the middle of:
6729 
6730  - a step n (n > 1), as there still more steps to be done.
6731 
6732  - a "finish" command, as the observer will be called in
6733  finish_command_continuation, so it can include the inferior
6734  function's return value.
6735 
6736  - calling an inferior function, as we pretend we inferior didn't
6737  run at all. The return value of the call is handled by the
6738  expression evaluator, through call_function_by_hand. */
6739 
6741  || last.kind == TARGET_WAITKIND_SIGNALLED
6742  || last.kind == TARGET_WAITKIND_EXITED
6743  || last.kind == TARGET_WAITKIND_NO_RESUMED
6744  || (!(inferior_thread ()->step_multi
6745  && inferior_thread ()->control.stop_step)
6746  && !(inferior_thread ()->control.stop_bpstat
6747  && inferior_thread ()->control.proceed_to_finish)
6748  && !inferior_thread ()->control.in_infcall))
6749  {
6751  observer_notify_normal_stop (inferior_thread ()->control.stop_bpstat,
6752  stop_print_frame);
6753  else
6754  observer_notify_normal_stop (NULL, stop_print_frame);
6755  }
6756 
6758  {
6759  if (last.kind != TARGET_WAITKIND_SIGNALLED
6760  && last.kind != TARGET_WAITKIND_EXITED)
6761  /* Delete the breakpoint we stopped at, if it wants to be deleted.
6762  Delete any breakpoint that is to be deleted at the next stop. */
6763  breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat);
6764  }
6765 
6766  /* Try to get rid of automatically added inferiors that are no
6767  longer needed. Keeping those around slows down things linearly.
6768  Note that this never removes the current inferior. */
6769  prune_inferiors ();
6770 }
6771 
6772 static int
6773 hook_stop_stub (void *cmd)
6774 {
6775  execute_cmd_pre_hook ((struct cmd_list_element *) cmd);
6776  return (0);
6777 }
6778 
6779 int
6781 {
6782  return signal_stop[signo];
6783 }
6784 
6785 int
6787 {
6788  return signal_print[signo];
6789 }
6790 
6791 int
6793 {
6794  return signal_program[signo];
6795 }
6796 
6797 static void
6799 {
6800  if (signo == -1)
6801  {
6802  for (signo = 0; signo < (int) GDB_SIGNAL_LAST; signo++)
6803  signal_cache_update (signo);
6804 
6805  return;
6806  }
6807 
6808  signal_pass[signo] = (signal_stop[signo] == 0
6809  && signal_print[signo] == 0
6810  && signal_program[signo] == 1
6811  && signal_catch[signo] == 0);
6812 }
6813 
6814 int
6815 signal_stop_update (int signo, int state)
6816 {
6817  int ret = signal_stop[signo];
6818 
6819  signal_stop[signo] = state;
6820  signal_cache_update (signo);
6821  return ret;
6822 }
6823 
6824 int
6825 signal_print_update (int signo, int state)
6826 {
6827  int ret = signal_print[signo];
6828 
6829  signal_print[signo] = state;
6830  signal_cache_update (signo);
6831  return ret;
6832 }
6833 
6834 int
6835 signal_pass_update (int signo, int state)
6836 {
6837  int ret = signal_program[signo];
6838 
6839  signal_program[signo] = state;
6840  signal_cache_update (signo);
6841  return ret;
6842 }
6843 
6844 /* Update the global 'signal_catch' from INFO and notify the
6845  target. */
6846 
6847 void
6848 signal_catch_update (const unsigned int *info)
6849 {
6850  int i;
6851 
6852  for (i = 0; i < GDB_SIGNAL_LAST; ++i)
6853  signal_catch[i] = info[i] > 0;
6854  signal_cache_update (-1);
6855  target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
6856 }
6857 
6858 static void
6860 {
6861  printf_filtered (_("Signal Stop\tPrint\tPass "
6862  "to program\tDescription\n"));
6863 }
6864 
6865 static void
6866 sig_print_info (enum gdb_signal oursig)
6867 {
6868  const char *name = gdb_signal_to_name (oursig);
6869  int name_padding = 13 - strlen (name);
6870 
6871  if (name_padding <= 0)
6872  name_padding = 0;
6873 
6874  printf_filtered ("%s", name);
6875  printf_filtered ("%*.*s ", name_padding, name_padding, " ");
6876  printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No");
6877  printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No");
6878  printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No");
6879  printf_filtered ("%s\n", gdb_signal_to_string (oursig));
6880 }
6881 
6882 /* Specify how various signals in the inferior should be handled. */
6883 
6884 static void
6885 handle_command (char *args, int from_tty)
6886 {
6887  char **argv;
6888  int digits, wordlen;
6889  int sigfirst, signum, siglast;
6890  enum gdb_signal oursig;
6891  int allsigs;
6892  int nsigs;
6893  unsigned char *sigs;
6894  struct cleanup *old_chain;
6895 
6896  if (args == NULL)
6897  {
6898  error_no_arg (_("signal to handle"));
6899  }
6900 
6901  /* Allocate and zero an array of flags for which signals to handle. */
6902 
6903  nsigs = (int) GDB_SIGNAL_LAST;
6904  sigs = (unsigned char *) alloca (nsigs);
6905  memset (sigs, 0, nsigs);
6906 
6907  /* Break the command line up into args. */
6908 
6909  argv = gdb_buildargv (args);
6910  old_chain = make_cleanup_freeargv (argv);
6911 
6912  /* Walk through the args, looking for signal oursigs, signal names, and
6913  actions. Signal numbers and signal names may be interspersed with
6914  actions, with the actions being performed for all signals cumulatively
6915  specified. Signal ranges can be specified as <LOW>-<HIGH>. */
6916 
6917  while (*argv != NULL)
6918  {
6919  wordlen = strlen (*argv);
6920  for (digits = 0; isdigit ((*argv)[digits]); digits++)
6921  {;
6922  }
6923  allsigs = 0;
6924  sigfirst = siglast = -1;
6925 
6926  if (wordlen >= 1 && !strncmp (*argv, "all", wordlen))
6927  {
6928  /* Apply action to all signals except those used by the
6929  debugger. Silently skip those. */
6930  allsigs = 1;
6931  sigfirst = 0;
6932  siglast = nsigs - 1;
6933  }
6934  else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen))
6935  {
6936  SET_SIGS (nsigs, sigs, signal_stop);
6937  SET_SIGS (nsigs, sigs, signal_print);
6938  }
6939  else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen))
6940  {
6941  UNSET_SIGS (nsigs, sigs, signal_program);
6942  }
6943  else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen))
6944  {
6945  SET_SIGS (nsigs, sigs, signal_print);
6946  }
6947  else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen))
6948  {
6949  SET_SIGS (nsigs, sigs, signal_program);
6950  }
6951  else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen))
6952  {
6953  UNSET_SIGS (nsigs, sigs, signal_stop);
6954  }
6955  else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen))
6956  {
6957  SET_SIGS (nsigs, sigs, signal_program);
6958  }
6959  else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen))
6960  {
6961  UNSET_SIGS (nsigs, sigs, signal_print);
6962  UNSET_SIGS (nsigs, sigs, signal_stop);
6963  }
6964  else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen))
6965  {
6966  UNSET_SIGS (nsigs, sigs, signal_program);
6967  }
6968  else if (digits > 0)
6969  {
6970  /* It is numeric. The numeric signal refers to our own
6971  internal signal numbering from target.h, not to host/target
6972  signal number. This is a feature; users really should be
6973  using symbolic names anyway, and the common ones like
6974  SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
6975 
6976  sigfirst = siglast = (int)
6977  gdb_signal_from_command (atoi (*argv));
6978  if ((*argv)[digits] == '-')
6979  {
6980  siglast = (int)
6981  gdb_signal_from_command (atoi ((*argv) + digits + 1));
6982  }
6983  if (sigfirst > siglast)
6984  {
6985  /* Bet he didn't figure we'd think of this case... */
6986  signum = sigfirst;
6987  sigfirst = siglast;
6988  siglast = signum;
6989  }
6990  }
6991  else
6992  {
6993  oursig = gdb_signal_from_name (*argv);
6994  if (oursig != GDB_SIGNAL_UNKNOWN)
6995  {
6996  sigfirst = siglast = (int) oursig;
6997  }
6998  else
6999  {
7000  /* Not a number and not a recognized flag word => complain. */
7001  error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv);
7002  }
7003  }
7004 
7005  /* If any signal numbers or symbol names were found, set flags for
7006  which signals to apply actions to. */
7007 
7008  for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++)
7009  {
7010  switch ((enum gdb_signal) signum)
7011  {
7012  case GDB_SIGNAL_TRAP:
7013  case GDB_SIGNAL_INT:
7014  if (!allsigs && !sigs[signum])
7015  {
7016  if (query (_("%s is used by the debugger.\n\
7017 Are you sure you want to change it? "),
7018  gdb_signal_to_name ((enum gdb_signal) signum)))
7019  {
7020  sigs[signum] = 1;
7021  }
7022  else
7023  {
7024  printf_unfiltered (_("Not confirmed, unchanged.\n"));
7026  }
7027  }
7028  break;
7029  case GDB_SIGNAL_0:
7030  case GDB_SIGNAL_DEFAULT:
7031  case GDB_SIGNAL_UNKNOWN:
7032  /* Make sure that "all" doesn't print these. */
7033  break;
7034  default:
7035  sigs[signum] = 1;
7036  break;
7037  }
7038  }
7039 
7040  argv++;
7041  }
7042 
7043  for (signum = 0; signum < nsigs; signum++)
7044  if (sigs[signum])
7045  {
7046  signal_cache_update (-1);
7047  target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass);
7048  target_program_signals ((int) GDB_SIGNAL_LAST, signal_program);
7049 
7050  if (from_tty)
7051  {
7052  /* Show the results. */
7053  sig_print_header ();
7054  for (; signum < nsigs; signum++)
7055  if (sigs[signum])
7056  sig_print_info (signum);
7057  }
7058 
7059  break;
7060  }
7061 
7062  do_cleanups (old_chain);
7063 }
7064 
7065 /* Complete the "handle" command. */
7066 
7067 static VEC (char_ptr) *
7068 handle_completer (struct cmd_list_element *ignore,
7069  const char *text, const char *word)
7070 {
7071  VEC (char_ptr) *vec_signals, *vec_keywords, *return_val;
7072  static const char * const keywords[] =
7073  {
7074  "all",
7075  "stop",
7076  "ignore",
7077  "print",
7078  "pass",
7079  "nostop",
7080  "noignore",
7081  "noprint",
7082  "nopass",
7083  NULL,
7084  };
7085 
7086  vec_signals = signal_completer (ignore, text, word);
7087  vec_keywords = complete_on_enum (keywords, word, word);
7088 
7089  return_val = VEC_merge (char_ptr, vec_signals, vec_keywords);
7090  VEC_free (char_ptr, vec_signals);
7091  VEC_free (char_ptr, vec_keywords);
7092  return return_val;
7093 }
7094 
7095 enum gdb_signal
7097 {
7098  if (num >= 1 && num <= 15)
7099  return (enum gdb_signal) num;
7100  error (_("Only signals 1-15 are valid as numeric signals.\n\
7101 Use \"info signals\" for a list of symbolic signals."));
7102 }
7103 
7104 /* Print current contents of the tables set by the handle command.
7105  It is possible we should just be printing signals actually used
7106  by the current target (but for things to work right when switching
7107  targets, all signals should be in the signal tables). */
7108 
7109 static void
7110 signals_info (char *signum_exp, int from_tty)
7111 {
7112  enum gdb_signal oursig;
7113 
7114  sig_print_header ();
7115 
7116  if (signum_exp)
7117  {
7118  /* First see if this is a symbol name. */
7119  oursig = gdb_signal_from_name (signum_exp);
7120  if (oursig == GDB_SIGNAL_UNKNOWN)
7121  {
7122  /* No, try numeric. */
7123  oursig =
7125  }
7126  sig_print_info (oursig);
7127  return;
7128  }
7129 
7130  printf_filtered ("\n");
7131  /* These ugly casts brought to you by the native VAX compiler. */
7132  for (oursig = GDB_SIGNAL_FIRST;
7133  (int) oursig < (int) GDB_SIGNAL_LAST;
7134  oursig = (enum gdb_signal) ((int) oursig + 1))
7135  {
7136  QUIT;
7137 
7138  if (oursig != GDB_SIGNAL_UNKNOWN
7139  && oursig != GDB_SIGNAL_DEFAULT && oursig != GDB_SIGNAL_0)
7140  sig_print_info (oursig);
7141  }
7142 
7143  printf_filtered (_("\nUse the \"handle\" command "
7144  "to change these tables.\n"));
7145 }
7146 
7147 /* Check if it makes sense to read $_siginfo from the current thread
7148  at this point. If not, throw an error. */
7149 
7150 static void
7152 {
7153  /* No current inferior, no siginfo. */
7155  error (_("No thread selected."));
7156 
7157  /* Don't try to read from a dead thread. */
7158  if (is_exited (inferior_ptid))
7159  error (_("The current thread has terminated"));
7160 
7161  /* ... or from a spinning thread. */
7162  if (is_running (inferior_ptid))
7163  error (_("Selected thread is running."));
7164 }
7165 
7166 /* The $_siginfo convenience variable is a bit special. We don't know
7167  for sure the type of the value until we actually have a chance to
7168  fetch the data. The type can change depending on gdbarch, so it is
7169  also dependent on which thread you have selected.
7170 
7171  1. making $_siginfo be an internalvar that creates a new value on
7172  access.
7173 
7174  2. making the value of $_siginfo be an lval_computed value. */
7175 
7176 /* This function implements the lval_computed support for reading a
7177  $_siginfo value. */
7178 
7179 static void
7181 {
7182  LONGEST transferred;
7183 
7185 
7186  transferred =
7188  NULL,
7190  value_offset (v),
7191  TYPE_LENGTH (value_type (v)));
7192 
7193  if (transferred != TYPE_LENGTH (value_type (v)))
7194  error (_("Unable to read siginfo"));
7195 }
7196 
7197 /* This function implements the lval_computed support for writing a
7198  $_siginfo value. */
7199 
7200 static void
7201 siginfo_value_write (struct value *v, struct value *fromval)
7202 {
7203  LONGEST transferred;
7204 
7206 
7207  transferred = target_write (&current_target,
7209  NULL,
7210  value_contents_all_raw (fromval),
7211  value_offset (v),
7212  TYPE_LENGTH (value_type (fromval)));
7213 
7214  if (transferred != TYPE_LENGTH (value_type (fromval)))
7215  error (_("Unable to write siginfo"));
7216 }
7217 
7218 static const struct lval_funcs siginfo_value_funcs =
7219  {
7222  };
7223 
7224 /* Return a new value with the correct type for the siginfo object of
7225  the current thread using architecture GDBARCH. Return a void value
7226  if there's no object available. */
7227 
7228 static struct value *
7230  void *ignore)
7231 {
7232  if (target_has_stack
7234  && gdbarch_get_siginfo_type_p (gdbarch))
7235  {
7236  struct type *type = gdbarch_get_siginfo_type (gdbarch);
7237 
7238  return allocate_computed_value (type, &siginfo_value_funcs, NULL);
7239  }
7240 
7241  return allocate_value (builtin_type (gdbarch)->builtin_void);
7242 }
7243 
7244 
7245 /* infcall_suspend_state contains state about the program itself like its
7246  registers and any signal it received when it last stopped.
7247  This state must be restored regardless of how the inferior function call
7248  ends (either successfully, or after it hits a breakpoint or signal)
7249  if the program is to properly continue where it left off. */
7250 
7252 {
7254 
7255  /* Other fields: */
7258 
7259  /* Format of SIGINFO_DATA or NULL if it is not present. */
7261 
7262  /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
7263  TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
7264  content would be invalid. */
7266 };
7267 
7268 struct infcall_suspend_state *
7270 {
7271  struct infcall_suspend_state *inf_state;
7272  struct thread_info *tp = inferior_thread ();
7273  struct regcache *regcache = get_current_regcache ();
7274  struct gdbarch *gdbarch = get_regcache_arch (regcache);
7275  gdb_byte *siginfo_data = NULL;
7276 
7277  if (gdbarch_get_siginfo_type_p (gdbarch))
7278  {
7279  struct type *type = gdbarch_get_siginfo_type (gdbarch);
7280  size_t len = TYPE_LENGTH (type);
7281  struct cleanup *back_to;
7282 
7283  siginfo_data = xmalloc (len);
7284  back_to = make_cleanup (xfree, siginfo_data);
7285 
7287  siginfo_data, 0, len) == len)
7288  discard_cleanups (back_to);
7289  else
7290  {
7291  /* Errors ignored. */
7292  do_cleanups (back_to);
7293  siginfo_data = NULL;
7294  }
7295  }
7296 
7297  inf_state = XCNEW (struct infcall_suspend_state);
7298 
7299  if (siginfo_data)
7300  {
7301  inf_state->siginfo_gdbarch = gdbarch;
7302  inf_state->siginfo_data = siginfo_data;
7303  }
7304 
7305  inf_state->thread_suspend = tp->suspend;
7306 
7307  /* run_inferior_call will not use the signal due to its `proceed' call with
7308  GDB_SIGNAL_0 anyway. */
7309  tp->suspend.stop_signal = GDB_SIGNAL_0;
7310 
7311  inf_state->stop_pc = stop_pc;
7312 
7313  inf_state->registers = regcache_dup (regcache);
7314 
7315  return inf_state;
7316 }
7317 
7318 /* Restore inferior session state to INF_STATE. */
7319 
7320 void
7322 {
7323  struct thread_info *tp = inferior_thread ();
7324  struct regcache *regcache = get_current_regcache ();
7325  struct gdbarch *gdbarch = get_regcache_arch (regcache);
7326 
7327  tp->suspend = inf_state->thread_suspend;
7328 
7329  stop_pc = inf_state->stop_pc;
7330 
7331  if (inf_state->siginfo_gdbarch == gdbarch)
7332  {
7333  struct type *type = gdbarch_get_siginfo_type (gdbarch);
7334 
7335  /* Errors ignored. */
7337  inf_state->siginfo_data, 0, TYPE_LENGTH (type));
7338  }
7339 
7340  /* The inferior can be gone if the user types "print exit(0)"
7341  (and perhaps other times). */
7343  /* NB: The register write goes through to the target. */
7344  regcache_cpy (regcache, inf_state->registers);
7345 
7346  discard_infcall_suspend_state (inf_state);
7347 }
7348 
7349 static void
7351 {
7353 }
7354 
7355 struct cleanup *
7357  (struct infcall_suspend_state *inf_state)
7358 {
7360 }
7361 
7362 void
7364 {
7365  regcache_xfree (inf_state->registers);
7366  xfree (inf_state->siginfo_data);
7367  xfree (inf_state);
7368 }
7369 
7370 struct regcache *
7372 {
7373  return inf_state->registers;
7374 }
7375 
7376 /* infcall_control_state contains state regarding gdb's control of the
7377  inferior itself like stepping control. It also contains session state like
7378  the user's currently selected frame. */
7379 
7381 {
7384 
7385  /* Other fields: */
7389 
7390  /* ID if the selected frame when the inferior function call was made. */
7392 };
7393 
7394 /* Save all of the information associated with the inferior<==>gdb
7395  connection. */
7396 
7397 struct infcall_control_state *
7399 {
7400  struct infcall_control_state *inf_status = xmalloc (sizeof (*inf_status));
7401  struct thread_info *tp = inferior_thread ();
7402  struct inferior *inf = current_inferior ();
7403 
7404  inf_status->thread_control = tp->control;
7405  inf_status->inferior_control = inf->control;
7406 
7407  tp->control.step_resume_breakpoint = NULL;
7409 
7410  /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
7411  chain. If caller's caller is walking the chain, they'll be happier if we
7412  hand them back the original chain when restore_infcall_control_state is
7413  called. */
7415 
7416  /* Other fields: */
7417  inf_status->stop_stack_dummy = stop_stack_dummy;
7419  inf_status->stop_after_trap = stop_after_trap;
7420 
7421  inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
7422 
7423  return inf_status;
7424 }
7425 
7426 static int
7428 {
7429  struct frame_id *fid = (struct frame_id *) args;
7430  struct frame_info *frame;
7431 
7432  frame = frame_find_by_id (*fid);
7433 
7434  /* If inf_status->selected_frame_id is NULL, there was no previously
7435  selected frame. */
7436  if (frame == NULL)
7437  {
7438  warning (_("Unable to restore previously selected frame."));
7439  return 0;
7440  }
7441 
7442  select_frame (frame);
7443 
7444  return (1);
7445 }
7446 
7447 /* Restore inferior session state to INF_STATUS. */
7448 
7449 void
7451 {
7452  struct thread_info *tp = inferior_thread ();
7453  struct inferior *inf = current_inferior ();
7454 
7457 
7461 
7462  /* Handle the bpstat_copy of the chain. */
7464 
7465  tp->control = inf_status->thread_control;
7466  inf->control = inf_status->inferior_control;
7467 
7468  /* Other fields: */
7469  stop_stack_dummy = inf_status->stop_stack_dummy;
7471  stop_after_trap = inf_status->stop_after_trap;
7472 
7473  if (target_has_stack)
7474  {
7475  /* The point of catch_errors is that if the stack is clobbered,
7476  walking the stack might encounter a garbage pointer and
7477  error() trying to dereference it. */
7478  if (catch_errors
7480  "Unable to restore previously selected frame:\n",
7481  RETURN_MASK_ERROR) == 0)
7482  /* Error in restoring the selected frame. Select the innermost
7483  frame. */
7485  }
7486 
7487  xfree (inf_status);
7488 }
7489 
7490 static void
7492 {
7494 }
7495 
7496 struct cleanup *
7498  (struct infcall_control_state *inf_status)
7499 {
7501 }
7502 
7503 void
7505 {
7506  if (inf_status->thread_control.step_resume_breakpoint)
7509 
7513 
7514  /* See save_infcall_control_state for info on stop_bpstat. */
7515  bpstat_clear (&inf_status->thread_control.stop_bpstat);
7516 
7517  xfree (inf_status);
7518 }
7519 
7520 /* restore_inferior_ptid() will be used by the cleanup machinery
7521  to restore the inferior_ptid value saved in a call to
7522  save_inferior_ptid(). */
7523 
7524 static void
7526 {
7527  ptid_t *saved_ptid_ptr = arg;
7528 
7529  inferior_ptid = *saved_ptid_ptr;
7530  xfree (arg);
7531 }
7532 
7533 /* Save the value of inferior_ptid so that it may be restored by a
7534  later call to do_cleanups(). Returns the struct cleanup pointer
7535  needed for later doing the cleanup. */
7536 
7537 struct cleanup *
7539 {
7540  ptid_t *saved_ptid_ptr;
7541 
7542  saved_ptid_ptr = xmalloc (sizeof (ptid_t));
7543  *saved_ptid_ptr = inferior_ptid;
7544  return make_cleanup (restore_inferior_ptid, saved_ptid_ptr);
7545 }
7546 
7547 /* See infrun.h. */
7548 
7549 void
7551 {
7552  clear_internalvar (lookup_internalvar ("_exitsignal"));
7553  clear_internalvar (lookup_internalvar ("_exitcode"));
7554 }
7555 
7556 
7557 /* User interface for reverse debugging:
7558  Set exec-direction / show exec-direction commands
7559  (returns error unless target implements to_set_exec_direction method). */
7560 
7561 int execution_direction = EXEC_FORWARD;
7562 static const char exec_forward[] = "forward";
7563 static const char exec_reverse[] = "reverse";
7564 static const char *exec_direction = exec_forward;
7565 static const char *const exec_direction_names[] = {
7566  exec_forward,
7567  exec_reverse,
7568  NULL
7569 };
7570 
7571 static void
7572 set_exec_direction_func (char *args, int from_tty,
7573  struct cmd_list_element *cmd)
7574 {
7576  {
7577  if (!strcmp (exec_direction, exec_forward))
7578  execution_direction = EXEC_FORWARD;
7579  else if (!strcmp (exec_direction, exec_reverse))
7580  execution_direction = EXEC_REVERSE;
7581  }
7582  else
7583  {
7584  exec_direction = exec_forward;
7585  error (_("Target does not support this operation."));
7586  }
7587 }
7588 
7589 static void
7590 show_exec_direction_func (struct ui_file *out, int from_tty,
7591  struct cmd_list_element *cmd, const char *value)
7592 {
7593  switch (execution_direction) {
7594  case EXEC_FORWARD:
7595  fprintf_filtered (out, _("Forward.\n"));
7596  break;
7597  case EXEC_REVERSE:
7598  fprintf_filtered (out, _("Reverse.\n"));
7599  break;
7600  default:
7601  internal_error (__FILE__, __LINE__,
7602  _("bogus execution_direction value: %d"),
7603  (int) execution_direction);
7604  }
7605 }
7606 
7607 static void
7608 show_schedule_multiple (struct ui_file *file, int from_tty,
7609  struct cmd_list_element *c, const char *value)
7610 {
7611  fprintf_filtered (file, _("Resuming the execution of threads "
7612  "of all processes is %s.\n"), value);
7613 }
7614 
7615 /* Implementation of `siginfo' variable. */
7616 
7617 static const struct internalvar_funcs siginfo_funcs =
7618 {
7620  NULL,
7621  NULL
7622 };
7623 
7624 void
7626 {
7627  int i;
7628  int numsigs;
7629  struct cmd_list_element *c;
7630 
7631  add_info ("signals", signals_info, _("\
7632 What debugger does when program gets various signals.\n\
7633 Specify a signal as argument to print info on that signal only."));
7634  add_info_alias ("handle", "signals", 0);
7635 
7636  c = add_com ("handle", class_run, handle_command, _("\
7637 Specify how to handle signals.\n\
7638 Usage: handle SIGNAL [ACTIONS]\n\
7639 Args are signals and actions to apply to those signals.\n\
7640 If no actions are specified, the current settings for the specified signals\n\
7641 will be displayed instead.\n\
7642 \n\
7643 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\
7644 from 1-15 are allowed for compatibility with old versions of GDB.\n\
7645 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\
7646 The special arg \"all\" is recognized to mean all signals except those\n\
7647 used by the debugger, typically SIGTRAP and SIGINT.\n\
7648 \n\
7649 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\
7650 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\
7651 Stop means reenter debugger if this signal happens (implies print).\n\
7652 Print means print a message if this signal happens.\n\
7653 Pass means let program see this signal; otherwise program doesn't know.\n\
7654 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
7655 Pass and Stop may be combined.\n\
7656 \n\
7657 Multiple signals may be specified. Signal numbers and signal names\n\
7658 may be interspersed with actions, with the actions being performed for\n\
7659 all signals cumulatively specified."));
7660  set_cmd_completer (c, handle_completer);
7661 
7662  if (!dbx_commands)
7663  stop_command = add_cmd ("stop", class_obscure,
7665 There is no `stop' command, but you can set a hook on `stop'.\n\
7666 This allows you to set a list of commands to be run each time execution\n\
7667 of the program stops."), &cmdlist);
7668 
7669  add_setshow_zuinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\
7670 Set inferior debugging."), _("\
7671 Show inferior debugging."), _("\
7672 When non-zero, inferior specific debugging is enabled."),
7673  NULL,
7676 
7678  &debug_displaced, _("\
7679 Set displaced stepping debugging."), _("\
7680 Show displaced stepping debugging."), _("\
7681 When non-zero, displaced stepping specific debugging is enabled."),
7682  NULL,
7685 
7686  add_setshow_boolean_cmd ("non-stop", no_class,
7687  &non_stop_1, _("\
7688 Set whether gdb controls the inferior in non-stop mode."), _("\
7689 Show whether gdb controls the inferior in non-stop mode."), _("\
7690 When debugging a multi-threaded program and this setting is\n\
7691 off (the default, also called all-stop mode), when one thread stops\n\
7692 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\
7693 all other threads in the program while you interact with the thread of\n\
7694 interest. When you continue or step a thread, you can allow the other\n\
7695 threads to run, or have them remain stopped, but while you inspect any\n\
7696 thread's state, all threads stop.\n\
7697 \n\
7698 In non-stop mode, when one thread stops, other threads can continue\n\
7699 to run freely. You'll be able to step each thread independently,\n\
7700 leave it stopped or free to run as needed."),
7701  set_non_stop,
7702  show_non_stop,
7703  &setlist,
7704  &showlist);
7705 
7706  numsigs = (int) GDB_SIGNAL_LAST;
7707  signal_stop = (unsigned char *) xmalloc (sizeof (signal_stop[0]) * numsigs);
7708  signal_print = (unsigned char *)
7709  xmalloc (sizeof (signal_print[0]) * numsigs);
7710  signal_program = (unsigned char *)
7711  xmalloc (sizeof (signal_program[0]) * numsigs);
7712  signal_catch = (unsigned char *)
7713  xmalloc (sizeof (signal_catch[0]) * numsigs);
7714  signal_pass = (unsigned char *)
7715  xmalloc (sizeof (signal_pass[0]) * numsigs);
7716  for (i = 0; i < numsigs; i++)
7717  {
7718  signal_stop[i] = 1;
7719  signal_print[i] = 1;
7720  signal_program[i] = 1;
7721  signal_catch[i] = 0;
7722  }
7723 
7724  /* Signals caused by debugger's own actions
7725  should not be given to the program afterwards. */
7726  signal_program[GDB_SIGNAL_TRAP] = 0;
7727  signal_program[GDB_SIGNAL_INT] = 0;
7728 
7729  /* Signals that are not errors should not normally enter the debugger. */
7730  signal_stop[GDB_SIGNAL_ALRM] = 0;
7731  signal_print[GDB_SIGNAL_ALRM] = 0;
7732  signal_stop[GDB_SIGNAL_VTALRM] = 0;
7733  signal_print[GDB_SIGNAL_VTALRM] = 0;
7734  signal_stop[GDB_SIGNAL_PROF] = 0;
7735  signal_print[GDB_SIGNAL_PROF] = 0;
7736  signal_stop[GDB_SIGNAL_CHLD] = 0;
7737  signal_print[GDB_SIGNAL_CHLD] = 0;
7738  signal_stop[GDB_SIGNAL_IO] = 0;
7739  signal_print[GDB_SIGNAL_IO] = 0;
7740  signal_stop[GDB_SIGNAL_POLL] = 0;
7741  signal_print[GDB_SIGNAL_POLL] = 0;
7742  signal_stop[GDB_SIGNAL_URG] = 0;
7743  signal_print[GDB_SIGNAL_URG] = 0;
7744  signal_stop[GDB_SIGNAL_WINCH] = 0;
7745  signal_print[GDB_SIGNAL_WINCH] = 0;
7746  signal_stop[GDB_SIGNAL_PRIO] = 0;
7747  signal_print[GDB_SIGNAL_PRIO] = 0;
7748 
7749  /* These signals are used internally by user-level thread
7750  implementations. (See signal(5) on Solaris.) Like the above
7751  signals, a healthy program receives and handles them as part of
7752  its normal operation. */
7753  signal_stop[GDB_SIGNAL_LWP] = 0;
7754  signal_print[GDB_SIGNAL_LWP] = 0;
7755  signal_stop[GDB_SIGNAL_WAITING] = 0;
7756  signal_print[GDB_SIGNAL_WAITING] = 0;
7757  signal_stop[GDB_SIGNAL_CANCEL] = 0;
7758  signal_print[GDB_SIGNAL_CANCEL] = 0;
7759 
7760  /* Update cached state. */
7761  signal_cache_update (-1);
7762 
7763  add_setshow_zinteger_cmd ("stop-on-solib-events", class_support,
7764  &stop_on_solib_events, _("\
7765 Set stopping for shared library events."), _("\
7766 Show stopping for shared library events."), _("\
7767 If nonzero, gdb will give control to the user when the dynamic linker\n\
7768 notifies gdb of shared library events. The most common event of interest\n\
7769 to the user would be loading/unloading of a new library."),
7772  &setlist, &showlist);
7773 
7774  add_setshow_enum_cmd ("follow-fork-mode", class_run,
7775  follow_fork_mode_kind_names,
7776  &follow_fork_mode_string, _("\
7777 Set debugger response to a program call of fork or vfork."), _("\
7778 Show debugger response to a program call of fork or vfork."), _("\
7779 A fork or vfork creates a new process. follow-fork-mode can be:\n\
7780  parent - the original process is debugged after a fork\n\
7781  child - the new process is debugged after a fork\n\
7782 The unfollowed process will continue to run.\n\
7783 By default, the debugger will follow the parent process."),
7784  NULL,
7786  &setlist, &showlist);
7787 
7788  add_setshow_enum_cmd ("follow-exec-mode", class_run,
7789  follow_exec_mode_names,
7790  &follow_exec_mode_string, _("\
7791 Set debugger response to a program call of exec."), _("\
7792 Show debugger response to a program call of exec."), _("\
7793 An exec call replaces the program image of a process.\n\
7794 \n\
7795 follow-exec-mode can be:\n\
7796 \n\
7797  new - the debugger creates a new inferior and rebinds the process\n\
7798 to this new inferior. The program the process was running before\n\
7799 the exec call can be restarted afterwards by restarting the original\n\
7800 inferior.\n\
7801 \n\
7802  same - the debugger keeps the process bound to the same inferior.\n\
7803 The new executable image replaces the previous executable loaded in\n\
7804 the inferior. Restarting the inferior after the exec call restarts\n\
7805 the executable the process was running after the exec call.\n\
7806 \n\
7807 By default, the debugger will use the same inferior."),
7808  NULL,
7810  &setlist, &showlist);
7811 
7812  add_setshow_enum_cmd ("scheduler-locking", class_run,
7813  scheduler_enums, &scheduler_mode, _("\
7814 Set mode for locking scheduler during execution."), _("\
7815 Show mode for locking scheduler during execution."), _("\
7816 off == no locking (threads may preempt at any time)\n\
7817 on == full locking (no thread except the current thread may run)\n\
7818 step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\
7819  In this mode, other threads may run during other commands."),
7820  set_schedlock_func, /* traps on target vector */
7822  &setlist, &showlist);
7823 
7824  add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\
7825 Set mode for resuming threads of all processes."), _("\
7826 Show mode for resuming threads of all processes."), _("\
7827 When on, execution commands (such as 'continue' or 'next') resume all\n\
7828 threads of all processes. When off (which is the default), execution\n\
7829 commands only resume the threads of the current process. The set of\n\
7830 threads that are resumed is further refined by the scheduler-locking\n\
7831 mode (see help set scheduler-locking)."),
7832  NULL,
7834  &setlist, &showlist);
7835 
7836  add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\
7837 Set mode of the step operation."), _("\
7838 Show mode of the step operation."), _("\
7839 When set, doing a step over a function without debug line information\n\
7840 will stop at the first instruction of that function. Otherwise, the\n\
7841 function is skipped and the step command stops at a different source line."),
7842  NULL,
7844  &setlist, &showlist);
7845 
7846  add_setshow_auto_boolean_cmd ("displaced-stepping", class_run,
7847  &can_use_displaced_stepping, _("\
7848 Set debugger's willingness to use displaced stepping."), _("\
7849 Show debugger's willingness to use displaced stepping."), _("\
7850 If on, gdb will use displaced stepping to step over breakpoints if it is\n\
7851 supported by the target architecture. If off, gdb will not use displaced\n\
7852 stepping to step over breakpoints, even if such is supported by the target\n\
7853 architecture. If auto (which is the default), gdb will use displaced stepping\n\
7854 if the target architecture supports it and non-stop mode is active, but will not\n\
7855 use it in all-stop mode (see help set non-stop)."),
7856  NULL,
7858  &setlist, &showlist);
7859 
7860  add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names,
7861  &exec_direction, _("Set direction of execution.\n\
7862 Options are 'forward' or 'reverse'."),
7863  _("Show direction of execution (forward/reverse)."),
7864  _("Tells gdb whether to execute forward or backward."),
7866  &setlist, &showlist);
7867 
7868  /* Set/show detach-on-fork: user-settable mode. */
7869 
7870  add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\
7871 Set whether gdb will detach the child of a fork."), _("\
7872 Show whether gdb will detach the child of a fork."), _("\
7873 Tells gdb whether to detach the child of a fork."),
7874  NULL, NULL, &setlist, &showlist);
7875 
7876  /* Set/show disable address space randomization mode. */
7877 
7878  add_setshow_boolean_cmd ("disable-randomization", class_support,
7879  &disable_randomization, _("\
7880 Set disabling of debuggee's virtual address space randomization."), _("\
7881 Show disabling of debuggee's virtual address space randomization."), _("\
7882 When this mode is on (which is the default), randomization of the virtual\n\
7883 address space is disabled. Standalone programs run with the randomization\n\
7884 enabled by default on some platforms."),
7887  &setlist, &showlist);
7888 
7889  /* ptid initializations */
7891  target_last_wait_ptid = minus_one_ptid;
7892 
7897 
7898  /* Explicitly create without lookup, since that tries to create a
7899  value with a void typed value, and when we get here, gdbarch
7900  isn't initialized yet. At this point, we're quite sure there
7901  isn't another convenience variable of the same name. */
7902  create_internalvar_type_lazy ("_siginfo", &siginfo_funcs, NULL);
7903 
7904  add_setshow_boolean_cmd ("observer", no_class,
7905  &observer_mode_1, _("\
7906 Set whether gdb controls the inferior in observer mode."), _("\
7907 Show whether gdb controls the inferior in observer mode."), _("\
7908 In observer mode, GDB can get data from the inferior, but not\n\
7909 affect its execution. Registers and memory may not be changed,\n\
7910 breakpoints may not be set, and the program cannot be interrupted\n\
7911 or signalled."),
7914  &setlist,
7915  &showlist);
7916 }
char * target_waitstatus_to_string(const struct target_waitstatus *ws)
Definition: waitstatus.c:27
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
void get_last_target_status(ptid_t *ptidp, struct target_waitstatus *status)
Definition: infrun.c:3408
struct frame_id step_stack_frame_id
Definition: gdbthread.h:94
int target_supports_disable_randomization(void)
Definition: target.c:2636
int frame_id_p(struct frame_id l)
Definition: frame.c:576
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:733
char enabled
Definition: breakpoint.h:368
struct cleanup * make_cleanup_freeargv(char **arg)
Definition: utils.c:165
void annotate_signalled(void)
Definition: annotate.c:133
#define target_can_async_p()
Definition: target.h:1748
int gdbarch_software_single_step_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3009
static void handle_step_into_function(struct gdbarch *gdbarch, struct execution_control_state *ecs)
Definition: infrun.c:5841
static struct value * siginfo_make_value(struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
Definition: infrun.c:7229
void target_terminal_ours(void)
Definition: target.c:491
int target_thread_alive(ptid_t ptid)
Definition: target.c:3277
struct gdbarch * siginfo_gdbarch
Definition: infrun.c:7260
int in_solib_dynsym_resolve_code(CORE_ADDR pc)
Definition: solib.c:1280
#define VEC_merge(T, V1, V2)
Definition: vec.h:213
int pending_detach
Definition: inferior.h:354
Definition: interps.c:48
struct value * value_mark(void)
Definition: value.c:1499
int moribund_breakpoint_here_p(struct address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4220
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:344
ptid_t user_visible_resume_ptid(int step)
Definition: infrun.c:2021
struct thread_info * add_thread(ptid_t ptid)
Definition: thread.c:305
#define target_can_execute_reverse
Definition: target.h:1960
void normal_stop(void)
Definition: infrun.c:6551
struct address_space * maybe_new_address_space(void)
Definition: progspace.c:85
void handle_solib_event(void)
Definition: solib.c:1327
void do_all_intermediate_continuations_thread(struct thread_info *thread, int err)
int pc_in_thread_step_range(CORE_ADDR pc, struct thread_info *thread)
Definition: thread.c:960
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:393
static void handle_inferior_event(struct execution_control_state *ecs)
Definition: infrun.c:4211
struct thread_control_state thread_control
Definition: infrun.c:7382
struct observer * observer_attach_thread_exit(observer_thread_exit_ftype *f)
int catch_syscall_enabled(void)
static const char schedlock_off[]
Definition: infrun.c:1963
int function_name_is_marked_for_skip(const char *function_name, const struct symtab_and_line *function_sal)
Definition: skip.c:333
int dbx_commands
Definition: main.c:54
static int handle_syscall_event(struct execution_control_state *ecs)
Definition: infrun.c:3600
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
static int step_over_info_valid_p(void)
Definition: infrun.c:1312
static const char *const follow_fork_mode_kind_names[]
Definition: infrun.c:373
CORE_ADDR step_range_start
Definition: gdbthread.h:73
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
int ptid_is_pid(ptid_t ptid)
Definition: ptid.c:86
void value_free_to_mark(struct value *mark)
Definition: value.c:1551
void execute_cmd_pre_hook(struct cmd_list_element *c)
Definition: cli-script.c:319
int gdbarch_displaced_step_copy_insn_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3650
void add_setshow_zinteger_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:719
static int proceed_after_vfork_done(struct thread_info *thread, void *arg)
Definition: infrun.c:844
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
int single_step_breakpoint_inserted_here_p(struct address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:14860
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
void post_create_inferior(struct target_ops *target, int from_tty)
Definition: infcmd.c:406
void signal_catch_update(const unsigned int *info)
Definition: infrun.c:6848
void clear_inline_frame_state(ptid_t ptid)
Definition: inline-frame.c:113
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
bfd_vma CORE_ADDR
Definition: common-types.h:41
void print_signal_received_reason(struct ui_out *uiout, enum gdb_signal siggnal)
Definition: infrun.c:6441
void gdb_rl_callback_handler_reinstall(void)
Definition: event-top.c:263
#define target_shortname
Definition: target.h:1242
#define GDB_SIGNAL_FIRST
void displaced_step_dump_bytes(struct ui_file *file, const gdb_byte *buf, size_t len)
Definition: infrun.c:1615
struct address_space * aspace
Definition: progspace.h:166
void insert_breakpoints(void)
Definition: breakpoint.c:2984
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
struct cleanup * make_cleanup_restore_current_traceframe(void)
Definition: tracepoint.c:3244
struct cleanup * save_inferior_ptid(void)
Definition: infrun.c:7538
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:529
static void validate_siginfo_access(void)
Definition: infrun.c:7151
enum gdb_signal gdb_signal_from_command(int num)
Definition: infrun.c:7096
void delete_thread(ptid_t)
Definition: thread.c:368
stop_stack_kind
Definition: breakpoint.h:975
void bpstat_clear(bpstat *bsp)
Definition: breakpoint.c:4381
void do_displays(void)
Definition: printcmd.c:1819
void xfree(void *)
Definition: common-utils.c:97
int may_insert_fast_tracepoints
void set_running(ptid_t ptid, int running)
Definition: thread.c:772
void clear_exit_convenience_vars(void)
Definition: infrun.c:7550
int value_offset(const struct value *value)
Definition: value.c:1032
int gdbarch_get_longjmp_target(struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
Definition: gdbarch.c:2380
static int switch_back_to_stepped_thread(struct execution_control_state *ecs)
Definition: infrun.c:5583
struct target_waitstatus pending_follow
Definition: gdbthread.h:258
void print_no_history_reason(struct ui_out *uiout)
Definition: infrun.c:6475
void annotate_stopped(void)
Definition: annotate.c:119
enum print_stop_action bpstat_print(bpstat bs, int kind)
Definition: breakpoint.c:4839
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2122
int gdbarch_single_step_through_delay(struct gdbarch *gdbarch, struct frame_info *frame)
Definition: gdbarch.c:3040
void no_shared_libraries(char *ignored, int from_tty)
Definition: solib.c:1302
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void frame_pop(struct frame_info *this_frame)
Definition: frame.c:953
CORE_ADDR frame_unwind_caller_pc(struct frame_info *this_frame)
Definition: frame.c:870
struct displaced_step_inferior_state * next
Definition: infrun.c:1417
void copy_inferior_target_desc_info(struct inferior *destinf, struct inferior *srcinf)
void(* func)(char *)
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:487
struct gdbarch * frame_unwind_caller_arch(struct frame_info *next_frame)
Definition: frame.c:2569
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:5957
void warning(const char *fmt,...)
Definition: errors.c:26
#define target_stopped_by_hw_breakpoint()
Definition: target.h:1841
CORE_ADDR end
Definition: symtab.h:1377
struct breakpoint * set_momentary_breakpoint_at_pc(struct gdbarch *gdbarch, CORE_ADDR pc, enum bptype type)
Definition: breakpoint.c:8832
struct thread_info * event_thread
Definition: infrun.c:2826
int query(const char *ctlstr,...)
Definition: utils.c:1364
void discard_infcall_control_state(struct infcall_control_state *inf_status)
Definition: infrun.c:7504
void init_wait_for_inferior(void)
Definition: infrun.c:2802
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:1894
void async_enable_stdin(void)
Definition: event-top.c:442
int disable_randomization
Definition: infrun.c:151
void breakpoint_auto_delete(bpstat bs)
Definition: breakpoint.c:11914
char * ui_file_xstrdup(struct ui_file *file, long *length)
Definition: ui-file.c:345
struct symtab * current_symtab
Definition: gdbthread.h:205
void ui_file_delete(struct ui_file *file)
Definition: ui-file.c:76
static void resume_cleanups(void *)
Definition: infrun.c:1955
enum stop_kind stop_soon
Definition: inferior.h:276
void target_detach(const char *args, int from_tty)
Definition: target.c:2197
struct ui_file * gdb_stdout
Definition: main.c:71
static void show_schedule_multiple(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:7608
int gdbarch_gdb_signal_to_target_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3936
static void infrun_thread_ptid_changed(ptid_t old_ptid, ptid_t new_ptid)
Definition: infrun.c:1929
int pid
Definition: inferior.h:299
void select_frame(struct frame_info *fi)
Definition: frame.c:1574
#define target_supports_stopped_by_sw_breakpoint()
Definition: target.h:1838
static void check_exception_resume(struct execution_control_state *, struct frame_info *)
Definition: infrun.c:6154
struct frame_id get_stack_frame_id(struct frame_info *next_frame)
Definition: frame.c:483
void _initialize_infrun(void)
Definition: infrun.c:7625
char * args
Definition: inferior.h:320
int ptid_match(ptid_t ptid, ptid_t filter)
Definition: ptid.c:120
enum breakpoint_here breakpoint_here_p(struct address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4187
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
int num
Definition: inferior.h:295
const struct frame_id null_frame_id
Definition: frame.c:506
struct thread_info * inferior_thread(void)
Definition: thread.c:85
struct inferior_control_state inferior_control
Definition: infrun.c:7383
void target_pass_signals(int numsigs, unsigned char *pass_signals)
Definition: target.c:2261
void init_sal(struct symtab_and_line *sal)
Definition: symtab.c:1064
int info_verbose
Definition: top.c:1699
struct regcache * registers
Definition: infrun.c:7257
CORE_ADDR gdbarch_deprecated_function_start_offset(struct gdbarch *gdbarch)
Definition: gdbarch.c:2771
static void show_observer_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:249
void observer_notify_normal_stop(struct bpstats *bs, int print_frame)
int ui_out_is_mi_like_p(struct ui_out *uiout)
Definition: ui-out.c:655
CORE_ADDR address
Definition: infrun.c:1233
void restore_infcall_control_state(struct infcall_control_state *inf_status)
Definition: infrun.c:7450
void print_exited_reason(struct ui_out *uiout, int exitstatus)
Definition: infrun.c:6408
struct frame_id selected_frame_id
Definition: infrun.c:7391
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1185
static const char *const scheduler_enums[]
Definition: infrun.c:1966
static void insert_exception_resume_breakpoint(struct thread_info *tp, const struct block *b, struct frame_info *frame, struct symbol *sym)
Definition: infrun.c:6078
static const char follow_fork_mode_parent[]
Definition: infrun.c:371
int stepping_over_watchpoint
Definition: gdbthread.h:226
int removable
Definition: inferior.h:311
void nullify_last_target_wait_ptid(void)
Definition: infrun.c:3415
static void delete_just_stopped_threads_infrun_breakpoints(void)
Definition: infrun.c:3014
int breakpoints_not_allowed
Definition: progspace.h:180
static const char exec_reverse[]
Definition: infrun.c:7563
struct value * read_var_value(struct symbol *var, struct frame_info *frame)
Definition: findvar.c:613
static void fill_in_stop_func(struct gdbarch *gdbarch, struct execution_control_state *ecs)
Definition: infrun.c:3638
int thread_has_single_step_breakpoint_here(struct thread_info *tp, struct address_space *aspace, CORE_ADDR addr)
Definition: thread.c:151
void annotate_signal(void)
Definition: annotate.c:171
static void context_switch(ptid_t ptid)
Definition: infrun.c:3423
void set_initial_language(void)
Definition: symfile.c:1692
int catch_errors(catch_errors_ftype *func, void *func_args, char *errstring, return_mask mask)
Definition: exceptions.c:228
void(* deprecated_context_hook)(int)
Definition: top.c:244
struct infcall_control_state * save_infcall_control_state(void)
Definition: infrun.c:7398
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
static void siginfo_value_write(struct value *v, struct value *fromval)
Definition: infrun.c:7201
struct inferior * find_inferior_ptid(ptid_t ptid)
Definition: inferior.c:373
struct displaced_step_request * next
Definition: infrun.c:1410
struct obj_section * section
Definition: symtab.h:1370
int current_line
Definition: gdbthread.h:204
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:103
int sched_multi
Definition: infrun.c:1996
int batch_silent
Definition: main.c:84
int gdbarch_software_single_step(struct gdbarch *gdbarch, struct frame_info *frame)
Definition: gdbarch.c:3016
int stepped_breakpoint
Definition: gdbthread.h:218
struct address_space * get_frame_address_space(struct frame_info *frame)
Definition: frame.c:2490
static void keep_going(struct execution_control_state *ecs)
Definition: infrun.c:6235
LONGEST exit_code
Definition: inferior.h:375
char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2233
struct internalvar * lookup_internalvar(const char *name)
Definition: value.c:2131
int step_after_step_resume_breakpoint
Definition: gdbthread.h:237
#define _(String)
Definition: gdb_locale.h:40
static void displaced_step_clear(struct displaced_step_inferior_state *displaced)
Definition: infrun.c:1592
static void set_schedlock_func(char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:1984
enum gdb_signal stop_signal
Definition: gdbthread.h:159
static ptid_t target_last_wait_ptid
Definition: infrun.c:363
struct value * probe_safe_evaluate_at_pc(struct frame_info *frame, unsigned n)
Definition: probe.c:826
void set_current_sal_from_frame(struct frame_info *)
Definition: stack.c:731
int bpstat_causes_stop(bpstat bs)
Definition: breakpoint.c:5910
int gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch)
Definition: gdbarch.c:3251
char * char_ptr
Definition: gdb_vecs.h:25
int signal_print_state(int signo)
Definition: infrun.c:6786
void observer_notify_sync_execution_done(void)
int program_breakpoint_here_p(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:8925
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: regcache.c:1201
ptid_t(* deprecated_target_wait_hook)(ptid_t ptid, struct target_waitstatus *status, int options)
Definition: top.c:232
#define target_stopped_by_watchpoint()
Definition: target.h:1829
static int displaced_step_prepare(ptid_t ptid)
Definition: infrun.c:1641
int record_full_is_used(void)
Definition: record-full.c:214
#define SET_SIGS(nsigs, sigs, flags)
Definition: infrun.c:297
#define END_CATCH
void(* for_each_just_stopped_thread_callback_func)(struct thread_info *tp)
Definition: infrun.c:2985
int stepping_past_instruction_at(struct address_space *aspace, CORE_ADDR address)
Definition: infrun.c:1292
void ui_out_field_fmt(struct ui_out *uiout, const char *fldname, const char *format,...)
Definition: ui-out.c:556
void target_program_signals(int numsigs, unsigned char *program_signals)
Definition: target.c:2267
struct value * allocate_value(struct type *type)
Definition: value.c:962
Definition: ui-out.c:99
static void follow_inferior_reset_breakpoints(void)
Definition: infrun.c:801
struct displaced_step_request * step_request_queue
Definition: infrun.c:1424
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
#define target_stopped_data_address(target, addr_p)
Definition: target.h:1931
void ui_out_text(struct ui_out *uiout, const char *string)
Definition: ui-out.c:582
int detaching
Definition: inferior.h:362
struct cleanup * save_current_inferior(void)
Definition: inferior.c:87
CORE_ADDR gdbarch_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: gdbarch.c:3091
int may_insert_tracepoints
struct observer * observer_attach_thread_stop_requested(observer_thread_stop_requested_ftype *f)
static void handle_step_into_function_backward(struct gdbarch *gdbarch, struct execution_control_state *ecs)
Definition: infrun.c:5920
void printf_filtered(const char *format,...)
Definition: utils.c:2388
static int maybe_software_singlestep(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: infrun.c:2005
int pagination_enabled
Definition: utils.c:143
CORE_ADDR stop_func_start
Definition: infrun.c:2830
int breakpoint_inserted_here_p(struct address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4256
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
Definition: ptid.h:35
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3287
struct gdbarch * step_gdbarch
Definition: infrun.c:1432
struct program_space * add_program_space(struct address_space *aspace)
Definition: progspace.c:125
void restore_infcall_suspend_state(struct infcall_suspend_state *inf_state)
Definition: infrun.c:7321
void set_current_program_space(struct program_space *pspace)
Definition: progspace.c:199
struct regcache * regcache_dup(struct regcache *src)
Definition: regcache.c:436
#define UNSET_SIGS(nsigs, sigs, flags)
Definition: infrun.c:305
int bpstat_should_step(void)
Definition: breakpoint.c:5899
void gdbarch_displaced_step_free_closure(struct gdbarch *gdbarch, struct displaced_step_closure *closure)
Definition: gdbarch.c:3716
static void signal_cache_update(int signo)
Definition: infrun.c:6798
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
Definition: symtab.c:3051
int signal_stop_state(int signo)
Definition: infrun.c:6780
static int restore_selected_frame(void *)
Definition: infrun.c:7427
void null_cleanup(void *arg)
Definition: cleanups.c:295
enum bpdisp disposition
Definition: breakpoint.h:673
#define TRY
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:419
int frame_id_eq(struct frame_id l, struct frame_id r)
Definition: frame.c:604
void annotate_signal_name_end(void)
Definition: annotate.c:150
void find_frame_sal(struct frame_info *frame, struct symtab_and_line *sal)
Definition: frame.c:2328
void print_signal_exited_reason(struct ui_out *uiout, enum gdb_signal siggnal)
Definition: infrun.c:6387
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
#define target_stopped_by_sw_breakpoint()
Definition: target.h:1835
enum stop_stack_kind call_dummy
Definition: breakpoint.h:995
const char *const name
Definition: aarch64-tdep.c:68
static void signals_info(char *, int)
Definition: infrun.c:7110
void add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:516
#define target_execution_direction()
Definition: target.h:1757
static VEC(char_ptr)
Definition: infrun.c:7067
enum frame_type get_frame_type(struct frame_info *frame)
Definition: frame.c:2463
struct objfile * symbol_file_add(const char *name, int add_flags, struct section_addr_info *addrs, int flags)
Definition: symfile.c:1288
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
Definition: gdbarch.c:2754
static int stop_print_frame
Definition: infrun.c:358
struct objfile * objfile
Definition: probe.h:218
void observer_notify_about_to_proceed(void)
const char * stop_func_name
Definition: infrun.c:2832
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:473
struct probe * probe
Definition: probe.h:214
void breakpoint_re_set(void)
Definition: breakpoint.c:14273
int may_stop
struct infcall_suspend_state * save_infcall_suspend_state(void)
Definition: infrun.c:7269
ULONGEST gdbarch_max_insn_length(struct gdbarch *gdbarch)
Definition: gdbarch.c:3632
void target_dcache_invalidate(void)
Definition: target-dcache.c:51
#define CATCH(EXCEPTION, MASK)
struct address_space * aspace
Definition: inferior.h:314
struct cleanup * make_cleanup_restore_integer(int *variable)
Definition: utils.c:292
static const char * scheduler_mode
Definition: infrun.c:1972
void annotate_exited(int exitstatus)
Definition: annotate.c:126
struct cleanup * make_cleanup_restore_infcall_control_state(struct infcall_control_state *inf_status)
Definition: infrun.c:7498
static void clear_proceed_status_thread(struct thread_info *tp)
Definition: infrun.c:2429
int gdbarch_single_step_through_delay_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3033
void update_signals_program_target(void)
Definition: infrun.c:317
struct target_ops current_target
void inferior_event_handler(enum inferior_event_type event_type, gdb_client_data client_data)
Definition: inf-loop.c:40
int detach_breakpoints(ptid_t ptid)
Definition: breakpoint.c:3847
void do_all_continuations_thread(struct thread_info *thread, int err)
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
static void insert_exception_resume_from_probe(struct thread_info *tp, const struct bound_probe *probe, struct frame_info *frame)
Definition: infrun.c:6123
static struct thread_info * find_thread_needs_step_over(struct thread_info *except)
Definition: infrun.c:2542
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3315
static int non_stop_1
Definition: infrun.c:181
struct breakpoint * exception_resume_breakpoint
Definition: gdbthread.h:54
struct value * allocate_computed_value(struct type *type, const struct lval_funcs *funcs, void *closure)
Definition: value.c:987
static int infrun_thread_stop_requested_callback(struct thread_info *info, void *arg)
Definition: infrun.c:2868
int inline_skipped_frames(ptid_t ptid)
Definition: inline-frame.c:369
struct frame_id step_frame_id
Definition: gdbthread.h:90
void target_clear_description(void)
struct program_space * pspace
Definition: inferior.h:317
char * gdb_sysroot
Definition: main.c:57
static void insert_longjmp_resume_breakpoint(struct gdbarch *, CORE_ADDR)
Definition: infrun.c:6055
static void delete_thread_infrun_breakpoints(struct thread_info *tp)
Definition: infrun.c:2973
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
void jit_inferior_created_hook(void)
Definition: jit.c:1362
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
void update_target_permissions(void)
Definition: target.c:3819
static void for_each_just_stopped_thread(for_each_just_stopped_thread_callback_func func)
Definition: infrun.c:2988
enum gdb_signal sig
Definition: waitstatus.h:108
static enum auto_boolean can_use_displaced_stepping
Definition: infrun.c:1560
struct inferior * add_inferior(int pid)
Definition: inferior.c:155
struct displaced_step_closure * gdbarch_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
Definition: gdbarch.c:3657
static void infrun_thread_stop_requested(ptid_t ptid)
Definition: infrun.c:2927
int gdbarch_displaced_step_hw_singlestep(struct gdbarch *gdbarch, struct displaced_step_closure *closure)
Definition: gdbarch.c:3674
void annotate_starting(void)
Definition: annotate.c:112
struct thread_info * any_live_thread_of_process(int pid)
Definition: thread.c:528
int debug_displaced
Definition: infrun.c:132
int stepping_past_nonsteppable_watchpoint(void)
Definition: infrun.c:1304
int signal_pass_update(int signo, int state)
Definition: infrun.c:6835
static void insert_hp_step_resume_breakpoint_at_frame(struct frame_info *)
Definition: infrun.c:5995
void target_terminal_inferior(void)
Definition: target.c:470
void target_resume(ptid_t ptid, int step, enum gdb_signal signal)
Definition: target.c:2245
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
static void print_target_wait_results(ptid_t waiton_ptid, ptid_t result_ptid, const struct target_waitstatus *ws)
Definition: infrun.c:3039
struct cleanup * make_cleanup_restore_infcall_suspend_state(struct infcall_suspend_state *inf_state)
Definition: infrun.c:7357
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
static const char schedlock_on[]
Definition: infrun.c:1964
struct inferior_control_state control
Definition: inferior.h:305
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
struct breakpoint * clone_momentary_breakpoint(struct breakpoint *orig)
Definition: breakpoint.c:8822
void insert_single_step_breakpoint(struct gdbarch *gdbarch, struct address_space *aspace, CORE_ADDR next_pc)
Definition: breakpoint.c:14816
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
#define TARGET_WNOHANG
Definition: wait.h:28
void free_current_contents(void *ptr)
Definition: utils.c:476
void update_observer_mode(void)
Definition: infrun.c:262
struct symbol * get_frame_function(struct frame_info *frame)
Definition: blockframe.c:118
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:44
int async_command_editing_p
Definition: event-top.c:108
static void displaced_step_clear_cleanup(void *arg)
Definition: infrun.c:1606
int nonsteppable_watchpoint_p
Definition: infrun.c:1237
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
int catching_syscall_number(int syscall_number)
int sync_execution
Definition: infrun.c:117
union target_waitstatus::@161 value
static void do_restore_infcall_suspend_state_cleanup(void *state)
Definition: infrun.c:7350
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
void prune_inferiors(void)
Definition: inferior.c:493
struct address_space * aspace
Definition: infrun.c:1232
static void handle_command(char *, int)
Definition: infrun.c:6885
Definition: gdbtypes.h:749
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
const char * word
Definition: symtab.h:1448
struct thread_control_state control
Definition: gdbthread.h:198
static void adjust_pc_after_break(struct execution_control_state *ecs)
Definition: infrun.c:3437
static unsigned char * signal_stop
Definition: infrun.c:282
struct target_ops * find_record_target(void)
Definition: record.c:63
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:381
int interpreter_async
Definition: interps.c:46
int step_stop_if_no_debug
Definition: infrun.c:107
int step_multi
Definition: gdbthread.h:253
struct cmd_list_element * add_info(const char *name, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:857
Definition: gnu-nat.c:163
static void end_stepping_range(struct execution_control_state *ecs)
Definition: infrun.c:6357
CORE_ADDR gdbarch_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR ip)
Definition: gdbarch.c:2580
void target_mourn_inferior(void)
Definition: target.c:2300
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static void remove_displaced_stepping_state(int pid)
Definition: infrun.c:1524
void regcache_cpy(struct regcache *dst, struct regcache *src)
Definition: regcache.c:398
int overlay_cache_invalid
Definition: symfile.c:3082
int gdbarch_cannot_step_breakpoint(struct gdbarch *gdbarch)
Definition: gdbarch.c:3234
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
void gdbarch_skip_permanent_breakpoint(struct gdbarch *gdbarch, struct regcache *regcache)
Definition: gdbarch.c:3608
int waiting_for_vfork_done
Definition: inferior.h:359
struct program_space * frame_unwind_program_space(struct frame_info *this_frame)
Definition: frame.c:2479
#define target_is_async_p()
Definition: target.h:1751
struct regcache * get_infcall_suspend_state_regcache(struct infcall_suspend_state *inf_state)
Definition: infrun.c:7371
static void show_disable_randomization(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:154
static void clear_step_over_info(void)
Definition: infrun.c:1282
static void siginfo_value_read(struct value *v)
Definition: infrun.c:7180
const char * gdb_signal_to_name(enum gdb_signal)
Definition: signals.c:78
void print_stop_event(struct target_waitstatus *ws)
Definition: infrun.c:6486
#define target_has_execution
Definition: target.h:1726
gdb_byte * value_contents_all_raw(struct value *value)
Definition: value.c:1091
#define target_can_lock_scheduler
Definition: target.h:1741
static struct target_waitstatus target_last_waitstatus
Definition: infrun.c:364
static void set_step_over_info(struct address_space *aspace, CORE_ADDR address, int nonsteppable_watchpoint_p)
Definition: infrun.c:1270
static void delete_just_stopped_threads_single_step_breakpoints(void)
Definition: infrun.c:3023
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
ptid_t target_wait(ptid_t ptid, struct target_waitstatus *status, int options)
Definition: target.c:2227
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
struct frame_id frame_unwind_caller_id(struct frame_info *next_frame)
Definition: frame.c:489
void delete_step_resume_breakpoint(struct thread_info *)
Definition: thread.c:105
void annotate_thread_changed(void)
Definition: annotate.c:247
int software_breakpoint_inserted_here_p(struct address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4279
int gdbarch_in_solib_return_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
Definition: gdbarch.c:3108
void * xmalloc(YYSIZE_T)
struct symtab * symtab
Definition: symtab.h:1369
struct ui_file * gdb_stdlog
Definition: main.c:73
CORE_ADDR gdbarch_adjust_breakpoint_address(struct gdbarch *gdbarch, CORE_ADDR bpaddr)
Definition: gdbarch.c:2703
Definition: probe.h:185
static const char follow_exec_mode_same[]
Definition: infrun.c:1035
struct observer * observer_attach_thread_ptid_changed(observer_thread_ptid_changed_ftype *f)
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
static void prepare_to_wait(struct execution_control_state *ecs)
Definition: infrun.c:6342
static void displaced_step_restore(struct displaced_step_inferior_state *displaced, ptid_t ptid)
Definition: infrun.c:1777
CORE_ADDR prev_pc
Definition: gdbthread.h:213
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
Definition: thread.c:143
static void displaced_step_fixup(ptid_t event_ptid, enum gdb_signal signal)
Definition: infrun.c:1792
static void infrun_thread_thread_exit(struct thread_info *tp, int silent)
Definition: infrun.c:2963
struct inferior * vfork_child
Definition: inferior.h:350
bptype
Definition: breakpoint.h:51
void skip_inline_frames(ptid_t ptid)
Definition: inline-frame.c:304
struct breakpoint * set_momentary_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line sal, struct frame_id frame_id, enum bptype type)
Definition: breakpoint.c:8756
void fetch_inferior_event(void *client_data)
Definition: infrun.c:3257
static const char *const follow_exec_mode_names[]
Definition: infrun.c:1036
static void handle_inferior_event_1(struct execution_control_state *ecs)
Definition: infrun.c:3684
int symfile_flags
Definition: inferior.h:380
struct program_space * clone_program_space(struct program_space *dest, struct program_space *src)
Definition: progspace.c:176
int attach_flag
Definition: inferior.h:340
Definition: block.h:60
static void infrun_inferior_exit(struct inferior *inf)
Definition: infrun.c:1547
struct symbol * step_start_function
Definition: gdbthread.h:77
Definition: value.c:172
static void show_exec_direction_func(struct ui_file *out, int from_tty, struct cmd_list_element *cmd, const char *value)
Definition: infrun.c:7590
void init_thread_stepping_state(struct thread_info *tss)
Definition: infrun.c:3385
int stop_on_solib_events
Definition: infrun.c:332
CORE_ADDR stop_func_end
Definition: infrun.c:2831
enum bptype type
Definition: breakpoint.h:669
void finish_thread_state_cleanup(void *ptid_p)
Definition: thread.c:950
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
int stopped_by_random_signal
Definition: infcmd.c:137
static const char schedlock_step[]
Definition: infrun.c:1965
void annotate_signal_name(void)
Definition: annotate.c:143
void discard_infcall_suspend_state(struct infcall_suspend_state *inf_state)
Definition: infrun.c:7363
int signal_pass_state(int signo)
Definition: infrun.c:6792
static ptid_t previous_inferior_ptid
Definition: infrun.c:123
enum gdb_signal gdb_signal_from_name(const char *)
Definition: signals.c:91
bpstat bpstat_copy(bpstat bs)
Definition: breakpoint.c:4402
static void set_exec_direction_func(char *args, int from_tty, struct cmd_list_element *cmd)
Definition: infrun.c:7572
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:151
static void reinstall_readline_callback_handler_cleanup(void *arg)
Definition: infrun.c:3231
enum stop_stack_kind stop_stack_dummy
Definition: infrun.c:7386
int observer_mode
Definition: infrun.c:209
static unsigned char * signal_program
Definition: infrun.c:284
void disable_current_display(void)
Definition: printcmd.c:1845
char * execd_pathname
Definition: waitstatus.h:112
const char const char int
Definition: command.h:229
int stop_after_trap
Definition: infrun.c:354
bfd_byte gdb_byte
Definition: common-types.h:38
void exec_file_attach(const char *filename, int from_tty)
Definition: exec.c:195
static void process_event_stop_test(struct execution_control_state *ecs)
Definition: infrun.c:4766
void start_remote(int from_tty)
Definition: infrun.c:2768
static struct displaced_step_inferior_state * get_displaced_stepping_state(int pid)
Definition: infrun.c:1453
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
int non_stop
Definition: infrun.c:180
void print_end_stepping_range_reason(struct ui_out *uiout)
Definition: infrun.c:6375
void annotate_signal_string_end(void)
Definition: annotate.c:164
void observer_notify_no_history(void)
int value_optimized_out(struct value *value)
Definition: value.c:1346
ptid_t null_ptid
Definition: ptid.c:25
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:1045
static int follow_fork_inferior(int follow_child, int detach_fork)
Definition: infrun.c:398
#define target_has_stack
Definition: target.h:1705
long ptid_get_tid(ptid_t ptid)
Definition: ptid.c:68
stop_kind
Definition: inferior.h:248
static unsigned char * signal_catch
Definition: infrun.c:290
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:109
#define ALL_NON_EXITED_THREADS(T)
Definition: gdbthread.h:377
static void set_disable_randomization(char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:169
struct cleanup * make_bpstat_clear_actions_cleanup(void)
Definition: utils.c:3137
static void set_non_stop(char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:184
int may_insert_breakpoints
void proceed(CORE_ADDR addr, enum gdb_signal siggnal)
Definition: infrun.c:2592
static const char follow_exec_mode_new[]
Definition: infrun.c:1034
void update_thread_list(void)
Definition: thread.c:1735
const char * async_reason_lookup(enum async_reply_reason reason)
Definition: mi-common.c:49
void not_just_help_class_command(char *args, int from_tty)
Definition: cli-decode.c:383
void prepare_for_detach(void)
Definition: infrun.c:3087
ptid_t ptid
Definition: gdbthread.h:169
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:185
static int currently_stepping(struct thread_info *tp)
Definition: infrun.c:5827
void set_step_info(struct frame_info *frame, struct symtab_and_line sal)
Definition: infrun.c:3371
void clear_proceed_status(int step)
Definition: infrun.c:2463
enum target_waitkind kind
Definition: waitstatus.h:100
static struct displaced_step_inferior_state * displaced_step_inferior_states
Definition: infrun.c:1448
void delete_exception_resume_breakpoint(struct thread_info *)
Definition: thread.c:112
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
int gdbarch_get_siginfo_type_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3960
struct ui_file * gdb_stderr
Definition: main.c:72
void breakpoint_init_inferior(enum inf_context context)
Definition: breakpoint.c:4080
static int use_displaced_stepping(struct gdbarch *gdbarch)
Definition: infrun.c:1582
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1174
ptid_t inferior_ptid
Definition: infcmd.c:124
char * safe_strerror(int)
void set_internalvar_integer(struct internalvar *var, LONGEST l)
Definition: value.c:2347
struct cleanup * make_cleanup_restore_current_thread(void)
Definition: thread.c:1354
void observer_notify_signal_received(enum gdb_signal siggnal)
static struct displaced_step_inferior_state * add_displaced_stepping_state(int pid)
Definition: infrun.c:1485
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:1563
struct bp_location * loc
Definition: breakpoint.h:678
int remove_breakpoints(void)
Definition: breakpoint.c:3184
void solib_create_inferior_hook(int from_tty)
Definition: solib.c:1269
struct interp * command_interp(void)
Definition: interps.c:303
struct symbol * lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
struct program_space * pspace
Definition: symtab.h:1367
void set_current_traceframe(int num)
Definition: tracepoint.c:3195
int may_write_memory
static void sig_print_info(enum gdb_signal)
Definition: infrun.c:6866
void observer_notify_exited(int exitstatus)
int bpstat_explains_signal(bpstat bsp, enum gdb_signal sig)
Definition: breakpoint.c:4453
int may_write_registers
static void handle_vfork_child_exec_or_exit(int exec)
Definition: infrun.c:872
#define VEC_free(T, V)
Definition: vec.h:180
enum language compunit_language(const struct compunit_symtab *cust)
Definition: symtab.c:298
CORE_ADDR stop_pc
Definition: infcmd.c:128
struct frame_id initiating_frame
Definition: gdbthread.h:267
struct address_space * new_address_space(void)
Definition: progspace.c:69
char ** gdb_buildargv(const char *s)
Definition: utils.c:3036
char * exec_file_find(char *in_pathname, int *fd)
Definition: solib.c:387
CORE_ADDR stop_pc
Definition: infrun.c:7256
struct regcache * get_thread_arch_aspace_regcache(ptid_t ptid, struct gdbarch *gdbarch, struct address_space *aspace)
Definition: regcache.c:485
int gdbarch_adjust_breakpoint_address_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2696
static void do_target_resume(ptid_t resume_ptid, int step, enum gdb_signal sig)
Definition: infrun.c:2057
void clear_internalvar(struct internalvar *var)
Definition: value.c:2380
struct thread_suspend_state suspend
Definition: gdbthread.h:202
CORE_ADDR pc
Definition: symtab.h:1376
const char * gdb_signal_to_symbol_string(enum gdb_signal sig)
Definition: signals.c:59
struct address_space * get_regcache_aspace(const struct regcache *regcache)
Definition: regcache.c:303
struct bpstat_what bpstat_what(bpstat bs_head)
Definition: breakpoint.c:5689
struct bound_probe find_probe_by_pc(CORE_ADDR pc)
Definition: probe.c:215
struct breakpoint * single_step_breakpoints
Definition: gdbthread.h:61
char permanent
Definition: breakpoint.h:378
void exit_inferior_num_silent(int num)
Definition: inferior.c:301
static void restore_inferior_ptid(void *arg)
Definition: infrun.c:7525
void regcache_xfree(struct regcache *regcache)
Definition: regcache.c:247
static void stop_waiting(struct execution_control_state *ecs)
Definition: infrun.c:6219
struct inferior * current_inferior(void)
Definition: inferior.c:57
struct cmd_list_element * add_info_alias(const char *name, const char *oldname, int abbrev_flag)
Definition: cli-decode.c:865
static int stepped_in_from(struct frame_info *frame, struct frame_id step_frame_id)
Definition: infrun.c:3579
static void show_debug_displaced(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:134
int is_exited(ptid_t ptid)
Definition: thread.c:828
int breakpoints_should_be_inserted_now(void)
Definition: breakpoint.c:460
auto_boolean
Definition: defs.h:196
struct interp * command_interp
Definition: gdbthread.h:140
static void insert_step_resume_breakpoint_at_caller(struct frame_info *)
Definition: infrun.c:6028
static void show_non_stop(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:197
struct program_space * current_program_space
Definition: progspace.c:35
static void follow_exec(ptid_t ptid, char *execd_pathname)
Definition: infrun.c:1054
void delete_single_step_breakpoints(struct thread_info *tp)
Definition: thread.c:121
unsigned long long ULONGEST
Definition: common-types.h:53
static const char follow_fork_mode_child[]
Definition: infrun.c:370
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:3698
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
struct cleanup * save_current_program_space(void)
Definition: progspace.c:228
const struct frame_id outer_frame_id
Definition: frame.c:507
int has_exit_code
Definition: inferior.h:374
int pid_to_thread_id(ptid_t ptid)
Definition: thread.c:459
static int hook_stop_stub(void *)
Definition: infrun.c:6773
int stepping_over_breakpoint
Definition: gdbthread.h:221
struct cleanup * record_full_gdb_operation_disable_set(void)
Definition: record-full.c:679
static int observer_mode_1
Definition: infrun.c:210
static void set_last_target_status(ptid_t ptid, struct target_waitstatus status)
Definition: infrun.c:3396
#define target_supports_multi_process()
Definition: target.h:1353
struct cleanup * save_current_space_and_thread(void)
Definition: progspace.c:448
void update_breakpoints_after_exec(void)
Definition: breakpoint.c:3725
void resume(enum gdb_signal sig)
Definition: infrun.c:2104
long ptid_get_lwp(ptid_t ptid)
Definition: ptid.c:60
struct type * value_type(const struct value *value)
Definition: value.c:1021
int watchpoints_triggered(struct target_waitstatus *ws)
Definition: breakpoint.c:4912
void update_solib_breakpoints(void)
Definition: solib.c:1316
#define RESUME_ALL
Definition: infrun.c:324
const char * gdb_signal_to_string(enum gdb_signal)
Definition: signals.c:68
static unsigned char * signal_print
Definition: infrun.c:283
static void write_memory_ptid(ptid_t ptid, CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
Definition: infrun.c:1764
unsigned int debug_infrun
Definition: infrun.c:140
Definition: symtab.h:703
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1590
static void set_observer_mode(char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:213
CORE_ADDR gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
Definition: gdbarch.c:3074
static void show_scheduler_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:1974
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
int target_follow_fork(int follow_child, int detach_fork)
Definition: target.c:2286
int stopped_by_random_signal
Definition: infrun.c:7387
void annotate_signal_string(void)
Definition: annotate.c:157
static const char exec_forward[]
Definition: infrun.c:7562
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2679
int signal_print_update(int signo, int state)
Definition: infrun.c:6825
static int follow_fork(void)
Definition: infrun.c:640
void ui_out_field_string(struct ui_out *uiout, const char *fldname, const char *string)
Definition: ui-out.c:541
void target_terminal_ours_for_output(void)
Definition: target.c:503
int pc_at_non_inline_function(struct address_space *aspace, CORE_ADDR pc, const struct target_waitstatus *ws)
Definition: breakpoint.c:15536
int gdbarch_skip_entrypoint_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2621
void wait_for_inferior(void)
Definition: infrun.c:3165
CORE_ADDR gdbarch_displaced_step_location(struct gdbarch *gdbarch)
Definition: gdbarch.c:3733
CORE_ADDR address
Definition: breakpoint.h:410
enum step_over_calls_kind step_over_calls
Definition: gdbthread.h:128
void breakpoint_retire_moribund(void)
Definition: breakpoint.c:12486
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
struct breakpoint * step_resume_breakpoint
Definition: gdbthread.h:51
enum stop_stack_kind stop_stack_dummy
Definition: infcmd.c:132
static int thread_still_needs_step_over(struct thread_info *tp)
Definition: infrun.c:2509
CORE_ADDR gdbarch_skip_entrypoint(struct gdbarch *gdbarch, CORE_ADDR ip)
Definition: gdbarch.c:2628
int signal_stop_update(int signo, int state)
Definition: infrun.c:6815
CORE_ADDR skip_language_trampoline(struct frame_info *frame, CORE_ADDR pc)
Definition: language.c:604
void * arg
Definition: cleanups.c:43
static enum stop_kind get_inferior_stop_soon(ptid_t ptid)
Definition: infrun.c:3662
void reinit_frame_cache(void)
Definition: frame.c:1687
int stop_requested
Definition: gdbthread.h:261
#define target_have_steppable_watchpoint
Definition: target.h:1849
int remove_breakpoints_pid(int pid)
Definition: breakpoint.c:3224
static int detach_fork
Definition: infrun.c:130
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
static void set_stop_on_solib_events(char *args, int from_tty, struct cmd_list_element *c)
Definition: infrun.c:338
static const char * follow_exec_mode_string
Definition: infrun.c:1043
static unsigned char * signal_pass
Definition: infrun.c:295
static void show_debug_infrun(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infrun.c:142
static int displaced_step_in_progress(int pid)
Definition: infrun.c:1469
#define QUIT
Definition: defs.h:160
int is_running(ptid_t ptid)
Definition: thread.c:834
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
static void do_restore_infcall_control_state_cleanup(void *sts)
Definition: infrun.c:7491
bpstat bpstat_stop_status(struct address_space *aspace, CORE_ADDR bp_addr, ptid_t ptid, const struct target_waitstatus *ws)
Definition: breakpoint.c:5493
static const char * follow_fork_mode_string
Definition: infrun.c:379
void target_find_description(void)
struct inferior * vfork_parent
Definition: inferior.h:344
struct target_waitstatus ws
Definition: infrun.c:2828
int gdbarch_gdb_signal_to_target(struct gdbarch *gdbarch, enum gdb_signal signal)
Definition: gdbarch.c:3943
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
struct displaced_step_closure * get_displaced_step_closure_by_addr(CORE_ADDR addr)
Definition: infrun.c:1508
static struct cmd_list_element * stop_command
Definition: infrun.c:328
void insert_step_resume_breakpoint_at_sal(struct gdbarch *gdbarch, struct symtab_and_line sr_sal, struct frame_id sr_id)
Definition: infrun.c:5978
struct type * gdbarch_get_siginfo_type(struct gdbarch *gdbarch)
Definition: gdbarch.c:3967
int has_stack_frames(void)
Definition: frame.c:1506
struct program_space * get_frame_program_space(struct frame_info *frame)
Definition: frame.c:2473
void observer_notify_end_stepping_range(void)
static void delete_just_stopped_threads_infrun_breakpoints_cleanup(void *arg)
Definition: infrun.c:3031
void breakpoint_re_set_thread(struct breakpoint *b)
Definition: breakpoint.c:14311
struct internalvar * create_internalvar_type_lazy(const char *name, const struct internalvar_funcs *funcs, void *data)
Definition: value.c:2096
struct thread_suspend_state thread_suspend
Definition: infrun.c:7253
void set_executing(ptid_t ptid, int executing)
Definition: thread.c:850
static void handle_signal_stop(struct execution_control_state *ecs)
Definition: infrun.c:4225
void error(const char *fmt,...)
Definition: errors.c:38
int return_child_result_value
Definition: main.c:90
struct gdbarch * gdbarch
Definition: inferior.h:397
ptid_t minus_one_ptid
Definition: ptid.c:26
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
int breakpoint_address_match(struct address_space *aspace1, CORE_ADDR addr1, struct address_space *aspace2, CORE_ADDR addr2)
Definition: breakpoint.c:6993
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
#define ALL_BLOCK_SYMBOLS(block, iter, sym)
Definition: block.h:333
void copy_terminal_info(struct inferior *to, struct inferior *from)
Definition: inflow.c:556
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
void set_current_inferior(struct inferior *inf)
Definition: inferior.c:63
void throw_error(enum errors error, const char *fmt,...)
long long LONGEST
Definition: common-types.h:52
static void sig_print_header(void)
Definition: infrun.c:6859
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
int is_executing(ptid_t ptid)
Definition: thread.c:840
void observer_notify_signal_exited(enum gdb_signal siggnal)
CORE_ADDR step_range_end
Definition: gdbthread.h:74
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:795
static int schedlock_applies(struct thread_info *tp)
Definition: infrun.c:2530
int exec_done_display_p
Definition: event-top.c:116
void step_into_inline_frame(ptid_t ptid)
Definition: inline-frame.c:356
gdb_byte * siginfo_data
Definition: infrun.c:7265
void check_longjmp_breakpoint_for_call_dummy(struct thread_info *tp)
Definition: breakpoint.c:7537
#define ALL_THREADS_SAFE(T, TMP)
Definition: gdbthread.h:383
void mark_breakpoints_out(void)
Definition: breakpoint.c:4058
const ULONGEST const LONGEST len
Definition: target.h:309
struct displaced_step_closure * step_closure
Definition: infrun.c:1436
int gdbarch_get_longjmp_target_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2373
enum bpstat_what_main_action main_action
Definition: breakpoint.h:989
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111