-/* Copyright (C) 1992-2013 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2017 Free Software Foundation, Inc.
This file is part of GDB.
{
struct ada_tasks_pspace_data *data;
- data = program_space_data (pspace, ada_tasks_pspace_data_handle);
+ data = ((struct ada_tasks_pspace_data *)
+ program_space_data (pspace, ada_tasks_pspace_data_handle));
if (data == NULL)
{
- data = XZALLOC (struct ada_tasks_pspace_data);
+ data = XCNEW (struct ada_tasks_pspace_data);
set_program_space_data (pspace, ada_tasks_pspace_data_handle, data);
}
{
struct ada_tasks_inferior_data *data;
- data = inferior_data (inf, ada_tasks_inferior_data_handle);
+ data = ((struct ada_tasks_inferior_data *)
+ inferior_data (inf, ada_tasks_inferior_data_handle));
if (data == NULL)
{
- data = XZALLOC (struct ada_tasks_inferior_data);
+ data = XCNEW (struct ada_tasks_inferior_data);
set_inferior_data (inf, ada_tasks_inferior_data_handle, data);
}
ada_get_task_number (ptid_t ptid)
{
int i;
- struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
+ struct inferior *inf = find_inferior_ptid (ptid);
struct ada_tasks_inferior_data *data;
gdb_assert (inf != NULL);
C-like) lookups to get the first match. */
struct symbol *atcb_sym =
- lookup_symbol_in_language (atcb_name, NULL, VAR_DOMAIN,
- language_c, NULL);
+ lookup_symbol_in_language (atcb_name, NULL, STRUCT_DOMAIN,
+ language_c, NULL).symbol;
const struct symbol *common_atcb_sym =
- lookup_symbol_in_language (common_atcb_name, NULL, VAR_DOMAIN,
- language_c, NULL);
+ lookup_symbol_in_language (common_atcb_name, NULL, STRUCT_DOMAIN,
+ language_c, NULL).symbol;
const struct symbol *private_data_sym =
- lookup_symbol_in_language (private_data_name, NULL, VAR_DOMAIN,
- language_c, NULL);
+ lookup_symbol_in_language (private_data_name, NULL, STRUCT_DOMAIN,
+ language_c, NULL).symbol;
const struct symbol *entry_call_record_sym =
- lookup_symbol_in_language (entry_call_record_name, NULL, VAR_DOMAIN,
- language_c, NULL);
+ lookup_symbol_in_language (entry_call_record_name, NULL, STRUCT_DOMAIN,
+ language_c, NULL).symbol;
if (atcb_sym == NULL || atcb_sym->type == NULL)
{
/* In Ravenscar run-time libs, the ATCB does not have a dynamic
size, so the symbol name differs. */
- atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL, VAR_DOMAIN,
- language_c, NULL);
+ atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL,
+ STRUCT_DOMAIN, language_c,
+ NULL).symbol;
if (atcb_sym == NULL || atcb_sym->type == NULL)
error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
msym = lookup_minimal_symbol_by_pc (task_id);
if (msym.minsym)
{
- const char *full_name = SYMBOL_LINKAGE_NAME (msym.minsym);
+ const char *full_name = MSYMBOL_LINKAGE_NAME (msym.minsym);
const char *task_name = full_name;
const char *p;
{
const int target_ptr_byte = TYPE_LENGTH (data->known_tasks_element);
const int known_tasks_size = target_ptr_byte * data->known_tasks_length;
- gdb_byte *known_tasks = alloca (known_tasks_size);
+ gdb_byte *known_tasks = (gdb_byte *) alloca (known_tasks_size);
int i;
/* Build a new list by reading the ATCBs from the Known_Tasks array
read_known_tasks_list (struct ada_tasks_inferior_data *data)
{
const int target_ptr_byte = TYPE_LENGTH (data->known_tasks_element);
- gdb_byte *known_tasks = alloca (target_ptr_byte);
+ gdb_byte *known_tasks = (gdb_byte *) alloca (target_ptr_byte);
CORE_ADDR task_id;
const struct ada_tasks_pspace_data *pspace_data
= get_ada_tasks_pspace_data (current_program_space);
static void
ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
{
- struct minimal_symbol *msym;
+ struct bound_minimal_symbol msym;
struct symbol *sym;
/* Return now if already set. */
/* Try array. */
msym = lookup_minimal_symbol (KNOWN_TASKS_NAME, NULL, NULL);
- if (msym != NULL)
+ if (msym.minsym != NULL)
{
data->known_tasks_kind = ADA_TASKS_ARRAY;
- data->known_tasks_addr = SYMBOL_VALUE_ADDRESS (msym);
+ data->known_tasks_addr = BMSYMBOL_VALUE_ADDRESS (msym);
/* Try to get pointer type and array length from the symtab. */
sym = lookup_symbol_in_language (KNOWN_TASKS_NAME, NULL, VAR_DOMAIN,
- language_c, NULL);
+ language_c, NULL).symbol;
if (sym != NULL)
{
/* Validate. */
/* Try list. */
msym = lookup_minimal_symbol (KNOWN_TASKS_LIST, NULL, NULL);
- if (msym != NULL)
+ if (msym.minsym != NULL)
{
data->known_tasks_kind = ADA_TASKS_LIST;
- data->known_tasks_addr = SYMBOL_VALUE_ADDRESS (msym);
+ data->known_tasks_addr = BMSYMBOL_VALUE_ADDRESS (msym);
data->known_tasks_length = 1;
sym = lookup_symbol_in_language (KNOWN_TASKS_LIST, NULL, VAR_DOMAIN,
- language_c, NULL);
+ language_c, NULL).symbol;
if (sym != NULL && SYMBOL_VALUE_ADDRESS (sym) != 0)
{
/* Validate. */
if (ada_build_task_list () == 0)
{
- ui_out_message (uiout, 0,
- _("Your application does not use any Ada tasks.\n"));
+ uiout->message (_("Your application does not use any Ada tasks.\n"));
return;
}
if (arg_str != NULL && arg_str[0] != '\0')
taskno_arg = value_as_long (parse_and_eval (arg_str));
- if (ui_out_is_mi_like_p (uiout))
+ if (uiout->is_mi_like_p ())
/* In GDB/MI mode, we want to provide the thread ID corresponding
to each task. This allows clients to quickly find the thread
associated to any task, which is helpful for commands that
take a --thread argument. However, in order to be able to
provide that thread ID, the thread list must be up to date
first. */
- target_find_new_threads ();
+ target_update_thread_list ();
data = get_ada_tasks_inferior_data (inf);
else
nb_tasks = VEC_length (ada_task_info_s, data->task_list);
- nb_columns = ui_out_is_mi_like_p (uiout) ? 8 : 7;
+ nb_columns = uiout->is_mi_like_p () ? 8 : 7;
old_chain = make_cleanup_ui_out_table_begin_end (uiout, nb_columns,
nb_tasks, "tasks");
- ui_out_table_header (uiout, 1, ui_left, "current", "");
- ui_out_table_header (uiout, 3, ui_right, "id", "ID");
- ui_out_table_header (uiout, 9, ui_right, "task-id", "TID");
+ uiout->table_header (1, ui_left, "current", "");
+ uiout->table_header (3, ui_right, "id", "ID");
+ uiout->table_header (9, ui_right, "task-id", "TID");
/* The following column is provided in GDB/MI mode only because
it is only really useful in that mode, and also because it
allows us to keep the CLI output shorter and more compact. */
- if (ui_out_is_mi_like_p (uiout))
- ui_out_table_header (uiout, 4, ui_right, "thread-id", "");
- ui_out_table_header (uiout, 4, ui_right, "parent-id", "P-ID");
- ui_out_table_header (uiout, 3, ui_right, "priority", "Pri");
- ui_out_table_header (uiout, 22, ui_left, "state", "State");
+ if (uiout->is_mi_like_p ())
+ uiout->table_header (4, ui_right, "thread-id", "");
+ uiout->table_header (4, ui_right, "parent-id", "P-ID");
+ uiout->table_header (3, ui_right, "priority", "Pri");
+ uiout->table_header (22, ui_left, "state", "State");
/* Use ui_noalign for the last column, to prevent the CLI uiout
from printing an extra space at the end of each row. This
is a bit of a hack, but does get the job done. */
- ui_out_table_header (uiout, 1, ui_noalign, "name", "Name");
- ui_out_table_body (uiout);
+ uiout->table_header (1, ui_noalign, "name", "Name");
+ uiout->table_body ();
for (taskno = 1;
taskno <= VEC_length (ada_task_info_s, data->task_list);
const struct ada_task_info *const task_info =
VEC_index (ada_task_info_s, data->task_list, taskno - 1);
int parent_id;
- struct cleanup *chain2;
gdb_assert (task_info != NULL);
if (taskno_arg && taskno != taskno_arg)
continue;
- chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+ ui_out_emit_tuple tuple_emitter (uiout, NULL);
/* Print a star if this task is the current task (or the task
currently selected). */
if (ptid_equal (task_info->ptid, inferior_ptid))
- ui_out_field_string (uiout, "current", "*");
+ uiout->field_string ("current", "*");
else
- ui_out_field_skip (uiout, "current");
+ uiout->field_skip ("current");
/* Print the task number. */
- ui_out_field_int (uiout, "id", taskno);
+ uiout->field_int ("id", taskno);
/* Print the Task ID. */
- ui_out_field_fmt (uiout, "task-id", "%9lx", (long) task_info->task_id);
+ uiout->field_fmt ("task-id", "%9lx", (long) task_info->task_id);
/* Print the associated Thread ID. */
- if (ui_out_is_mi_like_p (uiout))
+ if (uiout->is_mi_like_p ())
{
- const int thread_id = pid_to_thread_id (task_info->ptid);
+ const int thread_id = ptid_to_global_thread_id (task_info->ptid);
if (thread_id != 0)
- ui_out_field_int (uiout, "thread-id", thread_id);
+ uiout->field_int ("thread-id", thread_id);
else
/* This should never happen unless there is a bug somewhere,
but be resilient when that happens. */
- ui_out_field_skip (uiout, "thread-id");
+ uiout->field_skip ("thread-id");
}
/* Print the ID of the parent task. */
parent_id = get_task_number_from_id (task_info->parent, inf);
if (parent_id)
- ui_out_field_int (uiout, "parent-id", parent_id);
+ uiout->field_int ("parent-id", parent_id);
else
- ui_out_field_skip (uiout, "parent-id");
+ uiout->field_skip ("parent-id");
/* Print the base priority of the task. */
- ui_out_field_int (uiout, "priority", task_info->priority);
+ uiout->field_int ("priority", task_info->priority);
/* Print the task current state. */
if (task_info->caller_task)
- ui_out_field_fmt (uiout, "state",
+ uiout->field_fmt ("state",
_("Accepting RV with %-4d"),
get_task_number_from_id (task_info->caller_task,
inf));
else if (task_info->state == Entry_Caller_Sleep
&& task_info->called_task)
- ui_out_field_fmt (uiout, "state",
+ uiout->field_fmt ("state",
_("Waiting on RV with %-3d"),
get_task_number_from_id (task_info->called_task,
inf));
else
- ui_out_field_string (uiout, "state", task_states[task_info->state]);
+ uiout->field_string ("state", task_states[task_info->state]);
/* Finally, print the task name. */
- ui_out_field_fmt (uiout, "name",
+ uiout->field_fmt ("name",
"%s",
task_info->name[0] != '\0' ? task_info->name
: _("<no name>"));
- ui_out_text (uiout, "\n");
- do_cleanups (chain2);
+ uiout->text ("\n");
}
do_cleanups (old_chain);
if (ada_build_task_list () == 0)
{
- ui_out_message (uiout, 0,
- _("Your application does not use any Ada tasks.\n"));
+ uiout->message (_("Your application does not use any Ada tasks.\n"));
return;
}
to the thread associated to our task if GDB does not know about
that thread, we need to make sure that any new threads gets added
to the thread list. */
- target_find_new_threads ();
+ target_update_thread_list ();
/* Verify that the ptid of the task we want to switch to is valid
(in other words, a ptid that GDB knows about). Otherwise, we will
printf_filtered (_("[Switching to task %d]\n"), taskno);
print_stack_frame (get_selected_frame (NULL),
frame_relative_level (get_selected_frame (NULL)),
- SRC_AND_LOC);
+ SRC_AND_LOC, 1);
}
if (ada_build_task_list () == 0)
{
- ui_out_message (uiout, 0,
- _("Your application does not use any Ada tasks.\n"));
+ uiout->message (_("Your application does not use any Ada tasks.\n"));
return;
}
/* The 'normal_stop' observer notification callback. */
static void
-ada_normal_stop_observer (struct bpstats *unused_args, int unused_args2)
+ada_tasks_normal_stop_observer (struct bpstats *unused_args, int unused_args2)
{
/* The inferior has been resumed, and just stopped. This means that
our task_list needs to be recomputed before it can be used again. */
/* A routine to be called when the objfiles have changed. */
static void
-ada_new_objfile_observer (struct objfile *objfile)
+ada_tasks_new_objfile_observer (struct objfile *objfile)
{
struct inferior *inf;
ada_tasks_inferior_data_handle = register_inferior_data ();
/* Attach various observers. */
- observer_attach_normal_stop (ada_normal_stop_observer);
- observer_attach_new_objfile (ada_new_objfile_observer);
+ observer_attach_normal_stop (ada_tasks_normal_stop_observer);
+ observer_attach_new_objfile (ada_tasks_new_objfile_observer);
/* Some new commands provided by this module. */
add_info ("tasks", info_tasks_command,
Without argument, this command simply prints the current task ID"),
&cmdlist);
}
-