1 /* Copyright (C) 1992, 1993, 1994, 1997, 1998, 1999, 2000, 2003, 2004, 2005,
2 2007, 2008, 2009 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
)
202 && task_num
<= VEC_length (ada_task_info_s
, task_list
));
205 /* Extract the contents of the value as a string whose length is LENGTH,
206 and store the result in DEST. */
209 value_as_string (char *dest
, struct value
*val
, int length
)
211 memcpy (dest
, value_contents (val
), length
);
215 /* Extract the string image from the fat string corresponding to VAL,
216 and store it in DEST. If the string length is greater than MAX_LEN,
217 then truncate the result to the first MAX_LEN characters of the fat
221 read_fat_string_value (char *dest
, struct value
*val
, int max_len
)
223 struct value
*array_val
;
224 struct value
*bounds_val
;
227 /* The following variables are made static to avoid recomputing them
228 each time this function is called. */
229 static int initialize_fieldnos
= 1;
230 static int array_fieldno
;
231 static int bounds_fieldno
;
232 static int upper_bound_fieldno
;
234 /* Get the index of the fields that we will need to read in order
235 to extract the string from the fat string. */
236 if (initialize_fieldnos
)
238 struct type
*type
= value_type (val
);
239 struct type
*bounds_type
;
241 array_fieldno
= ada_get_field_index (type
, "P_ARRAY", 0);
242 bounds_fieldno
= ada_get_field_index (type
, "P_BOUNDS", 0);
244 bounds_type
= TYPE_FIELD_TYPE (type
, bounds_fieldno
);
245 if (TYPE_CODE (bounds_type
) == TYPE_CODE_PTR
)
246 bounds_type
= TYPE_TARGET_TYPE (bounds_type
);
247 if (TYPE_CODE (bounds_type
) != TYPE_CODE_STRUCT
)
248 error (_("Unknown task name format. Aborting"));
249 upper_bound_fieldno
= ada_get_field_index (bounds_type
, "UB0", 0);
251 initialize_fieldnos
= 0;
254 /* Get the size of the task image by checking the value of the bounds.
255 The lower bound is always 1, so we only need to read the upper bound. */
256 bounds_val
= value_ind (value_field (val
, bounds_fieldno
));
257 len
= value_as_long (value_field (bounds_val
, upper_bound_fieldno
));
259 /* Make sure that we do not read more than max_len characters... */
263 /* Extract LEN characters from the fat string. */
264 array_val
= value_ind (value_field (val
, array_fieldno
));
265 read_memory (VALUE_ADDRESS (array_val
), dest
, len
);
267 /* Add the NUL character to close the string. */
271 /* Return the address of the Known_Tasks array maintained in
272 the Ada Runtime. Return NULL if the array could not be found,
273 meaning that the inferior program probably does not use tasking.
275 In order to provide a fast response time, this function caches
276 the Known_Tasks array address after the lookup during the first
277 call. Subsequent calls will simply return this cached address. */
280 get_known_tasks_addr (void)
282 static CORE_ADDR known_tasks_addr
= 0;
284 if (ada_tasks_check_symbol_table
)
287 struct minimal_symbol
*msym
;
289 msym
= lookup_minimal_symbol (KNOWN_TASKS_NAME
, NULL
, NULL
);
291 known_tasks_addr
= SYMBOL_VALUE_ADDRESS (msym
);
294 if (target_lookup_symbol (KNOWN_TASKS_NAME
, &known_tasks_addr
) != 0)
298 /* FIXME: brobecker 2003-03-05: Here would be a much better place
299 to attach the ada-tasks observers, instead of doing this
300 unconditionaly in _initialize_tasks. This would avoid an
301 unecessary notification when the inferior does not use tasking
302 or as long as the user does not use the ada-tasks commands.
303 Unfortunately, this is not possible for the moment: the current
304 code resets ada__tasks_check_symbol_table back to 1 whenever
305 symbols for a new program are being loaded. If we place the
306 observers intialization here, we will end up adding new observers
307 everytime we do the check for Ada tasking-related symbols
308 above. This would currently have benign effects, but is still
309 undesirable. The cleanest approach is probably to create a new
310 observer to notify us when the user is debugging a new program.
311 We would then reset ada__tasks_check_symbol_table back to 1
312 during the notification, but also detach all observers.
313 BTW: observers are probably not reentrant, so detaching during
314 a notification may not be the safest thing to do... Sigh...
315 But creating the new observer would be a good idea in any case,
316 since this allow us to make ada__tasks_check_symbol_table
317 static, which is a good bonus. */
318 ada_tasks_check_symbol_table
= 0;
321 return known_tasks_addr
;
324 /* Get from the debugging information the type description of all types
325 related to the Ada Task Control Block that will be needed in order to
326 read the list of known tasks in the Ada runtime. Also return the
327 associated ATCB_FIELDNOS.
329 Error handling: Any data missing from the debugging info will cause
330 an error to be raised, and none of the return values to be set.
331 Users of this function can depend on the fact that all or none of the
332 return values will be set. */
335 get_tcb_types_info (struct type
**atcb_type
,
336 struct type
**atcb_common_type
,
337 struct type
**atcb_ll_type
,
338 struct type
**atcb_call_type
,
339 struct tcb_fieldnos
*atcb_fieldnos
)
342 struct type
*common_type
;
343 struct type
*ll_type
;
344 struct type
*call_type
;
345 struct tcb_fieldnos fieldnos
;
347 const char *atcb_name
= "system__tasking__ada_task_control_block___XVE";
348 const char *atcb_name_fixed
= "system__tasking__ada_task_control_block";
349 const char *common_atcb_name
= "system__tasking__common_atcb";
350 const char *private_data_name
= "system__task_primitives__private_data";
351 const char *entry_call_record_name
= "system__tasking__entry_call_record";
353 struct symbol
*atcb_sym
=
354 lookup_symbol (atcb_name
, NULL
, VAR_DOMAIN
, NULL
);
355 const struct symbol
*common_atcb_sym
=
356 lookup_symbol (common_atcb_name
, NULL
, VAR_DOMAIN
, NULL
);
357 const struct symbol
*private_data_sym
=
358 lookup_symbol (private_data_name
, NULL
, VAR_DOMAIN
, NULL
);
359 const struct symbol
*entry_call_record_sym
=
360 lookup_symbol (entry_call_record_name
, NULL
, VAR_DOMAIN
, NULL
);
362 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
364 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
365 size, so the symbol name differs. */
366 atcb_sym
= lookup_symbol (atcb_name_fixed
, NULL
, VAR_DOMAIN
, NULL
);
368 if (atcb_sym
== NULL
|| atcb_sym
->type
== NULL
)
369 error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
371 type
= atcb_sym
->type
;
375 /* Get a static representation of the type record
376 Ada_Task_Control_Block. */
377 type
= atcb_sym
->type
;
378 type
= ada_template_to_fixed_record_type_1 (type
, NULL
, 0, NULL
, 0);
381 if (common_atcb_sym
== NULL
|| common_atcb_sym
->type
== NULL
)
382 error (_("Cannot find Common_ATCB type. Aborting"));
383 if (private_data_sym
== NULL
|| private_data_sym
->type
== NULL
)
384 error (_("Cannot find Private_Data type. Aborting"));
385 if (entry_call_record_sym
== NULL
|| entry_call_record_sym
->type
== NULL
)
386 error (_("Cannot find Entry_Call_Record type. Aborting"));
388 /* Get the type for Ada_Task_Control_Block.Common. */
389 common_type
= common_atcb_sym
->type
;
391 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
392 ll_type
= private_data_sym
->type
;
394 /* Get the type for Common_ATCB.Call.all. */
395 call_type
= entry_call_record_sym
->type
;
397 /* Get the field indices. */
398 fieldnos
.common
= ada_get_field_index (type
, "common", 0);
399 fieldnos
.entry_calls
= ada_get_field_index (type
, "entry_calls", 1);
400 fieldnos
.atc_nesting_level
=
401 ada_get_field_index (type
, "atc_nesting_level", 1);
402 fieldnos
.state
= ada_get_field_index (common_type
, "state", 0);
403 fieldnos
.parent
= ada_get_field_index (common_type
, "parent", 1);
404 fieldnos
.priority
= ada_get_field_index (common_type
, "base_priority", 0);
405 fieldnos
.image
= ada_get_field_index (common_type
, "task_image", 1);
406 fieldnos
.image_len
= ada_get_field_index (common_type
, "task_image_len", 1);
407 fieldnos
.call
= ada_get_field_index (common_type
, "call", 1);
408 fieldnos
.ll
= ada_get_field_index (common_type
, "ll", 0);
409 fieldnos
.ll_thread
= ada_get_field_index (ll_type
, "thread", 0);
410 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "lwp", 1);
411 fieldnos
.call_self
= ada_get_field_index (call_type
, "self", 0);
413 /* On certain platforms such as x86-windows, the "lwp" field has been
414 named "thread_id". This field will likely be renamed in the future,
415 but we need to support both possibilities to avoid an unnecessary
416 dependency on a recent compiler. We therefore try locating the
417 "thread_id" field in place of the "lwp" field if we did not find
419 if (fieldnos
.ll_lwp
< 0)
420 fieldnos
.ll_lwp
= ada_get_field_index (ll_type
, "thread_id", 1);
422 /* Set all the out parameters all at once, now that we are certain
423 that there are no potential error() anymore. */
425 *atcb_common_type
= common_type
;
426 *atcb_ll_type
= ll_type
;
427 *atcb_call_type
= call_type
;
428 *atcb_fieldnos
= fieldnos
;
431 /* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
432 component of its ATCB record. This PTID needs to match the PTID used
433 by the thread layer. */
436 ptid_from_atcb_common (struct value
*common_value
)
440 struct value
*ll_value
;
443 ll_value
= value_field (common_value
, fieldno
.ll
);
445 if (fieldno
.ll_lwp
>= 0)
446 lwp
= value_as_address (value_field (ll_value
, fieldno
.ll_lwp
));
447 thread
= value_as_long (value_field (ll_value
, fieldno
.ll_thread
));
449 ptid
= target_get_ada_task_ptid (lwp
, thread
);
454 /* Read the ATCB data of a given task given its TASK_ID (which is in practice
455 the address of its assocated ATCB record), and store the result inside
459 read_atcb (CORE_ADDR task_id
, struct ada_task_info
*task_info
)
461 struct value
*tcb_value
;
462 struct value
*common_value
;
463 struct value
*atc_nesting_level_value
;
464 struct value
*entry_calls_value
;
465 struct value
*entry_calls_value_element
;
466 int called_task_fieldno
= -1;
467 const char ravenscar_task_name
[] = "Ravenscar task";
469 if (atcb_type
== NULL
)
470 get_tcb_types_info (&atcb_type
, &atcb_common_type
, &atcb_ll_type
,
471 &atcb_call_type
, &fieldno
);
473 tcb_value
= value_from_contents_and_address (atcb_type
, NULL
, task_id
);
474 common_value
= value_field (tcb_value
, fieldno
.common
);
476 /* Fill in the task_id. */
478 task_info
->task_id
= task_id
;
480 /* Compute the name of the task.
482 Depending on the GNAT version used, the task image is either a fat
483 string, or a thin array of characters. Older versions of GNAT used
484 to use fat strings, and therefore did not need an extra field in
485 the ATCB to store the string length. For efficiency reasons, newer
486 versions of GNAT replaced the fat string by a static buffer, but this
487 also required the addition of a new field named "Image_Len" containing
488 the length of the task name. The method used to extract the task name
489 is selected depending on the existence of this field.
491 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
492 we may want to get it from the first user frame of the stack. For now,
493 we just give a dummy name. */
495 if (fieldno
.image_len
== -1)
497 if (fieldno
.image
>= 0)
498 read_fat_string_value (task_info
->name
,
499 value_field (common_value
, fieldno
.image
),
500 sizeof (task_info
->name
) - 1);
502 strcpy (task_info
->name
, ravenscar_task_name
);
506 int len
= value_as_long (value_field (common_value
, fieldno
.image_len
));
508 value_as_string (task_info
->name
,
509 value_field (common_value
, fieldno
.image
), len
);
512 /* Compute the task state and priority. */
514 task_info
->state
= value_as_long (value_field (common_value
, fieldno
.state
));
515 task_info
->priority
=
516 value_as_long (value_field (common_value
, fieldno
.priority
));
518 /* If the ATCB contains some information about the parent task,
519 then compute it as well. Otherwise, zero. */
521 if (fieldno
.parent
>= 0)
523 value_as_address (value_field (common_value
, fieldno
.parent
));
525 task_info
->parent
= 0;
528 /* If the ATCB contains some information about entry calls, then
529 compute the "called_task" as well. Otherwise, zero. */
531 if (fieldno
.atc_nesting_level
> 0 && fieldno
.entry_calls
> 0)
533 /* Let My_ATCB be the Ada task control block of a task calling the
534 entry of another task; then the Task_Id of the called task is
535 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
536 atc_nesting_level_value
= value_field (tcb_value
,
537 fieldno
.atc_nesting_level
);
539 ada_coerce_to_simple_array_ptr (value_field (tcb_value
,
540 fieldno
.entry_calls
));
541 entry_calls_value_element
=
542 value_subscript (entry_calls_value
, atc_nesting_level_value
);
543 called_task_fieldno
=
544 ada_get_field_index (value_type (entry_calls_value_element
),
546 task_info
->called_task
=
547 value_as_address (value_field (entry_calls_value_element
,
548 called_task_fieldno
));
552 task_info
->called_task
= 0;
555 /* If the ATCB cotnains some information about RV callers,
556 then compute the "caller_task". Otherwise, zero. */
558 task_info
->caller_task
= 0;
559 if (fieldno
.call
>= 0)
561 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
562 If Common_ATCB.Call is null, then there is no caller. */
563 const CORE_ADDR call
=
564 value_as_address (value_field (common_value
, fieldno
.call
));
565 struct value
*call_val
;
570 value_from_contents_and_address (atcb_call_type
, NULL
, call
);
571 task_info
->caller_task
=
572 value_as_address (value_field (call_val
, fieldno
.call_self
));
576 /* And finally, compute the task ptid. */
578 if (ada_task_is_alive (task_info
))
579 task_info
->ptid
= ptid_from_atcb_common (common_value
);
581 task_info
->ptid
= null_ptid
;
584 /* Read the ATCB info of the given task (identified by TASK_ID), and
585 add the result to the TASK_LIST. */
588 add_ada_task (CORE_ADDR task_id
)
590 struct ada_task_info task_info
;
592 read_atcb (task_id
, &task_info
);
593 VEC_safe_push (ada_task_info_s
, task_list
, &task_info
);
596 /* Read the Known_Tasks array from the inferior memory, and store
597 it in TASK_LIST. Return non-zero upon success. */
600 read_known_tasks_array (void)
602 const int target_ptr_byte
=
603 gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
604 const CORE_ADDR known_tasks_addr
= get_known_tasks_addr ();
605 const int known_tasks_size
= target_ptr_byte
* MAX_NUMBER_OF_KNOWN_TASKS
;
606 gdb_byte
*known_tasks
= alloca (known_tasks_size
);
609 /* Step 1: Clear the current list, if necessary. */
610 VEC_truncate (ada_task_info_s
, task_list
, 0);
612 /* If the application does not use task, then no more needs to be done.
613 It is important to have the task list cleared (see above) before we
614 return, as we don't want a stale task list to be used... This can
615 happen for instance when debugging a non-multitasking program after
616 having debugged a multitasking one. */
617 if (known_tasks_addr
== 0)
620 /* Step 2: Build a new list by reading the ATCBs from the Known_Tasks
621 array in the Ada runtime. */
622 read_memory (known_tasks_addr
, known_tasks
, known_tasks_size
);
623 for (i
= 0; i
< MAX_NUMBER_OF_KNOWN_TASKS
; i
++)
625 struct type
*data_ptr_type
=
626 builtin_type (current_gdbarch
)->builtin_data_ptr
;
628 extract_typed_address (known_tasks
+ i
* target_ptr_byte
,
632 add_ada_task (task_id
);
635 /* Step 3: Unset stale_task_list_p, to avoid re-reading the Known_Tasks
636 array unless needed. Then report a success. */
637 stale_task_list_p
= 0;
642 /* Builds the task_list by reading the Known_Tasks array from
643 the inferior. Prints an appropriate message and returns non-zero
644 if it failed to build this list. */
647 ada_build_task_list (int warn_if_null
)
649 if (!target_has_stack
)
650 error (_("Cannot inspect Ada tasks when program is not running"));
652 if (stale_task_list_p
)
653 read_known_tasks_array ();
655 if (task_list
== NULL
)
658 printf_filtered (_("Your application does not use any Ada tasks.\n"));
665 /* Return non-zero iff the task STATE corresponds to a non-terminated
669 ada_task_is_alive (struct ada_task_info
*task_info
)
671 return (task_info
->state
!= Terminated
);
674 /* Print a one-line description of the task whose number is TASKNO.
675 The formatting should fit the "info tasks" array. */
678 short_task_info (int taskno
)
680 const struct ada_task_info
*const task_info
=
681 VEC_index (ada_task_info_s
, task_list
, taskno
- 1);
684 gdb_assert (task_info
!= NULL
);
686 /* Print a star if this task is the current task (or the task currently
689 active_task_p
= ptid_equal (task_info
->ptid
, inferior_ptid
);
691 printf_filtered ("*");
693 printf_filtered (" ");
695 /* Print the task number. */
696 printf_filtered ("%3d", taskno
);
698 /* Print the Task ID. */
699 printf_filtered (" %9lx", (long) task_info
->task_id
);
701 /* Print the Task ID of the task parent. */
702 printf_filtered (" %4d", get_task_number_from_id (task_info
->parent
));
704 /* Print the base priority of the task. */
705 printf_filtered (" %3d", task_info
->priority
);
707 /* Print the task current state. */
708 if (task_info
->caller_task
)
709 printf_filtered (_(" Accepting RV with %-4d"),
710 get_task_number_from_id (task_info
->caller_task
));
711 else if (task_info
->state
== Entry_Caller_Sleep
&& task_info
->called_task
)
712 printf_filtered (_(" Waiting on RV with %-3d"),
713 get_task_number_from_id (task_info
->called_task
));
714 else if (task_info
->state
== Runnable
&& active_task_p
)
715 /* Replace "Runnable" by "Running" since this is the active task. */
716 printf_filtered (" %-22s", _("Running"));
718 printf_filtered (" %-22s", _(task_states
[task_info
->state
]));
720 /* Finally, print the task name. */
721 if (task_info
->name
[0] != '\0')
722 printf_filtered (" %s\n", task_info
->name
);
724 printf_filtered (_(" <no name>\n"));
727 /* Print a list containing a short description of all Ada tasks. */
728 /* FIXME: Shouldn't we be using ui_out??? */
731 info_tasks (int from_tty
)
734 const int nb_tasks
= VEC_length (ada_task_info_s
, task_list
);
736 printf_filtered (_(" ID TID P-ID Pri State Name\n"));
738 for (taskno
= 1; taskno
<= nb_tasks
; taskno
++)
739 short_task_info (taskno
);
742 /* Print a detailed description of the Ada task whose ID is TASKNO_STR. */
745 info_task (char *taskno_str
, int from_tty
)
747 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
748 struct ada_task_info
*task_info
;
749 int parent_taskno
= 0;
751 if (taskno
<= 0 || taskno
> VEC_length (ada_task_info_s
, task_list
))
752 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
753 "see the IDs of currently known tasks"), taskno
);
754 task_info
= VEC_index (ada_task_info_s
, task_list
, taskno
- 1);
756 /* Print the Ada task ID. */
757 printf_filtered (_("Ada Task: %s\n"), paddr_nz (task_info
->task_id
));
759 /* Print the name of the task. */
760 if (task_info
->name
[0] != '\0')
761 printf_filtered (_("Name: %s\n"), task_info
->name
);
763 printf_filtered (_("<no name>\n"));
765 /* Print the TID and LWP. */
766 printf_filtered (_("Thread: %#lx\n"), ptid_get_tid (task_info
->ptid
));
767 printf_filtered (_("LWP: %#lx\n"), ptid_get_lwp (task_info
->ptid
));
769 /* Print who is the parent (if any). */
770 if (task_info
->parent
!= 0)
771 parent_taskno
= get_task_number_from_id (task_info
->parent
);
774 struct ada_task_info
*parent
=
775 VEC_index (ada_task_info_s
, task_list
, parent_taskno
- 1);
777 printf_filtered (_("Parent: %d"), parent_taskno
);
778 if (parent
->name
[0] != '\0')
779 printf_filtered (" (%s)", parent
->name
);
780 printf_filtered ("\n");
783 printf_filtered (_("No parent\n"));
785 /* Print the base priority. */
786 printf_filtered (_("Base Priority: %d\n"), task_info
->priority
);
788 /* print the task current state. */
790 int target_taskno
= 0;
792 if (task_info
->caller_task
)
794 target_taskno
= get_task_number_from_id (task_info
->caller_task
);
795 printf_filtered (_("State: Accepting rendezvous with %d"),
798 else if (task_info
->state
== Entry_Caller_Sleep
&& task_info
->called_task
)
800 target_taskno
= get_task_number_from_id (task_info
->called_task
);
801 printf_filtered (_("State: Waiting on task %d's entry"),
805 printf_filtered (_("State: %s"), _(long_task_states
[task_info
->state
]));
809 struct ada_task_info
*target_task_info
=
810 VEC_index (ada_task_info_s
, task_list
, target_taskno
- 1);
812 if (target_task_info
->name
[0] != '\0')
813 printf_filtered (" (%s)", target_task_info
->name
);
816 printf_filtered ("\n");
820 /* If ARG is empty or null, then print a list of all Ada tasks.
821 Otherwise, print detailed information about the task whose ID
824 Does nothing if the program doesn't use Ada tasking. */
827 info_tasks_command (char *arg
, int from_tty
)
829 const int task_list_built
= ada_build_task_list (1);
831 if (!task_list_built
)
834 if (arg
== NULL
|| *arg
== '\0')
835 info_tasks (from_tty
);
837 info_task (arg
, from_tty
);
840 /* Print a message telling the user id of the current task.
841 This function assumes that tasking is in use in the inferior. */
844 display_current_task_id (void)
846 const int current_task
= ada_get_task_number (inferior_ptid
);
848 if (current_task
== 0)
849 printf_filtered (_("[Current task is unknown]\n"));
851 printf_filtered (_("[Current task is %d]\n"), current_task
);
854 /* Parse and evaluate TIDSTR into a task id, and try to switch to
855 that task. Print an error message if the task switch failed. */
858 task_command_1 (char *taskno_str
, int from_tty
)
860 const int taskno
= value_as_long (parse_and_eval (taskno_str
));
861 struct ada_task_info
*task_info
;
863 if (taskno
<= 0 || taskno
> VEC_length (ada_task_info_s
, task_list
))
864 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
865 "see the IDs of currently known tasks"), taskno
);
866 task_info
= VEC_index (ada_task_info_s
, task_list
, taskno
- 1);
868 if (!ada_task_is_alive (task_info
))
869 error (_("Cannot switch to task %d: Task is no longer running"), taskno
);
871 switch_to_thread (task_info
->ptid
);
872 ada_find_printable_frame (get_selected_frame (NULL
));
873 printf_filtered (_("[Switching to task %d]\n"), taskno
);
874 print_stack_frame (get_selected_frame (NULL
),
875 frame_relative_level (get_selected_frame (NULL
)), 1);
879 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
880 Otherwise, switch to the task indicated by TASKNO_STR. */
883 task_command (char *taskno_str
, int from_tty
)
885 const int task_list_built
= ada_build_task_list (1);
887 if (!task_list_built
)
890 if (taskno_str
== NULL
|| taskno_str
[0] == '\0')
891 display_current_task_id ();
894 /* Task switching in core files doesn't work, either because:
895 1. Thread support is not implemented with core files
896 2. Thread support is implemented, but the thread IDs created
897 after having read the core file are not the same as the ones
898 that were used during the program life, before the crash.
899 As a consequence, there is no longer a way for the debugger
900 to find the associated thead ID of any given Ada task.
901 So, instead of attempting a task switch without giving the user
902 any clue as to what might have happened, just error-out with
903 a message explaining that this feature is not supported. */
904 if (!target_has_execution
)
906 Task switching not supported when debugging from core files\n\
907 (use thread support instead)"));
908 task_command_1 (taskno_str
, from_tty
);
912 /* Indicate that the task list may have changed, so invalidate the cache. */
915 ada_task_list_changed (void)
917 stale_task_list_p
= 1;
920 /* The 'normal_stop' observer notification callback. */
923 ada_normal_stop_observer (struct bpstats
*unused_args
, int unused_args2
)
925 /* The inferior has been resumed, and just stopped. This means that
926 our task_list needs to be recomputed before it can be used again. */
927 ada_task_list_changed ();
930 /* A routine to be called when the objfiles have changed. */
933 ada_new_objfile_observer (struct objfile
*objfile
)
935 /* Invalidate all cached data that were extracted from an objfile. */
938 atcb_common_type
= NULL
;
940 atcb_call_type
= NULL
;
942 ada_tasks_check_symbol_table
= 1;
945 /* Provide a prototype to silence -Wmissing-prototypes. */
946 extern initialize_file_ftype _initialize_tasks
;
949 _initialize_tasks (void)
951 /* Attach various observers. */
952 observer_attach_normal_stop (ada_normal_stop_observer
);
953 observer_attach_new_objfile (ada_new_objfile_observer
);
955 /* Some new commands provided by this module. */
956 add_info ("tasks", info_tasks_command
,
957 _("Provide information about all known Ada tasks"));
958 add_cmd ("task", class_run
, task_command
,
959 _("Use this command to switch between Ada tasks.\n\
960 Without argument, this command simply prints the current task ID"),