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. */
127 /* Fields in Task_Primitives.Private_Data. */
129 int ll_lwp; /* This field may be missing. */
131 /* Fields in Common_ATCB.Call.all. */
135 /* This module's per-program-space data. */
137 struct ada_tasks_pspace_data
139 /* Nonzero if the data has been initialized. If set to zero,
140 it means that the data has either not been initialized, or
141 has potentially become stale. */
144 /* The ATCB record type. */
145 struct type *atcb_type;
147 /* The ATCB "Common" component type. */
148 struct type *atcb_common_type;
150 /* The type of the "ll" field, from the atcb_common_type. */
151 struct type *atcb_ll_type;
153 /* The type of the "call" field, from the atcb_common_type. */
154 struct type *atcb_call_type;
156 /* The index of various fields in the ATCB record and sub-records. */
157 struct atcb_fieldnos atcb_fieldno;
160 /* Key to our per-program-space data. */
161 static const struct program_space_data *ada_tasks_pspace_data_handle;
163 typedef struct ada_task_info ada_task_info_s;
164 DEF_VEC_O(ada_task_info_s);
166 /* The kind of data structure used by the runtime to store the list
169 enum ada_known_tasks_kind
171 /* Use this value when we haven't determined which kind of structure
172 is being used, or when we need to recompute it.
174 We set the value of this enumerate to zero on purpose: This allows
175 us to use this enumerate in a structure where setting all fields
176 to zero will result in this kind being set to unknown. */
177 ADA_TASKS_UNKNOWN = 0,
179 /* This value means that we did not find any task list. Unless
180 there is a bug somewhere, this means that the inferior does not
184 /* This value means that the task list is stored as an array.
185 This is the usual method, as it causes very little overhead.
186 But this method is not always used, as it does use a certain
187 amount of memory, which might be scarse in certain environments. */
190 /* This value means that the task list is stored as a linked list.
191 This has more runtime overhead than the array approach, but
192 also require less memory when the number of tasks is small. */
196 /* This module's per-inferior data. */
198 struct ada_tasks_inferior_data
200 /* The type of data structure used by the runtime to store
201 the list of Ada tasks. The value of this field influences
202 the interpretation of the known_tasks_addr field below:
203 - ADA_TASKS_UNKNOWN: The value of known_tasks_addr hasn't
205 - ADA_TASKS_NOT_FOUND: The program probably does not use tasking
206 and the known_tasks_addr is irrelevant;
207 - ADA_TASKS_ARRAY: The known_tasks is an array;
208 - ADA_TASKS_LIST: The known_tasks is a list. */
209 enum ada_known_tasks_kind known_tasks_kind;
211 /* The address of the known_tasks structure. This is where
212 the runtime stores the information for all Ada tasks.
213 The interpretation of this field depends on KNOWN_TASKS_KIND
215 CORE_ADDR known_tasks_addr;
217 /* Type of elements of the known task. Usually a pointer. */
218 struct type *known_tasks_element;
220 /* Number of elements in the known tasks array. */
221 unsigned int known_tasks_length;
223 /* When nonzero, this flag indicates that the task_list field
224 below is up to date. When set to zero, the list has either
225 not been initialized, or has potentially become stale. */
226 int task_list_valid_p;
228 /* The list of Ada tasks.
230 Note: To each task we associate a number that the user can use to
231 reference it - this number is printed beside each task in the tasks
232 info listing displayed by "info tasks". This number is equal to
233 its index in the vector + 1. Reciprocally, to compute the index
234 of a task in the vector, we need to substract 1 from its number. */
235 VEC(ada_task_info_s) *task_list;
238 /* Key to our per-inferior data. */
239 static const struct inferior_data *ada_tasks_inferior_data_handle;
241 /* Return the ada-tasks module's data for the given program space (PSPACE).
242 If none is found, add a zero'ed one now.
244 This function always returns a valid object. */
246 static struct ada_tasks_pspace_data *
247 get_ada_tasks_pspace_data (struct program_space *pspace)
249 struct ada_tasks_pspace_data *data;
251 data = ((struct ada_tasks_pspace_data *)
252 program_space_data (pspace, ada_tasks_pspace_data_handle));
255 data = XCNEW (struct ada_tasks_pspace_data);
256 set_program_space_data (pspace, ada_tasks_pspace_data_handle, data);
262 /* Return the ada-tasks module's data for the given inferior (INF).
263 If none is found, add a zero'ed one now.
265 This function always returns a valid object.
267 Note that we could use an observer of the inferior-created event
268 to make sure that the ada-tasks per-inferior data always exists.
269 But we prefered this approach, as it avoids this entirely as long
270 as the user does not use any of the tasking features. This is
271 quite possible, particularly in the case where the inferior does
274 static struct ada_tasks_inferior_data *
275 get_ada_tasks_inferior_data (struct inferior *inf)
277 struct ada_tasks_inferior_data *data;
279 data = ((struct ada_tasks_inferior_data *)
280 inferior_data (inf, ada_tasks_inferior_data_handle));
283 data = XCNEW (struct ada_tasks_inferior_data);
284 set_inferior_data (inf, ada_tasks_inferior_data_handle, data);
290 /* Return the task number of the task whose ptid is PTID, or zero
291 if the task could not be found. */
294 ada_get_task_number (ptid_t ptid)
297 struct inferior *inf = find_inferior_ptid (ptid);
298 struct ada_tasks_inferior_data *data;
300 gdb_assert (inf != NULL);
301 data = get_ada_tasks_inferior_data (inf);
303 for (i = 0; i < VEC_length (ada_task_info_s, data->task_list); i++)
304 if (ptid_equal (VEC_index (ada_task_info_s, data->task_list, i)->ptid,
308 return 0; /* No matching task found. */
311 /* Return the task number of the task running in inferior INF which
312 matches TASK_ID , or zero if the task could not be found. */
315 get_task_number_from_id (CORE_ADDR task_id, struct inferior *inf)
317 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
320 for (i = 0; i < VEC_length (ada_task_info_s, data->task_list); i++)
322 struct ada_task_info *task_info =
323 VEC_index (ada_task_info_s, data->task_list, i);
325 if (task_info->task_id == task_id)
329 /* Task not found. Return 0. */
333 /* Return non-zero if TASK_NUM is a valid task number. */
336 valid_task_id (int task_num)
338 struct ada_tasks_inferior_data *data;
340 ada_build_task_list ();
341 data = get_ada_tasks_inferior_data (current_inferior ());
343 && task_num <= VEC_length (ada_task_info_s, data->task_list));
346 /* Return non-zero iff the task STATE corresponds to a non-terminated
350 ada_task_is_alive (struct ada_task_info *task_info)
352 return (task_info->state != Terminated);
355 /* Call the ITERATOR function once for each Ada task that hasn't been
359 iterate_over_live_ada_tasks (ada_task_list_iterator_ftype *iterator)
362 struct ada_task_info *task;
363 struct ada_tasks_inferior_data *data;
365 ada_build_task_list ();
366 data = get_ada_tasks_inferior_data (current_inferior ());
367 nb_tasks = VEC_length (ada_task_info_s, data->task_list);
369 for (i = 0; i < nb_tasks; i++)
371 task = VEC_index (ada_task_info_s, data->task_list, i);
372 if (!ada_task_is_alive (task))
378 /* Extract the contents of the value as a string whose length is LENGTH,
379 and store the result in DEST. */
382 value_as_string (char *dest, struct value *val, int length)
384 memcpy (dest, value_contents (val), length);
388 /* Extract the string image from the fat string corresponding to VAL,
389 and store it in DEST. If the string length is greater than MAX_LEN,
390 then truncate the result to the first MAX_LEN characters of the fat
394 read_fat_string_value (char *dest, struct value *val, int max_len)
396 struct value *array_val;
397 struct value *bounds_val;
400 /* The following variables are made static to avoid recomputing them
401 each time this function is called. */
402 static int initialize_fieldnos = 1;
403 static int array_fieldno;
404 static int bounds_fieldno;
405 static int upper_bound_fieldno;
407 /* Get the index of the fields that we will need to read in order
408 to extract the string from the fat string. */
409 if (initialize_fieldnos)
411 struct type *type = value_type (val);
412 struct type *bounds_type;
414 array_fieldno = ada_get_field_index (type, "P_ARRAY", 0);
415 bounds_fieldno = ada_get_field_index (type, "P_BOUNDS", 0);
417 bounds_type = TYPE_FIELD_TYPE (type, bounds_fieldno);
418 if (TYPE_CODE (bounds_type) == TYPE_CODE_PTR)
419 bounds_type = TYPE_TARGET_TYPE (bounds_type);
420 if (TYPE_CODE (bounds_type) != TYPE_CODE_STRUCT)
421 error (_("Unknown task name format. Aborting"));
422 upper_bound_fieldno = ada_get_field_index (bounds_type, "UB0", 0);
424 initialize_fieldnos = 0;
427 /* Get the size of the task image by checking the value of the bounds.
428 The lower bound is always 1, so we only need to read the upper bound. */
429 bounds_val = value_ind (value_field (val, bounds_fieldno));
430 len = value_as_long (value_field (bounds_val, upper_bound_fieldno));
432 /* Make sure that we do not read more than max_len characters... */
436 /* Extract LEN characters from the fat string. */
437 array_val = value_ind (value_field (val, array_fieldno));
438 read_memory (value_address (array_val), (gdb_byte *) dest, len);
440 /* Add the NUL character to close the string. */
444 /* Get from the debugging information the type description of all types
445 related to the Ada Task Control Block that will be needed in order to
446 read the list of known tasks in the Ada runtime. Also return the
447 associated ATCB_FIELDNOS.
449 Error handling: Any data missing from the debugging info will cause
450 an error to be raised, and none of the return values to be set.
451 Users of this function can depend on the fact that all or none of the
452 return values will be set. */
455 get_tcb_types_info (void)
458 struct type *common_type;
459 struct type *ll_type;
460 struct type *call_type;
461 struct atcb_fieldnos fieldnos;
462 struct ada_tasks_pspace_data *pspace_data;
464 const char *atcb_name = "system__tasking__ada_task_control_block___XVE";
465 const char *atcb_name_fixed = "system__tasking__ada_task_control_block";
466 const char *common_atcb_name = "system__tasking__common_atcb";
467 const char *private_data_name = "system__task_primitives__private_data";
468 const char *entry_call_record_name = "system__tasking__entry_call_record";
470 /* ATCB symbols may be found in several compilation units. As we
471 are only interested in one instance, use standard (literal,
472 C-like) lookups to get the first match. */
474 struct symbol *atcb_sym =
475 lookup_symbol_in_language (atcb_name, NULL, STRUCT_DOMAIN,
476 language_c, NULL).symbol;
477 const struct symbol *common_atcb_sym =
478 lookup_symbol_in_language (common_atcb_name, NULL, STRUCT_DOMAIN,
479 language_c, NULL).symbol;
480 const struct symbol *private_data_sym =
481 lookup_symbol_in_language (private_data_name, NULL, STRUCT_DOMAIN,
482 language_c, NULL).symbol;
483 const struct symbol *entry_call_record_sym =
484 lookup_symbol_in_language (entry_call_record_name, NULL, STRUCT_DOMAIN,
485 language_c, NULL).symbol;
487 if (atcb_sym == NULL || atcb_sym->type == NULL)
489 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
490 size, so the symbol name differs. */
491 atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL,
492 STRUCT_DOMAIN, language_c,
495 if (atcb_sym == NULL || atcb_sym->type == NULL)
496 error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
498 type = atcb_sym->type;
502 /* Get a static representation of the type record
503 Ada_Task_Control_Block. */
504 type = atcb_sym->type;
505 type = ada_template_to_fixed_record_type_1 (type, NULL, 0, NULL, 0);
508 if (common_atcb_sym == NULL || common_atcb_sym->type == NULL)
509 error (_("Cannot find Common_ATCB type. Aborting"));
510 if (private_data_sym == NULL || private_data_sym->type == NULL)
511 error (_("Cannot find Private_Data type. Aborting"));
512 if (entry_call_record_sym == NULL || entry_call_record_sym->type == NULL)
513 error (_("Cannot find Entry_Call_Record type. Aborting"));
515 /* Get the type for Ada_Task_Control_Block.Common. */
516 common_type = common_atcb_sym->type;
518 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
519 ll_type = private_data_sym->type;
521 /* Get the type for Common_ATCB.Call.all. */
522 call_type = entry_call_record_sym->type;
524 /* Get the field indices. */
525 fieldnos.common = ada_get_field_index (type, "common", 0);
526 fieldnos.entry_calls = ada_get_field_index (type, "entry_calls", 1);
527 fieldnos.atc_nesting_level =
528 ada_get_field_index (type, "atc_nesting_level", 1);
529 fieldnos.state = ada_get_field_index (common_type, "state", 0);
530 fieldnos.parent = ada_get_field_index (common_type, "parent", 1);
531 fieldnos.priority = ada_get_field_index (common_type, "base_priority", 0);
532 fieldnos.image = ada_get_field_index (common_type, "task_image", 1);
533 fieldnos.image_len = ada_get_field_index (common_type, "task_image_len", 1);
534 fieldnos.activation_link = ada_get_field_index (common_type,
535 "activation_link", 1);
536 fieldnos.call = ada_get_field_index (common_type, "call", 1);
537 fieldnos.ll = ada_get_field_index (common_type, "ll", 0);
538 fieldnos.ll_thread = ada_get_field_index (ll_type, "thread", 0);
539 fieldnos.ll_lwp = ada_get_field_index (ll_type, "lwp", 1);
540 fieldnos.call_self = ada_get_field_index (call_type, "self", 0);
542 /* On certain platforms such as x86-windows, the "lwp" field has been
543 named "thread_id". This field will likely be renamed in the future,
544 but we need to support both possibilities to avoid an unnecessary
545 dependency on a recent compiler. We therefore try locating the
546 "thread_id" field in place of the "lwp" field if we did not find
548 if (fieldnos.ll_lwp < 0)
549 fieldnos.ll_lwp = ada_get_field_index (ll_type, "thread_id", 1);
551 /* Set all the out parameters all at once, now that we are certain
552 that there are no potential error() anymore. */
553 pspace_data = get_ada_tasks_pspace_data (current_program_space);
554 pspace_data->initialized_p = 1;
555 pspace_data->atcb_type = type;
556 pspace_data->atcb_common_type = common_type;
557 pspace_data->atcb_ll_type = ll_type;
558 pspace_data->atcb_call_type = call_type;
559 pspace_data->atcb_fieldno = fieldnos;
562 /* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
563 component of its ATCB record. This PTID needs to match the PTID used
564 by the thread layer. */
567 ptid_from_atcb_common (struct value *common_value)
571 struct value *ll_value;
573 const struct ada_tasks_pspace_data *pspace_data
574 = get_ada_tasks_pspace_data (current_program_space);
576 ll_value = value_field (common_value, pspace_data->atcb_fieldno.ll);
578 if (pspace_data->atcb_fieldno.ll_lwp >= 0)
579 lwp = value_as_address (value_field (ll_value,
580 pspace_data->atcb_fieldno.ll_lwp));
581 thread = value_as_long (value_field (ll_value,
582 pspace_data->atcb_fieldno.ll_thread));
584 ptid = target_get_ada_task_ptid (lwp, thread);
589 /* Read the ATCB data of a given task given its TASK_ID (which is in practice
590 the address of its assocated ATCB record), and store the result inside
594 read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
596 struct value *tcb_value;
597 struct value *common_value;
598 struct value *atc_nesting_level_value;
599 struct value *entry_calls_value;
600 struct value *entry_calls_value_element;
601 int called_task_fieldno = -1;
602 static const char ravenscar_task_name[] = "Ravenscar task";
603 const struct ada_tasks_pspace_data *pspace_data
604 = get_ada_tasks_pspace_data (current_program_space);
606 if (!pspace_data->initialized_p)
607 get_tcb_types_info ();
609 tcb_value = value_from_contents_and_address (pspace_data->atcb_type,
611 common_value = value_field (tcb_value, pspace_data->atcb_fieldno.common);
613 /* Fill in the task_id. */
615 task_info->task_id = task_id;
617 /* Compute the name of the task.
619 Depending on the GNAT version used, the task image is either a fat
620 string, or a thin array of characters. Older versions of GNAT used
621 to use fat strings, and therefore did not need an extra field in
622 the ATCB to store the string length. For efficiency reasons, newer
623 versions of GNAT replaced the fat string by a static buffer, but this
624 also required the addition of a new field named "Image_Len" containing
625 the length of the task name. The method used to extract the task name
626 is selected depending on the existence of this field.
628 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
629 we may want to get it from the first user frame of the stack. For now,
630 we just give a dummy name. */
632 if (pspace_data->atcb_fieldno.image_len == -1)
634 if (pspace_data->atcb_fieldno.image >= 0)
635 read_fat_string_value (task_info->name,
636 value_field (common_value,
637 pspace_data->atcb_fieldno.image),
638 sizeof (task_info->name) - 1);
641 struct bound_minimal_symbol msym;
643 msym = lookup_minimal_symbol_by_pc (task_id);
646 const char *full_name = MSYMBOL_LINKAGE_NAME (msym.minsym);
647 const char *task_name = full_name;
650 /* Strip the prefix. */
651 for (p = full_name; *p; p++)
652 if (p[0] == '_' && p[1] == '_')
655 /* Copy the task name. */
656 strncpy (task_info->name, task_name, sizeof (task_info->name));
657 task_info->name[sizeof (task_info->name) - 1] = 0;
661 /* No symbol found. Use a default name. */
662 strcpy (task_info->name, ravenscar_task_name);
668 int len = value_as_long
669 (value_field (common_value,
670 pspace_data->atcb_fieldno.image_len));
672 value_as_string (task_info->name,
673 value_field (common_value,
674 pspace_data->atcb_fieldno.image),
678 /* Compute the task state and priority. */
681 value_as_long (value_field (common_value,
682 pspace_data->atcb_fieldno.state));
683 task_info->priority =
684 value_as_long (value_field (common_value,
685 pspace_data->atcb_fieldno.priority));
687 /* If the ATCB contains some information about the parent task,
688 then compute it as well. Otherwise, zero. */
690 if (pspace_data->atcb_fieldno.parent >= 0)
692 value_as_address (value_field (common_value,
693 pspace_data->atcb_fieldno.parent));
695 task_info->parent = 0;
698 /* If the ATCB contains some information about entry calls, then
699 compute the "called_task" as well. Otherwise, zero. */
701 if (pspace_data->atcb_fieldno.atc_nesting_level > 0
702 && pspace_data->atcb_fieldno.entry_calls > 0)
704 /* Let My_ATCB be the Ada task control block of a task calling the
705 entry of another task; then the Task_Id of the called task is
706 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
707 atc_nesting_level_value =
708 value_field (tcb_value, pspace_data->atcb_fieldno.atc_nesting_level);
710 ada_coerce_to_simple_array_ptr
711 (value_field (tcb_value, pspace_data->atcb_fieldno.entry_calls));
712 entry_calls_value_element =
713 value_subscript (entry_calls_value,
714 value_as_long (atc_nesting_level_value));
715 called_task_fieldno =
716 ada_get_field_index (value_type (entry_calls_value_element),
718 task_info->called_task =
719 value_as_address (value_field (entry_calls_value_element,
720 called_task_fieldno));
724 task_info->called_task = 0;
727 /* If the ATCB cotnains some information about RV callers,
728 then compute the "caller_task". Otherwise, zero. */
730 task_info->caller_task = 0;
731 if (pspace_data->atcb_fieldno.call >= 0)
733 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
734 If Common_ATCB.Call is null, then there is no caller. */
735 const CORE_ADDR call =
736 value_as_address (value_field (common_value,
737 pspace_data->atcb_fieldno.call));
738 struct value *call_val;
743 value_from_contents_and_address (pspace_data->atcb_call_type,
745 task_info->caller_task =
747 (value_field (call_val, pspace_data->atcb_fieldno.call_self));
751 /* And finally, compute the task ptid. Note that there are situations
752 where this cannot be determined:
753 - The task is no longer alive - the ptid is irrelevant;
754 - We are debugging a core file - the thread is not always
755 completely preserved for us to link back a task to its
756 underlying thread. Since we do not support task switching
757 when debugging core files anyway, we don't need to compute
759 In either case, we don't need that ptid, and it is just good enough
760 to set it to null_ptid. */
762 if (target_has_execution && ada_task_is_alive (task_info))
763 task_info->ptid = ptid_from_atcb_common (common_value);
765 task_info->ptid = null_ptid;
768 /* Read the ATCB info of the given task (identified by TASK_ID), and
769 add the result to the given inferior's TASK_LIST. */
772 add_ada_task (CORE_ADDR task_id, struct inferior *inf)
774 struct ada_task_info task_info;
775 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
777 read_atcb (task_id, &task_info);
778 VEC_safe_push (ada_task_info_s, data->task_list, &task_info);
781 /* Read the Known_Tasks array from the inferior memory, and store
782 it in the current inferior's TASK_LIST. Return non-zero upon success. */
785 read_known_tasks_array (struct ada_tasks_inferior_data *data)
787 const int target_ptr_byte = TYPE_LENGTH (data->known_tasks_element);
788 const int known_tasks_size = target_ptr_byte * data->known_tasks_length;
789 gdb_byte *known_tasks = (gdb_byte *) alloca (known_tasks_size);
792 /* Build a new list by reading the ATCBs from the Known_Tasks array
793 in the Ada runtime. */
794 read_memory (data->known_tasks_addr, known_tasks, known_tasks_size);
795 for (i = 0; i < data->known_tasks_length; i++)
798 extract_typed_address (known_tasks + i * target_ptr_byte,
799 data->known_tasks_element);
802 add_ada_task (task_id, current_inferior ());
808 /* Read the known tasks from the inferior memory, and store it in
809 the current inferior's TASK_LIST. Return non-zero upon success. */
812 read_known_tasks_list (struct ada_tasks_inferior_data *data)
814 const int target_ptr_byte = TYPE_LENGTH (data->known_tasks_element);
815 gdb_byte *known_tasks = (gdb_byte *) alloca (target_ptr_byte);
817 const struct ada_tasks_pspace_data *pspace_data
818 = get_ada_tasks_pspace_data (current_program_space);
821 if (pspace_data->atcb_fieldno.activation_link < 0)
824 /* Build a new list by reading the ATCBs. Read head of the list. */
825 read_memory (data->known_tasks_addr, known_tasks, target_ptr_byte);
826 task_id = extract_typed_address (known_tasks, data->known_tasks_element);
829 struct value *tcb_value;
830 struct value *common_value;
832 add_ada_task (task_id, current_inferior ());
834 /* Read the chain. */
835 tcb_value = value_from_contents_and_address (pspace_data->atcb_type,
837 common_value = value_field (tcb_value, pspace_data->atcb_fieldno.common);
838 task_id = value_as_address
839 (value_field (common_value,
840 pspace_data->atcb_fieldno.activation_link));
846 /* Set all fields of the current inferior ada-tasks data pointed by DATA.
847 Do nothing if those fields are already set and still up to date. */
850 ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
852 struct bound_minimal_symbol msym;
855 /* Return now if already set. */
856 if (data->known_tasks_kind != ADA_TASKS_UNKNOWN)
861 msym = lookup_minimal_symbol (KNOWN_TASKS_NAME, NULL, NULL);
862 if (msym.minsym != NULL)
864 data->known_tasks_kind = ADA_TASKS_ARRAY;
865 data->known_tasks_addr = BMSYMBOL_VALUE_ADDRESS (msym);
867 /* Try to get pointer type and array length from the symtab. */
868 sym = lookup_symbol_in_language (KNOWN_TASKS_NAME, NULL, VAR_DOMAIN,
869 language_c, NULL).symbol;
873 struct type *type = check_typedef (SYMBOL_TYPE (sym));
874 struct type *eltype = NULL;
875 struct type *idxtype = NULL;
877 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
878 eltype = check_typedef (TYPE_TARGET_TYPE (type));
880 && TYPE_CODE (eltype) == TYPE_CODE_PTR)
881 idxtype = check_typedef (TYPE_INDEX_TYPE (type));
883 && !TYPE_LOW_BOUND_UNDEFINED (idxtype)
884 && !TYPE_HIGH_BOUND_UNDEFINED (idxtype))
886 data->known_tasks_element = eltype;
887 data->known_tasks_length =
888 TYPE_HIGH_BOUND (idxtype) - TYPE_LOW_BOUND (idxtype) + 1;
893 /* Fallback to default values. The runtime may have been stripped (as
894 in some distributions), but it is likely that the executable still
895 contains debug information on the task type (due to implicit with of
897 data->known_tasks_element =
898 builtin_type (target_gdbarch ())->builtin_data_ptr;
899 data->known_tasks_length = MAX_NUMBER_OF_KNOWN_TASKS;
906 msym = lookup_minimal_symbol (KNOWN_TASKS_LIST, NULL, NULL);
907 if (msym.minsym != NULL)
909 data->known_tasks_kind = ADA_TASKS_LIST;
910 data->known_tasks_addr = BMSYMBOL_VALUE_ADDRESS (msym);
911 data->known_tasks_length = 1;
913 sym = lookup_symbol_in_language (KNOWN_TASKS_LIST, NULL, VAR_DOMAIN,
914 language_c, NULL).symbol;
915 if (sym != NULL && SYMBOL_VALUE_ADDRESS (sym) != 0)
918 struct type *type = check_typedef (SYMBOL_TYPE (sym));
920 if (TYPE_CODE (type) == TYPE_CODE_PTR)
922 data->known_tasks_element = type;
927 /* Fallback to default values. */
928 data->known_tasks_element =
929 builtin_type (target_gdbarch ())->builtin_data_ptr;
930 data->known_tasks_length = 1;
934 /* Can't find tasks. */
936 data->known_tasks_kind = ADA_TASKS_NOT_FOUND;
937 data->known_tasks_addr = 0;
940 /* Read the known tasks from the current inferior's memory, and store it
941 in the current inferior's data TASK_LIST.
942 Return non-zero upon success. */
945 read_known_tasks (void)
947 struct ada_tasks_inferior_data *data =
948 get_ada_tasks_inferior_data (current_inferior ());
950 /* Step 1: Clear the current list, if necessary. */
951 VEC_truncate (ada_task_info_s, data->task_list, 0);
953 /* Step 2: do the real work.
954 If the application does not use task, then no more needs to be done.
955 It is important to have the task list cleared (see above) before we
956 return, as we don't want a stale task list to be used... This can
957 happen for instance when debugging a non-multitasking program after
958 having debugged a multitasking one. */
959 ada_tasks_inferior_data_sniffer (data);
960 gdb_assert (data->known_tasks_kind != ADA_TASKS_UNKNOWN);
962 switch (data->known_tasks_kind)
964 case ADA_TASKS_NOT_FOUND: /* Tasking not in use in inferior. */
966 case ADA_TASKS_ARRAY:
967 return read_known_tasks_array (data);
969 return read_known_tasks_list (data);
972 /* Step 3: Set task_list_valid_p, to avoid re-reading the Known_Tasks
973 array unless needed. Then report a success. */
974 data->task_list_valid_p = 1;
979 /* Build the task_list by reading the Known_Tasks array from
980 the inferior, and return the number of tasks in that list
981 (zero means that the program is not using tasking at all). */
984 ada_build_task_list (void)
986 struct ada_tasks_inferior_data *data;
988 if (!target_has_stack)
989 error (_("Cannot inspect Ada tasks when program is not running"));
991 data = get_ada_tasks_inferior_data (current_inferior ());
992 if (!data->task_list_valid_p)
995 return VEC_length (ada_task_info_s, data->task_list);
998 /* Print a table providing a short description of all Ada tasks
999 running inside inferior INF. If ARG_STR is set, it will be
1000 interpreted as a task number, and the table will be limited to
1004 print_ada_task_info (struct ui_out *uiout,
1006 struct inferior *inf)
1008 struct ada_tasks_inferior_data *data;
1009 int taskno, nb_tasks;
1011 struct cleanup *old_chain;
1014 if (ada_build_task_list () == 0)
1016 uiout->message (_("Your application does not use any Ada tasks.\n"));
1020 if (arg_str != NULL && arg_str[0] != '\0')
1021 taskno_arg = value_as_long (parse_and_eval (arg_str));
1023 if (uiout->is_mi_like_p ())
1024 /* In GDB/MI mode, we want to provide the thread ID corresponding
1025 to each task. This allows clients to quickly find the thread
1026 associated to any task, which is helpful for commands that
1027 take a --thread argument. However, in order to be able to
1028 provide that thread ID, the thread list must be up to date
1030 target_update_thread_list ();
1032 data = get_ada_tasks_inferior_data (inf);
1034 /* Compute the number of tasks that are going to be displayed
1035 in the output. If an argument was given, there will be
1036 at most 1 entry. Otherwise, there will be as many entries
1037 as we have tasks. */
1041 && taskno_arg <= VEC_length (ada_task_info_s, data->task_list))
1047 nb_tasks = VEC_length (ada_task_info_s, data->task_list);
1049 nb_columns = uiout->is_mi_like_p () ? 8 : 7;
1050 old_chain = make_cleanup_ui_out_table_begin_end (uiout, nb_columns,
1052 uiout->table_header (1, ui_left, "current", "");
1053 uiout->table_header (3, ui_right, "id", "ID");
1054 uiout->table_header (9, ui_right, "task-id", "TID");
1055 /* The following column is provided in GDB/MI mode only because
1056 it is only really useful in that mode, and also because it
1057 allows us to keep the CLI output shorter and more compact. */
1058 if (uiout->is_mi_like_p ())
1059 uiout->table_header (4, ui_right, "thread-id", "");
1060 uiout->table_header (4, ui_right, "parent-id", "P-ID");
1061 uiout->table_header (3, ui_right, "priority", "Pri");
1062 uiout->table_header (22, ui_left, "state", "State");
1063 /* Use ui_noalign for the last column, to prevent the CLI uiout
1064 from printing an extra space at the end of each row. This
1065 is a bit of a hack, but does get the job done. */
1066 uiout->table_header (1, ui_noalign, "name", "Name");
1067 uiout->table_body ();
1070 taskno <= VEC_length (ada_task_info_s, data->task_list);
1073 const struct ada_task_info *const task_info =
1074 VEC_index (ada_task_info_s, data->task_list, taskno - 1);
1076 struct cleanup *chain2;
1078 gdb_assert (task_info != NULL);
1080 /* If the user asked for the output to be restricted
1081 to one task only, and this is not the task, skip
1083 if (taskno_arg && taskno != taskno_arg)
1086 chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1088 /* Print a star if this task is the current task (or the task
1089 currently selected). */
1090 if (ptid_equal (task_info->ptid, inferior_ptid))
1091 uiout->field_string ("current", "*");
1093 uiout->field_skip ("current");
1095 /* Print the task number. */
1096 uiout->field_int ("id", taskno);
1098 /* Print the Task ID. */
1099 uiout->field_fmt ("task-id", "%9lx", (long) task_info->task_id);
1101 /* Print the associated Thread ID. */
1102 if (uiout->is_mi_like_p ())
1104 const int thread_id = ptid_to_global_thread_id (task_info->ptid);
1107 uiout->field_int ("thread-id", thread_id);
1109 /* This should never happen unless there is a bug somewhere,
1110 but be resilient when that happens. */
1111 uiout->field_skip ("thread-id");
1114 /* Print the ID of the parent task. */
1115 parent_id = get_task_number_from_id (task_info->parent, inf);
1117 uiout->field_int ("parent-id", parent_id);
1119 uiout->field_skip ("parent-id");
1121 /* Print the base priority of the task. */
1122 uiout->field_int ("priority", task_info->priority);
1124 /* Print the task current state. */
1125 if (task_info->caller_task)
1126 uiout->field_fmt ("state",
1127 _("Accepting RV with %-4d"),
1128 get_task_number_from_id (task_info->caller_task,
1130 else if (task_info->state == Entry_Caller_Sleep
1131 && task_info->called_task)
1132 uiout->field_fmt ("state",
1133 _("Waiting on RV with %-3d"),
1134 get_task_number_from_id (task_info->called_task,
1137 uiout->field_string ("state", task_states[task_info->state]);
1139 /* Finally, print the task name. */
1140 uiout->field_fmt ("name",
1142 task_info->name[0] != '\0' ? task_info->name
1146 do_cleanups (chain2);
1149 do_cleanups (old_chain);
1152 /* Print a detailed description of the Ada task whose ID is TASKNO_STR
1153 for the given inferior (INF). */
1156 info_task (struct ui_out *uiout, char *taskno_str, struct inferior *inf)
1158 const int taskno = value_as_long (parse_and_eval (taskno_str));
1159 struct ada_task_info *task_info;
1160 int parent_taskno = 0;
1161 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
1163 if (ada_build_task_list () == 0)
1165 uiout->message (_("Your application does not use any Ada tasks.\n"));
1169 if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, data->task_list))
1170 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1171 "see the IDs of currently known tasks"), taskno);
1172 task_info = VEC_index (ada_task_info_s, data->task_list, taskno - 1);
1174 /* Print the Ada task ID. */
1175 printf_filtered (_("Ada Task: %s\n"),
1176 paddress (target_gdbarch (), task_info->task_id));
1178 /* Print the name of the task. */
1179 if (task_info->name[0] != '\0')
1180 printf_filtered (_("Name: %s\n"), task_info->name);
1182 printf_filtered (_("<no name>\n"));
1184 /* Print the TID and LWP. */
1185 printf_filtered (_("Thread: %#lx\n"), ptid_get_tid (task_info->ptid));
1186 printf_filtered (_("LWP: %#lx\n"), ptid_get_lwp (task_info->ptid));
1188 /* Print who is the parent (if any). */
1189 if (task_info->parent != 0)
1190 parent_taskno = get_task_number_from_id (task_info->parent, inf);
1193 struct ada_task_info *parent =
1194 VEC_index (ada_task_info_s, data->task_list, parent_taskno - 1);
1196 printf_filtered (_("Parent: %d"), parent_taskno);
1197 if (parent->name[0] != '\0')
1198 printf_filtered (" (%s)", parent->name);
1199 printf_filtered ("\n");
1202 printf_filtered (_("No parent\n"));
1204 /* Print the base priority. */
1205 printf_filtered (_("Base Priority: %d\n"), task_info->priority);
1207 /* print the task current state. */
1209 int target_taskno = 0;
1211 if (task_info->caller_task)
1213 target_taskno = get_task_number_from_id (task_info->caller_task, inf);
1214 printf_filtered (_("State: Accepting rendezvous with %d"),
1217 else if (task_info->state == Entry_Caller_Sleep && task_info->called_task)
1219 target_taskno = get_task_number_from_id (task_info->called_task, inf);
1220 printf_filtered (_("State: Waiting on task %d's entry"),
1224 printf_filtered (_("State: %s"), _(long_task_states[task_info->state]));
1228 struct ada_task_info *target_task_info =
1229 VEC_index (ada_task_info_s, data->task_list, target_taskno - 1);
1231 if (target_task_info->name[0] != '\0')
1232 printf_filtered (" (%s)", target_task_info->name);
1235 printf_filtered ("\n");
1239 /* If ARG is empty or null, then print a list of all Ada tasks.
1240 Otherwise, print detailed information about the task whose ID
1243 Does nothing if the program doesn't use Ada tasking. */
1246 info_tasks_command (char *arg, int from_tty)
1248 struct ui_out *uiout = current_uiout;
1250 if (arg == NULL || *arg == '\0')
1251 print_ada_task_info (uiout, NULL, current_inferior ());
1253 info_task (uiout, arg, current_inferior ());
1256 /* Print a message telling the user id of the current task.
1257 This function assumes that tasking is in use in the inferior. */
1260 display_current_task_id (void)
1262 const int current_task = ada_get_task_number (inferior_ptid);
1264 if (current_task == 0)
1265 printf_filtered (_("[Current task is unknown]\n"));
1267 printf_filtered (_("[Current task is %d]\n"), current_task);
1270 /* Parse and evaluate TIDSTR into a task id, and try to switch to
1271 that task. Print an error message if the task switch failed. */
1274 task_command_1 (char *taskno_str, int from_tty, struct inferior *inf)
1276 const int taskno = value_as_long (parse_and_eval (taskno_str));
1277 struct ada_task_info *task_info;
1278 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
1280 if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, data->task_list))
1281 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1282 "see the IDs of currently known tasks"), taskno);
1283 task_info = VEC_index (ada_task_info_s, data->task_list, taskno - 1);
1285 if (!ada_task_is_alive (task_info))
1286 error (_("Cannot switch to task %d: Task is no longer running"), taskno);
1288 /* On some platforms, the thread list is not updated until the user
1289 performs a thread-related operation (by using the "info threads"
1290 command, for instance). So this thread list may not be up to date
1291 when the user attempts this task switch. Since we cannot switch
1292 to the thread associated to our task if GDB does not know about
1293 that thread, we need to make sure that any new threads gets added
1294 to the thread list. */
1295 target_update_thread_list ();
1297 /* Verify that the ptid of the task we want to switch to is valid
1298 (in other words, a ptid that GDB knows about). Otherwise, we will
1299 cause an assertion failure later on, when we try to determine
1300 the ptid associated thread_info data. We should normally never
1301 encounter such an error, but the wrong ptid can actually easily be
1302 computed if target_get_ada_task_ptid has not been implemented for
1303 our target (yet). Rather than cause an assertion error in that case,
1304 it's nicer for the user to just refuse to perform the task switch. */
1305 if (!find_thread_ptid (task_info->ptid))
1306 error (_("Unable to compute thread ID for task %d.\n"
1307 "Cannot switch to this task."),
1310 switch_to_thread (task_info->ptid);
1311 ada_find_printable_frame (get_selected_frame (NULL));
1312 printf_filtered (_("[Switching to task %d]\n"), taskno);
1313 print_stack_frame (get_selected_frame (NULL),
1314 frame_relative_level (get_selected_frame (NULL)),
1319 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
1320 Otherwise, switch to the task indicated by TASKNO_STR. */
1323 task_command (char *taskno_str, int from_tty)
1325 struct ui_out *uiout = current_uiout;
1327 if (ada_build_task_list () == 0)
1329 uiout->message (_("Your application does not use any Ada tasks.\n"));
1333 if (taskno_str == NULL || taskno_str[0] == '\0')
1334 display_current_task_id ();
1337 /* Task switching in core files doesn't work, either because:
1338 1. Thread support is not implemented with core files
1339 2. Thread support is implemented, but the thread IDs created
1340 after having read the core file are not the same as the ones
1341 that were used during the program life, before the crash.
1342 As a consequence, there is no longer a way for the debugger
1343 to find the associated thead ID of any given Ada task.
1344 So, instead of attempting a task switch without giving the user
1345 any clue as to what might have happened, just error-out with
1346 a message explaining that this feature is not supported. */
1347 if (!target_has_execution)
1349 Task switching not supported when debugging from core files\n\
1350 (use thread support instead)"));
1351 task_command_1 (taskno_str, from_tty, current_inferior ());
1355 /* Indicate that the given inferior's task list may have changed,
1356 so invalidate the cache. */
1359 ada_task_list_changed (struct inferior *inf)
1361 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
1363 data->task_list_valid_p = 0;
1366 /* Invalidate the per-program-space data. */
1369 ada_tasks_invalidate_pspace_data (struct program_space *pspace)
1371 get_ada_tasks_pspace_data (pspace)->initialized_p = 0;
1374 /* Invalidate the per-inferior data. */
1377 ada_tasks_invalidate_inferior_data (struct inferior *inf)
1379 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
1381 data->known_tasks_kind = ADA_TASKS_UNKNOWN;
1382 data->task_list_valid_p = 0;
1385 /* The 'normal_stop' observer notification callback. */
1388 ada_tasks_normal_stop_observer (struct bpstats *unused_args, int unused_args2)
1390 /* The inferior has been resumed, and just stopped. This means that
1391 our task_list needs to be recomputed before it can be used again. */
1392 ada_task_list_changed (current_inferior ());
1395 /* A routine to be called when the objfiles have changed. */
1398 ada_tasks_new_objfile_observer (struct objfile *objfile)
1400 struct inferior *inf;
1402 /* Invalidate the relevant data in our program-space data. */
1404 if (objfile == NULL)
1406 /* All objfiles are being cleared, so we should clear all
1407 our caches for all program spaces. */
1408 struct program_space *pspace;
1410 for (pspace = program_spaces; pspace != NULL; pspace = pspace->next)
1411 ada_tasks_invalidate_pspace_data (pspace);
1415 /* The associated program-space data might have changed after
1416 this objfile was added. Invalidate all cached data. */
1417 ada_tasks_invalidate_pspace_data (objfile->pspace);
1420 /* Invalidate the per-inferior cache for all inferiors using
1421 this objfile (or, in other words, for all inferiors who have
1422 the same program-space as the objfile's program space).
1423 If all objfiles are being cleared (OBJFILE is NULL), then
1424 clear the caches for all inferiors. */
1426 for (inf = inferior_list; inf != NULL; inf = inf->next)
1427 if (objfile == NULL || inf->pspace == objfile->pspace)
1428 ada_tasks_invalidate_inferior_data (inf);
1431 /* Provide a prototype to silence -Wmissing-prototypes. */
1432 extern initialize_file_ftype _initialize_tasks;
1435 _initialize_tasks (void)
1437 ada_tasks_pspace_data_handle = register_program_space_data ();
1438 ada_tasks_inferior_data_handle = register_inferior_data ();
1440 /* Attach various observers. */
1441 observer_attach_normal_stop (ada_tasks_normal_stop_observer);
1442 observer_attach_new_objfile (ada_tasks_new_objfile_observer);
1444 /* Some new commands provided by this module. */
1445 add_info ("tasks", info_tasks_command,
1446 _("Provide information about all known Ada tasks"));
1447 add_cmd ("task", class_run, task_command,
1448 _("Use this command to switch between Ada tasks.\n\
1449 Without argument, this command simply prints the current task ID"),