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, 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 switch_to_thread (task_info->ptid); 880 ada_find_printable_frame (get_selected_frame (NULL)); 881 printf_filtered (_("[Switching to task %d]\n"), taskno); 882 print_stack_frame (get_selected_frame (NULL), 883 frame_relative_level (get_selected_frame (NULL)), 1); 884 } 885 886 887 /* Print the ID of the current task if TASKNO_STR is empty or NULL. 888 Otherwise, switch to the task indicated by TASKNO_STR. */ 889 890 static void 891 task_command (char *taskno_str, int from_tty) 892 { 893 const int task_list_built = ada_build_task_list (1); 894 895 if (!task_list_built) 896 return; 897 898 if (taskno_str == NULL || taskno_str[0] == '\0') 899 display_current_task_id (); 900 else 901 { 902 /* Task switching in core files doesn't work, either because: 903 1. Thread support is not implemented with core files 904 2. Thread support is implemented, but the thread IDs created 905 after having read the core file are not the same as the ones 906 that were used during the program life, before the crash. 907 As a consequence, there is no longer a way for the debugger 908 to find the associated thead ID of any given Ada task. 909 So, instead of attempting a task switch without giving the user 910 any clue as to what might have happened, just error-out with 911 a message explaining that this feature is not supported. */ 912 if (!target_has_execution) 913 error (_("\ 914 Task switching not supported when debugging from core files\n\ 915 (use thread support instead)")); 916 task_command_1 (taskno_str, from_tty); 917 } 918 } 919 920 /* Indicate that the task list may have changed, so invalidate the cache. */ 921 922 static void 923 ada_task_list_changed (void) 924 { 925 stale_task_list_p = 1; 926 } 927 928 /* The 'normal_stop' observer notification callback. */ 929 930 static void 931 ada_normal_stop_observer (struct bpstats *unused_args, int unused_args2) 932 { 933 /* The inferior has been resumed, and just stopped. This means that 934 our task_list needs to be recomputed before it can be used again. */ 935 ada_task_list_changed (); 936 } 937 938 /* A routine to be called when the objfiles have changed. */ 939 940 static void 941 ada_new_objfile_observer (struct objfile *objfile) 942 { 943 /* Invalidate all cached data that were extracted from an objfile. */ 944 945 atcb_type = NULL; 946 atcb_common_type = NULL; 947 atcb_ll_type = NULL; 948 atcb_call_type = NULL; 949 950 ada_tasks_check_symbol_table = 1; 951 } 952 953 /* Provide a prototype to silence -Wmissing-prototypes. */ 954 extern initialize_file_ftype _initialize_tasks; 955 956 void 957 _initialize_tasks (void) 958 { 959 /* Attach various observers. */ 960 observer_attach_normal_stop (ada_normal_stop_observer); 961 observer_attach_new_objfile (ada_new_objfile_observer); 962 963 /* Some new commands provided by this module. */ 964 add_info ("tasks", info_tasks_command, 965 _("Provide information about all known Ada tasks")); 966 add_cmd ("task", class_run, task_command, 967 _("Use this command to switch between Ada tasks.\n\ 968 Without argument, this command simply prints the current task ID"), 969 &cmdlist); 970 } 971 972