gdb: rename things related to step over chains

Rename step_over_queue_head to global_thread_step_over_chain_head, to
make it more obvious when reading code that we are touching the global
queue.  Rename all functions that operate on it to have "global" in
their name, to make it clear on which chain they operate on.

I also reworded a few comments in gdbthread.h.  They implied that the
step over chain is per-inferior, when in reality there is only one
global chain, as far as I understand.

diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h
index 2e5b37b0564081733f67efd5b8679a7c3d1ca37a..1905b306ce52f90d33f47366bddbd330958400e3 100644 (file)
--- a/gdb/gdbthread.h
+++ b/gdb/gdbthread.h
@@ -723,20 +723,20 @@ extern value *get_last_thread_stack_temporary (struct thread_info *tp);
 extern bool value_in_thread_stack_temporaries (struct value *,
                                               struct thread_info *thr);
 
-/* Add TP to the end of its inferior's pending step-over chain.  */
+/* Add TP to the end of the global pending step-over chain.  */
 
-extern void thread_step_over_chain_enqueue (struct thread_info *tp);
+extern void global_thread_step_over_chain_enqueue (struct thread_info *tp);
 
-/* Remove TP from its inferior's pending step-over chain.  */
+/* Remove TP from the global pending step-over chain.  */
 
-extern void thread_step_over_chain_remove (struct thread_info *tp);
+extern void global_thread_step_over_chain_remove (struct thread_info *tp);
 
-/* Return the next thread in the step-over chain starting at TP.  NULL
+/* Return the next thread in the global step-over chain.  NULL
    if TP is the last entry in the chain.  */
 
-extern struct thread_info *thread_step_over_chain_next (struct thread_info *tp);
+extern struct thread_info *global_thread_step_over_chain_next (struct thread_info *tp);
 
-/* Return true if TP is in the step-over chain.  */
+/* Return true if TP is in any step-over chain.  */
 
 extern int thread_is_in_step_over_chain (struct thread_info *tp);
 

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 55aa7faa331f61184b0bd3061d2e1219e0ef6ba6..085e250a9bc1dccfdf95d5b3eb46af798235b736 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1247,7 +1247,7 @@ follow_exec (ptid_t ptid, const char *exec_file_target)
    to avoid starvation, otherwise, we could e.g., find ourselves
    constantly stepping the same couple threads past their breakpoints
    over and over, if the single-step finish fast enough.  */
-struct thread_info *step_over_queue_head;
+struct thread_info *global_thread_step_over_chain_head;
 
 /* Bit flags indicating what the thread needs to step over.  */
 
@@ -1689,7 +1689,7 @@ displaced_step_prepare_throw (thread_info *tp)
                            "displaced: deferring step of %s\n",
                            target_pid_to_str (tp->ptid).c_str ());
 
-      thread_step_over_chain_enqueue (tp);
+      global_thread_step_over_chain_enqueue (tp);
       return 0;
     }
   else
@@ -1959,7 +1959,7 @@ start_step_over (void)
   if (step_over_info_valid_p ())
     return 0;
 
-  for (tp = step_over_queue_head; tp != NULL; tp = next)
+  for (tp = global_thread_step_over_chain_head; tp != NULL; tp = next)
     {
       struct execution_control_state ecss;
       struct execution_control_state *ecs = &ecss;
@@ -1968,7 +1968,7 @@ start_step_over (void)
 
       gdb_assert (!tp->stop_requested);
 
-      next = thread_step_over_chain_next (tp);
+      next = global_thread_step_over_chain_next (tp);
 
       /* If this inferior already has a displaced step in process,
         don't start a new one.  */
@@ -1986,9 +1986,9 @@ start_step_over (void)
       if (must_be_in_line && displaced_step_in_progress_any_inferior ())
        return 0;
 
-      thread_step_over_chain_remove (tp);
+      global_thread_step_over_chain_remove (tp);
 
-      if (step_over_queue_head == NULL)
+      if (global_thread_step_over_chain_head == NULL)
        {
          if (debug_infrun)
            fprintf_unfiltered (gdb_stdlog,
@@ -2981,14 +2981,14 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
                                "infrun: need to step-over [%s] first\n",
                                target_pid_to_str (tp->ptid).c_str ());
 
-         thread_step_over_chain_enqueue (tp);
+         global_thread_step_over_chain_enqueue (tp);
        }
     }
 
   /* Enqueue the current thread last, so that we move all other
      threads over their breakpoints first.  */
   if (cur_thr->stepping_over_breakpoint)
-    thread_step_over_chain_enqueue (cur_thr);
+    global_thread_step_over_chain_enqueue (cur_thr);
 
   /* If the thread isn't started, we'll still need to set its prev_pc,
      so that switch_back_to_stepped_thread knows the thread hasn't
@@ -3163,7 +3163,7 @@ infrun_thread_stop_requested (ptid_t ptid)
         start_step_over doesn't try to resume them
         automatically.  */
       if (thread_is_in_step_over_chain (tp))
-       thread_step_over_chain_remove (tp);
+       global_thread_step_over_chain_remove (tp);
 
       /* If the thread is stopped, but the user/frontend doesn't
         know about that yet, queue a pending event, as if the
@@ -4443,7 +4443,7 @@ stop_all_threads (void)
                                              target_pid_to_str (t->ptid).c_str ());
                        }
                      t->control.trap_expected = 0;
-                     thread_step_over_chain_enqueue (t);
+                     global_thread_step_over_chain_enqueue (t);
                    }
                }
              else
@@ -4474,7 +4474,7 @@ stop_all_threads (void)
                    {
                      /* Add it back to the step-over queue.  */
                      t->control.trap_expected = 0;
-                     thread_step_over_chain_enqueue (t);
+                     global_thread_step_over_chain_enqueue (t);
                    }
 
                  regcache = get_thread_regcache (t);
@@ -7498,7 +7498,7 @@ keep_going_pass_signal (struct execution_control_state *ecs)
                                "infrun: step-over already in progress: "
                                "step-over for %s deferred\n",
                                target_pid_to_str (tp->ptid).c_str ());
-         thread_step_over_chain_enqueue (tp);
+         global_thread_step_over_chain_enqueue (tp);
        }
       else
        {

diff --git a/gdb/infrun.h b/gdb/infrun.h
index 1517beb0d3eed209b5d5d54e6ac1b772c12d882c..62e289eb6feb9cb36338b8e151112c0cbfdc4590 100644 (file)
--- a/gdb/infrun.h
+++ b/gdb/infrun.h
@@ -225,7 +225,7 @@ extern void mark_infrun_async_event_handler (void);
 
 /* The global queue of threads that need to do a step-over operation
    to get past e.g., a breakpoint.  */
-extern struct thread_info *step_over_queue_head;
+extern struct thread_info *global_thread_step_over_chain_head;
 
 /* Remove breakpoints if possible (usually that means, if everything
    is stopped).  On failure, print a message.  */

diff --git a/gdb/thread.c b/gdb/thread.c
index 036e35887cffcdc7823eda03fc5650bd56580c1d..861016125aa1b08595ca08172138e1712bd37e4e 100644 (file)
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -207,7 +207,7 @@ set_thread_exited (thread_info *tp, int silent)
 {
   /* Dead threads don't need to step-over.  Remove from queue.  */
   if (tp->step_over_next != NULL)
-    thread_step_over_chain_remove (tp);
+    global_thread_step_over_chain_remove (tp);
 
   if (tp->state != THREAD_EXITED)
     {
@@ -407,11 +407,11 @@ step_over_chain_remove (struct thread_info **list_p, struct thread_info *tp)
 /* See gdbthread.h.  */
 
 struct thread_info *
-thread_step_over_chain_next (struct thread_info *tp)
+global_thread_step_over_chain_next (struct thread_info *tp)
 {
   struct thread_info *next = tp->step_over_next;
 
-  return (next == step_over_queue_head ? NULL : next);
+  return (next == global_thread_step_over_chain_head ? NULL : next);
 }
 
 /* See gdbthread.h.  */
@@ -425,17 +425,17 @@ thread_is_in_step_over_chain (struct thread_info *tp)
 /* See gdbthread.h.  */
 
 void
-thread_step_over_chain_enqueue (struct thread_info *tp)
+global_thread_step_over_chain_enqueue (struct thread_info *tp)
 {
-  step_over_chain_enqueue (&step_over_queue_head, tp);
+  step_over_chain_enqueue (&global_thread_step_over_chain_head, tp);
 }
 
 /* See gdbthread.h.  */
 
 void
-thread_step_over_chain_remove (struct thread_info *tp)
+global_thread_step_over_chain_remove (struct thread_info *tp)
 {
-  step_over_chain_remove (&step_over_queue_head, tp);
+  step_over_chain_remove (&global_thread_step_over_chain_head, tp);
 }
 
 /* Delete the thread referenced by THR.  If SILENT, don't notify
@@ -818,7 +818,7 @@ set_running_thread (struct thread_info *tp, int running)
         the step-over queue, so that we don't try to resume
         it until the user wants it to.  */
       if (tp->step_over_next != NULL)
-       thread_step_over_chain_remove (tp);
+       global_thread_step_over_chain_remove (tp);
     }
 
   return started;