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 static 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 if (task_info->state == Runnable && active_task_p)
 715     /* Replace "Runnable" by "Running" since this is the active task.  */
 716     printf_filtered (" %-22s", _("Running"));
 717   else
 718     printf_filtered (" %-22s", _(task_states[task_info->state]));
 719
 720   /* Finally, print the task name.  */
 721   if (task_info->name[0] != '\0')
 722     printf_filtered (" %s\n", task_info->name);
 723   else
 724     printf_filtered (_(" <no name>\n"));
 725 }
 726
 727 /* Print a list containing a short description of all Ada tasks.  */
 728 /* FIXME: Shouldn't we be using ui_out??? */
 729
 730 static void
 731 info_tasks (int from_tty)
 732 {
 733   int taskno;
 734   const int nb_tasks = VEC_length (ada_task_info_s, task_list);
 735
 736   printf_filtered (_("  ID       TID P-ID Pri State                  Name\n"));
 737
 738   for (taskno = 1; taskno <= nb_tasks; taskno++)
 739     short_task_info (taskno);
 740 }
 741
 742 /* Print a detailed description of the Ada task whose ID is TASKNO_STR.  */
 743
 744 static void
 745 info_task (char *taskno_str, int from_tty)
 746 {
 747   const int taskno = value_as_long (parse_and_eval (taskno_str));
 748   struct ada_task_info *task_info;
 749   int parent_taskno = 0;
 750
 751   if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, task_list))
 752     error (_("Task ID %d not known.  Use the \"info tasks\" command to\n"
 753              "see the IDs of currently known tasks"), taskno);
 754   task_info = VEC_index (ada_task_info_s, task_list, taskno - 1);
 755
 756   /* Print the Ada task ID.  */
 757   printf_filtered (_("Ada Task: %s\n"), paddr_nz (task_info->task_id));
 758
 759   /* Print the name of the task.  */
 760   if (task_info->name[0] != '\0')
 761     printf_filtered (_("Name: %s\n"), task_info->name);
 762   else
 763     printf_filtered (_("<no name>\n"));
 764
 765   /* Print the TID and LWP.  */
 766   printf_filtered (_("Thread: %#lx\n"), ptid_get_tid (task_info->ptid));
 767   printf_filtered (_("LWP: %#lx\n"), ptid_get_lwp (task_info->ptid));
 768
 769   /* Print who is the parent (if any).  */
 770   if (task_info->parent != 0)
 771     parent_taskno = get_task_number_from_id (task_info->parent);
 772   if (parent_taskno)
 773     {
 774       struct ada_task_info *parent =
 775         VEC_index (ada_task_info_s, task_list, parent_taskno - 1);
 776
 777       printf_filtered (_("Parent: %d"), parent_taskno);
 778       if (parent->name[0] != '\0')
 779         printf_filtered (" (%s)", parent->name);
 780       printf_filtered ("\n");
 781     }
 782   else
 783     printf_filtered (_("No parent\n"));
 784
 785   /* Print the base priority.  */
 786   printf_filtered (_("Base Priority: %d\n"), task_info->priority);
 787
 788   /* print the task current state.  */
 789   {
 790     int target_taskno = 0;
 791
 792     if (task_info->caller_task)
 793       {
 794         target_taskno = get_task_number_from_id (task_info->caller_task);
 795         printf_filtered (_("State: Accepting rendezvous with %d"),
 796                          target_taskno);
 797       }
 798     else if (task_info->state == Entry_Caller_Sleep && task_info->called_task)
 799       {
 800         target_taskno = get_task_number_from_id (task_info->called_task);
 801         printf_filtered (_("State: Waiting on task %d's entry"),
 802                          target_taskno);
 803       }
 804     else
 805       printf_filtered (_("State: %s"), _(long_task_states[task_info->state]));
 806
 807     if (target_taskno)
 808       {
 809         struct ada_task_info *target_task_info =
 810           VEC_index (ada_task_info_s, task_list, target_taskno - 1);
 811
 812         if (target_task_info->name[0] != '\0')
 813           printf_filtered (" (%s)", target_task_info->name);
 814       }
 815
 816     printf_filtered ("\n");
 817   }
 818 }
 819
 820 /* If ARG is empty or null, then print a list of all Ada tasks.
 821    Otherwise, print detailed information about the task whose ID
 822    is ARG.
 823
 824    Does nothing if the program doesn't use Ada tasking.  */
 825
 826 static void
 827 info_tasks_command (char *arg, int from_tty)
 828 {
 829   const int task_list_built = ada_build_task_list (1);
 830
 831   if (!task_list_built)
 832     return;
 833
 834   if (arg == NULL || *arg == '\0')
 835     info_tasks (from_tty);
 836   else
 837     info_task (arg, from_tty);
 838 }
 839
 840 /* Print a message telling the user id of the current task.
 841    This function assumes that tasking is in use in the inferior.  */
 842
 843 static void
 844 display_current_task_id (void)
 845 {
 846   const int current_task = ada_get_task_number (inferior_ptid);
 847
 848   if (current_task == 0)
 849     printf_filtered (_("[Current task is unknown]\n"));
 850   else
 851     printf_filtered (_("[Current task is %d]\n"), current_task);
 852 }
 853
 854 /* Parse and evaluate TIDSTR into a task id, and try to switch to
 855    that task.  Print an error message if the task switch failed.  */
 856
 857 static void
 858 task_command_1 (char *taskno_str, int from_tty)
 859 {
 860   const int taskno = value_as_long (parse_and_eval (taskno_str));
 861   struct ada_task_info *task_info;
 862
 863   if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, task_list))
 864     error (_("Task ID %d not known.  Use the \"info tasks\" command to\n"
 865              "see the IDs of currently known tasks"), taskno);
 866   task_info = VEC_index (ada_task_info_s, task_list, taskno - 1);
 867
 868   if (!ada_task_is_alive (task_info))
 869     error (_("Cannot switch to task %d: Task is no longer running"), taskno);
 870
 871   switch_to_thread (task_info->ptid);
 872   ada_find_printable_frame (get_selected_frame (NULL));
 873   printf_filtered (_("[Switching to task %d]\n"), taskno);
 874   print_stack_frame (get_selected_frame (NULL),
 875                      frame_relative_level (get_selected_frame (NULL)), 1);
 876 }
 877
 878
 879 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
 880    Otherwise, switch to the task indicated by TASKNO_STR.  */
 881
 882 static void
 883 task_command (char *taskno_str, int from_tty)
 884 {
 885   const int task_list_built = ada_build_task_list (1);
 886
 887   if (!task_list_built)
 888     return;
 889
 890   if (taskno_str == NULL || taskno_str[0] == '\0')
 891     display_current_task_id ();
 892   else
 893     {
 894       /* Task switching in core files doesn't work, either because:
 895            1. Thread support is not implemented with core files
 896            2. Thread support is implemented, but the thread IDs created
 897               after having read the core file are not the same as the ones
 898               that were used during the program life, before the crash.
 899               As a consequence, there is no longer a way for the debugger
 900               to find the associated thead ID of any given Ada task.
 901          So, instead of attempting a task switch without giving the user
 902          any clue as to what might have happened, just error-out with
 903          a message explaining that this feature is not supported.  */
 904       if (!target_has_execution)
 905         error (_("\
 906 Task switching not supported when debugging from core files\n\
 907 (use thread support instead)"));
 908       task_command_1 (taskno_str, from_tty);
 909     }
 910 }
 911
 912 /* Indicate that the task list may have changed, so invalidate the cache.  */
 913
 914 static void
 915 ada_task_list_changed (void)
 916 {
 917   stale_task_list_p = 1;
 918 }
 919
 920 /* The 'normal_stop' observer notification callback.  */
 921
 922 static void
 923 ada_normal_stop_observer (struct bpstats *unused_args, int unused_args2)
 924 {
 925   /* The inferior has been resumed, and just stopped. This means that
 926      our task_list needs to be recomputed before it can be used again.  */
 927   ada_task_list_changed ();
 928 }
 929
 930 /* A routine to be called when the objfiles have changed.  */
 931
 932 static void
 933 ada_new_objfile_observer (struct objfile *objfile)
 934 {
 935   /* Invalidate all cached data that were extracted from an objfile.  */
 936
 937   atcb_type = NULL;
 938   atcb_common_type = NULL;
 939   atcb_ll_type = NULL;
 940   atcb_call_type = NULL;
 941
 942   ada_tasks_check_symbol_table = 1;
 943 }
 944
 945 /* Provide a prototype to silence -Wmissing-prototypes.  */
 946 extern initialize_file_ftype _initialize_tasks;
 947
 948 void
 949 _initialize_tasks (void)
 950 {
 951   /* Attach various observers.  */
 952   observer_attach_normal_stop (ada_normal_stop_observer);
 953   observer_attach_new_objfile (ada_new_objfile_observer);
 954
 955   /* Some new commands provided by this module.  */
 956   add_info ("tasks", info_tasks_command,
 957             _("Provide information about all known Ada tasks"));
 958   add_cmd ("task", class_run, task_command,
 959            _("Use this command to switch between Ada tasks.\n\
 960 Without argument, this command simply prints the current task ID"),
 961            &cmdlist);
 962 }
 963