#include "cli/cli-decode.h"
#include "gdb_regex.h"
#include "cli/cli-utils.h"
-#include "continuations.h"
+#include "thread-fsm.h"
/* Definition of struct thread_info exported to gdbthread.h. */
&& breakpoint_has_location_inserted_here (ss_bps, aspace, addr));
}
+/* See gdbthread.h. */
+
+void
+thread_cancel_execution_command (struct thread_info *thr)
+{
+ if (thr->thread_fsm != NULL)
+ {
+ thread_fsm_clean_up (thr->thread_fsm);
+ thread_fsm_delete (thr->thread_fsm);
+ thr->thread_fsm = NULL;
+ }
+}
+
static void
clear_thread_inferior_resources (struct thread_info *tp)
{
btrace_teardown (tp);
- do_all_intermediate_continuations_thread (tp, 1);
- do_all_continuations_thread (tp, 1);
+ thread_cancel_execution_command (tp);
}
static void
static struct thread_info *
new_thread (ptid_t ptid)
{
- struct thread_info *tp;
-
- tp = xcalloc (1, sizeof (*tp));
+ struct thread_info *tp = XCNEW (struct thread_info);
tp->ptid = ptid;
tp->num = ++highest_thread_num;
/* Nothing to follow yet. */
tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
tp->state = THREAD_STOPPED;
+ tp->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
return tp;
}
static void
disable_thread_stack_temporaries (void *data)
{
- ptid_t *pd = data;
+ ptid_t *pd = (ptid_t *) data;
struct thread_info *tp = find_thread_ptid (*pd);
if (tp != NULL)
tp->stack_temporaries_enabled = 1;
tp->stack_temporaries = NULL;
- data = (ptid_t *) xmalloc (sizeof (ptid_t));
+ data = XNEW (ptid_t);
*data = ptid;
c = make_cleanup (disable_thread_stack_temporaries, data);
observer_notify_thread_ptid_changed (old_ptid, new_ptid);
}
+/* See gdbthread.h. */
+
+void
+set_resumed (ptid_t ptid, int resumed)
+{
+ struct thread_info *tp;
+ int all = ptid_equal (ptid, minus_one_ptid);
+
+ if (all || ptid_is_pid (ptid))
+ {
+ for (tp = thread_list; tp; tp = tp->next)
+ if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
+ tp->resumed = resumed;
+ }
+ else
+ {
+ tp = find_thread_ptid (ptid);
+ gdb_assert (tp != NULL);
+ tp->resumed = resumed;
+ }
+}
+
+/* Helper for set_running, that marks one thread either running or
+ stopped. */
+
+static int
+set_running_thread (struct thread_info *tp, int running)
+{
+ int started = 0;
+
+ if (running && tp->state == THREAD_STOPPED)
+ started = 1;
+ tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
+
+ if (!running)
+ {
+ /* If the thread is now marked stopped, remove it from
+ 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);
+ }
+
+ return started;
+}
+
void
set_running (ptid_t ptid, int running)
{
struct thread_info *tp;
int all = ptid_equal (ptid, minus_one_ptid);
+ int any_started = 0;
/* We try not to notify the observer if no thread has actually changed
the running state -- merely to reduce the number of messages to
frontend. Frontend is supposed to handle multiple *running just fine. */
if (all || ptid_is_pid (ptid))
{
- int any_started = 0;
-
for (tp = thread_list; tp; tp = tp->next)
if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
{
if (tp->state == THREAD_EXITED)
continue;
- if (running && tp->state == THREAD_STOPPED)
+
+ if (set_running_thread (tp, running))
any_started = 1;
- tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
}
- if (any_started)
- observer_notify_target_resumed (ptid);
}
else
{
- int started = 0;
-
tp = find_thread_ptid (ptid);
- gdb_assert (tp);
+ gdb_assert (tp != NULL);
gdb_assert (tp->state != THREAD_EXITED);
- if (running && tp->state == THREAD_STOPPED)
- started = 1;
- tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
- if (started)
- observer_notify_target_resumed (ptid);
+ if (set_running_thread (tp, running))
+ any_started = 1;
}
+ if (any_started)
+ observer_notify_target_resumed (ptid);
}
static int
continue;
if (all || ptid_get_pid (ptid) == ptid_get_pid (tp->ptid))
{
- if (tp->executing && tp->state == THREAD_STOPPED)
+ if (set_running_thread (tp, tp->executing))
any_started = 1;
- tp->state = tp->executing ? THREAD_RUNNING : THREAD_STOPPED;
}
}
}
gdb_assert (tp);
if (tp->state != THREAD_EXITED)
{
- if (tp->executing && tp->state == THREAD_STOPPED)
+ if (set_running_thread (tp, tp->executing))
any_started = 1;
- tp->state = tp->executing ? THREAD_RUNNING : THREAD_STOPPED;
}
}
void
finish_thread_state_cleanup (void *arg)
{
- ptid_t *ptid_p = arg;
+ ptid_t *ptid_p = (ptid_t *) arg;
gdb_assert (arg);
do_restore_current_thread_cleanup (void *arg)
{
struct thread_info *tp;
- struct current_thread_cleanup *old = arg;
+ struct current_thread_cleanup *old = (struct current_thread_cleanup *) arg;
tp = find_thread_ptid (old->inferior_ptid);
static void
restore_current_thread_cleanup_dtor (void *arg)
{
- struct current_thread_cleanup *old = arg;
+ struct current_thread_cleanup *old = (struct current_thread_cleanup *) arg;
struct thread_info *tp;
struct inferior *inf;
set_thread_refcount (void *data)
{
int k;
- struct thread_array_cleanup *ta_cleanup = data;
+ struct thread_array_cleanup *ta_cleanup
+ = (struct thread_array_cleanup *) data;
for (k = 0; k != ta_cleanup->count; k++)
ta_cleanup->tp_array[k]->refcount--;
{
struct thread_info *tp;
struct frame_info *frame;
- struct current_thread_cleanup *old;
+ struct current_thread_cleanup *old = XNEW (struct current_thread_cleanup);
- old = xmalloc (sizeof (struct current_thread_cleanup));
old->inferior_ptid = inferior_ptid;
old->inf_id = current_inferior ()->num;
old->was_removable = current_inferior ()->removable;
static int
tp_array_compar (const void *ap_voidp, const void *bp_voidp)
{
- const struct thread_info *const *ap = ap_voidp;
- const struct thread_info *const *bp = bp_voidp;
+ const struct thread_info *const *ap
+ = (const struct thread_info * const*) ap_voidp;
+ const struct thread_info *const *bp
+ = (const struct thread_info * const*) bp_voidp;
return ((((*ap)->num > (*bp)->num) - ((*ap)->num < (*bp)->num))
* (tp_array_compar_ascending ? +1 : -1));
/* Save a copy of the thread_list in case we execute detach
command. */
- tp_array = xmalloc (sizeof (struct thread_info *) * tc);
+ tp_array = XNEWVEC (struct thread_info *, tc);
make_cleanup (xfree, tp_array);
ALL_NON_EXITED_THREADS (tp)
int num;
struct thread_info *tp;
- num = value_as_long (parse_and_eval (tidstr));
+ num = value_as_long (parse_and_eval ((const char *) tidstr));
tp = find_thread_id (num);