1 /* Copyright (C) 1992-2019 Free Software Foundation, Inc.
3 This file is part of GDB.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "observable.h"
25 #include "gdbthread.h"
26 #include "progspace.h"
29 static int ada_build_task_list ();
31 /* The name of the array in the GNAT runtime where the Ada Task Control
32 Block of each task is stored. */
33 #define KNOWN_TASKS_NAME "system__tasking__debug__known_tasks"
35 /* The maximum number of tasks known to the Ada runtime. */
36 static const int MAX_NUMBER_OF_KNOWN_TASKS
= 1000;
38 /* The name of the variable in the GNAT runtime where the head of a task
39 chain is saved. This is an alternate mechanism to find the list of known
41 #define KNOWN_TASKS_LIST "system__tasking__debug__first_task"
53 Master_Completion_Sleep
,
55 Interrupt_Server_Idle_Sleep
,
56 Interrupt_Server_Blocked_Interrupt_Sleep
,
60 Interrupt_Server_Blocked_On_Event_Flag
,
65 /* A short description corresponding to each possible task state. */
66 static const char *task_states
[] = {
70 N_("Child Activation Wait"),
71 N_("Accept or Select Term"),
72 N_("Waiting on entry call"),
73 N_("Async Select Wait"),
75 N_("Child Termination Wait"),
76 N_("Wait Child in Term Alt"),
81 N_("Asynchronous Hold"),
87 /* A longer description corresponding to each possible task state. */
88 static const char *long_task_states
[] = {
92 N_("Waiting for child activation"),
93 N_("Blocked in accept or select with terminate"),
94 N_("Waiting on entry call"),
95 N_("Asynchronous Selective Wait"),
97 N_("Waiting for children termination"),
98 N_("Waiting for children in terminate alternative"),
103 N_("Asynchronous Hold"),
106 N_("Blocked in selective wait statement")
109 /* The index of certain important fields in the Ada Task Control Block
110 record and sub-records. */
114 /* Fields in record Ada_Task_Control_Block. */
117 int atc_nesting_level
;
119 /* Fields in record Common_ATCB. */
124 int image_len
; /* This field may be missing. */
130 /* Fields in Task_Primitives.Private_Data. */
132 int ll_lwp
; /* This field may be missing. */
134 /* Fields in Common_ATCB.Call.all. */
138 /* This module's per-program-space data. */
140 struct ada_tasks_pspace_data
142 /* Nonzero if the data has been initialized. If set to zero,
143 it means that the data has either not been initialized, or
144 has potentially become stale. */
145 int initialized_p
= 0;
147 /* The ATCB record type. */
148 struct type
*atcb_type
= nullptr;
150 /* The ATCB "Common" component type. */
151 struct type
*atcb_common_type
= nullptr;
153 /* The type of the "ll" field, from the atcb_common_type. */
154 struct type
*atcb_ll_type
= nullptr;
156 /* The type of the "call" field, from the atcb_common_type. */
157 struct type
*atcb_call_type
= nullptr;
159 /* The index of various fields in the ATCB record and sub-records. */
160 struct atcb_fieldnos atcb_fieldno
{};
163 /* Key to our per-program-space data. */
164 static const struct program_space_key
<ada_tasks_pspace_data
>
165 ada_tasks_pspace_data_handle
;
167 /* The kind of data structure used by the runtime to store the list
170 enum ada_known_tasks_kind
172 /* Use this value when we haven't determined which kind of structure
173 is being used, or when we need to recompute it.
175 We set the value of this enumerate to zero on purpose: This allows
176 us to use this enumerate in a structure where setting all fields
177 to zero will result in this kind being set to unknown. */
178 ADA_TASKS_UNKNOWN
= 0,
180 /* This value means that we did not find any task list. Unless
181 there is a bug somewhere, this means that the inferior does not
185 /* This value means that the task list is stored as an array.
186 This is the usual method, as it causes very little overhead.
187 But this method is not always used, as it does use a certain
188 amount of memory, which might be scarse in certain environments. */
191 /* This value means that the task list is stored as a linked list.
192 This has more runtime overhead than the array approach, but
193 also require less memory when the number of tasks is small. */
197 /* This module's per-inferior data. */
199 struct ada_tasks_inferior_data
201 /* The type of data structure used by the runtime to store
202 the list of Ada tasks. The value of this field influences
203 the interpretation of the known_tasks_addr field below:
204 - ADA_TASKS_UNKNOWN: The value of known_tasks_addr hasn't
206 - ADA_TASKS_NOT_FOUND: The program probably does not use tasking
207 and the known_tasks_addr is irrelevant;
208 - ADA_TASKS_ARRAY: The known_tasks is an array;
209 - ADA_TASKS_LIST: The known_tasks is a list. */
210 enum ada_known_tasks_kind known_tasks_kind
= ADA_TASKS_UNKNOWN
;
212 /* The address of the known_tasks structure. This is where
213 the runtime stores the information for all Ada tasks.
214 The interpretation of this field depends on KNOWN_TASKS_KIND
216 CORE_ADDR known_tasks_addr
= 0;
218 /* Type of elements of the known task. Usually a pointer. */
219 struct type
*known_tasks_element
= nullptr;
221 /* Number of elements in the known tasks array. */
222 unsigned int known_tasks_length
= 0;
224 /* When nonzero, this flag indicates that the task_list field
225 below is up to date. When set to zero, the list has either
226 not been initialized, or has potentially become stale. */
227 bool task_list_valid_p
= false;
229 /* The list of Ada tasks.
231 Note: To each task we associate a number that the user can use to
232 reference it - this number is printed beside each task in the tasks
233 info listing displayed by "info tasks". This number is equal to
234 its index in the vector + 1. Reciprocally, to compute the index
235 of a task in the vector, we need to substract 1 from its number. */
236 std::vector
<ada_task_info
> task_list
;
239 /* Key to our per-inferior data. */
240 static const struct inferior_key
<ada_tasks_inferior_data
>
241 ada_tasks_inferior_data_handle
;
243 /* Return a string with TASKNO followed by the task name if TASK_INFO
247 task_to_str (int taskno
, const ada_task_info
*task_info
)
249 if (task_info
->name
[0] == '\0')
250 return string_printf ("%d", taskno
);
252 return string_printf ("%d \"%s\"", taskno
, task_info
->name
);
255 /* Return the ada-tasks module's data for the given program space (PSPACE).
256 If none is found, add a zero'ed one now.
258 This function always returns a valid object. */
260 static struct ada_tasks_pspace_data
*
261 get_ada_tasks_pspace_data (struct program_space
*pspace
)
263 struct ada_tasks_pspace_data
*data
;
265 data
= ada_tasks_pspace_data_handle
.get (pspace
);
267 data
= ada_tasks_pspace_data_handle
.emplace (pspace
);
272 /* Return the ada-tasks module's data for the given inferior (INF).
273 If none is found, add a zero'ed one now.
275 This function always returns a valid object.
277 Note that we could use an observer of the inferior-created event
278 to make sure that the ada-tasks per-inferior data always exists.
279 But we prefered this approach, as it avoids this entirely as long
280 as the user does not use any of the tasking features. This is
281 quite possible, particularly in the case where the inferior does
284 static struct ada_tasks_inferior_data
*
285 get_ada_tasks_inferior_data (struct inferior
*inf
)
287 struct ada_tasks_inferior_data
*data
;
289 data
= ada_tasks_inferior_data_handle
.get (inf
);
291 data
= ada_tasks_inferior_data_handle
.emplace (inf
);
296 /* Return the task number of the task whose thread is THREAD, or zero
297 if the task could not be found. */
300 ada_get_task_number (thread_info
*thread
)
302 struct inferior
*inf
= thread
->inf
;
303 struct ada_tasks_inferior_data
*data
;
305 gdb_assert (inf
!= NULL
);
306 data
= get_ada_tasks_inferior_data (inf
);
308 for (int i
= 0; i
< data
->task_list
.size (); i
++)
309 if (data
->task_list
[i
].ptid
== thread
->ptid
)
312 return 0; /* No matching task found. */
315 /* Return the task number of the task running in inferior INF which
316 matches TASK_ID , or zero if the task could not be found. */
319 get_task_number_from_id (CORE_ADDR task_id
, struct inferior
*inf
)
321 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
323 for (int i
= 0; i
< data
->task_list
.size (); i
++)
325 if (data
->task_list
[i
].task_id
== task_id
)
329 /* Task not found. Return 0. */
333 /* Return non-zero if TASK_NUM is a valid task number. */
336 valid_task_id (int task_num
)
338 struct ada_tasks_inferior_data
*data
;
340 ada_build_task_list ();
341 data
= get_ada_tasks_inferior_data (current_inferior ());
342 return task_num
> 0 && task_num
<= data
->task_list
.size ();
345 /* Return non-zero iff the task STATE corresponds to a non-terminated
349 ada_task_is_alive (struct ada_task_info
*task_info
)
351 return (task_info
->state
!= Terminated
);
354 /* Search through the list of known tasks for the one whose ptid is
355 PTID, and return it. Return NULL if the task was not found. */
357 struct ada_task_info
*
358 ada_get_task_info_from_ptid (ptid_t ptid
)
360 struct ada_tasks_inferior_data
*data
;
362 ada_build_task_list ();
363 data
= get_ada_tasks_inferior_data (current_inferior ());
365 for (ada_task_info
&task
: data
->task_list
)
367 if (task
.ptid
== ptid
)
374 /* Call the ITERATOR function once for each Ada task that hasn't been
378 iterate_over_live_ada_tasks (ada_task_list_iterator_ftype
*iterator
)
380 struct ada_tasks_inferior_data
*data
;
382 ada_build_task_list ();
383 data
= get_ada_tasks_inferior_data (current_inferior ());
385 for (ada_task_info
&task
: data
->task_list
)
387 if (!ada_task_is_alive (&task
))
393 /* Extract the contents of the value as a string whose length is LENGTH,
394 and store the result in DEST. */
397 value_as_string (char *dest
, struct value
*val
, int length
)
399 memcpy (dest
, value_contents (val
), length
);
403 /* Extract the string image from the fat string corresponding to VAL,
404 and store it in DEST. If the string length is greater than MAX_LEN,
405 then truncate the result to the first MAX_LEN characters of the fat
409 read_fat_string_value (char *dest
, struct value
*val
, int max_len
)
411 struct value
*array_val
;
412 struct value
*bounds_val
;
415 /* The following variables are made static to avoid recomputing them
416 each time this function is called. */
417 static int initialize_fieldnos
= 1;
418 static int array_fieldno
;
419 static int bounds_fieldno
;
420 static int upper_bound_fieldno
;
422 /* Get the index of the fields that we will need to read in order
423 to extract the string from the fat string. */
424 if (initialize_fieldnos
)
426 struct type
*type
= value_type (val
);
427 struct type
*bounds_type
;
429 array_fieldno
= ada_get_field_index (type
, "P_ARRAY", 0);
430 bounds_fieldno
= ada_get_field_index (type
, "P_BOUNDS", 0);
432 bounds_type
= TYPE_FIELD_TYPE (type
, bounds_fieldno
);
433 if (TYPE_CODE (bounds_type
) == TYPE_CODE_PTR
)
434 bounds_type
= TYPE_TARGET_TYPE (bounds_type
);
435 if (TYPE_CODE (bounds_type
) != TYPE_CODE_STRUCT
)
436 error (_("Unknown task name format. Aborting"));
437 upper_bound_fieldno
= ada_get_field_index (bounds_type
, "UB0", 0);
439 initialize_fieldnos
= 0;
442 /* Get the size of the task image by checking the value of the bounds.
443 The lower bound is always 1, so we only need to read the upper bound. */
444 bounds_val
= value_ind (value_field (val
, bounds_fieldno
));
445 len
= value_as_long (value_field (bounds_val
, upper_bound_fieldno
));
447 /* Make sure that we do not read more than max_len characters... */
451 /* Extract LEN characters from the fat string. */
452 array_val
= value_ind (value_field (val
, array_fieldno
));
453 read_memory (value_address (array_val
), (gdb_byte
*) dest
, len
);
455 /* Add the NUL character to close the string. */
459 /* Get, from the debugging information, the type description of all types
460 related to the Ada Task Control Block that are needed in order to
461 read the list of known tasks in the Ada runtime. If all of the info
462 needed to do so is found, then save that info in the module's per-
463 program-space data, and return NULL. Otherwise, if any information
464 cannot be found, leave the per-program-space data untouched, and
465 return an error message explaining what was missing (that error
466 message does NOT need to be deallocated). */
469 ada_get_tcb_types_info (void)
472 struct type
*common_type
;
473 struct type
*ll_type
;
474 struct type
*call_type
;
475 struct atcb_fieldnos fieldnos
;
476 struct ada_tasks_pspace_data
*pspace_data
;
478 const char *atcb_name
= "system__tasking__ada_task_control_block___XVE";
479 const char *atcb_name_fixed
= "system__tasking__ada_task_control_block";
480 const char *common_atcb_name
= "system__tasking__common_atcb";
481 const char *private_data_name
= "system__task_primitives__private_data";
482 const char *entry_call_record_name
= "system__tasking__entry_call_record";
484 /* ATCB symbols may be found in several compilation units. As we
485 are only interested in one instance, use standard (literal,
486 C-like) lookups to get the first match. */
488 struct symbol
*atcb_sym
=
489 lookup_symbol_in_language (atcb_name
, NULL
, STRUCT_DOMAIN
,
490 language_c
, NULL
).symbol
;
491 const struct symbol
*common_atcb_sym
=
492 lookup_symbol_in_language (common_atcb_name
, NULL
, STRUCT_DOMAIN
,
493 language_c
, NULL
).symbol
;
494 const struct symbol
*private_data_sym
=
495 lookup_symbol_in_language (private_data_name
, NULL
, STRUCT_DOMAIN
,
496 language_c
, NULL
).symbol
;
497 const struct symbol
*entry_call_record_sym
=
498 lookup_symbol_in_language (entry_call_record_name
, NULL
, STRUCT_DOMAIN
,
499 language_c
, NULL
).symbol
;
501 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
503 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
504 size, so the symbol name differs. */
505 atcb_sym
= lookup_symbol_in_language (atcb_name_fixed
, NULL
,
506 STRUCT_DOMAIN
, language_c
,
509 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
510 return _("Cannot find Ada_Task_Control_Block type");
512 type
= atcb_sym
->type
;
516 /* Get a static representation of the type record
517 Ada_Task_Control_Block. */
518 type
= atcb_sym
->type
;
519 type
= ada_template_to_fixed_record_type_1 (type
, NULL
, 0, NULL
, 0);
522 if (common_atcb_sym
== NULL
|| common_atcb_sym
->type
== NULL
)
523 return _("Cannot find Common_ATCB type");
524 if (private_data_sym
== NULL
|| private_data_sym
->type
== NULL
)
525 return _("Cannot find Private_Data type");
526 if (entry_call_record_sym
== NULL
|| entry_call_record_sym
->type
== NULL
)
527 return _("Cannot find Entry_Call_Record type");
529 /* Get the type for Ada_Task_Control_Block.Common. */
530 common_type
= common_atcb_sym
->type
;
532 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
533 ll_type
= private_data_sym
->type
;
535 /* Get the type for Common_ATCB.Call.all. */
536 call_type
= entry_call_record_sym
->type
;
538 /* Get the field indices. */
539 fieldnos
.common
= ada_get_field_index (type
, "common", 0);
540 fieldnos
.entry_calls
= ada_get_field_index (type
, "entry_calls", 1);
541 fieldnos
.atc_nesting_level
=
542 ada_get_field_index (type
, "atc_nesting_level", 1);
543 fieldnos
.state
= ada_get_field_index (common_type
, "state", 0);
544 fieldnos
.parent
= ada_get_field_index (common_type
, "parent", 1);
545 fieldnos
.priority
= ada_get_field_index (common_type
, "base_priority", 0);
546 fieldnos
.image
= ada_get_field_index (common_type
, "task_image", 1);
547 fieldnos
.image_len
= ada_get_field_index (common_type
, "task_image_len", 1);
548 fieldnos
.activation_link
= ada_get_field_index (common_type
,
549 "activation_link", 1);
550 fieldnos
.call
= ada_get_field_index (common_type
, "call", 1);
551 fieldnos
.ll
= ada_get_field_index (common_type
, "ll", 0);
552 fieldnos
.base_cpu
= ada_get_field_index (common_type
, "base_cpu", 0);
553 fieldnos
.ll_thread
= ada_get_field_index (ll_type
, "thread", 0);
554 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "lwp", 1);
555 fieldnos
.call_self
= ada_get_field_index (call_type
, "self", 0);
557 /* On certain platforms such as x86-windows, the "lwp" field has been
558 named "thread_id". This field will likely be renamed in the future,
559 but we need to support both possibilities to avoid an unnecessary
560 dependency on a recent compiler. We therefore try locating the
561 "thread_id" field in place of the "lwp" field if we did not find
563 if (fieldnos
.ll_lwp
< 0)
564 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "thread_id", 1);
566 /* Set all the out parameters all at once, now that we are certain
567 that there are no potential error() anymore. */
568 pspace_data
= get_ada_tasks_pspace_data (current_program_space
);
569 pspace_data
->initialized_p
= 1;
570 pspace_data
->atcb_type
= type
;
571 pspace_data
->atcb_common_type
= common_type
;
572 pspace_data
->atcb_ll_type
= ll_type
;
573 pspace_data
->atcb_call_type
= call_type
;
574 pspace_data
->atcb_fieldno
= fieldnos
;
578 /* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
579 component of its ATCB record. This PTID needs to match the PTID used
580 by the thread layer. */
583 ptid_from_atcb_common (struct value
*common_value
)
587 struct value
*ll_value
;
589 const struct ada_tasks_pspace_data
*pspace_data
590 = get_ada_tasks_pspace_data (current_program_space
);
592 ll_value
= value_field (common_value
, pspace_data
->atcb_fieldno
.ll
);
594 if (pspace_data
->atcb_fieldno
.ll_lwp
>= 0)
595 lwp
= value_as_address (value_field (ll_value
,
596 pspace_data
->atcb_fieldno
.ll_lwp
));
597 thread
= value_as_long (value_field (ll_value
,
598 pspace_data
->atcb_fieldno
.ll_thread
));
600 ptid
= target_get_ada_task_ptid (lwp
, thread
);
605 /* Read the ATCB data of a given task given its TASK_ID (which is in practice
606 the address of its assocated ATCB record), and store the result inside
610 read_atcb (CORE_ADDR task_id
, struct ada_task_info
*task_info
)
612 struct value
*tcb_value
;
613 struct value
*common_value
;
614 struct value
*atc_nesting_level_value
;
615 struct value
*entry_calls_value
;
616 struct value
*entry_calls_value_element
;
617 int called_task_fieldno
= -1;
618 static const char ravenscar_task_name
[] = "Ravenscar task";
619 const struct ada_tasks_pspace_data
*pspace_data
620 = get_ada_tasks_pspace_data (current_program_space
);
622 /* Clear the whole structure to start with, so that everything
623 is always initialized the same. */
624 memset (task_info
, 0, sizeof (struct ada_task_info
));
626 if (!pspace_data
->initialized_p
)
628 const char *err_msg
= ada_get_tcb_types_info ();
631 error (_("%s. Aborting"), err_msg
);
634 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
636 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
638 /* Fill in the task_id. */
640 task_info
->task_id
= task_id
;
642 /* Compute the name of the task.
644 Depending on the GNAT version used, the task image is either a fat
645 string, or a thin array of characters. Older versions of GNAT used
646 to use fat strings, and therefore did not need an extra field in
647 the ATCB to store the string length. For efficiency reasons, newer
648 versions of GNAT replaced the fat string by a static buffer, but this
649 also required the addition of a new field named "Image_Len" containing
650 the length of the task name. The method used to extract the task name
651 is selected depending on the existence of this field.
653 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
654 we may want to get it from the first user frame of the stack. For now,
655 we just give a dummy name. */
657 if (pspace_data
->atcb_fieldno
.image_len
== -1)
659 if (pspace_data
->atcb_fieldno
.image
>= 0)
660 read_fat_string_value (task_info
->name
,
661 value_field (common_value
,
662 pspace_data
->atcb_fieldno
.image
),
663 sizeof (task_info
->name
) - 1);
666 struct bound_minimal_symbol msym
;
668 msym
= lookup_minimal_symbol_by_pc (task_id
);
671 const char *full_name
= MSYMBOL_LINKAGE_NAME (msym
.minsym
);
672 const char *task_name
= full_name
;
675 /* Strip the prefix. */
676 for (p
= full_name
; *p
; p
++)
677 if (p
[0] == '_' && p
[1] == '_')
680 /* Copy the task name. */
681 strncpy (task_info
->name
, task_name
, sizeof (task_info
->name
));
682 task_info
->name
[sizeof (task_info
->name
) - 1] = 0;
686 /* No symbol found. Use a default name. */
687 strcpy (task_info
->name
, ravenscar_task_name
);
693 int len
= value_as_long
694 (value_field (common_value
,
695 pspace_data
->atcb_fieldno
.image_len
));
697 value_as_string (task_info
->name
,
698 value_field (common_value
,
699 pspace_data
->atcb_fieldno
.image
),
703 /* Compute the task state and priority. */
706 value_as_long (value_field (common_value
,
707 pspace_data
->atcb_fieldno
.state
));
708 task_info
->priority
=
709 value_as_long (value_field (common_value
,
710 pspace_data
->atcb_fieldno
.priority
));
712 /* If the ATCB contains some information about the parent task,
713 then compute it as well. Otherwise, zero. */
715 if (pspace_data
->atcb_fieldno
.parent
>= 0)
717 value_as_address (value_field (common_value
,
718 pspace_data
->atcb_fieldno
.parent
));
720 /* If the task is in an entry call waiting for another task,
721 then determine which task it is. */
723 if (task_info
->state
== Entry_Caller_Sleep
724 && pspace_data
->atcb_fieldno
.atc_nesting_level
> 0
725 && pspace_data
->atcb_fieldno
.entry_calls
> 0)
727 /* Let My_ATCB be the Ada task control block of a task calling the
728 entry of another task; then the Task_Id of the called task is
729 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
730 atc_nesting_level_value
=
731 value_field (tcb_value
, pspace_data
->atcb_fieldno
.atc_nesting_level
);
733 ada_coerce_to_simple_array_ptr
734 (value_field (tcb_value
, pspace_data
->atcb_fieldno
.entry_calls
));
735 entry_calls_value_element
=
736 value_subscript (entry_calls_value
,
737 value_as_long (atc_nesting_level_value
));
738 called_task_fieldno
=
739 ada_get_field_index (value_type (entry_calls_value_element
),
741 task_info
->called_task
=
742 value_as_address (value_field (entry_calls_value_element
,
743 called_task_fieldno
));
746 /* If the ATCB cotnains some information about RV callers, then
747 compute the "caller_task". Otherwise, leave it as zero. */
749 if (pspace_data
->atcb_fieldno
.call
>= 0)
751 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
752 If Common_ATCB.Call is null, then there is no caller. */
753 const CORE_ADDR call
=
754 value_as_address (value_field (common_value
,
755 pspace_data
->atcb_fieldno
.call
));
756 struct value
*call_val
;
761 value_from_contents_and_address (pspace_data
->atcb_call_type
,
763 task_info
->caller_task
=
765 (value_field (call_val
, pspace_data
->atcb_fieldno
.call_self
));
770 = value_as_long (value_field (common_value
,
771 pspace_data
->atcb_fieldno
.base_cpu
));
773 /* And finally, compute the task ptid. Note that there is not point
774 in computing it if the task is no longer alive, in which case
775 it is good enough to set its ptid to the null_ptid. */
776 if (ada_task_is_alive (task_info
))
777 task_info
->ptid
= ptid_from_atcb_common (common_value
);
779 task_info
->ptid
= null_ptid
;
782 /* Read the ATCB info of the given task (identified by TASK_ID), and
783 add the result to the given inferior's TASK_LIST. */
786 add_ada_task (CORE_ADDR task_id
, struct inferior
*inf
)
788 struct ada_task_info task_info
;
789 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
791 read_atcb (task_id
, &task_info
);
792 data
->task_list
.push_back (task_info
);
795 /* Read the Known_Tasks array from the inferior memory, and store
796 it in the current inferior's TASK_LIST. Return true upon success. */
799 read_known_tasks_array (struct ada_tasks_inferior_data
*data
)
801 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
802 const int known_tasks_size
= target_ptr_byte
* data
->known_tasks_length
;
803 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (known_tasks_size
);
806 /* Build a new list by reading the ATCBs from the Known_Tasks array
807 in the Ada runtime. */
808 read_memory (data
->known_tasks_addr
, known_tasks
, known_tasks_size
);
809 for (i
= 0; i
< data
->known_tasks_length
; i
++)
812 extract_typed_address (known_tasks
+ i
* target_ptr_byte
,
813 data
->known_tasks_element
);
816 add_ada_task (task_id
, current_inferior ());
822 /* Read the known tasks from the inferior memory, and store it in
823 the current inferior's TASK_LIST. Return true upon success. */
826 read_known_tasks_list (struct ada_tasks_inferior_data
*data
)
828 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
829 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (target_ptr_byte
);
831 const struct ada_tasks_pspace_data
*pspace_data
832 = get_ada_tasks_pspace_data (current_program_space
);
835 if (pspace_data
->atcb_fieldno
.activation_link
< 0)
838 /* Build a new list by reading the ATCBs. Read head of the list. */
839 read_memory (data
->known_tasks_addr
, known_tasks
, target_ptr_byte
);
840 task_id
= extract_typed_address (known_tasks
, data
->known_tasks_element
);
843 struct value
*tcb_value
;
844 struct value
*common_value
;
846 add_ada_task (task_id
, current_inferior ());
848 /* Read the chain. */
849 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
851 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
852 task_id
= value_as_address
853 (value_field (common_value
,
854 pspace_data
->atcb_fieldno
.activation_link
));
860 /* Set all fields of the current inferior ada-tasks data pointed by DATA.
861 Do nothing if those fields are already set and still up to date. */
864 ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data
*data
)
866 struct bound_minimal_symbol msym
;
869 /* Return now if already set. */
870 if (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
)
875 msym
= lookup_minimal_symbol (KNOWN_TASKS_NAME
, NULL
, NULL
);
876 if (msym
.minsym
!= NULL
)
878 data
->known_tasks_kind
= ADA_TASKS_ARRAY
;
879 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
881 /* Try to get pointer type and array length from the symtab. */
882 sym
= lookup_symbol_in_language (KNOWN_TASKS_NAME
, NULL
, VAR_DOMAIN
,
883 language_c
, NULL
).symbol
;
887 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
888 struct type
*eltype
= NULL
;
889 struct type
*idxtype
= NULL
;
891 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
892 eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
894 && TYPE_CODE (eltype
) == TYPE_CODE_PTR
)
895 idxtype
= check_typedef (TYPE_INDEX_TYPE (type
));
897 && !TYPE_LOW_BOUND_UNDEFINED (idxtype
)
898 && !TYPE_HIGH_BOUND_UNDEFINED (idxtype
))
900 data
->known_tasks_element
= eltype
;
901 data
->known_tasks_length
=
902 TYPE_HIGH_BOUND (idxtype
) - TYPE_LOW_BOUND (idxtype
) + 1;
907 /* Fallback to default values. The runtime may have been stripped (as
908 in some distributions), but it is likely that the executable still
909 contains debug information on the task type (due to implicit with of
911 data
->known_tasks_element
=
912 builtin_type (target_gdbarch ())->builtin_data_ptr
;
913 data
->known_tasks_length
= MAX_NUMBER_OF_KNOWN_TASKS
;
920 msym
= lookup_minimal_symbol (KNOWN_TASKS_LIST
, NULL
, NULL
);
921 if (msym
.minsym
!= NULL
)
923 data
->known_tasks_kind
= ADA_TASKS_LIST
;
924 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
925 data
->known_tasks_length
= 1;
927 sym
= lookup_symbol_in_language (KNOWN_TASKS_LIST
, NULL
, VAR_DOMAIN
,
928 language_c
, NULL
).symbol
;
929 if (sym
!= NULL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
932 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
934 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
936 data
->known_tasks_element
= type
;
941 /* Fallback to default values. */
942 data
->known_tasks_element
=
943 builtin_type (target_gdbarch ())->builtin_data_ptr
;
944 data
->known_tasks_length
= 1;
948 /* Can't find tasks. */
950 data
->known_tasks_kind
= ADA_TASKS_NOT_FOUND
;
951 data
->known_tasks_addr
= 0;
954 /* Read the known tasks from the current inferior's memory, and store it
955 in the current inferior's data TASK_LIST. */
960 struct ada_tasks_inferior_data
*data
=
961 get_ada_tasks_inferior_data (current_inferior ());
963 /* Step 1: Clear the current list, if necessary. */
964 data
->task_list
.clear ();
966 /* Step 2: do the real work.
967 If the application does not use task, then no more needs to be done.
968 It is important to have the task list cleared (see above) before we
969 return, as we don't want a stale task list to be used... This can
970 happen for instance when debugging a non-multitasking program after
971 having debugged a multitasking one. */
972 ada_tasks_inferior_data_sniffer (data
);
973 gdb_assert (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
);
975 /* Step 3: Set task_list_valid_p, to avoid re-reading the Known_Tasks
976 array unless needed. */
977 switch (data
->known_tasks_kind
)
979 case ADA_TASKS_NOT_FOUND
: /* Tasking not in use in inferior. */
981 case ADA_TASKS_ARRAY
:
982 data
->task_list_valid_p
= read_known_tasks_array (data
);
985 data
->task_list_valid_p
= read_known_tasks_list (data
);
990 /* Build the task_list by reading the Known_Tasks array from
991 the inferior, and return the number of tasks in that list
992 (zero means that the program is not using tasking at all). */
995 ada_build_task_list ()
997 struct ada_tasks_inferior_data
*data
;
999 if (!target_has_stack
)
1000 error (_("Cannot inspect Ada tasks when program is not running"));
1002 data
= get_ada_tasks_inferior_data (current_inferior ());
1003 if (!data
->task_list_valid_p
)
1004 read_known_tasks ();
1006 return data
->task_list
.size ();
1009 /* Print a table providing a short description of all Ada tasks
1010 running inside inferior INF. If ARG_STR is set, it will be
1011 interpreted as a task number, and the table will be limited to
1015 print_ada_task_info (struct ui_out
*uiout
,
1016 const char *arg_str
,
1017 struct inferior
*inf
)
1019 struct ada_tasks_inferior_data
*data
;
1020 int taskno
, nb_tasks
;
1024 if (ada_build_task_list () == 0)
1026 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1030 if (arg_str
!= NULL
&& arg_str
[0] != '\0')
1031 taskno_arg
= value_as_long (parse_and_eval (arg_str
));
1033 if (uiout
->is_mi_like_p ())
1034 /* In GDB/MI mode, we want to provide the thread ID corresponding
1035 to each task. This allows clients to quickly find the thread
1036 associated to any task, which is helpful for commands that
1037 take a --thread argument. However, in order to be able to
1038 provide that thread ID, the thread list must be up to date
1040 target_update_thread_list ();
1042 data
= get_ada_tasks_inferior_data (inf
);
1044 /* Compute the number of tasks that are going to be displayed
1045 in the output. If an argument was given, there will be
1046 at most 1 entry. Otherwise, there will be as many entries
1047 as we have tasks. */
1050 if (taskno_arg
> 0 && taskno_arg
<= data
->task_list
.size ())
1056 nb_tasks
= data
->task_list
.size ();
1058 nb_columns
= uiout
->is_mi_like_p () ? 8 : 7;
1059 ui_out_emit_table
table_emitter (uiout
, nb_columns
, nb_tasks
, "tasks");
1060 uiout
->table_header (1, ui_left
, "current", "");
1061 uiout
->table_header (3, ui_right
, "id", "ID");
1063 size_t tid_width
= 9;
1064 /* Grown below in case the largest entry is bigger. */
1066 if (!uiout
->is_mi_like_p ())
1068 for (taskno
= 1; taskno
<= data
->task_list
.size (); taskno
++)
1070 const struct ada_task_info
*const task_info
1071 = &data
->task_list
[taskno
- 1];
1073 gdb_assert (task_info
!= NULL
);
1075 tid_width
= std::max (tid_width
,
1076 1 + strlen (phex_nz (task_info
->task_id
,
1077 sizeof (CORE_ADDR
))));
1080 uiout
->table_header (tid_width
, ui_right
, "task-id", "TID");
1082 /* The following column is provided in GDB/MI mode only because
1083 it is only really useful in that mode, and also because it
1084 allows us to keep the CLI output shorter and more compact. */
1085 if (uiout
->is_mi_like_p ())
1086 uiout
->table_header (4, ui_right
, "thread-id", "");
1087 uiout
->table_header (4, ui_right
, "parent-id", "P-ID");
1088 uiout
->table_header (3, ui_right
, "priority", "Pri");
1089 uiout
->table_header (22, ui_left
, "state", "State");
1090 /* Use ui_noalign for the last column, to prevent the CLI uiout
1091 from printing an extra space at the end of each row. This
1092 is a bit of a hack, but does get the job done. */
1093 uiout
->table_header (1, ui_noalign
, "name", "Name");
1094 uiout
->table_body ();
1096 for (taskno
= 1; taskno
<= data
->task_list
.size (); taskno
++)
1098 const struct ada_task_info
*const task_info
=
1099 &data
->task_list
[taskno
- 1];
1102 gdb_assert (task_info
!= NULL
);
1104 /* If the user asked for the output to be restricted
1105 to one task only, and this is not the task, skip
1107 if (taskno_arg
&& taskno
!= taskno_arg
)
1110 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1112 /* Print a star if this task is the current task (or the task
1113 currently selected). */
1114 if (task_info
->ptid
== inferior_ptid
)
1115 uiout
->field_string ("current", "*");
1117 uiout
->field_skip ("current");
1119 /* Print the task number. */
1120 uiout
->field_signed ("id", taskno
);
1122 /* Print the Task ID. */
1123 uiout
->field_string ("task-id", phex_nz (task_info
->task_id
,
1124 sizeof (CORE_ADDR
)));
1126 /* Print the associated Thread ID. */
1127 if (uiout
->is_mi_like_p ())
1129 thread_info
*thread
= find_thread_ptid (task_info
->ptid
);
1132 uiout
->field_signed ("thread-id", thread
->global_num
);
1134 /* This should never happen unless there is a bug somewhere,
1135 but be resilient when that happens. */
1136 uiout
->field_skip ("thread-id");
1139 /* Print the ID of the parent task. */
1140 parent_id
= get_task_number_from_id (task_info
->parent
, inf
);
1142 uiout
->field_signed ("parent-id", parent_id
);
1144 uiout
->field_skip ("parent-id");
1146 /* Print the base priority of the task. */
1147 uiout
->field_signed ("priority", task_info
->priority
);
1149 /* Print the task current state. */
1150 if (task_info
->caller_task
)
1151 uiout
->field_fmt ("state",
1152 _("Accepting RV with %-4d"),
1153 get_task_number_from_id (task_info
->caller_task
,
1155 else if (task_info
->called_task
)
1156 uiout
->field_fmt ("state",
1157 _("Waiting on RV with %-3d"),
1158 get_task_number_from_id (task_info
->called_task
,
1161 uiout
->field_string ("state", task_states
[task_info
->state
]);
1163 /* Finally, print the task name, without quotes around it, as mi like
1164 is not expecting quotes, and in non mi-like no need for quotes
1165 as there is a specific column for the name. */
1166 uiout
->field_string ("name",
1167 task_info
->name
[0] != '\0' ? task_info
->name
1174 /* Print a detailed description of the Ada task whose ID is TASKNO_STR
1175 for the given inferior (INF). */
1178 info_task (struct ui_out
*uiout
, const char *taskno_str
, struct inferior
*inf
)
1180 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1181 struct ada_task_info
*task_info
;
1182 int parent_taskno
= 0;
1183 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1185 if (ada_build_task_list () == 0)
1187 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1191 if (taskno
<= 0 || taskno
> data
->task_list
.size ())
1192 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1193 "see the IDs of currently known tasks"), taskno
);
1194 task_info
= &data
->task_list
[taskno
- 1];
1196 /* Print the Ada task ID. */
1197 printf_filtered (_("Ada Task: %s\n"),
1198 paddress (target_gdbarch (), task_info
->task_id
));
1200 /* Print the name of the task. */
1201 if (task_info
->name
[0] != '\0')
1202 printf_filtered (_("Name: \"%s\"\n"), task_info
->name
);
1204 printf_filtered (_("<no name>\n"));
1206 /* Print the TID and LWP. */
1207 printf_filtered (_("Thread: %#lx\n"), task_info
->ptid
.tid ());
1208 printf_filtered (_("LWP: %#lx\n"), task_info
->ptid
.lwp ());
1210 /* If set, print the base CPU. */
1211 if (task_info
->base_cpu
!= 0)
1212 printf_filtered (_("Base CPU: %d\n"), task_info
->base_cpu
);
1214 /* Print who is the parent (if any). */
1215 if (task_info
->parent
!= 0)
1216 parent_taskno
= get_task_number_from_id (task_info
->parent
, inf
);
1219 struct ada_task_info
*parent
= &data
->task_list
[parent_taskno
- 1];
1221 printf_filtered (_("Parent: %d"), parent_taskno
);
1222 if (parent
->name
[0] != '\0')
1223 printf_filtered (" (\"%s\")", parent
->name
);
1224 printf_filtered ("\n");
1227 printf_filtered (_("No parent\n"));
1229 /* Print the base priority. */
1230 printf_filtered (_("Base Priority: %d\n"), task_info
->priority
);
1232 /* print the task current state. */
1234 int target_taskno
= 0;
1236 if (task_info
->caller_task
)
1238 target_taskno
= get_task_number_from_id (task_info
->caller_task
, inf
);
1239 printf_filtered (_("State: Accepting rendezvous with %d"),
1242 else if (task_info
->called_task
)
1244 target_taskno
= get_task_number_from_id (task_info
->called_task
, inf
);
1245 printf_filtered (_("State: Waiting on task %d's entry"),
1249 printf_filtered (_("State: %s"), _(long_task_states
[task_info
->state
]));
1253 ada_task_info
*target_task_info
= &data
->task_list
[target_taskno
- 1];
1255 if (target_task_info
->name
[0] != '\0')
1256 printf_filtered (" (\"%s\")", target_task_info
->name
);
1259 printf_filtered ("\n");
1263 /* If ARG is empty or null, then print a list of all Ada tasks.
1264 Otherwise, print detailed information about the task whose ID
1267 Does nothing if the program doesn't use Ada tasking. */
1270 info_tasks_command (const char *arg
, int from_tty
)
1272 struct ui_out
*uiout
= current_uiout
;
1274 if (arg
== NULL
|| *arg
== '\0')
1275 print_ada_task_info (uiout
, NULL
, current_inferior ());
1277 info_task (uiout
, arg
, current_inferior ());
1280 /* Print a message telling the user id of the current task.
1281 This function assumes that tasking is in use in the inferior. */
1284 display_current_task_id (void)
1286 const int current_task
= ada_get_task_number (inferior_thread ());
1288 if (current_task
== 0)
1289 printf_filtered (_("[Current task is unknown]\n"));
1292 struct ada_tasks_inferior_data
*data
1293 = get_ada_tasks_inferior_data (current_inferior ());
1294 struct ada_task_info
*task_info
= &data
->task_list
[current_task
- 1];
1296 printf_filtered (_("[Current task is %s]\n"),
1297 task_to_str (current_task
, task_info
).c_str ());
1301 /* Parse and evaluate TIDSTR into a task id, and try to switch to
1302 that task. Print an error message if the task switch failed. */
1305 task_command_1 (const char *taskno_str
, int from_tty
, struct inferior
*inf
)
1307 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1308 struct ada_task_info
*task_info
;
1309 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1311 if (taskno
<= 0 || taskno
> data
->task_list
.size ())
1312 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1313 "see the IDs of currently known tasks"), taskno
);
1314 task_info
= &data
->task_list
[taskno
- 1];
1316 if (!ada_task_is_alive (task_info
))
1317 error (_("Cannot switch to task %s: Task is no longer running"),
1318 task_to_str (taskno
, task_info
).c_str ());
1320 /* On some platforms, the thread list is not updated until the user
1321 performs a thread-related operation (by using the "info threads"
1322 command, for instance). So this thread list may not be up to date
1323 when the user attempts this task switch. Since we cannot switch
1324 to the thread associated to our task if GDB does not know about
1325 that thread, we need to make sure that any new threads gets added
1326 to the thread list. */
1327 target_update_thread_list ();
1329 /* Verify that the ptid of the task we want to switch to is valid
1330 (in other words, a ptid that GDB knows about). Otherwise, we will
1331 cause an assertion failure later on, when we try to determine
1332 the ptid associated thread_info data. We should normally never
1333 encounter such an error, but the wrong ptid can actually easily be
1334 computed if target_get_ada_task_ptid has not been implemented for
1335 our target (yet). Rather than cause an assertion error in that case,
1336 it's nicer for the user to just refuse to perform the task switch. */
1337 thread_info
*tp
= find_thread_ptid (task_info
->ptid
);
1339 error (_("Unable to compute thread ID for task %s.\n"
1340 "Cannot switch to this task."),
1341 task_to_str (taskno
, task_info
).c_str ());
1343 switch_to_thread (tp
);
1344 ada_find_printable_frame (get_selected_frame (NULL
));
1345 printf_filtered (_("[Switching to task %s]\n"),
1346 task_to_str (taskno
, task_info
).c_str ());
1347 print_stack_frame (get_selected_frame (NULL
),
1348 frame_relative_level (get_selected_frame (NULL
)),
1353 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
1354 Otherwise, switch to the task indicated by TASKNO_STR. */
1357 task_command (const char *taskno_str
, int from_tty
)
1359 struct ui_out
*uiout
= current_uiout
;
1361 if (ada_build_task_list () == 0)
1363 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1367 if (taskno_str
== NULL
|| taskno_str
[0] == '\0')
1368 display_current_task_id ();
1370 task_command_1 (taskno_str
, from_tty
, current_inferior ());
1373 /* Indicate that the given inferior's task list may have changed,
1374 so invalidate the cache. */
1377 ada_task_list_changed (struct inferior
*inf
)
1379 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1381 data
->task_list_valid_p
= false;
1384 /* Invalidate the per-program-space data. */
1387 ada_tasks_invalidate_pspace_data (struct program_space
*pspace
)
1389 get_ada_tasks_pspace_data (pspace
)->initialized_p
= 0;
1392 /* Invalidate the per-inferior data. */
1395 ada_tasks_invalidate_inferior_data (struct inferior
*inf
)
1397 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1399 data
->known_tasks_kind
= ADA_TASKS_UNKNOWN
;
1400 data
->task_list_valid_p
= false;
1403 /* The 'normal_stop' observer notification callback. */
1406 ada_tasks_normal_stop_observer (struct bpstats
*unused_args
, int unused_args2
)
1408 /* The inferior has been resumed, and just stopped. This means that
1409 our task_list needs to be recomputed before it can be used again. */
1410 ada_task_list_changed (current_inferior ());
1413 /* A routine to be called when the objfiles have changed. */
1416 ada_tasks_new_objfile_observer (struct objfile
*objfile
)
1418 struct inferior
*inf
;
1420 /* Invalidate the relevant data in our program-space data. */
1422 if (objfile
== NULL
)
1424 /* All objfiles are being cleared, so we should clear all
1425 our caches for all program spaces. */
1426 struct program_space
*pspace
;
1428 for (pspace
= program_spaces
; pspace
!= NULL
; pspace
= pspace
->next
)
1429 ada_tasks_invalidate_pspace_data (pspace
);
1433 /* The associated program-space data might have changed after
1434 this objfile was added. Invalidate all cached data. */
1435 ada_tasks_invalidate_pspace_data (objfile
->pspace
);
1438 /* Invalidate the per-inferior cache for all inferiors using
1439 this objfile (or, in other words, for all inferiors who have
1440 the same program-space as the objfile's program space).
1441 If all objfiles are being cleared (OBJFILE is NULL), then
1442 clear the caches for all inferiors. */
1444 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
1445 if (objfile
== NULL
|| inf
->pspace
== objfile
->pspace
)
1446 ada_tasks_invalidate_inferior_data (inf
);
1450 _initialize_tasks (void)
1452 /* Attach various observers. */
1453 gdb::observers::normal_stop
.attach (ada_tasks_normal_stop_observer
);
1454 gdb::observers::new_objfile
.attach (ada_tasks_new_objfile_observer
);
1456 /* Some new commands provided by this module. */
1457 add_info ("tasks", info_tasks_command
,
1458 _("Provide information about all known Ada tasks."));
1459 add_cmd ("task", class_run
, task_command
,
1460 _("Use this command to switch between Ada tasks.\n\
1461 Without argument, this command simply prints the current task ID."),