| blob | 9469b74af397dac9a3d47e362a49107e4e25cd67 |
1 /* Target-struct-independent code to start (run) and stop an inferior
2 process.
4 Copyright (C) 1986-2021 Free Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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/>. */
24 #include <ctype.h>
69 #include <unordered_map>
76 /* Prototypes for local functions */
98 /* Asynchronous signal handler registered as event loop source for
99 when we have pending events ready to be passed to the core. */
102 /* Stores whether infrun_async was previously enabled or disabled.
103 Starts off as -1, indicating "never enabled/disabled". */
106 /* See infrun.h. */
108 void
110 {
112 {
119 else
121 }
122 }
124 /* See infrun.h. */
126 void
128 {
130 }
132 /* When set, stop the 'step' command if we enter a function which has
133 no line number information. The normal behavior is that we step
134 over such function. */
136 static void
139 {
141 }
143 /* proceed and normal_stop use this to notify the user when the
144 inferior stopped in a different thread than it had been running
145 in. */
149 /* If set (default for legacy reasons), when following a fork, GDB
150 will detach from one of the fork branches, child or parent.
151 Exactly which branch is detached depends on 'set follow-fork-mode'
152 setting. */
157 static void
160 {
162 }
164 /* Support for disabling address space randomization. */
168 static void
171 {
176 value);
177 else
181 }
183 static void
186 {
191 }
193 /* User interface for non-stop mode. */
198 static void
201 {
203 {
206 }
209 }
211 static void
214 {
217 value);
218 }
220 /* "Observer mode" is somewhat like a more extreme version of
221 non-stop, in which all GDB operations that might affect the
222 target's execution have been disabled. */
227 static void
230 {
232 {
235 }
243 /* We can insert fast tracepoints in or out of observer mode,
244 but enable them if we're going into this mode. */
250 /* Going *into* observer mode we must force non-stop, then
251 going out we leave it that way. */
253 {
256 }
261 }
263 static void
266 {
268 }
270 /* This updates the value of observer mode based on changes in
271 permissions. Note that we are deliberately ignoring the values of
272 may-write-registers and may-write-memory, since the user may have
273 reason to enable these during a session, for instance to turn on a
274 debugging-related global. */
276 void
278 {
280 && !may_insert_tracepoints
281 && may_insert_fast_tracepoints
282 && !may_stop
285 /* Let the user know if things change. */
291 }
293 /* Tables of how to react to signals; the user sets them. */
299 /* Table of signals that are registered with "catch signal". A
300 non-zero entry indicates that the signal is caught by some "catch
301 signal" command. */
304 /* Table of signals that the target may silently handle.
305 This is automatically determined from the flags above,
306 and simply cached here. */
309 #define SET_SIGS(nsigs,sigs,flags) \
310 do { \
311 int signum = (nsigs); \
312 while (signum-- > 0) \
313 if ((sigs)[signum]) \
314 (flags)[signum] = 1; \
315 } while (0)
317 #define UNSET_SIGS(nsigs,sigs,flags) \
318 do { \
319 int signum = (nsigs); \
320 while (signum-- > 0) \
321 if ((sigs)[signum]) \
322 (flags)[signum] = 0; \
323 } while (0)
325 /* Update the target's copy of SIGNAL_PROGRAM. The sole purpose of
326 this function is to avoid exporting `signal_program'. */
328 void
330 {
332 }
334 /* Value to pass to target_resume() to cause all threads to resume. */
336 #define RESUME_ALL minus_one_ptid
338 /* Command list pointer for the "stop" placeholder. */
342 /* Nonzero if we want to give control to the user when we're notified
343 of shared library events by the dynamic linker. */
346 /* Enable or disable optional shared library event breakpoints
347 as appropriate when the above flag is changed. */
349 static void
352 {
354 }
356 static void
359 {
361 value);
362 }
364 /* True after stop if current stack frame should be printed. */
368 /* This is a cached copy of the target/ptid/waitstatus of the last
369 event returned by target_wait()/deprecated_target_wait_hook().
370 This information is returned by get_last_target_status(). */
381 follow_fork_mode_child,
382 follow_fork_mode_parent,
383 NULL
384 };
387 static void
390 {
394 value);
395 }
396 \f
398 /* Handle changes to the inferior list based on the type of fork,
399 which process is being followed, and whether the other process
400 should be detached. On entry inferior_ptid must be the ptid of
401 the fork parent. At return inferior_ptid is the ptid of the
402 followed inferior. */
404 static bool
406 {
419 {
420 /* The parent stays blocked inside the vfork syscall until the
421 child execs or exits. If we don't let the child run, then
422 the parent stays blocked. If we're telling the parent to run
423 in the foreground, the user will not be able to ctrl-c to get
424 back the terminal, effectively hanging the debug session. */
430 }
433 {
434 /* Detach new forked process? */
436 {
437 /* Before detaching from the child, remove all breakpoints
438 from it. If we forked, then this has already been taken
439 care of by infrun.c. If we vforked however, any
440 breakpoint inserted in the parent is visible in the
441 child, even those added while stopped in a vfork
442 catchpoint. This will remove the breakpoints from the
443 parent also, but they'll be reinserted below. */
445 {
446 /* Keep breakpoints list in sync. */
448 }
451 {
452 /* Ensure that we have a process ptid. */
460 }
461 }
462 else
463 {
466 /* Add process to GDB's tables. */
475 scoped_restore_current_pspace_and_thread restore_pspace_thread;
481 thread_info *child_thr
484 /* If this is a vfork child, then the address-space is
485 shared with the parent. */
487 {
493 /* The parent will be frozen until the child is done
494 with the shared region. Keep track of the
495 parent. */
501 /* Now that the inferiors and program spaces are all
502 wired up, we can switch to the child thread (which
503 switches inferior and program space too). */
505 }
506 else
507 {
514 /* solib_create_inferior_hook relies on the current
515 thread. */
518 /* Let the shared library layer (e.g., solib-svr4) learn
519 about this new process, relocate the cloned exec, pull
520 in shared libraries, and install the solib event
521 breakpoint. If a "cloned-VM" event was propagated
522 better throughout the core, this wouldn't be
523 required. */
524 scoped_restore restore_in_initial_library_scan
528 }
529 }
532 {
537 /* If we detached from the child, then we have to be careful
538 to not insert breakpoints in the parent until the child
539 is done with the shared memory region. However, if we're
540 staying attached to the child, then we can and should
541 insert breakpoints, so that we can debug it. A
542 subsequent child exec or exit is enough to know when does
543 the child stops using the parent's address space. */
546 }
547 }
548 else
549 {
550 /* Follow the child. */
555 {
565 }
567 /* Add the new inferior first, so that the target_detach below
568 doesn't unpush the target. */
582 {
583 /* Hold a strong reference to the target while (maybe)
584 detaching the parent. Otherwise detaching could close the
585 target. */
588 /* If we're vforking, we want to hold on to the parent until
589 the child exits or execs. At child exec or exit time we
590 can remove the old breakpoints from the parent and detach
591 or resume debugging it. Otherwise, detach the parent now;
592 we'll want to reuse it's program/address spaces, but we
593 can't set them to the child before removing breakpoints
594 from the parent, otherwise, the breakpoints module could
595 decide to remove breakpoints from the wrong process (since
596 they'd be assigned to the same address space). */
599 {
607 }
609 {
611 {
612 /* Ensure that we have a process ptid. */
620 }
624 }
626 /* Note that the detach above makes PARENT_INF dangling. */
628 /* Add the child thread to the appropriate lists, and switch
629 to this new thread, before cloning the program space, and
630 informing the solib layer about this new process. */
634 }
638 /* If this is a vfork child, then the address-space is shared
639 with the parent. If we detached from the parent, then we can
640 reuse the parent's program/address spaces. */
642 {
647 }
648 else
649 {
657 /* Let the shared library layer (e.g., solib-svr4) learn
658 about this new process, relocate the cloned exec, pull in
659 shared libraries, and install the solib event breakpoint.
660 If a "cloned-VM" event was propagated better throughout
661 the core, this wouldn't be required. */
662 scoped_restore restore_in_initial_library_scan
665 }
668 }
673 }
675 /* Tell the target to follow the fork we're stopped at. Returns true
676 if the inferior should be resumed; false, if the target for some
677 reason decided it's best not to resume. */
679 static bool
681 {
686 /* Copy user stepping state to the new inferior thread. FIXME: the
687 followed fork child thread should have a copy of most of the
688 parent thread structure's run control related fields, not just these.
689 Initialized to avoid "may be used uninitialized" warnings from gcc. */
700 {
702 ptid_t wait_ptid;
705 /* Get the last target status returned by target_wait(). */
708 /* If not stopped at a fork event, then there's nothing else to
709 do. */
714 /* Check if we switched over from WAIT_PTID, since the event was
715 reported. */
719 {
720 /* We did. Switch back to WAIT_PTID thread, to tell the
721 target to follow it (in either direction). We'll
722 afterwards refuse to resume, and inform the user what
723 happened. */
727 }
728 }
732 /* If there were any forks/vforks that were caught and are now to be
733 followed, then do so now. */
735 {
738 {
741 /* If the user did a next/step, etc, over a fork call,
742 preserve the stepping state in the fork child. */
744 {
745 step_resume_breakpoint = clone_momentary_breakpoint
752 exception_resume_breakpoint
756 /* For now, delete the parent's sr breakpoint, otherwise,
757 parent/child sr breakpoints are considered duplicates,
758 and the child version will not be installed. Remove
759 this when the breakpoints module becomes aware of
760 inferiors and address spaces. */
767 }
773 /* Set up inferior(s) as specified by the caller, and tell the
774 target to do whatever is necessary to follow either parent
775 or child. */
777 {
778 /* Target refused to follow, or there's some other reason
779 we shouldn't resume. */
781 }
782 else
783 {
784 /* This pending follow fork event is now handled, one way
785 or another. The previous selected thread may be gone
786 from the lists by now, but if it is still around, need
787 to clear the pending follow request. */
792 /* This makes sure we don't try to apply the "Switched
793 over from WAIT_PID" logic above. */
796 /* If we followed the child, switch to it... */
798 {
802 /* ... and preserve the stepping state, in case the
803 user was stepping over the fork call. */
805 {
817 }
818 else
819 {
820 /* If we get here, it was because we're trying to
821 resume from a fork catchpoint, but, the user
822 has switched threads away from the thread that
823 forked. In that case, the resume command
824 issued is most likely not applicable to the
825 child, so just warn, and refuse to resume. */
828 }
830 /* Reset breakpoints in the child as appropriate. */
832 }
833 }
834 }
837 /* Nothing to follow. */
844 }
847 }
849 static void
851 {
854 /* Was there a step_resume breakpoint? (There was if the user
855 did a "next" at the fork() call.) If so, explicitly reset its
856 thread number. Cloned step_resume breakpoints are disabled on
857 creation, so enable it here now that it is associated with the
858 correct thread.
860 step_resumes are a form of bp that are made to be per-thread.
861 Since we created the step_resume bp when the parent process
862 was being debugged, and now are switching to the child process,
863 from the breakpoint package's viewpoint, that's a switch of
864 "threads". We must update the bp's notion of which thread
865 it is for, or it'll be ignored when it triggers. */
868 {
871 }
873 /* Treat exception_resume breakpoints like step_resume breakpoints. */
875 {
878 }
880 /* Reinsert all breakpoints in the child. The user may have set
881 breakpoints after catching the fork, in which case those
882 were never set in the child, but only in the parent. This makes
883 sure the inserted breakpoints match the breakpoint list. */
887 }
889 /* The child has exited or execed: resume threads of the parent the
890 user wanted to be executing. */
892 static int
895 {
903 {
910 }
913 }
915 /* Called whenever we notice an exec or exit event, to handle
916 detaching or resuming a vfork parent. */
918 static void
920 {
924 {
927 /* This exec or exit marks the end of the shared memory region
928 between the parent and the child. Break the bonds. */
933 /* If the user wanted to detach from the parent, now is the
934 time. */
936 {
940 /* follow-fork child, detach-on-fork on. */
944 scoped_restore_current_pspace_and_thread restore_thread;
946 /* We're letting loose of the parent. */
950 /* We're about to detach from the parent, which implicitly
951 removes breakpoints from its address space. There's a
952 catch here: we want to reuse the spaces for the child,
953 but, parent/child are still sharing the pspace at this
954 point, although the exec in reality makes the kernel give
955 the child a fresh set of new pages. The problem here is
956 that the breakpoints module being unaware of this, would
957 likely chose the child process to write to the parent
958 address space. Swapping the child temporarily away from
959 the spaces has the desired effect. Yes, this is "sort
960 of" a hack. */
968 {
975 {
979 }
980 else
981 {
985 }
986 }
990 /* Put it back. */
993 }
995 {
996 /* We're staying attached to the parent, so, really give the
997 child a new address space. */
1004 }
1005 else
1006 {
1007 /* If this is a vfork child exiting, then the pspace and
1008 aspaces were shared with the parent. Since we're
1009 reporting the process exit, we'll be mourning all that is
1010 found in the address space, and switching to null_ptid,
1011 preparing to start a new inferior. But, since we don't
1012 want to clobber the parent's address/program spaces, we
1013 go ahead and create a new one for this exiting
1014 inferior. */
1016 /* Switch to no-thread while running clone_program_space, so
1017 that clone_program_space doesn't want to read the
1018 selected frame of a dead process. */
1019 scoped_restore_current_thread restore_thread;
1030 }
1035 {
1036 /* If the user wanted the parent to be running, let it go
1037 free now. */
1038 scoped_restore_current_thread restore_thread;
1041 resume_parent);
1044 }
1045 }
1046 }
1048 /* Enum strings for "set|show follow-exec-mode". */
1053 {
1054 follow_exec_mode_new,
1055 follow_exec_mode_same,
1056 NULL,
1057 };
1060 static void
1063 {
1065 }
1067 /* EXEC_FILE_TARGET is assumed to be non-NULL. */
1069 static void
1071 {
1073 ptid_t process_ptid;
1075 /* Switch terminal for any messages produced e.g. by
1076 breakpoint_re_set. */
1079 /* This is an exec event that we actually wish to pay attention to.
1080 Refresh our symbol table to the newly exec'd program, remove any
1081 momentary bp's, etc.
1083 If there are breakpoints, they aren't really inserted now,
1084 since the exec() transformed our inferior into a fresh set
1085 of instructions.
1087 We want to preserve symbolic breakpoints on the list, since
1088 we have hopes that they can be reset after the new a.out's
1089 symbol table is read.
1091 However, any "raw" breakpoints must be removed from the list
1092 (e.g., the solib bp's), since their address is probably invalid
1093 now.
1095 And, we DON'T want to call delete_breakpoints() here, since
1096 that may write the bp's "shadow contents" (the instruction
1097 value that was overwritten with a TRAP instruction). Since
1098 we now have a new a.out, those shadow contents aren't valid. */
1102 /* The target reports the exec event to the main thread, even if
1103 some other thread does the exec, and even if the main thread was
1104 stopped or already gone. We may still have non-leader threads of
1105 the process on our list. E.g., on targets that don't have thread
1106 exit events (like remote); or on native Linux in non-stop mode if
1107 there were only two threads in the inferior and the non-leader
1108 one is the one that execs (and nothing forces an update of the
1109 thread list up to here). When debugging remotely, it's best to
1110 avoid extra traffic, when possible, so avoid syncing the thread
1111 list with the target, and instead go ahead and delete all threads
1112 of the process but one that reported the event. Note this must
1113 be done before calling update_breakpoints_after_exec, as
1114 otherwise clearing the threads' resources would reference stale
1115 thread breakpoints -- it may have been one of these threads that
1116 stepped across the exec. We could just clear their stepping
1117 states, but as long as we're iterating, might as well delete
1118 them. Deleting them now rather than at the next user-visible
1119 stop provides a nicer sequence of events for user and MI
1120 notifications. */
1125 /* We also need to clear any left over stale state for the
1126 leader/event thread. E.g., if there was any step-resume
1127 breakpoint or similar, it's gone now. We cannot truly
1128 step-to-next statement through an exec(). */
1136 /* The user may have had the main thread held stopped in the
1137 previous image (e.g., schedlock on, or non-stop). Release
1138 it now. */
1143 /* What is this a.out's name? */
1147 exec_file_target);
1149 /* We've followed the inferior through an exec. Therefore, the
1150 inferior has essentially been killed & reborn. */
1157 /* If we were unable to map the executable target pathname onto a host
1158 pathname, tell the user that. Otherwise GDB's subsequent behavior
1159 is confusing. Maybe it would even be better to stop at this point
1160 so that the user can specify a file manually before continuing. */
1164 exec_file_target);
1166 /* Reset the shared library package. This ensures that we get a
1167 shlib event when the child reaches "_start", at which point the
1168 dld will have had a chance to initialize the child. */
1169 /* Also, loading a symbol file below may trigger symbol lookups, and
1170 we don't want those to be satisfied by the libraries of the
1171 previous incarnation of this process. */
1177 {
1178 /* The user wants to keep the old inferior and program spaces
1179 around. Create a new fresh one, and switch to it. */
1181 /* Do exit processing for the original inferior before setting the new
1182 inferior's pid. Having two inferiors with the same pid would confuse
1183 find_inferior_p(t)id. Transfer the terminal state and info from the
1184 old to the new inferior. */
1193 /* We continue with the new inferior. */
1195 }
1196 else
1197 {
1198 /* The old description may no longer be fit for the new image.
1199 E.g, a 64-bit process exec'ed a 32-bit process. Clear the
1200 old description; we'll read a new one below. No need to do
1201 this on "follow-exec-mode new", as the old inferior stays
1202 around (its description is later cleared/refetched on
1203 restart). */
1206 }
1211 /* Attempt to open the exec file. SYMFILE_DEFER_BP_RESET is used
1212 because the proper displacement for a PIE (Position Independent
1213 Executable) main symbol file will only be computed by
1214 solib_create_inferior_hook below. breakpoint_re_set would fail
1215 to insert the breakpoints with the zero displacement. */
1218 /* If the target can specify a description, read it. Must do this
1219 after flipping to the new executable (because the target supplied
1220 description must be compatible with the executable's
1221 architecture, and the old executable may e.g., be 32-bit, while
1222 the new one 64-bit), and before anything involving memory or
1223 registers. */
1230 /* Reinsert all breakpoints. (Those which were symbolic have
1231 been reset to the proper address in the new a.out, thanks
1232 to symbol_file_command...). */
1235 /* The next resume of this inferior should bring it to the shlib
1236 startup breakpoints. (If the user had also set bp's on
1237 "main" from the old (parent) process, then they'll auto-
1238 matically get reset there in the new process.). */
1239 }
1241 /* The chain of threads that need to do a step-over operation to get
1242 past e.g., a breakpoint. What technique is used to step over the
1243 breakpoint/watchpoint does not matter -- all threads end up in the
1244 same queue, to maintain rough temporal order of execution, in order
1245 to avoid starvation, otherwise, we could e.g., find ourselves
1246 constantly stepping the same couple threads past their breakpoints
1247 over and over, if the single-step finish fast enough. */
1250 /* Bit flags indicating what the thread needs to step over. */
1252 enum step_over_what_flag
1253 {
1254 /* Step over a breakpoint. */
1257 /* Step past a non-continuable watchpoint, in order to let the
1258 instruction execute so we can evaluate the watchpoint
1259 expression. */
1261 };
1264 /* Info about an instruction that is being stepped over. */
1266 struct step_over_info
1267 {
1268 /* If we're stepping past a breakpoint, this is the address space
1269 and address of the instruction the breakpoint is set at. We'll
1270 skip inserting all breakpoints here. Valid iff ASPACE is
1271 non-NULL. */
1275 /* The instruction being stepped over triggers a nonsteppable
1276 watchpoint. If true, we'll skip inserting watchpoints. */
1279 /* The thread's global number. */
1281 };
1283 /* The step-over info of the location that is being stepped over.
1285 Note that with async/breakpoint always-inserted mode, a user might
1286 set a new breakpoint/watchpoint/etc. exactly while a breakpoint is
1287 being stepped over. As setting a new breakpoint inserts all
1288 breakpoints, we need to make sure the breakpoint being stepped over
1289 isn't inserted then. We do that by only clearing the step-over
1290 info when the step-over is actually finished (or aborted).
1292 Presently GDB can only step over one breakpoint at any given time.
1293 Given threads that can't run code in the same address space as the
1294 breakpoint's can't really miss the breakpoint, GDB could be taught
1295 to step-over at most one breakpoint per address space (so this info
1296 could move to the address space object if/when GDB is extended).
1297 The set of breakpoints being stepped over will normally be much
1298 smaller than the set of all breakpoints, so a flag in the
1299 breakpoint location structure would be wasteful. A separate list
1300 also saves complexity and run-time, as otherwise we'd have to go
1301 through all breakpoint locations clearing their flag whenever we
1302 start a new sequence. Similar considerations weigh against storing
1303 this info in the thread object. Plus, not all step overs actually
1304 have breakpoint locations -- e.g., stepping past a single-step
1305 breakpoint, or stepping to complete a non-continuable
1306 watchpoint. */
1309 /* Record the address of the breakpoint/instruction we're currently
1310 stepping over.
1311 N.B. We record the aspace and address now, instead of say just the thread,
1312 because when we need the info later the thread may be running. */
1314 static void
1318 {
1323 }
1325 /* Called when we're not longer stepping over a breakpoint / an
1326 instruction, so all breakpoints are free to be (re)inserted. */
1328 static void
1330 {
1336 }
1338 /* See infrun.h. */
1340 int
1342 CORE_ADDR address)
1343 {
1348 }
1350 /* See infrun.h. */
1352 int
1354 {
1357 }
1359 /* See infrun.h. */
1361 int
1363 {
1365 }
1367 /* Returns true if step-over info is valid. */
1369 static bool
1371 {
1374 }
1376 \f
1377 /* Displaced stepping. */
1379 /* In non-stop debugging mode, we must take special care to manage
1380 breakpoints properly; in particular, the traditional strategy for
1381 stepping a thread past a breakpoint it has hit is unsuitable.
1382 'Displaced stepping' is a tactic for stepping one thread past a
1383 breakpoint it has hit while ensuring that other threads running
1384 concurrently will hit the breakpoint as they should.
1386 The traditional way to step a thread T off a breakpoint in a
1387 multi-threaded program in all-stop mode is as follows:
1389 a0) Initially, all threads are stopped, and breakpoints are not
1390 inserted.
1391 a1) We single-step T, leaving breakpoints uninserted.
1392 a2) We insert breakpoints, and resume all threads.
1394 In non-stop debugging, however, this strategy is unsuitable: we
1395 don't want to have to stop all threads in the system in order to
1396 continue or step T past a breakpoint. Instead, we use displaced
1397 stepping:
1399 n0) Initially, T is stopped, other threads are running, and
1400 breakpoints are inserted.
1401 n1) We copy the instruction "under" the breakpoint to a separate
1402 location, outside the main code stream, making any adjustments
1403 to the instruction, register, and memory state as directed by
1404 T's architecture.
1405 n2) We single-step T over the instruction at its new location.
1406 n3) We adjust the resulting register and memory state as directed
1407 by T's architecture. This includes resetting T's PC to point
1408 back into the main instruction stream.
1409 n4) We resume T.
1411 This approach depends on the following gdbarch methods:
1413 - gdbarch_max_insn_length and gdbarch_displaced_step_location
1414 indicate where to copy the instruction, and how much space must
1415 be reserved there. We use these in step n1.
1417 - gdbarch_displaced_step_copy_insn copies a instruction to a new
1418 address, and makes any necessary adjustments to the instruction,
1419 register contents, and memory. We use this in step n1.
1421 - gdbarch_displaced_step_fixup adjusts registers and memory after
1422 we have successfully single-stepped the instruction, to yield the
1423 same effect the instruction would have had if we had executed it
1424 at its original address. We use this in step n3.
1426 The gdbarch_displaced_step_copy_insn and
1427 gdbarch_displaced_step_fixup functions must be written so that
1428 copying an instruction with gdbarch_displaced_step_copy_insn,
1429 single-stepping across the copied instruction, and then applying
1430 gdbarch_displaced_insn_fixup should have the same effects on the
1431 thread's memory and registers as stepping the instruction in place
1432 would have. Exactly which responsibilities fall to the copy and
1433 which fall to the fixup is up to the author of those functions.
1435 See the comments in gdbarch.sh for details.
1437 Note that displaced stepping and software single-step cannot
1438 currently be used in combination, although with some care I think
1439 they could be made to. Software single-step works by placing
1440 breakpoints on all possible subsequent instructions; if the
1441 displaced instruction is a PC-relative jump, those breakpoints
1442 could fall in very strange places --- on pages that aren't
1443 executable, or at addresses that are not proper instruction
1444 boundaries. (We do generally let other threads run while we wait
1445 to hit the software single-step breakpoint, and they might
1446 encounter such a corrupted instruction.) One way to work around
1447 this would be to have gdbarch_displaced_step_copy_insn fully
1448 simulate the effect of PC-relative instructions (and return NULL)
1449 on architectures that use software single-stepping.
1451 In non-stop mode, we can have independent and simultaneous step
1452 requests, so more than one thread may need to simultaneously step
1453 over a breakpoint. The current implementation assumes there is
1454 only one scratch space per process. In this case, we have to
1455 serialize access to the scratch space. If thread A wants to step
1456 over a breakpoint, but we are currently waiting for some other
1457 thread to complete a displaced step, we leave thread A stopped and
1458 place it in the displaced_step_request_queue. Whenever a displaced
1459 step finishes, we pick the next thread in the queue and start a new
1460 displaced step operation on it. See displaced_step_prepare and
1461 displaced_step_finish for details. */
1463 /* Return true if THREAD is doing a displaced step. */
1465 static bool
1467 {
1471 }
1473 /* Return true if INF has a thread doing a displaced step. */
1475 static bool
1477 {
1479 }
1481 /* Return true if any thread is doing a displaced step. */
1483 static bool
1485 {
1487 {
1490 }
1493 }
1495 static void
1497 {
1499 }
1501 static void
1503 {
1504 /* If some threads where was doing a displaced step in this inferior at the
1505 moment of the exec, they no longer exist. Even if the exec'ing thread
1506 doing a displaced step, we don't want to to any fixup nor restore displaced
1507 stepping buffer bytes. */
1513 /* Since an in-line step is done with everything else stopped, if there was
1514 one in progress at the time of the exec, it must have been the exec'ing
1515 thread. */
1517 }
1519 /* If ON, and the architecture supports it, GDB will use displaced
1520 stepping to step over breakpoints. If OFF, or if the architecture
1521 doesn't support it, GDB will instead use the traditional
1522 hold-and-step approach. If AUTO (which is the default), GDB will
1523 decide which technique to use to step over breakpoints depending on
1524 whether the target works in a non-stop way (see use_displaced_stepping). */
1528 static void
1532 {
1538 else
1542 }
1544 /* Return true if the gdbarch implements the required methods to use
1545 displaced stepping. */
1547 static bool
1549 {
1550 /* Only check for the presence of `prepare`. The gdbarch verification ensures
1551 that if `prepare` is provided, so is `finish`. */
1553 }
1555 /* Return non-zero if displaced stepping can/should be used to step
1556 over breakpoints of thread TP. */
1558 static bool
1560 {
1561 /* If the user disabled it explicitly, don't use displaced stepping. */
1565 /* If "auto", only use displaced stepping if the target operates in a non-stop
1566 way. */
1573 /* If the architecture doesn't implement displaced stepping, don't use
1574 it. */
1578 /* If recording, don't use displaced stepping. */
1582 /* If displaced stepping failed before for this inferior, don't bother trying
1583 again. */
1588 }
1590 /* Simple function wrapper around displaced_step_thread_state::reset. */
1592 static void
1594 {
1596 }
1598 /* A cleanup that wraps displaced_step_reset. We use this instead of, say,
1599 SCOPE_EXIT, because it needs to be discardable with "cleanup.release ()". */
1603 /* See infrun.h. */
1607 {
1611 {
1614 else
1616 }
1619 }
1621 /* Prepare to single-step, using displaced stepping.
1623 Note that we cannot use displaced stepping when we have a signal to
1624 deliver. If we have a signal to deliver and an instruction to step
1625 over, then after the step, there will be no indication from the
1626 target whether the thread entered a signal handler or ignored the
1627 signal and stepped over the instruction successfully --- both cases
1628 result in a simple SIGTRAP. In the first case we mustn't do a
1629 fixup, and in the second case we must --- but we can't tell which.
1630 Comments in the code for 'random signals' in handle_inferior_event
1631 explain how we handle this case instead.
1633 Returns DISPLACED_STEP_PREPARE_STATUS_OK if preparing was successful -- this
1634 thread is going to be stepped now; DISPLACED_STEP_PREPARE_STATUS_UNAVAILABLE
1635 if displaced stepping this thread got queued; or
1636 DISPLACED_STEP_PREPARE_STATUS_CANT if this instruction can't be displaced
1637 stepped. */
1639 static displaced_step_prepare_status
1641 {
1644 displaced_step_thread_state &disp_step_thread_state
1647 /* We should never reach this function if the architecture does not
1648 support displaced stepping. */
1651 /* Nor if the thread isn't meant to step over a breakpoint. */
1654 /* Disable range stepping while executing in the scratch pad. We
1655 want a single-step even if executing the displaced instruction in
1656 the scratch buffer lands within the stepping range (e.g., a
1657 jump/branch). */
1660 /* We are about to start a displaced step for this thread. If one is already
1661 in progress, something's wrong. */
1665 {
1666 /* The gdbarch tells us it's not worth asking to try a prepare because
1667 it is likely that it will return unavailable, so don't bother asking. */
1674 }
1679 scoped_restore_current_thread restore_thread;
1684 CORE_ADDR displaced_pc;
1686 displaced_step_prepare_status status
1690 {
1695 }
1697 {
1698 /* Not enough displaced stepping resources available, defer this
1699 request by placing it the queue. */
1708 }
1712 /* Save the information we need to fix things up if the step
1713 succeeds. */
1725 }
1727 /* Wrapper for displaced_step_prepare_throw that disabled further
1728 attempts at displaced stepping if we get a memory error. */
1730 static displaced_step_prepare_status
1732 {
1733 displaced_step_prepare_status status
1736 try
1737 {
1739 }
1741 {
1749 /* Be verbose if "set displaced-stepping" is "on", silent if
1750 "auto". */
1752 {
1755 }
1757 /* Disable further displaced stepping attempts. */
1759 }
1762 }
1764 /* If we displaced stepped an instruction successfully, adjust registers and
1765 memory to yield the same effect the instruction would have had if we had
1766 executed it at its original address, and return
1767 DISPLACED_STEP_FINISH_STATUS_OK. If the instruction didn't complete,
1768 relocate the PC and return DISPLACED_STEP_FINISH_STATUS_NOT_EXECUTED.
1770 If the thread wasn't displaced stepping, return
1771 DISPLACED_STEP_FINISH_STATUS_OK as well. */
1773 static displaced_step_finish_status
1775 {
1778 /* Was this thread performing a displaced step? */
1785 /* Fixup may need to read memory/registers. Switch to the thread
1786 that we're fixing up. Also, target_stopped_by_watchpoint checks
1787 the current thread, and displaced_step_restore performs ptid-dependent
1788 memory accesses using current_inferior(). */
1793 /* Do the fixup, and release the resources acquired to do the displaced
1794 step. */
1797 }
1799 /* Data to be passed around while handling an event. This data is
1800 discarded between events. */
1801 struct execution_control_state
1802 {
1804 ptid_t ptid;
1805 /* The thread that got the event, if this was a thread event; NULL
1806 otherwise. */
1811 CORE_ADDR stop_func_start;
1812 CORE_ADDR stop_func_end;
1816 /* True if the event thread hit the single-step breakpoint of
1817 another thread. Thus the event doesn't cause a stop, the thread
1818 needs to be single-stepped past the single-step breakpoint before
1819 we can switch back to the original stepping thread. */
1821 };
1823 /* Clear ECS and set it to point at TP. */
1825 static void
1827 {
1831 }
1838 /* Are there any pending step-over requests? If so, run all we can
1839 now and return true. Otherwise, return false. */
1841 static bool
1843 {
1844 INFRUN_SCOPED_DEBUG_ENTER_EXIT;
1848 /* Don't start a new step-over if we already have an in-line
1849 step-over operation ongoing. */
1853 /* Steal the global thread step over chain. As we try to initiate displaced
1854 steps, threads will be enqueued in the global chain if no buffers are
1855 available. If we iterated on the global chain directly, we might iterate
1856 indefinitely. */
1865 /* On scope exit (whatever the reason, return or exception), if there are
1866 threads left in the THREADS_TO_STEP chain, put back these threads in the
1867 global list. */
1868 SCOPE_EXIT
1869 {
1872 else
1873 {
1878 }
1879 };
1882 {
1885 step_over_what step_what;
1893 {
1894 /* The arch told us to not even try preparing another displaced step
1895 for this inferior. Just leave the thread in THREADS_TO_STEP, it
1896 will get moved to the global chain on scope exit. */
1898 }
1900 /* Remove thread from the THREADS_TO_STEP chain. If anything goes wrong
1901 while we try to prepare the displaced step, we don't add it back to
1902 the global step over chain. This is to avoid a thread staying in the
1903 step over chain indefinitely if something goes wrong when resuming it
1904 If the error is intermittent and it still needs a step over, it will
1905 get enqueued again when we try to resume it normally. */
1913 /* We currently stop all threads of all processes to step-over
1914 in-line. If we need to start a new in-line step-over, let
1915 any pending displaced steps finish first. */
1917 {
1920 }
1925 {
1927 "[%s] has inconsistent state: "
1933 }
1938 /* keep_going_pass_signal skips the step-over if the breakpoint
1939 is no longer inserted. In all-stop, we want to keep looking
1940 for a thread that needs a step-over instead of resuming TP,
1941 because we wouldn't be able to resume anything else until the
1942 target stops again. In non-stop, the resume always resumes
1943 only TP, so it's OK to let the thread resume freely. */
1954 /* If the thread's step over could not be initiated because no buffers
1955 were available, it was re-added to the global step over chain. */
1957 {
1961 }
1962 else
1963 {
1967 }
1969 /* If we started a new in-line step-over, we're done. */
1971 {
1975 }
1978 {
1979 /* On all-stop, shouldn't have resumed unless we needed a
1980 step over. */
1984 /* With remote targets (at least), in all-stop, we can't
1985 issue any further remote commands until the program stops
1986 again. */
1989 }
1991 /* Either the thread no longer needed a step-over, or a new
1992 displaced stepping sequence started. Even in the latter
1993 case, continue looking. Maybe we can also start another
1994 displaced step on a thread of other process. */
1995 }
1998 }
2000 /* Update global variables holding ptids to hold NEW_PTID if they were
2001 holding OLD_PTID. */
2002 static void
2005 {
2009 }
2011 \f
2018 schedlock_off,
2019 schedlock_on,
2020 schedlock_step,
2021 schedlock_replay,
2022 NULL
2023 };
2025 static void
2028 {
2032 value);
2033 }
2035 static void
2037 {
2039 {
2043 }
2044 }
2046 /* True if execution commands resume all threads of all processes by
2047 default; otherwise, resume only threads of the current inferior
2048 process. */
2051 /* Try to setup for software single stepping over the specified location.
2052 Return true if target_resume() should use hardware single step.
2054 GDBARCH the current gdbarch.
2055 PC the location to step over. */
2057 static bool
2059 {
2067 }
2069 /* See infrun.h. */
2071 ptid_t
2073 {
2074 ptid_t resume_ptid;
2077 {
2078 /* With non-stop mode on, threads are always handled
2079 individually. */
2081 }
2084 {
2085 /* User-settable 'scheduler' mode requires solo thread
2086 resume. */
2088 }
2091 {
2092 /* User-settable 'scheduler' mode requires solo thread resume in replay
2093 mode. */
2095 }
2097 {
2098 /* Resume all threads of the current process (and none of other
2099 processes). */
2101 }
2102 else
2103 {
2104 /* Resume all threads of all processes. */
2106 }
2109 }
2111 /* See infrun.h. */
2113 process_stratum_target *
2115 {
2117 ? NULL
2119 }
2121 /* Return a ptid representing the set of threads that we will resume,
2122 in the perspective of the target, assuming run control handling
2123 does not require leaving some threads stopped (e.g., stepping past
2124 breakpoint). USER_STEP indicates whether we're about to start the
2125 target for a stepping command. */
2127 static ptid_t
2129 {
2130 /* In non-stop, we always control threads individually. Note that
2131 the target may always work in non-stop mode even with "set
2132 non-stop off", in which case user_visible_resume_ptid could
2133 return a wildcard ptid. */
2136 else
2138 }
2140 /* Wrapper for target_resume, that handles infrun-specific
2141 bookkeeping. */
2143 static void
2145 {
2150 /* Install inferior's terminal modes. */
2153 /* Avoid confusing the next resume, if the next stop/resume
2154 happens to apply to another thread. */
2157 /* Advise target which signals may be handled silently.
2159 If we have removed breakpoints because we are stepping over one
2160 in-line (in any thread), we need to receive all signals to avoid
2161 accidentally skipping a breakpoint during execution of a signal
2162 handler.
2164 Likewise if we're displaced stepping, otherwise a trap for a
2165 breakpoint in a signal handler might be confused with the
2166 displaced step finishing. We don't make the displaced_step_finish
2167 step distinguish the cases instead, because:
2169 - a backtrace while stopped in the signal handler would show the
2170 scratch pad as frame older than the signal handler, instead of
2171 the real mainline code.
2173 - when the thread is later resumed, the signal handler would
2174 return to the scratch pad area, which would no longer be
2175 valid. */
2179 else
2186 }
2188 /* Resume the inferior. SIG is the signal to give the inferior
2189 (GDB_SIGNAL_0 for none). Note: don't call this directly; instead
2190 call 'resume', which handles exceptions. */
2192 static void
2194 {
2199 ptid_t resume_ptid;
2200 /* This represents the user's step vs continue request. When
2201 deciding whether "set scheduler-locking step" applies, it's the
2202 user's intention that counts. */
2204 /* This represents what we'll actually request the target to do.
2205 This can decay from a step to a continue, if e.g., we need to
2206 implement single-stepping with breakpoints (software
2207 single-step). */
2214 {
2215 infrun_debug_printf
2225 /* FIXME: What should we do if we are supposed to resume this
2226 thread with a signal? Maybe we should maintain a queue of
2227 pending signals to deliver. */
2229 {
2233 }
2238 {
2240 /* Tell the event loop we have an event to process. */
2242 }
2244 }
2248 /* Depends on stepped_breakpoint. */
2252 {
2253 /* Don't try to single-step a vfork parent that is waiting for
2254 the child to get out of the shared memory region (by exec'ing
2255 or exiting). This is particularly important on software
2256 single-step archs, as the child process would trip on the
2257 software single step breakpoint inserted for the parent
2258 process. Since the parent will not actually execute any
2259 instruction until the child is out of the shared region (such
2260 are vfork's semantics), it is safe to simply continue it.
2261 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for
2262 the parent, and tell it to `keep_going', which automatically
2263 re-sets it stepping. */
2266 }
2277 /* Normally, by the time we reach `resume', the breakpoints are either
2278 removed or inserted, as appropriate. The exception is if we're sitting
2279 at a permanent breakpoint; we need to step over it, but permanent
2280 breakpoints can't be removed. So we have to test for it here. */
2282 {
2284 {
2285 /* We have a signal to pass to the inferior. The resume
2286 may, or may not take us to the signal handler. If this
2287 is a step, we'll need to stop in the signal handler, if
2288 there's one, (if the target supports stepping into
2289 handlers), or in the next mainline instruction, if
2290 there's no handler. If this is a continue, we need to be
2291 sure to run the handler with all breakpoints inserted.
2292 In all cases, set a breakpoint at the current address
2293 (where the handler returns to), and once that breakpoint
2294 is hit, resume skipping the permanent breakpoint. If
2295 that breakpoint isn't hit, then we've stepped into the
2296 signal handler (or hit some other event). We'll delete
2297 the step-resume breakpoint then. */
2306 {
2307 /* Set a "high-priority" step-resume, as we don't want
2308 user breakpoints at PC to trigger (again) when this
2309 hits. */
2314 }
2317 }
2318 else
2319 {
2320 /* There's no signal to pass, we can go ahead and skip the
2321 permanent breakpoint manually. */
2324 /* Update pc to reflect the new address from which we will
2325 execute instructions. */
2329 {
2330 /* We've already advanced the PC, so the stepping part
2331 is done. Now we need to arrange for a trap to be
2332 reported to handle_inferior_event. Set a breakpoint
2333 at the current PC, and run to it. Don't update
2334 prev_pc, because if we end in
2335 switch_back_to_stepped_thread, we want the "expected
2336 thread advanced also" branch to be taken. IOW, we
2337 don't want this thread to step further from PC
2338 (overstep). */
2347 }
2348 }
2349 }
2351 /* If we have a breakpoint to step over, make sure to do a single
2352 step only. Same if we have software watchpoints. */
2356 /* If displaced stepping is enabled, step over breakpoints by executing a
2357 copy of the instruction at a different address.
2359 We can't use displaced stepping when we have a signal to deliver;
2360 the comments for displaced_step_prepare explain why. The
2361 comments in the handle_inferior event for dealing with 'random
2362 signals' explain what we do instead.
2364 We can't use displaced stepping when we are waiting for vfork_done
2365 event, displaced stepping breaks the vfork child similarly as single
2366 step software breakpoint. */
2372 {
2373 displaced_step_prepare_status prepare_status
2377 {
2382 }
2384 {
2385 /* Fallback to stepping over the breakpoint in-line. */
2396 }
2398 {
2399 /* Update pc to reflect the new address from which we will
2400 execute instructions due to displaced stepping. */
2404 }
2405 else
2408 }
2410 /* Do we need to do it the hard way, w/temp breakpoints? */
2414 /* Currently, our software single-step implementation leads to different
2415 results than hardware single-stepping in one situation: when stepping
2416 into delivering a signal which has an associated signal handler,
2417 hardware single-step will stop at the first instruction of the handler,
2418 while software single-step will simply skip execution of the handler.
2420 For now, this difference in behavior is accepted since there is no
2421 easy way to actually implement single-stepping into a signal handler
2422 without kernel support.
2424 However, there is one scenario where this difference leads to follow-on
2425 problems: if we're stepping off a breakpoint by removing all breakpoints
2426 and then single-stepping. In this case, the software single-step
2427 behavior means that even if there is a *breakpoint* in the signal
2428 handler, GDB still would not stop.
2430 Fortunately, we can at least fix this particular issue. We detect
2431 here the case where we are about to deliver a signal while software
2432 single-stepping with breakpoints removed. In this situation, we
2433 revert the decisions to remove all breakpoints and insert single-
2434 step breakpoints, and instead we install a step-resume breakpoint
2435 at the current address, deliver the signal without stepping, and
2436 once we arrive back at the step-resume breakpoint, actually step
2437 over the breakpoint we originally wanted to step over. */
2441 {
2442 /* If we have nested signals or a pending signal is delivered
2443 immediately after a handler returns, might already have
2444 a step-resume breakpoint set on the earlier handler. We cannot
2445 set another step-resume breakpoint; just continue on until the
2446 original breakpoint is hit. */
2448 {
2451 }
2459 }
2461 /* If STEP is set, it's a request to use hardware stepping
2462 facilities. But in that case, we should never
2463 use singlestep breakpoint. */
2466 /* Decide the set of threads to ask the target to resume. */
2468 {
2469 /* We're allowing a thread to run past a breakpoint it has
2470 hit, either by single-stepping the thread with the breakpoint
2471 removed, or by displaced stepping, with the breakpoint inserted.
2472 In the former case, we need to single-step only this thread,
2473 and keep others stopped, as they can miss this breakpoint if
2474 allowed to run. That's not really a problem for displaced
2475 stepping, but, we still keep other threads stopped, in case
2476 another thread is also stopped for a breakpoint waiting for
2477 its turn in the displaced stepping queue. */
2479 }
2480 else
2485 {
2486 /* There are two cases where we currently need to step a
2487 breakpoint instruction when we have a signal to deliver:
2489 - See handle_signal_stop where we handle random signals that
2490 could take out us out of the stepping range. Normally, in
2491 that case we end up continuing (instead of stepping) over the
2492 signal handler with a breakpoint at PC, but there are cases
2493 where we should _always_ single-step, even if we have a
2494 step-resume breakpoint, like when a software watchpoint is
2495 set. Assuming single-stepping and delivering a signal at the
2496 same time would takes us to the signal handler, then we could
2497 have removed the breakpoint at PC to step over it. However,
2498 some hardware step targets (like e.g., Mac OS) can't step
2499 into signal handlers, and for those, we need to leave the
2500 breakpoint at PC inserted, as otherwise if the handler
2501 recurses and executes PC again, it'll miss the breakpoint.
2502 So we leave the breakpoint inserted anyway, but we need to
2503 record that we tried to step a breakpoint instruction, so
2504 that adjust_pc_after_break doesn't end up confused.
2506 - In non-stop if we insert a breakpoint (e.g., a step-resume)
2507 in one thread after another thread that was stepping had been
2508 momentarily paused for a step-over. When we re-resume the
2509 stepping thread, it may be resumed from that address with a
2510 breakpoint that hasn't trapped yet. Seen with
2511 gdb.threads/non-stop-fair-events.exp, on targets that don't
2512 do displaced stepping. */
2519 /* Most targets can step a breakpoint instruction, thus
2520 executing it normally. But if this one cannot, just
2521 continue and we will hit it anyway. */
2524 }
2530 {
2539 displaced_step_dump_bytes
2541 }
2544 {
2545 /* If we're resuming a thread with the PC out of the step
2546 range, then we're doing some nested/finer run control
2547 operation, like stepping the thread out of the dynamic
2548 linker or the displaced stepping scratch pad. We
2549 shouldn't have allowed a range step then. */
2551 }
2555 }
2557 /* Resume the inferior. SIG is the signal to give the inferior
2558 (GDB_SIGNAL_0 for none). This is a wrapper around 'resume_1' that
2559 rolls back state on error. */
2561 static void
2563 {
2564 try
2565 {
2567 }
2569 {
2570 /* If resuming is being aborted for any reason, delete any
2571 single-step breakpoint resume_1 may have created, to avoid
2572 confusing the following resumption, and to avoid leaving
2573 single-step breakpoints perturbing other threads, in case
2574 we're running in non-stop mode. */
2578 }
2579 }
2581 \f
2582 /* Proceeding. */
2584 /* See infrun.h. */
2586 /* Counter that tracks number of user visible stops. This can be used
2587 to tell whether a command has proceeded the inferior past the
2588 current location. This allows e.g., inferior function calls in
2589 breakpoint commands to not interrupt the command list. When the
2590 call finishes successfully, the inferior is standing at the same
2591 breakpoint as if nothing happened (and so we don't call
2592 normal_stop). */
2595 /* See infrun.h. */
2597 ULONGEST
2599 {
2601 }
2603 /* Called when we report a user visible stop. */
2605 static void
2607 {
2608 current_stop_id++;
2609 }
2611 /* Clear out all variables saying what to do when inferior is continued.
2612 First do this, then set the ones you want, then call `proceed'. */
2614 static void
2616 {
2619 /* If we're starting a new sequence, then the previous finished
2620 single-step is no longer relevant. */
2622 {
2624 {
2631 }
2632 else
2633 {
2634 infrun_debug_printf
2639 }
2640 }
2642 /* If this signal should not be seen by program, give it zero.
2643 Used for debugging signals. */
2666 /* Discard any remaining commands or status from previous stop. */
2668 }
2670 void
2672 {
2673 /* With scheduler-locking replay, stop replaying other threads if we're
2674 not replaying the user-visible resume ptid.
2676 This is a convenience feature to not require the user to explicitly
2677 stop replaying the other threads. We're assuming that the user's
2678 intent is to resume tracing the recorded process. */
2682 execution_direction))
2686 {
2688 process_stratum_target *resume_target
2691 /* In all-stop mode, delete the per-thread status of all threads
2692 we're about to resume, implicitly and explicitly. */
2695 }
2698 {
2702 {
2703 /* If in non-stop mode, only delete the per-thread status of
2704 the current thread. */
2706 }
2710 }
2713 }
2715 /* Returns true if TP is still stopped at a breakpoint that needs
2716 stepping-over in order to make progress. If the breakpoint is gone
2717 meanwhile, we can skip the whole step-over dance. */
2719 static bool
2721 {
2723 {
2732 }
2735 }
2737 /* Check whether thread TP still needs to start a step-over in order
2738 to make progress when resumed. Returns an bitwise or of enum
2739 step_over_what bits, indicating what needs to be stepped over. */
2741 static step_over_what
2743 {
2754 }
2756 /* Returns true if scheduler locking applies. STEP indicates whether
2757 we're about to do a step/next-like command to a thread. */
2759 static bool
2761 {
2767 execution_direction)));
2768 }
2770 /* Set process_stratum_target::COMMIT_RESUMED_STATE in all target
2771 stacks that have threads executing and don't have threads with
2772 pending events. */
2774 static void
2776 {
2777 scoped_restore_current_thread restore_thread;
2780 {
2784 {
2785 /* We already set this in a previous iteration, via another
2786 inferior sharing the process_stratum target. */
2788 }
2790 /* If the target has no resumed threads, it would be useless to
2791 ask it to commit the resumed threads. */
2793 {
2798 }
2800 /* As an optimization, if a thread from this target has some
2801 status to report, handle it before requiring the target to
2802 commit its resumed threads: handling the status might lead to
2803 resuming more threads. */
2807 {
2810 }
2813 {
2818 }
2823 {
2828 }
2834 }
2835 }
2837 /* See infrun.h. */
2839 void
2841 {
2842 scoped_restore_current_thread restore_thread;
2845 {
2857 }
2858 }
2860 /* To track nesting of scoped_disable_commit_resumed objects, ensuring
2861 that only the outermost one attempts to re-enable
2862 commit-resumed. */
2865 /* See infrun.h. */
2871 {
2877 {
2881 {
2882 /* This is the outermost instance: force all
2883 COMMIT_RESUMED_STATE to false. */
2885 }
2886 else
2887 {
2888 /* This is not the outermost instance, we expect
2889 COMMIT_RESUMED_STATE to have been cleared by the
2890 outermost instance. */
2892 }
2893 }
2894 }
2896 /* See infrun.h. */
2898 void
2900 {
2912 {
2913 /* This is the outermost instance, re-enable
2914 COMMIT_RESUMED_STATE on the targets where it's possible. */
2916 }
2917 else
2918 {
2919 /* This is not the outermost instance, we expect
2920 COMMIT_RESUMED_STATE to still be false. */
2922 {
2925 }
2926 }
2927 }
2929 /* See infrun.h. */
2932 {
2934 }
2936 /* See infrun.h. */
2938 void
2940 {
2943 }
2945 /* See infrun.h. */
2951 {
2955 {
2958 /* Re-enable COMMIT_RESUMED_STATE on the targets where it's
2959 possible. */
2963 }
2964 }
2966 /* See infrun.h. */
2969 {
2977 {
2978 /* Force all COMMIT_RESUMED_STATE back to false. */
2980 {
2983 }
2984 }
2985 }
2987 /* Check that all the targets we're about to resume are in non-stop
2988 mode. Ideally, we'd only care whether all targets support
2989 target-async, but we're not there yet. E.g., stop_all_threads
2990 doesn't know how to handle all-stop targets. Also, the remote
2991 protocol in all-stop mode is synchronous, irrespective of
2992 target-async, which means that things like a breakpoint re-set
2993 triggered by one target would try to read memory from all targets
2994 and fail. */
2996 static void
2998 {
3000 {
3001 scoped_restore_current_thread restore_thread;
3003 /* This is used to track whether we're resuming more than one
3004 target. */
3007 /* The first inferior we see with a target that does not work in
3008 always-non-stop mode. */
3012 {
3018 process_stratum_target *proc_target
3028 {
3037 }
3038 }
3039 }
3040 }
3042 /* Basic routine for continuing the program in various fashions.
3044 ADDR is the address to resume at, or -1 for resume where stopped.
3045 SIGGNAL is the signal to give it, or GDB_SIGNAL_0 for none,
3046 or GDB_SIGNAL_DEFAULT for act according to how it stopped.
3048 You should call clear_proceed_status before calling proceed. */
3050 void
3052 {
3053 INFRUN_SCOPED_DEBUG_ENTER_EXIT;
3057 CORE_ADDR pc;
3062 /* If we're stopped at a fork/vfork, follow the branch set by the
3063 "set follow-fork-mode" command; otherwise, we'll just proceed
3064 resuming the current thread. */
3066 {
3067 /* The target for some reason decided not to resume. */
3072 }
3074 /* We'll update this if & when we switch to a new thread. */
3085 /* Fill in with reasonable starting values. */
3090 ptid_t resume_ptid
3092 process_stratum_target *resume_target
3098 {
3102 /* There is a breakpoint at the address we will resume at,
3103 step one instruction before inserting breakpoints so that
3104 we do not stop right away (and report a second hit at this
3105 breakpoint).
3107 Note, we don't do this in reverse, because we won't
3108 actually be executing the breakpoint insn anyway.
3109 We'll be (un-)executing the previous instruction. */
3114 /* We stepped onto an instruction that needs to be stepped
3115 again before re-inserting the breakpoint, do so. */
3117 }
3118 else
3119 {
3121 }
3126 /* If an exception is thrown from this point on, make sure to
3127 propagate GDB's knowledge of the executing state to the
3128 frontend/user running state. */
3131 /* Even if RESUME_PTID is a wildcard, and we end up resuming fewer
3132 threads (e.g., we might need to set threads stepping over
3133 breakpoints first), from the user/frontend's point of view, all
3134 threads in RESUME_PTID are now running. Unless we're calling an
3135 inferior function, as in that case we pretend the inferior
3136 doesn't run at all. */
3145 /* Make sure that output from GDB appears before output from the
3146 inferior. */
3149 /* Since we've marked the inferior running, give it the terminal. A
3150 QUIT/Ctrl-C from here on is forwarded to the target (which can
3151 still detect attempts to unblock a stuck connection with repeated
3152 Ctrl-C from within target_pass_ctrlc). */
3155 /* In a multi-threaded task we may select another thread and
3156 then continue or step.
3158 But if a thread that we're resuming had stopped at a breakpoint,
3159 it will immediately cause another breakpoint stop without any
3160 execution (i.e. it will report a breakpoint hit incorrectly). So
3161 we must step over it first.
3163 Look for threads other than the current (TP) that reported a
3164 breakpoint hit and haven't been resumed yet since. */
3166 /* If scheduler locking applies, we can avoid iterating over all
3167 threads. */
3169 {
3171 resume_ptid))
3172 {
3175 /* Ignore the current thread here. It's handled
3176 afterwards. */
3189 }
3192 }
3194 /* Enqueue the current thread last, so that we move all other
3195 threads over their breakpoints first. */
3199 /* If the thread isn't started, we'll still need to set its prev_pc,
3200 so that switch_back_to_stepped_thread knows the thread hasn't
3201 advanced. Must do this before resuming any thread, as in
3202 all-stop/remote, once we resume we can't send any other packet
3203 until the target stops again. */
3206 {
3212 {
3213 /* Either this thread started a new in-line step over, or some
3214 other thread was already doing one. In either case, don't
3215 resume anything else until the step-over is finished. */
3216 }
3218 {
3219 /* A new displaced stepping sequence was started. In all-stop,
3220 we can't talk to the target anymore until it next stops. */
3221 }
3223 {
3224 INFRUN_SCOPED_DEBUG_START_END
3227 /* In all-stop, but the target is always in non-stop mode.
3228 Start all other threads that are implicitly resumed too. */
3230 resume_ptid))
3231 {
3235 {
3239 }
3242 {
3247 }
3250 {
3254 }
3264 }
3265 }
3267 {
3268 /* The thread wasn't started, and isn't queued, run it now. */
3274 }
3277 }
3281 /* If we've switched threads above, switch back to the previously
3282 current thread. We don't want the user to see a different
3283 selected thread. */
3286 /* Tell the event loop to wait for it to stop. If the target
3287 supports asynchronous execution, it'll do this from within
3288 target_resume. */
3291 }
3292 \f
3294 /* Start remote-debugging of a machine over a serial link. */
3296 void
3298 {
3302 /* Always go on waiting for the target, regardless of the mode. */
3303 /* FIXME: cagney/1999-09-23: At present it isn't possible to
3304 indicate to wait_for_inferior that a target should timeout if
3305 nothing is returned (instead of just blocking). Because of this,
3306 targets expecting an immediate response need to, internally, set
3307 things up so that the target_wait() is forced to eventually
3308 timeout. */
3309 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to
3310 differentiate to its caller what the state of the target is after
3311 the initial open has been performed. Here we're assuming that
3312 the target has stopped. It should be possible to eventually have
3313 target_open() return to the caller an indication that the target
3314 is currently running and GDB state should be set to the same as
3315 for an async run. */
3318 /* Now that the inferior has stopped, do any bookkeeping like
3319 loading shared libraries. We want to do this before normal_stop,
3320 so that the displayed frame is up to date. */
3324 }
3326 /* Initialize static vars when a new inferior begins. */
3328 void
3330 {
3331 /* These are meaningless until the first time through wait_for_inferior. */
3340 }
3342 \f
3360 /* This function is attached as a "thread_stop_requested" observer.
3361 Cleanup local state that assumed the PTID was to be resumed, and
3362 report the stop to the frontend. */
3364 static void
3366 {
3369 /* PTID was requested to stop. If the thread was already stopped,
3370 but the user/frontend doesn't know about that yet (e.g., the
3371 thread had been temporarily paused for some step-over), set up
3372 for reporting the stop now. */
3374 {
3380 /* Remove matching threads from the step-over queue, so
3381 start_step_over doesn't try to resume them
3382 automatically. */
3386 /* If the thread is stopped, but the user/frontend doesn't
3387 know about that yet, queue a pending event, as if the
3388 thread had just stopped now. Unless the thread already had
3389 a pending event. */
3391 {
3395 }
3397 /* Clear the inline-frame state, since we're re-processing the
3398 stop. */
3401 /* If this thread was paused because some other thread was
3402 doing an inline-step over, let that finish first. Once
3403 that happens, we'll restart all threads and consume pending
3404 stop events then. */
3408 /* Otherwise we can process the (new) pending event now. Set
3409 it so this pending event is considered by
3410 do_target_wait. */
3412 }
3413 }
3415 static void
3417 {
3421 }
3423 /* Delete the step resume, single-step and longjmp/exception resume
3424 breakpoints of TP. */
3426 static void
3428 {
3432 }
3434 /* If the target still has execution, call FUNC for each thread that
3435 just stopped. In all-stop, that's all the non-exited threads; in
3436 non-stop, that's the current thread, only. */
3441 static void
3443 {
3448 {
3449 /* If in non-stop mode, only the current thread stopped. */
3451 }
3452 else
3453 {
3454 /* In all-stop mode, all threads have stopped. */
3457 }
3458 }
3460 /* Delete the step resume and longjmp/exception resume breakpoints of
3461 the threads that just stopped. */
3463 static void
3465 {
3467 }
3469 /* Delete the single-step breakpoints of the threads that just
3470 stopped. */
3472 static void
3474 {
3476 }
3478 /* See infrun.h. */
3480 void
3483 {
3495 }
3497 /* Select a thread at random, out of those which are resumed and have
3498 had events. */
3502 {
3506 {
3510 };
3512 /* First see how many events we have. Count only resumed threads
3513 that have an event pending. */
3516 num_events++;
3521 /* Now randomly pick a thread out of those that have had events. */
3529 /* Select the Nth thread that has had an event. */
3536 }
3538 /* Wrapper for target_wait that first checks whether threads have
3539 pending statuses to report before actually asking the target for
3540 more events. INF is the inferior we're using to call target_wait
3541 on. */
3543 static ptid_t
3546 {
3547 ptid_t event_ptid;
3550 /* We know that we are looking for an event in the target of inferior
3551 INF, but we don't know which thread the event might come from. As
3552 such we want to make sure that INFERIOR_PTID is reset so that none of
3553 the wait code relies on it - doing so is always a mistake. */
3556 /* First check if there is a resumed thread with a wait status
3557 pending. */
3559 {
3561 }
3562 else
3563 {
3567 /* We have a specific thread to check. */
3572 }
3577 {
3580 CORE_ADDR pc;
3586 {
3592 }
3594 {
3600 }
3603 {
3609 }
3610 }
3613 {
3615 target_waitstatus_to_string
3619 /* Now that we've selected our final event LWP, un-adjust its PC
3620 if it was a software breakpoint (and the target doesn't
3621 always adjust the PC itself). */
3624 {
3634 {
3635 CORE_ADDR pc;
3639 }
3640 }
3646 /* Wake up the event loop again, until all pending events are
3647 processed. */
3651 }
3653 /* But if we don't find one, we'll have to wait. */
3655 /* We can't ask a non-async target to do a non-blocking wait, so this will be
3656 a blocking wait. */
3662 else
3666 }
3668 /* Wrapper for target_wait that first checks whether threads have
3669 pending statuses to report before actually asking the target for
3670 more events. Polls for events from all inferiors/targets. */
3672 static bool
3674 {
3678 /* For fairness, we pick the first inferior/target to poll at random
3679 out of all inferiors that may report events, and then continue
3680 polling the rest of the inferior list starting from that one in a
3681 circular fashion until the whole list is polled once. */
3684 {
3686 };
3688 /* First see how many matching inferiors we have. */
3691 num_inferiors++;
3694 {
3697 }
3699 /* Now randomly pick an inferior out of those that matched. */
3707 /* Select the Nth inferior that matched. */
3714 {
3717 }
3719 /* Now poll for events out of each of the matching inferior's
3720 targets, starting from the selected one. */
3723 {
3727 };
3729 /* Needed in 'all-stop + target-non-stop' mode, because we end up
3730 here spuriously after the target is all stopped and we've already
3731 reported the stop to the user, polling for events. */
3732 scoped_restore_current_thread restore_thread;
3749 }
3751 /* An event reported by wait_one. */
3753 struct wait_one_event
3754 {
3755 /* The target the event came out of. */
3758 /* The PTID the event was for. */
3759 ptid_t ptid;
3761 /* The waitstatus. */
3762 target_waitstatus ws;
3763 };
3768 /* Prepare and stabilize the inferior for detaching it. E.g.,
3769 detaching while a thread is displaced stepping is a recipe for
3770 crashing it, as nothing would readjust the PC out of the scratch
3771 pad. */
3773 void
3775 {
3778 scoped_restore_current_thread restore_thread;
3782 /* Remove all threads of INF from the global step-over chain. We
3783 want to stop any ongoing step-over, not start any new one. */
3788 {
3792 }
3794 /* If we were already in the middle of an inline step-over, and the
3795 thread stepping belongs to the inferior we're detaching, we need
3796 to restart the threads of other inferiors. */
3798 {
3803 {
3804 /* Since we removed threads of INF from the step-over chain,
3805 we know this won't start a step-over for INF. */
3809 {
3810 /* Start a new step-over in another thread if there's
3811 one that needs it. */
3814 /* Restart all other threads (except the
3815 previously-stepping thread, since that one is still
3816 running). */
3819 }
3820 }
3821 }
3824 {
3827 /* Stop threads currently displaced stepping, aborting it. */
3830 {
3832 {
3834 {
3836 {
3839 }
3840 }
3841 else
3843 }
3844 }
3847 {
3848 wait_one_event event;
3857 }
3859 /* It's OK to leave some of the threads of INF stopped, since
3860 they'll be detached shortly. */
3861 }
3862 }
3864 /* Wait for control to return from inferior to debugger.
3866 If inferior gets a signal, we may decide to start it up again
3867 instead of returning. That is why there is a loop in this function.
3868 When this function actually returns it means the inferior
3869 should be left stopped and GDB should read more commands. */
3871 static void
3873 {
3878 /* If an error happens while handling the event, propagate GDB's
3879 knowledge of the executing state to the frontend/user running
3880 state. */
3881 scoped_finish_thread_state finish_state
3885 {
3893 /* Flush target cache before starting to handle each event.
3894 Target was running and cache could be stale. This is just a
3895 heuristic. Running threads may modify target memory, but we
3896 don't get any event. */
3905 /* Now figure out what to do with the result of the result. */
3910 }
3912 /* No error, don't finish the state yet. */
3914 }
3916 /* Cleanup that reinstalls the readline callback handler, if the
3917 target is running in the background. If while handling the target
3918 event something triggered a secondary prompt, like e.g., a
3919 pagination prompt, we'll have removed the callback handler (see
3920 gdb_readline_wrapper_line). Need to do this as we go back to the
3921 event loop, ready to process further input. Note this has no
3922 effect if the handler hasn't actually been removed, because calling
3923 rl_callback_handler_install resets the line buffer, thus losing
3924 input. */
3926 static void
3928 {
3932 {
3933 /* We're not going back to the top level event loop yet. Don't
3934 install the readline callback, as it'd prep the terminal,
3935 readline-style (raw, noecho) (e.g., --batch). We'll install
3936 it the next time the prompt is displayed, when we're ready
3937 for input. */
3939 }
3943 }
3945 /* Clean up the FSMs of threads that are now stopped. In non-stop,
3946 that's just the event thread. In all-stop, that's all threads. */
3948 static void
3950 {
3956 {
3958 {
3966 }
3970 }
3971 }
3973 /* Helper for all_uis_check_sync_execution_done that works on the
3974 current UI. */
3976 static void
3978 {
3984 {
3988 }
3989 }
3991 /* See infrun.h. */
3993 void
3995 {
3997 {
3999 }
4000 }
4002 /* See infrun.h. */
4004 void
4006 {
4008 {
4011 }
4012 }
4014 /* Asynchronous version of wait_for_inferior. It is called by the
4015 event loop whenever a change of state is detected on the file
4016 descriptor corresponding to the target. It can be called more than
4017 once to complete a single execution command. In such cases we need
4018 to keep the state in a global variable ECSS. If it is the last time
4019 that this function is called for a single execution command, then
4020 report to the user that the inferior has stopped, and do the
4021 necessary cleanups. */
4023 void
4025 {
4026 INFRUN_SCOPED_DEBUG_ENTER_EXIT;
4034 /* Events are always processed with the main UI as current UI. This
4035 way, warnings, debug output, etc. are always consistently sent to
4036 the main console. */
4039 /* Temporarily disable pagination. Otherwise, the user would be
4040 given an option to press 'q' to quit, which would cause an early
4041 exit and could leave GDB in a half-baked state. */
4042 scoped_restore save_pagination
4045 /* End up with readline processing input, if necessary. */
4046 {
4049 /* We're handling a live event, so make sure we're doing live
4050 debugging. If we're looking at traceframes while the target is
4051 running, we're going to need to get back to that mode after
4052 handling the event. */
4055 {
4058 }
4060 /* The user/frontend should not notice a thread switch due to
4061 internal events. Make sure we revert to the user selected
4062 thread and frame after handling the event and running any
4063 breakpoint commands. */
4064 scoped_restore_current_thread restore_thread;
4067 /* Flush target cache before starting to handle each event. Target
4068 was running and cache could be stale. This is just a heuristic.
4069 Running threads may modify target memory, but we don't get any
4070 event. */
4073 scoped_restore save_exec_dir
4077 /* Allow targets to pause their resumed threads while we handle
4078 the event. */
4082 {
4086 }
4090 /* Switch to the target that generated the event, so we can do
4091 target calls. */
4097 /* If an error happens while handling the event, propagate GDB's
4098 knowledge of the executing state to the frontend/user running
4099 state. */
4103 /* Get executed before scoped_restore_current_thread above to apply
4104 still for the thread which has thrown the exception. */
4105 auto defer_bpstat_clear
4107 auto defer_delete_threads
4110 /* Now figure out what to do with the result of the result. */
4114 {
4122 {
4127 }
4130 {
4132 }
4133 else
4134 {
4144 {
4145 /* We may not find an inferior if this was a process exit. */
4148 }
4151 {
4154 }
4156 /* If we got a TARGET_WAITKIND_NO_RESUMED event, then the
4157 previously selected thread is gone. We have two
4158 choices - switch to no thread selected, or restore the
4159 previously selected thread (now exited). We chose the
4160 later, just because that's what GDB used to do. After
4161 this, "info threads" says "The current thread <Thread
4162 ID 2> has terminated." instead of "No thread
4163 selected.". */
4165 && cmd_done
4168 }
4169 }
4174 /* No error, don't finish the thread states yet. */
4179 /* This scope is used to ensure that readline callbacks are
4180 reinstalled here. */
4181 }
4183 /* If a UI was in sync execution mode, and now isn't, restore its
4184 prompt (a synchronous execution command has finished, and we're
4185 ready for input). */
4189 && exec_done_display_p
4193 }
4195 /* See infrun.h. */
4197 void
4200 {
4201 /* This can be removed once this function no longer implicitly relies on the
4202 inferior_ptid value. */
4210 }
4212 /* Clear context switchable stepping state. */
4214 void
4216 {
4221 }
4223 /* See infrun.h. */
4225 void
4227 target_waitstatus status)
4228 {
4232 }
4234 /* See infrun.h. */
4236 void
4239 {
4246 }
4248 /* See infrun.h. */
4250 void
4252 {
4255 target_last_waitstatus = {};
4256 }
4258 /* Switch thread contexts. */
4260 static void
4262 {
4266 {
4270 }
4273 }
4275 /* If the target can't tell whether we've hit breakpoints
4276 (target_supports_stopped_by_sw_breakpoint), and we got a SIGTRAP,
4277 check whether that could have been caused by a breakpoint. If so,
4278 adjust the PC, per gdbarch_decr_pc_after_break. */
4280 static void
4283 {
4288 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If
4289 we aren't, just return.
4291 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not
4292 affected by gdbarch_decr_pc_after_break. Other waitkinds which are
4293 implemented by software breakpoints should be handled through the normal
4294 breakpoint layer.
4296 NOTE drow/2004-01-31: On some targets, breakpoints may generate
4297 different signals (SIGILL or SIGEMT for instance), but it is less
4298 clear where the PC is pointing afterwards. It may not match
4299 gdbarch_decr_pc_after_break. I don't know any specific target that
4300 generates these signals at breakpoints (the code has been in GDB since at
4301 least 1992) so I can not guess how to handle them here.
4303 In earlier versions of GDB, a target with
4304 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a
4305 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any
4306 target with both of these set in GDB history, and it seems unlikely to be
4307 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
4315 /* In reverse execution, when a breakpoint is hit, the instruction
4316 under it has already been de-executed. The reported PC always
4317 points at the breakpoint address, so adjusting it further would
4318 be wrong. E.g., consider this case on a decr_pc_after_break == 1
4319 architecture:
4321 B1 0x08000000 : INSN1
4322 B2 0x08000001 : INSN2
4323 0x08000002 : INSN3
4324 PC -> 0x08000003 : INSN4
4326 Say you're stopped at 0x08000003 as above. Reverse continuing
4327 from that point should hit B2 as below. Reading the PC when the
4328 SIGTRAP is reported should read 0x08000001 and INSN2 should have
4329 been de-executed already.
4331 B1 0x08000000 : INSN1
4332 B2 PC -> 0x08000001 : INSN2
4333 0x08000002 : INSN3
4334 0x08000003 : INSN4
4336 We can't apply the same logic as for forward execution, because
4337 we would wrongly adjust the PC to 0x08000000, since there's a
4338 breakpoint at PC - 1. We'd then report a hit on B1, although
4339 INSN1 hadn't been de-executed yet. Doing nothing is the correct
4340 behaviour. */
4344 /* If the target can tell whether the thread hit a SW breakpoint,
4345 trust it. Targets that can tell also adjust the PC
4346 themselves. */
4350 /* Note that relying on whether a breakpoint is planted in memory to
4351 determine this can fail. E.g,. the breakpoint could have been
4352 removed since. Or the thread could have been told to step an
4353 instruction the size of a breakpoint instruction, and only
4354 _after_ was a breakpoint inserted at its address. */
4356 /* If this target does not decrement the PC after breakpoints, then
4357 we have nothing to do. */
4367 /* Find the location where (if we've hit a breakpoint) the
4368 breakpoint would be. */
4371 /* If the target can't tell whether a software breakpoint triggered,
4372 fallback to figuring it out based on breakpoints we think were
4373 inserted in the target, and on whether the thread was stepped or
4374 continued. */
4376 /* Check whether there actually is a software breakpoint inserted at
4377 that location.
4379 If in non-stop mode, a race condition is possible where we've
4380 removed a breakpoint, but stop events for that breakpoint were
4381 already queued and arrive later. To suppress those spurious
4382 SIGTRAPs, we keep a list of such breakpoint locations for a bit,
4383 and retire them after a number of stop events are reported. Note
4384 this is an heuristic and can thus get confused. The real fix is
4385 to get the "stopped by SW BP and needs adjustment" info out of
4386 the target/kernel (and thus never reach here; see above). */
4390 {
4394 restore_operation_disable.emplace
4397 /* When using hardware single-step, a SIGTRAP is reported for both
4398 a completed single-step and a software breakpoint. Need to
4399 differentiate between the two, as the latter needs adjusting
4400 but the former does not.
4402 The SIGTRAP can be due to a completed hardware single-step only if
4403 - we didn't insert software single-step breakpoints
4404 - this thread is currently being stepped
4406 If any of these events did not occur, we must have stopped due
4407 to hitting a software breakpoint, and have to back up to the
4408 breakpoint address.
4410 As a special case, we could have hardware single-stepped a
4411 software breakpoint. In this case (prev_pc == breakpoint_pc),
4412 we also need to back up to the breakpoint address. */
4419 }
4420 }
4422 static bool
4424 {
4428 {
4434 }
4437 }
4439 /* Look for an inline frame that is marked for skip.
4440 If PREV_FRAME is TRUE start at the previous frame,
4441 otherwise start at the current frame. Stop at the
4442 first non-inline frame, or at the frame where the
4443 step started. */
4445 static bool
4447 {
4454 {
4456 symtab_and_line sal;
4473 }
4476 }
4478 /* If the event thread has the stop requested flag set, pretend it
4479 stopped for a GDB_SIGNAL_0 (i.e., as if it stopped due to
4480 target_stop). */
4482 static bool
4484 {
4486 {
4491 }
4493 }
4495 /* Auxiliary function that handles syscall entry/return events.
4496 It returns true if the inferior should keep going (and GDB
4497 should ignore the event), or false if the event deserves to be
4498 processed. */
4500 static bool
4502 {
4514 {
4526 {
4527 /* Catchpoint hit. */
4529 }
4530 }
4535 /* If no catchpoint triggered for this, then keep going. */
4539 }
4541 /* Lazily fill in the execution_control_state's stop_func_* fields. */
4543 static void
4546 {
4548 {
4552 /* Don't care about return value; stop_func_start and stop_func_name
4553 will both be 0 if it doesn't work. */
4561 /* The call to find_pc_partial_function, above, will set
4562 stop_func_start and stop_func_end to the start and end
4563 of the range containing the stop pc. If this range
4564 contains the entry pc for the block (which is always the
4565 case for contiguous blocks), advance stop_func_start past
4566 the function's start offset and entrypoint. Note that
4567 stop_func_start is NOT advanced when in a range of a
4568 non-contiguous block that does not contain the entry pc. */
4572 {
4573 ecs->stop_func_start
4577 ecs->stop_func_start
4579 }
4582 }
4583 }
4586 /* Return the STOP_SOON field of the inferior pointed at by ECS. */
4588 static enum stop_kind
4590 {
4595 }
4597 /* Poll for one event out of the current target. Store the resulting
4598 waitstatus in WS, and return the event ptid. Does not block. */
4600 static ptid_t
4602 {
4603 ptid_t event_ptid;
4607 /* Flush target cache before starting to handle each event.
4608 Target was running and cache could be stale. This is just a
4609 heuristic. Running threads may modify target memory, but we
4610 don't get any event. */
4615 else
4622 }
4624 /* Wait for one event out of any target. */
4626 static wait_one_event
4628 {
4630 {
4632 {
4641 wait_one_event event;
4646 {
4647 /* If nothing is resumed, remove the target from the
4648 event loop. */
4650 }
4653 }
4655 /* Block waiting for some event. */
4657 fd_set readfds;
4663 {
4674 }
4677 {
4678 /* No waitable targets left. All must be stopped. */
4680 }
4682 QUIT;
4686 {
4689 else
4691 }
4692 }
4693 }
4695 /* Save the thread's event and stop reason to process it later. */
4697 static void
4699 {
4706 /* Record for later. */
4712 {
4719 scoped_restore_current_thread restore_thread;
4723 {
4726 }
4729 {
4732 }
4735 {
4738 }
4741 pc))
4742 {
4745 }
4748 pc))
4749 {
4752 }
4755 {
4758 }
4759 }
4760 }
4762 /* Mark the non-executing threads accordingly. In all-stop, all
4763 threads of all processes are stopped when we get any event
4764 reported. In non-stop mode, only the event thread stops. */
4766 static void
4768 ptid_t event_ptid,
4770 {
4771 ptid_t mark_ptid;
4777 {
4778 /* If we're handling a process exit in non-stop mode, even
4779 though threads haven't been deleted yet, one would think
4780 that there is nothing to do, as threads of the dead process
4781 will be soon deleted, and threads of any other process were
4782 left running. However, on some targets, threads survive a
4783 process exit event. E.g., for the "checkpoint" command,
4784 when the current checkpoint/fork exits, linux-fork.c
4785 automatically switches to another fork from within
4786 target_mourn_inferior, by associating the same
4787 inferior/thread to another fork. We haven't mourned yet at
4788 this point, but we must mark any threads left in the
4789 process as not-executing so that finish_thread_state marks
4790 them stopped (in the user's perspective) if/when we present
4791 the stop to the user. */
4793 }
4794 else
4799 /* Likewise the resumed flag. */
4801 }
4803 /* Handle one event after stopping threads. If the eventing thread
4804 reports back any interesting event, we leave it pending. If the
4805 eventing thread was in the middle of a displaced step, we
4806 cancel/finish it, and unless the thread's inferior is being
4807 detached, put the thread back in the step-over chain. Returns true
4808 if there are no resumed threads left in the target (thus there's no
4809 point in waiting further), false otherwise. */
4811 static bool
4813 {
4814 infrun_debug_printf
4819 {
4820 /* All resumed threads exited. */
4822 }
4826 {
4827 /* One thread/process exited/signalled. */
4831 /* The target may have reported just a pid. If so, try
4832 the first non-exited thread. */
4834 {
4838 {
4841 }
4843 /* If there is no available thread, the event would
4844 have to be appended to a per-inferior event list,
4845 which does not exist (and if it did, we'd have
4846 to adjust run control command to be able to
4847 resume such an inferior). We assert here instead
4848 of going into an infinite loop. */
4851 infrun_debug_printf
4853 }
4854 else
4855 {
4857 /* Check if this is the first time we see this thread.
4858 Don't bother adding if it individually exited. */
4862 }
4865 {
4866 /* Set the threads as non-executing to avoid
4867 another stop attempt on them. */
4873 }
4874 }
4875 else
4876 {
4886 /* This may be the first time we see the inferior report
4887 a stop. */
4890 {
4893 }
4897 {
4898 /* We caught the event that we intended to catch, so
4899 there's no event pending. */
4905 {
4906 /* Add it back to the step-over queue. */
4907 infrun_debug_printf
4914 }
4915 }
4916 else
4917 {
4921 infrun_debug_printf
4926 /* Record for later. */
4934 {
4935 /* Add it back to the step-over queue. */
4939 }
4950 }
4951 }
4954 }
4956 /* See infrun.h. */
4958 void
4960 {
4961 /* We may need multiple passes to discover all threads. */
4969 scoped_restore_current_thread restore_thread;
4971 /* Enable thread events of all targets. */
4973 {
4976 }
4978 SCOPE_EXIT
4979 {
4980 /* Disable thread events of all targets. */
4982 {
4985 }
4987 /* Use debug_prefixed_printf directly to get a meaningful function
4988 name. */
4991 };
4993 /* Request threads to stop, and then wait for the stops. Because
4994 threads we already know about can spawn more threads while we're
4995 trying to stop them, and we only learn about new threads when we
4996 update the thread list, do this in a loop, and keep iterating
4997 until two passes find no threads that need to be stopped. */
4999 {
5002 {
5006 {
5009 }
5011 /* Go through all threads looking for threads that we need
5012 to tell the target to stop. */
5014 {
5015 /* For a single-target setting with an all-stop target,
5016 we would not even arrive here. For a multi-target
5017 setting, until GDB is able to handle a mixture of
5018 all-stop and non-stop targets, simply skip all-stop
5019 targets' threads. This should be fine due to the
5020 protection of 'check_multi_target_resumption'. */
5027 {
5028 /* If already stopping, don't request a stop again.
5029 We just haven't seen the notification yet. */
5031 {
5036 }
5037 else
5038 {
5041 }
5044 waits_needed++;
5045 }
5046 else
5047 {
5051 /* The thread may be not executing, but still be
5052 resumed with a pending status to process. */
5054 }
5055 }
5060 /* If we find new threads on the second iteration, restart
5061 over. We want to see two iterations in a row with all
5062 threads stopped. */
5067 {
5071 }
5072 }
5073 }
5074 }
5076 /* Handle a TARGET_WAITKIND_NO_RESUMED event. */
5078 static bool
5080 {
5082 {
5086 {
5088 {
5091 }
5092 }
5094 {
5095 /* There were no unwaited-for children left in the target, but,
5096 we're not synchronously waiting for events either. Just
5097 ignore. */
5102 }
5103 }
5105 /* Otherwise, if we were running a synchronous execution command, we
5106 may need to cancel it and give the user back the terminal.
5108 In non-stop mode, the target can't tell whether we've already
5109 consumed previous stop events, so it can end up sending us a
5110 no-resumed event like so:
5112 #0 - thread 1 is left stopped
5114 #1 - thread 2 is resumed and hits breakpoint
5115 -> TARGET_WAITKIND_STOPPED
5117 #2 - thread 3 is resumed and exits
5118 this is the last resumed thread, so
5119 -> TARGET_WAITKIND_NO_RESUMED
5121 #3 - gdb processes stop for thread 2 and decides to re-resume
5122 it.
5124 #4 - gdb processes the TARGET_WAITKIND_NO_RESUMED event.
5125 thread 2 is now resumed, so the event should be ignored.
5127 IOW, if the stop for thread 2 doesn't end a foreground command,
5128 then we need to ignore the following TARGET_WAITKIND_NO_RESUMED
5129 event. But it could be that the event meant that thread 2 itself
5130 (or whatever other thread was the last resumed thread) exited.
5132 To address this we refresh the thread list and check whether we
5133 have resumed threads _now_. In the example above, this removes
5134 thread 3 from the thread list. If thread 2 was re-resumed, we
5135 ignore this event. If we find no thread resumed, then we cancel
5136 the synchronous command and show "no unwaited-for " to the
5137 user. */
5141 scoped_restore_current_thread restore_thread;
5144 {
5147 }
5149 /* If:
5151 - the current target has no thread executing, and
5152 - the current inferior is native, and
5153 - the current inferior is the one which has the terminal, and
5154 - we did nothing,
5156 then a Ctrl-C from this point on would remain stuck in the
5157 kernel, until a thread resumes and dequeues it. That would
5158 result in the GDB CLI not reacting to Ctrl-C, not able to
5159 interrupt the program. To address this, if the current inferior
5160 no longer has any thread executing, we give the terminal to some
5161 other inferior that has at least one thread executing. */
5164 /* Whether to ignore this TARGET_WAITKIND_NO_RESUMED event, or
5165 whether to report it to the user. */
5169 {
5171 {
5173 {
5178 }
5180 }
5185 {
5186 /* Either there were no unwaited-for children left in the
5187 target at some point, but there are now, or some target
5188 other than the eventing one has unwaited-for children
5189 left. Just ignore. */
5194 }
5198 }
5201 {
5205 }
5207 /* Go ahead and report the event. */
5209 }
5211 /* Given an execution control state that has been freshly filled in by
5212 an event from the inferior, figure out what it means and take
5213 appropriate action.
5215 The alternatives are:
5217 1) stop_waiting and return; to really stop and return to the
5218 debugger.
5220 2) keep_going and return; to wait for the next event (set
5221 ecs->event_thread->stepping_over_breakpoint to 1 to single step
5222 once). */
5224 static void
5226 {
5227 /* Make sure that all temporary struct value objects that were
5228 created during the handling of the event get deleted at the
5229 end. */
5230 scoped_value_mark free_values;
5235 {
5236 /* We had an event in the inferior, but we are not interested in
5237 handling it at this level. The lower layers have already
5238 done what needs to be done, if anything.
5240 One of the possible circumstances for this is when the
5241 inferior produces output for the console. The inferior has
5242 not stopped, and we are ignoring the event. Another possible
5243 circumstance is any event which the lower level knows will be
5244 reported multiple times without an intervening resume. */
5247 }
5250 {
5253 }
5259 /* Cache the last target/ptid/waitstatus. */
5262 /* Always clear state belonging to the previous time we stopped. */
5266 {
5267 /* No unwaited-for children left. IOW, all resumed children
5268 have exited. */
5272 }
5276 {
5278 /* If it's a new thread, add it to the thread database. */
5282 /* Disable range stepping. If the next step request could use a
5283 range, this will be end up re-enabled then. */
5285 }
5287 /* Dependent on valid ECS->EVENT_THREAD. */
5290 /* Dependent on the current PC value modified by adjust_pc_after_break. */
5295 /* First, distinguish signals caused by the debugger from signals
5296 that have to do with the program's own actions. Note that
5297 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending
5298 on the operating system version. Here we detect when a SIGILL or
5299 SIGEMT is really a breakpoint and change it to SIGTRAP. We do
5300 something similar for SIGSEGV, since a SIGSEGV will be generated
5301 when we're trying to execute a breakpoint instruction on a
5302 non-executable stack. This happens for call dummy breakpoints
5303 for architectures like SPARC that place call dummies on the
5304 stack. */
5309 {
5314 {
5317 }
5318 }
5323 {
5325 {
5327 /* Ignore gracefully during startup of the inferior, as it might
5328 be the shell which has just loaded some objects, otherwise
5329 add the symbols for the newly loaded objects. Also ignore at
5330 the beginning of an attach or remote session; we will query
5331 the full list of libraries once the connection is
5332 established. */
5336 {
5352 {
5353 /* A catchpoint triggered. */
5356 }
5358 /* If requested, stop when the dynamic linker notifies
5359 gdb of events. This allows the user to get control
5360 and place breakpoints in initializer routines for
5361 dynamically loaded objects (among other things). */
5364 {
5365 /* Make sure we print "Stopped due to solib-event" in
5366 normal_stop. */
5371 }
5372 }
5374 /* If we are skipping through a shell, or through shared library
5375 loading that we aren't interested in, resume the program. If
5376 we're running the program normally, also resume. */
5378 {
5379 /* Loading of shared libraries might have changed breakpoint
5380 addresses. Make sure new breakpoints are inserted. */
5386 }
5388 /* But stop if we're attaching or setting up a remote
5389 connection. */
5392 {
5396 }
5400 }
5420 {
5421 /* Depending on the system, ecs->ptid may point to a thread or
5422 to a process. On some targets, target_mourn_inferior may
5423 need to have access to the just-exited thread. That is the
5424 case of GNU/Linux's "checkpoint" support, for example.
5425 Call the switch_to_xxx routine as appropriate. */
5429 else
5430 {
5433 }
5434 }
5438 /* Clearing any previous state of convenience variables. */
5442 {
5443 /* Record the exit code in the convenience variable $_exitcode, so
5444 that the user can inspect this again later. */
5448 /* Also record this in the inferior itself. */
5452 /* Support the --return-child-result option. */
5456 }
5457 else
5458 {
5462 {
5463 /* Set the value of the internal variable $_exitsignal,
5464 which holds the signal uncaught by the inferior. */
5468 }
5469 else
5470 {
5471 /* We don't have access to the target's method used for
5472 converting between signal numbers (GDB's internal
5473 representation <-> target's representation).
5474 Therefore, we cannot do a good job at displaying this
5475 information to the user. It's better to just warn
5476 her about it (if infrun debugging is enabled), and
5477 give up. */
5480 }
5483 }
5493 /* Check whether the inferior is displaced stepping. */
5494 {
5499 /* If this is a fork (child gets its own address space copy)
5500 and some displaced step buffers were in use at the time of
5501 the fork, restore the displaced step buffer bytes in the
5502 child process.
5504 Architectures which support displaced stepping and fork
5505 events must supply an implementation of
5506 gdbarch_displaced_step_restore_all_in_ptid. This is not
5507 enforced during gdbarch validation to support architectures
5508 which support displaced stepping but not forks. */
5511 gdbarch_displaced_step_restore_all_in_ptid
5514 /* If displaced stepping is supported, and thread ecs->ptid is
5515 displaced stepping. */
5517 {
5519 CORE_ADDR parent_pc;
5521 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED,
5522 indicating that the displaced stepping of syscall instruction
5523 has been done. Perform cleanup for parent process here. Note
5524 that this operation also cleans up the child process for vfork,
5525 because their pages are shared. */
5527 /* Start a new step-over in another thread if there's one
5528 that needs it. */
5531 /* Since the vfork/fork syscall instruction was executed in the scratchpad,
5532 the child's PC is also within the scratchpad. Set the child's PC
5533 to the parent's PC value, which has already been fixed up.
5534 FIXME: we use the parent's aspace here, although we're touching
5535 the child, because the child hasn't been added to the inferior
5536 list yet at this point. */
5538 child_regcache
5541 gdbarch,
5543 /* Read PC value of parent process. */
5552 }
5553 }
5557 /* Immediately detach breakpoints from the child before there's
5558 any chance of letting the user delete breakpoints from the
5559 breakpoint lists. If we don't do this early, it's easy to
5560 leave left over traps in the child, vis: "break foo; catch
5561 fork; c; <fork>; del; c; <child calls foo>". We only follow
5562 the fork on the last `continue', and by that time the
5563 breakpoint at "foo" is long gone from the breakpoint table.
5564 If we vforked, then we don't need to unpatch here, since both
5565 parent and child are sharing the same memory pages; we'll
5566 need to unpatch at follow/detach time instead to be certain
5567 that new breakpoints added between catchpoint hit time and
5568 vfork follow are detached. */
5570 {
5571 /* This won't actually modify the breakpoint list, but will
5572 physically remove the breakpoints from the child. */
5574 }
5578 /* In case the event is caught by a catchpoint, remember that
5579 the event is to be followed at the next resume of the thread,
5580 and not immediately. */
5594 /* If no catchpoint triggered for this, then keep going. Note
5595 that we're interested in knowing the bpstat actually causes a
5596 stop, not just if it may explain the signal. Software
5597 watchpoints, for example, always appear in the bpstat. */
5599 {
5600 bool follow_child
5605 process_stratum_target *targ
5610 /* Note that one of these may be an invalid pointer,
5611 depending on detach_fork. */
5613 thread_info *child
5616 /* At this point, the parent is marked running, and the
5617 child is marked stopped. */
5619 /* If not resuming the parent, mark it stopped. */
5623 /* If resuming the child, mark it running. */
5627 /* In non-stop mode, also resume the other branch. */
5630 {
5633 else
5639 }
5643 else
5651 else
5654 }
5659 /* Done with the shared memory region. Re-insert breakpoints in
5660 the parent, and keep going. */
5670 /* This also takes care of reinserting breakpoints in the
5671 previously locked inferior. */
5677 /* Note we can't read registers yet (the stop_pc), because we
5678 don't yet know the inferior's post-exec architecture.
5679 'stop_pc' is explicitly read below instead. */
5682 /* Do whatever is necessary to the parent branch of the vfork. */
5685 /* This causes the eventpoints and symbol table to be reset.
5686 Must do this now, before trying to determine whether to
5687 stop. */
5690 /* In follow_exec we may have deleted the original thread and
5691 created a new one. Make sure that the event thread is the
5692 execd thread for that case (this is a nop otherwise). */
5703 /* Note that this may be referenced from inside
5704 bpstat_stop_status above, through inferior_has_execd. */
5711 /* If no catchpoint triggered for this, then keep going. */
5713 {
5717 }
5721 /* Be careful not to try to gather much state about a thread
5722 that's in a syscall. It's frequently a losing proposition. */
5724 /* Getting the current syscall number. */
5729 /* Before examining the threads further, step this thread to
5730 get it entirely out of the syscall. (We get notice of the
5731 event when the thread is just on the verge of exiting a
5732 syscall. Stepping one instruction seems to get it back
5733 into user code.) */
5744 /* Reverse execution: target ran out of history info. */
5746 /* Switch to the stopped thread. */
5760 }
5761 }
5763 /* Restart threads back to what they were trying to do back when we
5764 paused them for an in-line step-over. The EVENT_THREAD thread is
5765 ignored. */
5767 static void
5769 {
5770 /* In case the instruction just stepped spawned a new thread. */
5774 {
5776 {
5780 }
5785 {
5789 }
5792 {
5796 }
5799 {
5804 }
5807 {
5812 }
5816 {
5821 }
5825 /* If some thread needs to start a step-over at this point, it
5826 should still be in the step-over queue, and thus skipped
5827 above. */
5829 {
5831 "thread [%s] needs a step-over, but not in "
5834 }
5837 {
5841 }
5842 else
5843 {
5852 }
5853 }
5854 }
5856 /* Callback for iterate_over_threads. Find a resumed thread that has
5857 a pending waitstatus. */
5859 static int
5862 {
5865 }
5867 /* Called when we get an event that may finish an in-line or
5868 out-of-line (displaced stepping) step-over started previously.
5869 Return true if the event is processed and we should go back to the
5870 event loop; false if the caller should continue processing the
5871 event. */
5873 static int
5875 {
5882 {
5883 /* If we're stepping over a breakpoint with all threads locked,
5884 then only the thread that was stepped should be reporting
5885 back an event. */
5889 }
5894 /* Start a new step-over in another thread if there's one that
5895 needs it. */
5898 /* If we were stepping over a breakpoint before, and haven't started
5899 a new in-line step-over sequence, then restart all other threads
5900 (except the event thread). We can't do this in all-stop, as then
5901 e.g., we wouldn't be able to issue any other remote packet until
5902 these other threads stop. */
5904 {
5907 /* If we only have threads with pending statuses, the restart
5908 below won't restart any thread and so nothing re-inserts the
5909 breakpoint we just stepped over. But we need it inserted
5910 when we later process the pending events, otherwise if
5911 another thread has a pending event for this breakpoint too,
5912 we'd discard its event (because the breakpoint that
5913 originally caused the event was no longer inserted). */
5919 /* If we have events pending, go through handle_inferior_event
5920 again, picking up a pending event at random. This avoids
5921 thread starvation. */
5923 /* But not if we just stepped over a watchpoint in order to let
5924 the instruction execute so we can evaluate its expression.
5925 The set of watchpoints that triggered is recorded in the
5926 breakpoint objects themselves (see bp->watchpoint_triggered).
5927 If we processed another event first, that other event could
5928 clobber this info. */
5933 NULL);
5935 {
5944 /* Record the event thread's event for later. */
5946 /* This was cleared early, by handle_inferior_event. Set it
5947 so this pending event is considered by
5948 do_target_wait. */
5963 /* This in-line step-over finished; clear this so we won't
5964 start a new one. This is what handle_signal_stop would
5965 do, if we returned false. */
5968 /* Wake up the event loop again. */
5973 }
5974 }
5977 }
5979 /* Come here when the program has stopped with a signal. */
5981 static void
5983 {
5994 /* Do we need to clean up the state of a thread that has
5995 completed a displaced single-step? (Doing so usually affects
5996 the PC, so do it here, before we set stop_pc.) */
6000 /* If we either finished a single-step or hit a breakpoint, but
6001 the user wanted this thread to be stopped, pretend we got a
6002 SIG0 (generic unsignaled stop). */
6016 {
6024 {
6025 CORE_ADDR addr;
6033 else
6035 }
6036 }
6038 /* This is originated from start_remote(), start_inferior() and
6039 shared libraries hook functions. */
6042 {
6047 }
6049 /* This originates from attach_command(). We need to overwrite
6050 the stop_signal here, because some kernels don't ignore a
6051 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call.
6052 See more comments in inferior.h. On the other hand, if we
6053 get a non-SIGSTOP, report it to the user - assume the backend
6054 will handle the SIGSTOP if it should show up later.
6056 Also consider that the attach is complete when we see a
6057 SIGTRAP. Some systems (e.g. Windows), and stubs supporting
6058 target extended-remote report it instead of a SIGSTOP
6059 (e.g. gdbserver). We already rely on SIGTRAP being our
6060 signal, so this is no exception.
6062 Also consider that the attach is complete when we see a
6063 GDB_SIGNAL_0. In non-stop mode, GDB will explicitly tell
6064 the target to stop all threads of the inferior, in case the
6065 low level attach operation doesn't stop them implicitly. If
6066 they weren't stopped implicitly, then the stub will report a
6067 GDB_SIGNAL_0, meaning: stopped for no particular reason
6068 other than GDB's request. */
6073 {
6078 }
6080 /* At this point, get hold of the now-current thread's frame. */
6084 /* Pull the single step breakpoints out of the target. */
6086 {
6088 CORE_ADDR pc;
6095 /* However, before doing so, if this single-step breakpoint was
6096 actually for another thread, set this thread up for moving
6097 past it. */
6100 {
6102 {
6107 }
6108 }
6109 else
6110 {
6113 }
6114 }
6121 else
6124 /* If necessary, step over this watchpoint. We'll be back to display
6125 it in a moment. */
6129 {
6130 /* At this point, we are stopped at an instruction which has
6131 attempted to write to a piece of memory under control of
6132 a watchpoint. The instruction hasn't actually executed
6133 yet. If we were to evaluate the watchpoint expression
6134 now, we would get the old value, and therefore no change
6135 would seem to have occurred.
6137 In order to make watchpoints work `right', we really need
6138 to complete the memory write, and then evaluate the
6139 watchpoint expression. We do this by single-stepping the
6140 target.
6142 It may not be necessary to disable the watchpoint to step over
6143 it. For example, the PA can (with some kernel cooperation)
6144 single step over a watchpoint without disabling the watchpoint.
6146 It is far more common to need to disable a watchpoint to step
6147 the inferior over it. If we have non-steppable watchpoints,
6148 we must disable the current watchpoint; it's simplest to
6149 disable all watchpoints.
6151 Any breakpoint at PC must also be stepped over -- if there's
6152 one, it will have already triggered before the watchpoint
6153 triggered, and we either already reported it to the user, or
6154 it didn't cause a stop and we called keep_going. In either
6155 case, if there was a breakpoint at PC, we must be trying to
6156 step past it. */
6160 }
6170 /* Hide inlined functions starting here, unless we just performed stepi or
6171 nexti. After stepi and nexti, always show the innermost frame (not any
6172 inline function call sites). */
6174 {
6178 /* skip_inline_frames is expensive, so we avoid it if we can
6179 determine that the address is one where functions cannot have
6180 been inlined. This improves performance with inferiors that
6181 load a lot of shared libraries, because the solib event
6182 breakpoint is defined as the address of a function (i.e. not
6183 inline). Note that we have to check the previous PC as well
6184 as the current one to catch cases when we have just
6185 single-stepped off a breakpoint prior to reinstating it.
6186 Note that we're assuming that the code we single-step to is
6187 not inline, but that's not definitive: there's nothing
6188 preventing the event breakpoint function from containing
6189 inlined code, and the single-step ending up there. If the
6190 user had set a breakpoint on that inlined code, the missing
6191 skip_inline_frames call would break things. Fortunately
6192 that's an extremely unlikely scenario. */
6201 {
6207 /* Re-fetch current thread's frame in case that invalidated
6208 the frame cache. */
6211 }
6212 }
6218 {
6219 /* We're trying to step off a breakpoint. Turns out that we're
6220 also on an instruction that needs to be stepped multiple
6221 times before it's been fully executing. E.g., architectures
6222 with a delay slot. It needs to be stepped twice, once for
6223 the instruction and once for the delay slot. */
6224 int step_through_delay
6232 {
6233 /* The user issued a continue when stopped at a breakpoint.
6234 Set up for another trap and get out of here. */
6238 }
6240 {
6241 /* The user issued a step when stopped at a breakpoint.
6242 Maybe we should stop, maybe we should not - the delay
6243 slot *might* correspond to a line of source. In any
6244 case, don't decide that here, just set
6245 ecs->stepping_over_breakpoint, making sure we
6246 single-step again before breakpoints are re-inserted. */
6248 }
6249 }
6251 /* See if there is a breakpoint/watchpoint/catchpoint/etc. that
6252 handles this event. */
6258 /* Following in case break condition called a
6259 function. */
6262 /* This is where we handle "moribund" watchpoints. Unlike
6263 software breakpoints traps, hardware watchpoint traps are
6264 always distinguishable from random traps. If no high-level
6265 watchpoint is associated with the reported stop data address
6266 anymore, then the bpstat does not explain the signal ---
6267 simply make sure to ignore it if `stopped_by_watchpoint' is
6268 set. */
6272 GDB_SIGNAL_TRAP)
6274 {
6277 }
6279 /* NOTE: cagney/2003-03-29: These checks for a random signal
6280 at one stage in the past included checks for an inferior
6281 function call's call dummy's return breakpoint. The original
6282 comment, that went with the test, read:
6284 ``End of a stack dummy. Some systems (e.g. Sony news) give
6285 another signal besides SIGTRAP, so check here as well as
6286 above.''
6288 If someone ever tries to get call dummys on a
6289 non-executable stack to work (where the target would stop
6290 with something like a SIGSEGV), then those tests might need
6291 to be re-instated. Given, however, that the tests were only
6292 enabled when momentary breakpoints were not being used, I
6293 suspect that it won't be the case.
6295 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
6296 be necessary for call dummies on a non-executable stack on
6297 SPARC. */
6299 /* See if the breakpoints module can explain the signal. */
6300 random_signal
6304 /* Maybe this was a trap for a software breakpoint that has since
6305 been removed. */
6307 {
6310 {
6314 /* Re-adjust PC to what the program would see if GDB was not
6315 debugging it. */
6319 {
6321 restore_operation_disable;
6324 restore_operation_disable.emplace
6329 }
6330 }
6331 else
6332 {
6333 /* A delayed software breakpoint event. Ignore the trap. */
6336 }
6337 }
6339 /* Maybe this was a trap for a hardware breakpoint/watchpoint that
6340 has since been removed. */
6342 {
6343 /* A delayed hardware breakpoint event. Ignore the trap. */
6347 }
6349 /* If not, perhaps stepping/nexting can. */
6354 /* Perhaps the thread hit a single-step breakpoint of _another_
6355 thread. Single-step breakpoints are transparent to the
6356 breakpoints module. */
6360 /* No? Perhaps we got a moribund watchpoint. */
6364 /* Always stop if the user explicitly requested this thread to
6365 remain stopped. */
6367 {
6370 }
6372 /* For the program's own signals, act according to
6373 the signal handling tables. */
6376 {
6377 /* Signal not for debugging purposes. */
6385 /* Always stop on signals if we're either just gaining control
6386 of the program, or the user explicitly requested this thread
6387 to remain stopped. */
6391 {
6394 }
6396 /* Notify observers the signal has "handle print" set. Note we
6397 returned early above if stopping; normal_stop handles the
6398 printing in that case. */
6400 {
6401 /* The signal table tells us to print about this signal. */
6405 }
6407 /* Clear the signal if it should not be passed. */
6414 {
6415 /* We were just starting a new sequence, attempting to
6416 single-step off of a breakpoint and expecting a SIGTRAP.
6417 Instead this signal arrives. This signal will take us out
6418 of the stepping range so GDB needs to remember to, when
6419 the signal handler returns, resume stepping off that
6420 breakpoint. */
6421 /* To simplify things, "continue" is forced to use the same
6422 code paths as single-step - set a breakpoint at the
6423 signal return address and then, once hit, step off that
6424 breakpoint. */
6429 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6432 /* If we were nexting/stepping some other thread, switch to
6433 it, so that we don't continue it, losing control. */
6437 }
6446 {
6447 /* The inferior is about to take a signal that will take it
6448 out of the single step range. Set a breakpoint at the
6449 current PC (which is presumably where the signal handler
6450 will eventually return) and then allow the inferior to
6451 run free.
6453 Note that this is only needed for a signal delivered
6454 while in the single-step range. Nested signals aren't a
6455 problem as they eventually all return. */
6461 /* Reset trap_expected to ensure breakpoints are re-inserted. */
6465 }
6467 /* Note: step_resume_breakpoint may be non-NULL. This occurs
6468 when either there's a nested signal, or when there's a
6469 pending signal enabled just as the signal handler returns
6470 (leaving the inferior at the step-resume-breakpoint without
6471 actually executing it). Either way continue until the
6472 breakpoint is really hit. */
6475 {
6479 }
6481 }
6484 }
6486 /* Come here when we've got some debug event / signal we can explain
6487 (IOW, not a random signal), and test whether it should cause a
6488 stop, or whether we should resume the inferior (transparently).
6489 E.g., could be a breakpoint whose condition evaluates false; we
6490 could be still stepping within the line; etc. */
6492 static void
6494 {
6498 CORE_ADDR jmp_buf_pc;
6501 /* Handle cases caused by hitting a breakpoint. */
6509 {
6511 }
6513 /* A few breakpoint types have callbacks associated (e.g.,
6514 bp_jit_event). Run them now. */
6517 /* If we hit an internal event that triggers symbol changes, the
6518 current frame will be invalidated within bpstat_what (e.g., if we
6519 hit an internal solib event). Re-fetch it. */
6524 {
6526 /* If we hit the breakpoint at longjmp while stepping, we
6527 install a momentary breakpoint at the target of the
6528 jmp_buf. */
6535 {
6538 /* If we set the longjmp breakpoint via a SystemTap probe,
6539 then use it to extract the arguments. The destination PC
6540 is the third argument to the probe. */
6543 {
6546 }
6550 {
6555 }
6557 /* Insert a breakpoint at resume address. */
6559 }
6560 else
6566 {
6569 /* There are several cases to consider.
6571 1. The initiating frame no longer exists. In this case we
6572 must stop, because the exception or longjmp has gone too
6573 far.
6575 2. The initiating frame exists, and is the same as the
6576 current frame. We stop, because the exception or longjmp
6577 has been caught.
6579 3. The initiating frame exists and is different from the
6580 current frame. This means the exception or longjmp has
6581 been caught beneath the initiating frame, so keep going.
6583 4. longjmp breakpoint has been placed just to protect
6584 against stale dummy frames and user is not interested in
6585 stopping around longjmps. */
6594 {
6598 {
6599 /* Case 4. */
6602 }
6603 }
6608 {
6609 struct frame_id current_id
6613 {
6614 /* Case 2. Fall through. */
6615 }
6616 else
6617 {
6618 /* Case 3. */
6621 }
6622 }
6624 /* For Cases 1 and 2, remove the step-resume breakpoint, if it
6625 exists. */
6629 }
6635 /* Still need to check other stuff, at least the case where we
6636 are stepping and step out of the right range. */
6645 {
6648 /* We are finishing a function in reverse, and just hit the
6649 step-resume breakpoint at the start address of the
6650 function, and we're almost there -- just need to back up
6651 by one more single-step, which should take us back to the
6652 function call. */
6656 }
6660 {
6661 /* We are stepping over a function call in reverse, and just
6662 hit the step-resume breakpoint at the start address of
6663 the function. Go back to single-stepping, which should
6664 take us back to the function call. */
6668 }
6675 /* Assume the thread stopped for a breakpoint. We'll still check
6676 whether a/the breakpoint is there when the thread is next
6677 resumed. */
6687 /* Assume the thread stopped for a breakpoint. We'll still check
6688 whether a/the breakpoint is there when the thread is next
6689 resumed. */
6699 {
6700 /* Back when the step-resume breakpoint was inserted, we
6701 were trying to single-step off a breakpoint. Go back to
6702 doing that. */
6707 }
6712 }
6714 /* If we stepped a permanent breakpoint and we had a high priority
6715 step-resume breakpoint for the address we stepped, but we didn't
6716 hit it, then we must have stepped into the signal handler. The
6717 step-resume was only necessary to catch the case of _not_
6718 stepping into the handler, so delete it, and fall through to
6719 checking whether the step finished. */
6721 {
6729 {
6733 }
6734 }
6736 /* We come here if we hit a breakpoint but should not stop for it.
6737 Possibly we also were stepping and should stop for that. So fall
6738 through and test for stepping. But, if not stepping, do not
6739 stop. */
6741 /* In all-stop mode, if we're currently stepping but have stopped in
6742 some other thread, we need to switch back to the stepped thread. */
6747 {
6750 /* Having a step-resume breakpoint overrides anything
6751 else having to do with stepping commands until
6752 that breakpoint is reached. */
6755 }
6758 {
6760 /* Likewise if we aren't even stepping. */
6763 }
6765 /* Re-fetch current thread's frame in case the code above caused
6766 the frame cache to be re-initialized, making our FRAME variable
6767 a dangling pointer. */
6772 /* If stepping through a line, keep going if still within it.
6774 Note that step_range_end is the address of the first instruction
6775 beyond the step range, and NOT the address of the last instruction
6776 within it!
6778 Note also that during reverse execution, we may be stepping
6779 through a function epilogue and therefore must detect when
6780 the current-frame changes in the middle of a line. */
6787 {
6788 infrun_debug_printf
6793 /* Tentatively re-enable range stepping; `resume' disables it if
6794 necessary (e.g., if we're stepping over a breakpoint or we
6795 have software watchpoints). */
6798 /* When stepping backward, stop at beginning of line range
6799 (unless it's the function entry point, in which case
6800 keep going back to the call point). */
6806 else
6810 }
6812 /* We stepped out of the stepping range. */
6814 /* If we are stepping at the source level and entered the runtime
6815 loader dynamic symbol resolution code...
6817 EXEC_FORWARD: we keep on single stepping until we exit the run
6818 time loader code and reach the callee's address.
6820 EXEC_REVERSE: we've already executed the callee (backward), and
6821 the runtime loader code is handled just like any other
6822 undebuggable function call. Now we need only keep stepping
6823 backward through the trampoline code, and that's handled further
6824 down, so there is nothing for us to do here. */
6829 {
6830 CORE_ADDR pc_after_resolver =
6837 {
6838 /* Set up a step-resume breakpoint at the address
6839 indicated by SKIP_SOLIB_RESOLVER. */
6840 symtab_and_line sr_sal;
6846 }
6850 }
6852 /* Step through an indirect branch thunk. */
6856 {
6860 }
6866 {
6868 /* The inferior, while doing a "step" or "next", has ended up in
6869 a signal trampoline (either by a signal being delivered or by
6870 the signal handler returning). Just single-step until the
6871 inferior leaves the trampoline (either by calling the handler
6872 or returning). */
6875 }
6877 /* If we're in the return path from a shared library trampoline,
6878 we want to proceed through the trampoline when stepping. */
6879 /* macro/2012-04-25: This needs to come before the subroutine
6880 call check below as on some targets return trampolines look
6881 like subroutine calls (MIPS16 return thunks). */
6886 {
6887 /* Determine where this trampoline returns. */
6889 CORE_ADDR real_stop_pc
6894 /* Only proceed through if we know where it's going. */
6896 {
6897 /* And put the step-breakpoint there and go until there. */
6898 symtab_and_line sr_sal;
6903 /* Do not specify what the fp should be when we stop since
6904 on some machines the prologue is where the new fp value
6905 is established. */
6909 /* Restart without fiddling with the step ranges or
6910 other state. */
6913 }
6914 }
6916 /* Check for subroutine calls. The check for the current frame
6917 equalling the step ID is not necessary - the check of the
6918 previous frame's ID is sufficient - but it is a common case and
6919 cheaper than checking the previous frame's ID.
6921 NOTE: frame_id_eq will never report two invalid frame IDs as
6922 being equal, so to get into this block, both the current and
6923 previous frame must have valid frame IDs. */
6924 /* The outer_frame_id check is a heuristic to detect stepping
6925 through startup code. If we step over an instruction which
6926 sets the stack pointer from an invalid value to a valid value,
6927 we may detect that as a subroutine call from the mythical
6928 "outermost" function. This could be fixed by marking
6929 outermost frames as !stack_p,code_p,special_p. Then the
6930 initial outermost frame, before sp was valid, would
6931 have code_addr == &_start. See the comment in frame_id_eq
6932 for more. */
6938 outer_frame_id)
6941 {
6943 CORE_ADDR real_stop_pc;
6948 {
6949 /* I presume that step_over_calls is only 0 when we're
6950 supposed to be stepping at the assembly language level
6951 ("stepi"). Just stop. */
6952 /* And this works the same backward as frontward. MVS */
6955 }
6957 /* Reverse stepping through solib trampolines. */
6964 {
6965 /* Any solib trampoline code can be handled in reverse
6966 by simply continuing to single-step. We have already
6967 executed the solib function (backwards), and a few
6968 steps will take us back through the trampoline to the
6969 caller. */
6972 }
6975 {
6976 /* We're doing a "next".
6978 Normal (forward) execution: set a breakpoint at the
6979 callee's return address (the address at which the caller
6980 will resume).
6982 Reverse (backward) execution. set the step-resume
6983 breakpoint at the start of the function that we just
6984 stepped into (backwards), and continue to there. When we
6985 get there, we'll need to single-step back to the caller. */
6988 {
6989 /* If we're already at the start of the function, we've either
6990 just stepped backward into a single instruction function,
6991 or stepped back out of a signal handler to the first instruction
6992 of the function. Just keep going, which will single-step back
6993 to the caller. */
6995 {
6996 /* Normal function call return (static or dynamic). */
6997 symtab_and_line sr_sal;
7002 }
7003 }
7004 else
7009 }
7011 /* If we are in a function call trampoline (a stub between the
7012 calling routine and the real function), locate the real
7013 function. That's what tells us (a) whether we want to step
7014 into it at all, and (b) what prologue we want to run to the
7015 end of, if we do step into it. */
7023 {
7024 symtab_and_line sr_sal;
7032 }
7034 /* If we have line number information for the function we are
7035 thinking of stepping into and the function isn't on the skip
7036 list, step into it.
7038 If there are several symtabs at that PC (e.g. with include
7039 files), just want to know whether *any* of them have line
7040 numbers. find_pc_line handles this. */
7041 {
7047 tmp_sal)
7049 {
7052 else
7055 }
7056 }
7058 /* If we have no line number and the step-stop-if-no-debug is
7059 set, we stop the step so that the user has a chance to switch
7060 in assembly mode. */
7063 {
7066 }
7069 {
7070 /* If we're already at the start of the function, we've either just
7071 stepped backward into a single instruction function without line
7072 number info, or stepped back out of a signal handler to the first
7073 instruction of the function without line number info. Just keep
7074 going, which will single-step back to the caller. */
7076 {
7077 /* Set a breakpoint at callee's start address.
7078 From there we can step once and be back in the caller. */
7079 symtab_and_line sr_sal;
7084 }
7085 }
7086 else
7087 /* Set a breakpoint at callee's return address (the address
7088 at which the caller will resume). */
7093 }
7095 /* Reverse stepping through solib trampolines. */
7099 {
7105 {
7106 /* Any solib trampoline code can be handled in reverse
7107 by simply continuing to single-step. We have already
7108 executed the solib function (backwards), and a few
7109 steps will take us back through the trampoline to the
7110 caller. */
7113 }
7115 {
7116 /* Stepped backward into the solib dynsym resolver.
7117 Set a breakpoint at its start and continue, then
7118 one more step will take us out. */
7119 symtab_and_line sr_sal;
7126 }
7127 }
7129 /* This always returns the sal for the inner-most frame when we are in a
7130 stack of inlined frames, even if GDB actually believes that it is in a
7131 more outer frame. This is checked for below by calls to
7132 inline_skipped_frames. */
7135 /* NOTE: tausq/2004-05-24: This if block used to be done before all
7136 the trampoline processing logic, however, there are some trampolines
7137 that have no names, so we should do trampoline handling first. */
7141 {
7144 /* The inferior just stepped into, or returned to, an
7145 undebuggable function (where there is no debugging information
7146 and no line number corresponding to the address where the
7147 inferior stopped). Since we want to skip this kind of code,
7148 we keep going until the inferior returns from this
7149 function - unless the user has asked us not to (via
7150 set step-mode) or we no longer know how to get back
7151 to the call site. */
7154 {
7155 /* If we have no line number and the step-stop-if-no-debug
7156 is set, we stop the step so that the user has a chance to
7157 switch in assembly mode. */
7160 }
7161 else
7162 {
7163 /* Set a breakpoint at callee's return address (the address
7164 at which the caller will resume). */
7168 }
7169 }
7172 {
7173 /* It is stepi or nexti. We always want to stop stepping after
7174 one instruction. */
7178 }
7181 {
7182 /* We have no line number information. That means to stop
7183 stepping (does this always happen right after one instruction,
7184 when we do "s" in a function with no line numbers,
7185 or can this happen as a result of a return or longjmp?). */
7189 }
7191 /* Look for "calls" to inlined functions, part one. If the inline
7192 frame machinery detected some skipped call sites, we have entered
7193 a new inline function. */
7198 {
7204 {
7205 /* For "step", we're going to stop. But if the call site
7206 for this inlined function is on the same source line as
7207 we were previously stepping, go down into the function
7208 first. Otherwise stop at the call site. */
7212 {
7215 {
7218 }
7219 }
7223 }
7224 else
7225 {
7226 /* For "next", we should stop at the call site if it is on a
7227 different source line. Otherwise continue through the
7228 inlined function. */
7232 else
7235 }
7236 }
7238 /* Look for "calls" to inlined functions, part two. If we are still
7239 in the same real function we were stepping through, but we have
7240 to go further up to find the exact frame ID, we are stepping
7241 through a more inlined call beyond its call site. */
7248 {
7254 else
7257 }
7263 {
7264 /* We are at a different line. */
7267 {
7268 /* We are at the start of a statement.
7270 So stop. Note that we don't stop if we step into the middle of a
7271 statement. That is said to make things like for (;;) statements
7272 work better. */
7276 }
7279 {
7280 /* We are not at the start of a statement, and we have not changed
7281 frame.
7283 We ignore this line table entry, and continue stepping forward,
7284 looking for a better place to stop. */
7288 }
7289 else
7290 {
7291 /* We are not the start of a statement, and we have changed frame.
7293 We ignore this line table entry, and continue stepping forward,
7294 looking for a better place to stop. Keep refresh_step_info at
7295 true to note that the frame has changed, but ignore the line
7296 number to make sure we don't ignore a subsequent entry with the
7297 same line number. */
7301 }
7302 }
7304 /* We aren't done stepping.
7306 Optimize by setting the stepping range to the line.
7307 (We might not be in the original line, but if we entered a
7308 new line in mid-statement, we continue stepping. This makes
7309 things like for(;;) statements work better.)
7311 If we entered a SAL that indicates a non-statement line table entry,
7312 then we update the stepping range, but we don't update the step info,
7313 which includes things like the line number we are stepping away from.
7314 This means we will stop when we find a line table entry that is marked
7315 as is-statement, even if it matches the non-statement one we just
7316 stepped into. */
7326 }
7329 ptid_t resume_ptid);
7331 /* In all-stop mode, if we're currently stepping but have stopped in
7332 some other thread, we may need to switch back to the stepped
7333 thread. Returns true we set the inferior running, false if we left
7334 it stopped (and the event needs further processing). */
7336 static bool
7338 {
7340 {
7341 /* If any thread is blocked on some internal breakpoint, and we
7342 simply need to step over that breakpoint to get it going
7343 again, do that first. */
7345 /* However, if we see an event for the stepping thread, then we
7346 know all other threads have been moved past their breakpoints
7347 already. Let the caller check whether the step is finished,
7348 etc., before deciding to move it past a breakpoint. */
7352 /* Check if the current thread is blocked on an incomplete
7353 step-over, interrupted by a random signal. */
7356 {
7357 infrun_debug_printf
7362 }
7364 /* Check if the current thread is blocked by a single-step
7365 breakpoint of another thread. */
7367 {
7372 }
7374 /* If this thread needs yet another step-over (e.g., stepping
7375 through a delay slot), do it first before moving on to
7376 another thread. */
7378 {
7379 infrun_debug_printf
7384 }
7386 /* If scheduler locking applies even if not stepping, there's no
7387 need to walk over threads. Above we've checked whether the
7388 current thread is stepping. If some other thread not the
7389 event thread is stepping, then it must be that scheduler
7390 locking is not in effect. */
7394 /* Otherwise, we no longer expect a trap in the current thread.
7395 Clear the trap_expected flag before switching back -- this is
7396 what keep_going does as well, if we call it. */
7399 /* Likewise, clear the signal if it should not be passed. */
7404 {
7407 }
7410 }
7413 }
7415 /* Look for the thread that was stepping, and resume it.
7416 RESUME_TARGET / RESUME_PTID indicate the set of threads the caller
7417 is resuming. Return true if a thread was started, false
7418 otherwise. */
7420 static bool
7422 ptid_t resume_ptid)
7423 {
7424 /* Do all pending step-overs before actually proceeding with
7425 step/next/etc. */
7430 {
7437 /* Ignore threads of processes the caller is not
7438 resuming. */
7445 {
7450 }
7451 }
7454 {
7461 /* Ignore threads of processes the caller is not
7462 resuming. */
7468 /* Did we find the stepping thread? */
7470 {
7475 }
7476 }
7479 }
7481 /* See infrun.h. */
7483 void
7485 {
7486 /* Note we don't check target_is_non_stop_p() here, because the
7487 current inferior may no longer have a process_stratum target
7488 pushed, as we just detached. */
7490 /* See if we have a THREAD_RUNNING thread that need to be
7491 re-resumed. If we have any thread that is already executing,
7492 then we don't need to resume the target -- it is already been
7493 resumed. With the remote target (in all-stop), it's even
7494 impossible to issue another resumption if the target is already
7495 resumed, until the target reports a stop. */
7497 {
7501 /* If we have any thread that is already executing, then we
7502 don't need to resume the target -- it is already been
7503 resumed. */
7507 /* If we have a pending event to process, skip resuming the
7508 target and go straight to processing it. */
7511 }
7513 /* Alright, we need to re-resume the target. If a thread was
7514 stepping, we need to restart it stepping. */
7518 /* Otherwise, find the first THREAD_RUNNING thread and resume
7519 it. */
7521 {
7525 execution_control_state ecs;
7530 }
7531 }
7533 /* Set a previously stepped thread back to stepping. Returns true on
7534 success, false if the resume is not possible (e.g., the thread
7535 vanished). */
7537 static bool
7539 {
7544 /* If the stepping thread exited, then don't try to switch back and
7545 resume it, which could fail in several different ways depending
7546 on the target. Instead, just keep going.
7548 We can find a stepping dead thread in the thread list in two
7549 cases:
7551 - The target supports thread exit events, and when the target
7552 tries to delete the thread from the thread list, inferior_ptid
7553 pointed at the exiting thread. In such case, calling
7554 delete_thread does not really remove the thread from the list;
7555 instead, the thread is left listed, with 'exited' state.
7557 - The target's debug interface does not support thread exit
7558 events, and so we have no idea whatsoever if the previously
7559 stepping thread is still alive. For that reason, we need to
7560 synchronously query the target now. */
7563 {
7569 }
7579 /* If the PC of the thread we were trying to single-step has
7580 changed, then that thread has trapped or been signaled, but the
7581 event has not been reported to GDB yet. Re-poll the target
7582 looking for this particular thread's event (i.e. temporarily
7583 enable schedlock) by:
7585 - setting a break at the current PC
7586 - resuming that particular thread, only (by setting trap
7587 expected)
7589 This prevents us continuously moving the single-step breakpoint
7590 forward, one instruction at a time, overstepping. */
7593 {
7594 ptid_t resume_ptid;
7600 /* Clear the info of the previous step-over, as it's no longer
7601 valid (if the thread was trying to step over a breakpoint, it
7602 has already succeeded). It's what keep_going would do too,
7603 if we called it. Do this before trying to insert the sss
7604 breakpoint, otherwise if we were previously trying to step
7605 over this exact address in another thread, the breakpoint is
7606 skipped. */
7617 }
7618 else
7619 {
7623 }
7626 }
7628 /* Is thread TP in the middle of (software or hardware)
7629 single-stepping? (Note the result of this function must never be
7630 passed directly as target_resume's STEP parameter.) */
7632 static bool
7634 {
7640 }
7642 /* Inferior has stepped into a subroutine call with source code that
7643 we should not step over. Do step to the first line of code in
7644 it. */
7646 static void
7649 {
7652 compunit_symtab *cust
7655 ecs->stop_func_start
7659 /* Use the step_resume_break to step until the end of the prologue,
7660 even if that involves jumps (as it seems to on the vax under
7661 4.2). */
7662 /* If the prologue ends in the middle of a source line, continue to
7663 the end of that source line (if it is still within the function).
7664 Otherwise, just go to end of prologue. */
7670 /* Architectures which require breakpoint adjustment might not be able
7671 to place a breakpoint at the computed address. If so, the test
7672 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
7673 ecs->stop_func_start to an address at which a breakpoint may be
7674 legitimately placed.
7676 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
7677 made, GDB will enter an infinite loop when stepping through
7678 optimized code consisting of VLIW instructions which contain
7679 subinstructions corresponding to different source lines. On
7680 FR-V, it's not permitted to place a breakpoint on any but the
7681 first subinstruction of a VLIW instruction. When a breakpoint is
7682 set, GDB will adjust the breakpoint address to the beginning of
7683 the VLIW instruction. Thus, we need to make the corresponding
7684 adjustment here when computing the stop address. */
7687 {
7688 ecs->stop_func_start
7691 }
7694 {
7695 /* We are already there: stop now. */
7698 }
7699 else
7700 {
7701 /* Put the step-breakpoint there and go until there. */
7702 symtab_and_line sr_sal;
7707 /* Do not specify what the fp should be when we stop since on
7708 some machines the prologue is where the new fp value is
7709 established. */
7712 /* And make sure stepping stops right away then. */
7715 }
7717 }
7719 /* Inferior has stepped backward into a subroutine call with source
7720 code that we should not step over. Do step to the beginning of the
7721 last line of code in it. */
7723 static void
7726 {
7734 ecs->stop_func_start
7739 /* OK, we're just going to keep stepping here. */
7741 {
7742 /* We're there already. Just stop stepping now. */
7744 }
7745 else
7746 {
7747 /* Else just reset the step range and keep going.
7748 No step-resume breakpoint, they don't work for
7749 epilogues, which can have multiple entry paths. */
7753 }
7755 }
7757 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID.
7758 This is used to both functions and to skip over code. */
7760 static void
7765 {
7766 /* There should never be more than one step-resume or longjmp-resume
7767 breakpoint per thread, so we should never be setting a new
7768 step_resume_breakpoint when one is already active. */
7777 }
7779 void
7783 {
7786 bp_step_resume);
7787 }
7789 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc.
7790 This is used to skip a potential signal handler.
7792 This is called with the interrupted function's frame. The signal
7793 handler, when it returns, will resume the interrupted function at
7794 RETURN_FRAME.pc. */
7796 static void
7798 {
7803 symtab_and_line sr_sal;
7810 bp_hp_step_resume);
7811 }
7813 /* Insert a "step-resume breakpoint" at the previous frame's PC. This
7814 is used to skip a function after stepping into it (for "next" or if
7815 the called function has no debugging information).
7817 The current function has almost always been reached by single
7818 stepping a call or return instruction. NEXT_FRAME belongs to the
7819 current function, and the breakpoint will be set at the caller's
7820 resume address.
7822 This is a separate function rather than reusing
7823 insert_hp_step_resume_breakpoint_at_frame in order to avoid
7824 get_prev_frame, which may stop prematurely (see the implementation
7825 of frame_unwind_caller_id for an example). */
7827 static void
7829 {
7830 /* We shouldn't have gotten here if we don't know where the call site
7831 is. */
7836 symtab_and_line sr_sal;
7844 }
7846 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a
7847 new breakpoint at the target of a jmp_buf. The handling of
7848 longjmp-resume uses the same mechanisms used for handling
7849 "step-resume" breakpoints. */
7851 static void
7853 {
7854 /* There should never be more than one longjmp-resume breakpoint per
7855 thread, so we should never be setting a new
7856 longjmp_resume_breakpoint when one is already active. */
7864 }
7866 /* Insert an exception resume breakpoint. TP is the thread throwing
7867 the exception. The block B is the block of the unwinder debug hook
7868 function. FRAME is the frame corresponding to the call to this
7869 function. SYM is the symbol of the function argument holding the
7870 target PC of the exception. */
7872 static void
7877 {
7878 try
7879 {
7882 CORE_ADDR handler;
7888 /* If the value was optimized out, revert to the old behavior. */
7890 {
7897 handler,
7900 /* set_momentary_breakpoint_at_pc invalidates FRAME. */
7905 }
7906 }
7908 {
7909 /* We want to ignore errors here. */
7910 }
7911 }
7913 /* A helper for check_exception_resume that sets an
7914 exception-breakpoint based on a SystemTap probe. */
7916 static void
7920 {
7922 CORE_ADDR handler;
7938 }
7940 /* This is called when an exception has been intercepted. Check to
7941 see whether the exception's destination is of interest, and if so,
7942 set an exception resume breakpoint there. */
7944 static void
7947 {
7951 /* First see if this exception unwinding breakpoint was set via a
7952 SystemTap probe point. If so, the probe has two arguments: the
7953 CFA and the HANDLER. We ignore the CFA, extract the handler, and
7954 set a breakpoint there. */
7957 {
7960 }
7966 try
7967 {
7973 /* The exception breakpoint is a thread-specific breakpoint on
7974 the unwinder's debug hook, declared as:
7976 void _Unwind_DebugHook (void *cfa, void *handler);
7978 The CFA argument indicates the frame to which control is
7979 about to be transferred. HANDLER is the destination PC.
7981 We ignore the CFA and set a temporary breakpoint at HANDLER.
7982 This is not extremely efficient but it avoids issues in gdb
7983 with computing the DWARF CFA, and it also works even in weird
7984 cases such as throwing an exception from inside a signal
7985 handler. */
7989 {
7995 else
7996 {
8000 }
8001 }
8002 }
8004 {
8005 }
8006 }
8008 static void
8010 {
8013 /* Let callers know we don't want to wait for the inferior anymore. */
8016 /* If all-stop, but there exists a non-stop target, stop all
8017 threads now that we're presenting the stop to the user. */
8020 }
8022 /* Like keep_going, but passes the signal to the inferior, even if the
8023 signal is set to nopass. */
8025 static void
8027 {
8031 /* Save the pc before execution, to compare with pc after stop. */
8036 {
8043 /* We haven't yet gotten our trap, and either: intercepted a
8044 non-signal event (e.g., a fork); or took a signal which we
8045 are supposed to pass through to the inferior. Simply
8046 continue. */
8048 }
8050 {
8051 /* Another thread is stepping over a breakpoint in-line. If
8052 this thread needs a step-over too, queue the request. In
8053 either case, this resume must be deferred for later. */
8058 {
8063 }
8064 else
8065 {
8068 }
8069 }
8070 else
8071 {
8075 step_over_what step_what;
8077 /* Either the trap was not expected, but we are continuing
8078 anyway (if we got a signal, the user asked it be passed to
8079 the child)
8080 -- or --
8081 We got our expected trap, but decided we should resume from
8082 it.
8084 We're going to run this baby now!
8086 Note that insert_breakpoints won't try to re-insert
8087 already inserted breakpoints. Therefore, we don't
8088 care if breakpoints were already inserted, or not. */
8090 /* If we need to step over a breakpoint, and we're not using
8091 displaced stepping to do so, insert all breakpoints
8092 (watchpoints, etc.) but the one we're stepping over, step one
8093 instruction, and then re-insert the breakpoint when that step
8094 is finished. */
8102 /* We can't use displaced stepping if we need to step past a
8103 watchpoint. The instruction copied to the scratch pad would
8104 still trigger the watchpoint. */
8107 {
8111 }
8115 /* If we now need to do an in-line step-over, we need to stop
8116 all other threads. Note this must be done before
8117 insert_breakpoints below, because that removes the breakpoint
8118 we're about to step over, otherwise other threads could miss
8119 it. */
8123 /* Stop stepping if inserting breakpoints fails. */
8124 try
8125 {
8127 }
8129 {
8134 }
8139 }
8142 }
8144 /* Called when we should continue running the inferior, because the
8145 current event doesn't cause a user visible stop. This does the
8146 resuming part; waiting for the next event is done elsewhere. */
8148 static void
8150 {
8158 }
8160 /* This function normally comes after a resume, before
8161 handle_inferior_event exits. It takes care of any last bits of
8162 housekeeping, and sets the all-important wait_some_more flag. */
8164 static void
8166 {
8171 /* If the target can't async, emulate it by marking the infrun event
8172 handler such that as soon as we get back to the event-loop, we
8173 immediately end up in fetch_inferior_event again calling
8174 target_wait. */
8177 }
8179 /* We are done with the step range of a step/next/si/ni command.
8180 Called once for each n of a "step n" operation. */
8182 static void
8184 {
8187 }
8189 /* Several print_*_reason functions to print why the inferior has stopped.
8190 We always print something when the inferior exits, or receives a signal.
8191 The rest of the cases are dealt with later on in normal_stop and
8192 print_it_typical. Ideally there should be a call to one of these
8193 print_*_reason functions functions from handle_inferior_event each time
8194 stop_waiting is called.
8196 Note that we don't call these directly, instead we delegate that to
8197 the interpreters, through observers. Interpreters then call these
8198 with whatever uiout is right. */
8200 void
8202 {
8203 /* For CLI-like interpreters, print nothing. */
8206 {
8209 }
8210 }
8212 void
8214 {
8217 uiout->field_string
8231 }
8233 void
8235 {
8241 {
8249 }
8250 else
8251 {
8253 uiout->field_string
8257 }
8258 }
8260 void
8262 {
8268 ;
8270 {
8278 {
8282 }
8283 }
8284 else
8289 else
8290 {
8294 uiout->field_string
8308 }
8310 }
8312 void
8314 {
8316 }
8318 /* Print current location without a level number, if we have changed
8319 functions or hit a breakpoint. Print source line if we have one.
8320 bpstat_print contains the logic deciding in detail what to print,
8321 based on the event(s) that just occurred. */
8323 static void
8325 {
8333 {
8335 /* FIXME: cagney/2002-12-01: Given that a frame ID does (or
8336 should) carry around the function and does (or should) use
8337 that when doing a frame comparison. */
8343 {
8344 /* Finished step, just print source line. */
8346 }
8347 else
8348 {
8349 /* Print location and source line. */
8351 }
8354 /* Print location and source line. */
8361 /* Something bogus. */
8367 }
8369 /* The behavior of this routine with respect to the source
8370 flag is:
8371 SRC_LINE: Print only source line
8372 LOCATION: Print only location
8373 SRC_AND_LOC: Print location and source line. */
8376 }
8378 /* See infrun.h. */
8380 void
8382 {
8388 {
8393 /* Display the auto-display expressions. */
8396 }
8401 {
8407 }
8408 }
8410 /* See infrun.h. */
8412 void
8414 {
8416 {
8418 {
8423 }
8424 }
8425 }
8427 /* The execution context that just caused a normal stop. */
8429 struct stop_context
8430 {
8437 /* The stop ID. */
8438 ULONGEST stop_id;
8440 /* The event PTID. */
8442 ptid_t ptid;
8444 /* If stopp for a thread event, this is the thread that caused the
8445 stop. */
8446 thread_info_ref thread;
8448 /* The inferior that caused the stop. */
8450 };
8452 /* Initializes a new stop context. If stopped for a thread event, this
8453 takes a strong reference to the thread. */
8456 {
8462 {
8463 /* Take a strong reference so that the thread can't be deleted
8464 yet. */
8466 }
8467 }
8469 /* Return true if the current context no longer matches the saved stop
8470 context. */
8472 bool
8474 {
8484 }
8486 /* See infrun.h. */
8488 int
8490 {
8497 /* If an exception is thrown from this point on, make sure to
8498 propagate GDB's knowledge of the executing state to the
8499 frontend/user running state. A QUIT is an easy exception to see
8500 here, so do this before any filtered output. */
8508 {
8509 /* On some targets, we may still have live threads in the
8510 inferior when we get a process exit event. E.g., for
8511 "checkpoint", when the current checkpoint/fork exits,
8512 linux-fork.c automatically switches to another fork from
8513 within target_mourn_inferior. */
8516 }
8522 {
8523 maybe_finish_thread_state.emplace
8525 }
8527 /* As we're presenting a stop, and potentially removing breakpoints,
8528 update the thread list so we can tell whether there are threads
8529 running on the target. With target remote, for example, we can
8530 only learn about new threads when we explicitly update the thread
8531 list. Do this before notifying the interpreters about signal
8532 stops, end of stepping ranges, etc., so that the "new thread"
8533 output is emitted before e.g., "Program received signal FOO",
8534 instead of after. */
8540 /* As with the notification of thread events, we want to delay
8541 notifying the user that we've switched thread context until
8542 the inferior actually stops.
8544 There's no point in saying anything if the inferior has exited.
8545 Note that SIGNALLED here means "exited with a signal", not
8546 "received a signal".
8548 Also skip saying anything in non-stop mode. In that mode, as we
8549 don't want GDB to switch threads behind the user's back, to avoid
8550 races where the user is typing a command to apply to thread x,
8551 but GDB switches to thread y before the user finishes entering
8552 the command, fetch_inferior_event installs a cleanup to restore
8553 the current thread back to the thread the user had selected right
8554 after this event is handled, so we're not really switching, only
8555 informing of a stop. */
8562 {
8564 {
8569 }
8571 }
8574 {
8577 {
8580 }
8581 }
8583 /* Note: this depends on the update_thread_list call above. */
8586 /* If an auto-display called a function and that got a signal,
8587 delete that auto-display to avoid an infinite recursion. */
8593 {
8595 }
8597 /* Let the user/frontend see the threads as stopped. */
8600 /* Select innermost stack frame - i.e., current frame is frame 0,
8601 and current location is based on that. Handle the case where the
8602 dummy call is returning after being stopped. E.g. the dummy call
8603 previously hit a breakpoint. (If the dummy call returns
8604 normally, we won't reach here.) Do this before the stop hook is
8605 run, so that it doesn't get to see the temporary dummy frame,
8606 which is not where we'll present the stop. */
8608 {
8610 {
8611 /* Pop the empty frame that contains the stack dummy. This
8612 also restores inferior state prior to the call (struct
8613 infcall_suspend_state). */
8618 /* frame_pop calls reinit_frame_cache as the last thing it
8619 does which means there's now no selected frame. */
8620 }
8624 /* Set the current source location. */
8626 }
8628 /* Look up the hook_stop and run it (CLI internally handles problem
8629 of stop_command's pre-hook not existing). */
8631 {
8632 stop_context saved_context;
8634 try
8635 {
8637 }
8639 {
8642 }
8644 /* If the stop hook resumes the target, then there's no point in
8645 trying to notify about the previous stop; its context is
8646 gone. Likewise if the command switches thread or inferior --
8647 the observers would print a stop for the wrong
8648 thread/inferior. */
8651 }
8653 /* Notify observers about the stop. This is where the interpreters
8654 print the stop event. */
8657 stop_print_frame);
8658 else
8664 {
8668 /* Delete the breakpoint we stopped at, if it wants to be deleted.
8669 Delete any breakpoint that is to be deleted at the next stop. */
8671 }
8673 /* Try to get rid of automatically added inferiors that are no
8674 longer needed. Keeping those around slows down things linearly.
8675 Note that this never removes the current inferior. */
8679 }
8680 \f
8681 int
8683 {
8685 }
8687 int
8689 {
8691 }
8693 int
8695 {
8697 }
8699 static void
8701 {
8703 {
8708 }
8714 }
8716 int
8718 {
8724 }
8726 int
8728 {
8734 }
8736 int
8738 {
8744 }
8746 /* Update the global 'signal_catch' from INFO and notify the
8747 target. */
8749 void
8751 {
8758 }
8760 static void
8762 {
8765 }
8767 static void
8769 {
8782 }
8784 /* Specify how various signals in the inferior should be handled. */
8786 static void
8788 {
8795 {
8797 }
8799 /* Allocate and zero an array of flags for which signals to handle. */
8804 /* Break the command line up into args. */
8808 /* Walk through the args, looking for signal oursigs, signal names, and
8809 actions. Signal numbers and signal names may be interspersed with
8810 actions, with the actions being performed for all signals cumulatively
8811 specified. Signal ranges can be specified as <LOW>-<HIGH>. */
8814 {
8817 {;
8818 }
8823 {
8824 /* Apply action to all signals except those used by the
8825 debugger. Silently skip those. */
8829 }
8831 {
8834 }
8836 {
8838 }
8840 {
8842 }
8844 {
8846 }
8848 {
8850 }
8852 {
8854 }
8856 {
8859 }
8861 {
8863 }
8865 {
8866 /* It is numeric. The numeric signal refers to our own
8867 internal signal numbering from target.h, not to host/target
8868 signal number. This is a feature; users really should be
8869 using symbolic names anyway, and the common ones like
8870 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */
8875 {
8878 }
8880 {
8881 /* Bet he didn't figure we'd think of this case... */
8883 }
8884 }
8885 else
8886 {
8889 {
8891 }
8892 else
8893 {
8894 /* Not a number and not a recognized flag word => complain. */
8896 }
8897 }
8899 /* If any signal numbers or symbol names were found, set flags for
8900 which signals to apply actions to. */
8903 {
8905 {
8909 {
8913 {
8915 }
8916 else
8918 }
8923 /* Make sure that "all" doesn't print these. */
8928 }
8929 }
8930 }
8934 {
8940 {
8941 /* Show the results. */
8946 }
8949 }
8950 }
8952 /* Complete the "handle" command. */
8954 static void
8958 {
8960 {
8970 NULL,
8971 };
8975 }
8977 enum gdb_signal
8979 {
8984 }
8986 /* Print current contents of the tables set by the handle command.
8987 It is possible we should just be printing signals actually used
8988 by the current target (but for things to work right when switching
8989 targets, all signals should be in the signal tables). */
8991 static void
8993 {
8999 {
9000 /* First see if this is a symbol name. */
9003 {
9004 /* No, try numeric. */
9005 oursig =
9007 }
9010 }
9013 /* These ugly casts brought to you by the native VAX compiler. */
9017 {
9018 QUIT;
9023 }
9027 }
9029 /* The $_siginfo convenience variable is a bit special. We don't know
9030 for sure the type of the value until we actually have a chance to
9031 fetch the data. The type can change depending on gdbarch, so it is
9032 also dependent on which thread you have selected.
9034 1. making $_siginfo be an internalvar that creates a new value on
9035 access.
9037 2. making the value of $_siginfo be an lval_computed value. */
9039 /* This function implements the lval_computed support for reading a
9040 $_siginfo value. */
9042 static void
9044 {
9045 LONGEST transferred;
9047 /* If we can access registers, so can we access $_siginfo. Likewise
9048 vice versa. */
9051 transferred =
9053 TARGET_OBJECT_SIGNAL_INFO,
9054 NULL,
9061 }
9063 /* This function implements the lval_computed support for writing a
9064 $_siginfo value. */
9066 static void
9068 {
9069 LONGEST transferred;
9071 /* If we can access registers, so can we access $_siginfo. Likewise
9072 vice versa. */
9076 TARGET_OBJECT_SIGNAL_INFO,
9077 NULL,
9084 }
9087 {
9088 siginfo_value_read,
9089 siginfo_value_write
9090 };
9092 /* Return a new value with the correct type for the siginfo object of
9093 the current thread using architecture GDBARCH. Return a void value
9094 if there's no object available. */
9099 {
9103 {
9107 }
9110 }
9112 \f
9113 /* infcall_suspend_state contains state about the program itself like its
9114 registers and any signal it received when it last stopped.
9115 This state must be restored regardless of how the inferior function call
9116 ends (either successfully, or after it hits a breakpoint or signal)
9117 if the program is to properly continue where it left off. */
9119 class infcall_suspend_state
9120 {
9122 /* Capture state from GDBARCH, TP, and REGCACHE that must be restored
9123 once the inferior function call has finished. */
9129 {
9133 {
9142 {
9143 /* Errors ignored. */
9145 }
9146 }
9149 {
9152 }
9153 }
9155 /* Return a pointer to the stored register state. */
9158 {
9160 }
9162 /* Restores the stored state into GDBARCH, TP, and REGCACHE. */
9167 {
9171 {
9174 /* Errors ignored. */
9178 }
9180 /* The inferior can be gone if the user types "print exit(0)"
9181 (and perhaps other times). */
9183 /* NB: The register write goes through to the target. */
9185 }
9188 /* How the current thread stopped before the inferior function call was
9189 executed. */
9192 /* The registers before the inferior function call was executed. */
9195 /* Format of SIGINFO_DATA or NULL if it is not present. */
9198 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of
9199 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the
9200 content would be invalid. */
9202 };
9204 infcall_suspend_state_up
9206 {
9211 infcall_suspend_state_up inf_state
9214 /* Having saved the current state, adjust the thread state, discarding
9215 any stop signal information. The stop signal is not useful when
9216 starting an inferior function call, and run_inferior_call will not use
9217 the signal due to its `proceed' call with GDB_SIGNAL_0. */
9221 }
9223 /* Restore inferior session state to INF_STATE. */
9225 void
9227 {
9234 }
9236 void
9238 {
9240 }
9242 readonly_detached_regcache *
9244 {
9246 }
9248 /* infcall_control_state contains state regarding gdb's control of the
9249 inferior itself like stepping control. It also contains session state like
9250 the user's currently selected frame. */
9252 struct infcall_control_state
9253 {
9257 /* Other fields: */
9261 /* ID and level of the selected frame when the inferior function
9262 call was made. */
9265 };
9267 /* Save all of the information associated with the inferior<==>gdb
9268 connection. */
9270 infcall_control_state_up
9272 {
9283 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of
9284 chain. If caller's caller is walking the chain, they'll be happier if we
9285 hand them back the original chain when restore_infcall_control_state is
9286 called. */
9289 /* Other fields: */
9297 }
9299 /* Restore inferior session state to INF_STATUS. */
9301 void
9303 {
9314 /* Handle the bpstat_copy of the chain. */
9320 /* Other fields: */
9325 {
9328 }
9331 }
9333 void
9335 {
9344 /* See save_infcall_control_state for info on stop_bpstat. */
9348 }
9349 \f
9350 /* See infrun.h. */
9352 void
9354 {
9357 }
9358 \f
9360 /* User interface for reverse debugging:
9361 Set exec-direction / show exec-direction commands
9362 (returns error unless target implements to_set_exec_direction method). */
9369 exec_forward,
9370 exec_reverse,
9371 NULL
9372 };
9374 static void
9377 {
9379 {
9384 }
9385 else
9386 {
9389 }
9390 }
9392 static void
9395 {
9407 }
9408 }
9410 static void
9413 {
9416 }
9418 /* Implementation of `siginfo' variable. */
9421 {
9422 siginfo_make_value,
9423 NULL,
9424 NULL
9425 };
9427 /* Callback for infrun's target events source. This is marked when a
9428 thread has a pending status to process. */
9430 static void
9432 {
9435 }
9437 #if GDB_SELF_TEST
9438 namespace selftests
9439 {
9441 /* Verify that when two threads with the same ptid exist (from two different
9442 targets) and one of them changes ptid, we only update inferior_ptid if
9443 it is appropriate. */
9445 static void
9447 {
9450 /* The thread which inferior_ptid represents changes ptid. */
9451 {
9452 scoped_restore_current_pspace_and_thread restore;
9472 }
9474 /* A thread with the same ptid as inferior_ptid, but from another target,
9475 changes ptid. */
9476 {
9477 scoped_restore_current_pspace_and_thread restore;
9497 }
9498 }
9505 void
9507 {
9510 /* Register extra event sources in the event loop. */
9511 infrun_async_inferior_event_token
9515 cmd_list_element *info_signals_cmd
9554 add_setshow_boolean_cmd
9576 set_non_stop,
9577 show_non_stop,
9582 {
9587 }
9589 /* Signals caused by debugger's own actions should not be given to
9590 the program afterwards.
9592 Do not deliver GDB_SIGNAL_TRAP by default, except when the user
9593 explicitly specifies that it should be delivered to the target
9594 program. Typically, that would occur when a user is debugging a
9595 target monitor on a simulator: the target monitor sets a
9596 breakpoint; the simulator encounters this breakpoint and halts
9597 the simulation handing control to GDB; GDB, noting that the stop
9598 address doesn't map to any known breakpoint, returns control back
9599 to the simulator; the simulator then delivers the hardware
9600 equivalent of a GDB_SIGNAL_TRAP to the program being
9601 debugged. */
9605 /* Signals that are not errors should not normally enter the debugger. */
9625 /* These signals are used internally by user-level thread
9626 implementations. (See signal(5) on Solaris.) Like the above
9627 signals, a healthy program receives and handles them as part of
9628 its normal operation. */
9638 /* Update cached state. */
9648 set_stop_on_solib_events,
9649 show_stop_on_solib_events,
9653 follow_fork_mode_kind_names,
9662 NULL,
9663 show_follow_fork_mode_string,
9667 follow_exec_mode_names,
9686 NULL,
9687 show_follow_exec_mode_string,
9702 show_scheduler_mode,
9713 NULL,
9714 show_schedule_multiple,
9723 NULL,
9724 show_step_stop_if_no_debug,
9737 NULL,
9738 show_can_use_displaced_stepping,
9749 /* Set/show detach-on-fork: user-settable mode. */
9757 /* Set/show disable address space randomization mode. */
9770 /* ptid initializations */
9782 /* Explicitly create without lookup, since that tries to create a
9783 value with a void typed value, and when we get here, gdbarch
9784 isn't initialized yet. At this point, we're quite sure there
9785 isn't another convenience variable of the same name. */
9796 set_observer_mode,
9797 show_observer_mode,
9801 #if GDB_SELF_TEST
9804 #endif
9805 }