static void
mi_on_normal_stop (struct bpstats *bs, int print_frame)
{
/* Since this can be called when CLI command is executing,
using cli interpreter, be sure to use MI uiout for output,
not the current one. */
struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
if (print_frame)
{
int core;
if (current_uiout != mi_uiout)
{
/* The normal_stop function has printed frame information
into CLI uiout, or some other non-MI uiout. There's no
way we can extract proper fields from random uiout
object, so we print the frame again. In practice, this
can only happen when running a CLI command in MI. */
struct ui_out *saved_uiout = current_uiout;
struct target_waitstatus last;
ptid_t last_ptid;
current_uiout = mi_uiout;
get_last_target_status (&last_ptid, &last);
bpstat_print (bs, last.kind);
print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
current_uiout = saved_uiout;
}
ui_out_field_int (mi_uiout, "thread-id",
pid_to_thread_id (inferior_ptid));
if (non_stop)
{
struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
(mi_uiout, "stopped-threads");
ui_out_field_int (mi_uiout, NULL,
pid_to_thread_id (inferior_ptid));
do_cleanups (back_to);
}
else
ui_out_field_string (mi_uiout, "stopped-threads", "all");
core = target_core_of_thread (inferior_ptid);
if (core != -1)
ui_out_field_int (mi_uiout, "core", core);
}
fputs_unfiltered ("*stopped", raw_stdout);
mi_out_put (mi_uiout, raw_stdout);
mi_out_rewind (mi_uiout);
mi_print_timing_maybe ();
fputs_unfiltered ("\n", raw_stdout);
gdb_flush (raw_stdout);
}
static void
fbsd_thread_fetch_registers (struct target_ops *ops,
struct regcache *regcache, int regnum)
{
prgregset_t gregset;
prfpregset_t fpregset;
td_thrhandle_t th;
td_err_e err;
#ifdef PT_GETXMMREGS
char xmmregs[512];
#endif
if (!IS_THREAD (inferior_ptid))
{
fbsd_lwp_fetch_registers (ops, regcache, regnum);
return;
}
err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
if (err != TD_OK)
error ("Cannot find thread %d: Thread ID=%ld, %s",
pid_to_thread_id (inferior_ptid),
GET_THREAD (inferior_ptid), thread_db_err_str (err));
err = td_thr_getgregs_p (&th, gregset);
if (err != TD_OK)
error ("Cannot fetch general-purpose registers for thread %d: Thread ID=%ld, %s",
pid_to_thread_id (inferior_ptid),
GET_THREAD (inferior_ptid), thread_db_err_str (err));
#ifdef PT_GETXMMREGS
err = td_thr_getxmmregs_p (&th, xmmregs);
if (err == TD_OK)
{
i387_supply_fxsave (regcache, -1, xmmregs);
}
else
{
#endif
err = td_thr_getfpregs_p (&th, &fpregset);
if (err != TD_OK)
error ("Cannot get floating-point registers for thread %d: Thread ID=%ld, %s",
pid_to_thread_id (inferior_ptid),
GET_THREAD (inferior_ptid), thread_db_err_str (err));
supply_fpregset (regcache, &fpregset);
#ifdef PT_GETXMMREGS
}
#endif
supply_gregset (regcache, gregset);
}
static void
kgdb_switch_to_thread(int tid)
{
char buf[16];
int thread_id;
thread_id = pid_to_thread_id(pid_to_ptid(tid));
if (thread_id == 0)
error ("invalid tid");
snprintf(buf, sizeof(buf), "%d", thread_id);
gdb_thread_select(uiout, buf);
}
static void
fbsd_thread_store_registers (int regno)
{
prgregset_t gregset;
prfpregset_t fpregset;
td_thrhandle_t th;
td_err_e err;
#ifdef PT_GETXMMREGS
char xmmregs[512];
#endif
if (!IS_THREAD (inferior_ptid))
{
fbsd_lwp_store_registers (regno);
return;
}
err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
if (err != TD_OK)
error ("Cannot find thread %d: Thread ID=%ld, %s",
pid_to_thread_id (inferior_ptid),
GET_THREAD (inferior_ptid),
thread_db_err_str (err));
if (regno != -1)
{
char old_value[MAX_REGISTER_SIZE];
regcache_collect (regno, old_value);
err = td_thr_getgregs_p (&th, gregset);
if (err != TD_OK)
error ("%s: td_thr_getgregs %s", __func__, thread_db_err_str (err));
#ifdef PT_GETXMMREGS
err = td_thr_getxmmregs_p (&th, xmmregs);
if (err != TD_OK)
{
#endif
err = td_thr_getfpregs_p (&th, &fpregset);
if (err != TD_OK)
error ("%s: td_thr_getfpgregs %s", __func__, thread_db_err_str (err));
#ifdef PT_GETXMMREGS
}
#endif
supply_register (regno, old_value);
}
fill_gregset (gregset, regno);
err = td_thr_setgregs_p (&th, gregset);
if (err != TD_OK)
error ("Cannot store general-purpose registers for thread %d: Thread ID=%d, %s",
pid_to_thread_id (inferior_ptid), GET_THREAD (inferior_ptid),
thread_db_err_str (err));
#ifdef PT_GETXMMREGS
i387_fill_fxsave (xmmregs, regno);
err = td_thr_setxmmregs_p (&th, xmmregs);
if (err == TD_OK)
return;
#endif
fill_fpregset (&fpregset, regno);
err = td_thr_setfpregs_p (&th, &fpregset);
if (err != TD_OK)
error ("Cannot store floating-point registers for thread %d: Thread ID=%d, %s",
pid_to_thread_id (inferior_ptid), GET_THREAD (inferior_ptid),
thread_db_err_str (err));
}
static void
mi_on_normal_stop (struct bpstats *bs, int print_frame)
{
/* Since this can be called when CLI command is executing,
using cli interpreter, be sure to use MI uiout for output,
not the current one. */
struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
if (print_frame)
{
int core;
if (current_uiout != mi_uiout)
{
/* The normal_stop function has printed frame information
into CLI uiout, or some other non-MI uiout. There's no
way we can extract proper fields from random uiout
object, so we print the frame again. In practice, this
can only happen when running a CLI command in MI. */
struct ui_out *saved_uiout = current_uiout;
struct target_waitstatus last;
ptid_t last_ptid;
current_uiout = mi_uiout;
get_last_target_status (&last_ptid, &last);
print_stop_event (&last);
current_uiout = saved_uiout;
}
/* Otherwise, frame information has already been printed by
normal_stop. */
else
{
/* Breakpoint hits should always be mirrored to the console.
Deciding what to mirror to the console wrt to breakpoints
and random stops gets messy real fast. E.g., say "s"
trips on a breakpoint. We'd clearly want to mirror the
event to the console in this case. But what about more
complicated cases like "s&; thread n; s&", and one of
those steps spawning a new thread, and that thread
hitting a breakpoint? It's impossible in general to
track whether the thread had any relation to the commands
that had been executed. So we just simplify and always
mirror breakpoints and random events to the console.
Also, CLI execution commands (-interpreter-exec console
"next", for example) in async mode have the opposite
issue as described in the "then" branch above --
normal_stop has already printed frame information to MI
uiout, but nothing has printed the same information to
the CLI channel. We should print the source line to the
console when stepping or other similar commands, iff the
step was started by a console command (but not if it was
started with -exec-step or similar). */
struct thread_info *tp = inferior_thread ();
if ((!tp->control.stop_step
&& !tp->control.proceed_to_finish)
|| (tp->control.command_interp != NULL
&& tp->control.command_interp != top_level_interpreter ()))
{
struct mi_interp *mi = top_level_interpreter_data ();
struct target_waitstatus last;
ptid_t last_ptid;
struct cleanup *old_chain;
/* Set the current uiout to CLI uiout temporarily. */
old_chain = make_cleanup (restore_current_uiout_cleanup,
current_uiout);
current_uiout = mi->cli_uiout;
get_last_target_status (&last_ptid, &last);
print_stop_event (&last);
do_cleanups (old_chain);
}
}
ui_out_field_int (mi_uiout, "thread-id",
pid_to_thread_id (inferior_ptid));
if (non_stop)
{
struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
(mi_uiout, "stopped-threads");
ui_out_field_int (mi_uiout, NULL,
pid_to_thread_id (inferior_ptid));
do_cleanups (back_to);
}
else
ui_out_field_string (mi_uiout, "stopped-threads", "all");
core = target_core_of_thread (inferior_ptid);
if (core != -1)
ui_out_field_int (mi_uiout, "core", core);
}
fputs_unfiltered ("*stopped", raw_stdout);
mi_out_put (mi_uiout, raw_stdout);
mi_out_rewind (mi_uiout);
mi_print_timing_maybe ();
fputs_unfiltered ("\n", raw_stdout);
gdb_flush (raw_stdout);
}
static void
mi_on_normal_stop (struct bpstats *bs, int print_frame)
{
/* Since this can be called when CLI command is executing,
using cli interpreter, be sure to use MI uiout for output,
not the current one. */
struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
if (print_frame)
{
struct thread_info *tp;
int core;
tp = inferior_thread ();
if (tp->thread_fsm != NULL
&& thread_fsm_finished_p (tp->thread_fsm))
{
enum async_reply_reason reason;
reason = thread_fsm_async_reply_reason (tp->thread_fsm);
ui_out_field_string (mi_uiout, "reason",
async_reason_lookup (reason));
}
print_stop_event (mi_uiout);
/* Breakpoint hits should always be mirrored to the console.
Deciding what to mirror to the console wrt to breakpoints and
random stops gets messy real fast. E.g., say "s" trips on a
breakpoint. We'd clearly want to mirror the event to the
console in this case. But what about more complicated cases
like "s&; thread n; s&", and one of those steps spawning a
new thread, and that thread hitting a breakpoint? It's
impossible in general to track whether the thread had any
relation to the commands that had been executed. So we just
simplify and always mirror breakpoints and random events to
the console.
OTOH, we should print the source line to the console when
stepping or other similar commands, iff the step was started
by a console command, but not if it was started with
-exec-step or similar. */
if ((bpstat_what (tp->control.stop_bpstat).main_action
== BPSTAT_WHAT_STOP_NOISY)
|| !(tp->thread_fsm != NULL
&& thread_fsm_finished_p (tp->thread_fsm))
|| (tp->control.command_interp != NULL
&& tp->control.command_interp != top_level_interpreter ()))
{
struct mi_interp *mi
= (struct mi_interp *) top_level_interpreter_data ();
print_stop_event (mi->cli_uiout);
}
ui_out_field_int (mi_uiout, "thread-id",
pid_to_thread_id (inferior_ptid));
if (non_stop)
{
struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
(mi_uiout, "stopped-threads");
ui_out_field_int (mi_uiout, NULL,
pid_to_thread_id (inferior_ptid));
do_cleanups (back_to);
}
else
ui_out_field_string (mi_uiout, "stopped-threads", "all");
core = target_core_of_thread (inferior_ptid);
if (core != -1)
ui_out_field_int (mi_uiout, "core", core);
}
fputs_unfiltered ("*stopped", raw_stdout);
mi_out_put (mi_uiout, raw_stdout);
mi_out_rewind (mi_uiout);
mi_print_timing_maybe ();
fputs_unfiltered ("\n", raw_stdout);
gdb_flush (raw_stdout);
}
PyErr_SetString (PyExc_ValueError,
_("Invalid ID for the `frame' object."));
}
}
}
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
return -1;
}
END_CATCH
if (PyErr_Occurred ())
return -1;
thread = pid_to_thread_id (inferior_ptid);
if (thread == 0)
{
PyErr_SetString (PyExc_ValueError,
_("No thread currently selected."));
return -1;
}
if (internal)
{
internal_bp = PyObject_IsTrue (internal);
if (internal_bp == -1)
{
PyErr_SetString (PyExc_ValueError,
_("The value of `internal' must be a boolean."));
return -1;