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 target_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 target_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 #if defined(FIND_NEW_THREADS)
458 current_pid
= inferior_pid
;
459 for (tp
= thread_list
; tp
; tp
= tp
->next
)
461 if (tp
->pid
== current_pid
)
462 printf_filtered ("* ");
464 printf_filtered (" ");
467 printf_filtered ("%d %s ", tp
->num
, target_tid_to_str (tp
->pid
));
469 printf_filtered ("%d %s ", tp
->num
, target_pid_to_str (tp
->pid
));
471 switch_to_thread (tp
->pid
);
473 print_only_stack_frame (selected_frame
, -1, 0);
475 printf_filtered ("[No stack.]\n");
478 switch_to_thread (current_pid
);
480 /* Code below copied from "up_silently_base" in "stack.c".
481 * It restores the frame set by the user before the "info threads"
482 * command. We have finished the info-threads display by switching
483 * back to the current thread. That switch has put us at the top
484 * of the stack (leaf frame).
486 counter
= saved_frame_level
;
487 cur_frame
= find_relative_frame(selected_frame
, &counter
);
490 /* Ooops, can't restore, tell user where we are. */
491 warning ("Couldn't restore frame in current thread, at frame 0");
492 print_stack_frame (selected_frame
, -1, 0);
496 select_frame(cur_frame
, saved_frame_level
);
499 /* re-show current frame. */
500 show_stack_frame(cur_frame
);
503 /* Switch from one thread to another. */
506 switch_to_thread (pid
)
509 if (pid
== inferior_pid
)
513 flush_cached_frames ();
514 registers_changed ();
516 select_frame (get_current_frame (), 0);
520 restore_current_thread (pid
)
523 if (pid
!= inferior_pid
)
525 switch_to_thread (pid
);
526 print_stack_frame( get_current_frame(), 0, -1);
530 /* Apply a GDB command to a list of threads. List syntax is a whitespace
531 seperated list of numbers, or ranges, or the keyword `all'. Ranges consist
532 of two numbers seperated by a hyphen. Examples:
534 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
535 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
536 thread apply all p x/i $pc Apply x/i $pc cmd to all threads
540 thread_apply_all_command (cmd
, from_tty
)
544 struct thread_info
*tp
;
545 struct cleanup
*old_chain
;
547 if (cmd
== NULL
|| *cmd
== '\000')
548 error ("Please specify a command following the thread ID list");
550 old_chain
= make_cleanup ((make_cleanup_func
) restore_current_thread
,
551 (void *) inferior_pid
);
553 for (tp
= thread_list
; tp
; tp
= tp
->next
)
554 if (thread_alive (tp
))
556 switch_to_thread (tp
->pid
);
558 printf_filtered ("\nThread %d (%s):\n",
560 target_tid_to_str (inferior_pid
));
562 printf_filtered ("\nThread %d (%s):\n", tp
->num
,
563 target_pid_to_str (inferior_pid
));
565 execute_command (cmd
, from_tty
);
570 thread_apply_command (tidlist
, from_tty
)
576 struct cleanup
*old_chain
;
578 if (tidlist
== NULL
|| *tidlist
== '\000')
579 error ("Please specify a thread ID list");
581 for (cmd
= tidlist
; *cmd
!= '\000' && !isalpha(*cmd
); cmd
++);
584 error ("Please specify a command following the thread ID list");
586 old_chain
= make_cleanup ((make_cleanup_func
) restore_current_thread
,
587 (void *) inferior_pid
);
589 while (tidlist
< cmd
)
591 struct thread_info
*tp
;
594 start
= strtol (tidlist
, &p
, 10);
596 error ("Error parsing %s", tidlist
);
599 while (*tidlist
== ' ' || *tidlist
== '\t')
602 if (*tidlist
== '-') /* Got a range of IDs? */
604 tidlist
++; /* Skip the - */
605 end
= strtol (tidlist
, &p
, 10);
607 error ("Error parsing %s", tidlist
);
610 while (*tidlist
== ' ' || *tidlist
== '\t')
616 for (; start
<= end
; start
++)
618 tp
= find_thread_id (start
);
621 warning ("Unknown thread %d.", start
);
622 else if (!thread_alive (tp
))
623 warning ("Thread %d has terminated.", start
);
626 switch_to_thread (tp
->pid
);
628 printf_filtered ("\nThread %d (%s):\n", tp
->num
,
629 target_tid_to_str (inferior_pid
));
631 printf_filtered ("\nThread %d (%s):\n", tp
->num
,
632 target_pid_to_str (inferior_pid
));
634 execute_command (cmd
, from_tty
);
640 /* Switch to the specified thread. Will dispatch off to thread_apply_command
641 if prefix of arg is `apply'. */
644 thread_command (tidstr
, from_tty
)
649 struct thread_info
*tp
;
653 /* Don't generate an error, just say which thread is current. */
654 if (target_has_stack
)
655 printf_filtered ("[Current thread is %d (%s)]\n",
656 pid_to_thread_id(inferior_pid
),
657 #if defined(HPUXHPPA)
658 target_tid_to_str(inferior_pid
)
660 target_pid_to_str(inferior_pid
)
669 tp
= find_thread_id (num
);
672 error ("Thread ID %d not known. Use the \"info threads\" command to\n\
673 see the IDs of currently known threads.", num
);
675 if (!thread_alive (tp
))
676 error ("Thread ID %d has terminated.\n", num
);
678 switch_to_thread (tp
->pid
);
683 printf_filtered ("[Switching to thread %d (%s)]\n",
684 pid_to_thread_id (inferior_pid
),
685 #if defined(HPUXHPPA)
686 target_tid_to_str (inferior_pid
)
688 target_pid_to_str (inferior_pid
)
691 print_stack_frame (selected_frame
, selected_frame_level
, 1);
694 /* Commands with a prefix of `thread'. */
695 struct cmd_list_element
*thread_cmd_list
= NULL
;
698 _initialize_thread ()
700 static struct cmd_list_element
*thread_apply_list
= NULL
;
701 extern struct cmd_list_element
*cmdlist
;
703 add_info ("threads", info_threads_command
,
704 "IDs of currently known threads.");
706 add_prefix_cmd ("thread", class_run
, thread_command
,
707 "Use this command to switch between threads.\n\
708 The new thread ID must be currently known.", &thread_cmd_list
, "thread ", 1,
711 add_prefix_cmd ("apply", class_run
, thread_apply_command
,
712 "Apply a command to a list of threads.",
713 &thread_apply_list
, "apply ", 1, &thread_cmd_list
);
715 add_cmd ("all", class_run
, thread_apply_all_command
,
716 "Apply a command to all threads.",
720 add_com_alias ("t", "thread", class_run
, 1);