Fix ARI warning about function names in first column.

[deliverable/binutils-gdb.git] / gdb / gdbtypes.c

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 94ae1792f774f89bcc2203416a5da5a2fa11f573..91fafa21524fea912fd2b985185feec52dc8b1db 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1955,6 +1955,68 @@ is_integral_type (struct type *t)
         || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
 }
 
+/* Return true if TYPE is scalar.  */
+
+static int
+is_scalar_type (struct type *type)
+{
+  CHECK_TYPEDEF (type);
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_ARRAY:
+    case TYPE_CODE_STRUCT:
+    case TYPE_CODE_UNION:
+    case TYPE_CODE_SET:
+    case TYPE_CODE_STRING:
+    case TYPE_CODE_BITSTRING:
+      return 0;
+    default:
+      return 1;
+    }
+}
+
+/* Return true if T is scalar, or a composite type which in practice has
+   the memory layout of a scalar type.  E.g., an array or struct with only
+   one scalar element inside it, or a union with only scalar elements.  */
+
+int
+is_scalar_type_recursive (struct type *t)
+{
+  CHECK_TYPEDEF (t);
+
+  if (is_scalar_type (t))
+    return 1;
+  /* Are we dealing with an array or string of known dimensions?  */
+  else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
+           || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
+          && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
+    {
+      LONGEST low_bound, high_bound;
+      struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
+
+      get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
+
+      return high_bound == low_bound && is_scalar_type_recursive (elt_type);
+    }
+  /* Are we dealing with a struct with one element?  */
+  else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
+    return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
+  else if (TYPE_CODE (t) == TYPE_CODE_UNION)
+    {
+      int i, n = TYPE_NFIELDS (t);
+
+      /* If all elements of the union are scalar, then the union is scalar.  */
+      for (i = 0; i < n; i++)
+       if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
+         return 0;
+
+      return 1;
+    }
+
+  return 0;
+}
+
 /* A helper function which returns true if types A and B represent the
    "same" class type.  This is true if the types have the same main
    type, or the same name.  */
@@ -2039,7 +2101,8 @@ is_public_ancestor (struct type *base, struct type *dclass)
 static int
 is_unique_ancestor_worker (struct type *base, struct type *dclass,
                           int *offset,
-                          const bfd_byte *contents, CORE_ADDR address)
+                          const gdb_byte *valaddr, int embedded_offset,
+                          CORE_ADDR address, struct value *val)
 {
   int i, count = 0;
 
@@ -2048,11 +2111,13 @@ is_unique_ancestor_worker (struct type *base, struct type *dclass,
 
   for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
     {
-      struct type *iter = check_typedef (TYPE_BASECLASS (dclass, i));
-      int this_offset = baseclass_offset (dclass, i, contents, address);
+      struct type *iter;
+      int this_offset;
+
+      iter = check_typedef (TYPE_BASECLASS (dclass, i));
 
-      if (this_offset == -1)
-       error (_("virtual baseclass botch"));
+      this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
+                                     address, val);
 
       if (class_types_same_p (base, iter))
        {
@@ -2074,8 +2139,9 @@ is_unique_ancestor_worker (struct type *base, struct type *dclass,
        }
       else
        count += is_unique_ancestor_worker (base, iter, offset,
-                                           contents + this_offset,
-                                           address + this_offset);
+                                           valaddr,
+                                           embedded_offset + this_offset,
+                                           address, val);
     }
 
   return count;
@@ -2090,8 +2156,9 @@ is_unique_ancestor (struct type *base, struct value *val)
   int offset = -1;
 
   return is_unique_ancestor_worker (base, value_type (val), &offset,
-                                   value_contents (val),
-                                   value_address (val)) == 1;
+                                   value_contents_for_printing (val),
+                                   value_embedded_offset (val),
+                                   value_address (val), val) == 1;
 }
 
 \f