1 /* Multi-process/thread control for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1988, 1993, 1998
4 Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30 #include "gdbthread.h"
35 #include <sys/types.h>
38 /*#include "lynxos-core.h"*/
42 struct thread_info
*next
;
43 int pid
; /* Actual process id */
44 int num
; /* Convenient handle */
45 CORE_ADDR prev_pc
; /* State from wait_for_inferior */
46 CORE_ADDR prev_func_start
;
48 struct breakpoint
*step_resume_breakpoint
;
49 struct breakpoint
*through_sigtramp_breakpoint
;
50 CORE_ADDR step_range_start
;
51 CORE_ADDR step_range_end
;
52 CORE_ADDR step_frame_address
;
57 /* This is set TRUE when a catchpoint of a shared library event
58 triggers. Since we don't wish to leave the inferior in the
59 solib hook when we report the event, we step the inferior
60 back to user code before stopping and reporting the event.
62 int stepping_through_solib_after_catch
;
64 /* When stepping_through_solib_after_catch is TRUE, this is a
65 list of the catchpoints that should be reported as triggering
66 when we finally do stop stepping.
68 bpstat stepping_through_solib_catchpoints
;
70 /* This is set to TRUE when this thread is in a signal handler
71 trampoline and we're single-stepping through it */
72 int stepping_through_sigtramp
;
76 /* Prototypes for exported functions. */
78 void _initialize_thread
PARAMS ((void));
80 /* Prototypes for local functions. */
82 #if !defined(FIND_NEW_THREADS)
83 #define FIND_NEW_THREADS local_find_new_threads
86 static struct thread_info
*thread_list
= NULL
;
87 static int highest_thread_num
;
89 static struct thread_info
* find_thread_id
PARAMS ((int num
));
91 static void thread_command
PARAMS ((char * tidstr
, int from_tty
));
92 static void thread_apply_all_command
PARAMS ((char *, int));
93 static int thread_alive
PARAMS ((struct thread_info
*));
94 static void info_threads_command
PARAMS ((char *, int));
95 static void thread_apply_command
PARAMS ((char *, int));
96 static void restore_current_thread
PARAMS ((int));
97 static void switch_to_thread
PARAMS ((int pid
));
98 static void prune_threads
PARAMS ((void));
100 /* If the host has threads, the host machine definition may set this
101 macro. But, for remote thread debugging, it gets more complex and
102 setting macros does not bind to the various target dependent
103 methods well. So, we use the vector target_thread_functions */
105 static struct target_thread_vector
*target_thread_functions
;
108 local_find_new_threads ()
111 if (target_thread_functions
&&
112 target_thread_functions
->find_new_threads
)
113 retval
= (*(target_thread_functions
->find_new_threads
)) ();
114 return retval
; /* no support */
119 target_get_thread_info
PARAMS ((gdb_threadref
* ref
,
120 int selection
, /* FIXME: Selection */
121 struct gdb_ext_thread_info
* info
));
124 target_get_thread_info (ref
, selection
, info
)
128 /* FIXME: Selection */
129 struct gdb_ext_thread_info
*info
;
133 if (target_thread_functions
134 && target_thread_functions
->get_thread_info
)
135 retval
= (*(target_thread_functions
->get_thread_info
)) (ref
, selection
, info
);
140 /* It is possible that these bind and unbinf functions implement a
141 stack the interface allows it, but its not implemented that way
146 bind_target_thread_vector (vec
)
147 struct target_thread_vector
*vec
;
149 target_thread_functions
= vec
;
152 struct target_thread_vector
*
153 unbind_target_thread_vector ()
155 struct target_thread_vector
*retval
;
156 retval
= target_thread_functions
;
157 target_thread_functions
= 0;
159 } /* unbind_target_thread-vector */
164 struct thread_info
*tp
, *tpnext
;
169 for (tp
= thread_list
; tp
; tp
= tpnext
)
176 highest_thread_num
= 0;
183 struct thread_info
*tp
;
185 tp
= (struct thread_info
*) xmalloc (sizeof (struct thread_info
));
188 tp
->num
= ++highest_thread_num
;
190 tp
->prev_func_start
= 0;
191 tp
->prev_func_name
= NULL
;
192 tp
->step_range_start
= 0;
193 tp
->step_range_end
= 0;
194 tp
->step_frame_address
=0;
195 tp
->step_resume_breakpoint
= 0;
196 tp
->through_sigtramp_breakpoint
= 0;
197 tp
->handling_longjmp
= 0;
198 tp
->trap_expected
= 0;
199 tp
->another_trap
= 0;
200 tp
->stepping_through_solib_after_catch
= 0;
201 tp
->stepping_through_solib_catchpoints
= NULL
;
202 tp
->stepping_through_sigtramp
= 0;
203 tp
->next
= thread_list
;
211 struct thread_info
*tp
, *tpprev
;
215 for (tp
= thread_list
; tp
; tpprev
= tp
, tp
= tp
->next
)
223 tpprev
->next
= tp
->next
;
225 thread_list
= tp
->next
;
232 static struct thread_info
*
236 struct thread_info
*tp
;
238 for (tp
= thread_list
; tp
; tp
= tp
->next
)
246 valid_thread_id (num
)
249 struct thread_info
*tp
;
251 for (tp
= thread_list
; tp
; tp
= tp
->next
)
259 pid_to_thread_id (pid
)
262 struct thread_info
*tp
;
264 for (tp
= thread_list
; tp
; tp
= tp
->next
)
272 thread_id_to_pid (num
)
275 struct thread_info
*thread
= find_thread_id (num
);
286 struct thread_info
*tp
;
288 for (tp
= thread_list
; tp
; tp
= tp
->next
)
292 return 0; /* Never heard of 'im */
295 /* Load infrun state for the thread PID. */
297 void load_infrun_state (pid
, prev_pc
, prev_func_start
, prev_func_name
,
298 trap_expected
, step_resume_breakpoint
,
299 through_sigtramp_breakpoint
, step_range_start
,
300 step_range_end
, step_frame_address
,
301 handling_longjmp
, another_trap
,
302 stepping_through_solib_after_catch
,
303 stepping_through_solib_catchpoints
,
304 stepping_through_sigtramp
)
307 CORE_ADDR
*prev_func_start
;
308 char **prev_func_name
;
310 struct breakpoint
**step_resume_breakpoint
;
311 struct breakpoint
**through_sigtramp_breakpoint
;
312 CORE_ADDR
*step_range_start
;
313 CORE_ADDR
*step_range_end
;
314 CORE_ADDR
*step_frame_address
;
315 int *handling_longjmp
;
317 int * stepping_through_solib_after_catch
;
318 bpstat
* stepping_through_solib_catchpoints
;
319 int * stepping_through_sigtramp
;
321 struct thread_info
*tp
;
323 /* If we can't find the thread, then we're debugging a single threaded
324 process. No need to do anything in that case. */
325 tp
= find_thread_id (pid_to_thread_id (pid
));
329 *prev_pc
= tp
->prev_pc
;
330 *prev_func_start
= tp
->prev_func_start
;
331 *prev_func_name
= tp
->prev_func_name
;
332 *step_resume_breakpoint
= tp
->step_resume_breakpoint
;
333 *step_range_start
= tp
->step_range_start
;
334 *step_range_end
= tp
->step_range_end
;
335 *step_frame_address
= tp
->step_frame_address
;
336 *through_sigtramp_breakpoint
= tp
->through_sigtramp_breakpoint
;
337 *handling_longjmp
= tp
->handling_longjmp
;
338 *trap_expected
= tp
->trap_expected
;
339 *another_trap
= tp
->another_trap
;
340 *stepping_through_solib_after_catch
= tp
->stepping_through_solib_after_catch
;
341 *stepping_through_solib_catchpoints
= tp
->stepping_through_solib_catchpoints
;
342 *stepping_through_sigtramp
= tp
->stepping_through_sigtramp
;
345 /* Save infrun state for the thread PID. */
347 void save_infrun_state (pid
, prev_pc
, prev_func_start
, prev_func_name
,
348 trap_expected
, step_resume_breakpoint
,
349 through_sigtramp_breakpoint
, step_range_start
,
350 step_range_end
, step_frame_address
,
351 handling_longjmp
, another_trap
,
352 stepping_through_solib_after_catch
,
353 stepping_through_solib_catchpoints
,
354 stepping_through_sigtramp
)
357 CORE_ADDR prev_func_start
;
358 char *prev_func_name
;
360 struct breakpoint
*step_resume_breakpoint
;
361 struct breakpoint
*through_sigtramp_breakpoint
;
362 CORE_ADDR step_range_start
;
363 CORE_ADDR step_range_end
;
364 CORE_ADDR step_frame_address
;
365 int handling_longjmp
;
367 int stepping_through_solib_after_catch
;
368 bpstat stepping_through_solib_catchpoints
;
369 int stepping_through_sigtramp
;
371 struct thread_info
*tp
;
373 /* If we can't find the thread, then we're debugging a single-threaded
374 process. Nothing to do in that case. */
375 tp
= find_thread_id (pid_to_thread_id (pid
));
379 tp
->prev_pc
= prev_pc
;
380 tp
->prev_func_start
= prev_func_start
;
381 tp
->prev_func_name
= prev_func_name
;
382 tp
->step_resume_breakpoint
= step_resume_breakpoint
;
383 tp
->step_range_start
= step_range_start
;
384 tp
->step_range_end
= step_range_end
;
385 tp
->step_frame_address
= step_frame_address
;
386 tp
->through_sigtramp_breakpoint
= through_sigtramp_breakpoint
;
387 tp
->handling_longjmp
= handling_longjmp
;
388 tp
->trap_expected
= trap_expected
;
389 tp
->another_trap
= another_trap
;
390 tp
->stepping_through_solib_after_catch
= stepping_through_solib_after_catch
;
391 tp
->stepping_through_solib_catchpoints
= stepping_through_solib_catchpoints
;
392 tp
->stepping_through_sigtramp
= stepping_through_sigtramp
;
395 /* Return true if TP is an active thread. */
398 struct thread_info
*tp
;
402 if (! target_thread_alive (tp
->pid
))
404 tp
->pid
= -1; /* Mark it as dead */
413 struct thread_info
*tp
, *tpprev
, *next
;
416 for (tp
= thread_list
; tp
; tp
= next
)
419 if (!thread_alive (tp
))
432 /* Print information about currently known threads
434 * Note: this has the drawback that it _really_ switches
435 * threads, which frees the frame cache. A no-side
436 * effects info-threads command would be nicer.
440 info_threads_command (arg
, from_tty
)
444 struct thread_info
*tp
;
446 struct frame_info
*cur_frame
;
447 int saved_frame_level
= selected_frame_level
;
450 /* Avoid coredumps which would happen if we tried to access a NULL
452 if (!target_has_stack
) error ("No stack.");
455 target_find_new_threads ();
456 current_pid
= inferior_pid
;
457 for (tp
= thread_list
; tp
; tp
= tp
->next
)
459 if (tp
->pid
== current_pid
)
460 printf_filtered ("* ");
462 printf_filtered (" ");
465 printf_filtered ("%d %s ", tp
->num
, target_tid_to_str (tp
->pid
));
467 printf_filtered ("%d %s ", tp
->num
, target_pid_to_str (tp
->pid
));
469 switch_to_thread (tp
->pid
);
471 print_only_stack_frame (selected_frame
, -1, 0);
473 printf_filtered ("[No stack.]\n");
476 switch_to_thread (current_pid
);
478 /* Code below copied from "up_silently_base" in "stack.c".
479 * It restores the frame set by the user before the "info threads"
480 * command. We have finished the info-threads display by switching
481 * back to the current thread. That switch has put us at the top
482 * of the stack (leaf frame).
484 counter
= saved_frame_level
;
485 cur_frame
= find_relative_frame(selected_frame
, &counter
);
488 /* Ooops, can't restore, tell user where we are. */
489 warning ("Couldn't restore frame in current thread, at frame 0");
490 print_stack_frame (selected_frame
, -1, 0);
494 select_frame(cur_frame
, saved_frame_level
);
497 /* re-show current frame. */
498 show_stack_frame(cur_frame
);
501 /* Switch from one thread to another. */
504 switch_to_thread (pid
)
507 if (pid
== inferior_pid
)
511 flush_cached_frames ();
512 registers_changed ();
514 select_frame (get_current_frame (), 0);
518 restore_current_thread (pid
)
521 if (pid
!= inferior_pid
)
523 switch_to_thread (pid
);
524 print_stack_frame( get_current_frame(), 0, -1);
528 /* Apply a GDB command to a list of threads. List syntax is a whitespace
529 seperated list of numbers, or ranges, or the keyword `all'. Ranges consist
530 of two numbers seperated by a hyphen. Examples:
532 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
533 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
534 thread apply all p x/i $pc Apply x/i $pc cmd to all threads
538 thread_apply_all_command (cmd
, from_tty
)
542 struct thread_info
*tp
;
543 struct cleanup
*old_chain
;
545 if (cmd
== NULL
|| *cmd
== '\000')
546 error ("Please specify a command following the thread ID list");
548 old_chain
= make_cleanup ((make_cleanup_func
) restore_current_thread
,
549 (void *) inferior_pid
);
551 for (tp
= thread_list
; tp
; tp
= tp
->next
)
552 if (thread_alive (tp
))
554 switch_to_thread (tp
->pid
);
556 printf_filtered ("\nThread %d (%s):\n",
558 target_tid_to_str (inferior_pid
));
560 printf_filtered ("\nThread %d (%s):\n", tp
->num
,
561 target_pid_to_str (inferior_pid
));
563 execute_command (cmd
, from_tty
);
568 thread_apply_command (tidlist
, from_tty
)
574 struct cleanup
*old_chain
;
576 if (tidlist
== NULL
|| *tidlist
== '\000')
577 error ("Please specify a thread ID list");
579 for (cmd
= tidlist
; *cmd
!= '\000' && !isalpha(*cmd
); cmd
++);
582 error ("Please specify a command following the thread ID list");
584 old_chain
= make_cleanup ((make_cleanup_func
) restore_current_thread
,
585 (void *) inferior_pid
);
587 while (tidlist
< cmd
)
589 struct thread_info
*tp
;
592 start
= strtol (tidlist
, &p
, 10);
594 error ("Error parsing %s", tidlist
);
597 while (*tidlist
== ' ' || *tidlist
== '\t')
600 if (*tidlist
== '-') /* Got a range of IDs? */
602 tidlist
++; /* Skip the - */
603 end
= strtol (tidlist
, &p
, 10);
605 error ("Error parsing %s", tidlist
);
608 while (*tidlist
== ' ' || *tidlist
== '\t')
614 for (; start
<= end
; start
++)
616 tp
= find_thread_id (start
);
619 warning ("Unknown thread %d.", start
);
620 else if (!thread_alive (tp
))
621 warning ("Thread %d has terminated.", start
);
624 switch_to_thread (tp
->pid
);
626 printf_filtered ("\nThread %d (%s):\n", tp
->num
,
627 target_tid_to_str (inferior_pid
));
629 printf_filtered ("\nThread %d (%s):\n", tp
->num
,
630 target_pid_to_str (inferior_pid
));
632 execute_command (cmd
, from_tty
);
638 /* Switch to the specified thread. Will dispatch off to thread_apply_command
639 if prefix of arg is `apply'. */
642 thread_command (tidstr
, from_tty
)
647 struct thread_info
*tp
;
651 /* Don't generate an error, just say which thread is current. */
652 if (target_has_stack
)
653 printf_filtered ("[Current thread is %d (%s)]\n",
654 pid_to_thread_id(inferior_pid
),
655 #if defined(HPUXHPPA)
656 target_tid_to_str(inferior_pid
)
658 target_pid_to_str(inferior_pid
)
667 tp
= find_thread_id (num
);
670 error ("Thread ID %d not known. Use the \"info threads\" command to\n\
671 see the IDs of currently known threads.", num
);
673 if (!thread_alive (tp
))
674 error ("Thread ID %d has terminated.\n", num
);
676 switch_to_thread (tp
->pid
);
681 printf_filtered ("[Switching to thread %d (%s)]\n",
682 pid_to_thread_id (inferior_pid
),
683 #if defined(HPUXHPPA)
684 target_tid_to_str (inferior_pid
)
686 target_pid_to_str (inferior_pid
)
689 print_stack_frame (selected_frame
, selected_frame_level
, 1);
692 /* Commands with a prefix of `thread'. */
693 struct cmd_list_element
*thread_cmd_list
= NULL
;
696 _initialize_thread ()
698 static struct cmd_list_element
*thread_apply_list
= NULL
;
700 add_info ("threads", info_threads_command
,
701 "IDs of currently known threads.");
703 add_prefix_cmd ("thread", class_run
, thread_command
,
704 "Use this command to switch between threads.\n\
705 The new thread ID must be currently known.", &thread_cmd_list
, "thread ", 1,
708 add_prefix_cmd ("apply", class_run
, thread_apply_command
,
709 "Apply a command to a list of threads.",
710 &thread_apply_list
, "apply ", 1, &thread_cmd_list
);
712 add_cmd ("all", class_run
, thread_apply_all_command
,
713 "Apply a command to all threads.",
717 add_com_alias ("t", "thread", class_run
, 1);