GDB (xrefs)

/tmp/gdb-8.1/gdb/gdbthread.h
Go to the documentation of this file.
1 /* Multi-process/thread control defs for GDB, the GNU debugger.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
3 Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
4
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 #ifndef GDBTHREAD_H
22 #define GDBTHREAD_H
23
24 struct symtab;
25
26 #include "breakpoint.h"
27 #include "frame.h"
28 #include "ui-out.h"
29 #include "inferior.h"
30 #include "btrace.h"
31 #include "common/vec.h"
32 #include "target/waitstatus.h"
33 #include "cli/cli-utils.h"
34 #include "common/refcounted-object.h"
35 #include "common-gdbthread.h"
36
37 /* Frontend view of the thread state. Possible extensions: stepping,
38 finishing, until(ling),... */
39 enum thread_state
40 {
41 THREAD_STOPPED,
42 THREAD_RUNNING,
43 THREAD_EXITED,
44 };
45
46 /* Inferior thread specific part of `struct infcall_control_state'.
47
48 Inferior process counterpart is `struct inferior_control_state'. */
49
50 struct thread_control_state
51 {
52 /* User/external stepping state. */
53
54 /* Step-resume or longjmp-resume breakpoint. */
55 struct breakpoint *step_resume_breakpoint;
56
57 /* Exception-resume breakpoint. */
58 struct breakpoint *exception_resume_breakpoint;
59
60 /* Breakpoints used for software single stepping. Plural, because
61 it may have multiple locations. E.g., if stepping over a
62 conditional branch instruction we can't decode the condition for,
63 we'll need to put a breakpoint at the branch destination, and
64 another at the instruction after the branch. */
65 struct breakpoint *single_step_breakpoints;
66
67 /* Range to single step within.
68
69 If this is nonzero, respond to a single-step signal by continuing
70 to step if the pc is in this range.
71
72 If step_range_start and step_range_end are both 1, it means to
73 step for a single instruction (FIXME: it might clean up
74 wait_for_inferior in a minor way if this were changed to the
75 address of the instruction and that address plus one. But maybe
76 not). */
77 CORE_ADDR step_range_start; /* Inclusive */
78 CORE_ADDR step_range_end; /* Exclusive */
79
80 /* Function the thread was in as of last it started stepping. */
81 struct symbol *step_start_function;
82
83 /* If GDB issues a target step request, and this is nonzero, the
84 target should single-step this thread once, and then continue
85 single-stepping it without GDB core involvement as long as the
86 thread stops in the step range above. If this is zero, the
87 target should ignore the step range, and only issue one single
88 step. */
89 int may_range_step;
90
91 /* Stack frame address as of when stepping command was issued.
92 This is how we know when we step into a subroutine call, and how
93 to set the frame for the breakpoint used to step out. */
94 struct frame_id step_frame_id;
95
96 /* Similarly, the frame ID of the underlying stack frame (skipping
97 any inlined frames). */
98 struct frame_id step_stack_frame_id;
99
100 /* Nonzero if we are presently stepping over a breakpoint.
101
102 If we hit a breakpoint or watchpoint, and then continue, we need
103 to single step the current thread with breakpoints disabled, to
104 avoid hitting the same breakpoint or watchpoint again. And we
105 should step just a single thread and keep other threads stopped,
106 so that other threads don't miss breakpoints while they are
107 removed.
108
109 So, this variable simultaneously means that we need to single
110 step the current thread, keep other threads stopped, and that
111 breakpoints should be removed while we step.
112
113 This variable is set either:
114 - in proceed, when we resume inferior on user's explicit request
115 - in keep_going, if handle_inferior_event decides we need to
116 step over breakpoint.
117
118 The variable is cleared in normal_stop. The proceed calls
119 wait_for_inferior, which calls handle_inferior_event in a loop,
120 and until wait_for_inferior exits, this variable is changed only
121 by keep_going. */
122 int trap_expected;
123
124 /* Nonzero if the thread is being proceeded for a "finish" command
125 or a similar situation when return value should be printed. */
126 int proceed_to_finish;
127
128 /* Nonzero if the thread is being proceeded for an inferior function
129 call. */
130 int in_infcall;
131
132 enum step_over_calls_kind step_over_calls;
133
134 /* Nonzero if stopped due to a step command. */
135 int stop_step;
136
137 /* Chain containing status of breakpoint(s) the thread stopped
138 at. */
139 bpstat stop_bpstat;
140
141 /* Whether the command that started the thread was a stepping
142 command. This is used to decide whether "set scheduler-locking
143 step" behaves like "on" or "off". */
144 int stepping_command;
145 };
146
147 /* Inferior thread specific part of `struct infcall_suspend_state'. */
148
149 struct thread_suspend_state
150 {
151 /* Last signal that the inferior received (why it stopped). When
152 the thread is resumed, this signal is delivered. Note: the
153 target should not check whether the signal is in pass state,
154 because the signal may have been explicitly passed with the
155 "signal" command, which overrides "handle nopass". If the signal
156 should be suppressed, the core will take care of clearing this
157 before the target is resumed. */
158 enum gdb_signal stop_signal;
159
160 /* The reason the thread last stopped, if we need to track it
161 (breakpoint, watchpoint, etc.) */
162 enum target_stop_reason stop_reason;
163
164 /* The waitstatus for this thread's last event. */
165 struct target_waitstatus waitstatus;
166 /* If true WAITSTATUS hasn't been handled yet. */
167 int waitstatus_pending_p;
168
169 /* Record the pc of the thread the last time it stopped. (This is
170 not the current thread's PC as that may have changed since the
171 last stop, e.g., "return" command, or "p $pc = 0xf000"). This is
172 used in coordination with stop_reason and waitstatus_pending_p:
173 if the thread's PC is changed since it last stopped, a pending
174 breakpoint waitstatus is discarded. */
175 CORE_ADDR stop_pc;
176 };
177
178 typedef struct value *value_ptr;
179 DEF_VEC_P (value_ptr);
180 typedef VEC (value_ptr) value_vec;
181
182 /* Base class for target-specific thread data. */
183 struct private_thread_info
184 {
185 virtual ~private_thread_info () = 0;
186 };
187
188 /* Threads are intrusively refcounted objects. Being the
189 user-selected thread is normally considered an implicit strong
190 reference and is thus not accounted in the refcount, unlike
191 inferior objects. This is necessary, because there's no "current
192 thread" pointer. Instead the current thread is inferred from the
193 inferior_ptid global. However, when GDB needs to remember the
194 selected thread to later restore it, GDB bumps the thread object's
195 refcount, to prevent something deleting the thread object before
196 reverting back (e.g., due to a "kill" command). If the thread
197 meanwhile exits before being re-selected, then the thread object is
198 left listed in the thread list, but marked with state
199 THREAD_EXITED. (See make_cleanup_restore_current_thread and
200 delete_thread). All other thread references are considered weak
201 references. Placing a thread in the thread list is an implicit
202 strong reference, and is thus not accounted for in the thread's
203 refcount. */
204
205 class thread_info : public refcounted_object
206 {
207 public:
208 explicit thread_info (inferior *inf, ptid_t ptid);
209 ~thread_info ();
210
211 bool deletable () const
212 {
213 /* If this is the current thread, or there's code out there that
214 relies on it existing (refcount > 0) we can't delete yet. */
215 return (refcount () == 0 && !ptid_equal (ptid, inferior_ptid));
216 }
217
218 struct thread_info *next = NULL;
219 ptid_t ptid; /* "Actual process id";
220 In fact, this may be overloaded with
221 kernel thread id, etc. */
222
223 /* Each thread has two GDB IDs.
224
225 a) The thread ID (Id). This consists of the pair of:
226
227 - the number of the thread's inferior and,
228
229 - the thread's thread number in its inferior, aka, the
230 per-inferior thread number. This number is unique in the
231 inferior but not unique between inferiors.
232
233 b) The global ID (GId). This is a a single integer unique
234 between all inferiors.
235
236 E.g.:
237
238 (gdb) info threads -gid
239 Id GId Target Id Frame
240 * 1.1 1 Thread A 0x16a09237 in foo () at foo.c:10
241 1.2 3 Thread B 0x15ebc6ed in bar () at foo.c:20
242 1.3 5 Thread C 0x15ebc6ed in bar () at foo.c:20
243 2.1 2 Thread A 0x16a09237 in foo () at foo.c:10
244 2.2 4 Thread B 0x15ebc6ed in bar () at foo.c:20
245 2.3 6 Thread C 0x15ebc6ed in bar () at foo.c:20
246
247 Above, both inferiors 1 and 2 have threads numbered 1-3, but each
248 thread has its own unique global ID. */
249
250 /* The thread's global GDB thread number. This is exposed to MI,
251 Python/Scheme, visible with "info threads -gid", and is also what
252 the $_gthread convenience variable is bound to. */
253 int global_num;
254
255 /* The per-inferior thread number. This is unique in the inferior
256 the thread belongs to, but not unique between inferiors. This is
257 what the $_thread convenience variable is bound to. */
258 int per_inf_num;
259
260 /* The inferior this thread belongs to. */
261 struct inferior *inf;
262
263 /* The name of the thread, as specified by the user. This is NULL
264 if the thread does not have a user-given name. */
265 char *name = NULL;
266
267 /* Non-zero means the thread is executing. Note: this is different
268 from saying that there is an active target and we are stopped at
269 a breakpoint, for instance. This is a real indicator whether the
270 thread is off and running. */
271 int executing = 0;
272
273 /* Non-zero if this thread is resumed from infrun's perspective.
274 Note that a thread can be marked both as not-executing and
275 resumed at the same time. This happens if we try to resume a
276 thread that has a wait status pending. We shouldn't let the
277 thread really run until that wait status has been processed, but
278 we should not process that wait status if we didn't try to let
279 the thread run. */
280 int resumed = 0;
281
282 /* Frontend view of the thread state. Note that the THREAD_RUNNING/
283 THREAD_STOPPED states are different from EXECUTING. When the
284 thread is stopped internally while handling an internal event,
285 like a software single-step breakpoint, EXECUTING will be false,
286 but STATE will still be THREAD_RUNNING. */
287 enum thread_state state = THREAD_STOPPED;
288
289 /* State of GDB control of inferior thread execution.
290 See `struct thread_control_state'. */
291 thread_control_state control {};
292
293 /* State of inferior thread to restore after GDB is done with an inferior
294 call. See `struct thread_suspend_state'. */
295 thread_suspend_state suspend {};
296
297 int current_line = 0;
298 struct symtab *current_symtab = NULL;
299
300 /* Internal stepping state. */
301
302 /* Record the pc of the thread the last time it was resumed. (It
303 can't be done on stop as the PC may change since the last stop,
304 e.g., "return" command, or "p $pc = 0xf000"). This is maintained
305 by proceed and keep_going, and among other things, it's used in
306 adjust_pc_after_break to distinguish a hardware single-step
307 SIGTRAP from a breakpoint SIGTRAP. */
308 CORE_ADDR prev_pc = 0;
309
310 /* Did we set the thread stepping a breakpoint instruction? This is
311 used in conjunction with PREV_PC to decide whether to adjust the
312 PC. */
313 int stepped_breakpoint = 0;
314
315 /* Should we step over breakpoint next time keep_going is called? */
316 int stepping_over_breakpoint = 0;
317
318 /* Should we step over a watchpoint next time keep_going is called?
319 This is needed on targets with non-continuable, non-steppable
320 watchpoints. */
321 int stepping_over_watchpoint = 0;
322
323 /* Set to TRUE if we should finish single-stepping over a breakpoint
324 after hitting the current step-resume breakpoint. The context here
325 is that GDB is to do `next' or `step' while signal arrives.
326 When stepping over a breakpoint and signal arrives, GDB will attempt
327 to skip signal handler, so it inserts a step_resume_breakpoint at the
328 signal return address, and resume inferior.
329 step_after_step_resume_breakpoint is set to TRUE at this moment in
330 order to keep GDB in mind that there is still a breakpoint to step over
331 when GDB gets back SIGTRAP from step_resume_breakpoint. */
332 int step_after_step_resume_breakpoint = 0;
333
334 /* Pointer to the state machine manager object that handles what is
335 left to do for the thread's execution command after the target
336 stops. Several execution commands use it. */
337 struct thread_fsm *thread_fsm = NULL;
338
339 /* This is used to remember when a fork or vfork event was caught by
340 a catchpoint, and thus the event is to be followed at the next
341 resume of the thread, and not immediately. */
342 struct target_waitstatus pending_follow;
343
344 /* True if this thread has been explicitly requested to stop. */
345 int stop_requested = 0;
346
347 /* The initiating frame of a nexting operation, used for deciding
348 which exceptions to intercept. If it is null_frame_id no
349 bp_longjmp or bp_exception but longjmp has been caught just for
350 bp_longjmp_call_dummy. */
351 struct frame_id initiating_frame = null_frame_id;
352
353 /* Private data used by the target vector implementation. */
354 std::unique_ptr<private_thread_info> priv;
355
356 /* Branch trace information for this thread. */
357 struct btrace_thread_info btrace {};
358
359 /* Flag which indicates that the stack temporaries should be stored while
360 evaluating expressions. */
361 int stack_temporaries_enabled = 0;
362
363 /* Values that are stored as temporaries on stack while evaluating
364 expressions. */
365 value_vec *stack_temporaries = NULL;
366
367 /* Step-over chain. A thread is in the step-over queue if these are
368 non-NULL. If only a single thread is in the chain, then these
369 fields point to self. */
370 struct thread_info *step_over_prev = NULL;
371 struct thread_info *step_over_next = NULL;
372 };
373
374 /* Create an empty thread list, or empty the existing one. */
375 extern void init_thread_list (void);
376
377 /* Add a thread to the thread list, print a message
378 that a new thread is found, and return the pointer to
379 the new thread. Caller my use this pointer to
380 initialize the private thread data. */
381 extern struct thread_info *add_thread (ptid_t ptid);
382
383 /* Same as add_thread, but does not print a message
384 about new thread. */
385 extern struct thread_info *add_thread_silent (ptid_t ptid);
386
387 /* Same as add_thread, and sets the private info. */
388 extern struct thread_info *add_thread_with_info (ptid_t ptid,
389 struct private_thread_info *);
390
391 /* Delete an existing thread list entry. */
392 extern void delete_thread (ptid_t);
393
394 /* Delete an existing thread list entry, and be quiet about it. Used
395 after the process this thread having belonged to having already
396 exited, for example. */
397 extern void delete_thread_silent (ptid_t);
398
399 /* Delete a step_resume_breakpoint from the thread database. */
400 extern void delete_step_resume_breakpoint (struct thread_info *);
401
402 /* Delete an exception_resume_breakpoint from the thread database. */
403 extern void delete_exception_resume_breakpoint (struct thread_info *);
404
405 /* Delete the single-step breakpoints of thread TP, if any. */
406 extern void delete_single_step_breakpoints (struct thread_info *tp);
407
408 /* Check if the thread has software single stepping breakpoints
409 set. */
410 extern int thread_has_single_step_breakpoints_set (struct thread_info *tp);
411
412 /* Check whether the thread has software single stepping breakpoints
413 set at PC. */
414 extern int thread_has_single_step_breakpoint_here (struct thread_info *tp,
415 const address_space *aspace,
416 CORE_ADDR addr);
417
418 /* Translate the global integer thread id (GDB's homegrown id, not the
419 system's) into a "pid" (which may be overloaded with extra thread
420 information). */
421 extern ptid_t global_thread_id_to_ptid (int num);
422
423 /* Translate a 'pid' (which may be overloaded with extra thread
424 information) into the global integer thread id (GDB's homegrown id,
425 not the system's). */
426 extern int ptid_to_global_thread_id (ptid_t ptid);
427
428 /* Returns whether to show inferior-qualified thread IDs, or plain
429 thread numbers. Inferior-qualified IDs are shown whenever we have
430 multiple inferiors, or the only inferior left has number > 1. */
431 extern int show_inferior_qualified_tids (void);
432
433 /* Return a string version of THR's thread ID. If there are multiple
434 inferiors, then this prints the inferior-qualifier form, otherwise
435 it only prints the thread number. The result is stored in a
436 circular static buffer, NUMCELLS deep. */
437 const char *print_thread_id (struct thread_info *thr);
438
439 /* Boolean test for an already-known pid (which may be overloaded with
440 extra thread information). */
441 extern int in_thread_list (ptid_t ptid);
442
443 /* Boolean test for an already-known global thread id (GDB's homegrown
444 global id, not the system's). */
445 extern int valid_global_thread_id (int global_id);
446
447 /* Search function to lookup a thread by 'pid'. */
448 extern struct thread_info *find_thread_ptid (ptid_t ptid);
449
450 /* Find thread by GDB global thread ID. */
451 struct thread_info *find_thread_global_id (int global_id);
452
453 /* Find thread by thread library specific handle in inferior INF. */
454 struct thread_info *find_thread_by_handle (struct value *thread_handle,
455 struct inferior *inf);
456
457 /* Finds the first thread of the inferior given by PID. If PID is -1,
458 returns the first thread in the list. */
459 struct thread_info *first_thread_of_process (int pid);
460
461 /* Returns any thread of process PID, giving preference to the current
462 thread. */
463 extern struct thread_info *any_thread_of_process (int pid);
464
465 /* Returns any non-exited thread of process PID, giving preference to
466 the current thread, and to not executing threads. */
467 extern struct thread_info *any_live_thread_of_process (int pid);
468
469 /* Change the ptid of thread OLD_PTID to NEW_PTID. */
470 void thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid);
471
472 /* Iterator function to call a user-provided callback function
473 once for each known thread. */
474 typedef int (*thread_callback_func) (struct thread_info *, void *);
475 extern struct thread_info *iterate_over_threads (thread_callback_func, void *);
476
477 /* Traverse all threads. */
478 #define ALL_THREADS(T) \
479 for (T = thread_list; T; T = T->next) \
480
481 /* Traverse over all threads, sorted by inferior. */
482 #define ALL_THREADS_BY_INFERIOR(inf, tp) \
483 ALL_INFERIORS (inf) \
484 ALL_THREADS (tp) \
485 if (inf == tp->inf)
486
487 /* Traverse all threads, except those that have THREAD_EXITED
488 state. */
489
490 #define ALL_NON_EXITED_THREADS(T) \
491 for (T = thread_list; T; T = T->next) \
492 if ((T)->state != THREAD_EXITED)
493
494 /* Traverse all threads, including those that have THREAD_EXITED
495 state. Allows deleting the currently iterated thread. */
496 #define ALL_THREADS_SAFE(T, TMP) \
497 for ((T) = thread_list; \
498 (T) != NULL ? ((TMP) = (T)->next, 1): 0; \
499 (T) = (TMP))
500
501 extern int thread_count (void);
502
503 /* Switch from one thread to another. Does not read registers and
504 sets STOP_PC to -1. */
505 extern void switch_to_thread_no_regs (struct thread_info *thread);
506
507 /* Marks or clears thread(s) PTID as resumed. If PTID is
508 MINUS_ONE_PTID, applies to all threads. If ptid_is_pid(PTID) is
509 true, applies to all threads of the process pointed at by PTID. */
510 extern void set_resumed (ptid_t ptid, int resumed);
511
512 /* Marks thread PTID is running, or stopped.
513 If PTID is minus_one_ptid, marks all threads. */
514 extern void set_running (ptid_t ptid, int running);
515
516 /* Marks or clears thread(s) PTID as having been requested to stop.
517 If PTID is MINUS_ONE_PTID, applies to all threads. If
518 ptid_is_pid(PTID) is true, applies to all threads of the process
519 pointed at by PTID. If STOP, then the THREAD_STOP_REQUESTED
520 observer is called with PTID as argument. */
521 extern void set_stop_requested (ptid_t ptid, int stop);
522
523 /* NOTE: Since the thread state is not a boolean, most times, you do
524 not want to check it with negation. If you really want to check if
525 the thread is stopped,
526
527 use (good):
528
529 if (is_stopped (ptid))
530
531 instead of (bad):
532
533 if (!is_running (ptid))
534
535 The latter also returns true on exited threads, most likelly not
536 what you want. */
537
538 /* Reports if in the frontend's perpective, thread PTID is running. */
539 extern int is_running (ptid_t ptid);
540
541 /* Is this thread listed, but known to have exited? We keep it listed
542 (but not visible) until it's safe to delete. */
543 extern int is_exited (ptid_t ptid);
544
545 /* In the frontend's perpective, is this thread stopped? */
546 extern int is_stopped (ptid_t ptid);
547
548 /* Marks thread PTID as executing, or not. If PTID is minus_one_ptid,
549 marks all threads.
550
551 Note that this is different from the running state. See the
552 description of state and executing fields of struct
553 thread_info. */
554 extern void set_executing (ptid_t ptid, int executing);
555
556 /* Reports if thread PTID is executing. */
557 extern int is_executing (ptid_t ptid);
558
559 /* True if any (known or unknown) thread is or may be executing. */
560 extern int threads_are_executing (void);
561
562 /* Merge the executing property of thread PTID over to its thread
563 state property (frontend running/stopped view).
564
565 "not executing" -> "stopped"
566 "executing" -> "running"
567 "exited" -> "exited"
568
569 If PTID is minus_one_ptid, go over all threads.
570
571 Notifications are only emitted if the thread state did change. */
572 extern void finish_thread_state (ptid_t ptid);
573
574 /* Same as FINISH_THREAD_STATE, but with an interface suitable to be
575 registered as a cleanup. PTID_P points to the ptid_t that is
576 passed to FINISH_THREAD_STATE. */
577 extern void finish_thread_state_cleanup (void *ptid_p);
578
579 /* Commands with a prefix of `thread'. */
580 extern struct cmd_list_element *thread_cmd_list;
581
582 extern void thread_command (const char *tidstr, int from_tty);
583
584 /* Print notices on thread events (attach, detach, etc.), set with
585 `set print thread-events'. */
586 extern int print_thread_events;
587
588 /* Prints the list of threads and their details on UIOUT. If
589 REQUESTED_THREADS, a list of GDB ids/ranges, is not NULL, only
590 print threads whose ID is included in the list. If PID is not -1,
591 only print threads from the process PID. Otherwise, threads from
592 all attached PIDs are printed. If both REQUESTED_THREADS is not
593 NULL and PID is not -1, then the thread is printed if it belongs to
594 the specified process. Otherwise, an error is raised. */
595 extern void print_thread_info (struct ui_out *uiout, char *requested_threads,
596 int pid);
597
598 /* Save/restore current inferior/thread/frame. */
599
600 class scoped_restore_current_thread
601 {
602 public:
603 scoped_restore_current_thread ();
604 ~scoped_restore_current_thread ();
605
606 DISABLE_COPY_AND_ASSIGN (scoped_restore_current_thread);
607
608 private:
609 /* Use the "class" keyword here, because of a clash with a "thread_info"
610 function in the Darwin API. */
611 class thread_info *m_thread;
612 inferior *m_inf;
613 frame_id m_selected_frame_id;
614 int m_selected_frame_level;
615 bool m_was_stopped;
616 };
617
618 /* Returns a pointer into the thread_info corresponding to
619 INFERIOR_PTID. INFERIOR_PTID *must* be in the thread list. */
620 extern struct thread_info* inferior_thread (void);
621
622 extern void update_thread_list (void);
623
624 /* Delete any thread the target says is no longer alive. */
625
626 extern void prune_threads (void);
627
628 /* Delete threads marked THREAD_EXITED. Unlike prune_threads, this
629 does not consult the target about whether the thread is alive right
630 now. */
631 extern void delete_exited_threads (void);
632
633 /* Return true if PC is in the stepping range of THREAD. */
634
635 int pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread);
636
637 extern struct cleanup *enable_thread_stack_temporaries (ptid_t ptid);
638
639 extern int thread_stack_temporaries_enabled_p (ptid_t ptid);
640
641 extern void push_thread_stack_temporary (ptid_t ptid, struct value *v);
642
643 extern struct value *get_last_thread_stack_temporary (ptid_t);
644
645 extern int value_in_thread_stack_temporaries (struct value *, ptid_t);
646
647 /* Add TP to the end of its inferior's pending step-over chain. */
648
649 extern void thread_step_over_chain_enqueue (struct thread_info *tp);
650
651 /* Remove TP from its inferior's pending step-over chain. */
652
653 extern void thread_step_over_chain_remove (struct thread_info *tp);
654
655 /* Return the next thread in the step-over chain starting at TP. NULL
656 if TP is the last entry in the chain. */
657
658 extern struct thread_info *thread_step_over_chain_next (struct thread_info *tp);
659
660 /* Return true if TP is in the step-over chain. */
661
662 extern int thread_is_in_step_over_chain (struct thread_info *tp);
663
664 /* Cancel any ongoing execution command. */
665
666 extern void thread_cancel_execution_command (struct thread_info *thr);
667
668 /* Check whether it makes sense to access a register of the current
669 thread at this point. If not, throw an error (e.g., the thread is
670 executing). */
671 extern void validate_registers_access (void);
672
673 /* Check whether it makes sense to access a register of PTID at this point.
674 Returns true if registers may be accessed; false otherwise. */
675 extern bool can_access_registers_ptid (ptid_t ptid);
676
677 /* Returns whether to show which thread hit the breakpoint, received a
678 signal, etc. and ended up causing a user-visible stop. This is
679 true iff we ever detected multiple threads. */
680 extern int show_thread_that_caused_stop (void);
681
682 /* Print the message for a thread or/and frame selected. */
683 extern void print_selected_thread_frame (struct ui_out *uiout,
684 user_selected_what selection);
685
686 /* Helper for the CLI's "thread" command and for MI's -thread-select.
687 Selects thread THR. TIDSTR is the original string the thread ID
688 was parsed from. This is used in the error message if THR is not
689 alive anymore. */
690 extern void thread_select (const char *tidstr, class thread_info *thr);
691
692 extern struct thread_info *thread_list;
693
694 #endif /* GDBTHREAD_H */
threads_are_executing
int threads_are_executing(void)
Definition: thread.c:1021
thread_control_state::step_stack_frame_id
struct frame_id step_stack_frame_id
Definition: gdbthread.h:98
thread_control_state::stepping_command
int stepping_command
Definition: gdbthread.h:144
thread_info::resumed
int resumed
Definition: gdbthread.h:280
add_thread
struct thread_info * add_thread(ptid_t ptid)
Definition: thread.c:333
THREAD_STOPPED
Definition: gdbthread.h:41
pc_in_thread_step_range
int pc_in_thread_step_range(CORE_ADDR pc, struct thread_info *thread)
Definition: thread.c:1141
find_thread_ptid
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:514
thread_control_state::stop_bpstat
bpstat stop_bpstat
Definition: gdbthread.h:139
thread_info::stop_requested
int stop_requested
Definition: gdbthread.h:345
thread_control_state::step_range_start
CORE_ADDR step_range_start
Definition: gdbthread.h:77
show_inferior_qualified_tids
int show_inferior_qualified_tids(void)
Definition: thread.c:1594
target_waitstatus
Definition: waitstatus.h:104
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
can_access_registers_ptid
bool can_access_registers_ptid(ptid_t ptid)
Definition: thread.c:1123
thread_info::stepped_breakpoint
int stepped_breakpoint
Definition: gdbthread.h:313
VEC
typedef VEC(value_ptr) value_vec
thread_fsm
Definition: thread-fsm.h:31
delete_thread
void delete_thread(ptid_t)
Definition: thread.c:476
thread_info::deletable
bool deletable() const
Definition: gdbthread.h:211
pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1824
thread_info::initiating_frame
struct frame_id initiating_frame
Definition: gdbthread.h:351
set_running
void set_running(ptid_t ptid, int running)
Definition: thread.c:919
thread_control_state::may_range_step
int may_range_step
Definition: gdbthread.h:89
thread_control_state::proceed_to_finish
int proceed_to_finish
Definition: gdbthread.h:126
common-gdbthread.h
cmd_list_element
Definition: cli-decode.h:46
thread_info::stack_temporaries
value_vec * stack_temporaries
Definition: gdbthread.h:365
delete_thread_silent
void delete_thread_silent(ptid_t)
Definition: thread.c:482
add_thread_with_info
struct thread_info * add_thread_with_info(ptid_t ptid, struct private_thread_info *)
Definition: thread.c:319
refcounted_object
Definition: refcounted-object.h:26
scoped_restore_current_thread::DISABLE_COPY_AND_ASSIGN
DISABLE_COPY_AND_ASSIGN(scoped_restore_current_thread)
show_thread_that_caused_stop
int show_thread_that_caused_stop(void)
Definition: thread.c:1586
valid_global_thread_id
int valid_global_thread_id(int global_id)
Definition: thread.c:593
inferior_thread
struct thread_info * inferior_thread(void)
Definition: thread.c:90
null_frame_id
const struct frame_id null_frame_id
Definition: frame.c:575
thread_stack_temporaries_enabled_p
int thread_stack_temporaries_enabled_p(ptid_t ptid)
Definition: thread.c:795
inferior
Definition: inferior.h:310
scoped_restore_current_thread::m_was_stopped
bool m_was_stopped
Definition: gdbthread.h:615
value_in_thread_stack_temporaries
int value_in_thread_stack_temporaries(struct value *, ptid_t)
Definition: thread.c:820
thread_control_state
Definition: gdbthread.h:50
btrace.h
thread_info::state
enum thread_state state
Definition: gdbthread.h:287
first_thread_of_process
struct thread_info * first_thread_of_process(int pid)
Definition: thread.c:643
cleanup
Definition: cleanups.c:38
thread_suspend_state::stop_signal
enum gdb_signal stop_signal
Definition: gdbthread.h:158
scoped_restore_current_thread::m_thread
class thread_info * m_thread
Definition: gdbthread.h:611
THREAD_EXITED
Definition: gdbthread.h:43
thread_info::stepping_over_breakpoint
int stepping_over_breakpoint
Definition: gdbthread.h:316
THREAD_RUNNING
Definition: gdbthread.h:42
thread_info::current_symtab
struct symtab * current_symtab
Definition: gdbthread.h:298
thread_state
thread_state
Definition: gdbthread.h:39
scoped_restore_current_thread::~scoped_restore_current_thread
~scoped_restore_current_thread()
Definition: thread.c:1512
thread_step_over_chain_next
struct thread_info * thread_step_over_chain_next(struct thread_info *tp)
Definition: thread.c:408
in_thread_list
int in_thread_list(ptid_t ptid)
Definition: thread.c:628
thread_count
int thread_count(void)
Definition: thread.c:567
iterate_over_threads
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:551
thread_select
void thread_select(const char *tidstr, class thread_info *thr)
Definition: thread.c:1925
thread_control_state::in_infcall
int in_infcall
Definition: gdbthread.h:130
thread_info::next
struct thread_info * next
Definition: gdbthread.h:218
thread_info::per_inf_num
int per_inf_num
Definition: gdbthread.h:258
is_stopped
int is_stopped(ptid_t ptid)
Definition: thread.c:963
thread_info::suspend
thread_suspend_state suspend
Definition: gdbthread.h:295
value_ptr
struct value * value_ptr
Definition: gdbthread.h:178
thread_control_state::exception_resume_breakpoint
struct breakpoint * exception_resume_breakpoint
Definition: gdbthread.h:58
find_thread_global_id
struct thread_info * find_thread_global_id(int global_id)
Definition: thread.c:488
thread_control_state::step_frame_id
struct frame_id step_frame_id
Definition: gdbthread.h:94
thread_is_in_step_over_chain
int thread_is_in_step_over_chain(struct thread_info *tp)
Definition: thread.c:418
print_selected_thread_frame
void print_selected_thread_frame(struct ui_out *uiout, user_selected_what selection)
Definition: thread.c:1942
thread_info::executing
int executing
Definition: gdbthread.h:271
any_live_thread_of_process
struct thread_info * any_live_thread_of_process(int pid)
Definition: thread.c:674
thread_info::thread_info
thread_info(inferior *inf, ptid_t ptid)
Definition: thread.c:340
ptid_t
Definition: ptid.h:35
thread_control_state::trap_expected
int trap_expected
Definition: gdbthread.h:122
cli-utils.h
frame.h
thread_info::global_num
int global_num
Definition: gdbthread.h:253
private_thread_info::~private_thread_info
virtual ~private_thread_info()=0
thread_suspend_state::stop_pc
CORE_ADDR stop_pc
Definition: gdbthread.h:175
breakpoint
Definition: breakpoint.h:684
inferior.h
thread_info::prev_pc
CORE_ADDR prev_pc
Definition: gdbthread.h:308
ptid_to_global_thread_id
int ptid_to_global_thread_id(ptid_t ptid)
Definition: thread.c:605
thread_cancel_execution_command
void thread_cancel_execution_command(struct thread_info *thr)
Definition: thread.c:169
private_thread_info
Definition: gdbthread.h:183
finish_thread_state
void finish_thread_state(ptid_t ptid)
Definition: thread.c:1052
thread_info::pending_follow
struct target_waitstatus pending_follow
Definition: gdbthread.h:342
inf
Definition: gnu-nat.c:174
thread_change_ptid
void thread_change_ptid(ptid_t old_ptid, ptid_t new_ptid)
Definition: thread.c:855
print_thread_id
const char * print_thread_id(struct thread_info *thr)
Definition: thread.c:1602
push_thread_stack_temporary
void push_thread_stack_temporary(ptid_t ptid, struct value *v)
Definition: thread.c:808
add_thread_silent
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:266
thread_info::ptid
ptid_t ptid
Definition: gdbthread.h:219
find_thread_by_handle
struct thread_info * find_thread_by_handle(struct value *thread_handle, struct inferior *inf)
Definition: thread.c:528
breakpoint.h
thread_has_single_step_breakpoint_here
int thread_has_single_step_breakpoint_here(struct thread_info *tp, const address_space *aspace, CORE_ADDR addr)
Definition: thread.c:156
delete_step_resume_breakpoint
void delete_step_resume_breakpoint(struct thread_info *)
Definition: thread.c:110
symtab
Definition: symtab.h:1291
get_last_thread_stack_temporary
struct value * get_last_thread_stack_temporary(ptid_t)
Definition: thread.c:842
thread_cmd_list
struct cmd_list_element * thread_cmd_list
Definition: thread.c:2049
thread_info::step_over_prev
struct thread_info * step_over_prev
Definition: gdbthread.h:370
thread_suspend_state::stop_reason
enum target_stop_reason stop_reason
Definition: gdbthread.h:162
thread_has_single_step_breakpoints_set
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
Definition: thread.c:148
step_over_calls_kind
step_over_calls_kind
Definition: inferior.h:221
global_thread_id_to_ptid
ptid_t global_thread_id_to_ptid(int num)
Definition: thread.c:617
waitstatus.h
thread_control_state::step_start_function
struct symbol * step_start_function
Definition: gdbthread.h:81
value
Definition: value.c:169
thread_info::current_line
int current_line
Definition: gdbthread.h:297
ui_out
Definition: ui-out.h:77
finish_thread_state_cleanup
void finish_thread_state_cleanup(void *ptid_p)
Definition: thread.c:1089
thread_command
void thread_command(const char *tidstr, int from_tty)
Definition: thread.c:1795
scoped_restore_current_thread::scoped_restore_current_thread
scoped_restore_current_thread()
Definition: thread.c:1545
thread_step_over_chain_enqueue
void thread_step_over_chain_enqueue(struct thread_info *tp)
Definition: thread.c:426
btrace_thread_info
Definition: btrace.h:319
refcounted-object.h
thread_info::stepping_over_watchpoint
int stepping_over_watchpoint
Definition: gdbthread.h:321
thread_control_state::stop_step
int stop_step
Definition: gdbthread.h:135
address_space
Definition: progspace.h:216
thread_info::priv
std::unique_ptr< private_thread_info > priv
Definition: gdbthread.h:354
thread_info::name
char * name
Definition: gdbthread.h:265
set_resumed
void set_resumed(ptid_t ptid, int resumed)
Definition: thread.c:875
prune_threads
void prune_threads(void)
Definition: thread.c:727
update_thread_list
void update_thread_list(void)
Definition: thread.c:2000
thread_info::control
thread_control_state control
Definition: gdbthread.h:291
enable_thread_stack_temporaries
struct cleanup * enable_thread_stack_temporaries(ptid_t ptid)
Definition: thread.c:774
delete_exception_resume_breakpoint
void delete_exception_resume_breakpoint(struct thread_info *)
Definition: thread.c:117
scoped_restore_current_thread::m_selected_frame_id
frame_id m_selected_frame_id
Definition: gdbthread.h:613
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
thread_suspend_state
Definition: gdbthread.h:149
thread_info::btrace
Definition: gdbthread.h:357
print_thread_info
void print_thread_info(struct ui_out *uiout, char *requested_threads, int pid)
Definition: thread.c:1367
set_stop_requested
void set_stop_requested(ptid_t ptid, int stop)
Definition: thread.c:1027
switch_to_thread_no_regs
void switch_to_thread_no_regs(struct thread_info *thread)
Definition: thread.c:1396
DEF_VEC_P
DEF_VEC_P(value_ptr)
thread_control_state::single_step_breakpoints
struct breakpoint * single_step_breakpoints
Definition: gdbthread.h:65
thread_info::inf
struct inferior * inf
Definition: gdbthread.h:261
thread_list
struct thread_info * thread_list
Definition: thread.c:53
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
is_exited
int is_exited(ptid_t ptid)
Definition: thread.c:969
delete_exited_threads
void delete_exited_threads(void)
Definition: thread.c:741
delete_single_step_breakpoints
void delete_single_step_breakpoints(struct thread_info *tp)
Definition: thread.c:126
thread_info::~thread_info
~thread_info()
Definition: thread.c:354
validate_registers_access
void validate_registers_access(void)
Definition: thread.c:1101
thread_step_over_chain_remove
void thread_step_over_chain_remove(struct thread_info *tp)
Definition: thread.c:434
refcounted_object::refcount
int refcount() const
Definition: refcounted-object.h:45
symbol
Definition: symtab.h:1049
thread_callback_func
int(* thread_callback_func)(struct thread_info *, void *)
Definition: gdbthread.h:474
bpstats
Definition: breakpoint.h:1087
thread_info::stack_temporaries_enabled
int stack_temporaries_enabled
Definition: gdbthread.h:361
thread_suspend_state::waitstatus
struct target_waitstatus waitstatus
Definition: gdbthread.h:165
thread_control_state::step_over_calls
enum step_over_calls_kind step_over_calls
Definition: gdbthread.h:132
thread_control_state::step_resume_breakpoint
struct breakpoint * step_resume_breakpoint
Definition: gdbthread.h:55
thread_info::step_over_next
struct thread_info * step_over_next
Definition: gdbthread.h:371
is_running
int is_running(ptid_t ptid)
Definition: thread.c:975
scoped_restore_current_thread::m_selected_frame_level
int m_selected_frame_level
Definition: gdbthread.h:614
scoped_restore_current_thread::m_inf
inferior * m_inf
Definition: gdbthread.h:612
thread_suspend_state::waitstatus_pending_p
int waitstatus_pending_p
Definition: gdbthread.h:167
set_executing
void set_executing(ptid_t ptid, int executing)
Definition: thread.c:991
target_stop_reason
target_stop_reason
Definition: waitstatus.h:127
any_thread_of_process
struct thread_info * any_thread_of_process(int pid)
Definition: thread.c:656
thread_info
Definition: gdbthread.h:205
thread_info::step_after_step_resume_breakpoint
int step_after_step_resume_breakpoint
Definition: gdbthread.h:332
frame_id
Definition: frame.h:111
print_thread_events
int print_thread_events
Definition: thread.c:1912
is_executing
int is_executing(ptid_t ptid)
Definition: thread.c:981
scoped_restore_current_thread
Definition: gdbthread.h:600
thread_control_state::step_range_end
CORE_ADDR step_range_end
Definition: gdbthread.h:78
vec.h
init_thread_list
void init_thread_list(void)
Definition: thread.c:221
ui-out.h