X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fthread.c;h=647976c5719694ac2905999c2b345d8a8f90ab76;hb=5dbd90485c7ad1c93344d96ae381b25430467433;hp=4a2070b702787b8f4eee537a132f515e8646e3a8;hpb=53a5351d907ef4eacd463a48a86d35b2b70b9f60;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/thread.c b/gdb/thread.c index 4a2070b702..647976c571 100644 --- a/gdb/thread.c +++ b/gdb/thread.c @@ -1,5 +1,5 @@ /* Multi-process/thread control for GDB, the GNU debugger. - Copyright 1986, 1987, 1988, 1993, 1998 + Copyright 1986, 1987, 1988, 1993, 1998, 1999, 2000 Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA. Free Software Foundation, Inc. @@ -35,86 +35,73 @@ #include #include #include +#ifdef UI_OUT +#include "ui-out.h" +#endif /*#include "lynxos-core.h" */ -struct thread_info - { - struct thread_info *next; - int pid; /* Actual process id */ - int num; /* Convenient handle */ - CORE_ADDR prev_pc; /* State from wait_for_inferior */ - CORE_ADDR prev_func_start; - char *prev_func_name; - struct breakpoint *step_resume_breakpoint; - struct breakpoint *through_sigtramp_breakpoint; - CORE_ADDR step_range_start; - CORE_ADDR step_range_end; - CORE_ADDR step_frame_address; - int trap_expected; - int handling_longjmp; - int another_trap; - - /* This is set TRUE when a catchpoint of a shared library event - triggers. Since we don't wish to leave the inferior in the - solib hook when we report the event, we step the inferior - back to user code before stopping and reporting the event. - */ - int stepping_through_solib_after_catch; - - /* When stepping_through_solib_after_catch is TRUE, this is a - list of the catchpoints that should be reported as triggering - when we finally do stop stepping. - */ - bpstat stepping_through_solib_catchpoints; - - /* This is set to TRUE when this thread is in a signal handler - trampoline and we're single-stepping through it */ - int stepping_through_sigtramp; - - }; +/* Definition of struct thread_info exported to gdbthread.h */ /* Prototypes for exported functions. */ -void _initialize_thread PARAMS ((void)); +void _initialize_thread (void); /* Prototypes for local functions. */ static struct thread_info *thread_list = NULL; static int highest_thread_num; -static struct thread_info *find_thread_id PARAMS ((int num)); +static struct thread_info *find_thread_id (int num); + +static void thread_command (char *tidstr, int from_tty); +static void thread_apply_all_command (char *, int); +static int thread_alive (struct thread_info *); +static void info_threads_command (char *, int); +static void thread_apply_command (char *, int); +static void restore_current_thread (int); +static void switch_to_thread (int pid); +static void prune_threads (void); + +static void +free_thread (struct thread_info *tp) +{ + /* NOTE: this will take care of any left-over step_resume breakpoints, + but not any user-specified thread-specific breakpoints. */ + if (tp->step_resume_breakpoint) + delete_breakpoint (tp->step_resume_breakpoint); + + /* FIXME: do I ever need to call the back-end to give it a + chance at this private data before deleting the thread? */ + if (tp->private) + xfree (tp->private); -static void thread_command PARAMS ((char *tidstr, int from_tty)); -static void thread_apply_all_command PARAMS ((char *, int)); -static int thread_alive PARAMS ((struct thread_info *)); -static void info_threads_command PARAMS ((char *, int)); -static void thread_apply_command PARAMS ((char *, int)); -static void restore_current_thread PARAMS ((int)); -static void switch_to_thread PARAMS ((int pid)); -static void prune_threads PARAMS ((void)); + xfree (tp); +} void -init_thread_list () +init_thread_list (void) { struct thread_info *tp, *tpnext; + highest_thread_num = 0; if (!thread_list) return; for (tp = thread_list; tp; tp = tpnext) { tpnext = tp->next; - free (tp); + free_thread (tp); } thread_list = NULL; - highest_thread_num = 0; } -void -add_thread (pid) - int pid; +/* add_thread now returns a pointer to the new thread_info, + so that back_ends can initialize their private data. */ + +struct thread_info * +add_thread (int pid) { struct thread_info *tp; @@ -137,12 +124,13 @@ add_thread (pid) tp->stepping_through_solib_catchpoints = NULL; tp->stepping_through_sigtramp = 0; tp->next = thread_list; + tp->private = NULL; thread_list = tp; + return tp; } void -delete_thread (pid) - int pid; +delete_thread (int pid) { struct thread_info *tp, *tpprev; @@ -160,19 +148,11 @@ delete_thread (pid) else thread_list = tp->next; - /* NOTE: this will take care of any left-over step_resume breakpoints, - but not any user-specified thread-specific breakpoints. */ - if (tp->step_resume_breakpoint) - delete_breakpoint (tp->step_resume_breakpoint); - - free (tp); - - return; + free_thread (tp); } static struct thread_info * -find_thread_id (num) - int num; +find_thread_id (int num) { struct thread_info *tp; @@ -183,9 +163,48 @@ find_thread_id (num) return NULL; } +/* Find a thread_info by matching 'pid'. */ +struct thread_info * +find_thread_pid (int pid) +{ + struct thread_info *tp; + + for (tp = thread_list; tp; tp = tp->next) + if (tp->pid == pid) + return tp; + + return NULL; +} + +/* + * Thread iterator function. + * + * Calls a callback function once for each thread, so long as + * the callback function returns false. If the callback function + * returns true, the iteration will end and the current thread + * will be returned. This can be useful for implementing a + * search for a thread with arbitrary attributes, or for applying + * some operation to every thread. + * + * FIXME: some of the existing functionality, such as + * "Thread apply all", might be rewritten using this functionality. + */ + +struct thread_info * +iterate_over_threads (int (*callback) (struct thread_info *, void *), + void *data) +{ + struct thread_info *tp; + + for (tp = thread_list; tp; tp = tp->next) + if ((*callback) (tp, data)) + return tp; + + return NULL; +} + int -valid_thread_id (num) - int num; +valid_thread_id (int num) { struct thread_info *tp; @@ -197,8 +216,7 @@ valid_thread_id (num) } int -pid_to_thread_id (pid) - int pid; +pid_to_thread_id (int pid) { struct thread_info *tp; @@ -210,8 +228,7 @@ pid_to_thread_id (pid) } int -thread_id_to_pid (num) - int num; +thread_id_to_pid (int num) { struct thread_info *thread = find_thread_id (num); if (thread) @@ -221,8 +238,7 @@ thread_id_to_pid (num) } int -in_thread_list (pid) - int pid; +in_thread_list (int pid) { struct thread_info *tp; @@ -232,33 +248,50 @@ in_thread_list (pid) return 0; /* Never heard of 'im */ } +#ifdef UI_OUT +/* Print a list of thread ids currently known, and the total number of + threads. To be used from within catch_errors. */ +static int +do_captured_list_thread_ids (void *arg) +{ + struct thread_info *tp; + int num = 0; + + ui_out_list_begin (uiout, "thread-ids"); + + for (tp = thread_list; tp; tp = tp->next) + { + num++; + ui_out_field_int (uiout, "thread-id", tp->num); + } + + ui_out_list_end (uiout); + ui_out_field_int (uiout, "number-of-threads", num); + return GDB_RC_OK; +} + +/* Official gdblib interface function to get a list of thread ids and + the total number. */ +enum gdb_rc +gdb_list_thread_ids (/* output object */) +{ + return catch_errors (do_captured_list_thread_ids, NULL, + NULL, RETURN_MASK_ALL); +} +#endif /* Load infrun state for the thread PID. */ void -load_infrun_state (pid, prev_pc, prev_func_start, prev_func_name, - trap_expected, step_resume_breakpoint, - through_sigtramp_breakpoint, step_range_start, - step_range_end, step_frame_address, - handling_longjmp, another_trap, - stepping_through_solib_after_catch, - stepping_through_solib_catchpoints, - stepping_through_sigtramp) - int pid; - CORE_ADDR *prev_pc; - CORE_ADDR *prev_func_start; - char **prev_func_name; - int *trap_expected; - struct breakpoint **step_resume_breakpoint; - struct breakpoint **through_sigtramp_breakpoint; - CORE_ADDR *step_range_start; - CORE_ADDR *step_range_end; - CORE_ADDR *step_frame_address; - int *handling_longjmp; - int *another_trap; - int *stepping_through_solib_after_catch; - bpstat *stepping_through_solib_catchpoints; - int *stepping_through_sigtramp; +load_infrun_state (int pid, CORE_ADDR *prev_pc, CORE_ADDR *prev_func_start, + char **prev_func_name, int *trap_expected, + struct breakpoint **step_resume_breakpoint, + struct breakpoint **through_sigtramp_breakpoint, + CORE_ADDR *step_range_start, CORE_ADDR *step_range_end, + CORE_ADDR *step_frame_address, int *handling_longjmp, + int *another_trap, int *stepping_through_solib_after_catch, + bpstat *stepping_through_solib_catchpoints, + int *stepping_through_sigtramp) { struct thread_info *tp; @@ -287,29 +320,15 @@ load_infrun_state (pid, prev_pc, prev_func_start, prev_func_name, /* Save infrun state for the thread PID. */ void -save_infrun_state (pid, prev_pc, prev_func_start, prev_func_name, - trap_expected, step_resume_breakpoint, - through_sigtramp_breakpoint, step_range_start, - step_range_end, step_frame_address, - handling_longjmp, another_trap, - stepping_through_solib_after_catch, - stepping_through_solib_catchpoints, - stepping_through_sigtramp) - int pid; - CORE_ADDR prev_pc; - CORE_ADDR prev_func_start; - char *prev_func_name; - int trap_expected; - struct breakpoint *step_resume_breakpoint; - struct breakpoint *through_sigtramp_breakpoint; - CORE_ADDR step_range_start; - CORE_ADDR step_range_end; - CORE_ADDR step_frame_address; - int handling_longjmp; - int another_trap; - int stepping_through_solib_after_catch; - bpstat stepping_through_solib_catchpoints; - int stepping_through_sigtramp; +save_infrun_state (int pid, CORE_ADDR prev_pc, CORE_ADDR prev_func_start, + char *prev_func_name, int trap_expected, + struct breakpoint *step_resume_breakpoint, + struct breakpoint *through_sigtramp_breakpoint, + CORE_ADDR step_range_start, CORE_ADDR step_range_end, + CORE_ADDR step_frame_address, int handling_longjmp, + int another_trap, int stepping_through_solib_after_catch, + bpstat stepping_through_solib_catchpoints, + int stepping_through_sigtramp) { struct thread_info *tp; @@ -337,8 +356,7 @@ save_infrun_state (pid, prev_pc, prev_func_start, prev_func_name, /* Return true if TP is an active thread. */ static int -thread_alive (tp) - struct thread_info *tp; +thread_alive (struct thread_info *tp) { if (tp->pid == -1) return 0; @@ -351,9 +369,9 @@ thread_alive (tp) } static void -prune_threads () +prune_threads (void) { - struct thread_info *tp, *tpprev, *next; + struct thread_info *tp, *next; for (tp = thread_list; tp; tp = next) { @@ -371,15 +389,14 @@ prune_threads () */ static void -info_threads_command (arg, from_tty) - char *arg; - int from_tty; +info_threads_command (char *arg, int from_tty) { struct thread_info *tp; int current_pid; struct frame_info *cur_frame; int saved_frame_level = selected_frame_level; int counter; + char *extra_info; /* Avoid coredumps which would happen if we tried to access a NULL selected_frame. */ @@ -397,10 +414,16 @@ info_threads_command (arg, from_tty) printf_filtered (" "); #ifdef HPUXHPPA - printf_filtered ("%d %s ", tp->num, target_tid_to_str (tp->pid)); + printf_filtered ("%d %s", tp->num, target_tid_to_str (tp->pid)); #else - printf_filtered ("%d %s ", tp->num, target_pid_to_str (tp->pid)); + printf_filtered ("%d %s", tp->num, target_pid_to_str (tp->pid)); #endif + + extra_info = target_extra_thread_info (tp); + if (extra_info) + printf_filtered (" (%s)", extra_info); + puts_filtered (" "); + switch_to_thread (tp->pid); if (selected_frame) print_only_stack_frame (selected_frame, -1, 0); @@ -436,8 +459,7 @@ info_threads_command (arg, from_tty) /* Switch from one thread to another. */ static void -switch_to_thread (pid) - int pid; +switch_to_thread (int pid) { if (pid == inferior_pid) return; @@ -450,8 +472,7 @@ switch_to_thread (pid) } static void -restore_current_thread (pid) - int pid; +restore_current_thread (int pid) { if (pid != inferior_pid) { @@ -460,6 +481,28 @@ restore_current_thread (pid) } } +struct current_thread_cleanup +{ + int inferior_pid; +}; + +static void +do_restore_current_thread_cleanup (void *arg) +{ + struct current_thread_cleanup *old = arg; + restore_current_thread (old->inferior_pid); + xfree (old); +} + +static struct cleanup * +make_cleanup_restore_current_thread (int inferior_pid) +{ + struct current_thread_cleanup *old + = xmalloc (sizeof (struct current_thread_cleanup)); + old->inferior_pid = inferior_pid; + return make_cleanup (do_restore_current_thread_cleanup, old); +} + /* Apply a GDB command to a list of threads. List syntax is a whitespace seperated list of numbers, or ranges, or the keyword `all'. Ranges consist of two numbers seperated by a hyphen. Examples: @@ -470,19 +513,26 @@ restore_current_thread (pid) */ static void -thread_apply_all_command (cmd, from_tty) - char *cmd; - int from_tty; +thread_apply_all_command (char *cmd, int from_tty) { struct thread_info *tp; struct cleanup *old_chain; + struct cleanup *saved_cmd_cleanup_chain; + char *saved_cmd; if (cmd == NULL || *cmd == '\000') error ("Please specify a command following the thread ID list"); - old_chain = make_cleanup ((make_cleanup_func) restore_current_thread, - (void *) inferior_pid); + old_chain = make_cleanup_restore_current_thread (inferior_pid); + /* It is safe to update the thread list now, before + traversing it for "thread apply all". MVS */ + target_find_new_threads (); + + /* Save a copy of the command in case it is clobbered by + execute_command */ + saved_cmd = strdup (cmd); + saved_cmd_cleanup_chain = make_cleanup (xfree, (void *) saved_cmd); for (tp = thread_list; tp; tp = tp->next) if (thread_alive (tp)) { @@ -496,17 +546,21 @@ thread_apply_all_command (cmd, from_tty) target_pid_to_str (inferior_pid)); #endif execute_command (cmd, from_tty); + strcpy (cmd, saved_cmd); /* Restore exact command used previously */ } + + do_cleanups (saved_cmd_cleanup_chain); + do_cleanups (old_chain); } static void -thread_apply_command (tidlist, from_tty) - char *tidlist; - int from_tty; +thread_apply_command (char *tidlist, int from_tty) { char *cmd; char *p; struct cleanup *old_chain; + struct cleanup *saved_cmd_cleanup_chain; + char *saved_cmd; if (tidlist == NULL || *tidlist == '\000') error ("Please specify a thread ID list"); @@ -516,9 +570,12 @@ thread_apply_command (tidlist, from_tty) if (*cmd == '\000') error ("Please specify a command following the thread ID list"); - old_chain = make_cleanup ((make_cleanup_func) restore_current_thread, - (void *) inferior_pid); + old_chain = make_cleanup_restore_current_thread (inferior_pid); + /* Save a copy of the command in case it is clobbered by + execute_command */ + saved_cmd = strdup (cmd); + saved_cmd_cleanup_chain = make_cleanup (xfree, (void *) saved_cmd); while (tidlist < cmd) { struct thread_info *tp; @@ -565,22 +622,21 @@ thread_apply_command (tidlist, from_tty) target_pid_to_str (inferior_pid)); #endif execute_command (cmd, from_tty); + strcpy (cmd, saved_cmd); /* Restore exact command used previously */ } } } + + do_cleanups (saved_cmd_cleanup_chain); + do_cleanups (old_chain); } /* Switch to the specified thread. Will dispatch off to thread_apply_command if prefix of arg is `apply'. */ static void -thread_command (tidstr, from_tty) - char *tidstr; - int from_tty; +thread_command (char *tidstr, int from_tty) { - int num; - struct thread_info *tp; - if (!tidstr) { /* Don't generate an error, just say which thread is current. */ @@ -597,22 +653,45 @@ thread_command (tidstr, from_tty) error ("No stack."); return; } - num = atoi (tidstr); + + gdb_thread_select (tidstr); +} + +static int +do_captured_thread_select (void *tidstr) +{ + int num; + struct thread_info *tp; + + num = atoi ((char *)tidstr); tp = find_thread_id (num); +#ifdef UI_OUT + if (!tp) + error ("Thread ID %d not known.", num); +#else if (!tp) error ("Thread ID %d not known. Use the \"info threads\" command to\n\ see the IDs of currently known threads.", num); +#endif if (!thread_alive (tp)) error ("Thread ID %d has terminated.\n", num); switch_to_thread (tp->pid); - if (context_hook) - context_hook (num); - +#ifdef UI_OUT + ui_out_text (uiout, "[Switching to thread "); + ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_pid)); + ui_out_text (uiout, " ("); +#if defined(HPUXHPPA) + ui_out_text (uiout, target_tid_to_str (inferior_pid)); +#else + ui_out_text (uiout, target_pid_to_str (inferior_pid)); +#endif + ui_out_text (uiout, ")]"); +#else /* UI_OUT */ printf_filtered ("[Switching to thread %d (%s)]\n", pid_to_thread_id (inferior_pid), #if defined(HPUXHPPA) @@ -621,14 +700,24 @@ see the IDs of currently known threads.", num); target_pid_to_str (inferior_pid) #endif ); +#endif /* UI_OUT */ + print_stack_frame (selected_frame, selected_frame_level, 1); + return GDB_RC_OK; +} + +enum gdb_rc +gdb_thread_select (char *tidstr) +{ + return catch_errors (do_captured_thread_select, tidstr, + NULL, RETURN_MASK_ALL); } /* Commands with a prefix of `thread'. */ struct cmd_list_element *thread_cmd_list = NULL; void -_initialize_thread () +_initialize_thread (void) { static struct cmd_list_element *thread_apply_list = NULL;