gdb: GC old versions
[dragonfly.git] / contrib / gdb-7 / gdb / ada-tasks.c
CommitLineData
5796c8dc
SS
1/* Copyright (C) 1992, 1993, 1994, 1997, 1998, 1999, 2000, 2003, 2004, 2005,
2 2007, 2008, 2009 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
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.
10
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.
15
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/>. */
18
19#include "defs.h"
20#include "observer.h"
21#include "gdbcmd.h"
22#include "target.h"
23#include "ada-lang.h"
24#include "gdbcore.h"
25#include "inferior.h"
26#include "gdbthread.h"
27
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"
31
32/* The maximum number of tasks known to the Ada runtime */
33static const int MAX_NUMBER_OF_KNOWN_TASKS = 1000;
34
35enum task_states
36{
37 Unactivated,
38 Runnable,
39 Terminated,
40 Activator_Sleep,
41 Acceptor_Sleep,
42 Entry_Caller_Sleep,
43 Async_Select_Sleep,
44 Delay_Sleep,
45 Master_Completion_Sleep,
46 Master_Phase_2_Sleep,
47 Interrupt_Server_Idle_Sleep,
48 Interrupt_Server_Blocked_Interrupt_Sleep,
49 Timer_Server_Sleep,
50 AST_Server_Sleep,
51 Asynchronous_Hold,
52 Interrupt_Server_Blocked_On_Event_Flag,
53 Activating,
54 Acceptor_Delay_Sleep
55};
56
57/* A short description corresponding to each possible task state. */
58static const char *task_states[] = {
59 N_("Unactivated"),
60 N_("Runnable"),
61 N_("Terminated"),
62 N_("Child Activation Wait"),
63 N_("Accept or Select Term"),
64 N_("Waiting on entry call"),
65 N_("Async Select Wait"),
66 N_("Delay Sleep"),
67 N_("Child Termination Wait"),
68 N_("Wait Child in Term Alt"),
69 "",
70 "",
71 "",
72 "",
73 N_("Asynchronous Hold"),
74 "",
75 N_("Activating"),
76 N_("Selective Wait")
77};
78
79/* A longer description corresponding to each possible task state. */
80static const char *long_task_states[] = {
81 N_("Unactivated"),
82 N_("Runnable"),
83 N_("Terminated"),
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"),
88 N_("Delay Sleep"),
89 N_("Waiting for children termination"),
90 N_("Waiting for children in terminate alternative"),
91 "",
92 "",
93 "",
94 "",
95 N_("Asynchronous Hold"),
96 "",
97 N_("Activating"),
98 N_("Blocked in selective wait statement")
99};
100
101/* The index of certain important fields in the Ada Task Control Block
102 record and sub-records. */
103
104struct tcb_fieldnos
105{
106 /* Fields in record Ada_Task_Control_Block. */
107 int common;
108 int entry_calls;
109 int atc_nesting_level;
110
111 /* Fields in record Common_ATCB. */
112 int state;
113 int parent;
114 int priority;
115 int image;
116 int image_len; /* This field may be missing. */
117 int call;
118 int ll;
119
120 /* Fields in Task_Primitives.Private_Data. */
121 int ll_thread;
122 int ll_lwp; /* This field may be missing. */
123
124 /* Fields in Common_ATCB.Call.all. */
125 int call_self;
126};
127
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
133 a new binary). */
134
135static struct type *atcb_type = NULL;
136static struct type *atcb_common_type = NULL;
137static struct type *atcb_ll_type = NULL;
138static struct type *atcb_call_type = NULL;
139static struct tcb_fieldnos fieldno;
140
141/* Set to 1 when the cached address of System.Tasking.Debug.Known_Tasks
142 might be stale and so needs to be recomputed. */
143static int ada_tasks_check_symbol_table = 1;
144
145/* The list of Ada tasks.
146
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. */
152typedef struct ada_task_info ada_task_info_s;
153DEF_VEC_O(ada_task_info_s);
154static VEC(ada_task_info_s) *task_list = NULL;
155
156/* When non-zero, this flag indicates that the current task_list
157 is obsolete, and should be recomputed before it is accessed. */
158static int stale_task_list_p = 1;
159
160/* Return the task number of the task whose ptid is PTID, or zero
161 if the task could not be found. */
162
163int
164ada_get_task_number (ptid_t ptid)
165{
166 int i;
167
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))
170 return i + 1;
171
172 return 0; /* No matching task found. */
173}
174
175/* Return the task number of the task that matches TASK_ID, or zero
176 if the task could not be found. */
177
178static int
179get_task_number_from_id (CORE_ADDR task_id)
180{
181 int i;
182
183 for (i = 0; i < VEC_length (ada_task_info_s, task_list); i++)
184 {
185 struct ada_task_info *task_info =
186 VEC_index (ada_task_info_s, task_list, i);
187
188 if (task_info->task_id == task_id)
189 return i + 1;
190 }
191
192 /* Task not found. Return 0. */
193 return 0;
194}
195
196/* Return non-zero if TASK_NUM is a valid task number. */
197
198int
199valid_task_id (int task_num)
200{
201 return (task_num > 0
202 && task_num <= VEC_length (ada_task_info_s, task_list));
203}
204
205/* Return non-zero iff the task STATE corresponds to a non-terminated
206 task state. */
207
208static int
209ada_task_is_alive (struct ada_task_info *task_info)
210{
211 return (task_info->state != Terminated);
212}
213
214/* Extract the contents of the value as a string whose length is LENGTH,
215 and store the result in DEST. */
216
217static void
218value_as_string (char *dest, struct value *val, int length)
219{
220 memcpy (dest, value_contents (val), length);
221 dest[length] = '\0';
222}
223
224/* Extract the string image from the fat string corresponding to VAL,
225 and store it in DEST. If the string length is greater than MAX_LEN,
226 then truncate the result to the first MAX_LEN characters of the fat
227 string. */
228
229static void
230read_fat_string_value (char *dest, struct value *val, int max_len)
231{
232 struct value *array_val;
233 struct value *bounds_val;
234 int len;
235
236 /* The following variables are made static to avoid recomputing them
237 each time this function is called. */
238 static int initialize_fieldnos = 1;
239 static int array_fieldno;
240 static int bounds_fieldno;
241 static int upper_bound_fieldno;
242
243 /* Get the index of the fields that we will need to read in order
244 to extract the string from the fat string. */
245 if (initialize_fieldnos)
246 {
247 struct type *type = value_type (val);
248 struct type *bounds_type;
249
250 array_fieldno = ada_get_field_index (type, "P_ARRAY", 0);
251 bounds_fieldno = ada_get_field_index (type, "P_BOUNDS", 0);
252
253 bounds_type = TYPE_FIELD_TYPE (type, bounds_fieldno);
254 if (TYPE_CODE (bounds_type) == TYPE_CODE_PTR)
255 bounds_type = TYPE_TARGET_TYPE (bounds_type);
256 if (TYPE_CODE (bounds_type) != TYPE_CODE_STRUCT)
257 error (_("Unknown task name format. Aborting"));
258 upper_bound_fieldno = ada_get_field_index (bounds_type, "UB0", 0);
259
260 initialize_fieldnos = 0;
261 }
262
263 /* Get the size of the task image by checking the value of the bounds.
264 The lower bound is always 1, so we only need to read the upper bound. */
265 bounds_val = value_ind (value_field (val, bounds_fieldno));
266 len = value_as_long (value_field (bounds_val, upper_bound_fieldno));
267
268 /* Make sure that we do not read more than max_len characters... */
269 if (len > max_len)
270 len = max_len;
271
272 /* Extract LEN characters from the fat string. */
273 array_val = value_ind (value_field (val, array_fieldno));
274 read_memory (value_address (array_val), dest, len);
275
276 /* Add the NUL character to close the string. */
277 dest[len] = '\0';
278}
279
280/* Return the address of the Known_Tasks array maintained in
281 the Ada Runtime. Return NULL if the array could not be found,
282 meaning that the inferior program probably does not use tasking.
283
284 In order to provide a fast response time, this function caches
285 the Known_Tasks array address after the lookup during the first
286 call. Subsequent calls will simply return this cached address. */
287
288static CORE_ADDR
289get_known_tasks_addr (void)
290{
291 static CORE_ADDR known_tasks_addr = 0;
292
293 if (ada_tasks_check_symbol_table)
294 {
295 struct symbol *sym;
296 struct minimal_symbol *msym;
297
298 msym = lookup_minimal_symbol (KNOWN_TASKS_NAME, NULL, NULL);
299 if (msym != NULL)
300 known_tasks_addr = SYMBOL_VALUE_ADDRESS (msym);
301 else
302 {
303 if (target_lookup_symbol (KNOWN_TASKS_NAME, &known_tasks_addr) != 0)
304 return 0;
305 }
306
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;
328 }
329
330 return known_tasks_addr;
331}
332
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.
337
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. */
342
343static void
344get_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)
349{
350 struct type *type;
351 struct type *common_type;
352 struct type *ll_type;
353 struct type *call_type;
354 struct tcb_fieldnos fieldnos;
355
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";
361
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);
370
371 if (atcb_sym == NULL || atcb_sym->type == NULL)
372 {
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);
376
377 if (atcb_sym == NULL || atcb_sym->type == NULL)
378 error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
379
380 type = atcb_sym->type;
381 }
382 else
383 {
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);
388 }
389
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"));
396
397 /* Get the type for Ada_Task_Control_Block.Common. */
398 common_type = common_atcb_sym->type;
399
400 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
401 ll_type = private_data_sym->type;
402
403 /* Get the type for Common_ATCB.Call.all. */
404 call_type = entry_call_record_sym->type;
405
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);
421
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
427 the latter. */
428 if (fieldnos.ll_lwp < 0)
429 fieldnos.ll_lwp = ada_get_field_index (ll_type, "thread_id", 1);
430
431 /* Set all the out parameters all at once, now that we are certain
432 that there are no potential error() anymore. */
433 *atcb_type = type;
434 *atcb_common_type = common_type;
435 *atcb_ll_type = ll_type;
436 *atcb_call_type = call_type;
437 *atcb_fieldnos = fieldnos;
438}
439
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. */
443
444static ptid_t
445ptid_from_atcb_common (struct value *common_value)
446{
447 long thread = 0;
448 CORE_ADDR lwp = 0;
449 struct value *ll_value;
450 ptid_t ptid;
451
452 ll_value = value_field (common_value, fieldno.ll);
453
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));
457
458 ptid = target_get_ada_task_ptid (lwp, thread);
459
460 return ptid;
461}
462
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
465 TASK_INFO. */
466
467static void
468read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
469{
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";
477
478 if (atcb_type == NULL)
479 get_tcb_types_info (&atcb_type, &atcb_common_type, &atcb_ll_type,
480 &atcb_call_type, &fieldno);
481
482 tcb_value = value_from_contents_and_address (atcb_type, NULL, task_id);
483 common_value = value_field (tcb_value, fieldno.common);
484
485 /* Fill in the task_id. */
486
487 task_info->task_id = task_id;
488
489 /* Compute the name of the task.
490
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.
499
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. */
503
504 if (fieldno.image_len == -1)
505 {
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);
510 else
511 strcpy (task_info->name, ravenscar_task_name);
512 }
513 else
514 {
515 int len = value_as_long (value_field (common_value, fieldno.image_len));
516
517 value_as_string (task_info->name,
518 value_field (common_value, fieldno.image), len);
519 }
520
521 /* Compute the task state and priority. */
522
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));
526
527 /* If the ATCB contains some information about the parent task,
528 then compute it as well. Otherwise, zero. */
529
530 if (fieldno.parent >= 0)
531 task_info->parent =
532 value_as_address (value_field (common_value, fieldno.parent));
533 else
534 task_info->parent = 0;
535
536
537 /* If the ATCB contains some information about entry calls, then
538 compute the "called_task" as well. Otherwise, zero. */
539
540 if (fieldno.atc_nesting_level > 0 && fieldno.entry_calls > 0)
541 {
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);
547 entry_calls_value =
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),
555 "called_task", 0);
556 task_info->called_task =
557 value_as_address (value_field (entry_calls_value_element,
558 called_task_fieldno));
559 }
560 else
561 {
562 task_info->called_task = 0;
563 }
564
565 /* If the ATCB cotnains some information about RV callers,
566 then compute the "caller_task". Otherwise, zero. */
567
568 task_info->caller_task = 0;
569 if (fieldno.call >= 0)
570 {
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;
576
577 if (call != 0)
578 {
579 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));
583 }
584 }
585
586 /* And finally, compute the task ptid. */
587
588 if (ada_task_is_alive (task_info))
589 task_info->ptid = ptid_from_atcb_common (common_value);
590 else
591 task_info->ptid = null_ptid;
592}
593
594/* Read the ATCB info of the given task (identified by TASK_ID), and
595 add the result to the TASK_LIST. */
596
597static void
598add_ada_task (CORE_ADDR task_id)
599{
600 struct ada_task_info task_info;
601
602 read_atcb (task_id, &task_info);
603 VEC_safe_push (ada_task_info_s, task_list, &task_info);
604}
605
606/* Read the Known_Tasks array from the inferior memory, and store
607 it in TASK_LIST. Return non-zero upon success. */
608
609static int
610read_known_tasks_array (void)
611{
612 const int target_ptr_byte =
613 gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT;
614 const CORE_ADDR known_tasks_addr = get_known_tasks_addr ();
615 const int known_tasks_size = target_ptr_byte * MAX_NUMBER_OF_KNOWN_TASKS;
616 gdb_byte *known_tasks = alloca (known_tasks_size);
617 int i;
618
619 /* Step 1: Clear the current list, if necessary. */
620 VEC_truncate (ada_task_info_s, task_list, 0);
621
622 /* If the application does not use task, then no more needs to be done.
623 It is important to have the task list cleared (see above) before we
624 return, as we don't want a stale task list to be used... This can
625 happen for instance when debugging a non-multitasking program after
626 having debugged a multitasking one. */
627 if (known_tasks_addr == 0)
628 return 0;
629
630 /* Step 2: Build a new list by reading the ATCBs from the Known_Tasks
631 array in the Ada runtime. */
632 read_memory (known_tasks_addr, known_tasks, known_tasks_size);
633 for (i = 0; i < MAX_NUMBER_OF_KNOWN_TASKS; i++)
634 {
635 struct type *data_ptr_type =
636 builtin_type (target_gdbarch)->builtin_data_ptr;
637 CORE_ADDR task_id =
638 extract_typed_address (known_tasks + i * target_ptr_byte,
639 data_ptr_type);
640
641 if (task_id != 0)
642 add_ada_task (task_id);
643 }
644
645 /* Step 3: Unset stale_task_list_p, to avoid re-reading the Known_Tasks
646 array unless needed. Then report a success. */
647 stale_task_list_p = 0;
648
649 return 1;
650}
651
652/* Builds the task_list by reading the Known_Tasks array from
653 the inferior. Prints an appropriate message and returns non-zero
654 if it failed to build this list. */
655
656int
657ada_build_task_list (int warn_if_null)
658{
659 if (!target_has_stack)
660 error (_("Cannot inspect Ada tasks when program is not running"));
661
662 if (stale_task_list_p)
663 read_known_tasks_array ();
664
665 if (task_list == NULL)
666 {
667 if (warn_if_null)
668 printf_filtered (_("Your application does not use any Ada tasks.\n"));
669 return 0;
670 }
671
672 return 1;
673}
674
675/* Print a one-line description of the task whose number is TASKNO.
676 The formatting should fit the "info tasks" array. */
677
678static void
679short_task_info (int taskno)
680{
681 const struct ada_task_info *const task_info =
682 VEC_index (ada_task_info_s, task_list, taskno - 1);
683 int active_task_p;
684
685 gdb_assert (task_info != NULL);
686
687 /* Print a star if this task is the current task (or the task currently
688 selected). */
689
690 active_task_p = ptid_equal (task_info->ptid, inferior_ptid);
691 if (active_task_p)
692 printf_filtered ("*");
693 else
694 printf_filtered (" ");
695
696 /* Print the task number. */
697 printf_filtered ("%3d", taskno);
698
699 /* Print the Task ID. */
700 printf_filtered (" %9lx", (long) task_info->task_id);
701
702 /* Print the Task ID of the task parent. */
703 printf_filtered (" %4d", get_task_number_from_id (task_info->parent));
704
705 /* Print the base priority of the task. */
706 printf_filtered (" %3d", task_info->priority);
707
708 /* Print the task current state. */
709 if (task_info->caller_task)
710 printf_filtered (_(" Accepting RV with %-4d"),
711 get_task_number_from_id (task_info->caller_task));
712 else if (task_info->state == Entry_Caller_Sleep && task_info->called_task)
713 printf_filtered (_(" Waiting on RV with %-3d"),
714 get_task_number_from_id (task_info->called_task));
715 else
716 printf_filtered (" %-22s", _(task_states[task_info->state]));
717
718 /* Finally, print the task name. */
719 if (task_info->name[0] != '\0')
720 printf_filtered (" %s\n", task_info->name);
721 else
722 printf_filtered (_(" <no name>\n"));
723}
724
725/* Print a list containing a short description of all Ada tasks. */
726/* FIXME: Shouldn't we be using ui_out??? */
727
728static void
729info_tasks (int from_tty)
730{
731 int taskno;
732 const int nb_tasks = VEC_length (ada_task_info_s, task_list);
733
734 printf_filtered (_(" ID TID P-ID Pri State Name\n"));
735
736 for (taskno = 1; taskno <= nb_tasks; taskno++)
737 short_task_info (taskno);
738}
739
740/* Print a detailed description of the Ada task whose ID is TASKNO_STR. */
741
742static void
743info_task (char *taskno_str, int from_tty)
744{
745 const int taskno = value_as_long (parse_and_eval (taskno_str));
746 struct ada_task_info *task_info;
747 int parent_taskno = 0;
748
749 if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, task_list))
750 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
751 "see the IDs of currently known tasks"), taskno);
752 task_info = VEC_index (ada_task_info_s, task_list, taskno - 1);
753
754 /* Print the Ada task ID. */
755 printf_filtered (_("Ada Task: %s\n"),
756 paddress (target_gdbarch, task_info->task_id));
757
758 /* Print the name of the task. */
759 if (task_info->name[0] != '\0')
760 printf_filtered (_("Name: %s\n"), task_info->name);
761 else
762 printf_filtered (_("<no name>\n"));
763
764 /* Print the TID and LWP. */
765 printf_filtered (_("Thread: %#lx\n"), ptid_get_tid (task_info->ptid));
766 printf_filtered (_("LWP: %#lx\n"), ptid_get_lwp (task_info->ptid));
767
768 /* Print who is the parent (if any). */
769 if (task_info->parent != 0)
770 parent_taskno = get_task_number_from_id (task_info->parent);
771 if (parent_taskno)
772 {
773 struct ada_task_info *parent =
774 VEC_index (ada_task_info_s, task_list, parent_taskno - 1);
775
776 printf_filtered (_("Parent: %d"), parent_taskno);
777 if (parent->name[0] != '\0')
778 printf_filtered (" (%s)", parent->name);
779 printf_filtered ("\n");
780 }
781 else
782 printf_filtered (_("No parent\n"));
783
784 /* Print the base priority. */
785 printf_filtered (_("Base Priority: %d\n"), task_info->priority);
786
787 /* print the task current state. */
788 {
789 int target_taskno = 0;
790
791 if (task_info->caller_task)
792 {
793 target_taskno = get_task_number_from_id (task_info->caller_task);
794 printf_filtered (_("State: Accepting rendezvous with %d"),
795 target_taskno);
796 }
797 else if (task_info->state == Entry_Caller_Sleep && task_info->called_task)
798 {
799 target_taskno = get_task_number_from_id (task_info->called_task);
800 printf_filtered (_("State: Waiting on task %d's entry"),
801 target_taskno);
802 }
803 else
804 printf_filtered (_("State: %s"), _(long_task_states[task_info->state]));
805
806 if (target_taskno)
807 {
808 struct ada_task_info *target_task_info =
809 VEC_index (ada_task_info_s, task_list, target_taskno - 1);
810
811 if (target_task_info->name[0] != '\0')
812 printf_filtered (" (%s)", target_task_info->name);
813 }
814
815 printf_filtered ("\n");
816 }
817}
818
819/* If ARG is empty or null, then print a list of all Ada tasks.
820 Otherwise, print detailed information about the task whose ID
821 is ARG.
822
823 Does nothing if the program doesn't use Ada tasking. */
824
825static void
826info_tasks_command (char *arg, int from_tty)
827{
828 const int task_list_built = ada_build_task_list (1);
829
830 if (!task_list_built)
831 return;
832
833 if (arg == NULL || *arg == '\0')
834 info_tasks (from_tty);
835 else
836 info_task (arg, from_tty);
837}
838
839/* Print a message telling the user id of the current task.
840 This function assumes that tasking is in use in the inferior. */
841
842static void
843display_current_task_id (void)
844{
845 const int current_task = ada_get_task_number (inferior_ptid);
846
847 if (current_task == 0)
848 printf_filtered (_("[Current task is unknown]\n"));
849 else
850 printf_filtered (_("[Current task is %d]\n"), current_task);
851}
852
853/* Parse and evaluate TIDSTR into a task id, and try to switch to
854 that task. Print an error message if the task switch failed. */
855
856static void
857task_command_1 (char *taskno_str, int from_tty)
858{
859 const int taskno = value_as_long (parse_and_eval (taskno_str));
860 struct ada_task_info *task_info;
861
862 if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, task_list))
863 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
864 "see the IDs of currently known tasks"), taskno);
865 task_info = VEC_index (ada_task_info_s, task_list, taskno - 1);
866
867 if (!ada_task_is_alive (task_info))
868 error (_("Cannot switch to task %d: Task is no longer running"), taskno);
869
870 /* On some platforms, the thread list is not updated until the user
871 performs a thread-related operation (by using the "info threads"
872 command, for instance). So this thread list may not be up to date
873 when the user attempts this task switch. Since we cannot switch
874 to the thread associated to our task if GDB does not know about
875 that thread, we need to make sure that any new threads gets added
876 to the thread list. */
877 target_find_new_threads ();
878
879 switch_to_thread (task_info->ptid);
880 ada_find_printable_frame (get_selected_frame (NULL));
881 printf_filtered (_("[Switching to task %d]\n"), taskno);
882 print_stack_frame (get_selected_frame (NULL),
883 frame_relative_level (get_selected_frame (NULL)), 1);
884}
885
886
887/* Print the ID of the current task if TASKNO_STR is empty or NULL.
888 Otherwise, switch to the task indicated by TASKNO_STR. */
889
890static void
891task_command (char *taskno_str, int from_tty)
892{
893 const int task_list_built = ada_build_task_list (1);
894
895 if (!task_list_built)
896 return;
897
898 if (taskno_str == NULL || taskno_str[0] == '\0')
899 display_current_task_id ();
900 else
901 {
902 /* Task switching in core files doesn't work, either because:
903 1. Thread support is not implemented with core files
904 2. Thread support is implemented, but the thread IDs created
905 after having read the core file are not the same as the ones
906 that were used during the program life, before the crash.
907 As a consequence, there is no longer a way for the debugger
908 to find the associated thead ID of any given Ada task.
909 So, instead of attempting a task switch without giving the user
910 any clue as to what might have happened, just error-out with
911 a message explaining that this feature is not supported. */
912 if (!target_has_execution)
913 error (_("\
914Task switching not supported when debugging from core files\n\
915(use thread support instead)"));
916 task_command_1 (taskno_str, from_tty);
917 }
918}
919
920/* Indicate that the task list may have changed, so invalidate the cache. */
921
922static void
923ada_task_list_changed (void)
924{
925 stale_task_list_p = 1;
926}
927
928/* The 'normal_stop' observer notification callback. */
929
930static void
931ada_normal_stop_observer (struct bpstats *unused_args, int unused_args2)
932{
933 /* The inferior has been resumed, and just stopped. This means that
934 our task_list needs to be recomputed before it can be used again. */
935 ada_task_list_changed ();
936}
937
938/* A routine to be called when the objfiles have changed. */
939
940static void
941ada_new_objfile_observer (struct objfile *objfile)
942{
943 /* Invalidate all cached data that were extracted from an objfile. */
944
945 atcb_type = NULL;
946 atcb_common_type = NULL;
947 atcb_ll_type = NULL;
948 atcb_call_type = NULL;
949
950 ada_tasks_check_symbol_table = 1;
951}
952
953/* Provide a prototype to silence -Wmissing-prototypes. */
954extern initialize_file_ftype _initialize_tasks;
955
956void
957_initialize_tasks (void)
958{
959 /* Attach various observers. */
960 observer_attach_normal_stop (ada_normal_stop_observer);
961 observer_attach_new_objfile (ada_new_objfile_observer);
962
963 /* Some new commands provided by this module. */
964 add_info ("tasks", info_tasks_command,
965 _("Provide information about all known Ada tasks"));
966 add_cmd ("task", class_run, task_command,
967 _("Use this command to switch between Ada tasks.\n\
968Without argument, this command simply prints the current task ID"),
969 &cmdlist);
970}
971