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 /* 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 /* A cleanup routine for our per-program-space data. */
166 ada_tasks_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
168 struct ada_tasks_pspace_data
*data
169 = (struct ada_tasks_pspace_data
*) arg
;
173 /* The kind of data structure used by the runtime to store the list
176 enum ada_known_tasks_kind
178 /* Use this value when we haven't determined which kind of structure
179 is being used, or when we need to recompute it.
181 We set the value of this enumerate to zero on purpose: This allows
182 us to use this enumerate in a structure where setting all fields
183 to zero will result in this kind being set to unknown. */
184 ADA_TASKS_UNKNOWN
= 0,
186 /* This value means that we did not find any task list. Unless
187 there is a bug somewhere, this means that the inferior does not
191 /* This value means that the task list is stored as an array.
192 This is the usual method, as it causes very little overhead.
193 But this method is not always used, as it does use a certain
194 amount of memory, which might be scarse in certain environments. */
197 /* This value means that the task list is stored as a linked list.
198 This has more runtime overhead than the array approach, but
199 also require less memory when the number of tasks is small. */
203 /* This module's per-inferior data. */
205 struct ada_tasks_inferior_data
207 /* The type of data structure used by the runtime to store
208 the list of Ada tasks. The value of this field influences
209 the interpretation of the known_tasks_addr field below:
210 - ADA_TASKS_UNKNOWN: The value of known_tasks_addr hasn't
212 - ADA_TASKS_NOT_FOUND: The program probably does not use tasking
213 and the known_tasks_addr is irrelevant;
214 - ADA_TASKS_ARRAY: The known_tasks is an array;
215 - ADA_TASKS_LIST: The known_tasks is a list. */
216 enum ada_known_tasks_kind known_tasks_kind
= ADA_TASKS_UNKNOWN
;
218 /* The address of the known_tasks structure. This is where
219 the runtime stores the information for all Ada tasks.
220 The interpretation of this field depends on KNOWN_TASKS_KIND
222 CORE_ADDR known_tasks_addr
= 0;
224 /* Type of elements of the known task. Usually a pointer. */
225 struct type
*known_tasks_element
= nullptr;
227 /* Number of elements in the known tasks array. */
228 unsigned int known_tasks_length
= 0;
230 /* When nonzero, this flag indicates that the task_list field
231 below is up to date. When set to zero, the list has either
232 not been initialized, or has potentially become stale. */
233 int task_list_valid_p
= 0;
235 /* The list of Ada tasks.
237 Note: To each task we associate a number that the user can use to
238 reference it - this number is printed beside each task in the tasks
239 info listing displayed by "info tasks". This number is equal to
240 its index in the vector + 1. Reciprocally, to compute the index
241 of a task in the vector, we need to substract 1 from its number. */
242 std::vector
<ada_task_info
> task_list
;
245 /* Key to our per-inferior data. */
246 static const struct inferior_data
*ada_tasks_inferior_data_handle
;
248 /* Return the ada-tasks module's data for the given program space (PSPACE).
249 If none is found, add a zero'ed one now.
251 This function always returns a valid object. */
253 static struct ada_tasks_pspace_data
*
254 get_ada_tasks_pspace_data (struct program_space
*pspace
)
256 struct ada_tasks_pspace_data
*data
;
258 data
= ((struct ada_tasks_pspace_data
*)
259 program_space_data (pspace
, ada_tasks_pspace_data_handle
));
262 data
= XCNEW (struct ada_tasks_pspace_data
);
263 set_program_space_data (pspace
, ada_tasks_pspace_data_handle
, data
);
269 /* Return the ada-tasks module's data for the given inferior (INF).
270 If none is found, add a zero'ed one now.
272 This function always returns a valid object.
274 Note that we could use an observer of the inferior-created event
275 to make sure that the ada-tasks per-inferior data always exists.
276 But we prefered this approach, as it avoids this entirely as long
277 as the user does not use any of the tasking features. This is
278 quite possible, particularly in the case where the inferior does
281 static struct ada_tasks_inferior_data
*
282 get_ada_tasks_inferior_data (struct inferior
*inf
)
284 struct ada_tasks_inferior_data
*data
;
286 data
= ((struct ada_tasks_inferior_data
*)
287 inferior_data (inf
, ada_tasks_inferior_data_handle
));
290 data
= new ada_tasks_inferior_data
;
291 set_inferior_data (inf
, ada_tasks_inferior_data_handle
, data
);
297 /* A cleanup routine for our per-inferior data. */
299 ada_tasks_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
301 struct ada_tasks_inferior_data
*data
302 = (struct ada_tasks_inferior_data
*) arg
;
306 /* Return the task number of the task whose thread is THREAD, or zero
307 if the task could not be found. */
310 ada_get_task_number (thread_info
*thread
)
312 struct inferior
*inf
= thread
->inf
;
313 struct ada_tasks_inferior_data
*data
;
315 gdb_assert (inf
!= NULL
);
316 data
= get_ada_tasks_inferior_data (inf
);
318 for (int i
= 0; i
< data
->task_list
.size (); i
++)
319 if (data
->task_list
[i
].ptid
== thread
->ptid
)
322 return 0; /* No matching task found. */
325 /* Return the task number of the task running in inferior INF which
326 matches TASK_ID , or zero if the task could not be found. */
329 get_task_number_from_id (CORE_ADDR task_id
, struct inferior
*inf
)
331 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
333 for (int i
= 0; i
< data
->task_list
.size (); i
++)
335 if (data
->task_list
[i
].task_id
== task_id
)
339 /* Task not found. Return 0. */
343 /* Return non-zero if TASK_NUM is a valid task number. */
346 valid_task_id (int task_num
)
348 struct ada_tasks_inferior_data
*data
;
350 ada_build_task_list ();
351 data
= get_ada_tasks_inferior_data (current_inferior ());
352 return task_num
> 0 && task_num
<= data
->task_list
.size ();
355 /* Return non-zero iff the task STATE corresponds to a non-terminated
359 ada_task_is_alive (struct ada_task_info
*task_info
)
361 return (task_info
->state
!= Terminated
);
364 /* Search through the list of known tasks for the one whose ptid is
365 PTID, and return it. Return NULL if the task was not found. */
367 struct ada_task_info
*
368 ada_get_task_info_from_ptid (ptid_t ptid
)
370 struct ada_tasks_inferior_data
*data
;
372 ada_build_task_list ();
373 data
= get_ada_tasks_inferior_data (current_inferior ());
375 for (ada_task_info
&task
: data
->task_list
)
377 if (task
.ptid
== ptid
)
384 /* Call the ITERATOR function once for each Ada task that hasn't been
388 iterate_over_live_ada_tasks (ada_task_list_iterator_ftype
*iterator
)
390 struct ada_tasks_inferior_data
*data
;
392 ada_build_task_list ();
393 data
= get_ada_tasks_inferior_data (current_inferior ());
395 for (ada_task_info
&task
: data
->task_list
)
397 if (!ada_task_is_alive (&task
))
403 /* Extract the contents of the value as a string whose length is LENGTH,
404 and store the result in DEST. */
407 value_as_string (char *dest
, struct value
*val
, int length
)
409 memcpy (dest
, value_contents (val
), length
);
413 /* Extract the string image from the fat string corresponding to VAL,
414 and store it in DEST. If the string length is greater than MAX_LEN,
415 then truncate the result to the first MAX_LEN characters of the fat
419 read_fat_string_value (char *dest
, struct value
*val
, int max_len
)
421 struct value
*array_val
;
422 struct value
*bounds_val
;
425 /* The following variables are made static to avoid recomputing them
426 each time this function is called. */
427 static int initialize_fieldnos
= 1;
428 static int array_fieldno
;
429 static int bounds_fieldno
;
430 static int upper_bound_fieldno
;
432 /* Get the index of the fields that we will need to read in order
433 to extract the string from the fat string. */
434 if (initialize_fieldnos
)
436 struct type
*type
= value_type (val
);
437 struct type
*bounds_type
;
439 array_fieldno
= ada_get_field_index (type
, "P_ARRAY", 0);
440 bounds_fieldno
= ada_get_field_index (type
, "P_BOUNDS", 0);
442 bounds_type
= TYPE_FIELD_TYPE (type
, bounds_fieldno
);
443 if (TYPE_CODE (bounds_type
) == TYPE_CODE_PTR
)
444 bounds_type
= TYPE_TARGET_TYPE (bounds_type
);
445 if (TYPE_CODE (bounds_type
) != TYPE_CODE_STRUCT
)
446 error (_("Unknown task name format. Aborting"));
447 upper_bound_fieldno
= ada_get_field_index (bounds_type
, "UB0", 0);
449 initialize_fieldnos
= 0;
452 /* Get the size of the task image by checking the value of the bounds.
453 The lower bound is always 1, so we only need to read the upper bound. */
454 bounds_val
= value_ind (value_field (val
, bounds_fieldno
));
455 len
= value_as_long (value_field (bounds_val
, upper_bound_fieldno
));
457 /* Make sure that we do not read more than max_len characters... */
461 /* Extract LEN characters from the fat string. */
462 array_val
= value_ind (value_field (val
, array_fieldno
));
463 read_memory (value_address (array_val
), (gdb_byte
*) dest
, len
);
465 /* Add the NUL character to close the string. */
469 /* Get, from the debugging information, the type description of all types
470 related to the Ada Task Control Block that are needed in order to
471 read the list of known tasks in the Ada runtime. If all of the info
472 needed to do so is found, then save that info in the module's per-
473 program-space data, and return NULL. Otherwise, if any information
474 cannot be found, leave the per-program-space data untouched, and
475 return an error message explaining what was missing (that error
476 message does NOT need to be deallocated). */
479 ada_get_tcb_types_info (void)
482 struct type
*common_type
;
483 struct type
*ll_type
;
484 struct type
*call_type
;
485 struct atcb_fieldnos fieldnos
;
486 struct ada_tasks_pspace_data
*pspace_data
;
488 const char *atcb_name
= "system__tasking__ada_task_control_block___XVE";
489 const char *atcb_name_fixed
= "system__tasking__ada_task_control_block";
490 const char *common_atcb_name
= "system__tasking__common_atcb";
491 const char *private_data_name
= "system__task_primitives__private_data";
492 const char *entry_call_record_name
= "system__tasking__entry_call_record";
494 /* ATCB symbols may be found in several compilation units. As we
495 are only interested in one instance, use standard (literal,
496 C-like) lookups to get the first match. */
498 struct symbol
*atcb_sym
=
499 lookup_symbol_in_language (atcb_name
, NULL
, STRUCT_DOMAIN
,
500 language_c
, NULL
).symbol
;
501 const struct symbol
*common_atcb_sym
=
502 lookup_symbol_in_language (common_atcb_name
, NULL
, STRUCT_DOMAIN
,
503 language_c
, NULL
).symbol
;
504 const struct symbol
*private_data_sym
=
505 lookup_symbol_in_language (private_data_name
, NULL
, STRUCT_DOMAIN
,
506 language_c
, NULL
).symbol
;
507 const struct symbol
*entry_call_record_sym
=
508 lookup_symbol_in_language (entry_call_record_name
, NULL
, STRUCT_DOMAIN
,
509 language_c
, NULL
).symbol
;
511 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
513 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
514 size, so the symbol name differs. */
515 atcb_sym
= lookup_symbol_in_language (atcb_name_fixed
, NULL
,
516 STRUCT_DOMAIN
, language_c
,
519 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
520 return _("Cannot find Ada_Task_Control_Block type");
522 type
= atcb_sym
->type
;
526 /* Get a static representation of the type record
527 Ada_Task_Control_Block. */
528 type
= atcb_sym
->type
;
529 type
= ada_template_to_fixed_record_type_1 (type
, NULL
, 0, NULL
, 0);
532 if (common_atcb_sym
== NULL
|| common_atcb_sym
->type
== NULL
)
533 return _("Cannot find Common_ATCB type");
534 if (private_data_sym
== NULL
|| private_data_sym
->type
== NULL
)
535 return _("Cannot find Private_Data type");
536 if (entry_call_record_sym
== NULL
|| entry_call_record_sym
->type
== NULL
)
537 return _("Cannot find Entry_Call_Record type");
539 /* Get the type for Ada_Task_Control_Block.Common. */
540 common_type
= common_atcb_sym
->type
;
542 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
543 ll_type
= private_data_sym
->type
;
545 /* Get the type for Common_ATCB.Call.all. */
546 call_type
= entry_call_record_sym
->type
;
548 /* Get the field indices. */
549 fieldnos
.common
= ada_get_field_index (type
, "common", 0);
550 fieldnos
.entry_calls
= ada_get_field_index (type
, "entry_calls", 1);
551 fieldnos
.atc_nesting_level
=
552 ada_get_field_index (type
, "atc_nesting_level", 1);
553 fieldnos
.state
= ada_get_field_index (common_type
, "state", 0);
554 fieldnos
.parent
= ada_get_field_index (common_type
, "parent", 1);
555 fieldnos
.priority
= ada_get_field_index (common_type
, "base_priority", 0);
556 fieldnos
.image
= ada_get_field_index (common_type
, "task_image", 1);
557 fieldnos
.image_len
= ada_get_field_index (common_type
, "task_image_len", 1);
558 fieldnos
.activation_link
= ada_get_field_index (common_type
,
559 "activation_link", 1);
560 fieldnos
.call
= ada_get_field_index (common_type
, "call", 1);
561 fieldnos
.ll
= ada_get_field_index (common_type
, "ll", 0);
562 fieldnos
.base_cpu
= ada_get_field_index (common_type
, "base_cpu", 0);
563 fieldnos
.ll_thread
= ada_get_field_index (ll_type
, "thread", 0);
564 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "lwp", 1);
565 fieldnos
.call_self
= ada_get_field_index (call_type
, "self", 0);
567 /* On certain platforms such as x86-windows, the "lwp" field has been
568 named "thread_id". This field will likely be renamed in the future,
569 but we need to support both possibilities to avoid an unnecessary
570 dependency on a recent compiler. We therefore try locating the
571 "thread_id" field in place of the "lwp" field if we did not find
573 if (fieldnos
.ll_lwp
< 0)
574 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "thread_id", 1);
576 /* Set all the out parameters all at once, now that we are certain
577 that there are no potential error() anymore. */
578 pspace_data
= get_ada_tasks_pspace_data (current_program_space
);
579 pspace_data
->initialized_p
= 1;
580 pspace_data
->atcb_type
= type
;
581 pspace_data
->atcb_common_type
= common_type
;
582 pspace_data
->atcb_ll_type
= ll_type
;
583 pspace_data
->atcb_call_type
= call_type
;
584 pspace_data
->atcb_fieldno
= fieldnos
;
588 /* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
589 component of its ATCB record. This PTID needs to match the PTID used
590 by the thread layer. */
593 ptid_from_atcb_common (struct value
*common_value
)
597 struct value
*ll_value
;
599 const struct ada_tasks_pspace_data
*pspace_data
600 = get_ada_tasks_pspace_data (current_program_space
);
602 ll_value
= value_field (common_value
, pspace_data
->atcb_fieldno
.ll
);
604 if (pspace_data
->atcb_fieldno
.ll_lwp
>= 0)
605 lwp
= value_as_address (value_field (ll_value
,
606 pspace_data
->atcb_fieldno
.ll_lwp
));
607 thread
= value_as_long (value_field (ll_value
,
608 pspace_data
->atcb_fieldno
.ll_thread
));
610 ptid
= target_get_ada_task_ptid (lwp
, thread
);
615 /* Read the ATCB data of a given task given its TASK_ID (which is in practice
616 the address of its assocated ATCB record), and store the result inside
620 read_atcb (CORE_ADDR task_id
, struct ada_task_info
*task_info
)
622 struct value
*tcb_value
;
623 struct value
*common_value
;
624 struct value
*atc_nesting_level_value
;
625 struct value
*entry_calls_value
;
626 struct value
*entry_calls_value_element
;
627 int called_task_fieldno
= -1;
628 static const char ravenscar_task_name
[] = "Ravenscar task";
629 const struct ada_tasks_pspace_data
*pspace_data
630 = get_ada_tasks_pspace_data (current_program_space
);
632 /* Clear the whole structure to start with, so that everything
633 is always initialized the same. */
634 memset (task_info
, 0, sizeof (struct ada_task_info
));
636 if (!pspace_data
->initialized_p
)
638 const char *err_msg
= ada_get_tcb_types_info ();
641 error (_("%s. Aborting"), err_msg
);
644 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
646 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
648 /* Fill in the task_id. */
650 task_info
->task_id
= task_id
;
652 /* Compute the name of the task.
654 Depending on the GNAT version used, the task image is either a fat
655 string, or a thin array of characters. Older versions of GNAT used
656 to use fat strings, and therefore did not need an extra field in
657 the ATCB to store the string length. For efficiency reasons, newer
658 versions of GNAT replaced the fat string by a static buffer, but this
659 also required the addition of a new field named "Image_Len" containing
660 the length of the task name. The method used to extract the task name
661 is selected depending on the existence of this field.
663 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
664 we may want to get it from the first user frame of the stack. For now,
665 we just give a dummy name. */
667 if (pspace_data
->atcb_fieldno
.image_len
== -1)
669 if (pspace_data
->atcb_fieldno
.image
>= 0)
670 read_fat_string_value (task_info
->name
,
671 value_field (common_value
,
672 pspace_data
->atcb_fieldno
.image
),
673 sizeof (task_info
->name
) - 1);
676 struct bound_minimal_symbol msym
;
678 msym
= lookup_minimal_symbol_by_pc (task_id
);
681 const char *full_name
= MSYMBOL_LINKAGE_NAME (msym
.minsym
);
682 const char *task_name
= full_name
;
685 /* Strip the prefix. */
686 for (p
= full_name
; *p
; p
++)
687 if (p
[0] == '_' && p
[1] == '_')
690 /* Copy the task name. */
691 strncpy (task_info
->name
, task_name
, sizeof (task_info
->name
));
692 task_info
->name
[sizeof (task_info
->name
) - 1] = 0;
696 /* No symbol found. Use a default name. */
697 strcpy (task_info
->name
, ravenscar_task_name
);
703 int len
= value_as_long
704 (value_field (common_value
,
705 pspace_data
->atcb_fieldno
.image_len
));
707 value_as_string (task_info
->name
,
708 value_field (common_value
,
709 pspace_data
->atcb_fieldno
.image
),
713 /* Compute the task state and priority. */
716 value_as_long (value_field (common_value
,
717 pspace_data
->atcb_fieldno
.state
));
718 task_info
->priority
=
719 value_as_long (value_field (common_value
,
720 pspace_data
->atcb_fieldno
.priority
));
722 /* If the ATCB contains some information about the parent task,
723 then compute it as well. Otherwise, zero. */
725 if (pspace_data
->atcb_fieldno
.parent
>= 0)
727 value_as_address (value_field (common_value
,
728 pspace_data
->atcb_fieldno
.parent
));
730 /* If the task is in an entry call waiting for another task,
731 then determine which task it is. */
733 if (task_info
->state
== Entry_Caller_Sleep
734 && pspace_data
->atcb_fieldno
.atc_nesting_level
> 0
735 && pspace_data
->atcb_fieldno
.entry_calls
> 0)
737 /* Let My_ATCB be the Ada task control block of a task calling the
738 entry of another task; then the Task_Id of the called task is
739 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
740 atc_nesting_level_value
=
741 value_field (tcb_value
, pspace_data
->atcb_fieldno
.atc_nesting_level
);
743 ada_coerce_to_simple_array_ptr
744 (value_field (tcb_value
, pspace_data
->atcb_fieldno
.entry_calls
));
745 entry_calls_value_element
=
746 value_subscript (entry_calls_value
,
747 value_as_long (atc_nesting_level_value
));
748 called_task_fieldno
=
749 ada_get_field_index (value_type (entry_calls_value_element
),
751 task_info
->called_task
=
752 value_as_address (value_field (entry_calls_value_element
,
753 called_task_fieldno
));
756 /* If the ATCB cotnains some information about RV callers, then
757 compute the "caller_task". Otherwise, leave it as zero. */
759 if (pspace_data
->atcb_fieldno
.call
>= 0)
761 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
762 If Common_ATCB.Call is null, then there is no caller. */
763 const CORE_ADDR call
=
764 value_as_address (value_field (common_value
,
765 pspace_data
->atcb_fieldno
.call
));
766 struct value
*call_val
;
771 value_from_contents_and_address (pspace_data
->atcb_call_type
,
773 task_info
->caller_task
=
775 (value_field (call_val
, pspace_data
->atcb_fieldno
.call_self
));
780 = value_as_long (value_field (common_value
,
781 pspace_data
->atcb_fieldno
.base_cpu
));
783 /* And finally, compute the task ptid. Note that there is not point
784 in computing it if the task is no longer alive, in which case
785 it is good enough to set its ptid to the null_ptid. */
786 if (ada_task_is_alive (task_info
))
787 task_info
->ptid
= ptid_from_atcb_common (common_value
);
789 task_info
->ptid
= null_ptid
;
792 /* Read the ATCB info of the given task (identified by TASK_ID), and
793 add the result to the given inferior's TASK_LIST. */
796 add_ada_task (CORE_ADDR task_id
, struct inferior
*inf
)
798 struct ada_task_info task_info
;
799 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
801 read_atcb (task_id
, &task_info
);
802 data
->task_list
.push_back (task_info
);
805 /* Read the Known_Tasks array from the inferior memory, and store
806 it in the current inferior's TASK_LIST. Return non-zero upon success. */
809 read_known_tasks_array (struct ada_tasks_inferior_data
*data
)
811 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
812 const int known_tasks_size
= target_ptr_byte
* data
->known_tasks_length
;
813 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (known_tasks_size
);
816 /* Build a new list by reading the ATCBs from the Known_Tasks array
817 in the Ada runtime. */
818 read_memory (data
->known_tasks_addr
, known_tasks
, known_tasks_size
);
819 for (i
= 0; i
< data
->known_tasks_length
; i
++)
822 extract_typed_address (known_tasks
+ i
* target_ptr_byte
,
823 data
->known_tasks_element
);
826 add_ada_task (task_id
, current_inferior ());
832 /* Read the known tasks from the inferior memory, and store it in
833 the current inferior's TASK_LIST. Return non-zero upon success. */
836 read_known_tasks_list (struct ada_tasks_inferior_data
*data
)
838 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
839 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (target_ptr_byte
);
841 const struct ada_tasks_pspace_data
*pspace_data
842 = get_ada_tasks_pspace_data (current_program_space
);
845 if (pspace_data
->atcb_fieldno
.activation_link
< 0)
848 /* Build a new list by reading the ATCBs. Read head of the list. */
849 read_memory (data
->known_tasks_addr
, known_tasks
, target_ptr_byte
);
850 task_id
= extract_typed_address (known_tasks
, data
->known_tasks_element
);
853 struct value
*tcb_value
;
854 struct value
*common_value
;
856 add_ada_task (task_id
, current_inferior ());
858 /* Read the chain. */
859 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
861 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
862 task_id
= value_as_address
863 (value_field (common_value
,
864 pspace_data
->atcb_fieldno
.activation_link
));
870 /* Set all fields of the current inferior ada-tasks data pointed by DATA.
871 Do nothing if those fields are already set and still up to date. */
874 ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data
*data
)
876 struct bound_minimal_symbol msym
;
879 /* Return now if already set. */
880 if (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
)
885 msym
= lookup_minimal_symbol (KNOWN_TASKS_NAME
, NULL
, NULL
);
886 if (msym
.minsym
!= NULL
)
888 data
->known_tasks_kind
= ADA_TASKS_ARRAY
;
889 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
891 /* Try to get pointer type and array length from the symtab. */
892 sym
= lookup_symbol_in_language (KNOWN_TASKS_NAME
, NULL
, VAR_DOMAIN
,
893 language_c
, NULL
).symbol
;
897 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
898 struct type
*eltype
= NULL
;
899 struct type
*idxtype
= NULL
;
901 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
902 eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
904 && TYPE_CODE (eltype
) == TYPE_CODE_PTR
)
905 idxtype
= check_typedef (TYPE_INDEX_TYPE (type
));
907 && !TYPE_LOW_BOUND_UNDEFINED (idxtype
)
908 && !TYPE_HIGH_BOUND_UNDEFINED (idxtype
))
910 data
->known_tasks_element
= eltype
;
911 data
->known_tasks_length
=
912 TYPE_HIGH_BOUND (idxtype
) - TYPE_LOW_BOUND (idxtype
) + 1;
917 /* Fallback to default values. The runtime may have been stripped (as
918 in some distributions), but it is likely that the executable still
919 contains debug information on the task type (due to implicit with of
921 data
->known_tasks_element
=
922 builtin_type (target_gdbarch ())->builtin_data_ptr
;
923 data
->known_tasks_length
= MAX_NUMBER_OF_KNOWN_TASKS
;
930 msym
= lookup_minimal_symbol (KNOWN_TASKS_LIST
, NULL
, NULL
);
931 if (msym
.minsym
!= NULL
)
933 data
->known_tasks_kind
= ADA_TASKS_LIST
;
934 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
935 data
->known_tasks_length
= 1;
937 sym
= lookup_symbol_in_language (KNOWN_TASKS_LIST
, NULL
, VAR_DOMAIN
,
938 language_c
, NULL
).symbol
;
939 if (sym
!= NULL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
942 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
944 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
946 data
->known_tasks_element
= type
;
951 /* Fallback to default values. */
952 data
->known_tasks_element
=
953 builtin_type (target_gdbarch ())->builtin_data_ptr
;
954 data
->known_tasks_length
= 1;
958 /* Can't find tasks. */
960 data
->known_tasks_kind
= ADA_TASKS_NOT_FOUND
;
961 data
->known_tasks_addr
= 0;
964 /* Read the known tasks from the current inferior's memory, and store it
965 in the current inferior's data TASK_LIST.
966 Return non-zero upon success. */
969 read_known_tasks (void)
971 struct ada_tasks_inferior_data
*data
=
972 get_ada_tasks_inferior_data (current_inferior ());
974 /* Step 1: Clear the current list, if necessary. */
975 data
->task_list
.clear ();
977 /* Step 2: do the real work.
978 If the application does not use task, then no more needs to be done.
979 It is important to have the task list cleared (see above) before we
980 return, as we don't want a stale task list to be used... This can
981 happen for instance when debugging a non-multitasking program after
982 having debugged a multitasking one. */
983 ada_tasks_inferior_data_sniffer (data
);
984 gdb_assert (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
);
986 switch (data
->known_tasks_kind
)
988 case ADA_TASKS_NOT_FOUND
: /* Tasking not in use in inferior. */
990 case ADA_TASKS_ARRAY
:
991 return read_known_tasks_array (data
);
993 return read_known_tasks_list (data
);
996 /* Step 3: Set task_list_valid_p, to avoid re-reading the Known_Tasks
997 array unless needed. Then report a success. */
998 data
->task_list_valid_p
= 1;
1003 /* Build the task_list by reading the Known_Tasks array from
1004 the inferior, and return the number of tasks in that list
1005 (zero means that the program is not using tasking at all). */
1008 ada_build_task_list (void)
1010 struct ada_tasks_inferior_data
*data
;
1012 if (!target_has_stack
)
1013 error (_("Cannot inspect Ada tasks when program is not running"));
1015 data
= get_ada_tasks_inferior_data (current_inferior ());
1016 if (!data
->task_list_valid_p
)
1017 read_known_tasks ();
1019 return data
->task_list
.size ();
1022 /* Print a table providing a short description of all Ada tasks
1023 running inside inferior INF. If ARG_STR is set, it will be
1024 interpreted as a task number, and the table will be limited to
1028 print_ada_task_info (struct ui_out
*uiout
,
1030 struct inferior
*inf
)
1032 struct ada_tasks_inferior_data
*data
;
1033 int taskno
, nb_tasks
;
1037 if (ada_build_task_list () == 0)
1039 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1043 if (arg_str
!= NULL
&& arg_str
[0] != '\0')
1044 taskno_arg
= value_as_long (parse_and_eval (arg_str
));
1046 if (uiout
->is_mi_like_p ())
1047 /* In GDB/MI mode, we want to provide the thread ID corresponding
1048 to each task. This allows clients to quickly find the thread
1049 associated to any task, which is helpful for commands that
1050 take a --thread argument. However, in order to be able to
1051 provide that thread ID, the thread list must be up to date
1053 target_update_thread_list ();
1055 data
= get_ada_tasks_inferior_data (inf
);
1057 /* Compute the number of tasks that are going to be displayed
1058 in the output. If an argument was given, there will be
1059 at most 1 entry. Otherwise, there will be as many entries
1060 as we have tasks. */
1063 if (taskno_arg
> 0 && taskno_arg
<= data
->task_list
.size ())
1069 nb_tasks
= data
->task_list
.size ();
1071 nb_columns
= uiout
->is_mi_like_p () ? 8 : 7;
1072 ui_out_emit_table
table_emitter (uiout
, nb_columns
, nb_tasks
, "tasks");
1073 uiout
->table_header (1, ui_left
, "current", "");
1074 uiout
->table_header (3, ui_right
, "id", "ID");
1075 uiout
->table_header (9, ui_right
, "task-id", "TID");
1076 /* The following column is provided in GDB/MI mode only because
1077 it is only really useful in that mode, and also because it
1078 allows us to keep the CLI output shorter and more compact. */
1079 if (uiout
->is_mi_like_p ())
1080 uiout
->table_header (4, ui_right
, "thread-id", "");
1081 uiout
->table_header (4, ui_right
, "parent-id", "P-ID");
1082 uiout
->table_header (3, ui_right
, "priority", "Pri");
1083 uiout
->table_header (22, ui_left
, "state", "State");
1084 /* Use ui_noalign for the last column, to prevent the CLI uiout
1085 from printing an extra space at the end of each row. This
1086 is a bit of a hack, but does get the job done. */
1087 uiout
->table_header (1, ui_noalign
, "name", "Name");
1088 uiout
->table_body ();
1090 for (taskno
= 1; taskno
<= data
->task_list
.size (); taskno
++)
1092 const struct ada_task_info
*const task_info
=
1093 &data
->task_list
[taskno
- 1];
1096 gdb_assert (task_info
!= NULL
);
1098 /* If the user asked for the output to be restricted
1099 to one task only, and this is not the task, skip
1101 if (taskno_arg
&& taskno
!= taskno_arg
)
1104 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1106 /* Print a star if this task is the current task (or the task
1107 currently selected). */
1108 if (task_info
->ptid
== inferior_ptid
)
1109 uiout
->field_string ("current", "*");
1111 uiout
->field_skip ("current");
1113 /* Print the task number. */
1114 uiout
->field_int ("id", taskno
);
1116 /* Print the Task ID. */
1117 uiout
->field_fmt ("task-id", "%9lx", (long) task_info
->task_id
);
1119 /* Print the associated Thread ID. */
1120 if (uiout
->is_mi_like_p ())
1122 thread_info
*thread
= find_thread_ptid (task_info
->ptid
);
1125 uiout
->field_int ("thread-id", thread
->global_num
);
1127 /* This should never happen unless there is a bug somewhere,
1128 but be resilient when that happens. */
1129 uiout
->field_skip ("thread-id");
1132 /* Print the ID of the parent task. */
1133 parent_id
= get_task_number_from_id (task_info
->parent
, inf
);
1135 uiout
->field_int ("parent-id", parent_id
);
1137 uiout
->field_skip ("parent-id");
1139 /* Print the base priority of the task. */
1140 uiout
->field_int ("priority", task_info
->priority
);
1142 /* Print the task current state. */
1143 if (task_info
->caller_task
)
1144 uiout
->field_fmt ("state",
1145 _("Accepting RV with %-4d"),
1146 get_task_number_from_id (task_info
->caller_task
,
1148 else if (task_info
->called_task
)
1149 uiout
->field_fmt ("state",
1150 _("Waiting on RV with %-3d"),
1151 get_task_number_from_id (task_info
->called_task
,
1154 uiout
->field_string ("state", task_states
[task_info
->state
]);
1156 /* Finally, print the task name. */
1157 uiout
->field_fmt ("name",
1159 task_info
->name
[0] != '\0' ? task_info
->name
1166 /* Print a detailed description of the Ada task whose ID is TASKNO_STR
1167 for the given inferior (INF). */
1170 info_task (struct ui_out
*uiout
, const char *taskno_str
, struct inferior
*inf
)
1172 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1173 struct ada_task_info
*task_info
;
1174 int parent_taskno
= 0;
1175 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1177 if (ada_build_task_list () == 0)
1179 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1183 if (taskno
<= 0 || taskno
> data
->task_list
.size ())
1184 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1185 "see the IDs of currently known tasks"), taskno
);
1186 task_info
= &data
->task_list
[taskno
- 1];
1188 /* Print the Ada task ID. */
1189 printf_filtered (_("Ada Task: %s\n"),
1190 paddress (target_gdbarch (), task_info
->task_id
));
1192 /* Print the name of the task. */
1193 if (task_info
->name
[0] != '\0')
1194 printf_filtered (_("Name: %s\n"), task_info
->name
);
1196 printf_filtered (_("<no name>\n"));
1198 /* Print the TID and LWP. */
1199 printf_filtered (_("Thread: %#lx\n"), task_info
->ptid
.tid ());
1200 printf_filtered (_("LWP: %#lx\n"), task_info
->ptid
.lwp ());
1202 /* If set, print the base CPU. */
1203 if (task_info
->base_cpu
!= 0)
1204 printf_filtered (_("Base CPU: %d\n"), task_info
->base_cpu
);
1206 /* Print who is the parent (if any). */
1207 if (task_info
->parent
!= 0)
1208 parent_taskno
= get_task_number_from_id (task_info
->parent
, inf
);
1211 struct ada_task_info
*parent
= &data
->task_list
[parent_taskno
- 1];
1213 printf_filtered (_("Parent: %d"), parent_taskno
);
1214 if (parent
->name
[0] != '\0')
1215 printf_filtered (" (%s)", parent
->name
);
1216 printf_filtered ("\n");
1219 printf_filtered (_("No parent\n"));
1221 /* Print the base priority. */
1222 printf_filtered (_("Base Priority: %d\n"), task_info
->priority
);
1224 /* print the task current state. */
1226 int target_taskno
= 0;
1228 if (task_info
->caller_task
)
1230 target_taskno
= get_task_number_from_id (task_info
->caller_task
, inf
);
1231 printf_filtered (_("State: Accepting rendezvous with %d"),
1234 else if (task_info
->called_task
)
1236 target_taskno
= get_task_number_from_id (task_info
->called_task
, inf
);
1237 printf_filtered (_("State: Waiting on task %d's entry"),
1241 printf_filtered (_("State: %s"), _(long_task_states
[task_info
->state
]));
1245 ada_task_info
*target_task_info
= &data
->task_list
[target_taskno
- 1];
1247 if (target_task_info
->name
[0] != '\0')
1248 printf_filtered (" (%s)", target_task_info
->name
);
1251 printf_filtered ("\n");
1255 /* If ARG is empty or null, then print a list of all Ada tasks.
1256 Otherwise, print detailed information about the task whose ID
1259 Does nothing if the program doesn't use Ada tasking. */
1262 info_tasks_command (const char *arg
, int from_tty
)
1264 struct ui_out
*uiout
= current_uiout
;
1266 if (arg
== NULL
|| *arg
== '\0')
1267 print_ada_task_info (uiout
, NULL
, current_inferior ());
1269 info_task (uiout
, arg
, current_inferior ());
1272 /* Print a message telling the user id of the current task.
1273 This function assumes that tasking is in use in the inferior. */
1276 display_current_task_id (void)
1278 const int current_task
= ada_get_task_number (inferior_thread ());
1280 if (current_task
== 0)
1281 printf_filtered (_("[Current task is unknown]\n"));
1283 printf_filtered (_("[Current task is %d]\n"), current_task
);
1286 /* Parse and evaluate TIDSTR into a task id, and try to switch to
1287 that task. Print an error message if the task switch failed. */
1290 task_command_1 (const char *taskno_str
, int from_tty
, struct inferior
*inf
)
1292 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1293 struct ada_task_info
*task_info
;
1294 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1296 if (taskno
<= 0 || taskno
> data
->task_list
.size ())
1297 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1298 "see the IDs of currently known tasks"), taskno
);
1299 task_info
= &data
->task_list
[taskno
- 1];
1301 if (!ada_task_is_alive (task_info
))
1302 error (_("Cannot switch to task %d: Task is no longer running"), taskno
);
1304 /* On some platforms, the thread list is not updated until the user
1305 performs a thread-related operation (by using the "info threads"
1306 command, for instance). So this thread list may not be up to date
1307 when the user attempts this task switch. Since we cannot switch
1308 to the thread associated to our task if GDB does not know about
1309 that thread, we need to make sure that any new threads gets added
1310 to the thread list. */
1311 target_update_thread_list ();
1313 /* Verify that the ptid of the task we want to switch to is valid
1314 (in other words, a ptid that GDB knows about). Otherwise, we will
1315 cause an assertion failure later on, when we try to determine
1316 the ptid associated thread_info data. We should normally never
1317 encounter such an error, but the wrong ptid can actually easily be
1318 computed if target_get_ada_task_ptid has not been implemented for
1319 our target (yet). Rather than cause an assertion error in that case,
1320 it's nicer for the user to just refuse to perform the task switch. */
1321 thread_info
*tp
= find_thread_ptid (task_info
->ptid
);
1323 error (_("Unable to compute thread ID for task %d.\n"
1324 "Cannot switch to this task."),
1327 switch_to_thread (tp
);
1328 ada_find_printable_frame (get_selected_frame (NULL
));
1329 printf_filtered (_("[Switching to task %d]\n"), taskno
);
1330 print_stack_frame (get_selected_frame (NULL
),
1331 frame_relative_level (get_selected_frame (NULL
)),
1336 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
1337 Otherwise, switch to the task indicated by TASKNO_STR. */
1340 task_command (const char *taskno_str
, int from_tty
)
1342 struct ui_out
*uiout
= current_uiout
;
1344 if (ada_build_task_list () == 0)
1346 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1350 if (taskno_str
== NULL
|| taskno_str
[0] == '\0')
1351 display_current_task_id ();
1353 task_command_1 (taskno_str
, from_tty
, current_inferior ());
1356 /* Indicate that the given inferior's task list may have changed,
1357 so invalidate the cache. */
1360 ada_task_list_changed (struct inferior
*inf
)
1362 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1364 data
->task_list_valid_p
= 0;
1367 /* Invalidate the per-program-space data. */
1370 ada_tasks_invalidate_pspace_data (struct program_space
*pspace
)
1372 get_ada_tasks_pspace_data (pspace
)->initialized_p
= 0;
1375 /* Invalidate the per-inferior data. */
1378 ada_tasks_invalidate_inferior_data (struct inferior
*inf
)
1380 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1382 data
->known_tasks_kind
= ADA_TASKS_UNKNOWN
;
1383 data
->task_list_valid_p
= 0;
1386 /* The 'normal_stop' observer notification callback. */
1389 ada_tasks_normal_stop_observer (struct bpstats
*unused_args
, int unused_args2
)
1391 /* The inferior has been resumed, and just stopped. This means that
1392 our task_list needs to be recomputed before it can be used again. */
1393 ada_task_list_changed (current_inferior ());
1396 /* A routine to be called when the objfiles have changed. */
1399 ada_tasks_new_objfile_observer (struct objfile
*objfile
)
1401 struct inferior
*inf
;
1403 /* Invalidate the relevant data in our program-space data. */
1405 if (objfile
== NULL
)
1407 /* All objfiles are being cleared, so we should clear all
1408 our caches for all program spaces. */
1409 struct program_space
*pspace
;
1411 for (pspace
= program_spaces
; pspace
!= NULL
; pspace
= pspace
->next
)
1412 ada_tasks_invalidate_pspace_data (pspace
);
1416 /* The associated program-space data might have changed after
1417 this objfile was added. Invalidate all cached data. */
1418 ada_tasks_invalidate_pspace_data (objfile
->pspace
);
1421 /* Invalidate the per-inferior cache for all inferiors using
1422 this objfile (or, in other words, for all inferiors who have
1423 the same program-space as the objfile's program space).
1424 If all objfiles are being cleared (OBJFILE is NULL), then
1425 clear the caches for all inferiors. */
1427 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
1428 if (objfile
== NULL
|| inf
->pspace
== objfile
->pspace
)
1429 ada_tasks_invalidate_inferior_data (inf
);
1433 _initialize_tasks (void)
1435 ada_tasks_pspace_data_handle
1436 = register_program_space_data_with_cleanup (NULL
,
1437 ada_tasks_pspace_data_cleanup
);
1438 ada_tasks_inferior_data_handle
1439 = register_inferior_data_with_cleanup (NULL
,
1440 ada_tasks_inferior_data_cleanup
);
1442 /* Attach various observers. */
1443 gdb::observers::normal_stop
.attach (ada_tasks_normal_stop_observer
);
1444 gdb::observers::new_objfile
.attach (ada_tasks_new_objfile_observer
);
1446 /* Some new commands provided by this module. */
1447 add_info ("tasks", info_tasks_command
,
1448 _("Provide information about all known Ada tasks"));
1449 add_cmd ("task", class_run
, task_command
,
1450 _("Use this command to switch between Ada tasks.\n\
1451 Without argument, this command simply prints the current task ID"),