static struct thread_info *
record_btrace_find_resume_thread (ptid_t ptid)
{
struct thread_info *tp;
/* When asked to resume everything, we pick the current thread. */
if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid))
ptid = inferior_ptid;
return find_thread_ptid (ptid);
}
int
ptid_match (ptid_t ptid, ptid_t filter)
{
if (ptid_equal (filter, minus_one_ptid))
return 1;
if (ptid_is_pid (filter)
&& ptid_get_pid (ptid) == ptid_get_pid (filter))
return 1;
else if (ptid_equal (ptid, filter))
return 1;
return 0;
}
static void
mi_on_resume (ptid_t ptid)
{
struct thread_info *tp = NULL;
if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
tp = inferior_thread ();
else
tp = find_thread_ptid (ptid);
/* Suppress output while calling an inferior function. */
if (tp->control.in_infcall)
return;
/* To cater for older frontends, emit ^running, but do it only once
per each command. We do it here, since at this point we know
that the target was successfully resumed, and in non-async mode,
we won't return back to MI interpreter code until the target
is done running, so delaying the output of "^running" until then
will make it impossible for frontend to know what's going on.
In future (MI3), we'll be outputting "^done" here. */
if (!running_result_record_printed && mi_proceeded)
{
fprintf_unfiltered (raw_stdout, "%s^running\n",
current_token ? current_token : "");
}
if (ptid_get_pid (ptid) == -1)
fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
else if (ptid_is_pid (ptid))
{
int count = 0;
/* Backwards compatibility. If there's only one inferior,
output "all", otherwise, output each resumed thread
individually. */
iterate_over_inferiors (mi_inferior_count, &count);
if (count == 1)
fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
else
iterate_over_threads (mi_output_running_pid, &ptid);
}
else
{
struct thread_info *ti = find_thread_ptid (ptid);
gdb_assert (ti);
fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
}
if (!running_result_record_printed && mi_proceeded)
{
running_result_record_printed = 1;
/* This is what gdb used to do historically -- printing prompt even if
it cannot actually accept any input. This will be surely removed
for MI3, and may be removed even earlier. SYNC_EXECUTION is
checked here because we only need to emit a prompt if a
synchronous command was issued when the target is async. */
if (!target_is_async_p () || sync_execution)
fputs_unfiltered ("(gdb) \n", raw_stdout);
}
gdb_flush (raw_stdout);
}
