static void
proceed_thread (struct thread_info *thread, int pid)
{
- if (!is_stopped (thread->ptid))
+ if (thread->state != THREAD_STOPPED)
return;
- if (pid != 0 && ptid_get_pid (thread->ptid) != pid)
+ if (pid != 0 && thread->ptid.pid () != pid)
return;
- switch_to_thread (thread->ptid);
+ switch_to_thread (thread);
clear_proceed_status (0);
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
static void
exec_continue (char **argv, int argc)
{
- prepare_execution_command (target_stack, mi_async_p ());
+ prepare_execution_command (current_top_target (), mi_async_p ());
if (non_stop)
{
{
int pid = *(int *)arg;
- if (!is_running (thread->ptid))
+ if (thread->state != THREAD_RUNNING)
return 0;
- if (ptid_get_pid (thread->ptid) != pid)
+ if (thread->ptid.pid () != pid)
return 0;
target_stop (thread->ptid);
if (inf->pid != 0)
{
- if (inf->pid != ptid_get_pid (inferior_ptid))
- {
- struct thread_info *tp;
-
- tp = any_thread_of_process (inf->pid);
- if (!tp)
- error (_("Inferior has no threads."));
+ thread_info *tp = any_thread_of_inferior (inf);
+ if (tp == NULL)
+ error (_("Inferior has no threads."));
- switch_to_thread (tp->ptid);
- }
+ switch_to_thread (tp);
}
else
{
set_current_inferior (inf);
- switch_to_thread (null_ptid);
+ switch_to_no_thread ();
set_current_program_space (inf->pspace);
}
mi_execute_cli_command (run_cmd, async_p,
{
int pid = *(int *)p;
- if (ptid_get_pid (ti->ptid) == pid && !is_exited (ti->ptid))
+ if (ti->ptid.pid () == pid && ti->state != THREAD_EXITED)
return 1;
return 0;
if (!tp)
error (_("Thread group is empty"));
- switch_to_thread (tp->ptid);
+ switch_to_thread (tp);
}
detach_command (NULL, 0);
USER_SELECTED_THREAD | USER_SELECTED_FRAME);
/* Notify if the thread has effectively changed. */
- if (!ptid_equal (inferior_ptid, previous_ptid))
+ if (inferior_ptid != previous_ptid)
{
gdb::observers::user_selected_context_changed.notify
(USER_SELECTED_THREAD | USER_SELECTED_FRAME);
{
struct collect_cores_data *data = (struct collect_cores_data *) xdata;
- if (ptid_get_pid (ti->ptid) == data->pid)
+ if (ti->ptid.pid () == data->pid)
{
int core = target_core_of_thread (ti->ptid);
for (const osdata_item &child : children)
{
- ui_out_emit_tuple tuple_emitter (uiout, NULL);
+ ui_out_emit_tuple inner_tuple_emitter (uiout, NULL);
const std::string *tid = get_osdata_column (child, "tid");
const std::string *tcore = get_osdata_column (child, "core");
gdb::byte_vector mbuf (total_bytes);
- nr_bytes = target_read (target_stack, TARGET_OBJECT_MEMORY, NULL, mbuf.data (),
- addr, total_bytes);
+ nr_bytes = target_read (current_top_target (), TARGET_OBJECT_MEMORY, NULL,
+ mbuf.data (), addr, total_bytes);
if (nr_bytes <= 0)
error (_("Unable to read memory."));
{
int col;
int col_byte;
- struct value_print_options opts;
+ struct value_print_options print_opts;
ui_out_emit_tuple tuple_emitter (uiout, NULL);
uiout->field_core_addr ("addr", gdbarch, addr + row_byte);
row_byte); */
{
ui_out_emit_list list_data_emitter (uiout, "data");
- get_formatted_print_options (&opts, word_format);
+ get_formatted_print_options (&print_opts, word_format);
for (col = 0, col_byte = row_byte;
col < nr_cols;
col++, col_byte += word_size)
else
{
stream.clear ();
- print_scalar_formatted (&mbuf[col_byte], word_type, &opts,
- word_asize, &stream);
+ print_scalar_formatted (&mbuf[col_byte], word_type,
+ &print_opts, word_asize, &stream);
uiout->field_stream (NULL, stream);
}
}
length = atol (argv[1]);
std::vector<memory_read_result> result
- = read_memory_robust (target_stack, addr, length);
+ = read_memory_robust (current_top_target (), addr, length);
if (result.size () == 0)
error (_("Unable to read memory."));
uiout->field_string (NULL, "info-gdb-mi-command");
uiout->field_string (NULL, "undefined-command-error-code");
uiout->field_string (NULL, "exec-run-start-option");
+ uiout->field_string (NULL, "data-disassemble-a-option");
if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
uiout->field_string (NULL, "python");
set_current_inferior (new_inferior);
if (new_inferior->pid != 0)
- tp = any_thread_of_process (new_inferior->pid);
- switch_to_thread (tp ? tp->ptid : null_ptid);
+ tp = any_thread_of_inferior (new_inferior);
+ if (tp != NULL)
+ switch_to_thread (tp);
+ else
+ switch_to_no_thread ();
set_current_program_space (new_inferior->pspace);
}
if (/* The notifications are only output when the top-level
interpreter (specified on the command line) is MI. */
- interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
+ top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
/* Don't try report anything if there are no threads --
the program is dead. */
&& thread_count () != 0
again. */
&& !command_notifies_uscc_observer (command.get ()))
{
- struct mi_interp *mi = (struct mi_interp *) top_level_interpreter ();
int report_change = 0;
if (command->thread == -1)
{
- report_change = (!ptid_equal (previous_ptid, null_ptid)
- && !ptid_equal (inferior_ptid, previous_ptid)
- && !ptid_equal (inferior_ptid, null_ptid));
+ report_change = (previous_ptid != null_ptid
+ && inferior_ptid != previous_ptid
+ && inferior_ptid != null_ptid);
}
- else if (!ptid_equal (inferior_ptid, null_ptid))
+ else if (inferior_ptid != null_ptid)
{
struct thread_info *ti = inferior_thread ();
provide --thread if it wishes to operate on a specific
thread. */
if (inf->pid != 0)
- tp = any_live_thread_of_process (inf->pid);
- switch_to_thread (tp ? tp->ptid : null_ptid);
+ tp = any_live_thread_of_inferior (inf);
+ if (tp != NULL)
+ switch_to_thread (tp);
+ else
+ switch_to_no_thread ();
set_current_program_space (inf->pspace);
}
if (parse->thread != -1)
{
- struct thread_info *tp = find_thread_global_id (parse->thread);
+ thread_info *tp = find_thread_global_id (parse->thread);
- if (!tp)
+ if (tp == NULL)
error (_("Invalid thread id: %d"), parse->thread);
- if (is_exited (tp->ptid))
+ if (tp->state == THREAD_EXITED)
error (_("Thread id: %d has terminated"), parse->thread);
- switch_to_thread (tp->ptid);
+ switch_to_thread (tp);
}
if (parse->frame != -1)
break;
case REGISTERS_FORMAT:
registers_format = oarg[0];
+ break;
case MEMORY_CONTENTS:
memory_contents = 1;
break;