Merge GDB 7.5.1

gdb/ada-varobj.c

+/* varobj support for Ada.
+
+   Copyright (C) 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.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "defs.h"
+#include "ada-varobj.h"
+#include "ada-lang.h"
+#include "language.h"
+#include "valprint.h"
+
+/* Implementation principle used in this unit:
+
+   For our purposes, the meat of the varobj object is made of two
+   elements: The varobj's (struct) value, and the varobj's (struct)
+   type.  In most situations, the varobj has a non-NULL value, and
+   the type becomes redundant, as it can be directly derived from
+   the value.  In the initial implementation of this unit, most
+   routines would only take a value, and return a value.
+
+   But there are many situations where it is possible for a varobj
+   to have a NULL value.  For instance, if the varobj becomes out of
+   scope.  Or better yet, when the varobj is the child of another
+   NULL pointer varobj.  In that situation, we must rely on the type
+   instead of the value to create the child varobj.
+
+   That's why most functions below work with a (value, type) pair.
+   The value may or may not be NULL.  But the type is always expected
+   to be set.  When the value is NULL, then we work with the type
+   alone, and keep the value NULL.  But when the value is not NULL,
+   then we work using the value, because it provides more information.
+   But we still always set the type as well, even if that type could
+   easily be derived from the value.  The reason behind this is that
+   it allows the code to use the type without having to worry about
+   it being set or not.  It makes the code clearer.  */
+
+/* A convenience function that decodes the VALUE_PTR/TYPE_PTR couple:
+   If there is a value (*VALUE_PTR not NULL), then perform the decoding
+   using it, and compute the associated type from the resulting value.
+   Otherwise, compute a static approximation of *TYPE_PTR, leaving
+   *VALUE_PTR unchanged.
+
+   The results are written in place.  */
+
+static void
+ada_varobj_decode_var (struct value **value_ptr, struct type **type_ptr)
+{
+  if (*value_ptr)
+    {
+      *value_ptr = ada_get_decoded_value (*value_ptr);
+      *type_ptr = ada_check_typedef (value_type (*value_ptr));
+    }
+  else
+    *type_ptr = ada_get_decoded_type (*type_ptr);
+}
+
+/* Return a string containing an image of the given scalar value.
+   VAL is the numeric value, while TYPE is the value's type.
+   This is useful for plain integers, of course, but even more
+   so for enumerated types.
+
+   The result should be deallocated by xfree after use.  */
+
+static char *
+ada_varobj_scalar_image (struct type *type, LONGEST val)
+{
+  struct ui_file *buf = mem_fileopen ();
+  struct cleanup *cleanups = make_cleanup_ui_file_delete (buf);
+  char *result;
+
+  ada_print_scalar (type, val, buf);
+  result = ui_file_xstrdup (buf, NULL);
+  do_cleanups (cleanups);
+
+  return result;
+}
+
+/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair designates
+   a struct or union, compute the (CHILD_VALUE, CHILD_TYPE) couple
+   corresponding to the field number FIELDNO.  */
+
+static void
+ada_varobj_struct_elt (struct value *parent_value,
+                       struct type *parent_type,
+                       int fieldno,
+                       struct value **child_value,
+                       struct type **child_type)
+{
+  struct value *value = NULL;
+  struct type *type = NULL;
+
+  if (parent_value)
+    {
+      value = value_field (parent_value, fieldno);
+      type = value_type (value);
+    }
+  else
+    type = TYPE_FIELD_TYPE (parent_type, fieldno);
+
+  if (child_value)
+    *child_value = value;
+  if (child_type)
+    *child_type = type;
+}
+
+/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is a pointer or
+   reference, return a (CHILD_VALUE, CHILD_TYPE) couple corresponding
+   to the dereferenced value.  */
+
+static void
+ada_varobj_ind (struct value *parent_value,
+                struct type *parent_type,
+                struct value **child_value,
+                struct type **child_type)
+{
+  struct value *value = NULL;
+  struct type *type = NULL;
+
+  if (ada_is_array_descriptor_type (parent_type))
+    {
+      /* This can only happen when PARENT_VALUE is NULL.  Otherwise,
+         ada_get_decoded_value would have transformed our parent_type
+         into a simple array pointer type.  */
+      gdb_assert (parent_value == NULL);
+      gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF);
+
+      /* Decode parent_type by the equivalent pointer to (decoded)
+         array.  */
+      while (TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF)
+        parent_type = TYPE_TARGET_TYPE (parent_type);
+      parent_type = ada_coerce_to_simple_array_type (parent_type);
+      parent_type = lookup_pointer_type (parent_type);
+    }
+
+  /* If parent_value is a null pointer, then only perform static
+     dereferencing.  We cannot dereference null pointers.  */
+  if (parent_value && value_as_address (parent_value) == 0)
+    parent_value = NULL;
+
+  if (parent_value)
+    {
+      value = ada_value_ind (parent_value);
+      type = value_type (value);
+    }
+  else
+    type = TYPE_TARGET_TYPE (parent_type);
+
+  if (child_value)
+    *child_value = value;
+  if (child_type)
+    *child_type = type;
+}
+
+/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is a simple
+   array (TYPE_CODE_ARRAY), return the (CHILD_VALUE, CHILD_TYPE)
+   pair corresponding to the element at ELT_INDEX.  */
+
+static void
+ada_varobj_simple_array_elt (struct value *parent_value,
+                             struct type *parent_type,
+                             int elt_index,
+                             struct value **child_value,
+                             struct type **child_type)
+{
+  struct value *value = NULL;
+  struct type *type = NULL;
+
+  if (parent_value)
+    {
+      struct value *index_value =
+        value_from_longest (TYPE_INDEX_TYPE (parent_type), elt_index);
+
+      value = ada_value_subscript (parent_value, 1, &index_value);
+      type = value_type (value);
+    }
+  else
+    type = TYPE_TARGET_TYPE (parent_type);
+
+  if (child_value)
+    *child_value = value;
+  if (child_type)
+    *child_type = type;
+}
+
+/* Given the decoded value and decoded type of a variable object,
+   adjust the value and type to those necessary for getting children
+   of the variable object.
+
+   The replacement is performed in place.  */
+
+static void
+ada_varobj_adjust_for_child_access (struct value **value,
+                                    struct type **type)
+{
+   /* Pointers to struct/union types are special: Instead of having
+      one child (the struct), their children are the components of
+      the struct/union type.  We handle this situation by dereferencing
+      the (value, type) couple.  */
+  if (TYPE_CODE (*type) == TYPE_CODE_PTR
+      && (TYPE_CODE (TYPE_TARGET_TYPE (*type)) == TYPE_CODE_STRUCT
+          || TYPE_CODE (TYPE_TARGET_TYPE (*type)) == TYPE_CODE_UNION)
+      && !ada_is_array_descriptor_type (TYPE_TARGET_TYPE (*type))
+      && !ada_is_constrained_packed_array_type (TYPE_TARGET_TYPE (*type)))
+    ada_varobj_ind (*value, *type, value, type);
+}
+
+/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is an array
+   (any type of array, "simple" or not), return the number of children
+   that this array contains.  */
+
+static int
+ada_varobj_get_array_number_of_children (struct value *parent_value,
+                                         struct type *parent_type)
+{
+  LONGEST lo, hi;
+
+  if (!get_array_bounds (parent_type, &lo, &hi))
+    {
+      /* Could not get the array bounds.  Pretend this is an empty array.  */
+      warning (_("unable to get bounds of array, assuming null array"));
+      return 0;
+    }
+
+  /* Ada allows the upper bound to be less than the lower bound,
+     in order to specify empty arrays...  */
+  if (hi < lo)
+    return 0;
+
+  return hi - lo + 1;
+}
+
+/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is a struct or
+   union, return the number of children this struct contains.  */
+
+static int
+ada_varobj_get_struct_number_of_children (struct value *parent_value,
+                                          struct type *parent_type)
+{
+  int n_children = 0;
+  int i;
+
+  gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT
+              || TYPE_CODE (parent_type) == TYPE_CODE_UNION);
+
+  for (i = 0; i < TYPE_NFIELDS (parent_type); i++)
+    {
+      if (ada_is_ignored_field (parent_type, i))
+        continue;
+
+      if (ada_is_wrapper_field (parent_type, i))
+        {
+          struct value *elt_value;
+          struct type *elt_type;
+
+          ada_varobj_struct_elt (parent_value, parent_type, i,
+                                 &elt_value, &elt_type);
+          if (ada_is_tagged_type (elt_type, 0))
+            {
+              /* We must not use ada_varobj_get_number_of_children
+                 to determine is element's number of children, because
+                 this function first calls ada_varobj_decode_var,
+                 which "fixes" the element.  For tagged types, this
+                 includes reading the object's tag to determine its
+                 real type, which happens to be the parent_type, and
+                 leads to an infinite loop (because the element gets
+                 fixed back into the parent).  */
+              n_children += ada_varobj_get_struct_number_of_children
+                (elt_value, elt_type);
+            }
+          else
+            n_children += ada_varobj_get_number_of_children (elt_value, elt_type);
+        }
+      else if (ada_is_variant_part (parent_type, i))
+        {
+          /* In normal situations, the variant part of the record should
+             have been "fixed". Or, in other words, it should have been
+             replaced by the branch of the variant part that is relevant
+             for our value.  But there are still situations where this
+             can happen, however (Eg. when our parent is a NULL pointer).
+             We do not support showing this part of the record for now,
+             so just pretend this field does not exist.  */
+        }
+      else
+        n_children++;
+    }
+
+  return n_children;
+}
+
+/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair designates
+   a pointer, return the number of children this pointer has.  */
+
+static int
+ada_varobj_get_ptr_number_of_children (struct value *parent_value,
+                                       struct type *parent_type)
+{
+  struct type *child_type = TYPE_TARGET_TYPE (parent_type);
+
+  /* Pointer to functions and to void do not have a child, since
+     you cannot print what they point to.  */
+  if (TYPE_CODE (child_type) == TYPE_CODE_FUNC
+      || TYPE_CODE (child_type) == TYPE_CODE_VOID)
+    return 0;
+
+  /* All other types have 1 child.  */
+  return 1;
+}
+
+/* Return the number of children for the (PARENT_VALUE, PARENT_TYPE)
+   pair.  */
+
+int
+ada_varobj_get_number_of_children (struct value *parent_value,
+                                   struct type *parent_type)
+{
+  ada_varobj_decode_var (&parent_value, &parent_type);
+  ada_varobj_adjust_for_child_access (&parent_value, &parent_type);
+
+  /* A typedef to an array descriptor in fact represents a pointer
+     to an unconstrained array.  These types always have one child
+     (the unconstrained array).  */
+  if (ada_is_array_descriptor_type (parent_type)
+      && TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF)
+    return 1;
+
+  if (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY)
+    return ada_varobj_get_array_number_of_children (parent_value,
+                                                    parent_type);
+
+  if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT
+      || TYPE_CODE (parent_type) == TYPE_CODE_UNION)
+    return ada_varobj_get_struct_number_of_children (parent_value,
+                                                     parent_type);
+
+  if (TYPE_CODE (parent_type) == TYPE_CODE_PTR)
+    return ada_varobj_get_ptr_number_of_children (parent_value,
+                                                  parent_type);
+
+  /* All other types have no child.  */
+  return 0;
+}
+
+/* Describe the child of the (PARENT_VALUE, PARENT_TYPE) pair
+   whose index is CHILD_INDEX:
+
+     - If CHILD_NAME is not NULL, then a copy of the child's name
+       is saved in *CHILD_NAME.  This copy must be deallocated
+       with xfree after use.
+
+     - If CHILD_VALUE is not NULL, then save the child's value
+       in *CHILD_VALUE. Same thing for the child's type with
+       CHILD_TYPE if not NULL.
+
+     - If CHILD_PATH_EXPR is not NULL, then compute the child's
+       path expression.  The resulting string must be deallocated
+       after use with xfree.
+
+       Computing the child's path expression requires the PARENT_PATH_EXPR
+       to be non-NULL.  Otherwise, PARENT_PATH_EXPR may be null if
+       CHILD_PATH_EXPR is NULL.
+
+  PARENT_NAME is the name of the parent, and should never be NULL.  */
+
+static void ada_varobj_describe_child (struct value *parent_value,
+                                       struct type *parent_type,
+                                       const char *parent_name,
+                                       const char *parent_path_expr,
+                                       int child_index,
+                                       char **child_name,
+                                       struct value **child_value,
+                                       struct type **child_type,
+                                       char **child_path_expr);
+
+/* Same as ada_varobj_describe_child, but limited to struct/union
+   objects.  */
+
+static void
+ada_varobj_describe_struct_child (struct value *parent_value,
+                                  struct type *parent_type,
+                                  const char *parent_name,
+                                  const char *parent_path_expr,
+                                  int child_index,
+                                  char **child_name,
+                                  struct value **child_value,
+                                  struct type **child_type,
+                                  char **child_path_expr)
+{
+  int fieldno;
+  int childno = 0;
+
+  gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT);
+
+  for (fieldno = 0; fieldno < TYPE_NFIELDS (parent_type); fieldno++)
+    {
+      if (ada_is_ignored_field (parent_type, fieldno))
+        continue;
+
+      if (ada_is_wrapper_field (parent_type, fieldno))
+        {
+          struct value *elt_value;
+          struct type *elt_type;
+          int elt_n_children;
+
+          ada_varobj_struct_elt (parent_value, parent_type, fieldno,
+                                 &elt_value, &elt_type);
+          if (ada_is_tagged_type (elt_type, 0))
+            {
+              /* Same as in ada_varobj_get_struct_number_of_children:
+                 For tagged types, we must be careful to not call
+                 ada_varobj_get_number_of_children, to prevent our
+                 element from being fixed back into the parent.  */
+              elt_n_children = ada_varobj_get_struct_number_of_children
+                (elt_value, elt_type);
+            }
+          else
+            elt_n_children =
+              ada_varobj_get_number_of_children (elt_value, elt_type);
+
+          /* Is the child we're looking for one of the children
+             of this wrapper field?  */
+          if (child_index - childno < elt_n_children)
+            {
+              if (ada_is_tagged_type (elt_type, 0))
+                {
+                  /* Same as in ada_varobj_get_struct_number_of_children:
+                     For tagged types, we must be careful to not call
+                     ada_varobj_describe_child, to prevent our element
+                     from being fixed back into the parent.  */
+                  ada_varobj_describe_struct_child
+                    (elt_value, elt_type, parent_name, parent_path_expr,
+                     child_index - childno, child_name, child_value,
+                     child_type, child_path_expr);
+                }
+              else
+                ada_varobj_describe_child (elt_value, elt_type,
+                                           parent_name, parent_path_expr,
+                                           child_index - childno,
+                                           child_name, child_value,
+                                           child_type, child_path_expr);
+              return;
+            }
+
+          /* The child we're looking for is beyond this wrapper
+             field, so skip all its children.  */
+          childno += elt_n_children;
+          continue;
+        }
+      else if (ada_is_variant_part (parent_type, fieldno))
+        {
+          /* In normal situations, the variant part of the record should
+             have been "fixed". Or, in other words, it should have been
+             replaced by the branch of the variant part that is relevant
+             for our value.  But there are still situations where this
+             can happen, however (Eg. when our parent is a NULL pointer).
+             We do not support showing this part of the record for now,
+             so just pretend this field does not exist.  */
+          continue;
+        }
+
+      if (childno == child_index)
+        {
+          if (child_name)
+            {
+              /* The name of the child is none other than the field's
+                 name, except that we need to strip suffixes from it.
+                 For instance, fields with alignment constraints will
+                 have an __XVA suffix added to them.  */
+              const char *field_name = TYPE_FIELD_NAME (parent_type, fieldno);
+              int child_name_len = ada_name_prefix_len (field_name);
+
+              *child_name = xstrprintf ("%.*s", child_name_len, field_name);
+            }
+
+          if (child_value && parent_value)
+            ada_varobj_struct_elt (parent_value, parent_type, fieldno,
+                                   child_value, NULL);
+
+          if (child_type)
+            ada_varobj_struct_elt (parent_value, parent_type, fieldno,
+                                   NULL, child_type);
+
+          if (child_path_expr)
+            {
+              /* The name of the child is none other than the field's
+                 name, except that we need to strip suffixes from it.
+                 For instance, fields with alignment constraints will
+                 have an __XVA suffix added to them.  */
+              const char *field_name = TYPE_FIELD_NAME (parent_type, fieldno);
+              int child_name_len = ada_name_prefix_len (field_name);
+
+              *child_path_expr =
+                xstrprintf ("(%s).%.*s", parent_path_expr,
+                            child_name_len, field_name);
+            }
+
+          return;
+        }
+
+      childno++;
+    }
+
+  /* Something went wrong.  Either we miscounted the number of
+     children, or CHILD_INDEX was too high.  But we should never
+     reach here.  We don't have enough information to recover
+     nicely, so just raise an assertion failure.  */
+  gdb_assert_not_reached ("unexpected code path");
+}
+
+/* Same as ada_varobj_describe_child, but limited to pointer objects.
+
+   Note that CHILD_INDEX is unused in this situation, but still provided
+   for consistency of interface with other routines describing an object's
+   child.  */
+
+static void
+ada_varobj_describe_ptr_child (struct value *parent_value,
+                               struct type *parent_type,
+                               const char *parent_name,
+                               const char *parent_path_expr,
+                               int child_index,
+                               char **child_name,
+                               struct value **child_value,
+                               struct type **child_type,
+                               char **child_path_expr)
+{
+  if (child_name)
+    *child_name = xstrprintf ("%s.all", parent_name);
+
+  if (child_value && parent_value)
+    ada_varobj_ind (parent_value, parent_type, child_value, NULL);
+
+  if (child_type)
+    ada_varobj_ind (parent_value, parent_type, NULL, child_type);
+
+  if (child_path_expr)
+    *child_path_expr = xstrprintf ("(%s).all", parent_path_expr);
+}
+
+/* Same as ada_varobj_describe_child, limited to simple array objects
+   (TYPE_CODE_ARRAY only).
+
+   Assumes that the (PARENT_VALUE, PARENT_TYPE) pair is properly decoded.
+   This is done by ada_varobj_describe_child before calling us.  */
+
+static void
+ada_varobj_describe_simple_array_child (struct value *parent_value,
+                                        struct type *parent_type,
+                                        const char *parent_name,
+                                        const char *parent_path_expr,
+                                        int child_index,
+                                        char **child_name,
+                                        struct value **child_value,
+                                        struct type **child_type,
+                                        char **child_path_expr)
+{
+  struct type *index_desc_type;
+  struct type *index_type;
+  int real_index;
+
+  gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY);
+
+  index_desc_type = ada_find_parallel_type (parent_type, "___XA");
+  ada_fixup_array_indexes_type (index_desc_type);
+  if (index_desc_type)
+    index_type = TYPE_FIELD_TYPE (index_desc_type, 0);
+  else
+    index_type = TYPE_INDEX_TYPE (parent_type);
+  real_index = child_index + ada_discrete_type_low_bound (index_type);
+
+  if (child_name)
+    *child_name = ada_varobj_scalar_image (index_type, real_index);
+
+  if (child_value && parent_value)
+    ada_varobj_simple_array_elt (parent_value, parent_type, real_index,
+                                 child_value, NULL);
+
+  if (child_type)
+    ada_varobj_simple_array_elt (parent_value, parent_type, real_index,
+                                 NULL, child_type);
+
+  if (child_path_expr)
+    {
+      char *index_img = ada_varobj_scalar_image (index_type, real_index);
+      struct cleanup *cleanups = make_cleanup (xfree, index_img);
+
+      /* Enumeration litterals by themselves are potentially ambiguous.
+         For instance, consider the following package spec:
+
+            package Pck is
+               type Color is (Red, Green, Blue, White);
+               type Blood_Cells is (White, Red);
+            end Pck;
+
+         In this case, the litteral "red" for instance, or even
+         the fully-qualified litteral "pck.red" cannot be resolved
+         by itself.  Type qualification is needed to determine which
+         enumeration litterals should be used.
+
+         The following variable will be used to contain the name
+         of the array index type when such type qualification is
+         needed.  */
+      const char *index_type_name = NULL;
+
+      /* If the index type is a range type, find the base type.  */
+      while (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
+        index_type = TYPE_TARGET_TYPE (index_type);
+
+      if (TYPE_CODE (index_type) == TYPE_CODE_ENUM
+          || TYPE_CODE (index_type) == TYPE_CODE_BOOL)
+        {
+          index_type_name = ada_type_name (index_type);
+          if (index_type_name)
+            index_type_name = ada_decode (index_type_name);
+        }
+
+      if (index_type_name != NULL)
+        *child_path_expr =
+          xstrprintf ("(%s)(%.*s'(%s))", parent_path_expr,
+                      ada_name_prefix_len (index_type_name),
+                      index_type_name, index_img);
+      else
+        *child_path_expr =
+          xstrprintf ("(%s)(%s)", parent_path_expr, index_img);
+      do_cleanups (cleanups);
+    }
+}
+
+/* See description at declaration above.  */
+
+static void
+ada_varobj_describe_child (struct value *parent_value,
+                           struct type *parent_type,
+                           const char *parent_name,
+                           const char *parent_path_expr,
+                           int child_index,
+                           char **child_name,
+                           struct value **child_value,
+                           struct type **child_type,
+                           char **child_path_expr)
+{
+  /* We cannot compute the child's path expression without
+     the parent's path expression.  This is a pre-condition
+     for calling this function.  */
+  if (child_path_expr)
+    gdb_assert (parent_path_expr != NULL);
+
+  ada_varobj_decode_var (&parent_value, &parent_type);
+  ada_varobj_adjust_for_child_access (&parent_value, &parent_type);
+
+  if (child_name)
+    *child_name = NULL;
+  if (child_value)
+    *child_value = NULL;
+  if (child_type)
+    *child_type = NULL;
+  if (child_path_expr)
+    *child_path_expr = NULL;
+
+  if (ada_is_array_descriptor_type (parent_type)
+      && TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF)
+    {
+      ada_varobj_describe_ptr_child (parent_value, parent_type,
+                                     parent_name, parent_path_expr,
+                                     child_index, child_name,
+                                     child_value, child_type,
+                                     child_path_expr);
+      return;
+    }
+
+  if (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY)
+    {
+      ada_varobj_describe_simple_array_child
+        (parent_value, parent_type, parent_name, parent_path_expr,
+         child_index, child_name, child_value, child_type,
+         child_path_expr);
+      return;
+    }
+
+  if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT)
+    {
+      ada_varobj_describe_struct_child (parent_value, parent_type,
+                                        parent_name, parent_path_expr,
+                                        child_index, child_name,
+                                        child_value, child_type,
+                                        child_path_expr);
+      return;
+    }
+
+  if (TYPE_CODE (parent_type) == TYPE_CODE_PTR)
+    {
+      ada_varobj_describe_ptr_child (parent_value, parent_type,
+                                     parent_name, parent_path_expr,
+                                     child_index, child_name,
+                                     child_value, child_type,
+                                     child_path_expr);
+      return;
+    }
+
+  /* It should never happen.  But rather than crash, report dummy names
+     and return a NULL child_value.  */
+  if (child_name)
+    *child_name = xstrdup ("???");
+}
+
+/* Return the name of the child number CHILD_INDEX of the (PARENT_VALUE,
+   PARENT_TYPE) pair.  PARENT_NAME is the name of the PARENT.
+
+   The result should be deallocated after use with xfree.  */
+
+char *
+ada_varobj_get_name_of_child (struct value *parent_value,
+                              struct type *parent_type,
+                              const char *parent_name, int child_index)
+{
+  char *child_name;
+
+  ada_varobj_describe_child (parent_value, parent_type, parent_name,
+                             NULL, child_index, &child_name, NULL,
+                             NULL, NULL);
+  return child_name;
+}
+
+/* Return the path expression of the child number CHILD_INDEX of
+   the (PARENT_VALUE, PARENT_TYPE) pair.  PARENT_NAME is the name
+   of the parent, and PARENT_PATH_EXPR is the parent's path expression.
+   Both must be non-NULL.
+
+   The result must be deallocated after use with xfree.  */
+
+char *
+ada_varobj_get_path_expr_of_child (struct value *parent_value,
+                                   struct type *parent_type,
+                                   const char *parent_name,
+                                   const char *parent_path_expr,
+                                   int child_index)
+{
+  char *child_path_expr;
+
+  ada_varobj_describe_child (parent_value, parent_type, parent_name,
+                             parent_path_expr, child_index, NULL,
+                             NULL, NULL, &child_path_expr);
+
+  return child_path_expr;
+}
+
+/* Return the value of child number CHILD_INDEX of the (PARENT_VALUE,
+   PARENT_TYPE) pair.  PARENT_NAME is the name of the parent.  */
+
+struct value *
+ada_varobj_get_value_of_child (struct value *parent_value,
+                               struct type *parent_type,
+                               const char *parent_name, int child_index)
+{
+  struct value *child_value;
+
+  ada_varobj_describe_child (parent_value, parent_type, parent_name,
+                             NULL, child_index, NULL, &child_value,
+                             NULL, NULL);
+
+  return child_value;
+}
+
+/* Return the type of child number CHILD_INDEX of the (PARENT_VALUE,
+   PARENT_TYPE) pair.  */
+
+struct type *
+ada_varobj_get_type_of_child (struct value *parent_value,
+                              struct type *parent_type,
+                              int child_index)
+{
+  struct type *child_type;
+
+  ada_varobj_describe_child (parent_value, parent_type, NULL, NULL,
+                             child_index, NULL, NULL, &child_type, NULL);
+
+  return child_type;
+}
+
+/* Return a string that contains the image of the given VALUE, using
+   the print options OPTS as the options for formatting the result.
+
+   The resulting string must be deallocated after use with xfree.  */
+
+static char *
+ada_varobj_get_value_image (struct value *value,
+                            struct value_print_options *opts)
+{
+  char *result;
+  struct ui_file *buffer;
+  struct cleanup *old_chain;
+
+  buffer = mem_fileopen ();
+  old_chain = make_cleanup_ui_file_delete (buffer);
+
+  common_val_print (value, buffer, 0, opts, current_language);
+  result = ui_file_xstrdup (buffer, NULL);
+
+  do_cleanups (old_chain);
+  return result;
+}
+
+/* Assuming that the (VALUE, TYPE) pair designates an array varobj,
+   return a string that is suitable for use in the "value" field of
+   the varobj output.  Most of the time, this is the number of elements
+   in the array inside square brackets, but there are situations where
+   it's useful to add more info.
+
+   OPTS are the print options used when formatting the result.
+
+   The result should be deallocated after use using xfree.  */
+
+static char *
+ada_varobj_get_value_of_array_variable (struct value *value,
+                                        struct type *type,
+                                        struct value_print_options *opts)
+{
+  char *result;
+  const int numchild = ada_varobj_get_array_number_of_children (value, type);
+
+  /* If we have a string, provide its contents in the "value" field.
+     Otherwise, the only other way to inspect the contents of the string
+     is by looking at the value of each element, as in any other array,
+     which is not very convenient...  */
+  if (value
+      && ada_is_string_type (type)
+      && (opts->format == 0 || opts->format == 's'))
+    {
+      char *str;
+      struct cleanup *old_chain;
+
+      str = ada_varobj_get_value_image (value, opts);
+      old_chain = make_cleanup (xfree, str);
+      result = xstrprintf ("[%d] %s", numchild, str);
+      do_cleanups (old_chain);
+    }
+  else
+    result = xstrprintf ("[%d]", numchild);
+
+  return result;
+}
+
+/* Return a string representation of the (VALUE, TYPE) pair, using
+   the given print options OPTS as our formatting options.  */
+
+char *
+ada_varobj_get_value_of_variable (struct value *value,
+                                  struct type *type,
+                                  struct value_print_options *opts)
+{
+  char *result = NULL;
+
+  ada_varobj_decode_var (&value, &type);
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_STRUCT:
+    case TYPE_CODE_UNION:
+      result = xstrdup ("{...}");
+      break;
+    case TYPE_CODE_ARRAY:
+      result = ada_varobj_get_value_of_array_variable (value, type, opts);
+      break;
+    default:
+      if (!value)
+        result = xstrdup ("");
+      else
+        result = ada_varobj_get_value_image (value, opts);
+      break;
+    }
+
+  return result;
+}
+
+