1 /* Copyright (C) 1992, 1993, 1994, 1997, 1998, 1999, 2000, 2003, 2004, 2005,
2 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdbthread.h"
28 /* The name of the array in the GNAT runtime where the Ada Task Control
29 Block of each task is stored. */
30 #define KNOWN_TASKS_NAME "system__tasking__debug__known_tasks"
32 /* The maximum number of tasks known to the Ada runtime */
33 static const int MAX_NUMBER_OF_KNOWN_TASKS
= 1000;
45 Master_Completion_Sleep
,
47 Interrupt_Server_Idle_Sleep
,
48 Interrupt_Server_Blocked_Interrupt_Sleep
,
52 Interrupt_Server_Blocked_On_Event_Flag
,
57 /* A short description corresponding to each possible task state. */
58 static const char *task_states
[] = {
62 N_("Child Activation Wait"),
63 N_("Accept or Select Term"),
64 N_("Waiting on entry call"),
65 N_("Async Select Wait"),
67 N_("Child Termination Wait"),
68 N_("Wait Child in Term Alt"),
73 N_("Asynchronous Hold"),
79 /* A longer description corresponding to each possible task state. */
80 static const char *long_task_states
[] = {
84 N_("Waiting for child activation"),
85 N_("Blocked in accept or select with terminate"),
86 N_("Waiting on entry call"),
87 N_("Asynchronous Selective Wait"),
89 N_("Waiting for children termination"),
90 N_("Waiting for children in terminate alternative"),
95 N_("Asynchronous Hold"),
98 N_("Blocked in selective wait statement")
101 /* The index of certain important fields in the Ada Task Control Block
102 record and sub-records. */
106 /* Fields in record Ada_Task_Control_Block. */
109 int atc_nesting_level
;
111 /* Fields in record Common_ATCB. */
116 int image_len
; /* This field may be missing. */
120 /* Fields in Task_Primitives.Private_Data. */
122 int ll_lwp
; /* This field may be missing. */
124 /* Fields in Common_ATCB.Call.all. */
128 /* The type description for the ATCB record and subrecords, and
129 the associated tcb_fieldnos. For efficiency reasons, these are made
130 static globals so that we can compute them only once the first time
131 and reuse them later. Set to NULL if the types haven't been computed
132 yet, or if they may be obsolete (for instance after having loaded
135 static struct type
*atcb_type
= NULL
;
136 static struct type
*atcb_common_type
= NULL
;
137 static struct type
*atcb_ll_type
= NULL
;
138 static struct type
*atcb_call_type
= NULL
;
139 static struct tcb_fieldnos fieldno
;
141 /* Set to 1 when the cached address of System.Tasking.Debug.Known_Tasks
142 might be stale and so needs to be recomputed. */
143 static int ada_tasks_check_symbol_table
= 1;
145 /* The list of Ada tasks.
147 Note: To each task we associate a number that the user can use to
148 reference it - this number is printed beside each task in the tasks
149 info listing displayed by "info tasks". This number is equal to
150 its index in the vector + 1. Reciprocally, to compute the index
151 of a task in the vector, we need to substract 1 from its number. */
152 typedef struct ada_task_info ada_task_info_s
;
153 DEF_VEC_O(ada_task_info_s
);
154 static VEC(ada_task_info_s
) *task_list
= NULL
;
156 /* When non-zero, this flag indicates that the current task_list
157 is obsolete, and should be recomputed before it is accessed. */
158 static int stale_task_list_p
= 1;
160 /* Return the task number of the task whose ptid is PTID, or zero
161 if the task could not be found. */
164 ada_get_task_number (ptid_t ptid
)
168 for (i
=0; i
< VEC_length (ada_task_info_s
, task_list
); i
++)
169 if (ptid_equal (VEC_index (ada_task_info_s
, task_list
, i
)->ptid
, ptid
))
172 return 0; /* No matching task found. */
175 /* Return the task number of the task that matches TASK_ID, or zero
176 if the task could not be found. */
179 get_task_number_from_id (CORE_ADDR task_id
)
183 for (i
= 0; i
< VEC_length (ada_task_info_s
, task_list
); i
++)
185 struct ada_task_info
*task_info
=
186 VEC_index (ada_task_info_s
, task_list
, i
);
188 if (task_info
->task_id
== task_id
)
192 /* Task not found. Return 0. */
196 /* Return non-zero if TASK_NUM is a valid task number. */
199 valid_task_id (int task_num
)
201 ada_build_task_list (0);
203 && task_num
<= VEC_length (ada_task_info_s
, task_list
));
206 /* Return non-zero iff the task STATE corresponds to a non-terminated
210 ada_task_is_alive (struct ada_task_info
*task_info
)
212 return (task_info
->state
!= Terminated
);
215 /* Extract the contents of the value as a string whose length is LENGTH,
216 and store the result in DEST. */
219 value_as_string (char *dest
, struct value
*val
, int length
)
221 memcpy (dest
, value_contents (val
), length
);
225 /* Extract the string image from the fat string corresponding to VAL,
226 and store it in DEST. If the string length is greater than MAX_LEN,
227 then truncate the result to the first MAX_LEN characters of the fat
231 read_fat_string_value (char *dest
, struct value
*val
, int max_len
)
233 struct value
*array_val
;
234 struct value
*bounds_val
;
237 /* The following variables are made static to avoid recomputing them
238 each time this function is called. */
239 static int initialize_fieldnos
= 1;
240 static int array_fieldno
;
241 static int bounds_fieldno
;
242 static int upper_bound_fieldno
;
244 /* Get the index of the fields that we will need to read in order
245 to extract the string from the fat string. */
246 if (initialize_fieldnos
)
248 struct type
*type
= value_type (val
);
249 struct type
*bounds_type
;
251 array_fieldno
= ada_get_field_index (type
, "P_ARRAY", 0);
252 bounds_fieldno
= ada_get_field_index (type
, "P_BOUNDS", 0);
254 bounds_type
= TYPE_FIELD_TYPE (type
, bounds_fieldno
);
255 if (TYPE_CODE (bounds_type
) == TYPE_CODE_PTR
)
256 bounds_type
= TYPE_TARGET_TYPE (bounds_type
);
257 if (TYPE_CODE (bounds_type
) != TYPE_CODE_STRUCT
)
258 error (_("Unknown task name format. Aborting"));
259 upper_bound_fieldno
= ada_get_field_index (bounds_type
, "UB0", 0);
261 initialize_fieldnos
= 0;
264 /* Get the size of the task image by checking the value of the bounds.
265 The lower bound is always 1, so we only need to read the upper bound. */
266 bounds_val
= value_ind (value_field (val
, bounds_fieldno
));
267 len
= value_as_long (value_field (bounds_val
, upper_bound_fieldno
));
269 /* Make sure that we do not read more than max_len characters... */
273 /* Extract LEN characters from the fat string. */
274 array_val
= value_ind (value_field (val
, array_fieldno
));
275 read_memory (value_address (array_val
), dest
, len
);
277 /* Add the NUL character to close the string. */
281 /* Return the address of the Known_Tasks array maintained in
282 the Ada Runtime. Return NULL if the array could not be found,
283 meaning that the inferior program probably does not use tasking.
285 In order to provide a fast response time, this function caches
286 the Known_Tasks array address after the lookup during the first
287 call. Subsequent calls will simply return this cached address. */
290 get_known_tasks_addr (void)
292 static CORE_ADDR known_tasks_addr
= 0;
294 if (ada_tasks_check_symbol_table
)
296 struct minimal_symbol
*msym
;
298 msym
= lookup_minimal_symbol (KNOWN_TASKS_NAME
, NULL
, NULL
);
300 known_tasks_addr
= SYMBOL_VALUE_ADDRESS (msym
);
303 if (target_lookup_symbol (KNOWN_TASKS_NAME
, &known_tasks_addr
) != 0)
307 /* FIXME: brobecker 2003-03-05: Here would be a much better place
308 to attach the ada-tasks observers, instead of doing this
309 unconditionaly in _initialize_tasks. This would avoid an
310 unecessary notification when the inferior does not use tasking
311 or as long as the user does not use the ada-tasks commands.
312 Unfortunately, this is not possible for the moment: the current
313 code resets ada__tasks_check_symbol_table back to 1 whenever
314 symbols for a new program are being loaded. If we place the
315 observers intialization here, we will end up adding new observers
316 everytime we do the check for Ada tasking-related symbols
317 above. This would currently have benign effects, but is still
318 undesirable. The cleanest approach is probably to create a new
319 observer to notify us when the user is debugging a new program.
320 We would then reset ada__tasks_check_symbol_table back to 1
321 during the notification, but also detach all observers.
322 BTW: observers are probably not reentrant, so detaching during
323 a notification may not be the safest thing to do... Sigh...
324 But creating the new observer would be a good idea in any case,
325 since this allow us to make ada__tasks_check_symbol_table
326 static, which is a good bonus. */
327 ada_tasks_check_symbol_table
= 0;
330 return known_tasks_addr
;
333 /* Get from the debugging information the type description of all types
334 related to the Ada Task Control Block that will be needed in order to
335 read the list of known tasks in the Ada runtime. Also return the
336 associated ATCB_FIELDNOS.
338 Error handling: Any data missing from the debugging info will cause
339 an error to be raised, and none of the return values to be set.
340 Users of this function can depend on the fact that all or none of the
341 return values will be set. */
344 get_tcb_types_info (struct type
**atcb_type
,
345 struct type
**atcb_common_type
,
346 struct type
**atcb_ll_type
,
347 struct type
**atcb_call_type
,
348 struct tcb_fieldnos
*atcb_fieldnos
)
351 struct type
*common_type
;
352 struct type
*ll_type
;
353 struct type
*call_type
;
354 struct tcb_fieldnos fieldnos
;
356 const char *atcb_name
= "system__tasking__ada_task_control_block___XVE";
357 const char *atcb_name_fixed
= "system__tasking__ada_task_control_block";
358 const char *common_atcb_name
= "system__tasking__common_atcb";
359 const char *private_data_name
= "system__task_primitives__private_data";
360 const char *entry_call_record_name
= "system__tasking__entry_call_record";
362 struct symbol
*atcb_sym
=
363 lookup_symbol (atcb_name
, NULL
, VAR_DOMAIN
, NULL
);
364 const struct symbol
*common_atcb_sym
=
365 lookup_symbol (common_atcb_name
, NULL
, VAR_DOMAIN
, NULL
);
366 const struct symbol
*private_data_sym
=
367 lookup_symbol (private_data_name
, NULL
, VAR_DOMAIN
, NULL
);
368 const struct symbol
*entry_call_record_sym
=
369 lookup_symbol (entry_call_record_name
, NULL
, VAR_DOMAIN
, NULL
);
371 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
373 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
374 size, so the symbol name differs. */
375 atcb_sym
= lookup_symbol (atcb_name_fixed
, NULL
, VAR_DOMAIN
, NULL
);
377 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
378 error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
380 type
= atcb_sym
->type
;
384 /* Get a static representation of the type record
385 Ada_Task_Control_Block. */
386 type
= atcb_sym
->type
;
387 type
= ada_template_to_fixed_record_type_1 (type
, NULL
, 0, NULL
, 0);
390 if (common_atcb_sym
== NULL
|| common_atcb_sym
->type
== NULL
)
391 error (_("Cannot find Common_ATCB type. Aborting"));
392 if (private_data_sym
== NULL
|| private_data_sym
->type
== NULL
)
393 error (_("Cannot find Private_Data type. Aborting"));
394 if (entry_call_record_sym
== NULL
|| entry_call_record_sym
->type
== NULL
)
395 error (_("Cannot find Entry_Call_Record type. Aborting"));
397 /* Get the type for Ada_Task_Control_Block.Common. */
398 common_type
= common_atcb_sym
->type
;
400 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
401 ll_type
= private_data_sym
->type
;
403 /* Get the type for Common_ATCB.Call.all. */
404 call_type
= entry_call_record_sym
->type
;
406 /* Get the field indices. */
407 fieldnos
.common
= ada_get_field_index (type
, "common", 0);
408 fieldnos
.entry_calls
= ada_get_field_index (type
, "entry_calls", 1);
409 fieldnos
.atc_nesting_level
=
410 ada_get_field_index (type
, "atc_nesting_level", 1);
411 fieldnos
.state
= ada_get_field_index (common_type
, "state", 0);
412 fieldnos
.parent
= ada_get_field_index (common_type
, "parent", 1);
413 fieldnos
.priority
= ada_get_field_index (common_type
, "base_priority", 0);
414 fieldnos
.image
= ada_get_field_index (common_type
, "task_image", 1);
415 fieldnos
.image_len
= ada_get_field_index (common_type
, "task_image_len", 1);
416 fieldnos
.call
= ada_get_field_index (common_type
, "call", 1);
417 fieldnos
.ll
= ada_get_field_index (common_type
, "ll", 0);
418 fieldnos
.ll_thread
= ada_get_field_index (ll_type
, "thread", 0);
419 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "lwp", 1);
420 fieldnos
.call_self
= ada_get_field_index (call_type
, "self", 0);
422 /* On certain platforms such as x86-windows, the "lwp" field has been
423 named "thread_id". This field will likely be renamed in the future,
424 but we need to support both possibilities to avoid an unnecessary
425 dependency on a recent compiler. We therefore try locating the
426 "thread_id" field in place of the "lwp" field if we did not find
428 if (fieldnos
.ll_lwp
< 0)
429 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "thread_id", 1);
431 /* Set all the out parameters all at once, now that we are certain
432 that there are no potential error() anymore. */
434 *atcb_common_type
= common_type
;
435 *atcb_ll_type
= ll_type
;
436 *atcb_call_type
= call_type
;
437 *atcb_fieldnos
= fieldnos
;
440 /* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
441 component of its ATCB record. This PTID needs to match the PTID used
442 by the thread layer. */
445 ptid_from_atcb_common (struct value
*common_value
)
449 struct value
*ll_value
;
452 ll_value
= value_field (common_value
, fieldno
.ll
);
454 if (fieldno
.ll_lwp
>= 0)
455 lwp
= value_as_address (value_field (ll_value
, fieldno
.ll_lwp
));
456 thread
= value_as_long (value_field (ll_value
, fieldno
.ll_thread
));
458 ptid
= target_get_ada_task_ptid (lwp
, thread
);
463 /* Read the ATCB data of a given task given its TASK_ID (which is in practice
464 the address of its assocated ATCB record), and store the result inside
468 read_atcb (CORE_ADDR task_id
, struct ada_task_info
*task_info
)
470 struct value
*tcb_value
;
471 struct value
*common_value
;
472 struct value
*atc_nesting_level_value
;
473 struct value
*entry_calls_value
;
474 struct value
*entry_calls_value_element
;
475 int called_task_fieldno
= -1;
476 const char ravenscar_task_name
[] = "Ravenscar task";
478 if (atcb_type
== NULL
)
479 get_tcb_types_info (&atcb_type
, &atcb_common_type
, &atcb_ll_type
,
480 &atcb_call_type
, &fieldno
);
482 tcb_value
= value_from_contents_and_address (atcb_type
, NULL
, task_id
);
483 common_value
= value_field (tcb_value
, fieldno
.common
);
485 /* Fill in the task_id. */
487 task_info
->task_id
= task_id
;
489 /* Compute the name of the task.
491 Depending on the GNAT version used, the task image is either a fat
492 string, or a thin array of characters. Older versions of GNAT used
493 to use fat strings, and therefore did not need an extra field in
494 the ATCB to store the string length. For efficiency reasons, newer
495 versions of GNAT replaced the fat string by a static buffer, but this
496 also required the addition of a new field named "Image_Len" containing
497 the length of the task name. The method used to extract the task name
498 is selected depending on the existence of this field.
500 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
501 we may want to get it from the first user frame of the stack. For now,
502 we just give a dummy name. */
504 if (fieldno
.image_len
== -1)
506 if (fieldno
.image
>= 0)
507 read_fat_string_value (task_info
->name
,
508 value_field (common_value
, fieldno
.image
),
509 sizeof (task_info
->name
) - 1);
511 strcpy (task_info
->name
, ravenscar_task_name
);
515 int len
= value_as_long (value_field (common_value
, fieldno
.image_len
));
517 value_as_string (task_info
->name
,
518 value_field (common_value
, fieldno
.image
), len
);
521 /* Compute the task state and priority. */
523 task_info
->state
= value_as_long (value_field (common_value
, fieldno
.state
));
524 task_info
->priority
=
525 value_as_long (value_field (common_value
, fieldno
.priority
));
527 /* If the ATCB contains some information about the parent task,
528 then compute it as well. Otherwise, zero. */
530 if (fieldno
.parent
>= 0)
532 value_as_address (value_field (common_value
, fieldno
.parent
));
534 task_info
->parent
= 0;
537 /* If the ATCB contains some information about entry calls, then
538 compute the "called_task" as well. Otherwise, zero. */
540 if (fieldno
.atc_nesting_level
> 0 && fieldno
.entry_calls
> 0)
542 /* Let My_ATCB be the Ada task control block of a task calling the
543 entry of another task; then the Task_Id of the called task is
544 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
545 atc_nesting_level_value
= value_field (tcb_value
,
546 fieldno
.atc_nesting_level
);
548 ada_coerce_to_simple_array_ptr (value_field (tcb_value
,
549 fieldno
.entry_calls
));
550 entry_calls_value_element
=
551 value_subscript (entry_calls_value
,
552 value_as_long (atc_nesting_level_value
));
553 called_task_fieldno
=
554 ada_get_field_index (value_type (entry_calls_value_element
),
556 task_info
->called_task
=
557 value_as_address (value_field (entry_calls_value_element
,
558 called_task_fieldno
));
562 task_info
->called_task
= 0;
565 /* If the ATCB cotnains some information about RV callers,
566 then compute the "caller_task". Otherwise, zero. */
568 task_info
->caller_task
= 0;
569 if (fieldno
.call
>= 0)
571 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
572 If Common_ATCB.Call is null, then there is no caller. */
573 const CORE_ADDR call
=
574 value_as_address (value_field (common_value
, fieldno
.call
));
575 struct value
*call_val
;
580 value_from_contents_and_address (atcb_call_type
, NULL
, call
);
581 task_info
->caller_task
=
582 value_as_address (value_field (call_val
, fieldno
.call_self
));
586 /* And finally, compute the task ptid. Note that there are situations
587 where this cannot be determined:
588 - The task is no longer alive - the ptid is irrelevant;
589 - We are debugging a core file - the thread is not always
590 completely preserved for us to link back a task to its
591 underlying thread. Since we do not support task switching
592 when debugging core files anyway, we don't need to compute
594 In either case, we don't need that ptid, and it is just good enough
595 to set it to null_ptid. */
597 if (target_has_execution
&& ada_task_is_alive (task_info
))
598 task_info
->ptid
= ptid_from_atcb_common (common_value
);
600 task_info
->ptid
= null_ptid
;
603 /* Read the ATCB info of the given task (identified by TASK_ID), and
604 add the result to the TASK_LIST. */
607 add_ada_task (CORE_ADDR task_id
)
609 struct ada_task_info task_info
;
611 read_atcb (task_id
, &task_info
);
612 VEC_safe_push (ada_task_info_s
, task_list
, &task_info
);
615 /* Read the Known_Tasks array from the inferior memory, and store
616 it in TASK_LIST. Return non-zero upon success. */
619 read_known_tasks_array (void)
621 const int target_ptr_byte
=
622 gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
;
623 const CORE_ADDR known_tasks_addr
= get_known_tasks_addr ();
624 const int known_tasks_size
= target_ptr_byte
* MAX_NUMBER_OF_KNOWN_TASKS
;
625 gdb_byte
*known_tasks
= alloca (known_tasks_size
);
628 /* Step 1: Clear the current list, if necessary. */
629 VEC_truncate (ada_task_info_s
, task_list
, 0);
631 /* If the application does not use task, then no more needs to be done.
632 It is important to have the task list cleared (see above) before we
633 return, as we don't want a stale task list to be used... This can
634 happen for instance when debugging a non-multitasking program after
635 having debugged a multitasking one. */
636 if (known_tasks_addr
== 0)
639 /* Step 2: Build a new list by reading the ATCBs from the Known_Tasks
640 array in the Ada runtime. */
641 read_memory (known_tasks_addr
, known_tasks
, known_tasks_size
);
642 for (i
= 0; i
< MAX_NUMBER_OF_KNOWN_TASKS
; i
++)
644 struct type
*data_ptr_type
=
645 builtin_type (target_gdbarch
)->builtin_data_ptr
;
647 extract_typed_address (known_tasks
+ i
* target_ptr_byte
,
651 add_ada_task (task_id
);
654 /* Step 3: Unset stale_task_list_p, to avoid re-reading the Known_Tasks
655 array unless needed. Then report a success. */
656 stale_task_list_p
= 0;
661 /* Builds the task_list by reading the Known_Tasks array from
662 the inferior. Prints an appropriate message and returns non-zero
663 if it failed to build this list. */
666 ada_build_task_list (int warn_if_null
)
668 if (!target_has_stack
)
669 error (_("Cannot inspect Ada tasks when program is not running"));
671 if (stale_task_list_p
)
672 read_known_tasks_array ();
674 if (task_list
== NULL
)
677 printf_filtered (_("Your application does not use any Ada tasks.\n"));
684 /* Print a one-line description of the task whose number is TASKNO.
685 The formatting should fit the "info tasks" array. */
688 short_task_info (int taskno
)
690 const struct ada_task_info
*const task_info
=
691 VEC_index (ada_task_info_s
, task_list
, taskno
- 1);
694 gdb_assert (task_info
!= NULL
);
696 /* Print a star if this task is the current task (or the task currently
699 active_task_p
= ptid_equal (task_info
->ptid
, inferior_ptid
);
701 printf_filtered ("*");
703 printf_filtered (" ");
705 /* Print the task number. */
706 printf_filtered ("%3d", taskno
);
708 /* Print the Task ID. */
709 printf_filtered (" %9lx", (long) task_info
->task_id
);
711 /* Print the Task ID of the task parent. */
712 printf_filtered (" %4d", get_task_number_from_id (task_info
->parent
));
714 /* Print the base priority of the task. */
715 printf_filtered (" %3d", task_info
->priority
);
717 /* Print the task current state. */
718 if (task_info
->caller_task
)
719 printf_filtered (_(" Accepting RV with %-4d"),
720 get_task_number_from_id (task_info
->caller_task
));
721 else if (task_info
->state
== Entry_Caller_Sleep
&& task_info
->called_task
)
722 printf_filtered (_(" Waiting on RV with %-3d"),
723 get_task_number_from_id (task_info
->called_task
));
725 printf_filtered (" %-22s", _(task_states
[task_info
->state
]));
727 /* Finally, print the task name. */
728 if (task_info
->name
[0] != '\0')
729 printf_filtered (" %s\n", task_info
->name
);
731 printf_filtered (_(" <no name>\n"));
734 /* Print a list containing a short description of all Ada tasks. */
735 /* FIXME: Shouldn't we be using ui_out??? */
738 info_tasks (int from_tty
)
741 const int nb_tasks
= VEC_length (ada_task_info_s
, task_list
);
743 printf_filtered (_(" ID TID P-ID Pri State Name\n"));
745 for (taskno
= 1; taskno
<= nb_tasks
; taskno
++)
746 short_task_info (taskno
);
749 /* Print a detailed description of the Ada task whose ID is TASKNO_STR. */
752 info_task (char *taskno_str
, int from_tty
)
754 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
755 struct ada_task_info
*task_info
;
756 int parent_taskno
= 0;
758 if (taskno
<= 0 || taskno
> VEC_length (ada_task_info_s
, task_list
))
759 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
760 "see the IDs of currently known tasks"), taskno
);
761 task_info
= VEC_index (ada_task_info_s
, task_list
, taskno
- 1);
763 /* Print the Ada task ID. */
764 printf_filtered (_("Ada Task: %s\n"),
765 paddress (target_gdbarch
, task_info
->task_id
));
767 /* Print the name of the task. */
768 if (task_info
->name
[0] != '\0')
769 printf_filtered (_("Name: %s\n"), task_info
->name
);
771 printf_filtered (_("<no name>\n"));
773 /* Print the TID and LWP. */
774 printf_filtered (_("Thread: %#lx\n"), ptid_get_tid (task_info
->ptid
));
775 printf_filtered (_("LWP: %#lx\n"), ptid_get_lwp (task_info
->ptid
));
777 /* Print who is the parent (if any). */
778 if (task_info
->parent
!= 0)
779 parent_taskno
= get_task_number_from_id (task_info
->parent
);
782 struct ada_task_info
*parent
=
783 VEC_index (ada_task_info_s
, task_list
, parent_taskno
- 1);
785 printf_filtered (_("Parent: %d"), parent_taskno
);
786 if (parent
->name
[0] != '\0')
787 printf_filtered (" (%s)", parent
->name
);
788 printf_filtered ("\n");
791 printf_filtered (_("No parent\n"));
793 /* Print the base priority. */
794 printf_filtered (_("Base Priority: %d\n"), task_info
->priority
);
796 /* print the task current state. */
798 int target_taskno
= 0;
800 if (task_info
->caller_task
)
802 target_taskno
= get_task_number_from_id (task_info
->caller_task
);
803 printf_filtered (_("State: Accepting rendezvous with %d"),
806 else if (task_info
->state
== Entry_Caller_Sleep
&& task_info
->called_task
)
808 target_taskno
= get_task_number_from_id (task_info
->called_task
);
809 printf_filtered (_("State: Waiting on task %d's entry"),
813 printf_filtered (_("State: %s"), _(long_task_states
[task_info
->state
]));
817 struct ada_task_info
*target_task_info
=
818 VEC_index (ada_task_info_s
, task_list
, target_taskno
- 1);
820 if (target_task_info
->name
[0] != '\0')
821 printf_filtered (" (%s)", target_task_info
->name
);
824 printf_filtered ("\n");
828 /* If ARG is empty or null, then print a list of all Ada tasks.
829 Otherwise, print detailed information about the task whose ID
832 Does nothing if the program doesn't use Ada tasking. */
835 info_tasks_command (char *arg
, int from_tty
)
837 const int task_list_built
= ada_build_task_list (1);
839 if (!task_list_built
)
842 if (arg
== NULL
|| *arg
== '\0')
843 info_tasks (from_tty
);
845 info_task (arg
, from_tty
);
848 /* Print a message telling the user id of the current task.
849 This function assumes that tasking is in use in the inferior. */
852 display_current_task_id (void)
854 const int current_task
= ada_get_task_number (inferior_ptid
);
856 if (current_task
== 0)
857 printf_filtered (_("[Current task is unknown]\n"));
859 printf_filtered (_("[Current task is %d]\n"), current_task
);
862 /* Parse and evaluate TIDSTR into a task id, and try to switch to
863 that task. Print an error message if the task switch failed. */
866 task_command_1 (char *taskno_str
, int from_tty
)
868 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
869 struct ada_task_info
*task_info
;
871 if (taskno
<= 0 || taskno
> VEC_length (ada_task_info_s
, task_list
))
872 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
873 "see the IDs of currently known tasks"), taskno
);
874 task_info
= VEC_index (ada_task_info_s
, task_list
, taskno
- 1);
876 if (!ada_task_is_alive (task_info
))
877 error (_("Cannot switch to task %d: Task is no longer running"), taskno
);
879 /* On some platforms, the thread list is not updated until the user
880 performs a thread-related operation (by using the "info threads"
881 command, for instance). So this thread list may not be up to date
882 when the user attempts this task switch. Since we cannot switch
883 to the thread associated to our task if GDB does not know about
884 that thread, we need to make sure that any new threads gets added
885 to the thread list. */
886 target_find_new_threads ();
888 /* Verify that the ptid of the task we want to switch to is valid
889 (in other words, a ptid that GDB knows about). Otherwise, we will
890 cause an assertion failure later on, when we try to determine
891 the ptid associated thread_info data. We should normally never
892 encounter such an error, but the wrong ptid can actually easily be
893 computed if target_get_ada_task_ptid has not been implemented for
894 our target (yet). Rather than cause an assertion error in that case,
895 it's nicer for the user to just refuse to perform the task switch. */
896 if (!find_thread_ptid (task_info
->ptid
))
897 error (_("Unable to compute thread ID for task %d.\n"
898 "Cannot switch to this task."),
901 switch_to_thread (task_info
->ptid
);
902 ada_find_printable_frame (get_selected_frame (NULL
));
903 printf_filtered (_("[Switching to task %d]\n"), taskno
);
904 print_stack_frame (get_selected_frame (NULL
),
905 frame_relative_level (get_selected_frame (NULL
)), 1);
909 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
910 Otherwise, switch to the task indicated by TASKNO_STR. */
913 task_command (char *taskno_str
, int from_tty
)
915 const int task_list_built
= ada_build_task_list (1);
917 if (!task_list_built
)
920 if (taskno_str
== NULL
|| taskno_str
[0] == '\0')
921 display_current_task_id ();
924 /* Task switching in core files doesn't work, either because:
925 1. Thread support is not implemented with core files
926 2. Thread support is implemented, but the thread IDs created
927 after having read the core file are not the same as the ones
928 that were used during the program life, before the crash.
929 As a consequence, there is no longer a way for the debugger
930 to find the associated thead ID of any given Ada task.
931 So, instead of attempting a task switch without giving the user
932 any clue as to what might have happened, just error-out with
933 a message explaining that this feature is not supported. */
934 if (!target_has_execution
)
936 Task switching not supported when debugging from core files\n\
937 (use thread support instead)"));
938 task_command_1 (taskno_str
, from_tty
);
942 /* Indicate that the task list may have changed, so invalidate the cache. */
945 ada_task_list_changed (void)
947 stale_task_list_p
= 1;
950 /* The 'normal_stop' observer notification callback. */
953 ada_normal_stop_observer (struct bpstats
*unused_args
, int unused_args2
)
955 /* The inferior has been resumed, and just stopped. This means that
956 our task_list needs to be recomputed before it can be used again. */
957 ada_task_list_changed ();
960 /* A routine to be called when the objfiles have changed. */
963 ada_new_objfile_observer (struct objfile
*objfile
)
965 /* Invalidate all cached data that were extracted from an objfile. */
968 atcb_common_type
= NULL
;
970 atcb_call_type
= NULL
;
972 ada_tasks_check_symbol_table
= 1;
975 /* Provide a prototype to silence -Wmissing-prototypes. */
976 extern initialize_file_ftype _initialize_tasks
;
979 _initialize_tasks (void)
981 /* Attach various observers. */
982 observer_attach_normal_stop (ada_normal_stop_observer
);
983 observer_attach_new_objfile (ada_new_objfile_observer
);
985 /* Some new commands provided by this module. */
986 add_info ("tasks", info_tasks_command
,
987 _("Provide information about all known Ada tasks"));
988 add_cmd ("task", class_run
, task_command
,
989 _("Use this command to switch between Ada tasks.\n\
990 Without argument, this command simply prints the current task ID"),