OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [ada-tasks.c] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* 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
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.