Merge GDB 7.5.1

gdb/ada-tasks.c

 /* Copyright (C) 1992-1994, 1997-2000, 2003-2005, 2007-2012 Free
    Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
@@ skipping 197 matching lines @@
        - ADA_TASKS_ARRAY: The known_tasks is an array;
        - ADA_TASKS_LIST: The known_tasks is a list.  */
   enum ada_known_tasks_kind known_tasks_kind;
 
   /* The address of the known_tasks structure.  This is where
      the runtime stores the information for all Ada tasks.
      The interpretation of this field depends on KNOWN_TASKS_KIND
      above.  */
   CORE_ADDR known_tasks_addr;
 
+  /* Type of elements of the known task.  Usually a pointer.  */
+  struct type *known_tasks_element;
+
+  /* Number of elements in the known tasks array.  */
+  unsigned int known_tasks_length;
+
   /* When nonzero, this flag indicates that the task_list field
      below is up to date.  When set to zero, the list has either
      not been initialized, or has potentially become stale.  */
   int task_list_valid_p;
 
   /* The list of Ada tasks.
 
      Note: To each task we associate a number that the user can use to
      reference it - this number is printed beside each task in the tasks
      info listing displayed by "info tasks".  This number is equal to
@@ skipping 539 matching lines @@
   struct ada_tasks_inferior_data *data = get_ada_tasks_inferior_data (inf);
 
   read_atcb (task_id, &task_info);
   VEC_safe_push (ada_task_info_s, data->task_list, &task_info);
 }
 
 /* Read the Known_Tasks array from the inferior memory, and store
    it in the current inferior's TASK_LIST.  Return non-zero upon success.  */
 
 static int
-read_known_tasks_array (CORE_ADDR known_tasks_addr)
+read_known_tasks_array (struct ada_tasks_inferior_data *data)
 {
-  const int target_ptr_byte =
-    gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT;
-  const int known_tasks_size = target_ptr_byte * MAX_NUMBER_OF_KNOWN_TASKS;
+  const int target_ptr_byte = TYPE_LENGTH (data->known_tasks_element);
+  const int known_tasks_size = target_ptr_byte * data->known_tasks_length;
   gdb_byte *known_tasks = alloca (known_tasks_size);
   int i;
 
   /* Build a new list by reading the ATCBs from the Known_Tasks array
      in the Ada runtime.  */
-  read_memory (known_tasks_addr, known_tasks, known_tasks_size);
-  for (i = 0; i < MAX_NUMBER_OF_KNOWN_TASKS; i++)
+  read_memory (data->known_tasks_addr, known_tasks, known_tasks_size);
+  for (i = 0; i < data->known_tasks_length; i++)
     {
-      struct type *data_ptr_type =
-        builtin_type (target_gdbarch)->builtin_data_ptr;
       CORE_ADDR task_id =
         extract_typed_address (known_tasks + i * target_ptr_byte,
-                               data_ptr_type);
+                               data->known_tasks_element);
 
       if (task_id != 0)
         add_ada_task (task_id, current_inferior ());
     }
 
   return 1;
 }
 
 /* Read the known tasks from the inferior memory, and store it in
    the current inferior's TASK_LIST.  Return non-zero upon success.  */
 
 static int
-read_known_tasks_list (CORE_ADDR known_tasks_addr)
+read_known_tasks_list (struct ada_tasks_inferior_data *data)
 {
-  const int target_ptr_byte =
-    gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT;
+  const int target_ptr_byte = TYPE_LENGTH (data->known_tasks_element);
   gdb_byte *known_tasks = alloca (target_ptr_byte);
-  struct type *data_ptr_type =
-    builtin_type (target_gdbarch)->builtin_data_ptr;
   CORE_ADDR task_id;
   const struct ada_tasks_pspace_data *pspace_data
     = get_ada_tasks_pspace_data (current_program_space);
 
   /* Sanity check.  */
   if (pspace_data->atcb_fieldno.activation_link < 0)
     return 0;
 
   /* Build a new list by reading the ATCBs.  Read head of the list.  */
-  read_memory (known_tasks_addr, known_tasks, target_ptr_byte);
-  task_id = extract_typed_address (known_tasks, data_ptr_type);
+  read_memory (data->known_tasks_addr, known_tasks, target_ptr_byte);
+  task_id = extract_typed_address (known_tasks, data->known_tasks_element);
   while (task_id != 0)
     {
       struct value *tcb_value;
       struct value *common_value;
 
       add_ada_task (task_id, current_inferior ());
 
       /* Read the chain.  */
       tcb_value = value_from_contents_and_address (pspace_data->atcb_type,
                                                    NULL, task_id);
       common_value = value_field (tcb_value, pspace_data->atcb_fieldno.common);
       task_id = value_as_address
                   (value_field (common_value,
                                 pspace_data->atcb_fieldno.activation_link));
     }
 
   return 1;
 }
 
-/* Return the address of the variable NAME that contains all the known
-   tasks maintained in the Ada Runtime.  Return NULL if the variable
-   could not be found, meaning that the inferior program probably does
-   not use tasking.  */
+/* Set all fields of the current inferior ada-tasks data pointed by DATA.
+   Do nothing if those fields are already set and still up to date.  */
 
-static CORE_ADDR
-get_known_tasks_addr (const char *name)
+static void
+ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
 {
   struct minimal_symbol *msym;
+  struct symbol *sym;
 
-  msym = lookup_minimal_symbol (name, NULL, NULL);
-  if (msym == NULL)
-    return 0;
-
-  return SYMBOL_VALUE_ADDRESS (msym);
-}
-
-/* Assuming DATA is the ada-tasks' data for the current inferior,
-   set the known_tasks_kind and known_tasks_addr fields.  Do nothing
-   if those fields are already set and still up to date.  */
-
-static void
-ada_set_current_inferior_known_tasks_addr (struct ada_tasks_inferior_data *data)
-{
-  CORE_ADDR known_tasks_addr;
-
+  /* Return now if already set.  */
   if (data->known_tasks_kind != ADA_TASKS_UNKNOWN)
     return;
 
-  known_tasks_addr = get_known_tasks_addr (KNOWN_TASKS_NAME);
-  if (known_tasks_addr != 0)
+  /* Try array.  */
+
+  msym = lookup_minimal_symbol (KNOWN_TASKS_NAME, NULL, NULL);
+  if (msym != NULL)
     {
       data->known_tasks_kind = ADA_TASKS_ARRAY;
-      data->known_tasks_addr = known_tasks_addr;
+      data->known_tasks_addr = SYMBOL_VALUE_ADDRESS (msym);
+
+      /* Try to get pointer type and array length from the symtab.  */
+      sym = lookup_symbol_in_language (KNOWN_TASKS_NAME, NULL, VAR_DOMAIN,
+                                       language_c, NULL);
+      if (sym != NULL)
+        {
+          /* Validate.  */
+          struct type *type = check_typedef (SYMBOL_TYPE (sym));
+          struct type *eltype = NULL;
+          struct type *idxtype = NULL;
+
+          if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+            eltype = check_typedef (TYPE_TARGET_TYPE (type));
+          if (eltype != NULL
+              && TYPE_CODE (eltype) == TYPE_CODE_PTR)
+            idxtype = check_typedef (TYPE_INDEX_TYPE (type));
+          if (idxtype != NULL
+              && !TYPE_LOW_BOUND_UNDEFINED (idxtype)
+              && !TYPE_HIGH_BOUND_UNDEFINED (idxtype))
+            {
+              data->known_tasks_element = eltype;
+              data->known_tasks_length =
+                TYPE_HIGH_BOUND (idxtype) - TYPE_LOW_BOUND (idxtype) + 1;
+              return;
+            }
+        }
+
+      /* Fallback to default values.  The runtime may have been stripped (as
+         in some distributions), but it is likely that the executable still
+         contains debug information on the task type (due to implicit with of
+         Ada.Tasking).  */
+      data->known_tasks_element =
+        builtin_type (target_gdbarch)->builtin_data_ptr;
+      data->known_tasks_length = MAX_NUMBER_OF_KNOWN_TASKS;
       return;
     }
 
-  known_tasks_addr = get_known_tasks_addr (KNOWN_TASKS_LIST);
-  if (known_tasks_addr != 0)
+
+  /* Try list.  */
+
+  msym = lookup_minimal_symbol (KNOWN_TASKS_LIST, NULL, NULL);
+  if (msym != NULL)
     {
       data->known_tasks_kind = ADA_TASKS_LIST;
-      data->known_tasks_addr = known_tasks_addr;
+      data->known_tasks_addr = SYMBOL_VALUE_ADDRESS (msym);
+      data->known_tasks_length = 1;
+
+      sym = lookup_symbol_in_language (KNOWN_TASKS_LIST, NULL, VAR_DOMAIN,
+                                       language_c, NULL);
+      if (sym != NULL && SYMBOL_VALUE_ADDRESS (sym) != 0)
+        {
+          /* Validate.  */
+          struct type *type = check_typedef (SYMBOL_TYPE (sym));
+
+          if (TYPE_CODE (type) == TYPE_CODE_PTR)
+            {
+              data->known_tasks_element = type;
+              return;
+            }
+        }
+
+      /* Fallback to default values.  */
+      data->known_tasks_element =
+        builtin_type (target_gdbarch)->builtin_data_ptr;
+      data->known_tasks_length = 1;
       return;
     }
 
+  /* Can't find tasks.  */
+
   data->known_tasks_kind = ADA_TASKS_NOT_FOUND;
   data->known_tasks_addr = 0;
 }
 
 /* Read the known tasks from the current inferior's memory, and store it
    in the current inferior's data TASK_LIST.
    Return non-zero upon success.  */
 
 static int
 read_known_tasks (void)
 {
   struct ada_tasks_inferior_data *data =
     get_ada_tasks_inferior_data (current_inferior ());
 
   /* Step 1: Clear the current list, if necessary.  */
   VEC_truncate (ada_task_info_s, data->task_list, 0);
 
   /* Step 2: do the real work.
      If the application does not use task, then no more needs to be done.
      It is important to have the task list cleared (see above) before we
      return, as we don't want a stale task list to be used...  This can
      happen for instance when debugging a non-multitasking program after
      having debugged a multitasking one.  */
-  ada_set_current_inferior_known_tasks_addr (data);
+  ada_tasks_inferior_data_sniffer (data);
   gdb_assert (data->known_tasks_kind != ADA_TASKS_UNKNOWN);
 
   switch (data->known_tasks_kind)
     {
       case ADA_TASKS_NOT_FOUND: /* Tasking not in use in inferior.  */
         return 0;
       case ADA_TASKS_ARRAY:
-        return read_known_tasks_array (data->known_tasks_addr);
+        return read_known_tasks_array (data);
       case ADA_TASKS_LIST:
-        return read_known_tasks_list (data->known_tasks_addr);
+        return read_known_tasks_list (data);
     }
 
   /* Step 3: Set task_list_valid_p, to avoid re-reading the Known_Tasks
      array unless needed.  Then report a success.  */
   data->task_list_valid_p = 1;
 
   return 1;
 }
 
 /* Build the task_list by reading the Known_Tasks array from
@@ skipping 465 matching lines @@
 
   /* Some new commands provided by this module.  */
   add_info ("tasks", info_tasks_command,
             _("Provide information about all known Ada tasks"));
   add_cmd ("task", class_run, task_command,
            _("Use this command to switch between Ada tasks.\n\
 Without argument, this command simply prints the current task ID"),
            &cmdlist);
 }