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 /* The kind of data structure used by the runtime to store the list
167 enum ada_known_tasks_kind
169 /* Use this value when we haven't determined which kind of structure
170 is being used, or when we need to recompute it.
172 We set the value of this enumerate to zero on purpose: This allows
173 us to use this enumerate in a structure where setting all fields
174 to zero will result in this kind being set to unknown. */
175 ADA_TASKS_UNKNOWN
= 0,
177 /* This value means that we did not find any task list. Unless
178 there is a bug somewhere, this means that the inferior does not
182 /* This value means that the task list is stored as an array.
183 This is the usual method, as it causes very little overhead.
184 But this method is not always used, as it does use a certain
185 amount of memory, which might be scarse in certain environments. */
188 /* This value means that the task list is stored as a linked list.
189 This has more runtime overhead than the array approach, but
190 also require less memory when the number of tasks is small. */
194 /* This module's per-inferior data. */
196 struct ada_tasks_inferior_data
198 /* The type of data structure used by the runtime to store
199 the list of Ada tasks. The value of this field influences
200 the interpretation of the known_tasks_addr field below:
201 - ADA_TASKS_UNKNOWN: The value of known_tasks_addr hasn't
203 - ADA_TASKS_NOT_FOUND: The program probably does not use tasking
204 and the known_tasks_addr is irrelevant;
205 - ADA_TASKS_ARRAY: The known_tasks is an array;
206 - ADA_TASKS_LIST: The known_tasks is a list. */
207 enum ada_known_tasks_kind known_tasks_kind
= ADA_TASKS_UNKNOWN
;
209 /* The address of the known_tasks structure. This is where
210 the runtime stores the information for all Ada tasks.
211 The interpretation of this field depends on KNOWN_TASKS_KIND
213 CORE_ADDR known_tasks_addr
= 0;
215 /* Type of elements of the known task. Usually a pointer. */
216 struct type
*known_tasks_element
= nullptr;
218 /* Number of elements in the known tasks array. */
219 unsigned int known_tasks_length
= 0;
221 /* When nonzero, this flag indicates that the task_list field
222 below is up to date. When set to zero, the list has either
223 not been initialized, or has potentially become stale. */
224 int task_list_valid_p
= 0;
226 /* The list of Ada tasks.
228 Note: To each task we associate a number that the user can use to
229 reference it - this number is printed beside each task in the tasks
230 info listing displayed by "info tasks". This number is equal to
231 its index in the vector + 1. Reciprocally, to compute the index
232 of a task in the vector, we need to substract 1 from its number. */
233 std::vector
<ada_task_info
> task_list
;
236 /* Key to our per-inferior data. */
237 static const struct inferior_data
*ada_tasks_inferior_data_handle
;
239 /* Return the ada-tasks module's data for the given program space (PSPACE).
240 If none is found, add a zero'ed one now.
242 This function always returns a valid object. */
244 static struct ada_tasks_pspace_data
*
245 get_ada_tasks_pspace_data (struct program_space
*pspace
)
247 struct ada_tasks_pspace_data
*data
;
249 data
= ((struct ada_tasks_pspace_data
*)
250 program_space_data (pspace
, ada_tasks_pspace_data_handle
));
253 data
= XCNEW (struct ada_tasks_pspace_data
);
254 set_program_space_data (pspace
, ada_tasks_pspace_data_handle
, data
);
260 /* Return the ada-tasks module's data for the given inferior (INF).
261 If none is found, add a zero'ed one now.
263 This function always returns a valid object.
265 Note that we could use an observer of the inferior-created event
266 to make sure that the ada-tasks per-inferior data always exists.
267 But we prefered this approach, as it avoids this entirely as long
268 as the user does not use any of the tasking features. This is
269 quite possible, particularly in the case where the inferior does
272 static struct ada_tasks_inferior_data
*
273 get_ada_tasks_inferior_data (struct inferior
*inf
)
275 struct ada_tasks_inferior_data
*data
;
277 data
= ((struct ada_tasks_inferior_data
*)
278 inferior_data (inf
, ada_tasks_inferior_data_handle
));
281 data
= new ada_tasks_inferior_data
;
282 set_inferior_data (inf
, ada_tasks_inferior_data_handle
, data
);
288 /* Return the task number of the task whose thread is THREAD, or zero
289 if the task could not be found. */
292 ada_get_task_number (thread_info
*thread
)
294 struct inferior
*inf
= thread
->inf
;
295 struct ada_tasks_inferior_data
*data
;
297 gdb_assert (inf
!= NULL
);
298 data
= get_ada_tasks_inferior_data (inf
);
300 for (int i
= 0; i
< data
->task_list
.size (); i
++)
301 if (data
->task_list
[i
].ptid
== thread
->ptid
)
304 return 0; /* No matching task found. */
307 /* Return the task number of the task running in inferior INF which
308 matches TASK_ID , or zero if the task could not be found. */
311 get_task_number_from_id (CORE_ADDR task_id
, struct inferior
*inf
)
313 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
315 for (int i
= 0; i
< data
->task_list
.size (); i
++)
317 if (data
->task_list
[i
].task_id
== task_id
)
321 /* Task not found. Return 0. */
325 /* Return non-zero if TASK_NUM is a valid task number. */
328 valid_task_id (int task_num
)
330 struct ada_tasks_inferior_data
*data
;
332 ada_build_task_list ();
333 data
= get_ada_tasks_inferior_data (current_inferior ());
334 return task_num
> 0 && task_num
<= data
->task_list
.size ();
337 /* Return non-zero iff the task STATE corresponds to a non-terminated
341 ada_task_is_alive (struct ada_task_info
*task_info
)
343 return (task_info
->state
!= Terminated
);
346 /* Search through the list of known tasks for the one whose ptid is
347 PTID, and return it. Return NULL if the task was not found. */
349 struct ada_task_info
*
350 ada_get_task_info_from_ptid (ptid_t ptid
)
352 struct ada_tasks_inferior_data
*data
;
354 ada_build_task_list ();
355 data
= get_ada_tasks_inferior_data (current_inferior ());
357 for (ada_task_info
&task
: data
->task_list
)
359 if (task
.ptid
== ptid
)
366 /* Call the ITERATOR function once for each Ada task that hasn't been
370 iterate_over_live_ada_tasks (ada_task_list_iterator_ftype
*iterator
)
372 struct ada_tasks_inferior_data
*data
;
374 ada_build_task_list ();
375 data
= get_ada_tasks_inferior_data (current_inferior ());
377 for (ada_task_info
&task
: data
->task_list
)
379 if (!ada_task_is_alive (&task
))
385 /* Extract the contents of the value as a string whose length is LENGTH,
386 and store the result in DEST. */
389 value_as_string (char *dest
, struct value
*val
, int length
)
391 memcpy (dest
, value_contents (val
), length
);
395 /* Extract the string image from the fat string corresponding to VAL,
396 and store it in DEST. If the string length is greater than MAX_LEN,
397 then truncate the result to the first MAX_LEN characters of the fat
401 read_fat_string_value (char *dest
, struct value
*val
, int max_len
)
403 struct value
*array_val
;
404 struct value
*bounds_val
;
407 /* The following variables are made static to avoid recomputing them
408 each time this function is called. */
409 static int initialize_fieldnos
= 1;
410 static int array_fieldno
;
411 static int bounds_fieldno
;
412 static int upper_bound_fieldno
;
414 /* Get the index of the fields that we will need to read in order
415 to extract the string from the fat string. */
416 if (initialize_fieldnos
)
418 struct type
*type
= value_type (val
);
419 struct type
*bounds_type
;
421 array_fieldno
= ada_get_field_index (type
, "P_ARRAY", 0);
422 bounds_fieldno
= ada_get_field_index (type
, "P_BOUNDS", 0);
424 bounds_type
= TYPE_FIELD_TYPE (type
, bounds_fieldno
);
425 if (TYPE_CODE (bounds_type
) == TYPE_CODE_PTR
)
426 bounds_type
= TYPE_TARGET_TYPE (bounds_type
);
427 if (TYPE_CODE (bounds_type
) != TYPE_CODE_STRUCT
)
428 error (_("Unknown task name format. Aborting"));
429 upper_bound_fieldno
= ada_get_field_index (bounds_type
, "UB0", 0);
431 initialize_fieldnos
= 0;
434 /* Get the size of the task image by checking the value of the bounds.
435 The lower bound is always 1, so we only need to read the upper bound. */
436 bounds_val
= value_ind (value_field (val
, bounds_fieldno
));
437 len
= value_as_long (value_field (bounds_val
, upper_bound_fieldno
));
439 /* Make sure that we do not read more than max_len characters... */
443 /* Extract LEN characters from the fat string. */
444 array_val
= value_ind (value_field (val
, array_fieldno
));
445 read_memory (value_address (array_val
), (gdb_byte
*) dest
, len
);
447 /* Add the NUL character to close the string. */
451 /* Get, from the debugging information, the type description of all types
452 related to the Ada Task Control Block that are needed in order to
453 read the list of known tasks in the Ada runtime. If all of the info
454 needed to do so is found, then save that info in the module's per-
455 program-space data, and return NULL. Otherwise, if any information
456 cannot be found, leave the per-program-space data untouched, and
457 return an error message explaining what was missing (that error
458 message does NOT need to be deallocated). */
461 ada_get_tcb_types_info (void)
464 struct type
*common_type
;
465 struct type
*ll_type
;
466 struct type
*call_type
;
467 struct atcb_fieldnos fieldnos
;
468 struct ada_tasks_pspace_data
*pspace_data
;
470 const char *atcb_name
= "system__tasking__ada_task_control_block___XVE";
471 const char *atcb_name_fixed
= "system__tasking__ada_task_control_block";
472 const char *common_atcb_name
= "system__tasking__common_atcb";
473 const char *private_data_name
= "system__task_primitives__private_data";
474 const char *entry_call_record_name
= "system__tasking__entry_call_record";
476 /* ATCB symbols may be found in several compilation units. As we
477 are only interested in one instance, use standard (literal,
478 C-like) lookups to get the first match. */
480 struct symbol
*atcb_sym
=
481 lookup_symbol_in_language (atcb_name
, NULL
, STRUCT_DOMAIN
,
482 language_c
, NULL
).symbol
;
483 const struct symbol
*common_atcb_sym
=
484 lookup_symbol_in_language (common_atcb_name
, NULL
, STRUCT_DOMAIN
,
485 language_c
, NULL
).symbol
;
486 const struct symbol
*private_data_sym
=
487 lookup_symbol_in_language (private_data_name
, NULL
, STRUCT_DOMAIN
,
488 language_c
, NULL
).symbol
;
489 const struct symbol
*entry_call_record_sym
=
490 lookup_symbol_in_language (entry_call_record_name
, NULL
, STRUCT_DOMAIN
,
491 language_c
, NULL
).symbol
;
493 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
495 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
496 size, so the symbol name differs. */
497 atcb_sym
= lookup_symbol_in_language (atcb_name_fixed
, NULL
,
498 STRUCT_DOMAIN
, language_c
,
501 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
502 return _("Cannot find Ada_Task_Control_Block type");
504 type
= atcb_sym
->type
;
508 /* Get a static representation of the type record
509 Ada_Task_Control_Block. */
510 type
= atcb_sym
->type
;
511 type
= ada_template_to_fixed_record_type_1 (type
, NULL
, 0, NULL
, 0);
514 if (common_atcb_sym
== NULL
|| common_atcb_sym
->type
== NULL
)
515 return _("Cannot find Common_ATCB type");
516 if (private_data_sym
== NULL
|| private_data_sym
->type
== NULL
)
517 return _("Cannot find Private_Data type");
518 if (entry_call_record_sym
== NULL
|| entry_call_record_sym
->type
== NULL
)
519 return _("Cannot find Entry_Call_Record type");
521 /* Get the type for Ada_Task_Control_Block.Common. */
522 common_type
= common_atcb_sym
->type
;
524 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
525 ll_type
= private_data_sym
->type
;
527 /* Get the type for Common_ATCB.Call.all. */
528 call_type
= entry_call_record_sym
->type
;
530 /* Get the field indices. */
531 fieldnos
.common
= ada_get_field_index (type
, "common", 0);
532 fieldnos
.entry_calls
= ada_get_field_index (type
, "entry_calls", 1);
533 fieldnos
.atc_nesting_level
=
534 ada_get_field_index (type
, "atc_nesting_level", 1);
535 fieldnos
.state
= ada_get_field_index (common_type
, "state", 0);
536 fieldnos
.parent
= ada_get_field_index (common_type
, "parent", 1);
537 fieldnos
.priority
= ada_get_field_index (common_type
, "base_priority", 0);
538 fieldnos
.image
= ada_get_field_index (common_type
, "task_image", 1);
539 fieldnos
.image_len
= ada_get_field_index (common_type
, "task_image_len", 1);
540 fieldnos
.activation_link
= ada_get_field_index (common_type
,
541 "activation_link", 1);
542 fieldnos
.call
= ada_get_field_index (common_type
, "call", 1);
543 fieldnos
.ll
= ada_get_field_index (common_type
, "ll", 0);
544 fieldnos
.base_cpu
= ada_get_field_index (common_type
, "base_cpu", 0);
545 fieldnos
.ll_thread
= ada_get_field_index (ll_type
, "thread", 0);
546 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "lwp", 1);
547 fieldnos
.call_self
= ada_get_field_index (call_type
, "self", 0);
549 /* On certain platforms such as x86-windows, the "lwp" field has been
550 named "thread_id". This field will likely be renamed in the future,
551 but we need to support both possibilities to avoid an unnecessary
552 dependency on a recent compiler. We therefore try locating the
553 "thread_id" field in place of the "lwp" field if we did not find
555 if (fieldnos
.ll_lwp
< 0)
556 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "thread_id", 1);
558 /* Set all the out parameters all at once, now that we are certain
559 that there are no potential error() anymore. */
560 pspace_data
= get_ada_tasks_pspace_data (current_program_space
);
561 pspace_data
->initialized_p
= 1;
562 pspace_data
->atcb_type
= type
;
563 pspace_data
->atcb_common_type
= common_type
;
564 pspace_data
->atcb_ll_type
= ll_type
;
565 pspace_data
->atcb_call_type
= call_type
;
566 pspace_data
->atcb_fieldno
= fieldnos
;
570 /* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
571 component of its ATCB record. This PTID needs to match the PTID used
572 by the thread layer. */
575 ptid_from_atcb_common (struct value
*common_value
)
579 struct value
*ll_value
;
581 const struct ada_tasks_pspace_data
*pspace_data
582 = get_ada_tasks_pspace_data (current_program_space
);
584 ll_value
= value_field (common_value
, pspace_data
->atcb_fieldno
.ll
);
586 if (pspace_data
->atcb_fieldno
.ll_lwp
>= 0)
587 lwp
= value_as_address (value_field (ll_value
,
588 pspace_data
->atcb_fieldno
.ll_lwp
));
589 thread
= value_as_long (value_field (ll_value
,
590 pspace_data
->atcb_fieldno
.ll_thread
));
592 ptid
= target_get_ada_task_ptid (lwp
, thread
);
597 /* Read the ATCB data of a given task given its TASK_ID (which is in practice
598 the address of its assocated ATCB record), and store the result inside
602 read_atcb (CORE_ADDR task_id
, struct ada_task_info
*task_info
)
604 struct value
*tcb_value
;
605 struct value
*common_value
;
606 struct value
*atc_nesting_level_value
;
607 struct value
*entry_calls_value
;
608 struct value
*entry_calls_value_element
;
609 int called_task_fieldno
= -1;
610 static const char ravenscar_task_name
[] = "Ravenscar task";
611 const struct ada_tasks_pspace_data
*pspace_data
612 = get_ada_tasks_pspace_data (current_program_space
);
614 /* Clear the whole structure to start with, so that everything
615 is always initialized the same. */
616 memset (task_info
, 0, sizeof (struct ada_task_info
));
618 if (!pspace_data
->initialized_p
)
620 const char *err_msg
= ada_get_tcb_types_info ();
623 error (_("%s. Aborting"), err_msg
);
626 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
628 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
630 /* Fill in the task_id. */
632 task_info
->task_id
= task_id
;
634 /* Compute the name of the task.
636 Depending on the GNAT version used, the task image is either a fat
637 string, or a thin array of characters. Older versions of GNAT used
638 to use fat strings, and therefore did not need an extra field in
639 the ATCB to store the string length. For efficiency reasons, newer
640 versions of GNAT replaced the fat string by a static buffer, but this
641 also required the addition of a new field named "Image_Len" containing
642 the length of the task name. The method used to extract the task name
643 is selected depending on the existence of this field.
645 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
646 we may want to get it from the first user frame of the stack. For now,
647 we just give a dummy name. */
649 if (pspace_data
->atcb_fieldno
.image_len
== -1)
651 if (pspace_data
->atcb_fieldno
.image
>= 0)
652 read_fat_string_value (task_info
->name
,
653 value_field (common_value
,
654 pspace_data
->atcb_fieldno
.image
),
655 sizeof (task_info
->name
) - 1);
658 struct bound_minimal_symbol msym
;
660 msym
= lookup_minimal_symbol_by_pc (task_id
);
663 const char *full_name
= MSYMBOL_LINKAGE_NAME (msym
.minsym
);
664 const char *task_name
= full_name
;
667 /* Strip the prefix. */
668 for (p
= full_name
; *p
; p
++)
669 if (p
[0] == '_' && p
[1] == '_')
672 /* Copy the task name. */
673 strncpy (task_info
->name
, task_name
, sizeof (task_info
->name
));
674 task_info
->name
[sizeof (task_info
->name
) - 1] = 0;
678 /* No symbol found. Use a default name. */
679 strcpy (task_info
->name
, ravenscar_task_name
);
685 int len
= value_as_long
686 (value_field (common_value
,
687 pspace_data
->atcb_fieldno
.image_len
));
689 value_as_string (task_info
->name
,
690 value_field (common_value
,
691 pspace_data
->atcb_fieldno
.image
),
695 /* Compute the task state and priority. */
698 value_as_long (value_field (common_value
,
699 pspace_data
->atcb_fieldno
.state
));
700 task_info
->priority
=
701 value_as_long (value_field (common_value
,
702 pspace_data
->atcb_fieldno
.priority
));
704 /* If the ATCB contains some information about the parent task,
705 then compute it as well. Otherwise, zero. */
707 if (pspace_data
->atcb_fieldno
.parent
>= 0)
709 value_as_address (value_field (common_value
,
710 pspace_data
->atcb_fieldno
.parent
));
712 /* If the ATCB contains some information about entry calls, then
713 compute the "called_task" as well. Otherwise, zero. */
715 if (pspace_data
->atcb_fieldno
.atc_nesting_level
> 0
716 && pspace_data
->atcb_fieldno
.entry_calls
> 0)
718 /* Let My_ATCB be the Ada task control block of a task calling the
719 entry of another task; then the Task_Id of the called task is
720 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
721 atc_nesting_level_value
=
722 value_field (tcb_value
, pspace_data
->atcb_fieldno
.atc_nesting_level
);
724 ada_coerce_to_simple_array_ptr
725 (value_field (tcb_value
, pspace_data
->atcb_fieldno
.entry_calls
));
726 entry_calls_value_element
=
727 value_subscript (entry_calls_value
,
728 value_as_long (atc_nesting_level_value
));
729 called_task_fieldno
=
730 ada_get_field_index (value_type (entry_calls_value_element
),
732 task_info
->called_task
=
733 value_as_address (value_field (entry_calls_value_element
,
734 called_task_fieldno
));
737 /* If the ATCB cotnains some information about RV callers, then
738 compute the "caller_task". Otherwise, leave it as zero. */
740 if (pspace_data
->atcb_fieldno
.call
>= 0)
742 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
743 If Common_ATCB.Call is null, then there is no caller. */
744 const CORE_ADDR call
=
745 value_as_address (value_field (common_value
,
746 pspace_data
->atcb_fieldno
.call
));
747 struct value
*call_val
;
752 value_from_contents_and_address (pspace_data
->atcb_call_type
,
754 task_info
->caller_task
=
756 (value_field (call_val
, pspace_data
->atcb_fieldno
.call_self
));
761 = value_as_long (value_field (common_value
,
762 pspace_data
->atcb_fieldno
.base_cpu
));
764 /* And finally, compute the task ptid. Note that there is not point
765 in computing it if the task is no longer alive, in which case
766 it is good enough to set its ptid to the null_ptid. */
767 if (ada_task_is_alive (task_info
))
768 task_info
->ptid
= ptid_from_atcb_common (common_value
);
770 task_info
->ptid
= null_ptid
;
773 /* Read the ATCB info of the given task (identified by TASK_ID), and
774 add the result to the given inferior's TASK_LIST. */
777 add_ada_task (CORE_ADDR task_id
, struct inferior
*inf
)
779 struct ada_task_info task_info
;
780 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
782 read_atcb (task_id
, &task_info
);
783 data
->task_list
.push_back (task_info
);
786 /* Read the Known_Tasks array from the inferior memory, and store
787 it in the current inferior's TASK_LIST. Return non-zero upon success. */
790 read_known_tasks_array (struct ada_tasks_inferior_data
*data
)
792 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
793 const int known_tasks_size
= target_ptr_byte
* data
->known_tasks_length
;
794 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (known_tasks_size
);
797 /* Build a new list by reading the ATCBs from the Known_Tasks array
798 in the Ada runtime. */
799 read_memory (data
->known_tasks_addr
, known_tasks
, known_tasks_size
);
800 for (i
= 0; i
< data
->known_tasks_length
; i
++)
803 extract_typed_address (known_tasks
+ i
* target_ptr_byte
,
804 data
->known_tasks_element
);
807 add_ada_task (task_id
, current_inferior ());
813 /* Read the known tasks from the inferior memory, and store it in
814 the current inferior's TASK_LIST. Return non-zero upon success. */
817 read_known_tasks_list (struct ada_tasks_inferior_data
*data
)
819 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
820 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (target_ptr_byte
);
822 const struct ada_tasks_pspace_data
*pspace_data
823 = get_ada_tasks_pspace_data (current_program_space
);
826 if (pspace_data
->atcb_fieldno
.activation_link
< 0)
829 /* Build a new list by reading the ATCBs. Read head of the list. */
830 read_memory (data
->known_tasks_addr
, known_tasks
, target_ptr_byte
);
831 task_id
= extract_typed_address (known_tasks
, data
->known_tasks_element
);
834 struct value
*tcb_value
;
835 struct value
*common_value
;
837 add_ada_task (task_id
, current_inferior ());
839 /* Read the chain. */
840 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
842 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
843 task_id
= value_as_address
844 (value_field (common_value
,
845 pspace_data
->atcb_fieldno
.activation_link
));
851 /* Set all fields of the current inferior ada-tasks data pointed by DATA.
852 Do nothing if those fields are already set and still up to date. */
855 ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data
*data
)
857 struct bound_minimal_symbol msym
;
860 /* Return now if already set. */
861 if (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
)
866 msym
= lookup_minimal_symbol (KNOWN_TASKS_NAME
, NULL
, NULL
);
867 if (msym
.minsym
!= NULL
)
869 data
->known_tasks_kind
= ADA_TASKS_ARRAY
;
870 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
872 /* Try to get pointer type and array length from the symtab. */
873 sym
= lookup_symbol_in_language (KNOWN_TASKS_NAME
, NULL
, VAR_DOMAIN
,
874 language_c
, NULL
).symbol
;
878 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
879 struct type
*eltype
= NULL
;
880 struct type
*idxtype
= NULL
;
882 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
883 eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
885 && TYPE_CODE (eltype
) == TYPE_CODE_PTR
)
886 idxtype
= check_typedef (TYPE_INDEX_TYPE (type
));
888 && !TYPE_LOW_BOUND_UNDEFINED (idxtype
)
889 && !TYPE_HIGH_BOUND_UNDEFINED (idxtype
))
891 data
->known_tasks_element
= eltype
;
892 data
->known_tasks_length
=
893 TYPE_HIGH_BOUND (idxtype
) - TYPE_LOW_BOUND (idxtype
) + 1;
898 /* Fallback to default values. The runtime may have been stripped (as
899 in some distributions), but it is likely that the executable still
900 contains debug information on the task type (due to implicit with of
902 data
->known_tasks_element
=
903 builtin_type (target_gdbarch ())->builtin_data_ptr
;
904 data
->known_tasks_length
= MAX_NUMBER_OF_KNOWN_TASKS
;
911 msym
= lookup_minimal_symbol (KNOWN_TASKS_LIST
, NULL
, NULL
);
912 if (msym
.minsym
!= NULL
)
914 data
->known_tasks_kind
= ADA_TASKS_LIST
;
915 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
916 data
->known_tasks_length
= 1;
918 sym
= lookup_symbol_in_language (KNOWN_TASKS_LIST
, NULL
, VAR_DOMAIN
,
919 language_c
, NULL
).symbol
;
920 if (sym
!= NULL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
923 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
925 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
927 data
->known_tasks_element
= type
;
932 /* Fallback to default values. */
933 data
->known_tasks_element
=
934 builtin_type (target_gdbarch ())->builtin_data_ptr
;
935 data
->known_tasks_length
= 1;
939 /* Can't find tasks. */
941 data
->known_tasks_kind
= ADA_TASKS_NOT_FOUND
;
942 data
->known_tasks_addr
= 0;
945 /* Read the known tasks from the current inferior's memory, and store it
946 in the current inferior's data TASK_LIST.
947 Return non-zero upon success. */
950 read_known_tasks (void)
952 struct ada_tasks_inferior_data
*data
=
953 get_ada_tasks_inferior_data (current_inferior ());
955 /* Step 1: Clear the current list, if necessary. */
956 data
->task_list
.clear ();
958 /* Step 2: do the real work.
959 If the application does not use task, then no more needs to be done.
960 It is important to have the task list cleared (see above) before we
961 return, as we don't want a stale task list to be used... This can
962 happen for instance when debugging a non-multitasking program after
963 having debugged a multitasking one. */
964 ada_tasks_inferior_data_sniffer (data
);
965 gdb_assert (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
);
967 switch (data
->known_tasks_kind
)
969 case ADA_TASKS_NOT_FOUND
: /* Tasking not in use in inferior. */
971 case ADA_TASKS_ARRAY
:
972 return read_known_tasks_array (data
);
974 return read_known_tasks_list (data
);
977 /* Step 3: Set task_list_valid_p, to avoid re-reading the Known_Tasks
978 array unless needed. Then report a success. */
979 data
->task_list_valid_p
= 1;
984 /* Build the task_list by reading the Known_Tasks array from
985 the inferior, and return the number of tasks in that list
986 (zero means that the program is not using tasking at all). */
989 ada_build_task_list (void)
991 struct ada_tasks_inferior_data
*data
;
993 if (!target_has_stack
)
994 error (_("Cannot inspect Ada tasks when program is not running"));
996 data
= get_ada_tasks_inferior_data (current_inferior ());
997 if (!data
->task_list_valid_p
)
1000 return data
->task_list
.size ();
1003 /* Print a table providing a short description of all Ada tasks
1004 running inside inferior INF. If ARG_STR is set, it will be
1005 interpreted as a task number, and the table will be limited to
1009 print_ada_task_info (struct ui_out
*uiout
,
1011 struct inferior
*inf
)
1013 struct ada_tasks_inferior_data
*data
;
1014 int taskno
, nb_tasks
;
1018 if (ada_build_task_list () == 0)
1020 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1024 if (arg_str
!= NULL
&& arg_str
[0] != '\0')
1025 taskno_arg
= value_as_long (parse_and_eval (arg_str
));
1027 if (uiout
->is_mi_like_p ())
1028 /* In GDB/MI mode, we want to provide the thread ID corresponding
1029 to each task. This allows clients to quickly find the thread
1030 associated to any task, which is helpful for commands that
1031 take a --thread argument. However, in order to be able to
1032 provide that thread ID, the thread list must be up to date
1034 target_update_thread_list ();
1036 data
= get_ada_tasks_inferior_data (inf
);
1038 /* Compute the number of tasks that are going to be displayed
1039 in the output. If an argument was given, there will be
1040 at most 1 entry. Otherwise, there will be as many entries
1041 as we have tasks. */
1044 if (taskno_arg
> 0 && taskno_arg
<= data
->task_list
.size ())
1050 nb_tasks
= data
->task_list
.size ();
1052 nb_columns
= uiout
->is_mi_like_p () ? 8 : 7;
1053 ui_out_emit_table
table_emitter (uiout
, nb_columns
, nb_tasks
, "tasks");
1054 uiout
->table_header (1, ui_left
, "current", "");
1055 uiout
->table_header (3, ui_right
, "id", "ID");
1056 uiout
->table_header (9, ui_right
, "task-id", "TID");
1057 /* The following column is provided in GDB/MI mode only because
1058 it is only really useful in that mode, and also because it
1059 allows us to keep the CLI output shorter and more compact. */
1060 if (uiout
->is_mi_like_p ())
1061 uiout
->table_header (4, ui_right
, "thread-id", "");
1062 uiout
->table_header (4, ui_right
, "parent-id", "P-ID");
1063 uiout
->table_header (3, ui_right
, "priority", "Pri");
1064 uiout
->table_header (22, ui_left
, "state", "State");
1065 /* Use ui_noalign for the last column, to prevent the CLI uiout
1066 from printing an extra space at the end of each row. This
1067 is a bit of a hack, but does get the job done. */
1068 uiout
->table_header (1, ui_noalign
, "name", "Name");
1069 uiout
->table_body ();
1071 for (taskno
= 1; taskno
<= data
->task_list
.size (); taskno
++)
1073 const struct ada_task_info
*const task_info
=
1074 &data
->task_list
[taskno
- 1];
1077 gdb_assert (task_info
!= NULL
);
1079 /* If the user asked for the output to be restricted
1080 to one task only, and this is not the task, skip
1082 if (taskno_arg
&& taskno
!= taskno_arg
)
1085 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1087 /* Print a star if this task is the current task (or the task
1088 currently selected). */
1089 if (task_info
->ptid
== inferior_ptid
)
1090 uiout
->field_string ("current", "*");
1092 uiout
->field_skip ("current");
1094 /* Print the task number. */
1095 uiout
->field_int ("id", taskno
);
1097 /* Print the Task ID. */
1098 uiout
->field_fmt ("task-id", "%9lx", (long) task_info
->task_id
);
1100 /* Print the associated Thread ID. */
1101 if (uiout
->is_mi_like_p ())
1103 thread_info
*thread
= find_thread_ptid (task_info
->ptid
);
1106 uiout
->field_int ("thread-id", thread
->global_num
);
1108 /* This should never happen unless there is a bug somewhere,
1109 but be resilient when that happens. */
1110 uiout
->field_skip ("thread-id");
1113 /* Print the ID of the parent task. */
1114 parent_id
= get_task_number_from_id (task_info
->parent
, inf
);
1116 uiout
->field_int ("parent-id", parent_id
);
1118 uiout
->field_skip ("parent-id");
1120 /* Print the base priority of the task. */
1121 uiout
->field_int ("priority", task_info
->priority
);
1123 /* Print the task current state. */
1124 if (task_info
->caller_task
)
1125 uiout
->field_fmt ("state",
1126 _("Accepting RV with %-4d"),
1127 get_task_number_from_id (task_info
->caller_task
,
1129 else if (task_info
->state
== Entry_Caller_Sleep
1130 && task_info
->called_task
)
1131 uiout
->field_fmt ("state",
1132 _("Waiting on RV with %-3d"),
1133 get_task_number_from_id (task_info
->called_task
,
1136 uiout
->field_string ("state", task_states
[task_info
->state
]);
1138 /* Finally, print the task name. */
1139 uiout
->field_fmt ("name",
1141 task_info
->name
[0] != '\0' ? task_info
->name
1148 /* Print a detailed description of the Ada task whose ID is TASKNO_STR
1149 for the given inferior (INF). */
1152 info_task (struct ui_out
*uiout
, const char *taskno_str
, struct inferior
*inf
)
1154 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1155 struct ada_task_info
*task_info
;
1156 int parent_taskno
= 0;
1157 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1159 if (ada_build_task_list () == 0)
1161 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1165 if (taskno
<= 0 || taskno
> data
->task_list
.size ())
1166 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1167 "see the IDs of currently known tasks"), taskno
);
1168 task_info
= &data
->task_list
[taskno
- 1];
1170 /* Print the Ada task ID. */
1171 printf_filtered (_("Ada Task: %s\n"),
1172 paddress (target_gdbarch (), task_info
->task_id
));
1174 /* Print the name of the task. */
1175 if (task_info
->name
[0] != '\0')
1176 printf_filtered (_("Name: %s\n"), task_info
->name
);
1178 printf_filtered (_("<no name>\n"));
1180 /* Print the TID and LWP. */
1181 printf_filtered (_("Thread: %#lx\n"), task_info
->ptid
.tid ());
1182 printf_filtered (_("LWP: %#lx\n"), task_info
->ptid
.lwp ());
1184 /* If set, print the base CPU. */
1185 if (task_info
->base_cpu
!= 0)
1186 printf_filtered (_("Base CPU: %d\n"), task_info
->base_cpu
);
1188 /* Print who is the parent (if any). */
1189 if (task_info
->parent
!= 0)
1190 parent_taskno
= get_task_number_from_id (task_info
->parent
, inf
);
1193 struct ada_task_info
*parent
= &data
->task_list
[parent_taskno
- 1];
1195 printf_filtered (_("Parent: %d"), parent_taskno
);
1196 if (parent
->name
[0] != '\0')
1197 printf_filtered (" (%s)", parent
->name
);
1198 printf_filtered ("\n");
1201 printf_filtered (_("No parent\n"));
1203 /* Print the base priority. */
1204 printf_filtered (_("Base Priority: %d\n"), task_info
->priority
);
1206 /* print the task current state. */
1208 int target_taskno
= 0;
1210 if (task_info
->caller_task
)
1212 target_taskno
= get_task_number_from_id (task_info
->caller_task
, inf
);
1213 printf_filtered (_("State: Accepting rendezvous with %d"),
1216 else if (task_info
->state
== Entry_Caller_Sleep
&& task_info
->called_task
)
1218 target_taskno
= get_task_number_from_id (task_info
->called_task
, inf
);
1219 printf_filtered (_("State: Waiting on task %d's entry"),
1223 printf_filtered (_("State: %s"), _(long_task_states
[task_info
->state
]));
1227 ada_task_info
*target_task_info
= &data
->task_list
[target_taskno
- 1];
1229 if (target_task_info
->name
[0] != '\0')
1230 printf_filtered (" (%s)", target_task_info
->name
);
1233 printf_filtered ("\n");
1237 /* If ARG is empty or null, then print a list of all Ada tasks.
1238 Otherwise, print detailed information about the task whose ID
1241 Does nothing if the program doesn't use Ada tasking. */
1244 info_tasks_command (const char *arg
, int from_tty
)
1246 struct ui_out
*uiout
= current_uiout
;
1248 if (arg
== NULL
|| *arg
== '\0')
1249 print_ada_task_info (uiout
, NULL
, current_inferior ());
1251 info_task (uiout
, arg
, current_inferior ());
1254 /* Print a message telling the user id of the current task.
1255 This function assumes that tasking is in use in the inferior. */
1258 display_current_task_id (void)
1260 const int current_task
= ada_get_task_number (inferior_thread ());
1262 if (current_task
== 0)
1263 printf_filtered (_("[Current task is unknown]\n"));
1265 printf_filtered (_("[Current task is %d]\n"), current_task
);
1268 /* Parse and evaluate TIDSTR into a task id, and try to switch to
1269 that task. Print an error message if the task switch failed. */
1272 task_command_1 (const char *taskno_str
, int from_tty
, struct inferior
*inf
)
1274 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1275 struct ada_task_info
*task_info
;
1276 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1278 if (taskno
<= 0 || taskno
> data
->task_list
.size ())
1279 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1280 "see the IDs of currently known tasks"), taskno
);
1281 task_info
= &data
->task_list
[taskno
- 1];
1283 if (!ada_task_is_alive (task_info
))
1284 error (_("Cannot switch to task %d: Task is no longer running"), taskno
);
1286 /* On some platforms, the thread list is not updated until the user
1287 performs a thread-related operation (by using the "info threads"
1288 command, for instance). So this thread list may not be up to date
1289 when the user attempts this task switch. Since we cannot switch
1290 to the thread associated to our task if GDB does not know about
1291 that thread, we need to make sure that any new threads gets added
1292 to the thread list. */
1293 target_update_thread_list ();
1295 /* Verify that the ptid of the task we want to switch to is valid
1296 (in other words, a ptid that GDB knows about). Otherwise, we will
1297 cause an assertion failure later on, when we try to determine
1298 the ptid associated thread_info data. We should normally never
1299 encounter such an error, but the wrong ptid can actually easily be
1300 computed if target_get_ada_task_ptid has not been implemented for
1301 our target (yet). Rather than cause an assertion error in that case,
1302 it's nicer for the user to just refuse to perform the task switch. */
1303 thread_info
*tp
= find_thread_ptid (task_info
->ptid
);
1305 error (_("Unable to compute thread ID for task %d.\n"
1306 "Cannot switch to this task."),
1309 switch_to_thread (tp
);
1310 ada_find_printable_frame (get_selected_frame (NULL
));
1311 printf_filtered (_("[Switching to task %d]\n"), taskno
);
1312 print_stack_frame (get_selected_frame (NULL
),
1313 frame_relative_level (get_selected_frame (NULL
)),
1318 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
1319 Otherwise, switch to the task indicated by TASKNO_STR. */
1322 task_command (const char *taskno_str
, int from_tty
)
1324 struct ui_out
*uiout
= current_uiout
;
1326 if (ada_build_task_list () == 0)
1328 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1332 if (taskno_str
== NULL
|| taskno_str
[0] == '\0')
1333 display_current_task_id ();
1335 task_command_1 (taskno_str
, from_tty
, current_inferior ());
1338 /* Indicate that the given inferior's task list may have changed,
1339 so invalidate the cache. */
1342 ada_task_list_changed (struct inferior
*inf
)
1344 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1346 data
->task_list_valid_p
= 0;
1349 /* Invalidate the per-program-space data. */
1352 ada_tasks_invalidate_pspace_data (struct program_space
*pspace
)
1354 get_ada_tasks_pspace_data (pspace
)->initialized_p
= 0;
1357 /* Invalidate the per-inferior data. */
1360 ada_tasks_invalidate_inferior_data (struct inferior
*inf
)
1362 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1364 data
->known_tasks_kind
= ADA_TASKS_UNKNOWN
;
1365 data
->task_list_valid_p
= 0;
1368 /* The 'normal_stop' observer notification callback. */
1371 ada_tasks_normal_stop_observer (struct bpstats
*unused_args
, int unused_args2
)
1373 /* The inferior has been resumed, and just stopped. This means that
1374 our task_list needs to be recomputed before it can be used again. */
1375 ada_task_list_changed (current_inferior ());
1378 /* A routine to be called when the objfiles have changed. */
1381 ada_tasks_new_objfile_observer (struct objfile
*objfile
)
1383 struct inferior
*inf
;
1385 /* Invalidate the relevant data in our program-space data. */
1387 if (objfile
== NULL
)
1389 /* All objfiles are being cleared, so we should clear all
1390 our caches for all program spaces. */
1391 struct program_space
*pspace
;
1393 for (pspace
= program_spaces
; pspace
!= NULL
; pspace
= pspace
->next
)
1394 ada_tasks_invalidate_pspace_data (pspace
);
1398 /* The associated program-space data might have changed after
1399 this objfile was added. Invalidate all cached data. */
1400 ada_tasks_invalidate_pspace_data (objfile
->pspace
);
1403 /* Invalidate the per-inferior cache for all inferiors using
1404 this objfile (or, in other words, for all inferiors who have
1405 the same program-space as the objfile's program space).
1406 If all objfiles are being cleared (OBJFILE is NULL), then
1407 clear the caches for all inferiors. */
1409 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
1410 if (objfile
== NULL
|| inf
->pspace
== objfile
->pspace
)
1411 ada_tasks_invalidate_inferior_data (inf
);
1415 _initialize_tasks (void)
1417 ada_tasks_pspace_data_handle
= register_program_space_data ();
1418 ada_tasks_inferior_data_handle
= register_inferior_data ();
1420 /* Attach various observers. */
1421 gdb::observers::normal_stop
.attach (ada_tasks_normal_stop_observer
);
1422 gdb::observers::new_objfile
.attach (ada_tasks_new_objfile_observer
);
1424 /* Some new commands provided by this module. */
1425 add_info ("tasks", info_tasks_command
,
1426 _("Provide information about all known Ada tasks"));
1427 add_cmd ("task", class_run
, task_command
,
1428 _("Use this command to switch between Ada tasks.\n\
1429 Without argument, this command simply prints the current task ID"),