gdb/thread.c

   1 /* Multi-process/thread control for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1988, 1993, 1998
   3
   4    Contributed by Lynx Real-Time Systems, Inc.  Los Gatos, CA.
   5    Free Software Foundation, Inc.
   6
   7 This file is part of GDB.
   8
   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.
  13
  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.
  18
  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.  */
  22
  23 #include "defs.h"
  24 #include "symtab.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "environ.h"
  28 #include "value.h"
  29 #include "target.h"
  30 #include "gdbthread.h"
  31 #include "command.h"
  32 #include "gdbcmd.h"
  33
  34 #include <ctype.h>
  35 #include <sys/types.h>
  36 #include <signal.h>
  37
  38 /*#include "lynxos-core.h"*/
  39
  40 struct thread_info
  41 {
  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;
  47   char *prev_func_name;
  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;
  53   int trap_expected;
  54   int handling_longjmp;
  55   int another_trap;
  56
  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.
  61      */
  62   int  stepping_through_solib_after_catch;
  63
  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.
  67      */
  68   bpstat  stepping_through_solib_catchpoints;
  69
  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;
  73
  74 };
  75
  76 /* Prototypes for exported functions. */
  77
  78 void _initialize_thread PARAMS ((void));
  79
  80 /* Prototypes for local functions. */
  81
  82 #if !defined(FIND_NEW_THREADS)
  83 #define FIND_NEW_THREADS local_find_new_threads
  84 #endif
  85
  86 static struct thread_info *thread_list = NULL;
  87 static int highest_thread_num;
  88
  89 static struct thread_info * find_thread_id PARAMS ((int num));
  90
  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));
  99
 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 */
 104
 105 static struct target_thread_vector *target_thread_functions;
 106
 107 static int
 108 local_find_new_threads ()
 109 {
 110   int retval = 0;
 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 */
 115 }
 116
 117
 118 int
 119 target_get_thread_info PARAMS ((gdb_threadref * ref,
 120                                 int selection,          /* FIXME: Selection */
 121                                 struct gdb_ext_thread_info * info));
 122
 123 int
 124 target_get_thread_info (ref, selection, info)
 125
 126      gdb_threadref *ref;
 127      int selection;
 128     /* FIXME: Selection */
 129      struct gdb_ext_thread_info *info;
 130
 131 {
 132   int retval = 0;
 133   if (target_thread_functions
 134       && target_thread_functions->get_thread_info)
 135     retval = (*(target_thread_functions->get_thread_info)) (ref, selection, info);
 136   return retval;
 137 }
 138
 139
 140 /* It is possible that these bind and unbinf functions implement a
 141    stack the interface allows it, but its not implemented that way
 142  */
 143
 144
 145 void
 146 bind_target_thread_vector (vec)
 147      struct target_thread_vector *vec;
 148 {
 149   target_thread_functions = vec;
 150 }
 151
 152 struct target_thread_vector *
 153 unbind_target_thread_vector ()
 154 {
 155   struct target_thread_vector *retval;
 156   retval = target_thread_functions;
 157   target_thread_functions = 0;
 158   return retval;
 159 }                               /* unbind_target_thread-vector */
 160
 161 void
 162 init_thread_list ()
 163 {
 164   struct thread_info *tp, *tpnext;
 165
 166   if (!thread_list)
 167     return;
 168
 169   for (tp = thread_list; tp; tp = tpnext)
 170     {
 171       tpnext = tp->next;
 172       free (tp);
 173     }
 174
 175   thread_list = NULL;
 176   highest_thread_num = 0;
 177 }
 178
 179 void
 180 add_thread (pid)
 181      int pid;
 182 {
 183   struct thread_info *tp;
 184
 185   tp = (struct thread_info *) xmalloc (sizeof (struct thread_info));
 186
 187   tp->pid = pid;
 188   tp->num = ++highest_thread_num;
 189   tp->prev_pc = 0;
 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;
 204   thread_list = tp;
 205 }
 206
 207 void
 208 delete_thread (pid)
 209      int pid;
 210 {
 211   struct thread_info *tp, *tpprev;
 212
 213   tpprev = NULL;
 214
 215   for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
 216     if (tp->pid == pid)
 217       break;
 218
 219   if (!tp)
 220     return;
 221
 222   if (tpprev)
 223     tpprev->next = tp->next;
 224   else
 225     thread_list = tp->next;
 226
 227   free (tp);
 228
 229   return;
 230 }
 231
 232 static struct thread_info *
 233 find_thread_id (num)
 234     int num;
 235 {
 236   struct thread_info *tp;
 237
 238   for (tp = thread_list; tp; tp = tp->next)
 239     if (tp->num == num)
 240       return tp;
 241
 242   return NULL;
 243 }
 244
 245 int
 246 valid_thread_id (num)
 247     int num;
 248 {
 249   struct thread_info *tp;
 250
 251   for (tp = thread_list; tp; tp = tp->next)
 252     if (tp->num == num)
 253       return 1;
 254
 255   return 0;
 256 }
 257
 258 int
 259 pid_to_thread_id (pid)
 260     int pid;
 261 {
 262   struct thread_info *tp;
 263
 264   for (tp = thread_list; tp; tp = tp->next)
 265     if (tp->pid == pid)
 266       return tp->num;
 267
 268   return 0;
 269 }
 270
 271 int
 272 thread_id_to_pid (num)
 273     int num;
 274 {
 275   struct thread_info *thread = find_thread_id (num);
 276   if (thread)
 277     return thread->pid;
 278   else
 279     return -1;
 280 }
 281
 282 int
 283 in_thread_list (pid)
 284     int pid;
 285 {
 286   struct thread_info *tp;
 287
 288   for (tp = thread_list; tp; tp = tp->next)
 289     if (tp->pid == pid)
 290       return 1;
 291
 292   return 0;                     /* Never heard of 'im */
 293 }
 294
 295 /* Load infrun state for the thread PID.  */
 296
 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)
 305      int pid;
 306      CORE_ADDR *prev_pc;
 307      CORE_ADDR *prev_func_start;
 308      char **prev_func_name;
 309      int *trap_expected;
 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;
 316      int *another_trap;
 317      int *  stepping_through_solib_after_catch;
 318      bpstat *  stepping_through_solib_catchpoints;
 319      int *  stepping_through_sigtramp;
 320 {
 321   struct thread_info *tp;
 322
 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));
 326   if (tp == NULL)
 327     return;
 328
 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;
 343 }
 344
 345 /* Save infrun state for the thread PID.  */
 346
 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)
 355      int pid;
 356      CORE_ADDR prev_pc;
 357      CORE_ADDR prev_func_start;
 358      char *prev_func_name;
 359      int trap_expected;
 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;
 366      int another_trap;
 367      int  stepping_through_solib_after_catch;
 368      bpstat  stepping_through_solib_catchpoints;
 369      int  stepping_through_sigtramp;
 370 {
 371   struct thread_info *tp;
 372
 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));
 376   if (tp == NULL)
 377     return;
 378
 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;
 393 }
 394
 395 /* Return true if TP is an active thread. */
 396 static int
 397 thread_alive (tp)
 398      struct thread_info *tp;
 399 {
 400   if (tp->pid == -1)
 401     return 0;
 402   if (! target_thread_alive (tp->pid))
 403     {
 404       tp->pid = -1;     /* Mark it as dead */
 405       return 0;
 406     }
 407   return 1;
 408 }
 409
 410 static void
 411 prune_threads ()
 412 {
 413   struct thread_info *tp, *tpprev, *next;
 414
 415   tpprev = 0;
 416   for (tp = thread_list; tp; tp = next)
 417     {
 418       next = tp->next;
 419       if (!thread_alive (tp))
 420         {
 421           if (tpprev)
 422             tpprev->next = next;
 423           else
 424             thread_list  = next;
 425           free (tp);
 426         }
 427       else
 428         tpprev = tp;
 429     }
 430 }
 431
 432 /* Print information about currently known threads
 433  *
 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.
 437  */
 438
 439 static void
 440 info_threads_command (arg, from_tty)
 441      char *arg;
 442      int from_tty;
 443 {
 444   struct thread_info *tp;
 445   int                current_pid;
 446   struct frame_info  *cur_frame;
 447   int                saved_frame_level = selected_frame_level;
 448   int                counter;
 449
 450   /* Avoid coredumps which would happen if we tried to access a NULL
 451      selected_frame.  */
 452   if (!target_has_stack) error ("No stack.");
 453
 454   prune_threads ();
 455   target_find_new_threads ();
 456   current_pid = inferior_pid;
 457   for (tp = thread_list; tp; tp = tp->next)
 458     {
 459       if (tp->pid == current_pid)
 460         printf_filtered ("* ");
 461       else
 462         printf_filtered ("  ");
 463
 464 #ifdef HPUXHPPA
 465       printf_filtered ("%d %s  ", tp->num, target_tid_to_str (tp->pid));
 466 #else
 467       printf_filtered ("%d %s  ", tp->num, target_pid_to_str (tp->pid));
 468 #endif
 469       switch_to_thread (tp->pid);
 470       if (selected_frame)
 471         print_only_stack_frame (selected_frame, -1, 0);
 472       else
 473         printf_filtered ("[No stack.]\n");
 474     }
 475
 476   switch_to_thread (current_pid);
 477
 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).
 483    */
 484   counter   = saved_frame_level;
 485   cur_frame = find_relative_frame(selected_frame, &counter);
 486   if (counter != 0)
 487     {
 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);
 491     }
 492   else
 493     {
 494       select_frame(cur_frame, saved_frame_level);
 495     }
 496
 497   /* re-show current frame. */
 498   show_stack_frame(cur_frame);
 499 }
 500
 501 /* Switch from one thread to another. */
 502
 503 static void
 504 switch_to_thread (pid)
 505      int pid;
 506 {
 507   if (pid == inferior_pid)
 508     return;
 509
 510   inferior_pid = pid;
 511   flush_cached_frames ();
 512   registers_changed ();
 513   stop_pc = read_pc();
 514   select_frame (get_current_frame (), 0);
 515 }
 516
 517 static void
 518 restore_current_thread (pid)
 519      int pid;
 520 {
 521   if (pid != inferior_pid)
 522     {
 523       switch_to_thread (pid);
 524       print_stack_frame( get_current_frame(), 0, -1);
 525     }
 526 }
 527
 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:
 531
 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
 535 */
 536
 537 static void
 538 thread_apply_all_command (cmd, from_tty)
 539      char *cmd;
 540      int from_tty;
 541 {
 542   struct thread_info *tp;
 543   struct cleanup *old_chain;
 544
 545   if (cmd == NULL || *cmd == '\000')
 546     error ("Please specify a command following the thread ID list");
 547
 548   old_chain = make_cleanup ((make_cleanup_func) restore_current_thread,
 549                             (void *) inferior_pid);
 550
 551   for (tp = thread_list; tp; tp = tp->next)
 552     if (thread_alive (tp))
 553       {
 554         switch_to_thread (tp->pid);
 555 #ifdef HPUXHPPA
 556         printf_filtered ("\nThread %d (%s):\n",
 557                          tp->num,
 558                          target_tid_to_str (inferior_pid));
 559 #else
 560         printf_filtered ("\nThread %d (%s):\n", tp->num,
 561                          target_pid_to_str (inferior_pid));
 562 #endif
 563         execute_command (cmd, from_tty);
 564       }
 565 }
 566
 567 static void
 568 thread_apply_command (tidlist, from_tty)
 569      char *tidlist;
 570      int from_tty;
 571 {
 572   char *cmd;
 573   char *p;
 574   struct cleanup *old_chain;
 575
 576   if (tidlist == NULL || *tidlist == '\000')
 577     error ("Please specify a thread ID list");
 578
 579   for (cmd = tidlist; *cmd != '\000' && !isalpha(*cmd); cmd++);
 580
 581   if (*cmd == '\000')
 582     error ("Please specify a command following the thread ID list");
 583
 584   old_chain = make_cleanup ((make_cleanup_func) restore_current_thread,
 585                             (void *) inferior_pid);
 586
 587   while (tidlist < cmd)
 588     {
 589       struct thread_info *tp;
 590       int start, end;
 591
 592       start = strtol (tidlist, &p, 10);
 593       if (p == tidlist)
 594         error ("Error parsing %s", tidlist);
 595       tidlist = p;
 596
 597       while (*tidlist == ' ' || *tidlist == '\t')
 598         tidlist++;
 599
 600       if (*tidlist == '-')      /* Got a range of IDs? */
 601         {
 602           tidlist++;    /* Skip the - */
 603           end = strtol (tidlist, &p, 10);
 604           if (p == tidlist)
 605             error ("Error parsing %s", tidlist);
 606           tidlist = p;
 607
 608           while (*tidlist == ' ' || *tidlist == '\t')
 609             tidlist++;
 610         }
 611       else
 612         end = start;
 613
 614       for (; start <= end; start++)
 615         {
 616           tp = find_thread_id (start);
 617
 618           if (!tp)
 619             warning ("Unknown thread %d.", start);
 620           else if (!thread_alive (tp))
 621             warning ("Thread %d has terminated.", start);
 622           else
 623             {
 624               switch_to_thread (tp->pid);
 625 #ifdef HPUXHPPA
 626               printf_filtered ("\nThread %d (%s):\n", tp->num,
 627                                target_tid_to_str (inferior_pid));
 628 #else
 629               printf_filtered ("\nThread %d (%s):\n", tp->num,
 630                                target_pid_to_str (inferior_pid));
 631 #endif
 632               execute_command (cmd, from_tty);
 633             }
 634         }
 635     }
 636 }
 637
 638 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
 639    if prefix of arg is `apply'.  */
 640
 641 static void
 642 thread_command (tidstr, from_tty)
 643      char *tidstr;
 644      int from_tty;
 645 {
 646   int num;
 647   struct thread_info *tp;
 648
 649   if (!tidstr)
 650     {
 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)
 657 #else
 658                          target_pid_to_str(inferior_pid)
 659 #endif
 660                          );
 661       else
 662         error ("No stack.");
 663       return;
 664     }
 665   num = atoi (tidstr);
 666
 667   tp = find_thread_id (num);
 668
 669   if (!tp)
 670     error ("Thread ID %d not known.  Use the \"info threads\" command to\n\
 671 see the IDs of currently known threads.", num);
 672
 673   if (!thread_alive (tp))
 674     error ("Thread ID %d has terminated.\n", num);
 675
 676   switch_to_thread (tp->pid);
 677
 678   if (context_hook)
 679     context_hook (num);
 680
 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)
 685 #else
 686                    target_pid_to_str (inferior_pid)
 687 #endif
 688                    );
 689   print_stack_frame (selected_frame, selected_frame_level, 1);
 690 }
 691
 692 /* Commands with a prefix of `thread'.  */
 693 struct cmd_list_element *thread_cmd_list = NULL;
 694
 695 void
 696 _initialize_thread ()
 697 {
 698   static struct cmd_list_element *thread_apply_list = NULL;
 699
 700   add_info ("threads", info_threads_command,
 701             "IDs of currently known threads.");
 702
 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,
 706                   &cmdlist);
 707
 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);
 711
 712   add_cmd ("all", class_run, thread_apply_all_command,
 713            "Apply a command to all threads.",
 714            &thread_apply_list);
 715
 716   if (!xdb_commands)
 717     add_com_alias ("t", "thread", class_run, 1);
 718 }