gdb/ada-tasks.c

   1 /* Copyright (C) 1992, 1993, 1994, 1997, 1998, 1999, 2000, 2003, 2004, 2005,
   2    2007, 2008, 2009 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "defs.h"
  20 #include "observer.h"
  21 #include "gdbcmd.h"
  22 #include "target.h"
  23 #include "ada-lang.h"
  24 #include "gdbcore.h"
  25 #include "inferior.h"
  26 #include "gdbthread.h"
  27
  28 /* The name of the array in the GNAT runtime where the Ada Task Control
  29    Block of each task is stored.  */
  30 #define KNOWN_TASKS_NAME "system__tasking__debug__known_tasks"
  31
  32 /* The maximum number of tasks known to the Ada runtime */
  33 static const int MAX_NUMBER_OF_KNOWN_TASKS = 1000;
  34
  35 enum task_states
  36 {
  37   Unactivated,
  38   Runnable,
  39   Terminated,
  40   Activator_Sleep,
  41   Acceptor_Sleep,
  42   Entry_Caller_Sleep,
  43   Async_Select_Sleep,
  44   Delay_Sleep,
  45   Master_Completion_Sleep,
  46   Master_Phase_2_Sleep,
  47   Interrupt_Server_Idle_Sleep,
  48   Interrupt_Server_Blocked_Interrupt_Sleep,
  49   Timer_Server_Sleep,
  50   AST_Server_Sleep,
  51   Asynchronous_Hold,
  52   Interrupt_Server_Blocked_On_Event_Flag,
  53   Activating,
  54   Acceptor_Delay_Sleep
  55 };
  56
  57 /* A short description corresponding to each possible task state.  */
  58 static const char *task_states[] = {
  59   N_("Unactivated"),
  60   N_("Runnable"),
  61   N_("Terminated"),
  62   N_("Child Activation Wait"),
  63   N_("Accept or Select Term"),
  64   N_("Waiting on entry call"),
  65   N_("Async Select Wait"),
  66   N_("Delay Sleep"),
  67   N_("Child Termination Wait"),
  68   N_("Wait Child in Term Alt"),
  69   "",
  70   "",
  71   "",
  72   "",
  73   N_("Asynchronous Hold"),
  74   "",
  75   N_("Activating"),
  76   N_("Selective Wait")
  77 };
  78
  79 /* A longer description corresponding to each possible task state.  */
  80 static const char *long_task_states[] = {
  81   N_("Unactivated"),
  82   N_("Runnable"),
  83   N_("Terminated"),
  84   N_("Waiting for child activation"),
  85   N_("Blocked in accept or select with terminate"),
  86   N_("Waiting on entry call"),
  87   N_("Asynchronous Selective Wait"),
  88   N_("Delay Sleep"),
  89   N_("Waiting for children termination"),
  90   N_("Waiting for children in terminate alternative"),
  91   "",
  92   "",
  93   "",
  94   "",
  95   N_("Asynchronous Hold"),
  96   "",
  97   N_("Activating"),
  98   N_("Blocked in selective wait statement")
  99 };
 100
 101 /* The index of certain important fields in the Ada Task Control Block
 102    record and sub-records.  */
 103
 104 struct tcb_fieldnos
 105 {
 106   /* Fields in record Ada_Task_Control_Block.  */
 107   int common;
 108   int entry_calls;
 109   int atc_nesting_level;
 110
 111   /* Fields in record Common_ATCB.  */
 112   int state;
 113   int parent;
 114   int priority;
 115   int image;
 116   int image_len;     /* This field may be missing.  */
 117   int call;
 118   int ll;
 119
 120   /* Fields in Task_Primitives.Private_Data.  */
 121   int ll_thread;
 122   int ll_lwp;        /* This field may be missing.  */
 123
 124   /* Fields in Common_ATCB.Call.all.  */
 125   int call_self;
 126 };
 127
 128 /* The type description for the ATCB record and subrecords, and
 129    the associated tcb_fieldnos. For efficiency reasons, these are made
 130    static globals so that we can compute them only once the first time
 131    and reuse them later.  Set to NULL if the types haven't been computed
 132    yet, or if they may be obsolete (for instance after having loaded
 133    a new binary).  */
 134
 135 static struct type *atcb_type = NULL;
 136 static struct type *atcb_common_type = NULL;
 137 static struct type *atcb_ll_type = NULL;
 138 static struct type *atcb_call_type = NULL;
 139 static struct tcb_fieldnos fieldno;
 140
 141 /* Set to 1 when the cached address of System.Tasking.Debug.Known_Tasks
 142    might be stale and so needs to be recomputed.  */
 143 static int ada_tasks_check_symbol_table = 1;
 144
 145 /* The list of Ada tasks.
 146
 147    Note: To each task we associate a number that the user can use to
 148    reference it - this number is printed beside each task in the tasks
 149    info listing displayed by "info tasks".  This number is equal to
 150    its index in the vector + 1.  Reciprocally, to compute the index
 151    of a task in the vector, we need to substract 1 from its number.  */
 152 typedef struct ada_task_info ada_task_info_s;
 153 DEF_VEC_O(ada_task_info_s);
 154 static VEC(ada_task_info_s) *task_list = NULL;
 155
 156 /* When non-zero, this flag indicates that the current task_list
 157    is obsolete, and should be recomputed before it is accessed.  */
 158 static int stale_task_list_p = 1;
 159
 160 /* Return the task number of the task whose ptid is PTID, or zero
 161    if the task could not be found.  */
 162
 163 int
 164 ada_get_task_number (ptid_t ptid)
 165 {
 166   int i;
 167
 168   for (i=0; i < VEC_length (ada_task_info_s, task_list); i++)
 169     if (ptid_equal (VEC_index (ada_task_info_s, task_list, i)->ptid, ptid))
 170       return i + 1;
 171
 172   return 0;  /* No matching task found.  */
 173 }
 174
 175 /* Return the task number of the task that matches TASK_ID, or zero
 176    if the task could not be found.  */
 177
 178 static int
 179 get_task_number_from_id (CORE_ADDR task_id)
 180 {
 181   int i;
 182
 183   for (i = 0; i < VEC_length (ada_task_info_s, task_list); i++)
 184     {
 185       struct ada_task_info *task_info =
 186         VEC_index (ada_task_info_s, task_list, i);
 187
 188       if (task_info->task_id == task_id)
 189         return i + 1;
 190     }
 191
 192   /* Task not found.  Return 0.  */
 193   return 0;
 194 }
 195
 196 /* Return non-zero if TASK_NUM is a valid task number.  */
 197
 198 int
 199 valid_task_id (int task_num)
 200 {
 201   return (task_num > 0
 202           && task_num <= VEC_length (ada_task_info_s, task_list));
 203 }
 204
 205 /* Return non-zero iff the task STATE corresponds to a non-terminated
 206    task state.  */
 207
 208 static int
 209 ada_task_is_alive (struct ada_task_info *task_info)
 210 {
 211   return (task_info->state != Terminated);
 212 }
 213
 214 /* Extract the contents of the value as a string whose length is LENGTH,
 215    and store the result in DEST.  */
 216
 217 static void
 218 value_as_string (char *dest, struct value *val, int length)
 219 {
 220   memcpy (dest, value_contents (val), length);
 221   dest[length] = '\0';
 222 }
 223
 224 /* Extract the string image from the fat string corresponding to VAL,
 225    and store it in DEST.  If the string length is greater than MAX_LEN,
 226    then truncate the result to the first MAX_LEN characters of the fat
 227    string.  */
 228
 229 static void
 230 read_fat_string_value (char *dest, struct value *val, int max_len)
 231 {
 232   struct value *array_val;
 233   struct value *bounds_val;
 234   int len;
 235
 236   /* The following variables are made static to avoid recomputing them
 237      each time this function is called.  */
 238   static int initialize_fieldnos = 1;
 239   static int array_fieldno;
 240   static int bounds_fieldno;
 241   static int upper_bound_fieldno;
 242
 243   /* Get the index of the fields that we will need to read in order
 244      to extract the string from the fat string.  */
 245   if (initialize_fieldnos)
 246     {
 247       struct type *type = value_type (val);
 248       struct type *bounds_type;
 249
 250       array_fieldno = ada_get_field_index (type, "P_ARRAY", 0);
 251       bounds_fieldno = ada_get_field_index (type, "P_BOUNDS", 0);
 252
 253       bounds_type = TYPE_FIELD_TYPE (type, bounds_fieldno);
 254       if (TYPE_CODE (bounds_type) == TYPE_CODE_PTR)
 255         bounds_type = TYPE_TARGET_TYPE (bounds_type);
 256       if (TYPE_CODE (bounds_type) != TYPE_CODE_STRUCT)
 257         error (_("Unknown task name format. Aborting"));
 258       upper_bound_fieldno = ada_get_field_index (bounds_type, "UB0", 0);
 259
 260       initialize_fieldnos = 0;
 261     }
 262
 263   /* Get the size of the task image by checking the value of the bounds.
 264      The lower bound is always 1, so we only need to read the upper bound.  */
 265   bounds_val = value_ind (value_field (val, bounds_fieldno));
 266   len = value_as_long (value_field (bounds_val, upper_bound_fieldno));
 267
 268   /* Make sure that we do not read more than max_len characters...  */
 269   if (len > max_len)
 270     len = max_len;
 271
 272   /* Extract LEN characters from the fat string.  */
 273   array_val = value_ind (value_field (val, array_fieldno));
 274   read_memory (VALUE_ADDRESS (array_val), dest, len);
 275
 276   /* Add the NUL character to close the string.  */
 277   dest[len] = '\0';
 278 }
 279
 280 /* Return the address of the Known_Tasks array maintained in
 281    the Ada Runtime.  Return NULL if the array could not be found,
 282    meaning that the inferior program probably does not use tasking.
 283
 284    In order to provide a fast response time, this function caches
 285    the Known_Tasks array address after the lookup during the first
 286    call. Subsequent calls will simply return this cached address.  */
 287
 288 static CORE_ADDR
 289 get_known_tasks_addr (void)
 290 {
 291   static CORE_ADDR known_tasks_addr = 0;
 292
 293   if (ada_tasks_check_symbol_table)
 294     {
 295       struct symbol *sym;
 296       struct minimal_symbol *msym;
 297
 298       msym = lookup_minimal_symbol (KNOWN_TASKS_NAME, NULL, NULL);
 299       if (msym != NULL)
 300         known_tasks_addr = SYMBOL_VALUE_ADDRESS (msym);
 301       else
 302         {
 303           if (target_lookup_symbol (KNOWN_TASKS_NAME, &known_tasks_addr) != 0)
 304             return 0;
 305         }
 306
 307       /* FIXME: brobecker 2003-03-05: Here would be a much better place
 308          to attach the ada-tasks observers, instead of doing this
 309          unconditionaly in _initialize_tasks. This would avoid an
 310          unecessary notification when the inferior does not use tasking
 311          or as long as the user does not use the ada-tasks commands.
 312          Unfortunately, this is not possible for the moment: the current
 313          code resets ada__tasks_check_symbol_table back to 1 whenever
 314          symbols for a new program are being loaded. If we place the
 315          observers intialization here, we will end up adding new observers
 316          everytime we do the check for Ada tasking-related symbols
 317          above. This would currently have benign effects, but is still
 318          undesirable. The cleanest approach is probably to create a new
 319          observer to notify us when the user is debugging a new program.
 320          We would then reset ada__tasks_check_symbol_table back to 1
 321          during the notification, but also detach all observers.
 322          BTW: observers are probably not reentrant, so detaching during
 323          a notification may not be the safest thing to do... Sigh...
 324          But creating the new observer would be a good idea in any case,
 325          since this allow us to make ada__tasks_check_symbol_table
 326          static, which is a good bonus.  */
 327       ada_tasks_check_symbol_table = 0;
 328     }
 329
 330   return known_tasks_addr;
 331 }
 332
 333 /* Get from the debugging information the type description of all types
 334    related to the Ada Task Control Block that will be needed in order to
 335    read the list of known tasks in the Ada runtime.  Also return the
 336    associated ATCB_FIELDNOS.
 337
 338    Error handling:  Any data missing from the debugging info will cause
 339    an error to be raised, and none of the return values to be set.
 340    Users of this function can depend on the fact that all or none of the
 341    return values will be set.  */
 342
 343 static void
 344 get_tcb_types_info (struct type **atcb_type,
 345                     struct type **atcb_common_type,
 346                     struct type **atcb_ll_type,
 347                     struct type **atcb_call_type,
 348                     struct tcb_fieldnos *atcb_fieldnos)
 349 {
 350   struct type *type;
 351   struct type *common_type;
 352   struct type *ll_type;
 353   struct type *call_type;
 354   struct tcb_fieldnos fieldnos;
 355
 356   const char *atcb_name = "system__tasking__ada_task_control_block___XVE";
 357   const char *atcb_name_fixed = "system__tasking__ada_task_control_block";
 358   const char *common_atcb_name = "system__tasking__common_atcb";
 359   const char *private_data_name = "system__task_primitives__private_data";
 360   const char *entry_call_record_name = "system__tasking__entry_call_record";
 361
 362   struct symbol *atcb_sym =
 363     lookup_symbol (atcb_name, NULL, VAR_DOMAIN, NULL);
 364   const struct symbol *common_atcb_sym =
 365     lookup_symbol (common_atcb_name, NULL, VAR_DOMAIN, NULL);
 366   const struct symbol *private_data_sym =
 367     lookup_symbol (private_data_name, NULL, VAR_DOMAIN, NULL);
 368   const struct symbol *entry_call_record_sym =
 369     lookup_symbol (entry_call_record_name, NULL, VAR_DOMAIN, NULL);
 370
 371   if (atcb_sym == NULL || atcb_sym->type == NULL)
 372     {
 373       /* In Ravenscar run-time libs, the  ATCB does not have a dynamic
 374          size, so the symbol name differs.  */
 375       atcb_sym = lookup_symbol (atcb_name_fixed, NULL, VAR_DOMAIN, NULL);
 376
 377       if (atcb_sym == NULL || atcb_sym->type == NULL)
 378         error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
 379
 380       type = atcb_sym->type;
 381     }
 382   else
 383     {
 384       /* Get a static representation of the type record
 385          Ada_Task_Control_Block.  */
 386       type = atcb_sym->type;
 387       type = ada_template_to_fixed_record_type_1 (type, NULL, 0, NULL, 0);
 388     }
 389
 390   if (common_atcb_sym == NULL || common_atcb_sym->type == NULL)
 391     error (_("Cannot find Common_ATCB type. Aborting"));
 392   if (private_data_sym == NULL || private_data_sym->type == NULL)
 393     error (_("Cannot find Private_Data type. Aborting"));
 394   if (entry_call_record_sym == NULL || entry_call_record_sym->type == NULL)
 395     error (_("Cannot find Entry_Call_Record type. Aborting"));
 396
 397   /* Get the type for Ada_Task_Control_Block.Common.  */
 398   common_type = common_atcb_sym->type;
 399
 400   /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL.  */
 401   ll_type = private_data_sym->type;
 402
 403   /* Get the type for Common_ATCB.Call.all.  */
 404   call_type = entry_call_record_sym->type;
 405
 406   /* Get the field indices.  */
 407   fieldnos.common = ada_get_field_index (type, "common", 0);
 408   fieldnos.entry_calls = ada_get_field_index (type, "entry_calls", 1);
 409   fieldnos.atc_nesting_level =
 410     ada_get_field_index (type, "atc_nesting_level", 1);
 411   fieldnos.state = ada_get_field_index (common_type, "state", 0);
 412   fieldnos.parent = ada_get_field_index (common_type, "parent", 1);
 413   fieldnos.priority = ada_get_field_index (common_type, "base_priority", 0);
 414   fieldnos.image = ada_get_field_index (common_type, "task_image", 1);
 415   fieldnos.image_len = ada_get_field_index (common_type, "task_image_len", 1);
 416   fieldnos.call = ada_get_field_index (common_type, "call", 1);
 417   fieldnos.ll = ada_get_field_index (common_type, "ll", 0);
 418   fieldnos.ll_thread = ada_get_field_index (ll_type, "thread", 0);
 419   fieldnos.ll_lwp = ada_get_field_index (ll_type, "lwp", 1);
 420   fieldnos.call_self = ada_get_field_index (call_type, "self", 0);
 421
 422   /* On certain platforms such as x86-windows, the "lwp" field has been
 423      named "thread_id".  This field will likely be renamed in the future,
 424      but we need to support both possibilities to avoid an unnecessary
 425      dependency on a recent compiler.  We therefore try locating the
 426      "thread_id" field in place of the "lwp" field if we did not find
 427      the latter.  */
 428   if (fieldnos.ll_lwp < 0)
 429     fieldnos.ll_lwp = ada_get_field_index (ll_type, "thread_id", 1);
 430
 431   /* Set all the out parameters all at once, now that we are certain
 432      that there are no potential error() anymore.  */
 433   *atcb_type = type;
 434   *atcb_common_type = common_type;
 435   *atcb_ll_type = ll_type;
 436   *atcb_call_type = call_type;
 437   *atcb_fieldnos = fieldnos;
 438 }
 439
 440 /* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
 441    component of its ATCB record.  This PTID needs to match the PTID used
 442    by the thread layer.  */
 443
 444 static ptid_t
 445 ptid_from_atcb_common (struct value *common_value)
 446 {
 447   long thread = 0;
 448   CORE_ADDR lwp = 0;
 449   struct value *ll_value;
 450   ptid_t ptid;
 451
 452   ll_value = value_field (common_value, fieldno.ll);
 453
 454   if (fieldno.ll_lwp >= 0)
 455     lwp = value_as_address (value_field (ll_value, fieldno.ll_lwp));
 456   thread = value_as_long (value_field (ll_value, fieldno.ll_thread));
 457
 458   ptid = target_get_ada_task_ptid (lwp, thread);
 459
 460   return ptid;
 461 }
 462
 463 /* Read the ATCB data of a given task given its TASK_ID (which is in practice
 464    the address of its assocated ATCB record), and store the result inside
 465    TASK_INFO.  */
 466
 467 static void
 468 read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
 469 {
 470   struct value *tcb_value;
 471   struct value *common_value;
 472   struct value *atc_nesting_level_value;
 473   struct value *entry_calls_value;
 474   struct value *entry_calls_value_element;
 475   int called_task_fieldno = -1;
 476   const char ravenscar_task_name[] = "Ravenscar task";
 477
 478   if (atcb_type == NULL)
 479     get_tcb_types_info (&atcb_type, &atcb_common_type, &atcb_ll_type,
 480                         &atcb_call_type, &fieldno);
 481
 482   tcb_value = value_from_contents_and_address (atcb_type, NULL, task_id);
 483   common_value = value_field (tcb_value, fieldno.common);
 484
 485   /* Fill in the task_id.  */
 486
 487   task_info->task_id = task_id;
 488
 489   /* Compute the name of the task.
 490
 491      Depending on the GNAT version used, the task image is either a fat
 492      string, or a thin array of characters.  Older versions of GNAT used
 493      to use fat strings, and therefore did not need an extra field in
 494      the ATCB to store the string length. For efficiency reasons, newer
 495      versions of GNAT replaced the fat string by a static buffer, but this
 496      also required the addition of a new field named "Image_Len" containing
 497      the length of the task name. The method used to extract the task name
 498      is selected depending on the existence of this field.
 499
 500      In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
 501      we may want to get it from the first user frame of the stack. For now,
 502      we just give a dummy name.  */
 503
 504   if (fieldno.image_len == -1)
 505     {
 506       if (fieldno.image >= 0)
 507         read_fat_string_value (task_info->name,
 508                                value_field (common_value, fieldno.image),
 509                                sizeof (task_info->name) - 1);
 510       else
 511         strcpy (task_info->name, ravenscar_task_name);
 512     }
 513   else
 514     {
 515       int len = value_as_long (value_field (common_value, fieldno.image_len));
 516
 517       value_as_string (task_info->name,
 518                        value_field (common_value, fieldno.image), len);
 519     }
 520
 521   /* Compute the task state and priority.  */
 522
 523   task_info->state = value_as_long (value_field (common_value, fieldno.state));
 524   task_info->priority =
 525     value_as_long (value_field (common_value, fieldno.priority));
 526
 527   /* If the ATCB contains some information about the parent task,
 528      then compute it as well.  Otherwise, zero.  */
 529
 530   if (fieldno.parent >= 0)
 531     task_info->parent =
 532       value_as_address (value_field (common_value, fieldno.parent));
 533   else
 534     task_info->parent = 0;
 535
 536
 537   /* If the ATCB contains some information about entry calls, then
 538      compute the "called_task" as well.  Otherwise, zero.  */
 539
 540   if (fieldno.atc_nesting_level > 0 && fieldno.entry_calls > 0)
 541     {
 542       /* Let My_ATCB be the Ada task control block of a task calling the
 543          entry of another task; then the Task_Id of the called task is
 544          in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task.  */
 545       atc_nesting_level_value = value_field (tcb_value,
 546                                              fieldno.atc_nesting_level);
 547       entry_calls_value =
 548         ada_coerce_to_simple_array_ptr (value_field (tcb_value,
 549                                                      fieldno.entry_calls));
 550       entry_calls_value_element =
 551         value_subscript (entry_calls_value, atc_nesting_level_value);
 552       called_task_fieldno =
 553         ada_get_field_index (value_type (entry_calls_value_element),
 554                              "called_task", 0);
 555       task_info->called_task =
 556         value_as_address (value_field (entry_calls_value_element,
 557                                        called_task_fieldno));
 558     }
 559   else
 560     {
 561       task_info->called_task = 0;
 562     }
 563
 564   /* If the ATCB cotnains some information about RV callers,
 565      then compute the "caller_task".  Otherwise, zero.  */
 566
 567   task_info->caller_task = 0;
 568   if (fieldno.call >= 0)
 569     {
 570       /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
 571          If Common_ATCB.Call is null, then there is no caller.  */
 572       const CORE_ADDR call =
 573         value_as_address (value_field (common_value, fieldno.call));
 574       struct value *call_val;
 575
 576       if (call != 0)
 577         {
 578           call_val =
 579             value_from_contents_and_address (atcb_call_type, NULL, call);
 580           task_info->caller_task =
 581             value_as_address (value_field (call_val, fieldno.call_self));
 582         }
 583     }
 584
 585   /* And finally, compute the task ptid.  */
 586
 587   if (ada_task_is_alive (task_info))
 588     task_info->ptid = ptid_from_atcb_common (common_value);
 589   else
 590     task_info->ptid = null_ptid;
 591 }
 592
 593 /* Read the ATCB info of the given task (identified by TASK_ID), and
 594    add the result to the TASK_LIST.  */
 595
 596 static void
 597 add_ada_task (CORE_ADDR task_id)
 598 {
 599   struct ada_task_info task_info;
 600
 601   read_atcb (task_id, &task_info);
 602   VEC_safe_push (ada_task_info_s, task_list, &task_info);
 603 }
 604
 605 /* Read the Known_Tasks array from the inferior memory, and store
 606    it in TASK_LIST.  Return non-zero upon success.  */
 607
 608 static int
 609 read_known_tasks_array (void)
 610 {
 611   const int target_ptr_byte =
 612     gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
 613   const CORE_ADDR known_tasks_addr = get_known_tasks_addr ();
 614   const int known_tasks_size = target_ptr_byte * MAX_NUMBER_OF_KNOWN_TASKS;
 615   gdb_byte *known_tasks = alloca (known_tasks_size);
 616   int i;
 617
 618   /* Step 1: Clear the current list, if necessary.  */
 619   VEC_truncate (ada_task_info_s, task_list, 0);
 620
 621   /* If the application does not use task, then no more needs to be done.
 622      It is important to have the task list cleared (see above) before we
 623      return, as we don't want a stale task list to be used...  This can
 624      happen for instance when debugging a non-multitasking program after
 625      having debugged a multitasking one.  */
 626   if (known_tasks_addr == 0)
 627     return 0;
 628
 629   /* Step 2: Build a new list by reading the ATCBs from the Known_Tasks
 630      array in the Ada runtime.  */
 631   read_memory (known_tasks_addr, known_tasks, known_tasks_size);
 632   for (i = 0; i < MAX_NUMBER_OF_KNOWN_TASKS; i++)
 633     {
 634       struct type *data_ptr_type =
 635         builtin_type (current_gdbarch)->builtin_data_ptr;
 636       CORE_ADDR task_id =
 637         extract_typed_address (known_tasks + i * target_ptr_byte,
 638                                data_ptr_type);
 639
 640       if (task_id != 0)
 641         add_ada_task (task_id);
 642     }
 643
 644   /* Step 3: Unset stale_task_list_p, to avoid re-reading the Known_Tasks
 645      array unless needed.  Then report a success.  */
 646   stale_task_list_p = 0;
 647
 648   return 1;
 649 }
 650
 651 /* Builds the task_list by reading the Known_Tasks array from
 652    the inferior.  Prints an appropriate message and returns non-zero
 653    if it failed to build this list.  */
 654
 655 int
 656 ada_build_task_list (int warn_if_null)
 657 {
 658   if (!target_has_stack)
 659     error (_("Cannot inspect Ada tasks when program is not running"));
 660
 661   if (stale_task_list_p)
 662     read_known_tasks_array ();
 663
 664   if (task_list == NULL)
 665     {
 666       if (warn_if_null)
 667         printf_filtered (_("Your application does not use any Ada tasks.\n"));
 668       return 0;
 669     }
 670
 671   return 1;
 672 }
 673
 674 /* Print a one-line description of the task whose number is TASKNO.
 675    The formatting should fit the "info tasks" array.  */
 676
 677 static void
 678 short_task_info (int taskno)
 679 {
 680   const struct ada_task_info *const task_info =
 681     VEC_index (ada_task_info_s, task_list, taskno - 1);
 682   int active_task_p;
 683
 684   gdb_assert (task_info != NULL);
 685
 686   /* Print a star if this task is the current task (or the task currently
 687      selected).  */
 688
 689   active_task_p = ptid_equal (task_info->ptid, inferior_ptid);
 690   if (active_task_p)
 691     printf_filtered ("*");
 692   else
 693     printf_filtered (" ");
 694
 695   /* Print the task number.  */
 696   printf_filtered ("%3d", taskno);
 697
 698   /* Print the Task ID.  */
 699   printf_filtered (" %9lx", (long) task_info->task_id);
 700
 701   /* Print the Task ID of the task parent.  */
 702   printf_filtered (" %4d", get_task_number_from_id (task_info->parent));
 703
 704   /* Print the base priority of the task.  */
 705   printf_filtered (" %3d", task_info->priority);
 706
 707   /* Print the task current state.  */
 708   if (task_info->caller_task)
 709     printf_filtered (_(" Accepting RV with %-4d"),
 710                      get_task_number_from_id (task_info->caller_task));
 711   else if (task_info->state == Entry_Caller_Sleep && task_info->called_task)
 712     printf_filtered (_(" Waiting on RV with %-3d"),
 713                      get_task_number_from_id (task_info->called_task));
 714   else
 715     printf_filtered (" %-22s", _(task_states[task_info->state]));
 716
 717   /* Finally, print the task name.  */
 718   if (task_info->name[0] != '\0')
 719     printf_filtered (" %s\n", task_info->name);
 720   else
 721     printf_filtered (_(" <no name>\n"));
 722 }
 723
 724 /* Print a list containing a short description of all Ada tasks.  */
 725 /* FIXME: Shouldn't we be using ui_out??? */
 726
 727 static void
 728 info_tasks (int from_tty)
 729 {
 730   int taskno;
 731   const int nb_tasks = VEC_length (ada_task_info_s, task_list);
 732
 733   printf_filtered (_("  ID       TID P-ID Pri State                  Name\n"));
 734
 735   for (taskno = 1; taskno <= nb_tasks; taskno++)
 736     short_task_info (taskno);
 737 }
 738
 739 /* Print a detailed description of the Ada task whose ID is TASKNO_STR.  */
 740
 741 static void
 742 info_task (char *taskno_str, int from_tty)
 743 {
 744   const int taskno = value_as_long (parse_and_eval (taskno_str));
 745   struct ada_task_info *task_info;
 746   int parent_taskno = 0;
 747
 748   if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, task_list))
 749     error (_("Task ID %d not known.  Use the \"info tasks\" command to\n"
 750              "see the IDs of currently known tasks"), taskno);
 751   task_info = VEC_index (ada_task_info_s, task_list, taskno - 1);
 752
 753   /* Print the Ada task ID.  */
 754   printf_filtered (_("Ada Task: %s\n"), paddr_nz (task_info->task_id));
 755
 756   /* Print the name of the task.  */
 757   if (task_info->name[0] != '\0')
 758     printf_filtered (_("Name: %s\n"), task_info->name);
 759   else
 760     printf_filtered (_("<no name>\n"));
 761
 762   /* Print the TID and LWP.  */
 763   printf_filtered (_("Thread: %#lx\n"), ptid_get_tid (task_info->ptid));
 764   printf_filtered (_("LWP: %#lx\n"), ptid_get_lwp (task_info->ptid));
 765
 766   /* Print who is the parent (if any).  */
 767   if (task_info->parent != 0)
 768     parent_taskno = get_task_number_from_id (task_info->parent);
 769   if (parent_taskno)
 770     {
 771       struct ada_task_info *parent =
 772         VEC_index (ada_task_info_s, task_list, parent_taskno - 1);
 773
 774       printf_filtered (_("Parent: %d"), parent_taskno);
 775       if (parent->name[0] != '\0')
 776         printf_filtered (" (%s)", parent->name);
 777       printf_filtered ("\n");
 778     }
 779   else
 780     printf_filtered (_("No parent\n"));
 781
 782   /* Print the base priority.  */
 783   printf_filtered (_("Base Priority: %d\n"), task_info->priority);
 784
 785   /* print the task current state.  */
 786   {
 787     int target_taskno = 0;
 788
 789     if (task_info->caller_task)
 790       {
 791         target_taskno = get_task_number_from_id (task_info->caller_task);
 792         printf_filtered (_("State: Accepting rendezvous with %d"),
 793                          target_taskno);
 794       }
 795     else if (task_info->state == Entry_Caller_Sleep && task_info->called_task)
 796       {
 797         target_taskno = get_task_number_from_id (task_info->called_task);
 798         printf_filtered (_("State: Waiting on task %d's entry"),
 799                          target_taskno);
 800       }
 801     else
 802       printf_filtered (_("State: %s"), _(long_task_states[task_info->state]));
 803
 804     if (target_taskno)
 805       {
 806         struct ada_task_info *target_task_info =
 807           VEC_index (ada_task_info_s, task_list, target_taskno - 1);
 808
 809         if (target_task_info->name[0] != '\0')
 810           printf_filtered (" (%s)", target_task_info->name);
 811       }
 812
 813     printf_filtered ("\n");
 814   }
 815 }
 816
 817 /* If ARG is empty or null, then print a list of all Ada tasks.
 818    Otherwise, print detailed information about the task whose ID
 819    is ARG.
 820
 821    Does nothing if the program doesn't use Ada tasking.  */
 822
 823 static void
 824 info_tasks_command (char *arg, int from_tty)
 825 {
 826   const int task_list_built = ada_build_task_list (1);
 827
 828   if (!task_list_built)
 829     return;
 830
 831   if (arg == NULL || *arg == '\0')
 832     info_tasks (from_tty);
 833   else
 834     info_task (arg, from_tty);
 835 }
 836
 837 /* Print a message telling the user id of the current task.
 838    This function assumes that tasking is in use in the inferior.  */
 839
 840 static void
 841 display_current_task_id (void)
 842 {
 843   const int current_task = ada_get_task_number (inferior_ptid);
 844
 845   if (current_task == 0)
 846     printf_filtered (_("[Current task is unknown]\n"));
 847   else
 848     printf_filtered (_("[Current task is %d]\n"), current_task);
 849 }
 850
 851 /* Parse and evaluate TIDSTR into a task id, and try to switch to
 852    that task.  Print an error message if the task switch failed.  */
 853
 854 static void
 855 task_command_1 (char *taskno_str, int from_tty)
 856 {
 857   const int taskno = value_as_long (parse_and_eval (taskno_str));
 858   struct ada_task_info *task_info;
 859
 860   if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, task_list))
 861     error (_("Task ID %d not known.  Use the \"info tasks\" command to\n"
 862              "see the IDs of currently known tasks"), taskno);
 863   task_info = VEC_index (ada_task_info_s, task_list, taskno - 1);
 864
 865   if (!ada_task_is_alive (task_info))
 866     error (_("Cannot switch to task %d: Task is no longer running"), taskno);
 867
 868   switch_to_thread (task_info->ptid);
 869   ada_find_printable_frame (get_selected_frame (NULL));
 870   printf_filtered (_("[Switching to task %d]\n"), taskno);
 871   print_stack_frame (get_selected_frame (NULL),
 872                      frame_relative_level (get_selected_frame (NULL)), 1);
 873 }
 874
 875
 876 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
 877    Otherwise, switch to the task indicated by TASKNO_STR.  */
 878
 879 static void
 880 task_command (char *taskno_str, int from_tty)
 881 {
 882   const int task_list_built = ada_build_task_list (1);
 883
 884   if (!task_list_built)
 885     return;
 886
 887   if (taskno_str == NULL || taskno_str[0] == '\0')
 888     display_current_task_id ();
 889   else
 890     {
 891       /* Task switching in core files doesn't work, either because:
 892            1. Thread support is not implemented with core files
 893            2. Thread support is implemented, but the thread IDs created
 894               after having read the core file are not the same as the ones
 895               that were used during the program life, before the crash.
 896               As a consequence, there is no longer a way for the debugger
 897               to find the associated thead ID of any given Ada task.
 898          So, instead of attempting a task switch without giving the user
 899          any clue as to what might have happened, just error-out with
 900          a message explaining that this feature is not supported.  */
 901       if (!target_has_execution)
 902         error (_("\
 903 Task switching not supported when debugging from core files\n\
 904 (use thread support instead)"));
 905       task_command_1 (taskno_str, from_tty);
 906     }
 907 }
 908
 909 /* Indicate that the task list may have changed, so invalidate the cache.  */
 910
 911 static void
 912 ada_task_list_changed (void)
 913 {
 914   stale_task_list_p = 1;
 915 }
 916
 917 /* The 'normal_stop' observer notification callback.  */
 918
 919 static void
 920 ada_normal_stop_observer (struct bpstats *unused_args, int unused_args2)
 921 {
 922   /* The inferior has been resumed, and just stopped. This means that
 923      our task_list needs to be recomputed before it can be used again.  */
 924   ada_task_list_changed ();
 925 }
 926
 927 /* A routine to be called when the objfiles have changed.  */
 928
 929 static void
 930 ada_new_objfile_observer (struct objfile *objfile)
 931 {
 932   /* Invalidate all cached data that were extracted from an objfile.  */
 933
 934   atcb_type = NULL;
 935   atcb_common_type = NULL;
 936   atcb_ll_type = NULL;
 937   atcb_call_type = NULL;
 938
 939   ada_tasks_check_symbol_table = 1;
 940 }
 941
 942 /* Provide a prototype to silence -Wmissing-prototypes.  */
 943 extern initialize_file_ftype _initialize_tasks;
 944
 945 void
 946 _initialize_tasks (void)
 947 {
 948   /* Attach various observers.  */
 949   observer_attach_normal_stop (ada_normal_stop_observer);
 950   observer_attach_new_objfile (ada_new_objfile_observer);
 951
 952   /* Some new commands provided by this module.  */
 953   add_info ("tasks", info_tasks_command,
 954             _("Provide information about all known Ada tasks"));
 955   add_cmd ("task", class_run, task_command,
 956            _("Use this command to switch between Ada tasks.\n\
 957 Without argument, this command simply prints the current task ID"),
 958            &cmdlist);
 959 }
 960