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/>. */
20 /* Local non-gdb includes. */
24 #include "gdbthread.h"
27 #include "observable.h"
28 #include "progspace.h"
31 static int ada_build_task_list ();
33 /* The name of the array in the GNAT runtime where the Ada Task Control
34 Block of each task is stored. */
35 #define KNOWN_TASKS_NAME "system__tasking__debug__known_tasks"
37 /* The maximum number of tasks known to the Ada runtime. */
38 static const int MAX_NUMBER_OF_KNOWN_TASKS
= 1000;
40 /* The name of the variable in the GNAT runtime where the head of a task
41 chain is saved. This is an alternate mechanism to find the list of known
43 #define KNOWN_TASKS_LIST "system__tasking__debug__first_task"
55 Master_Completion_Sleep
,
57 Interrupt_Server_Idle_Sleep
,
58 Interrupt_Server_Blocked_Interrupt_Sleep
,
62 Interrupt_Server_Blocked_On_Event_Flag
,
67 /* A short description corresponding to each possible task state. */
68 static const char *task_states
[] = {
72 N_("Child Activation Wait"),
73 N_("Accept or Select Term"),
74 N_("Waiting on entry call"),
75 N_("Async Select Wait"),
77 N_("Child Termination Wait"),
78 N_("Wait Child in Term Alt"),
83 N_("Asynchronous Hold"),
89 /* A longer description corresponding to each possible task state. */
90 static const char *long_task_states
[] = {
94 N_("Waiting for child activation"),
95 N_("Blocked in accept or select with terminate"),
96 N_("Waiting on entry call"),
97 N_("Asynchronous Selective Wait"),
99 N_("Waiting for children termination"),
100 N_("Waiting for children in terminate alternative"),
105 N_("Asynchronous Hold"),
108 N_("Blocked in selective wait statement")
111 /* The index of certain important fields in the Ada Task Control Block
112 record and sub-records. */
116 /* Fields in record Ada_Task_Control_Block. */
119 int atc_nesting_level
;
121 /* Fields in record Common_ATCB. */
126 int image_len
; /* This field may be missing. */
132 /* Fields in Task_Primitives.Private_Data. */
134 int ll_lwp
; /* This field may be missing. */
136 /* Fields in Common_ATCB.Call.all. */
140 /* This module's per-program-space data. */
142 struct ada_tasks_pspace_data
144 /* Nonzero if the data has been initialized. If set to zero,
145 it means that the data has either not been initialized, or
146 has potentially become stale. */
149 /* The ATCB record type. */
150 struct type
*atcb_type
;
152 /* The ATCB "Common" component type. */
153 struct type
*atcb_common_type
;
155 /* The type of the "ll" field, from the atcb_common_type. */
156 struct type
*atcb_ll_type
;
158 /* The type of the "call" field, from the atcb_common_type. */
159 struct type
*atcb_call_type
;
161 /* The index of various fields in the ATCB record and sub-records. */
162 struct atcb_fieldnos atcb_fieldno
;
165 /* Key to our per-program-space data. */
166 static const struct program_space_data
*ada_tasks_pspace_data_handle
;
168 /* A cleanup routine for our per-program-space data. */
170 ada_tasks_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
172 struct ada_tasks_pspace_data
*data
173 = (struct ada_tasks_pspace_data
*) arg
;
177 /* The kind of data structure used by the runtime to store the list
180 enum ada_known_tasks_kind
182 /* Use this value when we haven't determined which kind of structure
183 is being used, or when we need to recompute it.
185 We set the value of this enumerate to zero on purpose: This allows
186 us to use this enumerate in a structure where setting all fields
187 to zero will result in this kind being set to unknown. */
188 ADA_TASKS_UNKNOWN
= 0,
190 /* This value means that we did not find any task list. Unless
191 there is a bug somewhere, this means that the inferior does not
195 /* This value means that the task list is stored as an array.
196 This is the usual method, as it causes very little overhead.
197 But this method is not always used, as it does use a certain
198 amount of memory, which might be scarse in certain environments. */
201 /* This value means that the task list is stored as a linked list.
202 This has more runtime overhead than the array approach, but
203 also require less memory when the number of tasks is small. */
207 /* This module's per-inferior data. */
209 struct ada_tasks_inferior_data
211 /* The type of data structure used by the runtime to store
212 the list of Ada tasks. The value of this field influences
213 the interpretation of the known_tasks_addr field below:
214 - ADA_TASKS_UNKNOWN: The value of known_tasks_addr hasn't
216 - ADA_TASKS_NOT_FOUND: The program probably does not use tasking
217 and the known_tasks_addr is irrelevant;
218 - ADA_TASKS_ARRAY: The known_tasks is an array;
219 - ADA_TASKS_LIST: The known_tasks is a list. */
220 enum ada_known_tasks_kind known_tasks_kind
= ADA_TASKS_UNKNOWN
;
222 /* The address of the known_tasks structure. This is where
223 the runtime stores the information for all Ada tasks.
224 The interpretation of this field depends on KNOWN_TASKS_KIND
226 CORE_ADDR known_tasks_addr
= 0;
228 /* Type of elements of the known task. Usually a pointer. */
229 struct type
*known_tasks_element
= nullptr;
231 /* Number of elements in the known tasks array. */
232 unsigned int known_tasks_length
= 0;
234 /* When nonzero, this flag indicates that the task_list field
235 below is up to date. When set to zero, the list has either
236 not been initialized, or has potentially become stale. */
237 bool task_list_valid_p
= false;
239 /* The list of Ada tasks.
241 Note: To each task we associate a number that the user can use to
242 reference it - this number is printed beside each task in the tasks
243 info listing displayed by "info tasks". This number is equal to
244 its index in the vector + 1. Reciprocally, to compute the index
245 of a task in the vector, we need to substract 1 from its number. */
246 std::vector
<ada_task_info
> task_list
;
249 /* Key to our per-inferior data. */
250 static const struct inferior_data
*ada_tasks_inferior_data_handle
;
252 /* Return the ada-tasks module's data for the given program space (PSPACE).
253 If none is found, add a zero'ed one now.
255 This function always returns a valid object. */
257 static struct ada_tasks_pspace_data
*
258 get_ada_tasks_pspace_data (struct program_space
*pspace
)
260 struct ada_tasks_pspace_data
*data
;
262 data
= ((struct ada_tasks_pspace_data
*)
263 program_space_data (pspace
, ada_tasks_pspace_data_handle
));
266 data
= XCNEW (struct ada_tasks_pspace_data
);
267 set_program_space_data (pspace
, ada_tasks_pspace_data_handle
, data
);
273 /* Return the ada-tasks module's data for the given inferior (INF).
274 If none is found, add a zero'ed one now.
276 This function always returns a valid object.
278 Note that we could use an observer of the inferior-created event
279 to make sure that the ada-tasks per-inferior data always exists.
280 But we prefered this approach, as it avoids this entirely as long
281 as the user does not use any of the tasking features. This is
282 quite possible, particularly in the case where the inferior does
285 static struct ada_tasks_inferior_data
*
286 get_ada_tasks_inferior_data (struct inferior
*inf
)
288 struct ada_tasks_inferior_data
*data
;
290 data
= ((struct ada_tasks_inferior_data
*)
291 inferior_data (inf
, ada_tasks_inferior_data_handle
));
294 data
= new ada_tasks_inferior_data
;
295 set_inferior_data (inf
, ada_tasks_inferior_data_handle
, data
);
301 /* A cleanup routine for our per-inferior data. */
303 ada_tasks_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
305 struct ada_tasks_inferior_data
*data
306 = (struct ada_tasks_inferior_data
*) arg
;
310 /* Return the task number of the task whose thread is THREAD, or zero
311 if the task could not be found. */
314 ada_get_task_number (thread_info
*thread
)
316 struct inferior
*inf
= thread
->inf
;
317 struct ada_tasks_inferior_data
*data
;
319 gdb_assert (inf
!= NULL
);
320 data
= get_ada_tasks_inferior_data (inf
);
322 for (int i
= 0; i
< data
->task_list
.size (); i
++)
323 if (data
->task_list
[i
].ptid
== thread
->ptid
)
326 return 0; /* No matching task found. */
329 /* Return the task number of the task running in inferior INF which
330 matches TASK_ID , or zero if the task could not be found. */
333 get_task_number_from_id (CORE_ADDR task_id
, struct inferior
*inf
)
335 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
337 for (int i
= 0; i
< data
->task_list
.size (); i
++)
339 if (data
->task_list
[i
].task_id
== task_id
)
343 /* Task not found. Return 0. */
347 /* Return non-zero if TASK_NUM is a valid task number. */
350 valid_task_id (int task_num
)
352 struct ada_tasks_inferior_data
*data
;
354 ada_build_task_list ();
355 data
= get_ada_tasks_inferior_data (current_inferior ());
356 return task_num
> 0 && task_num
<= data
->task_list
.size ();
359 /* Return non-zero iff the task STATE corresponds to a non-terminated
363 ada_task_is_alive (struct ada_task_info
*task_info
)
365 return (task_info
->state
!= Terminated
);
368 /* Search through the list of known tasks for the one whose ptid is
369 PTID, and return it. Return NULL if the task was not found. */
371 struct ada_task_info
*
372 ada_get_task_info_from_ptid (ptid_t ptid
)
374 struct ada_tasks_inferior_data
*data
;
376 ada_build_task_list ();
377 data
= get_ada_tasks_inferior_data (current_inferior ());
379 for (ada_task_info
&task
: data
->task_list
)
381 if (task
.ptid
== ptid
)
388 /* Call the ITERATOR function once for each Ada task that hasn't been
392 iterate_over_live_ada_tasks (ada_task_list_iterator_ftype
*iterator
)
394 struct ada_tasks_inferior_data
*data
;
396 ada_build_task_list ();
397 data
= get_ada_tasks_inferior_data (current_inferior ());
399 for (ada_task_info
&task
: data
->task_list
)
401 if (!ada_task_is_alive (&task
))
407 /* Extract the contents of the value as a string whose length is LENGTH,
408 and store the result in DEST. */
411 value_as_string (char *dest
, struct value
*val
, int length
)
413 memcpy (dest
, value_contents (val
), length
);
417 /* Extract the string image from the fat string corresponding to VAL,
418 and store it in DEST. If the string length is greater than MAX_LEN,
419 then truncate the result to the first MAX_LEN characters of the fat
423 read_fat_string_value (char *dest
, struct value
*val
, int max_len
)
425 struct value
*array_val
;
426 struct value
*bounds_val
;
429 /* The following variables are made static to avoid recomputing them
430 each time this function is called. */
431 static int initialize_fieldnos
= 1;
432 static int array_fieldno
;
433 static int bounds_fieldno
;
434 static int upper_bound_fieldno
;
436 /* Get the index of the fields that we will need to read in order
437 to extract the string from the fat string. */
438 if (initialize_fieldnos
)
440 struct type
*type
= value_type (val
);
441 struct type
*bounds_type
;
443 array_fieldno
= ada_get_field_index (type
, "P_ARRAY", 0);
444 bounds_fieldno
= ada_get_field_index (type
, "P_BOUNDS", 0);
446 bounds_type
= TYPE_FIELD_TYPE (type
, bounds_fieldno
);
447 if (TYPE_CODE (bounds_type
) == TYPE_CODE_PTR
)
448 bounds_type
= TYPE_TARGET_TYPE (bounds_type
);
449 if (TYPE_CODE (bounds_type
) != TYPE_CODE_STRUCT
)
450 error (_("Unknown task name format. Aborting"));
451 upper_bound_fieldno
= ada_get_field_index (bounds_type
, "UB0", 0);
453 initialize_fieldnos
= 0;
456 /* Get the size of the task image by checking the value of the bounds.
457 The lower bound is always 1, so we only need to read the upper bound. */
458 bounds_val
= value_ind (value_field (val
, bounds_fieldno
));
459 len
= value_as_long (value_field (bounds_val
, upper_bound_fieldno
));
461 /* Make sure that we do not read more than max_len characters... */
465 /* Extract LEN characters from the fat string. */
466 array_val
= value_ind (value_field (val
, array_fieldno
));
467 read_memory (value_address (array_val
), (gdb_byte
*) dest
, len
);
469 /* Add the NUL character to close the string. */
473 /* Get, from the debugging information, the type description of all types
474 related to the Ada Task Control Block that are needed in order to
475 read the list of known tasks in the Ada runtime. If all of the info
476 needed to do so is found, then save that info in the module's per-
477 program-space data, and return NULL. Otherwise, if any information
478 cannot be found, leave the per-program-space data untouched, and
479 return an error message explaining what was missing (that error
480 message does NOT need to be deallocated). */
483 ada_get_tcb_types_info (void)
486 struct type
*common_type
;
487 struct type
*ll_type
;
488 struct type
*call_type
;
489 struct atcb_fieldnos fieldnos
;
490 struct ada_tasks_pspace_data
*pspace_data
;
492 const char *atcb_name
= "system__tasking__ada_task_control_block___XVE";
493 const char *atcb_name_fixed
= "system__tasking__ada_task_control_block";
494 const char *common_atcb_name
= "system__tasking__common_atcb";
495 const char *private_data_name
= "system__task_primitives__private_data";
496 const char *entry_call_record_name
= "system__tasking__entry_call_record";
498 /* ATCB symbols may be found in several compilation units. As we
499 are only interested in one instance, use standard (literal,
500 C-like) lookups to get the first match. */
502 struct symbol
*atcb_sym
=
503 lookup_symbol_in_language (atcb_name
, NULL
, STRUCT_DOMAIN
,
504 language_c
, NULL
).symbol
;
505 const struct symbol
*common_atcb_sym
=
506 lookup_symbol_in_language (common_atcb_name
, NULL
, STRUCT_DOMAIN
,
507 language_c
, NULL
).symbol
;
508 const struct symbol
*private_data_sym
=
509 lookup_symbol_in_language (private_data_name
, NULL
, STRUCT_DOMAIN
,
510 language_c
, NULL
).symbol
;
511 const struct symbol
*entry_call_record_sym
=
512 lookup_symbol_in_language (entry_call_record_name
, NULL
, STRUCT_DOMAIN
,
513 language_c
, NULL
).symbol
;
515 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
517 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
518 size, so the symbol name differs. */
519 atcb_sym
= lookup_symbol_in_language (atcb_name_fixed
, NULL
,
520 STRUCT_DOMAIN
, language_c
,
523 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
524 return _("Cannot find Ada_Task_Control_Block type");
526 type
= atcb_sym
->type
;
530 /* Get a static representation of the type record
531 Ada_Task_Control_Block. */
532 type
= atcb_sym
->type
;
533 type
= ada_template_to_fixed_record_type_1 (type
, NULL
, 0, NULL
, 0);
536 if (common_atcb_sym
== NULL
|| common_atcb_sym
->type
== NULL
)
537 return _("Cannot find Common_ATCB type");
538 if (private_data_sym
== NULL
|| private_data_sym
->type
== NULL
)
539 return _("Cannot find Private_Data type");
540 if (entry_call_record_sym
== NULL
|| entry_call_record_sym
->type
== NULL
)
541 return _("Cannot find Entry_Call_Record type");
543 /* Get the type for Ada_Task_Control_Block.Common. */
544 common_type
= common_atcb_sym
->type
;
546 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
547 ll_type
= private_data_sym
->type
;
549 /* Get the type for Common_ATCB.Call.all. */
550 call_type
= entry_call_record_sym
->type
;
552 /* Get the field indices. */
553 fieldnos
.common
= ada_get_field_index (type
, "common", 0);
554 fieldnos
.entry_calls
= ada_get_field_index (type
, "entry_calls", 1);
555 fieldnos
.atc_nesting_level
=
556 ada_get_field_index (type
, "atc_nesting_level", 1);
557 fieldnos
.state
= ada_get_field_index (common_type
, "state", 0);
558 fieldnos
.parent
= ada_get_field_index (common_type
, "parent", 1);
559 fieldnos
.priority
= ada_get_field_index (common_type
, "base_priority", 0);
560 fieldnos
.image
= ada_get_field_index (common_type
, "task_image", 1);
561 fieldnos
.image_len
= ada_get_field_index (common_type
, "task_image_len", 1);
562 fieldnos
.activation_link
= ada_get_field_index (common_type
,
563 "activation_link", 1);
564 fieldnos
.call
= ada_get_field_index (common_type
, "call", 1);
565 fieldnos
.ll
= ada_get_field_index (common_type
, "ll", 0);
566 fieldnos
.base_cpu
= ada_get_field_index (common_type
, "base_cpu", 0);
567 fieldnos
.ll_thread
= ada_get_field_index (ll_type
, "thread", 0);
568 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "lwp", 1);
569 fieldnos
.call_self
= ada_get_field_index (call_type
, "self", 0);
571 /* On certain platforms such as x86-windows, the "lwp" field has been
572 named "thread_id". This field will likely be renamed in the future,
573 but we need to support both possibilities to avoid an unnecessary
574 dependency on a recent compiler. We therefore try locating the
575 "thread_id" field in place of the "lwp" field if we did not find
577 if (fieldnos
.ll_lwp
< 0)
578 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "thread_id", 1);
580 /* Set all the out parameters all at once, now that we are certain
581 that there are no potential error() anymore. */
582 pspace_data
= get_ada_tasks_pspace_data (current_program_space
);
583 pspace_data
->initialized_p
= 1;
584 pspace_data
->atcb_type
= type
;
585 pspace_data
->atcb_common_type
= common_type
;
586 pspace_data
->atcb_ll_type
= ll_type
;
587 pspace_data
->atcb_call_type
= call_type
;
588 pspace_data
->atcb_fieldno
= fieldnos
;
592 /* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
593 component of its ATCB record. This PTID needs to match the PTID used
594 by the thread layer. */
597 ptid_from_atcb_common (struct value
*common_value
)
601 struct value
*ll_value
;
603 const struct ada_tasks_pspace_data
*pspace_data
604 = get_ada_tasks_pspace_data (current_program_space
);
606 ll_value
= value_field (common_value
, pspace_data
->atcb_fieldno
.ll
);
608 if (pspace_data
->atcb_fieldno
.ll_lwp
>= 0)
609 lwp
= value_as_address (value_field (ll_value
,
610 pspace_data
->atcb_fieldno
.ll_lwp
));
611 thread
= value_as_long (value_field (ll_value
,
612 pspace_data
->atcb_fieldno
.ll_thread
));
614 ptid
= target_get_ada_task_ptid (lwp
, thread
);
619 /* Read the ATCB data of a given task given its TASK_ID (which is in practice
620 the address of its assocated ATCB record), and store the result inside
624 read_atcb (CORE_ADDR task_id
, struct ada_task_info
*task_info
)
626 struct value
*tcb_value
;
627 struct value
*common_value
;
628 struct value
*atc_nesting_level_value
;
629 struct value
*entry_calls_value
;
630 struct value
*entry_calls_value_element
;
631 int called_task_fieldno
= -1;
632 static const char ravenscar_task_name
[] = "Ravenscar task";
633 const struct ada_tasks_pspace_data
*pspace_data
634 = get_ada_tasks_pspace_data (current_program_space
);
636 /* Clear the whole structure to start with, so that everything
637 is always initialized the same. */
638 memset (task_info
, 0, sizeof (struct ada_task_info
));
640 if (!pspace_data
->initialized_p
)
642 const char *err_msg
= ada_get_tcb_types_info ();
645 error (_("%s. Aborting"), err_msg
);
648 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
650 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
652 /* Fill in the task_id. */
654 task_info
->task_id
= task_id
;
656 /* Compute the name of the task.
658 Depending on the GNAT version used, the task image is either a fat
659 string, or a thin array of characters. Older versions of GNAT used
660 to use fat strings, and therefore did not need an extra field in
661 the ATCB to store the string length. For efficiency reasons, newer
662 versions of GNAT replaced the fat string by a static buffer, but this
663 also required the addition of a new field named "Image_Len" containing
664 the length of the task name. The method used to extract the task name
665 is selected depending on the existence of this field.
667 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
668 we may want to get it from the first user frame of the stack. For now,
669 we just give a dummy name. */
671 if (pspace_data
->atcb_fieldno
.image_len
== -1)
673 if (pspace_data
->atcb_fieldno
.image
>= 0)
674 read_fat_string_value (task_info
->name
,
675 value_field (common_value
,
676 pspace_data
->atcb_fieldno
.image
),
677 sizeof (task_info
->name
) - 1);
680 struct bound_minimal_symbol msym
;
682 msym
= lookup_minimal_symbol_by_pc (task_id
);
685 const char *full_name
= MSYMBOL_LINKAGE_NAME (msym
.minsym
);
686 const char *task_name
= full_name
;
689 /* Strip the prefix. */
690 for (p
= full_name
; *p
; p
++)
691 if (p
[0] == '_' && p
[1] == '_')
694 /* Copy the task name. */
695 strncpy (task_info
->name
, task_name
, sizeof (task_info
->name
));
696 task_info
->name
[sizeof (task_info
->name
) - 1] = 0;
700 /* No symbol found. Use a default name. */
701 strcpy (task_info
->name
, ravenscar_task_name
);
707 int len
= value_as_long
708 (value_field (common_value
,
709 pspace_data
->atcb_fieldno
.image_len
));
711 value_as_string (task_info
->name
,
712 value_field (common_value
,
713 pspace_data
->atcb_fieldno
.image
),
717 /* Compute the task state and priority. */
720 value_as_long (value_field (common_value
,
721 pspace_data
->atcb_fieldno
.state
));
722 task_info
->priority
=
723 value_as_long (value_field (common_value
,
724 pspace_data
->atcb_fieldno
.priority
));
726 /* If the ATCB contains some information about the parent task,
727 then compute it as well. Otherwise, zero. */
729 if (pspace_data
->atcb_fieldno
.parent
>= 0)
731 value_as_address (value_field (common_value
,
732 pspace_data
->atcb_fieldno
.parent
));
734 /* If the task is in an entry call waiting for another task,
735 then determine which task it is. */
737 if (task_info
->state
== Entry_Caller_Sleep
738 && pspace_data
->atcb_fieldno
.atc_nesting_level
> 0
739 && pspace_data
->atcb_fieldno
.entry_calls
> 0)
741 /* Let My_ATCB be the Ada task control block of a task calling the
742 entry of another task; then the Task_Id of the called task is
743 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
744 atc_nesting_level_value
=
745 value_field (tcb_value
, pspace_data
->atcb_fieldno
.atc_nesting_level
);
747 ada_coerce_to_simple_array_ptr
748 (value_field (tcb_value
, pspace_data
->atcb_fieldno
.entry_calls
));
749 entry_calls_value_element
=
750 value_subscript (entry_calls_value
,
751 value_as_long (atc_nesting_level_value
));
752 called_task_fieldno
=
753 ada_get_field_index (value_type (entry_calls_value_element
),
755 task_info
->called_task
=
756 value_as_address (value_field (entry_calls_value_element
,
757 called_task_fieldno
));
760 /* If the ATCB cotnains some information about RV callers, then
761 compute the "caller_task". Otherwise, leave it as zero. */
763 if (pspace_data
->atcb_fieldno
.call
>= 0)
765 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
766 If Common_ATCB.Call is null, then there is no caller. */
767 const CORE_ADDR call
=
768 value_as_address (value_field (common_value
,
769 pspace_data
->atcb_fieldno
.call
));
770 struct value
*call_val
;
775 value_from_contents_and_address (pspace_data
->atcb_call_type
,
777 task_info
->caller_task
=
779 (value_field (call_val
, pspace_data
->atcb_fieldno
.call_self
));
784 = value_as_long (value_field (common_value
,
785 pspace_data
->atcb_fieldno
.base_cpu
));
787 /* And finally, compute the task ptid. Note that there is not point
788 in computing it if the task is no longer alive, in which case
789 it is good enough to set its ptid to the null_ptid. */
790 if (ada_task_is_alive (task_info
))
791 task_info
->ptid
= ptid_from_atcb_common (common_value
);
793 task_info
->ptid
= null_ptid
;
796 /* Read the ATCB info of the given task (identified by TASK_ID), and
797 add the result to the given inferior's TASK_LIST. */
800 add_ada_task (CORE_ADDR task_id
, struct inferior
*inf
)
802 struct ada_task_info task_info
;
803 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
805 read_atcb (task_id
, &task_info
);
806 data
->task_list
.push_back (task_info
);
809 /* Read the Known_Tasks array from the inferior memory, and store
810 it in the current inferior's TASK_LIST. Return true upon success. */
813 read_known_tasks_array (struct ada_tasks_inferior_data
*data
)
815 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
816 const int known_tasks_size
= target_ptr_byte
* data
->known_tasks_length
;
817 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (known_tasks_size
);
820 /* Build a new list by reading the ATCBs from the Known_Tasks array
821 in the Ada runtime. */
822 read_memory (data
->known_tasks_addr
, known_tasks
, known_tasks_size
);
823 for (i
= 0; i
< data
->known_tasks_length
; i
++)
826 extract_typed_address (known_tasks
+ i
* target_ptr_byte
,
827 data
->known_tasks_element
);
830 add_ada_task (task_id
, current_inferior ());
836 /* Read the known tasks from the inferior memory, and store it in
837 the current inferior's TASK_LIST. Return true upon success. */
840 read_known_tasks_list (struct ada_tasks_inferior_data
*data
)
842 const int target_ptr_byte
= TYPE_LENGTH (data
->known_tasks_element
);
843 gdb_byte
*known_tasks
= (gdb_byte
*) alloca (target_ptr_byte
);
845 const struct ada_tasks_pspace_data
*pspace_data
846 = get_ada_tasks_pspace_data (current_program_space
);
849 if (pspace_data
->atcb_fieldno
.activation_link
< 0)
852 /* Build a new list by reading the ATCBs. Read head of the list. */
853 read_memory (data
->known_tasks_addr
, known_tasks
, target_ptr_byte
);
854 task_id
= extract_typed_address (known_tasks
, data
->known_tasks_element
);
857 struct value
*tcb_value
;
858 struct value
*common_value
;
860 add_ada_task (task_id
, current_inferior ());
862 /* Read the chain. */
863 tcb_value
= value_from_contents_and_address (pspace_data
->atcb_type
,
865 common_value
= value_field (tcb_value
, pspace_data
->atcb_fieldno
.common
);
866 task_id
= value_as_address
867 (value_field (common_value
,
868 pspace_data
->atcb_fieldno
.activation_link
));
874 /* Set all fields of the current inferior ada-tasks data pointed by DATA.
875 Do nothing if those fields are already set and still up to date. */
878 ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data
*data
)
880 struct bound_minimal_symbol msym
;
883 /* Return now if already set. */
884 if (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
)
889 msym
= lookup_minimal_symbol (KNOWN_TASKS_NAME
, NULL
, NULL
);
890 if (msym
.minsym
!= NULL
)
892 data
->known_tasks_kind
= ADA_TASKS_ARRAY
;
893 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
895 /* Try to get pointer type and array length from the symtab. */
896 sym
= lookup_symbol_in_language (KNOWN_TASKS_NAME
, NULL
, VAR_DOMAIN
,
897 language_c
, NULL
).symbol
;
901 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
902 struct type
*eltype
= NULL
;
903 struct type
*idxtype
= NULL
;
905 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
906 eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
908 && TYPE_CODE (eltype
) == TYPE_CODE_PTR
)
909 idxtype
= check_typedef (TYPE_INDEX_TYPE (type
));
911 && !TYPE_LOW_BOUND_UNDEFINED (idxtype
)
912 && !TYPE_HIGH_BOUND_UNDEFINED (idxtype
))
914 data
->known_tasks_element
= eltype
;
915 data
->known_tasks_length
=
916 TYPE_HIGH_BOUND (idxtype
) - TYPE_LOW_BOUND (idxtype
) + 1;
921 /* Fallback to default values. The runtime may have been stripped (as
922 in some distributions), but it is likely that the executable still
923 contains debug information on the task type (due to implicit with of
925 data
->known_tasks_element
=
926 builtin_type (target_gdbarch ())->builtin_data_ptr
;
927 data
->known_tasks_length
= MAX_NUMBER_OF_KNOWN_TASKS
;
934 msym
= lookup_minimal_symbol (KNOWN_TASKS_LIST
, NULL
, NULL
);
935 if (msym
.minsym
!= NULL
)
937 data
->known_tasks_kind
= ADA_TASKS_LIST
;
938 data
->known_tasks_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
939 data
->known_tasks_length
= 1;
941 sym
= lookup_symbol_in_language (KNOWN_TASKS_LIST
, NULL
, VAR_DOMAIN
,
942 language_c
, NULL
).symbol
;
943 if (sym
!= NULL
&& SYMBOL_VALUE_ADDRESS (sym
) != 0)
946 struct type
*type
= check_typedef (SYMBOL_TYPE (sym
));
948 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
950 data
->known_tasks_element
= type
;
955 /* Fallback to default values. */
956 data
->known_tasks_element
=
957 builtin_type (target_gdbarch ())->builtin_data_ptr
;
958 data
->known_tasks_length
= 1;
962 /* Can't find tasks. */
964 data
->known_tasks_kind
= ADA_TASKS_NOT_FOUND
;
965 data
->known_tasks_addr
= 0;
968 /* Read the known tasks from the current inferior's memory, and store it
969 in the current inferior's data TASK_LIST. */
974 struct ada_tasks_inferior_data
*data
=
975 get_ada_tasks_inferior_data (current_inferior ());
977 /* Step 1: Clear the current list, if necessary. */
978 data
->task_list
.clear ();
980 /* Step 2: do the real work.
981 If the application does not use task, then no more needs to be done.
982 It is important to have the task list cleared (see above) before we
983 return, as we don't want a stale task list to be used... This can
984 happen for instance when debugging a non-multitasking program after
985 having debugged a multitasking one. */
986 ada_tasks_inferior_data_sniffer (data
);
987 gdb_assert (data
->known_tasks_kind
!= ADA_TASKS_UNKNOWN
);
989 /* Step 3: Set task_list_valid_p, to avoid re-reading the Known_Tasks
990 array unless needed. */
991 switch (data
->known_tasks_kind
)
993 case ADA_TASKS_NOT_FOUND
: /* Tasking not in use in inferior. */
995 case ADA_TASKS_ARRAY
:
996 data
->task_list_valid_p
= read_known_tasks_array (data
);
999 data
->task_list_valid_p
= read_known_tasks_list (data
);
1004 /* Build the task_list by reading the Known_Tasks array from
1005 the inferior, and return the number of tasks in that list
1006 (zero means that the program is not using tasking at all). */
1009 ada_build_task_list ()
1011 struct ada_tasks_inferior_data
*data
;
1013 if (!target_has_stack
)
1014 error (_("Cannot inspect Ada tasks when program is not running"));
1016 data
= get_ada_tasks_inferior_data (current_inferior ());
1017 if (!data
->task_list_valid_p
)
1018 read_known_tasks ();
1020 return data
->task_list
.size ();
1023 /* Print a table providing a short description of all Ada tasks
1024 running inside inferior INF. If ARG_STR is set, it will be
1025 interpreted as a task number, and the table will be limited to
1029 print_ada_task_info (struct ui_out
*uiout
,
1031 struct inferior
*inf
)
1033 struct ada_tasks_inferior_data
*data
;
1034 int taskno
, nb_tasks
;
1038 if (ada_build_task_list () == 0)
1040 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1044 if (arg_str
!= NULL
&& arg_str
[0] != '\0')
1045 taskno_arg
= value_as_long (parse_and_eval (arg_str
));
1047 if (uiout
->is_mi_like_p ())
1048 /* In GDB/MI mode, we want to provide the thread ID corresponding
1049 to each task. This allows clients to quickly find the thread
1050 associated to any task, which is helpful for commands that
1051 take a --thread argument. However, in order to be able to
1052 provide that thread ID, the thread list must be up to date
1054 target_update_thread_list ();
1056 data
= get_ada_tasks_inferior_data (inf
);
1058 /* Compute the number of tasks that are going to be displayed
1059 in the output. If an argument was given, there will be
1060 at most 1 entry. Otherwise, there will be as many entries
1061 as we have tasks. */
1064 if (taskno_arg
> 0 && taskno_arg
<= data
->task_list
.size ())
1070 nb_tasks
= data
->task_list
.size ();
1072 nb_columns
= uiout
->is_mi_like_p () ? 8 : 7;
1073 ui_out_emit_table
table_emitter (uiout
, nb_columns
, nb_tasks
, "tasks");
1074 uiout
->table_header (1, ui_left
, "current", "");
1075 uiout
->table_header (3, ui_right
, "id", "ID");
1076 uiout
->table_header (9, ui_right
, "task-id", "TID");
1077 /* The following column is provided in GDB/MI mode only because
1078 it is only really useful in that mode, and also because it
1079 allows us to keep the CLI output shorter and more compact. */
1080 if (uiout
->is_mi_like_p ())
1081 uiout
->table_header (4, ui_right
, "thread-id", "");
1082 uiout
->table_header (4, ui_right
, "parent-id", "P-ID");
1083 uiout
->table_header (3, ui_right
, "priority", "Pri");
1084 uiout
->table_header (22, ui_left
, "state", "State");
1085 /* Use ui_noalign for the last column, to prevent the CLI uiout
1086 from printing an extra space at the end of each row. This
1087 is a bit of a hack, but does get the job done. */
1088 uiout
->table_header (1, ui_noalign
, "name", "Name");
1089 uiout
->table_body ();
1091 for (taskno
= 1; taskno
<= data
->task_list
.size (); taskno
++)
1093 const struct ada_task_info
*const task_info
=
1094 &data
->task_list
[taskno
- 1];
1097 gdb_assert (task_info
!= NULL
);
1099 /* If the user asked for the output to be restricted
1100 to one task only, and this is not the task, skip
1102 if (taskno_arg
&& taskno
!= taskno_arg
)
1105 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1107 /* Print a star if this task is the current task (or the task
1108 currently selected). */
1109 if (task_info
->ptid
== inferior_ptid
)
1110 uiout
->field_string ("current", "*");
1112 uiout
->field_skip ("current");
1114 /* Print the task number. */
1115 uiout
->field_int ("id", taskno
);
1117 /* Print the Task ID. */
1118 uiout
->field_fmt ("task-id", "%9lx", (long) task_info
->task_id
);
1120 /* Print the associated Thread ID. */
1121 if (uiout
->is_mi_like_p ())
1123 thread_info
*thread
= find_thread_ptid (task_info
->ptid
);
1126 uiout
->field_int ("thread-id", thread
->global_num
);
1128 /* This should never happen unless there is a bug somewhere,
1129 but be resilient when that happens. */
1130 uiout
->field_skip ("thread-id");
1133 /* Print the ID of the parent task. */
1134 parent_id
= get_task_number_from_id (task_info
->parent
, inf
);
1136 uiout
->field_int ("parent-id", parent_id
);
1138 uiout
->field_skip ("parent-id");
1140 /* Print the base priority of the task. */
1141 uiout
->field_int ("priority", task_info
->priority
);
1143 /* Print the task current state. */
1144 if (task_info
->caller_task
)
1145 uiout
->field_fmt ("state",
1146 _("Accepting RV with %-4d"),
1147 get_task_number_from_id (task_info
->caller_task
,
1149 else if (task_info
->called_task
)
1150 uiout
->field_fmt ("state",
1151 _("Waiting on RV with %-3d"),
1152 get_task_number_from_id (task_info
->called_task
,
1155 uiout
->field_string ("state", task_states
[task_info
->state
]);
1157 /* Finally, print the task name. */
1158 uiout
->field_fmt ("name",
1160 task_info
->name
[0] != '\0' ? task_info
->name
1167 /* Print a detailed description of the Ada task whose ID is TASKNO_STR
1168 for the given inferior (INF). */
1171 info_task (struct ui_out
*uiout
, const char *taskno_str
, struct inferior
*inf
)
1173 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1174 struct ada_task_info
*task_info
;
1175 int parent_taskno
= 0;
1176 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1178 if (ada_build_task_list () == 0)
1180 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1184 if (taskno
<= 0 || taskno
> data
->task_list
.size ())
1185 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1186 "see the IDs of currently known tasks"), taskno
);
1187 task_info
= &data
->task_list
[taskno
- 1];
1189 /* Print the Ada task ID. */
1190 printf_filtered (_("Ada Task: %s\n"),
1191 paddress (target_gdbarch (), task_info
->task_id
));
1193 /* Print the name of the task. */
1194 if (task_info
->name
[0] != '\0')
1195 printf_filtered (_("Name: %s\n"), task_info
->name
);
1197 printf_filtered (_("<no name>\n"));
1199 /* Print the TID and LWP. */
1200 printf_filtered (_("Thread: %#lx\n"), task_info
->ptid
.tid ());
1201 printf_filtered (_("LWP: %#lx\n"), task_info
->ptid
.lwp ());
1203 /* If set, print the base CPU. */
1204 if (task_info
->base_cpu
!= 0)
1205 printf_filtered (_("Base CPU: %d\n"), task_info
->base_cpu
);
1207 /* Print who is the parent (if any). */
1208 if (task_info
->parent
!= 0)
1209 parent_taskno
= get_task_number_from_id (task_info
->parent
, inf
);
1212 struct ada_task_info
*parent
= &data
->task_list
[parent_taskno
- 1];
1214 printf_filtered (_("Parent: %d"), parent_taskno
);
1215 if (parent
->name
[0] != '\0')
1216 printf_filtered (" (%s)", parent
->name
);
1217 printf_filtered ("\n");
1220 printf_filtered (_("No parent\n"));
1222 /* Print the base priority. */
1223 printf_filtered (_("Base Priority: %d\n"), task_info
->priority
);
1225 /* print the task current state. */
1227 int target_taskno
= 0;
1229 if (task_info
->caller_task
)
1231 target_taskno
= get_task_number_from_id (task_info
->caller_task
, inf
);
1232 printf_filtered (_("State: Accepting rendezvous with %d"),
1235 else if (task_info
->called_task
)
1237 target_taskno
= get_task_number_from_id (task_info
->called_task
, inf
);
1238 printf_filtered (_("State: Waiting on task %d's entry"),
1242 printf_filtered (_("State: %s"), _(long_task_states
[task_info
->state
]));
1246 ada_task_info
*target_task_info
= &data
->task_list
[target_taskno
- 1];
1248 if (target_task_info
->name
[0] != '\0')
1249 printf_filtered (" (%s)", target_task_info
->name
);
1252 printf_filtered ("\n");
1256 /* If ARG is empty or null, then print a list of all Ada tasks.
1257 Otherwise, print detailed information about the task whose ID
1260 Does nothing if the program doesn't use Ada tasking. */
1263 info_tasks_command (const char *arg
, int from_tty
)
1265 struct ui_out
*uiout
= current_uiout
;
1267 if (arg
== NULL
|| *arg
== '\0')
1268 print_ada_task_info (uiout
, NULL
, current_inferior ());
1270 info_task (uiout
, arg
, current_inferior ());
1273 /* Print a message telling the user id of the current task.
1274 This function assumes that tasking is in use in the inferior. */
1277 display_current_task_id (void)
1279 const int current_task
= ada_get_task_number (inferior_thread ());
1281 if (current_task
== 0)
1282 printf_filtered (_("[Current task is unknown]\n"));
1284 printf_filtered (_("[Current task is %d]\n"), current_task
);
1287 /* Parse and evaluate TIDSTR into a task id, and try to switch to
1288 that task. Print an error message if the task switch failed. */
1291 task_command_1 (const char *taskno_str
, int from_tty
, struct inferior
*inf
)
1293 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
1294 struct ada_task_info
*task_info
;
1295 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1297 if (taskno
<= 0 || taskno
> data
->task_list
.size ())
1298 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1299 "see the IDs of currently known tasks"), taskno
);
1300 task_info
= &data
->task_list
[taskno
- 1];
1302 if (!ada_task_is_alive (task_info
))
1303 error (_("Cannot switch to task %d: Task is no longer running"), taskno
);
1305 /* On some platforms, the thread list is not updated until the user
1306 performs a thread-related operation (by using the "info threads"
1307 command, for instance). So this thread list may not be up to date
1308 when the user attempts this task switch. Since we cannot switch
1309 to the thread associated to our task if GDB does not know about
1310 that thread, we need to make sure that any new threads gets added
1311 to the thread list. */
1312 target_update_thread_list ();
1314 /* Verify that the ptid of the task we want to switch to is valid
1315 (in other words, a ptid that GDB knows about). Otherwise, we will
1316 cause an assertion failure later on, when we try to determine
1317 the ptid associated thread_info data. We should normally never
1318 encounter such an error, but the wrong ptid can actually easily be
1319 computed if target_get_ada_task_ptid has not been implemented for
1320 our target (yet). Rather than cause an assertion error in that case,
1321 it's nicer for the user to just refuse to perform the task switch. */
1322 thread_info
*tp
= find_thread_ptid (task_info
->ptid
);
1324 error (_("Unable to compute thread ID for task %d.\n"
1325 "Cannot switch to this task."),
1328 switch_to_thread (tp
);
1329 ada_find_printable_frame (get_selected_frame (NULL
));
1330 printf_filtered (_("[Switching to task %d]\n"), taskno
);
1331 print_stack_frame (get_selected_frame (NULL
),
1332 frame_relative_level (get_selected_frame (NULL
)),
1337 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
1338 Otherwise, switch to the task indicated by TASKNO_STR. */
1341 task_command (const char *taskno_str
, int from_tty
)
1343 struct ui_out
*uiout
= current_uiout
;
1345 if (ada_build_task_list () == 0)
1347 uiout
->message (_("Your application does not use any Ada tasks.\n"));
1351 if (taskno_str
== NULL
|| taskno_str
[0] == '\0')
1352 display_current_task_id ();
1354 task_command_1 (taskno_str
, from_tty
, current_inferior ());
1357 /* Indicate that the given inferior's task list may have changed,
1358 so invalidate the cache. */
1361 ada_task_list_changed (struct inferior
*inf
)
1363 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1365 data
->task_list_valid_p
= false;
1368 /* Invalidate the per-program-space data. */
1371 ada_tasks_invalidate_pspace_data (struct program_space
*pspace
)
1373 get_ada_tasks_pspace_data (pspace
)->initialized_p
= 0;
1376 /* Invalidate the per-inferior data. */
1379 ada_tasks_invalidate_inferior_data (struct inferior
*inf
)
1381 struct ada_tasks_inferior_data
*data
= get_ada_tasks_inferior_data (inf
);
1383 data
->known_tasks_kind
= ADA_TASKS_UNKNOWN
;
1384 data
->task_list_valid_p
= false;
1387 /* The 'normal_stop' observer notification callback. */
1390 ada_tasks_normal_stop_observer (struct bpstats
*unused_args
, int unused_args2
)
1392 /* The inferior has been resumed, and just stopped. This means that
1393 our task_list needs to be recomputed before it can be used again. */
1394 ada_task_list_changed (current_inferior ());
1397 /* A routine to be called when the objfiles have changed. */
1400 ada_tasks_new_objfile_observer (struct objfile
*objfile
)
1402 struct inferior
*inf
;
1404 /* Invalidate the relevant data in our program-space data. */
1406 if (objfile
== NULL
)
1408 /* All objfiles are being cleared, so we should clear all
1409 our caches for all program spaces. */
1410 struct program_space
*pspace
;
1412 for (pspace
= program_spaces
; pspace
!= NULL
; pspace
= pspace
->next
)
1413 ada_tasks_invalidate_pspace_data (pspace
);
1417 /* The associated program-space data might have changed after
1418 this objfile was added. Invalidate all cached data. */
1419 ada_tasks_invalidate_pspace_data (objfile
->pspace
);
1422 /* Invalidate the per-inferior cache for all inferiors using
1423 this objfile (or, in other words, for all inferiors who have
1424 the same program-space as the objfile's program space).
1425 If all objfiles are being cleared (OBJFILE is NULL), then
1426 clear the caches for all inferiors. */
1428 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
1429 if (objfile
== NULL
|| inf
->pspace
== objfile
->pspace
)
1430 ada_tasks_invalidate_inferior_data (inf
);
1434 _initialize_tasks (void)
1436 ada_tasks_pspace_data_handle
1437 = register_program_space_data_with_cleanup (NULL
,
1438 ada_tasks_pspace_data_cleanup
);
1439 ada_tasks_inferior_data_handle
1440 = register_inferior_data_with_cleanup (NULL
,
1441 ada_tasks_inferior_data_cleanup
);
1443 /* Attach various observers. */
1444 gdb::observers::normal_stop
.attach (ada_tasks_normal_stop_observer
);
1445 gdb::observers::new_objfile
.attach (ada_tasks_new_objfile_observer
);
1447 /* Some new commands provided by this module. */
1448 add_info ("tasks", info_tasks_command
,
1449 _("Provide information about all known Ada tasks"));
1450 add_cmd ("task", class_run
, task_command
,
1451 _("Use this command to switch between Ada tasks.\n\
1452 Without argument, this command simply prints the current task ID"),