GDB (xrefs)

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