1 /* Copyright (C) 1992-2018 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 /* The name of the array in the GNAT runtime where the Ada Task Control
30 Block of each task is stored. */
31 #define KNOWN_TASKS_NAME "system__tasking__debug__known_tasks"
33 /* The maximum number of tasks known to the Ada runtime. */
34 static const int MAX_NUMBER_OF_KNOWN_TASKS
= 1000;
36 /* The name of the variable in the GNAT runtime where the head of a task
37 chain is saved. This is an alternate mechanism to find the list of known
39 #define KNOWN_TASKS_LIST "system__tasking__debug__first_task"
51 Master_Completion_Sleep
,
53 Interrupt_Server_Idle_Sleep
,
54 Interrupt_Server_Blocked_Interrupt_Sleep
,
58 Interrupt_Server_Blocked_On_Event_Flag
,
63 /* A short description corresponding to each possible task state. */
64 static const char *task_states
[] = {
68 N_("Child Activation Wait"),
69 N_("Accept or Select Term"),
70 N_("Waiting on entry call"),
71 N_("Async Select Wait"),
73 N_("Child Termination Wait"),
74 N_("Wait Child in Term Alt"),
79 N_("Asynchronous Hold"),
85 /* A longer description corresponding to each possible task state. */
86 static const char *long_task_states
[] = {
90 N_("Waiting for child activation"),
91 N_("Blocked in accept or select with terminate"),
92 N_("Waiting on entry call"),
93 N_("Asynchronous Selective Wait"),
95 N_("Waiting for children termination"),
96 N_("Waiting for children in terminate alternative"),
101 N_("Asynchronous Hold"),
104 N_("Blocked in selective wait statement")
107 /* The index of certain important fields in the Ada Task Control Block
108 record and sub-records. */
112 /* Fields in record Ada_Task_Control_Block. */
115 int atc_nesting_level
;
117 /* Fields in record Common_ATCB. */
122 int image_len
; /* This field may be missing. */
128 /* Fields in Task_Primitives.Private_Data. */
130 int ll_lwp
; /* This field may be missing. */
132 /* Fields in Common_ATCB.Call.all. */
136 /* This module's per-program-space data. */
138 struct ada_tasks_pspace_data
140 /* Nonzero if the data has been initialized. If set to zero,
141 it means that the data has either not been initialized, or
142 has potentially become stale. */
145 /* The ATCB record type. */
146 struct type
*atcb_type
;
148 /* The ATCB "Common" component type. */
149 struct type
*atcb_common_type
;
151 /* The type of the "ll" field, from the atcb_common_type. */
152 struct type
*atcb_ll_type
;
154 /* The type of the "call" field, from the atcb_common_type. */
155 struct type
*atcb_call_type
;
157 /* The index of various fields in the ATCB record and sub-records. */
158 struct atcb_fieldnos atcb_fieldno
;
161 /* Key to our per-program-space data. */
162 static const struct program_space_data
*ada_tasks_pspace_data_handle
;
164 typedef struct ada_task_info ada_task_info_s
;
165 DEF_VEC_O(ada_task_info_s
);
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
;
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
;
218 /* Type of elements of the known task. Usually a pointer. */
219 struct type
*known_tasks_element
;
221 /* Number of elements in the known tasks array. */
222 unsigned int known_tasks_length
;
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 int task_list_valid_p
;
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 VEC(ada_task_info_s
) *task_list
;
239 /* Key to our per-inferior data. */
240 static const struct inferior_data
*ada_tasks_inferior_data_handle
;
242 /* Return the ada-tasks module's data for the given program space (PSPACE).
243 If none is found, add a zero'ed one now.
245 This function always returns a valid object. */
247 static struct ada_tasks_pspace_data
*
248 get_ada_tasks_pspace_data (struct program_space
*pspace
)
250 struct ada_tasks_pspace_data
*data
;
252 data
= ((struct ada_tasks_pspace_data
*)
253 program_space_data (pspace
, ada_tasks_pspace_data_handle
));
256 data
= XCNEW (struct ada_tasks_pspace_data
);
257 set_program_space_data (pspace
, ada_tasks_pspace_data_handle
, data
);
263 /* Return the ada-tasks module's data for the given inferior (INF).
264 If none is found, add a zero'ed one now.
266 This function always returns a valid object.
268 Note that we could use an observer of the inferior-created event
269 to make sure that the ada-tasks per-inferior data always exists.
270 But we prefered this approach, as it avoids this entirely as long
271 as the user does not use any of the tasking features. This is
272 quite possible, particularly in the case where the inferior does
275 static struct ada_tasks_inferior_data
*
276 get_ada_tasks_inferior_data (struct inferior
*inf
)
278 struct ada_tasks_inferior_data
*data
;
280 data
= ((struct ada_tasks_inferior_data
*)
281 inferior_data (inf
, ada_tasks_inferior_data_handle
));
284 data
= XCNEW (struct ada_tasks_inferior_data
);
285 set_inferior_data (inf
, ada_tasks_inferior_data_handle
, data
);
291 /* Return the task number of the task whose thread is THREAD, or zero
292 if the task could not be found. */
295 ada_get_task_number (thread_info
*thread
)
298 struct inferior
*inf
= thread
->inf
;
299 struct ada_tasks_inferior_data
*data
;
301 gdb_assert (inf
!= NULL
);
302 data
= get_ada_tasks_inferior_data (inf
);
304 for (i
= 0; i
< VEC_length (ada_task_info_s
, data
->task_list
); i
++)
305 if (VEC_index (ada_task_info_s
, data
->task_list
, i
)->ptid
== thread
->ptid
)
308 return 0; /* No matching task found. */
311 /* Return the task number of the task running in inferior INF which
312 matches TASK_ID , or zero if the task could not be found. */
315 get_task_number_from_id (CORE_ADDR task_id
, struct inferior
*inf
)
317 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
320 for (i
= 0; i
< VEC_length (ada_task_info_s
, data
->task_list
); i
++)
322 struct ada_task_info
*task_info
=
323 VEC_index (ada_task_info_s
, data
->task_list
, i
);
325 if (task_info
->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 ());
343 && task_num
<= VEC_length (ada_task_info_s
, data
->task_list
));
346 /* Return non-zero iff the task STATE corresponds to a non-terminated
350 ada_task_is_alive (struct ada_task_info
*task_info
)
352 return (task_info
->state
!= Terminated
);
355 /* Search through the list of known tasks for the one whose ptid is
356 PTID, and return it. Return NULL if the task was not found. */
358 struct ada_task_info
*
359 ada_get_task_info_from_ptid (ptid_t ptid
)
362 struct ada_task_info
*task
;
363 struct ada_tasks_inferior_data
*data
;
365 ada_build_task_list ();
366 data
= get_ada_tasks_inferior_data (current_inferior ());
367 nb_tasks
= VEC_length (ada_task_info_s
, data
->task_list
);
369 for (i
= 0; i
< nb_tasks
; i
++)
371 task
= VEC_index (ada_task_info_s
, data
->task_list
, i
);
372 if (task
->ptid
== ptid
)
379 /* Call the ITERATOR function once for each Ada task that hasn't been
383 iterate_over_live_ada_tasks (ada_task_list_iterator_ftype
*iterator
)
386 struct ada_task_info
*task
;
387 struct ada_tasks_inferior_data
*data
;
389 ada_build_task_list ();
390 data
= get_ada_tasks_inferior_data (current_inferior ());
391 nb_tasks
= VEC_length (ada_task_info_s
, data
->task_list
);
393 for (i
= 0; i
< nb_tasks
; i
++)
395 task
= VEC_index (ada_task_info_s
, data
->task_list
, i
);
396 if (!ada_task_is_alive (task
))
402 /* Extract the contents of the value as a string whose length is LENGTH,
403 and store the result in DEST. */
406 value_as_string (char *dest
, struct value
*val
, int length
)
408 memcpy (dest
, value_contents (val
), length
);
412 /* Extract the string image from the fat string corresponding to VAL,
413 and store it in DEST. If the string length is greater than MAX_LEN,
414 then truncate the result to the first MAX_LEN characters of the fat
418 read_fat_string_value (char *dest
, struct value
*val
, int max_len
)
420 struct value
*array_val
;
421 struct value
*bounds_val
;
424 /* The following variables are made static to avoid recomputing them
425 each time this function is called. */
426 static int initialize_fieldnos
= 1;
427 static int array_fieldno
;
428 static int bounds_fieldno
;
429 static int upper_bound_fieldno
;
431 /* Get the index of the fields that we will need to read in order
432 to extract the string from the fat string. */
433 if (initialize_fieldnos
)
435 struct type
*type
= value_type (val
);
436 struct type
*bounds_type
;
438 array_fieldno
= ada_get_field_index (type
, "P_ARRAY", 0);
439 bounds_fieldno
= ada_get_field_index (type
, "P_BOUNDS", 0);
441 bounds_type
= TYPE_FIELD_TYPE (type
, bounds_fieldno
);
442 if (TYPE_CODE (bounds_type
) == TYPE_CODE_PTR
)
443 bounds_type
= TYPE_TARGET_TYPE (bounds_type
);
444 if (TYPE_CODE (bounds_type
) != TYPE_CODE_STRUCT
)
445 error (_("Unknown task name format. Aborting"));
446 upper_bound_fieldno
= ada_get_field_index (bounds_type
, "UB0", 0);
448 initialize_fieldnos
= 0;
451 /* Get the size of the task image by checking the value of the bounds.
452 The lower bound is always 1, so we only need to read the upper bound. */
453 bounds_val
= value_ind (value_field (val
, bounds_fieldno
));
454 len
= value_as_long (value_field (bounds_val
, upper_bound_fieldno
));
456 /* Make sure that we do not read more than max_len characters... */
460 /* Extract LEN characters from the fat string. */
461 array_val
= value_ind (value_field (val
, array_fieldno
));
462 read_memory (value_address (array_val
), (gdb_byte
*) dest
, len
);
464 /* Add the NUL character to close the string. */
468 /* Get, from the debugging information, the type description of all types
469 related to the Ada Task Control Block that are needed in order to
470 read the list of known tasks in the Ada runtime. If all of the info
471 needed to do so is found, then save that info in the module's per-
472 program-space data, and return NULL. Otherwise, if any information
473 cannot be found, leave the per-program-space data untouched, and
474 return an error message explaining what was missing (that error
475 message does NOT need to be deallocated). */
478 ada_get_tcb_types_info (void)
481 struct type
*common_type
;
482 struct type
*ll_type
;
483 struct type
*call_type
;
484 struct atcb_fieldnos fieldnos
;
485 struct ada_tasks_pspace_data
*pspace_data
;
487 const char *atcb_name
= "system__tasking__ada_task_control_block___XVE";
488 const char *atcb_name_fixed
= "system__tasking__ada_task_control_block";
489 const char *common_atcb_name
= "system__tasking__common_atcb";
490 const char *private_data_name
= "system__task_primitives__private_data";
491 const char *entry_call_record_name
= "system__tasking__entry_call_record";
493 /* ATCB symbols may be found in several compilation units. As we
494 are only interested in one instance, use standard (literal,
495 C-like) lookups to get the first match. */
497 struct symbol
*atcb_sym
=
498 lookup_symbol_in_language (atcb_name
, NULL
, STRUCT_DOMAIN
,
499 language_c
, NULL
).symbol
;
500 const struct symbol
*common_atcb_sym
=
501 lookup_symbol_in_language (common_atcb_name
, NULL
, STRUCT_DOMAIN
,
502 language_c
, NULL
).symbol
;
503 const struct symbol
*private_data_sym
=
504 lookup_symbol_in_language (private_data_name
, NULL
, STRUCT_DOMAIN
,
505 language_c
, NULL
).symbol
;
506 const struct symbol
*entry_call_record_sym
=
507 lookup_symbol_in_language (entry_call_record_name
, NULL
, STRUCT_DOMAIN
,
508 language_c
, NULL
).symbol
;
510 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
512 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
513 size, so the symbol name differs. */
514 atcb_sym
= lookup_symbol_in_language (atcb_name_fixed
, NULL
,
515 STRUCT_DOMAIN
, language_c
,
518 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
519 return _("Cannot find Ada_Task_Control_Block type");
521 type
= atcb_sym
->type
;
525 /* Get a static representation of the type record
526 Ada_Task_Control_Block. */
527 type
= atcb_sym
->type
;
528 type
= ada_template_to_fixed_record_type_1 (type
, NULL
, 0, NULL
, 0);
531 if (common_atcb_sym
== NULL
|| common_atcb_sym
->type
== NULL
)
532 return _("Cannot find Common_ATCB type");
533 if (private_data_sym
== NULL
|| private_data_sym
->type
== NULL
)
534 return _("Cannot find Private_Data type");
535 if (entry_call_record_sym
== NULL
|| entry_call_record_sym
->type
== NULL
)
536 return _("Cannot find Entry_Call_Record type");
538 /* Get the type for Ada_Task_Control_Block.Common. */
539 common_type
= common_atcb_sym
->type
;
541 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
542 ll_type
= private_data_sym
->type
;
544 /* Get the type for Common_ATCB.Call.all. */
545 call_type
= entry_call_record_sym
->type
;
547 /* Get the field indices. */
548 fieldnos
.common
= ada_get_field_index (type
, "common", 0);
549 fieldnos
.entry_calls
= ada_get_field_index (type
, "entry_calls", 1);
550 fieldnos
.atc_nesting_level
=
551 ada_get_field_index (type
, "atc_nesting_level", 1);
552 fieldnos
.state
= ada_get_field_index (common_type
, "state", 0);
553 fieldnos
.parent
= ada_get_field_index (common_type
, "parent", 1);
554 fieldnos
.priority
= ada_get_field_index (common_type
, "base_priority", 0);
555 fieldnos
.image
= ada_get_field_index (common_type
, "task_image", 1);
556 fieldnos
.image_len
= ada_get_field_index (common_type
, "task_image_len", 1);
557 fieldnos
.activation_link
= ada_get_field_index (common_type
,
558 "activation_link", 1);
559 fieldnos
.call
= ada_get_field_index (common_type
, "call", 1);
560 fieldnos
.ll
= ada_get_field_index (common_type
, "ll", 0);
561 fieldnos
.base_cpu
= ada_get_field_index (common_type
, "base_cpu", 0);
562 fieldnos
.ll_thread
= ada_get_field_index (ll_type
, "thread", 0);
563 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "lwp", 1);
564 fieldnos
.call_self
= ada_get_field_index (call_type
, "self", 0);
566 /* On certain platforms such as x86-windows, the "lwp" field has been
567 named "thread_id". This field will likely be renamed in the future,
568 but we need to support both possibilities to avoid an unnecessary
569 dependency on a recent compiler. We therefore try locating the
570 "thread_id" field in place of the "lwp" field if we did not find
572 if (fieldnos
.ll_lwp
< 0)
573 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "thread_id", 1);
575 /* Set all the out parameters all at once, now that we are certain
576 that there are no potential error() anymore. */
577 pspace_data
= get_ada_tasks_pspace_data (current_program_space
);
578 pspace_data
->initialized_p
= 1;
579 pspace_data
->atcb_type
= type
;
580 pspace_data
->atcb_common_type
= common_type
;
581 pspace_data
->atcb_ll_type
= ll_type
;
582 pspace_data
->atcb_call_type
= call_type
;
583 pspace_data
->atcb_fieldno
= fieldnos
;
587 /* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
588 component of its ATCB record. This PTID needs to match the PTID used
589 by the thread layer. */
592 ptid_from_atcb_common (struct value
*common_value
)
596 struct value
*ll_value
;
598 const struct ada_tasks_pspace_data
*pspace_data
599 = get_ada_tasks_pspace_data (current_program_space
);
601 ll_value
= value_field (common_value
, pspace_data
->atcb_fieldno
.ll
);
603 if (pspace_data
->atcb_fieldno
.ll_lwp
>= 0)
604 lwp
= value_as_address (value_field (ll_value
,
605 pspace_data
->atcb_fieldno
.ll_lwp
));
606 thread
= value_as_long (value_field (ll_value
,
607 pspace_data
->atcb_fieldno
.ll_thread
));
609 ptid
= target_get_ada_task_ptid (lwp
, thread
);
614 /* Read the ATCB data of a given task given its TASK_ID (which is in practice
615 the address of its assocated ATCB record), and store the result inside
619 read_atcb (CORE_ADDR task_id
, struct ada_task_info
*task_info
)
621 struct value
*tcb_value
;
622 struct value
*common_value
;
623 struct value
*atc_nesting_level_value
;
624 struct value
*entry_calls_value
;
625 struct value
*entry_calls_value_element
;
626 int called_task_fieldno
= -1;
627 static const char ravenscar_task_name
[] = "Ravenscar task";
628 const struct ada_tasks_pspace_data
*pspace_data
629 = get_ada_tasks_pspace_data (current_program_space
);
631 if (!pspace_data
->initialized_p
)
633 const char *err_msg
= ada_get_tcb_types_info ();
636 error (_("%s. Aborting"), err_msg
);
639 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
641 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
643 /* Fill in the task_id. */
645 task_info
->task_id
= task_id
;
647 /* Compute the name of the task.
649 Depending on the GNAT version used, the task image is either a fat
650 string, or a thin array of characters. Older versions of GNAT used
651 to use fat strings, and therefore did not need an extra field in
652 the ATCB to store the string length. For efficiency reasons, newer
653 versions of GNAT replaced the fat string by a static buffer, but this
654 also required the addition of a new field named "Image_Len" containing
655 the length of the task name. The method used to extract the task name
656 is selected depending on the existence of this field.
658 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
659 we may want to get it from the first user frame of the stack. For now,
660 we just give a dummy name. */
662 if (pspace_data
->atcb_fieldno
.image_len
== -1)
664 if (pspace_data
->atcb_fieldno
.image
>= 0)
665 read_fat_string_value (task_info
->name
,
666 value_field (common_value
,
667 pspace_data
->atcb_fieldno
.image
),
668 sizeof (task_info
->name
) - 1);
671 struct bound_minimal_symbol msym
;
673 msym
= lookup_minimal_symbol_by_pc (task_id
);
676 const char *full_name
= MSYMBOL_LINKAGE_NAME (msym
.minsym
);
677 const char *task_name
= full_name
;
680 /* Strip the prefix. */
681 for (p
= full_name
; *p
; p
++)
682 if (p
[0] == '_' && p
[1] == '_')
685 /* Copy the task name. */
686 strncpy (task_info
->name
, task_name
, sizeof (task_info
->name
));
687 task_info
->name
[sizeof (task_info
->name
) - 1] = 0;
691 /* No symbol found. Use a default name. */
692 strcpy (task_info
->name
, ravenscar_task_name
);
698 int len
= value_as_long
699 (value_field (common_value
,
700 pspace_data
->atcb_fieldno
.image_len
));
702 value_as_string (task_info
->name
,
703 value_field (common_value
,
704 pspace_data
->atcb_fieldno
.image
),
708 /* Compute the task state and priority. */
711 value_as_long (value_field (common_value
,
712 pspace_data
->atcb_fieldno
.state
));
713 task_info
->priority
=
714 value_as_long (value_field (common_value
,
715 pspace_data
->atcb_fieldno
.priority
));
717 /* If the ATCB contains some information about the parent task,
718 then compute it as well. Otherwise, zero. */
720 if (pspace_data
->atcb_fieldno
.parent
>= 0)
722 value_as_address (value_field (common_value
,
723 pspace_data
->atcb_fieldno
.parent
));
725 task_info
->parent
= 0;
728 /* If the ATCB contains some information about entry calls, then
729 compute the "called_task" as well. Otherwise, zero. */
731 if (pspace_data
->atcb_fieldno
.atc_nesting_level
> 0
732 && pspace_data
->atcb_fieldno
.entry_calls
> 0)
734 /* Let My_ATCB be the Ada task control block of a task calling the
735 entry of another task; then the Task_Id of the called task is
736 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
737 atc_nesting_level_value
=
738 value_field (tcb_value
, pspace_data
->atcb_fieldno
.atc_nesting_level
);
740 ada_coerce_to_simple_array_ptr
741 (value_field (tcb_value
, pspace_data
->atcb_fieldno
.entry_calls
));
742 entry_calls_value_element
=
743 value_subscript (entry_calls_value
,
744 value_as_long (atc_nesting_level_value
));
745 called_task_fieldno
=
746 ada_get_field_index (value_type (entry_calls_value_element
),
748 task_info
->called_task
=
749 value_as_address (value_field (entry_calls_value_element
,
750 called_task_fieldno
));
754 task_info
->called_task
= 0;
757 /* If the ATCB cotnains some information about RV callers,
758 then compute the "caller_task". Otherwise, zero. */
760 task_info
->caller_task
= 0;
761 if (pspace_data
->atcb_fieldno
.call
>= 0)
763 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
764 If Common_ATCB.Call is null, then there is no caller. */
765 const CORE_ADDR call
=
766 value_as_address (value_field (common_value
,
767 pspace_data
->atcb_fieldno
.call
));
768 struct value
*call_val
;
773 value_from_contents_and_address (pspace_data
->atcb_call_type
,
775 task_info
->caller_task
=
777 (value_field (call_val
, pspace_data
->atcb_fieldno
.call_self
));
782 = value_as_long (value_field (common_value
,
783 pspace_data
->atcb_fieldno
.base_cpu
));
785 /* And finally, compute the task ptid. Note that there is not point
786 in computing it if the task is no longer alive, in which case
787 it is good enough to set its ptid to the null_ptid. */
788 if (ada_task_is_alive (task_info
))
789 task_info
->ptid
= ptid_from_atcb_common (common_value
);
791 task_info
->ptid
= null_ptid
;
794 /* Read the ATCB info of the given task (identified by TASK_ID), and
795 add the result to the given inferior's TASK_LIST. */
798 add_ada_task (CORE_ADDR task_id
, struct inferior
*inf
)
800 struct ada_task_info task_info
;
801 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
803 read_atcb (task_id
, &task_info
);
804 VEC_safe_push (ada_task_info_s
, data
->task_list
, &task_info
);
807 /* Read the Known_Tasks array from the inferior memory, and store
808 it in the current inferior's TASK_LIST. Return non-zero upon success. */
811 read_known_tasks_array (struct ada_tasks_inferior_data
*data
)
813 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
814 const int known_tasks_size
= target_ptr_byte
* data
->known_tasks_length
;
815 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (known_tasks_size
);
818 /* Build a new list by reading the ATCBs from the Known_Tasks array
819 in the Ada runtime. */
820 read_memory (data
->known_tasks_addr
, known_tasks
, known_tasks_size
);
821 for (i
= 0; i
< data
->known_tasks_length
; i
++)
824 extract_typed_address (known_tasks
+ i
* target_ptr_byte
,
825 data
->known_tasks_element
);
828 add_ada_task (task_id
, current_inferior ());
834 /* Read the known tasks from the inferior memory, and store it in
835 the current inferior's TASK_LIST. Return non-zero upon success. */
838 read_known_tasks_list (struct ada_tasks_inferior_data
*data
)
840 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
841 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (target_ptr_byte
);
843 const struct ada_tasks_pspace_data
*pspace_data
844 = get_ada_tasks_pspace_data (current_program_space
);
847 if (pspace_data
->atcb_fieldno
.activation_link
< 0)
850 /* Build a new list by reading the ATCBs. Read head of the list. */
851 read_memory (data
->known_tasks_addr
, known_tasks
, target_ptr_byte
);
852 task_id
= extract_typed_address (known_tasks
, data
->known_tasks_element
);
855 struct value
*tcb_value
;
856 struct value
*common_value
;
858 add_ada_task (task_id
, current_inferior ());
860 /* Read the chain. */
861 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
863 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
864 task_id
= value_as_address
865 (value_field (common_value
,
866 pspace_data
->atcb_fieldno
.activation_link
));
872 /* Set all fields of the current inferior ada-tasks data pointed by DATA.
873 Do nothing if those fields are already set and still up to date. */
876 ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data
*data
)
878 struct bound_minimal_symbol msym
;
881 /* Return now if already set. */
882 if (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
)
887 msym
= lookup_minimal_symbol (KNOWN_TASKS_NAME
, NULL
, NULL
);
888 if (msym
.minsym
!= NULL
)
890 data
->known_tasks_kind
= ADA_TASKS_ARRAY
;
891 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
893 /* Try to get pointer type and array length from the symtab. */
894 sym
= lookup_symbol_in_language (KNOWN_TASKS_NAME
, NULL
, VAR_DOMAIN
,
895 language_c
, NULL
).symbol
;
899 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
900 struct type
*eltype
= NULL
;
901 struct type
*idxtype
= NULL
;
903 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
904 eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
906 && TYPE_CODE (eltype
) == TYPE_CODE_PTR
)
907 idxtype
= check_typedef (TYPE_INDEX_TYPE (type
));
909 && !TYPE_LOW_BOUND_UNDEFINED (idxtype
)
910 && !TYPE_HIGH_BOUND_UNDEFINED (idxtype
))
912 data
->known_tasks_element
= eltype
;
913 data
->known_tasks_length
=
914 TYPE_HIGH_BOUND (idxtype
) - TYPE_LOW_BOUND (idxtype
) + 1;
919 /* Fallback to default values. The runtime may have been stripped (as
920 in some distributions), but it is likely that the executable still
921 contains debug information on the task type (due to implicit with of
923 data
->known_tasks_element
=
924 builtin_type (target_gdbarch ())->builtin_data_ptr
;
925 data
->known_tasks_length
= MAX_NUMBER_OF_KNOWN_TASKS
;
932 msym
= lookup_minimal_symbol (KNOWN_TASKS_LIST
, NULL
, NULL
);
933 if (msym
.minsym
!= NULL
)
935 data
->known_tasks_kind
= ADA_TASKS_LIST
;
936 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
937 data
->known_tasks_length
= 1;
939 sym
= lookup_symbol_in_language (KNOWN_TASKS_LIST
, NULL
, VAR_DOMAIN
,
940 language_c
, NULL
).symbol
;
941 if (sym
!= NULL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
944 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
946 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
948 data
->known_tasks_element
= type
;
953 /* Fallback to default values. */
954 data
->known_tasks_element
=
955 builtin_type (target_gdbarch ())->builtin_data_ptr
;
956 data
->known_tasks_length
= 1;
960 /* Can't find tasks. */
962 data
->known_tasks_kind
= ADA_TASKS_NOT_FOUND
;
963 data
->known_tasks_addr
= 0;
966 /* Read the known tasks from the current inferior's memory, and store it
967 in the current inferior's data TASK_LIST.
968 Return non-zero upon success. */
971 read_known_tasks (void)
973 struct ada_tasks_inferior_data
*data
=
974 get_ada_tasks_inferior_data (current_inferior ());
976 /* Step 1: Clear the current list, if necessary. */
977 VEC_truncate (ada_task_info_s
, data
->task_list
, 0);
979 /* Step 2: do the real work.
980 If the application does not use task, then no more needs to be done.
981 It is important to have the task list cleared (see above) before we
982 return, as we don't want a stale task list to be used... This can
983 happen for instance when debugging a non-multitasking program after
984 having debugged a multitasking one. */
985 ada_tasks_inferior_data_sniffer (data
);
986 gdb_assert (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
);
988 switch (data
->known_tasks_kind
)
990 case ADA_TASKS_NOT_FOUND
: /* Tasking not in use in inferior. */
992 case ADA_TASKS_ARRAY
:
993 return read_known_tasks_array (data
);
995 return read_known_tasks_list (data
);
998 /* Step 3: Set task_list_valid_p, to avoid re-reading the Known_Tasks
999 array unless needed. Then report a success. */
1000 data
->task_list_valid_p
= 1;
1005 /* Build the task_list by reading the Known_Tasks array from
1006 the inferior, and return the number of tasks in that list
1007 (zero means that the program is not using tasking at all). */
1010 ada_build_task_list (void)
1012 struct ada_tasks_inferior_data
*data
;
1014 if (!target_has_stack
)
1015 error (_("Cannot inspect Ada tasks when program is not running"));
1017 data
= get_ada_tasks_inferior_data (current_inferior ());
1018 if (!data
->task_list_valid_p
)
1019 read_known_tasks ();
1021 return VEC_length (ada_task_info_s
, data
->task_list
);
1024 /* Print a table providing a short description of all Ada tasks
1025 running inside inferior INF. If ARG_STR is set, it will be
1026 interpreted as a task number, and the table will be limited to
1030 print_ada_task_info (struct ui_out
*uiout
,
1032 struct inferior
*inf
)
1034 struct ada_tasks_inferior_data
*data
;
1035 int taskno
, nb_tasks
;
1039 if (ada_build_task_list () == 0)
1041 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1045 if (arg_str
!= NULL
&& arg_str
[0] != '\0')
1046 taskno_arg
= value_as_long (parse_and_eval (arg_str
));
1048 if (uiout
->is_mi_like_p ())
1049 /* In GDB/MI mode, we want to provide the thread ID corresponding
1050 to each task. This allows clients to quickly find the thread
1051 associated to any task, which is helpful for commands that
1052 take a --thread argument. However, in order to be able to
1053 provide that thread ID, the thread list must be up to date
1055 target_update_thread_list ();
1057 data
= get_ada_tasks_inferior_data (inf
);
1059 /* Compute the number of tasks that are going to be displayed
1060 in the output. If an argument was given, there will be
1061 at most 1 entry. Otherwise, there will be as many entries
1062 as we have tasks. */
1066 && taskno_arg
<= VEC_length (ada_task_info_s
, data
->task_list
))
1072 nb_tasks
= VEC_length (ada_task_info_s
, data
->task_list
);
1074 nb_columns
= uiout
->is_mi_like_p () ? 8 : 7;
1075 ui_out_emit_table
table_emitter (uiout
, nb_columns
, nb_tasks
, "tasks");
1076 uiout
->table_header (1, ui_left
, "current", "");
1077 uiout
->table_header (3, ui_right
, "id", "ID");
1078 uiout
->table_header (9, ui_right
, "task-id", "TID");
1079 /* The following column is provided in GDB/MI mode only because
1080 it is only really useful in that mode, and also because it
1081 allows us to keep the CLI output shorter and more compact. */
1082 if (uiout
->is_mi_like_p ())
1083 uiout
->table_header (4, ui_right
, "thread-id", "");
1084 uiout
->table_header (4, ui_right
, "parent-id", "P-ID");
1085 uiout
->table_header (3, ui_right
, "priority", "Pri");
1086 uiout
->table_header (22, ui_left
, "state", "State");
1087 /* Use ui_noalign for the last column, to prevent the CLI uiout
1088 from printing an extra space at the end of each row. This
1089 is a bit of a hack, but does get the job done. */
1090 uiout
->table_header (1, ui_noalign
, "name", "Name");
1091 uiout
->table_body ();
1094 taskno
<= VEC_length (ada_task_info_s
, data
->task_list
);
1097 const struct ada_task_info
*const task_info
=
1098 VEC_index (ada_task_info_s
, data
->task_list
, taskno
- 1);
1101 gdb_assert (task_info
!= NULL
);
1103 /* If the user asked for the output to be restricted
1104 to one task only, and this is not the task, skip
1106 if (taskno_arg
&& taskno
!= taskno_arg
)
1109 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1111 /* Print a star if this task is the current task (or the task
1112 currently selected). */
1113 if (task_info
->ptid
== inferior_ptid
)
1114 uiout
->field_string ("current", "*");
1116 uiout
->field_skip ("current");
1118 /* Print the task number. */
1119 uiout
->field_int ("id", taskno
);
1121 /* Print the Task ID. */
1122 uiout
->field_fmt ("task-id", "%9lx", (long) task_info
->task_id
);
1124 /* Print the associated Thread ID. */
1125 if (uiout
->is_mi_like_p ())
1127 thread_info
*thread
= find_thread_ptid (task_info
->ptid
);
1130 uiout
->field_int ("thread-id", thread
->global_num
);
1132 /* This should never happen unless there is a bug somewhere,
1133 but be resilient when that happens. */
1134 uiout
->field_skip ("thread-id");
1137 /* Print the ID of the parent task. */
1138 parent_id
= get_task_number_from_id (task_info
->parent
, inf
);
1140 uiout
->field_int ("parent-id", parent_id
);
1142 uiout
->field_skip ("parent-id");
1144 /* Print the base priority of the task. */
1145 uiout
->field_int ("priority", task_info
->priority
);
1147 /* Print the task current state. */
1148 if (task_info
->caller_task
)
1149 uiout
->field_fmt ("state",
1150 _("Accepting RV with %-4d"),
1151 get_task_number_from_id (task_info
->caller_task
,
1153 else if (task_info
->state
== Entry_Caller_Sleep
1154 && task_info
->called_task
)
1155 uiout
->field_fmt ("state",
1156 _("Waiting on RV with %-3d"),
1157 get_task_number_from_id (task_info
->called_task
,
1160 uiout
->field_string ("state", task_states
[task_info
->state
]);
1162 /* Finally, print the task name. */
1163 uiout
->field_fmt ("name",
1165 task_info
->name
[0] != '\0' ? task_info
->name
1172 /* Print a detailed description of the Ada task whose ID is TASKNO_STR
1173 for the given inferior (INF). */
1176 info_task (struct ui_out
*uiout
, const char *taskno_str
, struct inferior
*inf
)
1178 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1179 struct ada_task_info
*task_info
;
1180 int parent_taskno
= 0;
1181 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1183 if (ada_build_task_list () == 0)
1185 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1189 if (taskno
<= 0 || taskno
> VEC_length (ada_task_info_s
, data
->task_list
))
1190 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1191 "see the IDs of currently known tasks"), taskno
);
1192 task_info
= VEC_index (ada_task_info_s
, data
->task_list
, taskno
- 1);
1194 /* Print the Ada task ID. */
1195 printf_filtered (_("Ada Task: %s\n"),
1196 paddress (target_gdbarch (), task_info
->task_id
));
1198 /* Print the name of the task. */
1199 if (task_info
->name
[0] != '\0')
1200 printf_filtered (_("Name: %s\n"), task_info
->name
);
1202 printf_filtered (_("<no name>\n"));
1204 /* Print the TID and LWP. */
1205 printf_filtered (_("Thread: %#lx\n"), task_info
->ptid
.tid ());
1206 printf_filtered (_("LWP: %#lx\n"), task_info
->ptid
.lwp ());
1208 /* If set, print the base CPU. */
1209 if (task_info
->base_cpu
!= 0)
1210 printf_filtered (_("Base CPU: %d\n"), task_info
->base_cpu
);
1212 /* Print who is the parent (if any). */
1213 if (task_info
->parent
!= 0)
1214 parent_taskno
= get_task_number_from_id (task_info
->parent
, inf
);
1217 struct ada_task_info
*parent
=
1218 VEC_index (ada_task_info_s
, data
->task_list
, parent_taskno
- 1);
1220 printf_filtered (_("Parent: %d"), parent_taskno
);
1221 if (parent
->name
[0] != '\0')
1222 printf_filtered (" (%s)", parent
->name
);
1223 printf_filtered ("\n");
1226 printf_filtered (_("No parent\n"));
1228 /* Print the base priority. */
1229 printf_filtered (_("Base Priority: %d\n"), task_info
->priority
);
1231 /* print the task current state. */
1233 int target_taskno
= 0;
1235 if (task_info
->caller_task
)
1237 target_taskno
= get_task_number_from_id (task_info
->caller_task
, inf
);
1238 printf_filtered (_("State: Accepting rendezvous with %d"),
1241 else if (task_info
->state
== Entry_Caller_Sleep
&& task_info
->called_task
)
1243 target_taskno
= get_task_number_from_id (task_info
->called_task
, inf
);
1244 printf_filtered (_("State: Waiting on task %d's entry"),
1248 printf_filtered (_("State: %s"), _(long_task_states
[task_info
->state
]));
1252 struct ada_task_info
*target_task_info
=
1253 VEC_index (ada_task_info_s
, 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"));
1291 printf_filtered (_("[Current task is %d]\n"), current_task
);
1294 /* Parse and evaluate TIDSTR into a task id, and try to switch to
1295 that task. Print an error message if the task switch failed. */
1298 task_command_1 (const char *taskno_str
, int from_tty
, struct inferior
*inf
)
1300 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1301 struct ada_task_info
*task_info
;
1302 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1304 if (taskno
<= 0 || taskno
> VEC_length (ada_task_info_s
, data
->task_list
))
1305 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1306 "see the IDs of currently known tasks"), taskno
);
1307 task_info
= VEC_index (ada_task_info_s
, data
->task_list
, taskno
- 1);
1309 if (!ada_task_is_alive (task_info
))
1310 error (_("Cannot switch to task %d: Task is no longer running"), taskno
);
1312 /* On some platforms, the thread list is not updated until the user
1313 performs a thread-related operation (by using the "info threads"
1314 command, for instance). So this thread list may not be up to date
1315 when the user attempts this task switch. Since we cannot switch
1316 to the thread associated to our task if GDB does not know about
1317 that thread, we need to make sure that any new threads gets added
1318 to the thread list. */
1319 target_update_thread_list ();
1321 /* Verify that the ptid of the task we want to switch to is valid
1322 (in other words, a ptid that GDB knows about). Otherwise, we will
1323 cause an assertion failure later on, when we try to determine
1324 the ptid associated thread_info data. We should normally never
1325 encounter such an error, but the wrong ptid can actually easily be
1326 computed if target_get_ada_task_ptid has not been implemented for
1327 our target (yet). Rather than cause an assertion error in that case,
1328 it's nicer for the user to just refuse to perform the task switch. */
1329 thread_info
*tp
= find_thread_ptid (task_info
->ptid
);
1331 error (_("Unable to compute thread ID for task %d.\n"
1332 "Cannot switch to this task."),
1335 switch_to_thread (tp
);
1336 ada_find_printable_frame (get_selected_frame (NULL
));
1337 printf_filtered (_("[Switching to task %d]\n"), taskno
);
1338 print_stack_frame (get_selected_frame (NULL
),
1339 frame_relative_level (get_selected_frame (NULL
)),
1344 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
1345 Otherwise, switch to the task indicated by TASKNO_STR. */
1348 task_command (const char *taskno_str
, int from_tty
)
1350 struct ui_out
*uiout
= current_uiout
;
1352 if (ada_build_task_list () == 0)
1354 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1358 if (taskno_str
== NULL
|| taskno_str
[0] == '\0')
1359 display_current_task_id ();
1361 task_command_1 (taskno_str
, from_tty
, current_inferior ());
1364 /* Indicate that the given inferior's task list may have changed,
1365 so invalidate the cache. */
1368 ada_task_list_changed (struct inferior
*inf
)
1370 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1372 data
->task_list_valid_p
= 0;
1375 /* Invalidate the per-program-space data. */
1378 ada_tasks_invalidate_pspace_data (struct program_space
*pspace
)
1380 get_ada_tasks_pspace_data (pspace
)->initialized_p
= 0;
1383 /* Invalidate the per-inferior data. */
1386 ada_tasks_invalidate_inferior_data (struct inferior
*inf
)
1388 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1390 data
->known_tasks_kind
= ADA_TASKS_UNKNOWN
;
1391 data
->task_list_valid_p
= 0;
1394 /* The 'normal_stop' observer notification callback. */
1397 ada_tasks_normal_stop_observer (struct bpstats
*unused_args
, int unused_args2
)
1399 /* The inferior has been resumed, and just stopped. This means that
1400 our task_list needs to be recomputed before it can be used again. */
1401 ada_task_list_changed (current_inferior ());
1404 /* A routine to be called when the objfiles have changed. */
1407 ada_tasks_new_objfile_observer (struct objfile
*objfile
)
1409 struct inferior
*inf
;
1411 /* Invalidate the relevant data in our program-space data. */
1413 if (objfile
== NULL
)
1415 /* All objfiles are being cleared, so we should clear all
1416 our caches for all program spaces. */
1417 struct program_space
*pspace
;
1419 for (pspace
= program_spaces
; pspace
!= NULL
; pspace
= pspace
->next
)
1420 ada_tasks_invalidate_pspace_data (pspace
);
1424 /* The associated program-space data might have changed after
1425 this objfile was added. Invalidate all cached data. */
1426 ada_tasks_invalidate_pspace_data (objfile
->pspace
);
1429 /* Invalidate the per-inferior cache for all inferiors using
1430 this objfile (or, in other words, for all inferiors who have
1431 the same program-space as the objfile's program space).
1432 If all objfiles are being cleared (OBJFILE is NULL), then
1433 clear the caches for all inferiors. */
1435 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
1436 if (objfile
== NULL
|| inf
->pspace
== objfile
->pspace
)
1437 ada_tasks_invalidate_inferior_data (inf
);
1441 _initialize_tasks (void)
1443 ada_tasks_pspace_data_handle
= register_program_space_data ();
1444 ada_tasks_inferior_data_handle
= register_inferior_data ();
1446 /* Attach various observers. */
1447 gdb::observers::normal_stop
.attach (ada_tasks_normal_stop_observer
);
1448 gdb::observers::new_objfile
.attach (ada_tasks_new_objfile_observer
);
1450 /* Some new commands provided by this module. */
1451 add_info ("tasks", info_tasks_command
,
1452 _("Provide information about all known Ada tasks"));
1453 add_cmd ("task", class_run
, task_command
,
1454 _("Use this command to switch between Ada tasks.\n\
1455 Without argument, this command simply prints the current task ID"),