gdb vendor branch: Bring in additional source files
[dragonfly.git] / contrib / gdb-7 / gdb / ada-tasks.c
CommitLineData
a45ae5f8
JM
1/* Copyright (C) 1992-1994, 1997-2000, 2003-2005, 2007-2012 Free
2 Software Foundation, Inc.
5796c8dc
SS
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"
a45ae5f8
JM
27#include "progspace.h"
28#include "objfiles.h"
5796c8dc
SS
29
30/* The name of the array in the GNAT runtime where the Ada Task Control
31 Block of each task is stored. */
32#define KNOWN_TASKS_NAME "system__tasking__debug__known_tasks"
33
c50c785c 34/* The maximum number of tasks known to the Ada runtime. */
5796c8dc
SS
35static const int MAX_NUMBER_OF_KNOWN_TASKS = 1000;
36
a45ae5f8
JM
37/* The name of the variable in the GNAT runtime where the head of a task
38 chain is saved. This is an alternate mechanism to find the list of known
39 tasks. */
40#define KNOWN_TASKS_LIST "system__tasking__debug__first_task"
41
5796c8dc
SS
42enum task_states
43{
44 Unactivated,
45 Runnable,
46 Terminated,
47 Activator_Sleep,
48 Acceptor_Sleep,
49 Entry_Caller_Sleep,
50 Async_Select_Sleep,
51 Delay_Sleep,
52 Master_Completion_Sleep,
53 Master_Phase_2_Sleep,
54 Interrupt_Server_Idle_Sleep,
55 Interrupt_Server_Blocked_Interrupt_Sleep,
56 Timer_Server_Sleep,
57 AST_Server_Sleep,
58 Asynchronous_Hold,
59 Interrupt_Server_Blocked_On_Event_Flag,
60 Activating,
61 Acceptor_Delay_Sleep
62};
63
64/* A short description corresponding to each possible task state. */
65static const char *task_states[] = {
66 N_("Unactivated"),
67 N_("Runnable"),
68 N_("Terminated"),
69 N_("Child Activation Wait"),
70 N_("Accept or Select Term"),
71 N_("Waiting on entry call"),
72 N_("Async Select Wait"),
73 N_("Delay Sleep"),
74 N_("Child Termination Wait"),
75 N_("Wait Child in Term Alt"),
76 "",
77 "",
78 "",
79 "",
80 N_("Asynchronous Hold"),
81 "",
82 N_("Activating"),
83 N_("Selective Wait")
84};
85
86/* A longer description corresponding to each possible task state. */
87static const char *long_task_states[] = {
88 N_("Unactivated"),
89 N_("Runnable"),
90 N_("Terminated"),
91 N_("Waiting for child activation"),
92 N_("Blocked in accept or select with terminate"),
93 N_("Waiting on entry call"),
94 N_("Asynchronous Selective Wait"),
95 N_("Delay Sleep"),
96 N_("Waiting for children termination"),
97 N_("Waiting for children in terminate alternative"),
98 "",
99 "",
100 "",
101 "",
102 N_("Asynchronous Hold"),
103 "",
104 N_("Activating"),
105 N_("Blocked in selective wait statement")
106};
107
108/* The index of certain important fields in the Ada Task Control Block
109 record and sub-records. */
110
a45ae5f8 111struct atcb_fieldnos
5796c8dc
SS
112{
113 /* Fields in record Ada_Task_Control_Block. */
114 int common;
115 int entry_calls;
116 int atc_nesting_level;
117
118 /* Fields in record Common_ATCB. */
119 int state;
120 int parent;
121 int priority;
122 int image;
123 int image_len; /* This field may be missing. */
a45ae5f8 124 int activation_link;
5796c8dc
SS
125 int call;
126 int ll;
127
128 /* Fields in Task_Primitives.Private_Data. */
129 int ll_thread;
130 int ll_lwp; /* This field may be missing. */
131
132 /* Fields in Common_ATCB.Call.all. */
133 int call_self;
134};
135
a45ae5f8 136/* This module's per-program-space data. */
5796c8dc 137
a45ae5f8
JM
138struct ada_tasks_pspace_data
139{
140 /* Nonzero if the data has been initialized. If set to zero,
141 it means that the data has either not been initialized, or
142 has potentially become stale. */
143 int initialized_p;
5796c8dc 144
a45ae5f8
JM
145 /* The ATCB record type. */
146 struct type *atcb_type;
147
148 /* The ATCB "Common" component type. */
149 struct type *atcb_common_type;
150
151 /* The type of the "ll" field, from the atcb_common_type. */
152 struct type *atcb_ll_type;
153
154 /* The type of the "call" field, from the atcb_common_type. */
155 struct type *atcb_call_type;
156
157 /* The index of various fields in the ATCB record and sub-records. */
158 struct atcb_fieldnos atcb_fieldno;
159};
160
161/* Key to our per-program-space data. */
162static const struct program_space_data *ada_tasks_pspace_data_handle;
5796c8dc 163
5796c8dc
SS
164typedef struct ada_task_info ada_task_info_s;
165DEF_VEC_O(ada_task_info_s);
5796c8dc 166
a45ae5f8
JM
167/* The kind of data structure used by the runtime to store the list
168 of Ada tasks. */
169
170enum ada_known_tasks_kind
171{
172 /* Use this value when we haven't determined which kind of structure
173 is being used, or when we need to recompute it.
174
175 We set the value of this enumerate to zero on purpose: This allows
176 us to use this enumerate in a structure where setting all fields
177 to zero will result in this kind being set to unknown. */
178 ADA_TASKS_UNKNOWN = 0,
179
180 /* This value means that we did not find any task list. Unless
181 there is a bug somewhere, this means that the inferior does not
182 use tasking. */
183 ADA_TASKS_NOT_FOUND,
184
185 /* This value means that the task list is stored as an array.
186 This is the usual method, as it causes very little overhead.
187 But this method is not always used, as it does use a certain
188 amount of memory, which might be scarse in certain environments. */
189 ADA_TASKS_ARRAY,
190
191 /* This value means that the task list is stored as a linked list.
192 This has more runtime overhead than the array approach, but
193 also require less memory when the number of tasks is small. */
194 ADA_TASKS_LIST,
195};
196
197/* This module's per-inferior data. */
198
199struct ada_tasks_inferior_data
200{
201 /* The type of data structure used by the runtime to store
202 the list of Ada tasks. The value of this field influences
203 the interpretation of the known_tasks_addr field below:
204 - ADA_TASKS_UNKNOWN: The value of known_tasks_addr hasn't
205 been determined yet;
206 - ADA_TASKS_NOT_FOUND: The program probably does not use tasking
207 and the known_tasks_addr is irrelevant;
208 - ADA_TASKS_ARRAY: The known_tasks is an array;
209 - ADA_TASKS_LIST: The known_tasks is a list. */
210 enum ada_known_tasks_kind known_tasks_kind;
211
212 /* The address of the known_tasks structure. This is where
213 the runtime stores the information for all Ada tasks.
214 The interpretation of this field depends on KNOWN_TASKS_KIND
215 above. */
216 CORE_ADDR known_tasks_addr;
217
218 /* When nonzero, this flag indicates that the task_list field
219 below is up to date. When set to zero, the list has either
220 not been initialized, or has potentially become stale. */
221 int task_list_valid_p;
222
223 /* The list of Ada tasks.
224
225 Note: To each task we associate a number that the user can use to
226 reference it - this number is printed beside each task in the tasks
227 info listing displayed by "info tasks". This number is equal to
228 its index in the vector + 1. Reciprocally, to compute the index
229 of a task in the vector, we need to substract 1 from its number. */
230 VEC(ada_task_info_s) *task_list;
231};
232
233/* Key to our per-inferior data. */
234static const struct inferior_data *ada_tasks_inferior_data_handle;
235
236/* Return the ada-tasks module's data for the given program space (PSPACE).
237 If none is found, add a zero'ed one now.
238
239 This function always returns a valid object. */
240
241static struct ada_tasks_pspace_data *
242get_ada_tasks_pspace_data (struct program_space *pspace)
243{
244 struct ada_tasks_pspace_data *data;
245
246 data = program_space_data (pspace, ada_tasks_pspace_data_handle);
247 if (data == NULL)
248 {
249 data = XZALLOC (struct ada_tasks_pspace_data);
250 set_program_space_data (pspace, ada_tasks_pspace_data_handle, data);
251 }
252
253 return data;
254}
255
256/* Return the ada-tasks module's data for the given inferior (INF).
257 If none is found, add a zero'ed one now.
258
259 This function always returns a valid object.
260
261 Note that we could use an observer of the inferior-created event
262 to make sure that the ada-tasks per-inferior data always exists.
263 But we prefered this approach, as it avoids this entirely as long
264 as the user does not use any of the tasking features. This is
265 quite possible, particularly in the case where the inferior does
266 not use tasking. */
267
268static struct ada_tasks_inferior_data *
269get_ada_tasks_inferior_data (struct inferior *inf)
270{
271 struct ada_tasks_inferior_data *data;
272
273 data = inferior_data (inf, ada_tasks_inferior_data_handle);
274 if (data == NULL)
275 {
276 data = XZALLOC (struct ada_tasks_inferior_data);
277 set_inferior_data (inf, ada_tasks_inferior_data_handle, data);
278 }
279
280 return data;
281}
5796c8dc
SS
282
283/* Return the task number of the task whose ptid is PTID, or zero
284 if the task could not be found. */
285
286int
287ada_get_task_number (ptid_t ptid)
288{
289 int i;
a45ae5f8
JM
290 struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
291 struct ada_tasks_inferior_data *data;
292
293 gdb_assert (inf != NULL);
294 data = get_ada_tasks_inferior_data (inf);
5796c8dc 295
a45ae5f8
JM
296 for (i = 0; i < VEC_length (ada_task_info_s, data->task_list); i++)
297 if (ptid_equal (VEC_index (ada_task_info_s, data->task_list, i)->ptid,
298 ptid))
5796c8dc
SS
299 return i + 1;
300
301 return 0; /* No matching task found. */
302}
303
a45ae5f8
JM
304/* Return the task number of the task running in inferior INF which
305 matches TASK_ID , or zero if the task could not be found. */
5796c8dc
SS
306
307static int
a45ae5f8 308get_task_number_from_id (CORE_ADDR task_id, struct inferior *inf)
5796c8dc 309{
a45ae5f8 310 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
5796c8dc
SS
311 int i;
312
a45ae5f8 313 for (i = 0; i < VEC_length (ada_task_info_s, data->task_list); i++)
5796c8dc
SS
314 {
315 struct ada_task_info *task_info =
a45ae5f8 316 VEC_index (ada_task_info_s, data->task_list, i);
5796c8dc
SS
317
318 if (task_info->task_id == task_id)
319 return i + 1;
320 }
321
322 /* Task not found. Return 0. */
323 return 0;
324}
325
326/* Return non-zero if TASK_NUM is a valid task number. */
327
328int
329valid_task_id (int task_num)
330{
a45ae5f8
JM
331 struct ada_tasks_inferior_data *data;
332
333 ada_build_task_list ();
334 data = get_ada_tasks_inferior_data (current_inferior ());
5796c8dc 335 return (task_num > 0
a45ae5f8 336 && task_num <= VEC_length (ada_task_info_s, data->task_list));
5796c8dc
SS
337}
338
339/* Return non-zero iff the task STATE corresponds to a non-terminated
340 task state. */
341
342static int
343ada_task_is_alive (struct ada_task_info *task_info)
344{
345 return (task_info->state != Terminated);
346}
347
c50c785c
JM
348/* Call the ITERATOR function once for each Ada task that hasn't been
349 terminated yet. */
350
351void
352iterate_over_live_ada_tasks (ada_task_list_iterator_ftype *iterator)
353{
354 int i, nb_tasks;
355 struct ada_task_info *task;
a45ae5f8 356 struct ada_tasks_inferior_data *data;
c50c785c 357
a45ae5f8
JM
358 ada_build_task_list ();
359 data = get_ada_tasks_inferior_data (current_inferior ());
360 nb_tasks = VEC_length (ada_task_info_s, data->task_list);
c50c785c
JM
361
362 for (i = 0; i < nb_tasks; i++)
363 {
a45ae5f8 364 task = VEC_index (ada_task_info_s, data->task_list, i);
c50c785c
JM
365 if (!ada_task_is_alive (task))
366 continue;
367 iterator (task);
368 }
369}
370
5796c8dc
SS
371/* Extract the contents of the value as a string whose length is LENGTH,
372 and store the result in DEST. */
373
374static void
375value_as_string (char *dest, struct value *val, int length)
376{
377 memcpy (dest, value_contents (val), length);
378 dest[length] = '\0';
379}
380
381/* Extract the string image from the fat string corresponding to VAL,
382 and store it in DEST. If the string length is greater than MAX_LEN,
383 then truncate the result to the first MAX_LEN characters of the fat
384 string. */
385
386static void
387read_fat_string_value (char *dest, struct value *val, int max_len)
388{
389 struct value *array_val;
390 struct value *bounds_val;
391 int len;
392
393 /* The following variables are made static to avoid recomputing them
394 each time this function is called. */
395 static int initialize_fieldnos = 1;
396 static int array_fieldno;
397 static int bounds_fieldno;
398 static int upper_bound_fieldno;
399
400 /* Get the index of the fields that we will need to read in order
401 to extract the string from the fat string. */
402 if (initialize_fieldnos)
403 {
404 struct type *type = value_type (val);
405 struct type *bounds_type;
406
407 array_fieldno = ada_get_field_index (type, "P_ARRAY", 0);
408 bounds_fieldno = ada_get_field_index (type, "P_BOUNDS", 0);
409
410 bounds_type = TYPE_FIELD_TYPE (type, bounds_fieldno);
411 if (TYPE_CODE (bounds_type) == TYPE_CODE_PTR)
412 bounds_type = TYPE_TARGET_TYPE (bounds_type);
413 if (TYPE_CODE (bounds_type) != TYPE_CODE_STRUCT)
414 error (_("Unknown task name format. Aborting"));
415 upper_bound_fieldno = ada_get_field_index (bounds_type, "UB0", 0);
416
417 initialize_fieldnos = 0;
418 }
419
420 /* Get the size of the task image by checking the value of the bounds.
421 The lower bound is always 1, so we only need to read the upper bound. */
422 bounds_val = value_ind (value_field (val, bounds_fieldno));
423 len = value_as_long (value_field (bounds_val, upper_bound_fieldno));
424
425 /* Make sure that we do not read more than max_len characters... */
426 if (len > max_len)
427 len = max_len;
428
429 /* Extract LEN characters from the fat string. */
430 array_val = value_ind (value_field (val, array_fieldno));
431 read_memory (value_address (array_val), dest, len);
432
433 /* Add the NUL character to close the string. */
434 dest[len] = '\0';
435}
436
5796c8dc
SS
437/* Get from the debugging information the type description of all types
438 related to the Ada Task Control Block that will be needed in order to
439 read the list of known tasks in the Ada runtime. Also return the
440 associated ATCB_FIELDNOS.
441
442 Error handling: Any data missing from the debugging info will cause
443 an error to be raised, and none of the return values to be set.
444 Users of this function can depend on the fact that all or none of the
445 return values will be set. */
446
447static void
a45ae5f8 448get_tcb_types_info (void)
5796c8dc
SS
449{
450 struct type *type;
451 struct type *common_type;
452 struct type *ll_type;
453 struct type *call_type;
a45ae5f8
JM
454 struct atcb_fieldnos fieldnos;
455 struct ada_tasks_pspace_data *pspace_data;
5796c8dc
SS
456
457 const char *atcb_name = "system__tasking__ada_task_control_block___XVE";
458 const char *atcb_name_fixed = "system__tasking__ada_task_control_block";
459 const char *common_atcb_name = "system__tasking__common_atcb";
460 const char *private_data_name = "system__task_primitives__private_data";
461 const char *entry_call_record_name = "system__tasking__entry_call_record";
462
c50c785c
JM
463 /* ATCB symbols may be found in several compilation units. As we
464 are only interested in one instance, use standard (literal,
465 C-like) lookups to get the first match. */
466
5796c8dc 467 struct symbol *atcb_sym =
c50c785c
JM
468 lookup_symbol_in_language (atcb_name, NULL, VAR_DOMAIN,
469 language_c, NULL);
5796c8dc 470 const struct symbol *common_atcb_sym =
c50c785c
JM
471 lookup_symbol_in_language (common_atcb_name, NULL, VAR_DOMAIN,
472 language_c, NULL);
5796c8dc 473 const struct symbol *private_data_sym =
c50c785c
JM
474 lookup_symbol_in_language (private_data_name, NULL, VAR_DOMAIN,
475 language_c, NULL);
5796c8dc 476 const struct symbol *entry_call_record_sym =
c50c785c
JM
477 lookup_symbol_in_language (entry_call_record_name, NULL, VAR_DOMAIN,
478 language_c, NULL);
5796c8dc
SS
479
480 if (atcb_sym == NULL || atcb_sym->type == NULL)
481 {
482 /* In Ravenscar run-time libs, the ATCB does not have a dynamic
483 size, so the symbol name differs. */
c50c785c
JM
484 atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL, VAR_DOMAIN,
485 language_c, NULL);
5796c8dc
SS
486
487 if (atcb_sym == NULL || atcb_sym->type == NULL)
488 error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
489
490 type = atcb_sym->type;
491 }
492 else
493 {
494 /* Get a static representation of the type record
495 Ada_Task_Control_Block. */
496 type = atcb_sym->type;
497 type = ada_template_to_fixed_record_type_1 (type, NULL, 0, NULL, 0);
498 }
499
500 if (common_atcb_sym == NULL || common_atcb_sym->type == NULL)
501 error (_("Cannot find Common_ATCB type. Aborting"));
502 if (private_data_sym == NULL || private_data_sym->type == NULL)
503 error (_("Cannot find Private_Data type. Aborting"));
504 if (entry_call_record_sym == NULL || entry_call_record_sym->type == NULL)
505 error (_("Cannot find Entry_Call_Record type. Aborting"));
506
507 /* Get the type for Ada_Task_Control_Block.Common. */
508 common_type = common_atcb_sym->type;
509
510 /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL. */
511 ll_type = private_data_sym->type;
512
513 /* Get the type for Common_ATCB.Call.all. */
514 call_type = entry_call_record_sym->type;
515
516 /* Get the field indices. */
517 fieldnos.common = ada_get_field_index (type, "common", 0);
518 fieldnos.entry_calls = ada_get_field_index (type, "entry_calls", 1);
519 fieldnos.atc_nesting_level =
520 ada_get_field_index (type, "atc_nesting_level", 1);
521 fieldnos.state = ada_get_field_index (common_type, "state", 0);
522 fieldnos.parent = ada_get_field_index (common_type, "parent", 1);
523 fieldnos.priority = ada_get_field_index (common_type, "base_priority", 0);
524 fieldnos.image = ada_get_field_index (common_type, "task_image", 1);
525 fieldnos.image_len = ada_get_field_index (common_type, "task_image_len", 1);
a45ae5f8
JM
526 fieldnos.activation_link = ada_get_field_index (common_type,
527 "activation_link", 1);
5796c8dc
SS
528 fieldnos.call = ada_get_field_index (common_type, "call", 1);
529 fieldnos.ll = ada_get_field_index (common_type, "ll", 0);
530 fieldnos.ll_thread = ada_get_field_index (ll_type, "thread", 0);
531 fieldnos.ll_lwp = ada_get_field_index (ll_type, "lwp", 1);
532 fieldnos.call_self = ada_get_field_index (call_type, "self", 0);
533
534 /* On certain platforms such as x86-windows, the "lwp" field has been
535 named "thread_id". This field will likely be renamed in the future,
536 but we need to support both possibilities to avoid an unnecessary
537 dependency on a recent compiler. We therefore try locating the
538 "thread_id" field in place of the "lwp" field if we did not find
539 the latter. */
540 if (fieldnos.ll_lwp < 0)
541 fieldnos.ll_lwp = ada_get_field_index (ll_type, "thread_id", 1);
542
543 /* Set all the out parameters all at once, now that we are certain
544 that there are no potential error() anymore. */
a45ae5f8
JM
545 pspace_data = get_ada_tasks_pspace_data (current_program_space);
546 pspace_data->initialized_p = 1;
547 pspace_data->atcb_type = type;
548 pspace_data->atcb_common_type = common_type;
549 pspace_data->atcb_ll_type = ll_type;
550 pspace_data->atcb_call_type = call_type;
551 pspace_data->atcb_fieldno = fieldnos;
5796c8dc
SS
552}
553
554/* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
555 component of its ATCB record. This PTID needs to match the PTID used
556 by the thread layer. */
557
558static ptid_t
559ptid_from_atcb_common (struct value *common_value)
560{
561 long thread = 0;
562 CORE_ADDR lwp = 0;
563 struct value *ll_value;
564 ptid_t ptid;
a45ae5f8
JM
565 const struct ada_tasks_pspace_data *pspace_data
566 = get_ada_tasks_pspace_data (current_program_space);
5796c8dc 567
a45ae5f8 568 ll_value = value_field (common_value, pspace_data->atcb_fieldno.ll);
5796c8dc 569
a45ae5f8
JM
570 if (pspace_data->atcb_fieldno.ll_lwp >= 0)
571 lwp = value_as_address (value_field (ll_value,
572 pspace_data->atcb_fieldno.ll_lwp));
573 thread = value_as_long (value_field (ll_value,
574 pspace_data->atcb_fieldno.ll_thread));
5796c8dc
SS
575
576 ptid = target_get_ada_task_ptid (lwp, thread);
577
578 return ptid;
579}
580
581/* Read the ATCB data of a given task given its TASK_ID (which is in practice
582 the address of its assocated ATCB record), and store the result inside
583 TASK_INFO. */
584
585static void
586read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
587{
588 struct value *tcb_value;
589 struct value *common_value;
590 struct value *atc_nesting_level_value;
591 struct value *entry_calls_value;
592 struct value *entry_calls_value_element;
593 int called_task_fieldno = -1;
a45ae5f8
JM
594 static const char ravenscar_task_name[] = "Ravenscar task";
595 const struct ada_tasks_pspace_data *pspace_data
596 = get_ada_tasks_pspace_data (current_program_space);
5796c8dc 597
a45ae5f8
JM
598 if (!pspace_data->initialized_p)
599 get_tcb_types_info ();
5796c8dc 600
a45ae5f8
JM
601 tcb_value = value_from_contents_and_address (pspace_data->atcb_type,
602 NULL, task_id);
603 common_value = value_field (tcb_value, pspace_data->atcb_fieldno.common);
5796c8dc
SS
604
605 /* Fill in the task_id. */
606
607 task_info->task_id = task_id;
608
609 /* Compute the name of the task.
610
611 Depending on the GNAT version used, the task image is either a fat
612 string, or a thin array of characters. Older versions of GNAT used
613 to use fat strings, and therefore did not need an extra field in
c50c785c 614 the ATCB to store the string length. For efficiency reasons, newer
5796c8dc
SS
615 versions of GNAT replaced the fat string by a static buffer, but this
616 also required the addition of a new field named "Image_Len" containing
c50c785c 617 the length of the task name. The method used to extract the task name
5796c8dc
SS
618 is selected depending on the existence of this field.
619
620 In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
c50c785c 621 we may want to get it from the first user frame of the stack. For now,
5796c8dc
SS
622 we just give a dummy name. */
623
a45ae5f8 624 if (pspace_data->atcb_fieldno.image_len == -1)
5796c8dc 625 {
a45ae5f8 626 if (pspace_data->atcb_fieldno.image >= 0)
5796c8dc 627 read_fat_string_value (task_info->name,
a45ae5f8
JM
628 value_field (common_value,
629 pspace_data->atcb_fieldno.image),
5796c8dc
SS
630 sizeof (task_info->name) - 1);
631 else
a45ae5f8
JM
632 {
633 struct minimal_symbol *msym;
634
635 msym = lookup_minimal_symbol_by_pc (task_id);
636 if (msym)
637 {
638 const char *full_name = SYMBOL_LINKAGE_NAME (msym);
639 const char *task_name = full_name;
640 const char *p;
641
642 /* Strip the prefix. */
643 for (p = full_name; *p; p++)
644 if (p[0] == '_' && p[1] == '_')
645 task_name = p + 2;
646
647 /* Copy the task name. */
648 strncpy (task_info->name, task_name, sizeof (task_info->name));
649 task_info->name[sizeof (task_info->name) - 1] = 0;
650 }
651 else
652 {
653 /* No symbol found. Use a default name. */
654 strcpy (task_info->name, ravenscar_task_name);
655 }
656 }
5796c8dc
SS
657 }
658 else
659 {
a45ae5f8
JM
660 int len = value_as_long
661 (value_field (common_value,
662 pspace_data->atcb_fieldno.image_len));
5796c8dc
SS
663
664 value_as_string (task_info->name,
a45ae5f8
JM
665 value_field (common_value,
666 pspace_data->atcb_fieldno.image),
667 len);
5796c8dc
SS
668 }
669
670 /* Compute the task state and priority. */
671
a45ae5f8
JM
672 task_info->state =
673 value_as_long (value_field (common_value,
674 pspace_data->atcb_fieldno.state));
5796c8dc 675 task_info->priority =
a45ae5f8
JM
676 value_as_long (value_field (common_value,
677 pspace_data->atcb_fieldno.priority));
5796c8dc
SS
678
679 /* If the ATCB contains some information about the parent task,
680 then compute it as well. Otherwise, zero. */
681
a45ae5f8 682 if (pspace_data->atcb_fieldno.parent >= 0)
5796c8dc 683 task_info->parent =
a45ae5f8
JM
684 value_as_address (value_field (common_value,
685 pspace_data->atcb_fieldno.parent));
5796c8dc
SS
686 else
687 task_info->parent = 0;
688
689
690 /* If the ATCB contains some information about entry calls, then
691 compute the "called_task" as well. Otherwise, zero. */
692
a45ae5f8
JM
693 if (pspace_data->atcb_fieldno.atc_nesting_level > 0
694 && pspace_data->atcb_fieldno.entry_calls > 0)
5796c8dc
SS
695 {
696 /* Let My_ATCB be the Ada task control block of a task calling the
697 entry of another task; then the Task_Id of the called task is
698 in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
a45ae5f8
JM
699 atc_nesting_level_value =
700 value_field (tcb_value, pspace_data->atcb_fieldno.atc_nesting_level);
5796c8dc 701 entry_calls_value =
a45ae5f8
JM
702 ada_coerce_to_simple_array_ptr
703 (value_field (tcb_value, pspace_data->atcb_fieldno.entry_calls));
5796c8dc
SS
704 entry_calls_value_element =
705 value_subscript (entry_calls_value,
706 value_as_long (atc_nesting_level_value));
707 called_task_fieldno =
708 ada_get_field_index (value_type (entry_calls_value_element),
709 "called_task", 0);
710 task_info->called_task =
711 value_as_address (value_field (entry_calls_value_element,
712 called_task_fieldno));
713 }
714 else
715 {
716 task_info->called_task = 0;
717 }
718
719 /* If the ATCB cotnains some information about RV callers,
720 then compute the "caller_task". Otherwise, zero. */
721
722 task_info->caller_task = 0;
a45ae5f8 723 if (pspace_data->atcb_fieldno.call >= 0)
5796c8dc
SS
724 {
725 /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
726 If Common_ATCB.Call is null, then there is no caller. */
727 const CORE_ADDR call =
a45ae5f8
JM
728 value_as_address (value_field (common_value,
729 pspace_data->atcb_fieldno.call));
5796c8dc
SS
730 struct value *call_val;
731
732 if (call != 0)
733 {
734 call_val =
a45ae5f8
JM
735 value_from_contents_and_address (pspace_data->atcb_call_type,
736 NULL, call);
5796c8dc 737 task_info->caller_task =
a45ae5f8
JM
738 value_as_address
739 (value_field (call_val, pspace_data->atcb_fieldno.call_self));
5796c8dc
SS
740 }
741 }
742
c50c785c
JM
743 /* And finally, compute the task ptid. Note that there are situations
744 where this cannot be determined:
745 - The task is no longer alive - the ptid is irrelevant;
746 - We are debugging a core file - the thread is not always
747 completely preserved for us to link back a task to its
748 underlying thread. Since we do not support task switching
749 when debugging core files anyway, we don't need to compute
750 that task ptid.
751 In either case, we don't need that ptid, and it is just good enough
752 to set it to null_ptid. */
753
754 if (target_has_execution && ada_task_is_alive (task_info))
5796c8dc
SS
755 task_info->ptid = ptid_from_atcb_common (common_value);
756 else
757 task_info->ptid = null_ptid;
758}
759
760/* Read the ATCB info of the given task (identified by TASK_ID), and
a45ae5f8 761 add the result to the given inferior's TASK_LIST. */
5796c8dc
SS
762
763static void
a45ae5f8 764add_ada_task (CORE_ADDR task_id, struct inferior *inf)
5796c8dc
SS
765{
766 struct ada_task_info task_info;
a45ae5f8 767 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
5796c8dc
SS
768
769 read_atcb (task_id, &task_info);
a45ae5f8 770 VEC_safe_push (ada_task_info_s, data->task_list, &task_info);
5796c8dc
SS
771}
772
773/* Read the Known_Tasks array from the inferior memory, and store
a45ae5f8 774 it in the current inferior's TASK_LIST. Return non-zero upon success. */
5796c8dc
SS
775
776static int
a45ae5f8 777read_known_tasks_array (CORE_ADDR known_tasks_addr)
5796c8dc
SS
778{
779 const int target_ptr_byte =
780 gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT;
5796c8dc
SS
781 const int known_tasks_size = target_ptr_byte * MAX_NUMBER_OF_KNOWN_TASKS;
782 gdb_byte *known_tasks = alloca (known_tasks_size);
783 int i;
784
a45ae5f8
JM
785 /* Build a new list by reading the ATCBs from the Known_Tasks array
786 in the Ada runtime. */
5796c8dc
SS
787 read_memory (known_tasks_addr, known_tasks, known_tasks_size);
788 for (i = 0; i < MAX_NUMBER_OF_KNOWN_TASKS; i++)
789 {
790 struct type *data_ptr_type =
791 builtin_type (target_gdbarch)->builtin_data_ptr;
792 CORE_ADDR task_id =
793 extract_typed_address (known_tasks + i * target_ptr_byte,
794 data_ptr_type);
795
796 if (task_id != 0)
a45ae5f8 797 add_ada_task (task_id, current_inferior ());
5796c8dc
SS
798 }
799
5796c8dc
SS
800 return 1;
801}
802
a45ae5f8
JM
803/* Read the known tasks from the inferior memory, and store it in
804 the current inferior's TASK_LIST. Return non-zero upon success. */
5796c8dc 805
a45ae5f8
JM
806static int
807read_known_tasks_list (CORE_ADDR known_tasks_addr)
5796c8dc 808{
a45ae5f8
JM
809 const int target_ptr_byte =
810 gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT;
811 gdb_byte *known_tasks = alloca (target_ptr_byte);
812 struct type *data_ptr_type =
813 builtin_type (target_gdbarch)->builtin_data_ptr;
814 CORE_ADDR task_id;
815 const struct ada_tasks_pspace_data *pspace_data
816 = get_ada_tasks_pspace_data (current_program_space);
817
818 /* Sanity check. */
819 if (pspace_data->atcb_fieldno.activation_link < 0)
820 return 0;
5796c8dc 821
a45ae5f8
JM
822 /* Build a new list by reading the ATCBs. Read head of the list. */
823 read_memory (known_tasks_addr, known_tasks, target_ptr_byte);
824 task_id = extract_typed_address (known_tasks, data_ptr_type);
825 while (task_id != 0)
5796c8dc 826 {
a45ae5f8
JM
827 struct value *tcb_value;
828 struct value *common_value;
829
830 add_ada_task (task_id, current_inferior ());
831
832 /* Read the chain. */
833 tcb_value = value_from_contents_and_address (pspace_data->atcb_type,
834 NULL, task_id);
835 common_value = value_field (tcb_value, pspace_data->atcb_fieldno.common);
836 task_id = value_as_address
837 (value_field (common_value,
838 pspace_data->atcb_fieldno.activation_link));
5796c8dc
SS
839 }
840
841 return 1;
842}
843
a45ae5f8
JM
844/* Return the address of the variable NAME that contains all the known
845 tasks maintained in the Ada Runtime. Return NULL if the variable
846 could not be found, meaning that the inferior program probably does
847 not use tasking. */
848
849static CORE_ADDR
850get_known_tasks_addr (const char *name)
851{
852 struct minimal_symbol *msym;
853
854 msym = lookup_minimal_symbol (name, NULL, NULL);
855 if (msym == NULL)
856 return 0;
857
858 return SYMBOL_VALUE_ADDRESS (msym);
859}
860
861/* Assuming DATA is the ada-tasks' data for the current inferior,
862 set the known_tasks_kind and known_tasks_addr fields. Do nothing
863 if those fields are already set and still up to date. */
5796c8dc
SS
864
865static void
a45ae5f8 866ada_set_current_inferior_known_tasks_addr (struct ada_tasks_inferior_data *data)
5796c8dc 867{
a45ae5f8 868 CORE_ADDR known_tasks_addr;
5796c8dc 869
a45ae5f8
JM
870 if (data->known_tasks_kind != ADA_TASKS_UNKNOWN)
871 return;
5796c8dc 872
a45ae5f8
JM
873 known_tasks_addr = get_known_tasks_addr (KNOWN_TASKS_NAME);
874 if (known_tasks_addr != 0)
875 {
876 data->known_tasks_kind = ADA_TASKS_ARRAY;
877 data->known_tasks_addr = known_tasks_addr;
878 return;
879 }
5796c8dc 880
a45ae5f8
JM
881 known_tasks_addr = get_known_tasks_addr (KNOWN_TASKS_LIST);
882 if (known_tasks_addr != 0)
883 {
884 data->known_tasks_kind = ADA_TASKS_LIST;
885 data->known_tasks_addr = known_tasks_addr;
886 return;
887 }
5796c8dc 888
a45ae5f8
JM
889 data->known_tasks_kind = ADA_TASKS_NOT_FOUND;
890 data->known_tasks_addr = 0;
891}
5796c8dc 892
a45ae5f8
JM
893/* Read the known tasks from the current inferior's memory, and store it
894 in the current inferior's data TASK_LIST.
895 Return non-zero upon success. */
5796c8dc 896
a45ae5f8
JM
897static int
898read_known_tasks (void)
899{
900 struct ada_tasks_inferior_data *data =
901 get_ada_tasks_inferior_data (current_inferior ());
5796c8dc 902
a45ae5f8
JM
903 /* Step 1: Clear the current list, if necessary. */
904 VEC_truncate (ada_task_info_s, data->task_list, 0);
5796c8dc 905
a45ae5f8
JM
906 /* Step 2: do the real work.
907 If the application does not use task, then no more needs to be done.
908 It is important to have the task list cleared (see above) before we
909 return, as we don't want a stale task list to be used... This can
910 happen for instance when debugging a non-multitasking program after
911 having debugged a multitasking one. */
912 ada_set_current_inferior_known_tasks_addr (data);
913 gdb_assert (data->known_tasks_kind != ADA_TASKS_UNKNOWN);
5796c8dc 914
a45ae5f8
JM
915 switch (data->known_tasks_kind)
916 {
917 case ADA_TASKS_NOT_FOUND: /* Tasking not in use in inferior. */
918 return 0;
919 case ADA_TASKS_ARRAY:
920 return read_known_tasks_array (data->known_tasks_addr);
921 case ADA_TASKS_LIST:
922 return read_known_tasks_list (data->known_tasks_addr);
923 }
924
925 /* Step 3: Set task_list_valid_p, to avoid re-reading the Known_Tasks
926 array unless needed. Then report a success. */
927 data->task_list_valid_p = 1;
928
929 return 1;
5796c8dc
SS
930}
931
a45ae5f8
JM
932/* Build the task_list by reading the Known_Tasks array from
933 the inferior, and return the number of tasks in that list
934 (zero means that the program is not using tasking at all). */
5796c8dc 935
a45ae5f8
JM
936int
937ada_build_task_list (void)
5796c8dc 938{
a45ae5f8 939 struct ada_tasks_inferior_data *data;
5796c8dc 940
a45ae5f8
JM
941 if (!target_has_stack)
942 error (_("Cannot inspect Ada tasks when program is not running"));
943
944 data = get_ada_tasks_inferior_data (current_inferior ());
945 if (!data->task_list_valid_p)
946 read_known_tasks ();
947
948 return VEC_length (ada_task_info_s, data->task_list);
5796c8dc
SS
949}
950
a45ae5f8
JM
951/* Print a table providing a short description of all Ada tasks
952 running inside inferior INF. If ARG_STR is set, it will be
953 interpreted as a task number, and the table will be limited to
954 that task only. */
955
956void
957print_ada_task_info (struct ui_out *uiout,
958 char *arg_str,
959 struct inferior *inf)
960{
961 struct ada_tasks_inferior_data *data;
962 int taskno, nb_tasks;
963 int taskno_arg = 0;
964 struct cleanup *old_chain;
965 int nb_columns;
966
967 if (ada_build_task_list () == 0)
968 {
969 ui_out_message (uiout, 0,
970 _("Your application does not use any Ada tasks.\n"));
971 return;
972 }
973
974 if (arg_str != NULL && arg_str[0] != '\0')
975 taskno_arg = value_as_long (parse_and_eval (arg_str));
976
977 if (ui_out_is_mi_like_p (uiout))
978 /* In GDB/MI mode, we want to provide the thread ID corresponding
979 to each task. This allows clients to quickly find the thread
980 associated to any task, which is helpful for commands that
981 take a --thread argument. However, in order to be able to
982 provide that thread ID, the thread list must be up to date
983 first. */
984 target_find_new_threads ();
985
986 data = get_ada_tasks_inferior_data (inf);
987
988 /* Compute the number of tasks that are going to be displayed
989 in the output. If an argument was given, there will be
990 at most 1 entry. Otherwise, there will be as many entries
991 as we have tasks. */
992 if (taskno_arg)
993 {
994 if (taskno_arg > 0
995 && taskno_arg <= VEC_length (ada_task_info_s, data->task_list))
996 nb_tasks = 1;
997 else
998 nb_tasks = 0;
999 }
1000 else
1001 nb_tasks = VEC_length (ada_task_info_s, data->task_list);
1002
1003 nb_columns = ui_out_is_mi_like_p (uiout) ? 8 : 7;
1004 old_chain = make_cleanup_ui_out_table_begin_end (uiout, nb_columns,
1005 nb_tasks, "tasks");
1006 ui_out_table_header (uiout, 1, ui_left, "current", "");
1007 ui_out_table_header (uiout, 3, ui_right, "id", "ID");
1008 ui_out_table_header (uiout, 9, ui_right, "task-id", "TID");
1009 /* The following column is provided in GDB/MI mode only because
1010 it is only really useful in that mode, and also because it
1011 allows us to keep the CLI output shorter and more compact. */
1012 if (ui_out_is_mi_like_p (uiout))
1013 ui_out_table_header (uiout, 4, ui_right, "thread-id", "");
1014 ui_out_table_header (uiout, 4, ui_right, "parent-id", "P-ID");
1015 ui_out_table_header (uiout, 3, ui_right, "priority", "Pri");
1016 ui_out_table_header (uiout, 22, ui_left, "state", "State");
1017 /* Use ui_noalign for the last column, to prevent the CLI uiout
1018 from printing an extra space at the end of each row. This
1019 is a bit of a hack, but does get the job done. */
1020 ui_out_table_header (uiout, 1, ui_noalign, "name", "Name");
1021 ui_out_table_body (uiout);
1022
1023 for (taskno = 1;
1024 taskno <= VEC_length (ada_task_info_s, data->task_list);
1025 taskno++)
1026 {
1027 const struct ada_task_info *const task_info =
1028 VEC_index (ada_task_info_s, data->task_list, taskno - 1);
1029 int parent_id;
1030 struct cleanup *chain2;
1031
1032 gdb_assert (task_info != NULL);
1033
1034 /* If the user asked for the output to be restricted
1035 to one task only, and this is not the task, skip
1036 to the next one. */
1037 if (taskno_arg && taskno != taskno_arg)
1038 continue;
1039
1040 chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1041
1042 /* Print a star if this task is the current task (or the task
1043 currently selected). */
1044 if (ptid_equal (task_info->ptid, inferior_ptid))
1045 ui_out_field_string (uiout, "current", "*");
1046 else
1047 ui_out_field_skip (uiout, "current");
1048
1049 /* Print the task number. */
1050 ui_out_field_int (uiout, "id", taskno);
1051
1052 /* Print the Task ID. */
1053 ui_out_field_fmt (uiout, "task-id", "%9lx", (long) task_info->task_id);
1054
1055 /* Print the associated Thread ID. */
1056 if (ui_out_is_mi_like_p (uiout))
1057 {
1058 const int thread_id = pid_to_thread_id (task_info->ptid);
1059
1060 if (thread_id != 0)
1061 ui_out_field_int (uiout, "thread-id", thread_id);
1062 else
1063 /* This should never happen unless there is a bug somewhere,
1064 but be resilient when that happens. */
1065 ui_out_field_skip (uiout, "thread-id");
1066 }
1067
1068 /* Print the ID of the parent task. */
1069 parent_id = get_task_number_from_id (task_info->parent, inf);
1070 if (parent_id)
1071 ui_out_field_int (uiout, "parent-id", parent_id);
1072 else
1073 ui_out_field_skip (uiout, "parent-id");
1074
1075 /* Print the base priority of the task. */
1076 ui_out_field_int (uiout, "priority", task_info->priority);
1077
1078 /* Print the task current state. */
1079 if (task_info->caller_task)
1080 ui_out_field_fmt (uiout, "state",
1081 _("Accepting RV with %-4d"),
1082 get_task_number_from_id (task_info->caller_task,
1083 inf));
1084 else if (task_info->state == Entry_Caller_Sleep
1085 && task_info->called_task)
1086 ui_out_field_fmt (uiout, "state",
1087 _("Waiting on RV with %-3d"),
1088 get_task_number_from_id (task_info->called_task,
1089 inf));
1090 else
1091 ui_out_field_string (uiout, "state", task_states[task_info->state]);
1092
1093 /* Finally, print the task name. */
1094 ui_out_field_fmt (uiout, "name",
1095 "%s",
1096 task_info->name[0] != '\0' ? task_info->name
1097 : _("<no name>"));
1098
1099 ui_out_text (uiout, "\n");
1100 do_cleanups (chain2);
1101 }
1102
1103 do_cleanups (old_chain);
1104}
1105
1106/* Print a detailed description of the Ada task whose ID is TASKNO_STR
1107 for the given inferior (INF). */
5796c8dc
SS
1108
1109static void
a45ae5f8 1110info_task (struct ui_out *uiout, char *taskno_str, struct inferior *inf)
5796c8dc
SS
1111{
1112 const int taskno = value_as_long (parse_and_eval (taskno_str));
1113 struct ada_task_info *task_info;
1114 int parent_taskno = 0;
a45ae5f8 1115 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
5796c8dc 1116
a45ae5f8
JM
1117 if (ada_build_task_list () == 0)
1118 {
1119 ui_out_message (uiout, 0,
1120 _("Your application does not use any Ada tasks.\n"));
1121 return;
1122 }
1123
1124 if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, data->task_list))
5796c8dc
SS
1125 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1126 "see the IDs of currently known tasks"), taskno);
a45ae5f8 1127 task_info = VEC_index (ada_task_info_s, data->task_list, taskno - 1);
5796c8dc
SS
1128
1129 /* Print the Ada task ID. */
1130 printf_filtered (_("Ada Task: %s\n"),
1131 paddress (target_gdbarch, task_info->task_id));
1132
1133 /* Print the name of the task. */
1134 if (task_info->name[0] != '\0')
1135 printf_filtered (_("Name: %s\n"), task_info->name);
1136 else
1137 printf_filtered (_("<no name>\n"));
1138
1139 /* Print the TID and LWP. */
1140 printf_filtered (_("Thread: %#lx\n"), ptid_get_tid (task_info->ptid));
1141 printf_filtered (_("LWP: %#lx\n"), ptid_get_lwp (task_info->ptid));
1142
1143 /* Print who is the parent (if any). */
1144 if (task_info->parent != 0)
a45ae5f8 1145 parent_taskno = get_task_number_from_id (task_info->parent, inf);
5796c8dc
SS
1146 if (parent_taskno)
1147 {
1148 struct ada_task_info *parent =
a45ae5f8 1149 VEC_index (ada_task_info_s, data->task_list, parent_taskno - 1);
5796c8dc
SS
1150
1151 printf_filtered (_("Parent: %d"), parent_taskno);
1152 if (parent->name[0] != '\0')
1153 printf_filtered (" (%s)", parent->name);
1154 printf_filtered ("\n");
1155 }
1156 else
1157 printf_filtered (_("No parent\n"));
1158
1159 /* Print the base priority. */
1160 printf_filtered (_("Base Priority: %d\n"), task_info->priority);
1161
1162 /* print the task current state. */
1163 {
1164 int target_taskno = 0;
1165
1166 if (task_info->caller_task)
1167 {
a45ae5f8 1168 target_taskno = get_task_number_from_id (task_info->caller_task, inf);
5796c8dc
SS
1169 printf_filtered (_("State: Accepting rendezvous with %d"),
1170 target_taskno);
1171 }
1172 else if (task_info->state == Entry_Caller_Sleep && task_info->called_task)
1173 {
a45ae5f8 1174 target_taskno = get_task_number_from_id (task_info->called_task, inf);
5796c8dc
SS
1175 printf_filtered (_("State: Waiting on task %d's entry"),
1176 target_taskno);
1177 }
1178 else
1179 printf_filtered (_("State: %s"), _(long_task_states[task_info->state]));
1180
1181 if (target_taskno)
1182 {
1183 struct ada_task_info *target_task_info =
a45ae5f8 1184 VEC_index (ada_task_info_s, data->task_list, target_taskno - 1);
5796c8dc
SS
1185
1186 if (target_task_info->name[0] != '\0')
1187 printf_filtered (" (%s)", target_task_info->name);
1188 }
1189
1190 printf_filtered ("\n");
1191 }
1192}
1193
1194/* If ARG is empty or null, then print a list of all Ada tasks.
1195 Otherwise, print detailed information about the task whose ID
1196 is ARG.
1197
1198 Does nothing if the program doesn't use Ada tasking. */
1199
1200static void
1201info_tasks_command (char *arg, int from_tty)
1202{
a45ae5f8 1203 struct ui_out *uiout = current_uiout;
5796c8dc
SS
1204
1205 if (arg == NULL || *arg == '\0')
a45ae5f8 1206 print_ada_task_info (uiout, NULL, current_inferior ());
5796c8dc 1207 else
a45ae5f8 1208 info_task (uiout, arg, current_inferior ());
5796c8dc
SS
1209}
1210
1211/* Print a message telling the user id of the current task.
1212 This function assumes that tasking is in use in the inferior. */
1213
1214static void
1215display_current_task_id (void)
1216{
1217 const int current_task = ada_get_task_number (inferior_ptid);
1218
1219 if (current_task == 0)
1220 printf_filtered (_("[Current task is unknown]\n"));
1221 else
1222 printf_filtered (_("[Current task is %d]\n"), current_task);
1223}
1224
1225/* Parse and evaluate TIDSTR into a task id, and try to switch to
1226 that task. Print an error message if the task switch failed. */
1227
1228static void
a45ae5f8 1229task_command_1 (char *taskno_str, int from_tty, struct inferior *inf)
5796c8dc
SS
1230{
1231 const int taskno = value_as_long (parse_and_eval (taskno_str));
1232 struct ada_task_info *task_info;
a45ae5f8 1233 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
5796c8dc 1234
a45ae5f8 1235 if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, data->task_list))
5796c8dc
SS
1236 error (_("Task ID %d not known. Use the \"info tasks\" command to\n"
1237 "see the IDs of currently known tasks"), taskno);
a45ae5f8 1238 task_info = VEC_index (ada_task_info_s, data->task_list, taskno - 1);
5796c8dc
SS
1239
1240 if (!ada_task_is_alive (task_info))
1241 error (_("Cannot switch to task %d: Task is no longer running"), taskno);
1242
1243 /* On some platforms, the thread list is not updated until the user
1244 performs a thread-related operation (by using the "info threads"
1245 command, for instance). So this thread list may not be up to date
1246 when the user attempts this task switch. Since we cannot switch
1247 to the thread associated to our task if GDB does not know about
1248 that thread, we need to make sure that any new threads gets added
1249 to the thread list. */
1250 target_find_new_threads ();
1251
cf7f2e2d
JM
1252 /* Verify that the ptid of the task we want to switch to is valid
1253 (in other words, a ptid that GDB knows about). Otherwise, we will
1254 cause an assertion failure later on, when we try to determine
1255 the ptid associated thread_info data. We should normally never
1256 encounter such an error, but the wrong ptid can actually easily be
1257 computed if target_get_ada_task_ptid has not been implemented for
1258 our target (yet). Rather than cause an assertion error in that case,
1259 it's nicer for the user to just refuse to perform the task switch. */
1260 if (!find_thread_ptid (task_info->ptid))
1261 error (_("Unable to compute thread ID for task %d.\n"
1262 "Cannot switch to this task."),
1263 taskno);
1264
5796c8dc
SS
1265 switch_to_thread (task_info->ptid);
1266 ada_find_printable_frame (get_selected_frame (NULL));
1267 printf_filtered (_("[Switching to task %d]\n"), taskno);
1268 print_stack_frame (get_selected_frame (NULL),
1269 frame_relative_level (get_selected_frame (NULL)), 1);
1270}
1271
1272
1273/* Print the ID of the current task if TASKNO_STR is empty or NULL.
1274 Otherwise, switch to the task indicated by TASKNO_STR. */
1275
1276static void
1277task_command (char *taskno_str, int from_tty)
1278{
a45ae5f8 1279 struct ui_out *uiout = current_uiout;
5796c8dc 1280
a45ae5f8
JM
1281 if (ada_build_task_list () == 0)
1282 {
1283 ui_out_message (uiout, 0,
1284 _("Your application does not use any Ada tasks.\n"));
1285 return;
1286 }
5796c8dc
SS
1287
1288 if (taskno_str == NULL || taskno_str[0] == '\0')
1289 display_current_task_id ();
1290 else
1291 {
1292 /* Task switching in core files doesn't work, either because:
1293 1. Thread support is not implemented with core files
1294 2. Thread support is implemented, but the thread IDs created
1295 after having read the core file are not the same as the ones
1296 that were used during the program life, before the crash.
1297 As a consequence, there is no longer a way for the debugger
1298 to find the associated thead ID of any given Ada task.
1299 So, instead of attempting a task switch without giving the user
1300 any clue as to what might have happened, just error-out with
1301 a message explaining that this feature is not supported. */
1302 if (!target_has_execution)
1303 error (_("\
1304Task switching not supported when debugging from core files\n\
1305(use thread support instead)"));
a45ae5f8 1306 task_command_1 (taskno_str, from_tty, current_inferior ());
5796c8dc
SS
1307 }
1308}
1309
a45ae5f8
JM
1310/* Indicate that the given inferior's task list may have changed,
1311 so invalidate the cache. */
5796c8dc
SS
1312
1313static void
a45ae5f8 1314ada_task_list_changed (struct inferior *inf)
5796c8dc 1315{
a45ae5f8
JM
1316 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
1317
1318 data->task_list_valid_p = 0;
1319}
1320
1321/* Invalidate the per-program-space data. */
1322
1323static void
1324ada_tasks_invalidate_pspace_data (struct program_space *pspace)
1325{
1326 get_ada_tasks_pspace_data (pspace)->initialized_p = 0;
1327}
1328
1329/* Invalidate the per-inferior data. */
1330
1331static void
1332ada_tasks_invalidate_inferior_data (struct inferior *inf)
1333{
1334 struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
1335
1336 data->known_tasks_kind = ADA_TASKS_UNKNOWN;
1337 data->task_list_valid_p = 0;
5796c8dc
SS
1338}
1339
1340/* The 'normal_stop' observer notification callback. */
1341
1342static void
1343ada_normal_stop_observer (struct bpstats *unused_args, int unused_args2)
1344{
1345 /* The inferior has been resumed, and just stopped. This means that
1346 our task_list needs to be recomputed before it can be used again. */
a45ae5f8 1347 ada_task_list_changed (current_inferior ());
5796c8dc
SS
1348}
1349
1350/* A routine to be called when the objfiles have changed. */
1351
1352static void
1353ada_new_objfile_observer (struct objfile *objfile)
1354{
a45ae5f8
JM
1355 struct inferior *inf;
1356
1357 /* Invalidate the relevant data in our program-space data. */
1358
1359 if (objfile == NULL)
1360 {
1361 /* All objfiles are being cleared, so we should clear all
1362 our caches for all program spaces. */
1363 struct program_space *pspace;
1364
1365 for (pspace = program_spaces; pspace != NULL; pspace = pspace->next)
1366 ada_tasks_invalidate_pspace_data (pspace);
1367 }
1368 else
1369 {
1370 /* The associated program-space data might have changed after
1371 this objfile was added. Invalidate all cached data. */
1372 ada_tasks_invalidate_pspace_data (objfile->pspace);
1373 }
5796c8dc 1374
a45ae5f8
JM
1375 /* Invalidate the per-inferior cache for all inferiors using
1376 this objfile (or, in other words, for all inferiors who have
1377 the same program-space as the objfile's program space).
1378 If all objfiles are being cleared (OBJFILE is NULL), then
1379 clear the caches for all inferiors. */
5796c8dc 1380
a45ae5f8
JM
1381 for (inf = inferior_list; inf != NULL; inf = inf->next)
1382 if (objfile == NULL || inf->pspace == objfile->pspace)
1383 ada_tasks_invalidate_inferior_data (inf);
5796c8dc
SS
1384}
1385
1386/* Provide a prototype to silence -Wmissing-prototypes. */
1387extern initialize_file_ftype _initialize_tasks;
1388
1389void
1390_initialize_tasks (void)
1391{
a45ae5f8
JM
1392 ada_tasks_pspace_data_handle = register_program_space_data ();
1393 ada_tasks_inferior_data_handle = register_inferior_data ();
1394
5796c8dc
SS
1395 /* Attach various observers. */
1396 observer_attach_normal_stop (ada_normal_stop_observer);
1397 observer_attach_new_objfile (ada_new_objfile_observer);
1398
1399 /* Some new commands provided by this module. */
1400 add_info ("tasks", info_tasks_command,
1401 _("Provide information about all known Ada tasks"));
1402 add_cmd ("task", class_run, task_command,
1403 _("Use this command to switch between Ada tasks.\n\
1404Without argument, this command simply prints the current task ID"),
1405 &cmdlist);
1406}
1407