1 /* Copyright (C) 1992-2017 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/>. */
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 ptid is PTID, or zero
292 if the task could not be found. */
295 ada_get_task_number (ptid_t ptid
)
298 struct inferior
*inf
= find_inferior_ptid (ptid
);
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 (ptid_equal (VEC_index (ada_task_info_s
, data
->task_list
, i
)->ptid
,
309 return 0; /* No matching task found. */
312 /* Return the task number of the task running in inferior INF which
313 matches TASK_ID , or zero if the task could not be found. */
316 get_task_number_from_id (CORE_ADDR task_id
, struct inferior
*inf
)
318 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
321 for (i
= 0; i
< VEC_length (ada_task_info_s
, data
->task_list
); i
++)
323 struct ada_task_info
*task_info
=
324 VEC_index (ada_task_info_s
, data
->task_list
, i
);
326 if (task_info
->task_id
== task_id
)
330 /* Task not found. Return 0. */
334 /* Return non-zero if TASK_NUM is a valid task number. */
337 valid_task_id (int task_num
)
339 struct ada_tasks_inferior_data
*data
;
341 ada_build_task_list ();
342 data
= get_ada_tasks_inferior_data (current_inferior ());
344 && task_num
<= VEC_length (ada_task_info_s
, data
->task_list
));
347 /* Return non-zero iff the task STATE corresponds to a non-terminated
351 ada_task_is_alive (struct ada_task_info
*task_info
)
353 return (task_info
->state
!= Terminated
);
356 /* Search through the list of known tasks for the one whose ptid is
357 PTID, and return it. Return NULL if the task was not found. */
359 struct ada_task_info
*
360 ada_get_task_info_from_ptid (ptid_t ptid
)
363 struct ada_task_info
*task
;
364 struct ada_tasks_inferior_data
*data
;
366 ada_build_task_list ();
367 data
= get_ada_tasks_inferior_data (current_inferior ());
368 nb_tasks
= VEC_length (ada_task_info_s
, data
->task_list
);
370 for (i
= 0; i
< nb_tasks
; i
++)
372 task
= VEC_index (ada_task_info_s
, data
->task_list
, i
);
373 if (ptid_equal (task
->ptid
, ptid
))
380 /* Call the ITERATOR function once for each Ada task that hasn't been
384 iterate_over_live_ada_tasks (ada_task_list_iterator_ftype
*iterator
)
387 struct ada_task_info
*task
;
388 struct ada_tasks_inferior_data
*data
;
390 ada_build_task_list ();
391 data
= get_ada_tasks_inferior_data (current_inferior ());
392 nb_tasks
= VEC_length (ada_task_info_s
, data
->task_list
);
394 for (i
= 0; i
< nb_tasks
; i
++)
396 task
= VEC_index (ada_task_info_s
, data
->task_list
, i
);
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 will be needed in order to
471 read the list of known tasks in the Ada runtime. Also return the
472 associated ATCB_FIELDNOS.
474 Error handling: Any data missing from the debugging info will cause
475 an error to be raised, and none of the return values to be set.
476 Users of this function can depend on the fact that all or none of the
477 return values will be set. */
480 get_tcb_types_info (void)
483 struct type
*common_type
;
484 struct type
*ll_type
;
485 struct type
*call_type
;
486 struct atcb_fieldnos fieldnos
;
487 struct ada_tasks_pspace_data
*pspace_data
;
489 const char *atcb_name
= "system__tasking__ada_task_control_block___XVE";
490 const char *atcb_name_fixed
= "system__tasking__ada_task_control_block";
491 const char *common_atcb_name
= "system__tasking__common_atcb";
492 const char *private_data_name
= "system__task_primitives__private_data";
493 const char *entry_call_record_name
= "system__tasking__entry_call_record";
495 /* ATCB symbols may be found in several compilation units. As we
496 are only interested in one instance, use standard (literal,
497 C-like) lookups to get the first match. */
499 struct symbol
*atcb_sym
=
500 lookup_symbol_in_language (atcb_name
, NULL
, STRUCT_DOMAIN
,
501 language_c
, NULL
).symbol
;
502 const struct symbol
*common_atcb_sym
=
503 lookup_symbol_in_language (common_atcb_name
, NULL
, STRUCT_DOMAIN
,
504 language_c
, NULL
).symbol
;
505 const struct symbol
*private_data_sym
=
506 lookup_symbol_in_language (private_data_name
, NULL
, STRUCT_DOMAIN
,
507 language_c
, NULL
).symbol
;
508 const struct symbol
*entry_call_record_sym
=
509 lookup_symbol_in_language (entry_call_record_name
, NULL
, STRUCT_DOMAIN
,
510 language_c
, NULL
).symbol
;
512 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
514 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
515 size, so the symbol name differs. */
516 atcb_sym
= lookup_symbol_in_language (atcb_name_fixed
, NULL
,
517 STRUCT_DOMAIN
, language_c
,
520 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
521 error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
523 type
= atcb_sym
->type
;
527 /* Get a static representation of the type record
528 Ada_Task_Control_Block. */
529 type
= atcb_sym
->type
;
530 type
= ada_template_to_fixed_record_type_1 (type
, NULL
, 0, NULL
, 0);
533 if (common_atcb_sym
== NULL
|| common_atcb_sym
->type
== NULL
)
534 error (_("Cannot find Common_ATCB type. Aborting"));
535 if (private_data_sym
== NULL
|| private_data_sym
->type
== NULL
)
536 error (_("Cannot find Private_Data type. Aborting"));
537 if (entry_call_record_sym
== NULL
|| entry_call_record_sym
->type
== NULL
)
538 error (_("Cannot find Entry_Call_Record type. Aborting"));
540 /* Get the type for Ada_Task_Control_Block.Common. */
541 common_type
= common_atcb_sym
->type
;
543 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
544 ll_type
= private_data_sym
->type
;
546 /* Get the type for Common_ATCB.Call.all. */
547 call_type
= entry_call_record_sym
->type
;
549 /* Get the field indices. */
550 fieldnos
.common
= ada_get_field_index (type
, "common", 0);
551 fieldnos
.entry_calls
= ada_get_field_index (type
, "entry_calls", 1);
552 fieldnos
.atc_nesting_level
=
553 ada_get_field_index (type
, "atc_nesting_level", 1);
554 fieldnos
.state
= ada_get_field_index (common_type
, "state", 0);
555 fieldnos
.parent
= ada_get_field_index (common_type
, "parent", 1);
556 fieldnos
.priority
= ada_get_field_index (common_type
, "base_priority", 0);
557 fieldnos
.image
= ada_get_field_index (common_type
, "task_image", 1);
558 fieldnos
.image_len
= ada_get_field_index (common_type
, "task_image_len", 1);
559 fieldnos
.activation_link
= ada_get_field_index (common_type
,
560 "activation_link", 1);
561 fieldnos
.call
= ada_get_field_index (common_type
, "call", 1);
562 fieldnos
.ll
= ada_get_field_index (common_type
, "ll", 0);
563 fieldnos
.base_cpu
= ada_get_field_index (common_type
, "base_cpu", 0);
564 fieldnos
.ll_thread
= ada_get_field_index (ll_type
, "thread", 0);
565 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "lwp", 1);
566 fieldnos
.call_self
= ada_get_field_index (call_type
, "self", 0);
568 /* On certain platforms such as x86-windows, the "lwp" field has been
569 named "thread_id". This field will likely be renamed in the future,
570 but we need to support both possibilities to avoid an unnecessary
571 dependency on a recent compiler. We therefore try locating the
572 "thread_id" field in place of the "lwp" field if we did not find
574 if (fieldnos
.ll_lwp
< 0)
575 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "thread_id", 1);
577 /* Set all the out parameters all at once, now that we are certain
578 that there are no potential error() anymore. */
579 pspace_data
= get_ada_tasks_pspace_data (current_program_space
);
580 pspace_data
->initialized_p
= 1;
581 pspace_data
->atcb_type
= type
;
582 pspace_data
->atcb_common_type
= common_type
;
583 pspace_data
->atcb_ll_type
= ll_type
;
584 pspace_data
->atcb_call_type
= call_type
;
585 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 if (!pspace_data
->initialized_p
)
633 get_tcb_types_info ();
635 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
637 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
639 /* Fill in the task_id. */
641 task_info
->task_id
= task_id
;
643 /* Compute the name of the task.
645 Depending on the GNAT version used, the task image is either a fat
646 string, or a thin array of characters. Older versions of GNAT used
647 to use fat strings, and therefore did not need an extra field in
648 the ATCB to store the string length. For efficiency reasons, newer
649 versions of GNAT replaced the fat string by a static buffer, but this
650 also required the addition of a new field named "Image_Len" containing
651 the length of the task name. The method used to extract the task name
652 is selected depending on the existence of this field.
654 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
655 we may want to get it from the first user frame of the stack. For now,
656 we just give a dummy name. */
658 if (pspace_data
->atcb_fieldno
.image_len
== -1)
660 if (pspace_data
->atcb_fieldno
.image
>= 0)
661 read_fat_string_value (task_info
->name
,
662 value_field (common_value
,
663 pspace_data
->atcb_fieldno
.image
),
664 sizeof (task_info
->name
) - 1);
667 struct bound_minimal_symbol msym
;
669 msym
= lookup_minimal_symbol_by_pc (task_id
);
672 const char *full_name
= MSYMBOL_LINKAGE_NAME (msym
.minsym
);
673 const char *task_name
= full_name
;
676 /* Strip the prefix. */
677 for (p
= full_name
; *p
; p
++)
678 if (p
[0] == '_' && p
[1] == '_')
681 /* Copy the task name. */
682 strncpy (task_info
->name
, task_name
, sizeof (task_info
->name
));
683 task_info
->name
[sizeof (task_info
->name
) - 1] = 0;
687 /* No symbol found. Use a default name. */
688 strcpy (task_info
->name
, ravenscar_task_name
);
694 int len
= value_as_long
695 (value_field (common_value
,
696 pspace_data
->atcb_fieldno
.image_len
));
698 value_as_string (task_info
->name
,
699 value_field (common_value
,
700 pspace_data
->atcb_fieldno
.image
),
704 /* Compute the task state and priority. */
707 value_as_long (value_field (common_value
,
708 pspace_data
->atcb_fieldno
.state
));
709 task_info
->priority
=
710 value_as_long (value_field (common_value
,
711 pspace_data
->atcb_fieldno
.priority
));
713 /* If the ATCB contains some information about the parent task,
714 then compute it as well. Otherwise, zero. */
716 if (pspace_data
->atcb_fieldno
.parent
>= 0)
718 value_as_address (value_field (common_value
,
719 pspace_data
->atcb_fieldno
.parent
));
721 task_info
->parent
= 0;
724 /* If the ATCB contains some information about entry calls, then
725 compute the "called_task" as well. Otherwise, zero. */
727 if (pspace_data
->atcb_fieldno
.atc_nesting_level
> 0
728 && pspace_data
->atcb_fieldno
.entry_calls
> 0)
730 /* Let My_ATCB be the Ada task control block of a task calling the
731 entry of another task; then the Task_Id of the called task is
732 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
733 atc_nesting_level_value
=
734 value_field (tcb_value
, pspace_data
->atcb_fieldno
.atc_nesting_level
);
736 ada_coerce_to_simple_array_ptr
737 (value_field (tcb_value
, pspace_data
->atcb_fieldno
.entry_calls
));
738 entry_calls_value_element
=
739 value_subscript (entry_calls_value
,
740 value_as_long (atc_nesting_level_value
));
741 called_task_fieldno
=
742 ada_get_field_index (value_type (entry_calls_value_element
),
744 task_info
->called_task
=
745 value_as_address (value_field (entry_calls_value_element
,
746 called_task_fieldno
));
750 task_info
->called_task
= 0;
753 /* If the ATCB cotnains some information about RV callers,
754 then compute the "caller_task". Otherwise, zero. */
756 task_info
->caller_task
= 0;
757 if (pspace_data
->atcb_fieldno
.call
>= 0)
759 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
760 If Common_ATCB.Call is null, then there is no caller. */
761 const CORE_ADDR call
=
762 value_as_address (value_field (common_value
,
763 pspace_data
->atcb_fieldno
.call
));
764 struct value
*call_val
;
769 value_from_contents_and_address (pspace_data
->atcb_call_type
,
771 task_info
->caller_task
=
773 (value_field (call_val
, pspace_data
->atcb_fieldno
.call_self
));
778 = value_as_long (value_field (common_value
,
779 pspace_data
->atcb_fieldno
.base_cpu
));
781 /* And finally, compute the task ptid. Note that there are situations
782 where this cannot be determined:
783 - The task is no longer alive - the ptid is irrelevant;
784 - We are debugging a core file - the thread is not always
785 completely preserved for us to link back a task to its
786 underlying thread. Since we do not support task switching
787 when debugging core files anyway, we don't need to compute
789 In either case, we don't need that ptid, and it is just good enough
790 to set it to null_ptid. */
792 if (target_has_execution
&& ada_task_is_alive (task_info
))
793 task_info
->ptid
= ptid_from_atcb_common (common_value
);
795 task_info
->ptid
= null_ptid
;
798 /* Read the ATCB info of the given task (identified by TASK_ID), and
799 add the result to the given inferior's TASK_LIST. */
802 add_ada_task (CORE_ADDR task_id
, struct inferior
*inf
)
804 struct ada_task_info task_info
;
805 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
807 read_atcb (task_id
, &task_info
);
808 VEC_safe_push (ada_task_info_s
, data
->task_list
, &task_info
);
811 /* Read the Known_Tasks array from the inferior memory, and store
812 it in the current inferior's TASK_LIST. Return non-zero upon success. */
815 read_known_tasks_array (struct ada_tasks_inferior_data
*data
)
817 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
818 const int known_tasks_size
= target_ptr_byte
* data
->known_tasks_length
;
819 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (known_tasks_size
);
822 /* Build a new list by reading the ATCBs from the Known_Tasks array
823 in the Ada runtime. */
824 read_memory (data
->known_tasks_addr
, known_tasks
, known_tasks_size
);
825 for (i
= 0; i
< data
->known_tasks_length
; i
++)
828 extract_typed_address (known_tasks
+ i
* target_ptr_byte
,
829 data
->known_tasks_element
);
832 add_ada_task (task_id
, current_inferior ());
838 /* Read the known tasks from the inferior memory, and store it in
839 the current inferior's TASK_LIST. Return non-zero upon success. */
842 read_known_tasks_list (struct ada_tasks_inferior_data
*data
)
844 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
845 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (target_ptr_byte
);
847 const struct ada_tasks_pspace_data
*pspace_data
848 = get_ada_tasks_pspace_data (current_program_space
);
851 if (pspace_data
->atcb_fieldno
.activation_link
< 0)
854 /* Build a new list by reading the ATCBs. Read head of the list. */
855 read_memory (data
->known_tasks_addr
, known_tasks
, target_ptr_byte
);
856 task_id
= extract_typed_address (known_tasks
, data
->known_tasks_element
);
859 struct value
*tcb_value
;
860 struct value
*common_value
;
862 add_ada_task (task_id
, current_inferior ());
864 /* Read the chain. */
865 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
867 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
868 task_id
= value_as_address
869 (value_field (common_value
,
870 pspace_data
->atcb_fieldno
.activation_link
));
876 /* Set all fields of the current inferior ada-tasks data pointed by DATA.
877 Do nothing if those fields are already set and still up to date. */
880 ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data
*data
)
882 struct bound_minimal_symbol msym
;
885 /* Return now if already set. */
886 if (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
)
891 msym
= lookup_minimal_symbol (KNOWN_TASKS_NAME
, NULL
, NULL
);
892 if (msym
.minsym
!= NULL
)
894 data
->known_tasks_kind
= ADA_TASKS_ARRAY
;
895 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
897 /* Try to get pointer type and array length from the symtab. */
898 sym
= lookup_symbol_in_language (KNOWN_TASKS_NAME
, NULL
, VAR_DOMAIN
,
899 language_c
, NULL
).symbol
;
903 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
904 struct type
*eltype
= NULL
;
905 struct type
*idxtype
= NULL
;
907 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
908 eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
910 && TYPE_CODE (eltype
) == TYPE_CODE_PTR
)
911 idxtype
= check_typedef (TYPE_INDEX_TYPE (type
));
913 && !TYPE_LOW_BOUND_UNDEFINED (idxtype
)
914 && !TYPE_HIGH_BOUND_UNDEFINED (idxtype
))
916 data
->known_tasks_element
= eltype
;
917 data
->known_tasks_length
=
918 TYPE_HIGH_BOUND (idxtype
) - TYPE_LOW_BOUND (idxtype
) + 1;
923 /* Fallback to default values. The runtime may have been stripped (as
924 in some distributions), but it is likely that the executable still
925 contains debug information on the task type (due to implicit with of
927 data
->known_tasks_element
=
928 builtin_type (target_gdbarch ())->builtin_data_ptr
;
929 data
->known_tasks_length
= MAX_NUMBER_OF_KNOWN_TASKS
;
936 msym
= lookup_minimal_symbol (KNOWN_TASKS_LIST
, NULL
, NULL
);
937 if (msym
.minsym
!= NULL
)
939 data
->known_tasks_kind
= ADA_TASKS_LIST
;
940 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
941 data
->known_tasks_length
= 1;
943 sym
= lookup_symbol_in_language (KNOWN_TASKS_LIST
, NULL
, VAR_DOMAIN
,
944 language_c
, NULL
).symbol
;
945 if (sym
!= NULL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
948 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
950 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
952 data
->known_tasks_element
= type
;
957 /* Fallback to default values. */
958 data
->known_tasks_element
=
959 builtin_type (target_gdbarch ())->builtin_data_ptr
;
960 data
->known_tasks_length
= 1;
964 /* Can't find tasks. */
966 data
->known_tasks_kind
= ADA_TASKS_NOT_FOUND
;
967 data
->known_tasks_addr
= 0;
970 /* Read the known tasks from the current inferior's memory, and store it
971 in the current inferior's data TASK_LIST.
972 Return non-zero upon success. */
975 read_known_tasks (void)
977 struct ada_tasks_inferior_data
*data
=
978 get_ada_tasks_inferior_data (current_inferior ());
980 /* Step 1: Clear the current list, if necessary. */
981 VEC_truncate (ada_task_info_s
, data
->task_list
, 0);
983 /* Step 2: do the real work.
984 If the application does not use task, then no more needs to be done.
985 It is important to have the task list cleared (see above) before we
986 return, as we don't want a stale task list to be used... This can
987 happen for instance when debugging a non-multitasking program after
988 having debugged a multitasking one. */
989 ada_tasks_inferior_data_sniffer (data
);
990 gdb_assert (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
);
992 switch (data
->known_tasks_kind
)
994 case ADA_TASKS_NOT_FOUND
: /* Tasking not in use in inferior. */
996 case ADA_TASKS_ARRAY
:
997 return read_known_tasks_array (data
);
999 return read_known_tasks_list (data
);
1002 /* Step 3: Set task_list_valid_p, to avoid re-reading the Known_Tasks
1003 array unless needed. Then report a success. */
1004 data
->task_list_valid_p
= 1;
1009 /* Build the task_list by reading the Known_Tasks array from
1010 the inferior, and return the number of tasks in that list
1011 (zero means that the program is not using tasking at all). */
1014 ada_build_task_list (void)
1016 struct ada_tasks_inferior_data
*data
;
1018 if (!target_has_stack
)
1019 error (_("Cannot inspect Ada tasks when program is not running"));
1021 data
= get_ada_tasks_inferior_data (current_inferior ());
1022 if (!data
->task_list_valid_p
)
1023 read_known_tasks ();
1025 return VEC_length (ada_task_info_s
, data
->task_list
);
1028 /* Print a table providing a short description of all Ada tasks
1029 running inside inferior INF. If ARG_STR is set, it will be
1030 interpreted as a task number, and the table will be limited to
1034 print_ada_task_info (struct ui_out
*uiout
,
1036 struct inferior
*inf
)
1038 struct ada_tasks_inferior_data
*data
;
1039 int taskno
, nb_tasks
;
1043 if (ada_build_task_list () == 0)
1045 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1049 if (arg_str
!= NULL
&& arg_str
[0] != '\0')
1050 taskno_arg
= value_as_long (parse_and_eval (arg_str
));
1052 if (uiout
->is_mi_like_p ())
1053 /* In GDB/MI mode, we want to provide the thread ID corresponding
1054 to each task. This allows clients to quickly find the thread
1055 associated to any task, which is helpful for commands that
1056 take a --thread argument. However, in order to be able to
1057 provide that thread ID, the thread list must be up to date
1059 target_update_thread_list ();
1061 data
= get_ada_tasks_inferior_data (inf
);
1063 /* Compute the number of tasks that are going to be displayed
1064 in the output. If an argument was given, there will be
1065 at most 1 entry. Otherwise, there will be as many entries
1066 as we have tasks. */
1070 && taskno_arg
<= VEC_length (ada_task_info_s
, data
->task_list
))
1076 nb_tasks
= VEC_length (ada_task_info_s
, data
->task_list
);
1078 nb_columns
= uiout
->is_mi_like_p () ? 8 : 7;
1079 ui_out_emit_table
table_emitter (uiout
, nb_columns
, nb_tasks
, "tasks");
1080 uiout
->table_header (1, ui_left
, "current", "");
1081 uiout
->table_header (3, ui_right
, "id", "ID");
1082 uiout
->table_header (9, ui_right
, "task-id", "TID");
1083 /* The following column is provided in GDB/MI mode only because
1084 it is only really useful in that mode, and also because it
1085 allows us to keep the CLI output shorter and more compact. */
1086 if (uiout
->is_mi_like_p ())
1087 uiout
->table_header (4, ui_right
, "thread-id", "");
1088 uiout
->table_header (4, ui_right
, "parent-id", "P-ID");
1089 uiout
->table_header (3, ui_right
, "priority", "Pri");
1090 uiout
->table_header (22, ui_left
, "state", "State");
1091 /* Use ui_noalign for the last column, to prevent the CLI uiout
1092 from printing an extra space at the end of each row. This
1093 is a bit of a hack, but does get the job done. */
1094 uiout
->table_header (1, ui_noalign
, "name", "Name");
1095 uiout
->table_body ();
1098 taskno
<= VEC_length (ada_task_info_s
, data
->task_list
);
1101 const struct ada_task_info
*const task_info
=
1102 VEC_index (ada_task_info_s
, data
->task_list
, taskno
- 1);
1105 gdb_assert (task_info
!= NULL
);
1107 /* If the user asked for the output to be restricted
1108 to one task only, and this is not the task, skip
1110 if (taskno_arg
&& taskno
!= taskno_arg
)
1113 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1115 /* Print a star if this task is the current task (or the task
1116 currently selected). */
1117 if (ptid_equal (task_info
->ptid
, inferior_ptid
))
1118 uiout
->field_string ("current", "*");
1120 uiout
->field_skip ("current");
1122 /* Print the task number. */
1123 uiout
->field_int ("id", taskno
);
1125 /* Print the Task ID. */
1126 uiout
->field_fmt ("task-id", "%9lx", (long) task_info
->task_id
);
1128 /* Print the associated Thread ID. */
1129 if (uiout
->is_mi_like_p ())
1131 const int thread_id
= ptid_to_global_thread_id (task_info
->ptid
);
1134 uiout
->field_int ("thread-id", thread_id
);
1136 /* This should never happen unless there is a bug somewhere,
1137 but be resilient when that happens. */
1138 uiout
->field_skip ("thread-id");
1141 /* Print the ID of the parent task. */
1142 parent_id
= get_task_number_from_id (task_info
->parent
, inf
);
1144 uiout
->field_int ("parent-id", parent_id
);
1146 uiout
->field_skip ("parent-id");
1148 /* Print the base priority of the task. */
1149 uiout
->field_int ("priority", task_info
->priority
);
1151 /* Print the task current state. */
1152 if (task_info
->caller_task
)
1153 uiout
->field_fmt ("state",
1154 _("Accepting RV with %-4d"),
1155 get_task_number_from_id (task_info
->caller_task
,
1157 else if (task_info
->state
== Entry_Caller_Sleep
1158 && task_info
->called_task
)
1159 uiout
->field_fmt ("state",
1160 _("Waiting on RV with %-3d"),
1161 get_task_number_from_id (task_info
->called_task
,
1164 uiout
->field_string ("state", task_states
[task_info
->state
]);
1166 /* Finally, print the task name. */
1167 uiout
->field_fmt ("name",
1169 task_info
->name
[0] != '\0' ? task_info
->name
1176 /* Print a detailed description of the Ada task whose ID is TASKNO_STR
1177 for the given inferior (INF). */
1180 info_task (struct ui_out
*uiout
, const char *taskno_str
, struct inferior
*inf
)
1182 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1183 struct ada_task_info
*task_info
;
1184 int parent_taskno
= 0;
1185 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1187 if (ada_build_task_list () == 0)
1189 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1193 if (taskno
<= 0 || taskno
> VEC_length (ada_task_info_s
, data
->task_list
))
1194 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1195 "see the IDs of currently known tasks"), taskno
);
1196 task_info
= VEC_index (ada_task_info_s
, data
->task_list
, taskno
- 1);
1198 /* Print the Ada task ID. */
1199 printf_filtered (_("Ada Task: %s\n"),
1200 paddress (target_gdbarch (), task_info
->task_id
));
1202 /* Print the name of the task. */
1203 if (task_info
->name
[0] != '\0')
1204 printf_filtered (_("Name: %s\n"), task_info
->name
);
1206 printf_filtered (_("<no name>\n"));
1208 /* Print the TID and LWP. */
1209 printf_filtered (_("Thread: %#lx\n"), ptid_get_tid (task_info
->ptid
));
1210 printf_filtered (_("LWP: %#lx\n"), ptid_get_lwp (task_info
->ptid
));
1212 /* If set, print the base CPU. */
1213 if (task_info
->base_cpu
!= 0)
1214 printf_filtered (_("Base CPU: %d\n"), task_info
->base_cpu
);
1216 /* Print who is the parent (if any). */
1217 if (task_info
->parent
!= 0)
1218 parent_taskno
= get_task_number_from_id (task_info
->parent
, inf
);
1221 struct ada_task_info
*parent
=
1222 VEC_index (ada_task_info_s
, data
->task_list
, parent_taskno
- 1);
1224 printf_filtered (_("Parent: %d"), parent_taskno
);
1225 if (parent
->name
[0] != '\0')
1226 printf_filtered (" (%s)", parent
->name
);
1227 printf_filtered ("\n");
1230 printf_filtered (_("No parent\n"));
1232 /* Print the base priority. */
1233 printf_filtered (_("Base Priority: %d\n"), task_info
->priority
);
1235 /* print the task current state. */
1237 int target_taskno
= 0;
1239 if (task_info
->caller_task
)
1241 target_taskno
= get_task_number_from_id (task_info
->caller_task
, inf
);
1242 printf_filtered (_("State: Accepting rendezvous with %d"),
1245 else if (task_info
->state
== Entry_Caller_Sleep
&& task_info
->called_task
)
1247 target_taskno
= get_task_number_from_id (task_info
->called_task
, inf
);
1248 printf_filtered (_("State: Waiting on task %d's entry"),
1252 printf_filtered (_("State: %s"), _(long_task_states
[task_info
->state
]));
1256 struct ada_task_info
*target_task_info
=
1257 VEC_index (ada_task_info_s
, data
->task_list
, target_taskno
- 1);
1259 if (target_task_info
->name
[0] != '\0')
1260 printf_filtered (" (%s)", target_task_info
->name
);
1263 printf_filtered ("\n");
1267 /* If ARG is empty or null, then print a list of all Ada tasks.
1268 Otherwise, print detailed information about the task whose ID
1271 Does nothing if the program doesn't use Ada tasking. */
1274 info_tasks_command (const char *arg
, int from_tty
)
1276 struct ui_out
*uiout
= current_uiout
;
1278 if (arg
== NULL
|| *arg
== '\0')
1279 print_ada_task_info (uiout
, NULL
, current_inferior ());
1281 info_task (uiout
, arg
, current_inferior ());
1284 /* Print a message telling the user id of the current task.
1285 This function assumes that tasking is in use in the inferior. */
1288 display_current_task_id (void)
1290 const int current_task
= ada_get_task_number (inferior_ptid
);
1292 if (current_task
== 0)
1293 printf_filtered (_("[Current task is unknown]\n"));
1295 printf_filtered (_("[Current task is %d]\n"), current_task
);
1298 /* Parse and evaluate TIDSTR into a task id, and try to switch to
1299 that task. Print an error message if the task switch failed. */
1302 task_command_1 (const char *taskno_str
, int from_tty
, struct inferior
*inf
)
1304 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1305 struct ada_task_info
*task_info
;
1306 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1308 if (taskno
<= 0 || taskno
> VEC_length (ada_task_info_s
, data
->task_list
))
1309 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1310 "see the IDs of currently known tasks"), taskno
);
1311 task_info
= VEC_index (ada_task_info_s
, data
->task_list
, taskno
- 1);
1313 if (!ada_task_is_alive (task_info
))
1314 error (_("Cannot switch to task %d: Task is no longer running"), taskno
);
1316 /* On some platforms, the thread list is not updated until the user
1317 performs a thread-related operation (by using the "info threads"
1318 command, for instance). So this thread list may not be up to date
1319 when the user attempts this task switch. Since we cannot switch
1320 to the thread associated to our task if GDB does not know about
1321 that thread, we need to make sure that any new threads gets added
1322 to the thread list. */
1323 target_update_thread_list ();
1325 /* Verify that the ptid of the task we want to switch to is valid
1326 (in other words, a ptid that GDB knows about). Otherwise, we will
1327 cause an assertion failure later on, when we try to determine
1328 the ptid associated thread_info data. We should normally never
1329 encounter such an error, but the wrong ptid can actually easily be
1330 computed if target_get_ada_task_ptid has not been implemented for
1331 our target (yet). Rather than cause an assertion error in that case,
1332 it's nicer for the user to just refuse to perform the task switch. */
1333 if (!find_thread_ptid (task_info
->ptid
))
1334 error (_("Unable to compute thread ID for task %d.\n"
1335 "Cannot switch to this task."),
1338 switch_to_thread (task_info
->ptid
);
1339 ada_find_printable_frame (get_selected_frame (NULL
));
1340 printf_filtered (_("[Switching to task %d]\n"), taskno
);
1341 print_stack_frame (get_selected_frame (NULL
),
1342 frame_relative_level (get_selected_frame (NULL
)),
1347 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
1348 Otherwise, switch to the task indicated by TASKNO_STR. */
1351 task_command (const char *taskno_str
, int from_tty
)
1353 struct ui_out
*uiout
= current_uiout
;
1355 if (ada_build_task_list () == 0)
1357 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1361 if (taskno_str
== NULL
|| taskno_str
[0] == '\0')
1362 display_current_task_id ();
1365 /* Task switching in core files doesn't work, either because:
1366 1. Thread support is not implemented with core files
1367 2. Thread support is implemented, but the thread IDs created
1368 after having read the core file are not the same as the ones
1369 that were used during the program life, before the crash.
1370 As a consequence, there is no longer a way for the debugger
1371 to find the associated thead ID of any given Ada task.
1372 So, instead of attempting a task switch without giving the user
1373 any clue as to what might have happened, just error-out with
1374 a message explaining that this feature is not supported. */
1375 if (!target_has_execution
)
1377 Task switching not supported when debugging from core files\n\
1378 (use thread support instead)"));
1379 task_command_1 (taskno_str
, from_tty
, current_inferior ());
1383 /* Indicate that the given inferior's task list may have changed,
1384 so invalidate the cache. */
1387 ada_task_list_changed (struct inferior
*inf
)
1389 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1391 data
->task_list_valid_p
= 0;
1394 /* Invalidate the per-program-space data. */
1397 ada_tasks_invalidate_pspace_data (struct program_space
*pspace
)
1399 get_ada_tasks_pspace_data (pspace
)->initialized_p
= 0;
1402 /* Invalidate the per-inferior data. */
1405 ada_tasks_invalidate_inferior_data (struct inferior
*inf
)
1407 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1409 data
->known_tasks_kind
= ADA_TASKS_UNKNOWN
;
1410 data
->task_list_valid_p
= 0;
1413 /* The 'normal_stop' observer notification callback. */
1416 ada_tasks_normal_stop_observer (struct bpstats
*unused_args
, int unused_args2
)
1418 /* The inferior has been resumed, and just stopped. This means that
1419 our task_list needs to be recomputed before it can be used again. */
1420 ada_task_list_changed (current_inferior ());
1423 /* A routine to be called when the objfiles have changed. */
1426 ada_tasks_new_objfile_observer (struct objfile
*objfile
)
1428 struct inferior
*inf
;
1430 /* Invalidate the relevant data in our program-space data. */
1432 if (objfile
== NULL
)
1434 /* All objfiles are being cleared, so we should clear all
1435 our caches for all program spaces. */
1436 struct program_space
*pspace
;
1438 for (pspace
= program_spaces
; pspace
!= NULL
; pspace
= pspace
->next
)
1439 ada_tasks_invalidate_pspace_data (pspace
);
1443 /* The associated program-space data might have changed after
1444 this objfile was added. Invalidate all cached data. */
1445 ada_tasks_invalidate_pspace_data (objfile
->pspace
);
1448 /* Invalidate the per-inferior cache for all inferiors using
1449 this objfile (or, in other words, for all inferiors who have
1450 the same program-space as the objfile's program space).
1451 If all objfiles are being cleared (OBJFILE is NULL), then
1452 clear the caches for all inferiors. */
1454 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
1455 if (objfile
== NULL
|| inf
->pspace
== objfile
->pspace
)
1456 ada_tasks_invalidate_inferior_data (inf
);
1460 _initialize_tasks (void)
1462 ada_tasks_pspace_data_handle
= register_program_space_data ();
1463 ada_tasks_inferior_data_handle
= register_inferior_data ();
1465 /* Attach various observers. */
1466 observer_attach_normal_stop (ada_tasks_normal_stop_observer
);
1467 observer_attach_new_objfile (ada_tasks_new_objfile_observer
);
1469 /* Some new commands provided by this module. */
1470 add_info ("tasks", info_tasks_command
,
1471 _("Provide information about all known Ada tasks"));
1472 add_cmd ("task", class_run
, task_command
,
1473 _("Use this command to switch between Ada tasks.\n\
1474 Without argument, this command simply prints the current task ID"),