X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fthread.c;h=8a0ed0c44e6e88848a0a61047f4d49204e20dcaa;hb=6c73f67f9c545425befde590f06d690a068a69e2;hp=88fd521a58ede3456395d5ea114e68e56049f427;hpb=c6609450b33960a0e9f8c1df045b02f0677e866a;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/thread.c b/gdb/thread.c
index 88fd521a58..8a0ed0c44e 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -68,7 +68,6 @@ 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);
 
 /* RAII type used to increase / decrease the refcount of each thread
    in a given list of threads.  */
@@ -719,26 +718,25 @@ do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
 {
   struct thread_info *tp;
   int num = 0;
-  struct cleanup *cleanup_chain;
   int current_thread = -1;
 
   update_thread_list ();
 
-  cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids");
-
-  for (tp = thread_list; tp; tp = tp->next)
-    {
-      if (tp->state == THREAD_EXITED)
-	continue;
+  {
+    ui_out_emit_tuple tuple_emitter (uiout, "thread-ids");
 
-      if (tp->ptid == inferior_ptid)
-	current_thread = tp->global_num;
+    for (tp = thread_list; tp; tp = tp->next)
+      {
+	if (tp->state == THREAD_EXITED)
+	  continue;
 
-      num++;
-      uiout->field_int ("thread-id", tp->global_num);
-    }
+	if (tp->ptid == inferior_ptid)
+	  current_thread = tp->global_num;
 
-  do_cleanups (cleanup_chain);
+	num++;
+	uiout->field_int ("thread-id", tp->global_num);
+      }
+  }
 
   if (current_thread != -1)
     uiout->field_int ("current-thread-id", current_thread);
@@ -1242,7 +1240,6 @@ print_thread_info_1 (struct ui_out *uiout, char *requested_threads,
 {
   struct thread_info *tp;
   ptid_t current_ptid;
-  struct cleanup *old_chain;
   const char *extra_info, *name, *target_id;
   struct inferior *inf;
   int default_inf_num = current_inferior ()->num;
@@ -1250,8 +1247,7 @@ print_thread_info_1 (struct ui_out *uiout, char *requested_threads,
   update_thread_list ();
   current_ptid = inferior_ptid;
 
-  /* We'll be switching threads temporarily.  */
-  old_chain = make_cleanup_restore_current_thread ();
+  struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
 
   /* For backward compatibility, we make a list for MI.  A table is
      preferable for the CLI, though, because it shows table
@@ -1298,109 +1294,101 @@ print_thread_info_1 (struct ui_out *uiout, char *requested_threads,
       uiout->table_body ();
     }
 
-  ALL_THREADS_BY_INFERIOR (inf, tp)
-    {
-      struct cleanup *chain2;
-      int core;
-
-      if (!should_print_thread (requested_threads, default_inf_num,
-				global_ids, pid, tp))
-	continue;
+  /* We'll be switching threads temporarily.  */
+  {
+    scoped_restore_current_thread restore_thread;
 
-      chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+    ALL_THREADS_BY_INFERIOR (inf, tp)
+      {
+	int core;
 
-      if (uiout->is_mi_like_p ())
-	{
-	  /* Compatibility.  */
-	  if (tp->ptid == current_ptid)
-	    uiout->text ("* ");
-	  else
-	    uiout->text ("  ");
-	}
-      else
-	{
-	  if (tp->ptid == current_ptid)
-	    uiout->field_string ("current", "*");
-	  else
-	    uiout->field_skip ("current");
-	}
+	if (!should_print_thread (requested_threads, default_inf_num,
+				  global_ids, pid, tp))
+	  continue;
 
-      if (!uiout->is_mi_like_p ())
-	uiout->field_string ("id-in-tg", print_thread_id (tp));
+	ui_out_emit_tuple tuple_emitter (uiout, NULL);
 
-      if (show_global_ids || uiout->is_mi_like_p ())
-	uiout->field_int ("id", tp->global_num);
+	if (!uiout->is_mi_like_p ())
+	  {
+	    if (tp->ptid == current_ptid)
+	      uiout->field_string ("current", "*");
+	    else
+	      uiout->field_skip ("current");
+	  }
 
-      /* For the CLI, we stuff everything into the target-id field.
-	 This is a gross hack to make the output come out looking
-	 correct.  The underlying problem here is that ui-out has no
-	 way to specify that a field's space allocation should be
-	 shared by several fields.  For MI, we do the right thing
-	 instead.  */
+	if (!uiout->is_mi_like_p ())
+	  uiout->field_string ("id-in-tg", print_thread_id (tp));
 
-      target_id = target_pid_to_str (tp->ptid);
-      extra_info = target_extra_thread_info (tp);
-      name = tp->name ? tp->name : target_thread_name (tp);
+	if (show_global_ids || uiout->is_mi_like_p ())
+	  uiout->field_int ("id", tp->global_num);
 
-      if (uiout->is_mi_like_p ())
-	{
-	  uiout->field_string ("target-id", target_id);
-	  if (extra_info)
-	    uiout->field_string ("details", extra_info);
-	  if (name)
-	    uiout->field_string ("name", name);
-	}
-      else
-	{
-	  struct cleanup *str_cleanup;
-	  char *contents;
-
-	  if (extra_info && name)
-	    contents = xstrprintf ("%s \"%s\" (%s)", target_id,
-				   name, extra_info);
-	  else if (extra_info)
-	    contents = xstrprintf ("%s (%s)", target_id, extra_info);
-	  else if (name)
-	    contents = xstrprintf ("%s \"%s\"", target_id, name);
-	  else
-	    contents = xstrdup (target_id);
-	  str_cleanup = make_cleanup (xfree, contents);
+	/* For the CLI, we stuff everything into the target-id field.
+	   This is a gross hack to make the output come out looking
+	   correct.  The underlying problem here is that ui-out has no
+	   way to specify that a field's space allocation should be
+	   shared by several fields.  For MI, we do the right thing
+	   instead.  */
 
-	  uiout->field_string ("target-id", contents);
-	  do_cleanups (str_cleanup);
-	}
+	target_id = target_pid_to_str (tp->ptid);
+	extra_info = target_extra_thread_info (tp);
+	name = tp->name ? tp->name : target_thread_name (tp);
 
-      if (tp->state == THREAD_RUNNING)
-	uiout->text ("(running)\n");
-      else
-	{
-	  /* The switch below puts us at the top of the stack (leaf
-	     frame).  */
-	  switch_to_thread (tp->ptid);
-	  print_stack_frame (get_selected_frame (NULL),
-			     /* For MI output, print frame level.  */
-			     uiout->is_mi_like_p (),
-			     LOCATION, 0);
-	}
+	if (uiout->is_mi_like_p ())
+	  {
+	    uiout->field_string ("target-id", target_id);
+	    if (extra_info)
+	      uiout->field_string ("details", extra_info);
+	    if (name)
+	      uiout->field_string ("name", name);
+	  }
+	else
+	  {
+	    std::string contents;
+
+	    if (extra_info && name)
+	      contents = string_printf ("%s \"%s\" (%s)", target_id,
+					name, extra_info);
+	    else if (extra_info)
+	      contents = string_printf ("%s (%s)", target_id, extra_info);
+	    else if (name)
+	      contents = string_printf ("%s \"%s\"", target_id, name);
+	    else
+	      contents = target_id;
+
+	    uiout->field_string ("target-id", contents.c_str ());
+	  }
 
-      if (uiout->is_mi_like_p ())
-	{
-	  const char *state = "stopped";
+	if (tp->state == THREAD_RUNNING)
+	  uiout->text ("(running)\n");
+	else
+	  {
+	    /* The switch below puts us at the top of the stack (leaf
+	       frame).  */
+	    switch_to_thread (tp->ptid);
+	    print_stack_frame (get_selected_frame (NULL),
+			       /* For MI output, print frame level.  */
+			       uiout->is_mi_like_p (),
+			       LOCATION, 0);
+	  }
 
-	  if (tp->state == THREAD_RUNNING)
-	    state = "running";
-	  uiout->field_string ("state", state);
-	}
+	if (uiout->is_mi_like_p ())
+	  {
+	    const char *state = "stopped";
 
-      core = target_core_of_thread (tp->ptid);
-      if (uiout->is_mi_like_p () && core != -1)
-	uiout->field_int ("core", core);
+	    if (tp->state == THREAD_RUNNING)
+	      state = "running";
+	    uiout->field_string ("state", state);
+	  }
 
-      do_cleanups (chain2);
+	core = target_core_of_thread (tp->ptid);
+	if (uiout->is_mi_like_p () && core != -1)
+	  uiout->field_int ("core", core);
     }
 
-  /* Restores the current thread and the frame selected before
-     the "info threads" command.  */
+    /* This end scope restores the current thread and the frame
+       selected before the "info threads" command.  */
+  }
+
   do_cleanups (old_chain);
 
   if (pid == -1 && requested_threads == NULL)
@@ -1458,10 +1446,8 @@ info_threads_command (char *arg, int from_tty)
 void
 switch_to_thread_no_regs (struct thread_info *thread)
 {
-  struct inferior *inf;
+  struct inferior *inf = thread->inf;
 
-  inf = find_inferior_ptid (thread->ptid);
-  gdb_assert (inf != NULL);
   set_current_program_space (inf->pspace);
   set_current_inferior (inf);
 
@@ -1469,45 +1455,50 @@ switch_to_thread_no_regs (struct thread_info *thread)
   stop_pc = ~(CORE_ADDR) 0;
 }
 
-/* Switch from one thread to another.  */
+/* Switch to no thread selected.  */
 
-void
-switch_to_thread (ptid_t ptid)
+static void
+switch_to_no_thread ()
 {
-  /* Switch the program space as well, if we can infer it from the now
-     current thread.  Otherwise, it's up to the caller to select the
-     space it wants.  */
-  if (ptid != null_ptid)
-    {
-      struct inferior *inf;
+  if (inferior_ptid == null_ptid)
+    return;
 
-      inf = find_inferior_ptid (ptid);
-      gdb_assert (inf != NULL);
-      set_current_program_space (inf->pspace);
-      set_current_inferior (inf);
-    }
+  inferior_ptid = null_ptid;
+  reinit_frame_cache ();
+  stop_pc = ~(CORE_ADDR) 0;
+}
 
-  if (ptid == inferior_ptid)
+/* Switch from one thread to another.  */
+
+static void
+switch_to_thread (thread_info *thr)
+{
+  gdb_assert (thr != NULL);
+
+  if (inferior_ptid == thr->ptid)
     return;
 
-  inferior_ptid = ptid;
+  switch_to_thread_no_regs (thr);
+
   reinit_frame_cache ();
 
   /* We don't check for is_stopped, because we're called at times
      while in the TARGET_RUNNING state, e.g., while handling an
      internal event.  */
-  if (inferior_ptid != null_ptid
-      && !is_exited (ptid)
-      && !is_executing (ptid))
-    stop_pc = regcache_read_pc (get_thread_regcache (ptid));
-  else
-    stop_pc = ~(CORE_ADDR) 0;
+  if (thr->state != THREAD_EXITED
+      && !thr->executing)
+    stop_pc = regcache_read_pc (get_thread_regcache (thr->ptid));
 }
 
-static void
-restore_current_thread (ptid_t ptid)
+/* See gdbthread.h.  */
+
+void
+switch_to_thread (ptid_t ptid)
 {
-  switch_to_thread (ptid);
+  if (ptid == null_ptid)
+    switch_to_no_thread ();
+  else
+    switch_to_thread (find_thread_ptid (ptid));
 }
 
 static void
@@ -1569,83 +1560,53 @@ restore_selected_frame (struct frame_id a_frame_id, int frame_level)
     }
 }
 
-/* Data used by the cleanup installed by
-   'make_cleanup_restore_current_thread'.  */
-
-struct current_thread_cleanup
+scoped_restore_current_thread::~scoped_restore_current_thread ()
 {
-  thread_info *thread;
-  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 current_thread_cleanup *old = (struct current_thread_cleanup *) arg;
-
   /* If an entry of thread_info was previously selected, it won't be
      deleted because we've increased its refcount.  The thread represented
      by this thread_info entry may have already exited (due to normal exit,
      detach, etc), so the thread_info.state is THREAD_EXITED.  */
-  if (old->thread != NULL
+  if (m_thread != NULL
       /* If the previously selected thread belonged to a process that has
 	 in the mean time exited (or killed, detached, etc.), then don't revert
 	 back to it, but instead simply drop back to no thread selected.  */
-      && find_inferior_ptid (old->thread->ptid) != NULL)
-    restore_current_thread (old->thread->ptid);
+      && m_inf->pid != 0)
+    switch_to_thread (m_thread);
   else
     {
-      restore_current_thread (null_ptid);
-      set_current_inferior (find_inferior_id (old->inf_id));
+      switch_to_no_thread ();
+      set_current_inferior (m_inf);
     }
 
   /* The running state of the originally selected thread may have
      changed, so we have to recheck it here.  */
   if (inferior_ptid != null_ptid
-      && old->was_stopped
+      && m_was_stopped
       && is_stopped (inferior_ptid)
       && target_has_registers
       && target_has_stack
       && 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 = (struct current_thread_cleanup *) arg;
-  struct thread_info *tp;
-  struct inferior *inf;
-
-  if (old->thread != NULL)
-    old->thread->decref ();
+    restore_selected_frame (m_selected_frame_id, m_selected_frame_level);
 
-  inf = find_inferior_id (old->inf_id);
-  if (inf != NULL)
-    inf->removable = old->was_removable;
-  xfree (old);
+  if (m_thread != NULL)
+    m_thread->decref ();
+  m_inf->decref ();
 }
 
-struct cleanup *
-make_cleanup_restore_current_thread (void)
+scoped_restore_current_thread::scoped_restore_current_thread ()
 {
-  struct current_thread_cleanup *old = XNEW (struct current_thread_cleanup);
-
-  old->thread = NULL;
-  old->inf_id = current_inferior ()->num;
-  old->was_removable = current_inferior ()->removable;
+  m_thread = NULL;
+  m_inf = current_inferior ();
 
   if (inferior_ptid != null_ptid)
     {
+      thread_info *tp = find_thread_ptid (inferior_ptid);
       struct frame_info *frame;
 
-      old->was_stopped = is_stopped (inferior_ptid);
-      if (old->was_stopped
+      gdb_assert (tp != NULL);
+
+      m_was_stopped = tp->state == THREAD_STOPPED;
+      if (m_was_stopped
 	  && target_has_registers
 	  && target_has_stack
 	  && target_has_memory)
@@ -1660,20 +1621,14 @@ make_cleanup_restore_current_thread (void)
       else
 	frame = NULL;
 
-      old->selected_frame_id = get_frame_id (frame);
-      old->selected_frame_level = frame_relative_level (frame);
+      m_selected_frame_id = get_frame_id (frame);
+      m_selected_frame_level = frame_relative_level (frame);
 
-      struct thread_info *tp = find_thread_ptid (inferior_ptid);
-
-      if (tp)
-	tp->incref ();
-      old->thread = tp;
+      tp->incref ();
+      m_thread = tp;
     }
 
-  current_inferior ()->removable = 0;
-
-  return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
-			    restore_current_thread_cleanup_dtor);
+  m_inf->incref ();
 }
 
 /* See gdbthread.h.  */
@@ -1743,9 +1698,6 @@ tp_array_compar (const thread_info *a, const thread_info *b)
 static void
 thread_apply_all_command (char *cmd, int from_tty)
 {
-  struct cleanup *old_chain;
-  char *saved_cmd;
-
   tp_array_compar_ascending = false;
   if (cmd != NULL
       && check_for_argument (&cmd, "-ascending", strlen ("-ascending")))
@@ -1759,12 +1711,9 @@ thread_apply_all_command (char *cmd, int from_tty)
 
   update_thread_list ();
 
-  old_chain = make_cleanup_restore_current_thread ();
-
   /* Save a copy of the command in case it is clobbered by
      execute_command.  */
-  saved_cmd = xstrdup (cmd);
-  make_cleanup (xfree, saved_cmd);
+  std::string saved_cmd = cmd;
 
   int tc = live_threads_count ();
   if (tc != 0)
@@ -1794,6 +1743,8 @@ thread_apply_all_command (char *cmd, int from_tty)
 
       std::sort (thr_list_cpy.begin (), thr_list_cpy.end (), tp_array_compar);
 
+      scoped_restore_current_thread restore_thread;
+
       for (thread_info *thr : thr_list_cpy)
 	if (thread_alive (thr))
 	  {
@@ -1804,11 +1755,9 @@ thread_apply_all_command (char *cmd, int from_tty)
 	    execute_command (cmd, from_tty);
 
 	    /* Restore exact command used previously.  */
-	    strcpy (cmd, saved_cmd);
+	    strcpy (cmd, saved_cmd.c_str ());
 	  }
     }
-
-  do_cleanups (old_chain);
 }
 
 /* Implementation of the "thread apply" command.  */
@@ -1817,8 +1766,6 @@ static void
 thread_apply_command (char *tidlist, int from_tty)
 {
   char *cmd = NULL;
-  struct cleanup *old_chain;
-  char *saved_cmd;
   tid_range_parser parser;
 
   if (tidlist == NULL || *tidlist == '\000')
@@ -1844,10 +1791,9 @@ thread_apply_command (char *tidlist, int from_tty)
 
   /* Save a copy of the command in case it is clobbered by
      execute_command.  */
-  saved_cmd = xstrdup (cmd);
-  old_chain = make_cleanup (xfree, saved_cmd);
+  std::string saved_cmd = cmd;
 
-  make_cleanup_restore_current_thread ();
+  scoped_restore_current_thread restore_thread;
 
   parser.init (tidlist, current_inferior ()->num);
   while (!parser.finished () && parser.cur_tok () < cmd)
@@ -1902,10 +1848,8 @@ thread_apply_command (char *tidlist, int from_tty)
       execute_command (cmd, from_tty);
 
       /* Restore exact command used previously.  */
-      strcpy (cmd, saved_cmd);
+      strcpy (cmd, saved_cmd.c_str ());
     }
-
-  do_cleanups (old_chain);
 }
 
 /* Switch to the specified thread.  Will dispatch off to thread_apply_command