contrib/gdb-7/gdb/ada-tasks.c

   1 /* Copyright (C) 1992, 1993, 1994, 1997, 1998, 1999, 2000, 2003, 2004, 2005,
   2    2007, 2008, 2009, 2010 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   ada_build_task_list (0);
 202   return (task_num > 0
 203           && task_num <= VEC_length (ada_task_info_s, task_list));
 204 }
 205
 206 /* Return non-zero iff the task STATE corresponds to a non-terminated
 207    task state.  */
 208
 209 static int
 210 ada_task_is_alive (struct ada_task_info *task_info)
 211 {
 212   return (task_info->state != Terminated);
 213 }
 214
 215 /* Extract the contents of the value as a string whose length is LENGTH,
 216    and store the result in DEST.  */
 217
 218 static void
 219 value_as_string (char *dest, struct value *val, int length)
 220 {
 221   memcpy (dest, value_contents (val), length);
 222   dest[length] = '\0';
 223 }
 224
 225 /* Extract the string image from the fat string corresponding to VAL,
 226    and store it in DEST.  If the string length is greater than MAX_LEN,
 227    then truncate the result to the first MAX_LEN characters of the fat
 228    string.  */
 229
 230 static void
 231 read_fat_string_value (char *dest, struct value *val, int max_len)
 232 {
 233   struct value *array_val;
 234   struct value *bounds_val;
 235   int len;
 236
 237   /* The following variables are made static to avoid recomputing them
 238      each time this function is called.  */
 239   static int initialize_fieldnos = 1;
 240   static int array_fieldno;
 241   static int bounds_fieldno;
 242   static int upper_bound_fieldno;
 243
 244   /* Get the index of the fields that we will need to read in order
 245      to extract the string from the fat string.  */
 246   if (initialize_fieldnos)
 247     {
 248       struct type *type = value_type (val);
 249       struct type *bounds_type;
 250
 251       array_fieldno = ada_get_field_index (type, "P_ARRAY", 0);
 252       bounds_fieldno = ada_get_field_index (type, "P_BOUNDS", 0);
 253
 254       bounds_type = TYPE_FIELD_TYPE (type, bounds_fieldno);
 255       if (TYPE_CODE (bounds_type) == TYPE_CODE_PTR)
 256         bounds_type = TYPE_TARGET_TYPE (bounds_type);
 257       if (TYPE_CODE (bounds_type) != TYPE_CODE_STRUCT)
 258         error (_("Unknown task name format. Aborting"));
 259       upper_bound_fieldno = ada_get_field_index (bounds_type, "UB0", 0);
 260
 261       initialize_fieldnos = 0;
 262     }
 263
 264   /* Get the size of the task image by checking the value of the bounds.
 265      The lower bound is always 1, so we only need to read the upper bound.  */
 266   bounds_val = value_ind (value_field (val, bounds_fieldno));
 267   len = value_as_long (value_field (bounds_val, upper_bound_fieldno));
 268
 269   /* Make sure that we do not read more than max_len characters...  */
 270   if (len > max_len)
 271     len = max_len;
 272
 273   /* Extract LEN characters from the fat string.  */
 274   array_val = value_ind (value_field (val, array_fieldno));
 275   read_memory (value_address (array_val), dest, len);
 276
 277   /* Add the NUL character to close the string.  */
 278   dest[len] = '\0';
 279 }
 280
 281 /* Return the address of the Known_Tasks array maintained in
 282    the Ada Runtime.  Return NULL if the array could not be found,
 283    meaning that the inferior program probably does not use tasking.
 284
 285    In order to provide a fast response time, this function caches
 286    the Known_Tasks array address after the lookup during the first
 287    call. Subsequent calls will simply return this cached address.  */
 288
 289 static CORE_ADDR
 290 get_known_tasks_addr (void)
 291 {
 292   static CORE_ADDR known_tasks_addr = 0;
 293
 294   if (ada_tasks_check_symbol_table)
 295     {
 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,
 552                          value_as_long (atc_nesting_level_value));
 553       called_task_fieldno =
 554         ada_get_field_index (value_type (entry_calls_value_element),
 555                              "called_task", 0);
 556       task_info->called_task =
 557         value_as_address (value_field (entry_calls_value_element,
 558                                        called_task_fieldno));
 559     }
 560   else
 561     {
 562       task_info->called_task = 0;
 563     }
 564
 565   /* If the ATCB cotnains some information about RV callers,
 566      then compute the "caller_task".  Otherwise, zero.  */
 567
 568   task_info->caller_task = 0;
 569   if (fieldno.call >= 0)
 570     {
 571       /* Get the ID of the caller task from Common_ATCB.Call.all.Self.
 572          If Common_ATCB.Call is null, then there is no caller.  */
 573       const CORE_ADDR call =
 574         value_as_address (value_field (common_value, fieldno.call));
 575       struct value *call_val;
 576
 577       if (call != 0)
 578         {
 579           call_val =
 580             value_from_contents_and_address (atcb_call_type, NULL, call);
 581           task_info->caller_task =
 582             value_as_address (value_field (call_val, fieldno.call_self));
 583         }
 584     }
 585
 586   /* And finally, compute the task ptid.  */
 587
 588   if (ada_task_is_alive (task_info))
 589     task_info->ptid = ptid_from_atcb_common (common_value);
 590   else
 591     task_info->ptid = null_ptid;
 592 }
 593
 594 /* Read the ATCB info of the given task (identified by TASK_ID), and
 595    add the result to the TASK_LIST.  */
 596
 597 static void
 598 add_ada_task (CORE_ADDR task_id)
 599 {
 600   struct ada_task_info task_info;
 601
 602   read_atcb (task_id, &task_info);
 603   VEC_safe_push (ada_task_info_s, task_list, &task_info);
 604 }
 605
 606 /* Read the Known_Tasks array from the inferior memory, and store
 607    it in TASK_LIST.  Return non-zero upon success.  */
 608
 609 static int
 610 read_known_tasks_array (void)
 611 {
 612   const int target_ptr_byte =
 613     gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT;
 614   const CORE_ADDR known_tasks_addr = get_known_tasks_addr ();
 615   const int known_tasks_size = target_ptr_byte * MAX_NUMBER_OF_KNOWN_TASKS;
 616   gdb_byte *known_tasks = alloca (known_tasks_size);
 617   int i;
 618
 619   /* Step 1: Clear the current list, if necessary.  */
 620   VEC_truncate (ada_task_info_s, task_list, 0);
 621
 622   /* If the application does not use task, then no more needs to be done.
 623      It is important to have the task list cleared (see above) before we
 624      return, as we don't want a stale task list to be used...  This can
 625      happen for instance when debugging a non-multitasking program after
 626      having debugged a multitasking one.  */
 627   if (known_tasks_addr == 0)
 628     return 0;
 629
 630   /* Step 2: Build a new list by reading the ATCBs from the Known_Tasks
 631      array in the Ada runtime.  */
 632   read_memory (known_tasks_addr, known_tasks, known_tasks_size);
 633   for (i = 0; i < MAX_NUMBER_OF_KNOWN_TASKS; i++)
 634     {
 635       struct type *data_ptr_type =
 636         builtin_type (target_gdbarch)->builtin_data_ptr;
 637       CORE_ADDR task_id =
 638         extract_typed_address (known_tasks + i * target_ptr_byte,
 639                                data_ptr_type);
 640
 641       if (task_id != 0)
 642         add_ada_task (task_id);
 643     }
 644
 645   /* Step 3: Unset stale_task_list_p, to avoid re-reading the Known_Tasks
 646      array unless needed.  Then report a success.  */
 647   stale_task_list_p = 0;
 648
 649   return 1;
 650 }
 651
 652 /* Builds the task_list by reading the Known_Tasks array from
 653    the inferior.  Prints an appropriate message and returns non-zero
 654    if it failed to build this list.  */
 655
 656 int
 657 ada_build_task_list (int warn_if_null)
 658 {
 659   if (!target_has_stack)
 660     error (_("Cannot inspect Ada tasks when program is not running"));
 661
 662   if (stale_task_list_p)
 663     read_known_tasks_array ();
 664
 665   if (task_list == NULL)
 666     {
 667       if (warn_if_null)
 668         printf_filtered (_("Your application does not use any Ada tasks.\n"));
 669       return 0;
 670     }
 671
 672   return 1;
 673 }
 674
 675 /* Print a one-line description of the task whose number is TASKNO.
 676    The formatting should fit the "info tasks" array.  */
 677
 678 static void
 679 short_task_info (int taskno)
 680 {
 681   const struct ada_task_info *const task_info =
 682     VEC_index (ada_task_info_s, task_list, taskno - 1);
 683   int active_task_p;
 684
 685   gdb_assert (task_info != NULL);
 686
 687   /* Print a star if this task is the current task (or the task currently
 688      selected).  */
 689
 690   active_task_p = ptid_equal (task_info->ptid, inferior_ptid);
 691   if (active_task_p)
 692     printf_filtered ("*");
 693   else
 694     printf_filtered (" ");
 695
 696   /* Print the task number.  */
 697   printf_filtered ("%3d", taskno);
 698
 699   /* Print the Task ID.  */
 700   printf_filtered (" %9lx", (long) task_info->task_id);
 701
 702   /* Print the Task ID of the task parent.  */
 703   printf_filtered (" %4d", get_task_number_from_id (task_info->parent));
 704
 705   /* Print the base priority of the task.  */
 706   printf_filtered (" %3d", task_info->priority);
 707
 708   /* Print the task current state.  */
 709   if (task_info->caller_task)
 710     printf_filtered (_(" Accepting RV with %-4d"),
 711                      get_task_number_from_id (task_info->caller_task));
 712   else if (task_info->state == Entry_Caller_Sleep && task_info->called_task)
 713     printf_filtered (_(" Waiting on RV with %-3d"),
 714                      get_task_number_from_id (task_info->called_task));
 715   else
 716     printf_filtered (" %-22s", _(task_states[task_info->state]));
 717
 718   /* Finally, print the task name.  */
 719   if (task_info->name[0] != '\0')
 720     printf_filtered (" %s\n", task_info->name);
 721   else
 722     printf_filtered (_(" <no name>\n"));
 723 }
 724
 725 /* Print a list containing a short description of all Ada tasks.  */
 726 /* FIXME: Shouldn't we be using ui_out??? */
 727
 728 static void
 729 info_tasks (int from_tty)
 730 {
 731   int taskno;
 732   const int nb_tasks = VEC_length (ada_task_info_s, task_list);
 733
 734   printf_filtered (_("  ID       TID P-ID Pri State                  Name\n"));
 735
 736   for (taskno = 1; taskno <= nb_tasks; taskno++)
 737     short_task_info (taskno);
 738 }
 739
 740 /* Print a detailed description of the Ada task whose ID is TASKNO_STR.  */
 741
 742 static void
 743 info_task (char *taskno_str, int from_tty)
 744 {
 745   const int taskno = value_as_long (parse_and_eval (taskno_str));
 746   struct ada_task_info *task_info;
 747   int parent_taskno = 0;
 748
 749   if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, task_list))
 750     error (_("Task ID %d not known.  Use the \"info tasks\" command to\n"
 751              "see the IDs of currently known tasks"), taskno);
 752   task_info = VEC_index (ada_task_info_s, task_list, taskno - 1);
 753
 754   /* Print the Ada task ID.  */
 755   printf_filtered (_("Ada Task: %s\n"),
 756                    paddress (target_gdbarch, task_info->task_id));
 757
 758   /* Print the name of the task.  */
 759   if (task_info->name[0] != '\0')
 760     printf_filtered (_("Name: %s\n"), task_info->name);
 761   else
 762     printf_filtered (_("<no name>\n"));
 763
 764   /* Print the TID and LWP.  */
 765   printf_filtered (_("Thread: %#lx\n"), ptid_get_tid (task_info->ptid));
 766   printf_filtered (_("LWP: %#lx\n"), ptid_get_lwp (task_info->ptid));
 767
 768   /* Print who is the parent (if any).  */
 769   if (task_info->parent != 0)
 770     parent_taskno = get_task_number_from_id (task_info->parent);
 771   if (parent_taskno)
 772     {
 773       struct ada_task_info *parent =
 774         VEC_index (ada_task_info_s, task_list, parent_taskno - 1);
 775
 776       printf_filtered (_("Parent: %d"), parent_taskno);
 777       if (parent->name[0] != '\0')
 778         printf_filtered (" (%s)", parent->name);
 779       printf_filtered ("\n");
 780     }
 781   else
 782     printf_filtered (_("No parent\n"));
 783
 784   /* Print the base priority.  */
 785   printf_filtered (_("Base Priority: %d\n"), task_info->priority);
 786
 787   /* print the task current state.  */
 788   {
 789     int target_taskno = 0;
 790
 791     if (task_info->caller_task)
 792       {
 793         target_taskno = get_task_number_from_id (task_info->caller_task);
 794         printf_filtered (_("State: Accepting rendezvous with %d"),
 795                          target_taskno);
 796       }
 797     else if (task_info->state == Entry_Caller_Sleep && task_info->called_task)
 798       {
 799         target_taskno = get_task_number_from_id (task_info->called_task);
 800         printf_filtered (_("State: Waiting on task %d's entry"),
 801                          target_taskno);
 802       }
 803     else
 804       printf_filtered (_("State: %s"), _(long_task_states[task_info->state]));
 805
 806     if (target_taskno)
 807       {
 808         struct ada_task_info *target_task_info =
 809           VEC_index (ada_task_info_s, task_list, target_taskno - 1);
 810
 811         if (target_task_info->name[0] != '\0')
 812           printf_filtered (" (%s)", target_task_info->name);
 813       }
 814
 815     printf_filtered ("\n");
 816   }
 817 }
 818
 819 /* If ARG is empty or null, then print a list of all Ada tasks.
 820    Otherwise, print detailed information about the task whose ID
 821    is ARG.
 822
 823    Does nothing if the program doesn't use Ada tasking.  */
 824
 825 static void
 826 info_tasks_command (char *arg, int from_tty)
 827 {
 828   const int task_list_built = ada_build_task_list (1);
 829
 830   if (!task_list_built)
 831     return;
 832
 833   if (arg == NULL || *arg == '\0')
 834     info_tasks (from_tty);
 835   else
 836     info_task (arg, from_tty);
 837 }
 838
 839 /* Print a message telling the user id of the current task.
 840    This function assumes that tasking is in use in the inferior.  */
 841
 842 static void
 843 display_current_task_id (void)
 844 {
 845   const int current_task = ada_get_task_number (inferior_ptid);
 846
 847   if (current_task == 0)
 848     printf_filtered (_("[Current task is unknown]\n"));
 849   else
 850     printf_filtered (_("[Current task is %d]\n"), current_task);
 851 }
 852
 853 /* Parse and evaluate TIDSTR into a task id, and try to switch to
 854    that task.  Print an error message if the task switch failed.  */
 855
 856 static void
 857 task_command_1 (char *taskno_str, int from_tty)
 858 {
 859   const int taskno = value_as_long (parse_and_eval (taskno_str));
 860   struct ada_task_info *task_info;
 861
 862   if (taskno <= 0 || taskno > VEC_length (ada_task_info_s, task_list))
 863     error (_("Task ID %d not known.  Use the \"info tasks\" command to\n"
 864              "see the IDs of currently known tasks"), taskno);
 865   task_info = VEC_index (ada_task_info_s, task_list, taskno - 1);
 866
 867   if (!ada_task_is_alive (task_info))
 868     error (_("Cannot switch to task %d: Task is no longer running"), taskno);
 869
 870   /* On some platforms, the thread list is not updated until the user
 871      performs a thread-related operation (by using the "info threads"
 872      command, for instance).  So this thread list may not be up to date
 873      when the user attempts this task switch.  Since we cannot switch
 874      to the thread associated to our task if GDB does not know about
 875      that thread, we need to make sure that any new threads gets added
 876      to the thread list.  */
 877   target_find_new_threads ();
 878
 879   /* Verify that the ptid of the task we want to switch to is valid
 880      (in other words, a ptid that GDB knows about).  Otherwise, we will
 881      cause an assertion failure later on, when we try to determine
 882      the ptid associated thread_info data.  We should normally never
 883      encounter such an error, but the wrong ptid can actually easily be
 884      computed if target_get_ada_task_ptid has not been implemented for
 885      our target (yet).  Rather than cause an assertion error in that case,
 886      it's nicer for the user to just refuse to perform the task switch.  */
 887   if (!find_thread_ptid (task_info->ptid))
 888     error (_("Unable to compute thread ID for task %d.\n"
 889              "Cannot switch to this task."),
 890            taskno);
 891
 892   switch_to_thread (task_info->ptid);
 893   ada_find_printable_frame (get_selected_frame (NULL));
 894   printf_filtered (_("[Switching to task %d]\n"), taskno);
 895   print_stack_frame (get_selected_frame (NULL),
 896                      frame_relative_level (get_selected_frame (NULL)), 1);
 897 }
 898
 899
 900 /* Print the ID of the current task if TASKNO_STR is empty or NULL.
 901    Otherwise, switch to the task indicated by TASKNO_STR.  */
 902
 903 static void
 904 task_command (char *taskno_str, int from_tty)
 905 {
 906   const int task_list_built = ada_build_task_list (1);
 907
 908   if (!task_list_built)
 909     return;
 910
 911   if (taskno_str == NULL || taskno_str[0] == '\0')
 912     display_current_task_id ();
 913   else
 914     {
 915       /* Task switching in core files doesn't work, either because:
 916            1. Thread support is not implemented with core files
 917            2. Thread support is implemented, but the thread IDs created
 918               after having read the core file are not the same as the ones
 919               that were used during the program life, before the crash.
 920               As a consequence, there is no longer a way for the debugger
 921               to find the associated thead ID of any given Ada task.
 922          So, instead of attempting a task switch without giving the user
 923          any clue as to what might have happened, just error-out with
 924          a message explaining that this feature is not supported.  */
 925       if (!target_has_execution)
 926         error (_("\
 927 Task switching not supported when debugging from core files\n\
 928 (use thread support instead)"));
 929       task_command_1 (taskno_str, from_tty);
 930     }
 931 }
 932
 933 /* Indicate that the task list may have changed, so invalidate the cache.  */
 934
 935 static void
 936 ada_task_list_changed (void)
 937 {
 938   stale_task_list_p = 1;
 939 }
 940
 941 /* The 'normal_stop' observer notification callback.  */
 942
 943 static void
 944 ada_normal_stop_observer (struct bpstats *unused_args, int unused_args2)
 945 {
 946   /* The inferior has been resumed, and just stopped. This means that
 947      our task_list needs to be recomputed before it can be used again.  */
 948   ada_task_list_changed ();
 949 }
 950
 951 /* A routine to be called when the objfiles have changed.  */
 952
 953 static void
 954 ada_new_objfile_observer (struct objfile *objfile)
 955 {
 956   /* Invalidate all cached data that were extracted from an objfile.  */
 957
 958   atcb_type = NULL;
 959   atcb_common_type = NULL;
 960   atcb_ll_type = NULL;
 961   atcb_call_type = NULL;
 962
 963   ada_tasks_check_symbol_table = 1;
 964 }
 965
 966 /* Provide a prototype to silence -Wmissing-prototypes.  */
 967 extern initialize_file_ftype _initialize_tasks;
 968
 969 void
 970 _initialize_tasks (void)
 971 {
 972   /* Attach various observers.  */
 973   observer_attach_normal_stop (ada_normal_stop_observer);
 974   observer_attach_new_objfile (ada_new_objfile_observer);
 975
 976   /* Some new commands provided by this module.  */
 977   add_info ("tasks", info_tasks_command,
 978             _("Provide information about all known Ada tasks"));
 979   add_cmd ("task", class_run, task_command,
 980            _("Use this command to switch between Ada tasks.\n\
 981 Without argument, this command simply prints the current task ID"),
 982            &cmdlist);
 983 }
 984