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