Merge GDB 7.5.1

gdb/thread.c

 /* Multi-process/thread control for GDB, the GNU debugger.
 
    Copyright (C) 1986-1988, 1993-2004, 2007-2012 Free Software
    Foundation, Inc.
 
    Contributed by Lynx Real-Time Systems, Inc.  Los Gatos, CA.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
@@ skipping 36 matching lines @@
 #include "continuations.h"
 
 /* Definition of struct thread_info exported to gdbthread.h.  */
 
 /* Prototypes for exported functions.  */
 
 void _initialize_thread (void);
 
 /* Prototypes for local functions.  */
 
-static struct thread_info *thread_list = NULL;
+struct thread_info *thread_list = NULL;
 static int highest_thread_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 (ptid_t);
 static void prune_threads (void);
 
@@ skipping 38 matching lines @@
       tp->control.step_resume_breakpoint = NULL;
     }
 
   if (tp->control.exception_resume_breakpoint)
     {
       tp->control.exception_resume_breakpoint->disposition
         = disp_del_at_next_stop;
       tp->control.exception_resume_breakpoint = NULL;
     }
 
+  delete_longjmp_breakpoint_at_next_stop (tp->num);
+
   bpstat_clear (&tp->control.stop_bpstat);
 
   do_all_intermediate_continuations_thread (tp, 1);
   do_all_continuations_thread (tp, 1);
-
-  delete_longjmp_breakpoint (tp->num);
 }
 
 static void
 free_thread (struct thread_info *tp)
 {
   if (tp->private)
     {
       if (tp->private_dtor)
         tp->private_dtor (tp->private);
       else
@@ skipping 933 matching lines @@
     }
 }
 
 struct current_thread_cleanup
 {
   ptid_t inferior_ptid;
   struct frame_id selected_frame_id;
   int selected_frame_level;
   int was_stopped;
   int inf_id;
+  int was_removable;
 };
 
 static void
 do_restore_current_thread_cleanup (void *arg)
 {
   struct thread_info *tp;
   struct current_thread_cleanup *old = arg;
 
   tp = find_thread_ptid (old->inferior_ptid);
 
@@ skipping 20 matching lines @@
       && target_has_memory)
     restore_selected_frame (old->selected_frame_id,
                             old->selected_frame_level);
 }
 
 static void
 restore_current_thread_cleanup_dtor (void *arg)
 {
   struct current_thread_cleanup *old = arg;
   struct thread_info *tp;
+  struct inferior *inf;
 
   tp = find_thread_ptid (old->inferior_ptid);
   if (tp)
     tp->refcount--;
+  inf = find_inferior_id (old->inf_id);
+  if (inf != NULL)
+    inf->removable = old->was_removable;
   xfree (old);
 }
 
 struct cleanup *
 make_cleanup_restore_current_thread (void)
 {
   struct thread_info *tp;
   struct frame_info *frame;
   struct current_thread_cleanup *old;
 
   old = xmalloc (sizeof (struct current_thread_cleanup));
   old->inferior_ptid = inferior_ptid;
   old->inf_id = current_inferior ()->num;
+  old->was_removable = current_inferior ()->removable;
 
   if (!ptid_equal (inferior_ptid, null_ptid))
     {
       old->was_stopped = is_stopped (inferior_ptid);
       if (old->was_stopped
           && target_has_registers
           && target_has_stack
           && target_has_memory)
         {
           /* When processing internal events, there might not be a
              selected frame.  If we naively call get_selected_frame
              here, then we can end up reading debuginfo for the
              current frame, but we don't generally need the debuginfo
              at this point.  */
           frame = get_selected_frame_if_set ();
         }
       else
         frame = NULL;
 
       old->selected_frame_id = get_frame_id (frame);
       old->selected_frame_level = frame_relative_level (frame);
 
       tp = find_thread_ptid (inferior_ptid);
       if (tp)
         tp->refcount++;
     }
 
+  current_inferior ()->removable = 0;
+
   return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
                             restore_current_thread_cleanup_dtor);
 }
 
 /* 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:
 
    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
@@ skipping 255 matching lines @@
 update_thread_list (void)
 {
   prune_threads ();
   target_find_new_threads ();
 }
 
 /* Return a new value for the selected thread's id.  Return a value of 0 if
    no thread is selected, or no threads exist.  */
 
 static struct value *
-thread_id_make_value (struct gdbarch *gdbarch, struct internalvar *var)
+thread_id_make_value (struct gdbarch *gdbarch, struct internalvar *var,
+                      void *ignore)
 {
   struct thread_info *tp = find_thread_ptid (inferior_ptid);
 
   return value_from_longest (builtin_type (gdbarch)->builtin_int,
                              (tp ? tp->num : 0));
 }
 
 /* Commands with a prefix of `thread'.  */
 struct cmd_list_element *thread_cmd_list = NULL;
 
+/* Implementation of `thread' variable.  */
+
+static const struct internalvar_funcs thread_funcs =
+{
+  thread_id_make_value,
+  NULL,
+  NULL
+};
+
 void
 _initialize_thread (void)
 {
   static struct cmd_list_element *thread_apply_list = NULL;
 
   add_info ("threads", info_threads_command, 
             _("Display currently known threads.\n\
 Usage: info threads [ID]...\n\
 Optional arguments are thread IDs with spaces between.\n\
 If no arguments, all threads are displayed."));
@@ skipping 25 matching lines @@
     add_com_alias ("t", "thread", class_run, 1);
 
   add_setshow_boolean_cmd ("thread-events", no_class,
          &print_thread_events, _("\
 Set printing of thread events (such as thread start and exit)."), _("\
 Show printing of thread events (such as thread start and exit)."), NULL,
          NULL,
          show_print_thread_events,
          &setprintlist, &showprintlist);
 
-  create_internalvar_type_lazy ("_thread", thread_id_make_value);
+  create_internalvar_type_lazy ("_thread", &thread_funcs, NULL);
 }