* Beginnings of SOM shared library support. Breakpoints and

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

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 2407efac1c31e79175c2db3e4d17b3164bc994d2..c386a4244b74883bfb6b2ec0c53eaeb7a7353de0 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -30,6 +30,29 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "target.h"
 #include "value.h"
 #include "demangle.h"
 #include "target.h"
 #include "value.h"
 #include "demangle.h"

+#include "complaints.h"
+
+/* These variables point to the objects
+   representing the predefined C data types.  */
+
+struct type *builtin_type_void;
+struct type *builtin_type_char;
+struct type *builtin_type_short;
+struct type *builtin_type_int;
+struct type *builtin_type_long;
+struct type *builtin_type_long_long;
+struct type *builtin_type_signed_char;
+struct type *builtin_type_unsigned_char;
+struct type *builtin_type_unsigned_short;
+struct type *builtin_type_unsigned_int;
+struct type *builtin_type_unsigned_long;
+struct type *builtin_type_unsigned_long_long;
+struct type *builtin_type_float;
+struct type *builtin_type_double;
+struct type *builtin_type_long_double;
+struct type *builtin_type_complex;
+struct type *builtin_type_double_complex;
+struct type *builtin_type_string;

 
 /* Alloc a new type structure and fill it with some defaults.  If
    OBJFILE is non-NULL, then allocate the space for the type structure
 
 /* Alloc a new type structure and fill it with some defaults.  If
    OBJFILE is non-NULL, then allocate the space for the type structure


@@ -52,7 +75,7 @@ alloc_type (objfile)
       type  = (struct type *) obstack_alloc (&objfile -> type_obstack,
                                             sizeof (struct type));
     }
       type  = (struct type *) obstack_alloc (&objfile -> type_obstack,
                                             sizeof (struct type));
     }

-  (void) memset ((char *)type, 0, sizeof (struct type));
+  memset ((char *) type, 0, sizeof (struct type));

 
   /* Initialize the fields that might not be zero. */
 
 
   /* Initialize the fields that might not be zero. */
 


@@ -97,7 +120,7 @@ make_pointer_type (type, typeptr)
     {
       ntype = *typeptr;
       objfile = TYPE_OBJFILE (ntype);
     {
       ntype = *typeptr;
       objfile = TYPE_OBJFILE (ntype);

-      memset ((char *)ntype, 0, sizeof (struct type));
+      memset ((char *) ntype, 0, sizeof (struct type));

       TYPE_OBJFILE (ntype) = objfile;
     }
 
       TYPE_OBJFILE (ntype) = objfile;
     }
 


@@ -162,7 +185,7 @@ make_reference_type (type, typeptr)
     {
       ntype = *typeptr;
       objfile = TYPE_OBJFILE (ntype);
     {
       ntype = *typeptr;
       objfile = TYPE_OBJFILE (ntype);

-      memset ((char *)ntype, 0, sizeof (struct type));
+      memset ((char *) ntype, 0, sizeof (struct type));

       TYPE_OBJFILE (ntype) = objfile;
     }
 
       TYPE_OBJFILE (ntype) = objfile;
     }
 


@@ -224,7 +247,7 @@ make_function_type (type, typeptr)
     {
       ntype = *typeptr;
       objfile = TYPE_OBJFILE (ntype);
     {
       ntype = *typeptr;
       objfile = TYPE_OBJFILE (ntype);

-      memset ((char *)ntype, 0, sizeof (struct type));
+      memset ((char *) ntype, 0, sizeof (struct type));

       TYPE_OBJFILE (ntype) = objfile;
     }
 
       TYPE_OBJFILE (ntype) = objfile;
     }
 


@@ -290,57 +313,258 @@ allocate_stub_method (type)
   return (mtype);
 }
 
   return (mtype);
 }
 

-/* Create an array type.  Elements will be of type TYPE, and there will
-   be NUM of them.
+/* Create a range type using either a blank type supplied in RESULT_TYPE,
+   or creating a new type, inheriting the objfile from INDEX_TYPE.

 
 

-   Eventually this should be extended to take two more arguments which
-   specify the bounds of the array and the type of the index.
-   It should also be changed to be a "lookup" function, with the
-   appropriate data structures added to the type field.
-   Then read array type should call here.  */
+   Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
+   HIGH_BOUND, inclusive.
+
+   FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
+   sure it is TYPE_CODE_UNDEF before we bash it into a range type? */

 
 struct type *
 
 struct type *

-create_array_type (element_type, number)
-     struct type *element_type;
-     int number;
+create_range_type (result_type, index_type, low_bound, high_bound)
+     struct type *result_type;
+     struct type *index_type;
+     int low_bound;
+     int high_bound;

 {
 {

-  struct type *result_type;
-  struct type *range_type;
+  if (result_type == NULL)
+    {
+      result_type = alloc_type (TYPE_OBJFILE (index_type));
+    }
+  TYPE_CODE (result_type) = TYPE_CODE_RANGE;
+  TYPE_TARGET_TYPE (result_type) = index_type;
+  TYPE_LENGTH (result_type) = TYPE_LENGTH (index_type);
+  TYPE_NFIELDS (result_type) = 2;
+  TYPE_FIELDS (result_type) = (struct field *)
+    TYPE_ALLOC (result_type, 2 * sizeof (struct field));
+  memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field));
+  TYPE_FIELD_BITPOS (result_type, 0) = low_bound;
+  TYPE_FIELD_BITPOS (result_type, 1) = high_bound;
+  TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int;         /* FIXME */
+  TYPE_FIELD_TYPE (result_type, 1) = builtin_type_int;         /* FIXME */

 
 

-  result_type = alloc_type (TYPE_OBJFILE (element_type));
+  return (result_type);
+}
+
+/* A lot of code assumes that the "index type" of an array/string/
+   set/bitstring is specifically a range type, though in some languages
+   it can be any discrete type. */
+
+struct type *
+force_to_range_type (type)
+     struct type *type;
+{
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_RANGE:
+      return type;
+
+    case TYPE_CODE_ENUM:
+      {
+       int low_bound = TYPE_FIELD_BITPOS (type, 0);
+       int high_bound = TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1);
+       struct type *range_type =
+         create_range_type (NULL, type, low_bound, high_bound);
+       TYPE_NAME (range_type) = TYPE_NAME (range_type);
+       TYPE_DUMMY_RANGE (range_type) = 1;
+       return range_type;
+      }
+    case TYPE_CODE_BOOL:
+      {
+       struct type *range_type = create_range_type (NULL, type, 0, 1);
+       TYPE_NAME (range_type) = TYPE_NAME (range_type);
+       TYPE_DUMMY_RANGE (range_type) = 1;
+       return range_type;
+      }
+    case TYPE_CODE_CHAR:
+      {
+       struct type *range_type = create_range_type (NULL, type, 0, 255);
+       TYPE_NAME (range_type) = TYPE_NAME (range_type);
+       TYPE_DUMMY_RANGE (range_type) = 1;
+       return range_type;
+      }
+    default:
+      {
+       static struct complaint msg =
+         { "array index type must be a discrete type", 0, 0};
+       complain (&msg);
+
+       return create_range_type (NULL, builtin_type_int, 0, 0);
+      }
+    }
+}

 
 

+/* Create an array type using either a blank type supplied in RESULT_TYPE,
+   or creating a new type, inheriting the objfile from RANGE_TYPE.
+
+   Elements will be of type ELEMENT_TYPE, the indices will be of type
+   RANGE_TYPE.
+
+   FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
+   sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
+
+struct type *
+create_array_type (result_type, element_type, range_type)
+     struct type *result_type;
+     struct type *element_type;
+     struct type *range_type;
+{
+  int low_bound;
+  int high_bound;
+
+  range_type = force_to_range_type (range_type);
+  if (result_type == NULL)
+    {
+      result_type = alloc_type (TYPE_OBJFILE (range_type));
+    }

   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
   TYPE_TARGET_TYPE (result_type) = element_type;
   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
   TYPE_TARGET_TYPE (result_type) = element_type;

-  TYPE_LENGTH (result_type) = number * TYPE_LENGTH (element_type);
+  low_bound = TYPE_LOW_BOUND (range_type);
+  high_bound = TYPE_HIGH_BOUND (range_type);
+  TYPE_LENGTH (result_type) =
+    TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);

   TYPE_NFIELDS (result_type) = 1;
   TYPE_NFIELDS (result_type) = 1;

-  TYPE_FIELDS (result_type) = (struct field *)
-    obstack_alloc (&TYPE_OBJFILE (result_type) -> type_obstack,
-                  sizeof (struct field));
-
-  {
-    /* Create range type.  */
-    range_type = alloc_type (TYPE_OBJFILE (result_type));
-    TYPE_CODE (range_type) = TYPE_CODE_RANGE;
-    TYPE_TARGET_TYPE (range_type) = builtin_type_int;  /* FIXME */
-
-    /* This should never be needed.  */
-    TYPE_LENGTH (range_type) = sizeof (int);
-
-    TYPE_NFIELDS (range_type) = 2;
-    TYPE_FIELDS (range_type) = (struct field *)
-      obstack_alloc (&TYPE_OBJFILE (range_type) -> type_obstack,
-                    2 * sizeof (struct field));
-    TYPE_FIELD_BITPOS (range_type, 0) = 0; /* FIXME */
-    TYPE_FIELD_BITPOS (range_type, 1) = number-1; /* FIXME */
-    TYPE_FIELD_TYPE (range_type, 0) = builtin_type_int; /* FIXME */
-    TYPE_FIELD_TYPE (range_type, 1) = builtin_type_int; /* FIXME */
-  }
-  TYPE_FIELD_TYPE(result_type,0)=range_type;
+  TYPE_FIELDS (result_type) =
+    (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
+  memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
+  TYPE_FIELD_TYPE (result_type, 0) = range_type;

   TYPE_VPTR_FIELDNO (result_type) = -1;
 
   return (result_type);
 }
 
   TYPE_VPTR_FIELDNO (result_type) = -1;
 
   return (result_type);
 }
 

+/* Create a string type using either a blank type supplied in RESULT_TYPE,
+   or creating a new type.  String types are similar enough to array of
+   char types that we can use create_array_type to build the basic type
+   and then bash it into a string type.
+
+   For fixed length strings, the range type contains 0 as the lower
+   bound and the length of the string minus one as the upper bound.
+
+   FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
+   sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
+
+struct type *
+create_string_type (result_type, range_type)
+     struct type *result_type;
+     struct type *range_type;
+{
+  result_type = create_array_type (result_type, builtin_type_char, range_type);
+  TYPE_CODE (result_type) = TYPE_CODE_STRING;
+  return (result_type);
+}
+
+struct type *
+create_set_type (result_type, domain_type)
+     struct type *result_type;
+     struct type *domain_type;
+{
+  int low_bound, high_bound, bit_length;
+  if (result_type == NULL)
+    {
+      result_type = alloc_type (TYPE_OBJFILE (domain_type));
+    }
+  TYPE_CODE (result_type) = TYPE_CODE_SET;
+  TYPE_NFIELDS (result_type) = 1;
+  TYPE_FIELDS (result_type) = (struct field *)
+    TYPE_ALLOC (result_type, 1 * sizeof (struct field));
+  memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
+
+  if (! (TYPE_FLAGS (domain_type) & TYPE_FLAG_STUB))
+    {
+      domain_type = force_to_range_type (domain_type);
+      low_bound = TYPE_LOW_BOUND (domain_type);
+      high_bound = TYPE_HIGH_BOUND (domain_type);
+      bit_length = high_bound - low_bound + 1;
+      TYPE_LENGTH (result_type)
+       = ((bit_length + TARGET_INT_BIT - 1) / TARGET_INT_BIT)
+         * TARGET_CHAR_BIT;
+    }
+  TYPE_FIELD_TYPE (result_type, 0) = domain_type;
+  return (result_type);
+}
+
+/* Create an  F77 literal complex type composed of the two types we are 
+   given as arguments.  */
+
+struct type * 
+f77_create_literal_complex_type (type_arg1, type_arg2)
+     struct type *type_arg1;
+     struct type *type_arg2;
+{
+  struct type *result; 
+
+  /* First make sure that the 2 components of the complex 
+     number both have the same type */
+
+  if (TYPE_CODE (type_arg1) != TYPE_CODE (type_arg2))
+    error ("Both components of a F77 complex number must have the same type!");
+   
+  result = alloc_type (TYPE_OBJFILE (type_arg1));
+   
+  TYPE_CODE (result) = TYPE_CODE_LITERAL_COMPLEX;
+  TYPE_LENGTH (result) = TYPE_LENGTH(type_arg1) * 2;
+
+  return result;
+}
+
+/* Create a F77 LITERAL string type supplied by the user from the keyboard.
+
+   Elements will be of type ELEMENT_TYPE, the indices will be of type
+   RANGE_TYPE.
+
+   FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
+   sure it is TYPE_CODE_UNDEF before we bash it into an array type? 
+
+   This is a total clone of create_array_type() except that there are 
+   a few simplyfing assumptions (e.g all bound types are simple).  */ 
+
+struct type *
+f77_create_literal_string_type (result_type, range_type)
+     struct type *result_type;
+     struct type *range_type;
+{
+  int low_bound;
+  int high_bound;
+
+  if (TYPE_CODE (range_type) != TYPE_CODE_RANGE)
+    {
+      /* FIXME:  We only handle range types at the moment.  Complain and
+        create a dummy range type to use. */
+      warning ("internal error:  array index type must be a range type");
+      range_type = lookup_fundamental_type (TYPE_OBJFILE (range_type),
+                                           FT_INTEGER);
+      range_type = create_range_type ((struct type *) NULL, range_type, 0, 0);
+    }
+  if (result_type == NULL)
+    result_type = alloc_type (TYPE_OBJFILE (range_type));
+  TYPE_CODE (result_type) = TYPE_CODE_LITERAL_STRING;
+  TYPE_TARGET_TYPE (result_type) = builtin_type_f_character; 
+  low_bound = TYPE_FIELD_BITPOS (range_type, 0);
+  high_bound = TYPE_FIELD_BITPOS (range_type, 1);
+
+  /* Safely can assume that all bound types are simple */ 
+
+  TYPE_LENGTH (result_type) =
+    TYPE_LENGTH (builtin_type_f_character) * (high_bound - low_bound + 1);
+
+  TYPE_NFIELDS (result_type) = 1;
+  TYPE_FIELDS (result_type) =
+    (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
+  memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
+  TYPE_FIELD_TYPE (result_type, 0) = range_type;
+  TYPE_VPTR_FIELDNO (result_type) = -1;
+
+  /* Remember that all literal strings in F77 are of the 
+     character*N type. */
+
+  TYPE_ARRAY_LOWER_BOUND_TYPE (result_type) = BOUND_SIMPLE; 
+  TYPE_ARRAY_UPPER_BOUND_TYPE (result_type) = BOUND_SIMPLE; 
+
+  return result_type;
+}

 
 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. 
    A MEMBER is a wierd thing -- it amounts to a typed offset into
 
 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. 
    A MEMBER is a wierd thing -- it amounts to a typed offset into


@@ -362,7 +586,7 @@ smash_to_member_type (type, domain, to_type)
 
   objfile = TYPE_OBJFILE (type);
 
 
   objfile = TYPE_OBJFILE (type);
 

-  (void) memset ((char *)type, 0, sizeof (struct type));
+  memset ((char *) type, 0, sizeof (struct type));

   TYPE_OBJFILE (type) = objfile;
   TYPE_TARGET_TYPE (type) = to_type;
   TYPE_DOMAIN_TYPE (type) = domain;
   TYPE_OBJFILE (type) = objfile;
   TYPE_TARGET_TYPE (type) = to_type;
   TYPE_DOMAIN_TYPE (type) = domain;


@@ -388,7 +612,7 @@ smash_to_method_type (type, domain, to_type, args)
 
   objfile = TYPE_OBJFILE (type);
 
 
   objfile = TYPE_OBJFILE (type);
 

-  (void) memset ((char *)type, 0, sizeof (struct type));
+  memset ((char *) type, 0, sizeof (struct type));

   TYPE_OBJFILE (type) = objfile;
   TYPE_TARGET_TYPE (type) = to_type;
   TYPE_DOMAIN_TYPE (type) = domain;
   TYPE_OBJFILE (type) = objfile;
   TYPE_TARGET_TYPE (type) = to_type;
   TYPE_DOMAIN_TYPE (type) = domain;


@@ -397,43 +621,20 @@ smash_to_method_type (type, domain, to_type, args)
   TYPE_CODE (type) = TYPE_CODE_METHOD;
 }
 
   TYPE_CODE (type) = TYPE_CODE_METHOD;
 }
 

-/* Return a typename for a struct/union/enum type
-   without the tag qualifier.  If the type has a NULL name,
-   NULL is returned.  */
+/* Return a typename for a struct/union/enum type without "struct ",
+   "union ", or "enum ".  If the type has a NULL name, return NULL.  */

 
 char *
 type_name_no_tag (type)
      register const struct type *type;
 {
 
 char *
 type_name_no_tag (type)
      register const struct type *type;
 {

-  register char *name;
+  if (TYPE_TAG_NAME (type) != NULL)
+    return TYPE_TAG_NAME (type);

 
 

-  if ((name = TYPE_NAME (type)) != NULL)
-    {
-      switch (TYPE_CODE (type))
-       {
-         case TYPE_CODE_STRUCT:
-           if(!strncmp (name, "struct ", 7))
-             {
-               name += 7;
-             }
-           break;
-         case TYPE_CODE_UNION:
-           if(!strncmp (name, "union ", 6))
-             {
-               name += 6;
-             }
-           break;
-         case TYPE_CODE_ENUM:
-           if(!strncmp (name, "enum ", 5))
-             {
-               name += 5;
-             }
-           break;
-         default:              /* To avoid -Wall warnings */
-           break;
-       }
-    }
-  return (name);
+  /* Is there code which expects this to return the name if there is no
+     tag name?  My guess is that this is mainly used for C++ in cases where
+     the two will always be the same.  */
+  return TYPE_NAME (type);

 }
 
 /* Lookup a primitive type named NAME. 
 }
 
 /* Lookup a primitive type named NAME. 


@@ -447,7 +648,7 @@ lookup_primitive_typename (name)
 
    for (p = current_language -> la_builtin_type_vector; *p != NULL; p++)
      {
 
    for (p = current_language -> la_builtin_type_vector; *p != NULL; p++)
      {

-       if (!strcmp ((**p) -> name, name))
+       if (STREQ ((**p) -> name, name))

         {
           return (**p);
         }
         {
           return (**p);
         }


@@ -499,6 +700,22 @@ lookup_unsigned_typename (name)
   return (lookup_typename (uns, (struct block *) NULL, 0));
 }
 
   return (lookup_typename (uns, (struct block *) NULL, 0));
 }
 

+struct type *
+lookup_signed_typename (name)
+     char *name;
+{
+  struct type *t;
+  char *uns = alloca (strlen (name) + 8);
+
+  strcpy (uns, "signed ");
+  strcpy (uns + 7, name);
+  t = lookup_typename (uns, (struct block *) NULL, 1);
+  /* If we don't find "signed FOO" just try again with plain "FOO". */
+  if (t != NULL)
+    return t;
+  return lookup_typename (name, (struct block *) NULL, 0);
+}
+

 /* Lookup a structure type named "struct NAME",
    visible in lexical block BLOCK.  */
 
 /* Lookup a structure type named "struct NAME",
    visible in lexical block BLOCK.  */
 


@@ -599,9 +816,15 @@ lookup_template_type (name, type, block)
   return (SYMBOL_TYPE (sym));
 }
 
   return (SYMBOL_TYPE (sym));
 }
 

-/* Given a type TYPE, lookup the type of the component of type named
-   NAME.  
-   If NOERR is nonzero, return zero if NAME is not suitably defined.  */
+/* Given a type TYPE, lookup the type of the component of type named NAME.  
+
+   TYPE can be either a struct or union, or a pointer or reference to a struct or
+   union.  If it is a pointer or reference, its target type is automatically used.
+   Thus '.' and '->' are interchangable, as specified for the definitions of the
+   expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
+
+   If NOERR is nonzero, return zero if NAME is not suitably defined.
+   If NAME is the name of a baseclass type, return that type.  */

 
 struct type *
 lookup_struct_elt_type (type, name, noerr)
 
 struct type *
 lookup_struct_elt_type (type, name, noerr)


@@ -611,23 +834,41 @@ lookup_struct_elt_type (type, name, noerr)
 {
   int i;
 
 {
   int i;
 

+  while (TYPE_CODE (type) == TYPE_CODE_PTR ||
+      TYPE_CODE (type) == TYPE_CODE_REF)
+      type = TYPE_TARGET_TYPE (type);
+

   if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
       TYPE_CODE (type) != TYPE_CODE_UNION)
     {
       target_terminal_ours ();
   if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
       TYPE_CODE (type) != TYPE_CODE_UNION)
     {
       target_terminal_ours ();

-      fflush (stdout);
-      fprintf (stderr, "Type ");
-      type_print (type, "", stderr, -1);
+      gdb_flush (gdb_stdout);
+      fprintf_unfiltered (gdb_stderr, "Type ");
+      type_print (type, "", gdb_stderr, -1);

       error (" is not a structure or union type.");
     }
 
   check_stub_type (type);
 
       error (" is not a structure or union type.");
     }
 
   check_stub_type (type);
 

+#if 0
+  /* FIXME:  This change put in by Michael seems incorrect for the case where
+     the structure tag name is the same as the member name.  I.E. when doing
+     "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
+     Disabled by fnf. */
+  {
+    char *typename;
+
+    typename = type_name_no_tag (type);
+    if (typename != NULL && STREQ (typename, name))
+      return type;
+  }
+#endif
+

   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
     {
       char *t_field_name = TYPE_FIELD_NAME (type, i);
 
   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
     {
       char *t_field_name = TYPE_FIELD_NAME (type, i);
 

-      if (t_field_name && !strcmp (t_field_name, name))
+      if (t_field_name && STREQ (t_field_name, name))

        {
          return TYPE_FIELD_TYPE (type, i);
        }
        {
          return TYPE_FIELD_TYPE (type, i);
        }


@@ -638,7 +879,7 @@ lookup_struct_elt_type (type, name, noerr)
     {
       struct type *t;
 
     {
       struct type *t;
 

-      t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 0);
+      t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr);

       if (t != NULL)
        {
          return t;
       if (t != NULL)
        {
          return t;


@@ -651,26 +892,35 @@ lookup_struct_elt_type (type, name, noerr)
     }
   
   target_terminal_ours ();
     }
   
   target_terminal_ours ();

-  fflush (stdout);
-  fprintf (stderr, "Type ");
-  type_print (type, "", stderr, -1);
-  fprintf (stderr, " has no component named ");
-  fputs_filtered (name, stderr);
+  gdb_flush (gdb_stdout);
+  fprintf_unfiltered (gdb_stderr, "Type ");
+  type_print (type, "", gdb_stderr, -1);
+  fprintf_unfiltered (gdb_stderr, " has no component named ");
+  fputs_filtered (name, gdb_stderr);

   error (".");
   return (struct type *)-1;    /* For lint */
 }
 
   error (".");
   return (struct type *)-1;    /* For lint */
 }
 

-/* This function is really horrible, but to avoid it, there would need
-   to be more filling in of forward references.  */
+/* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
+   valid.  Callers should be aware that in some cases (for example,
+   the type or one of its baseclasses is a stub type and we are
+   debugging a .o file), this function will not be able to find the virtual
+   function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
+   will remain NULL.  */

 
 void
 fill_in_vptr_fieldno (type)
      struct type *type;
 {
 
 void
 fill_in_vptr_fieldno (type)
      struct type *type;
 {

+  check_stub_type (type);
+

   if (TYPE_VPTR_FIELDNO (type) < 0)
     {
       int i;
   if (TYPE_VPTR_FIELDNO (type) < 0)
     {
       int i;

-      for (i = 1; i < TYPE_N_BASECLASSES (type); i++)
+
+      /* We must start at zero in case the first (and only) baseclass is
+        virtual (and hence we cannot share the table pointer).  */
+      for (i = 0; i < TYPE_N_BASECLASSES (type); i++)

        {
          fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
          if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)
        {
          fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
          if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)


@@ -689,13 +939,14 @@ fill_in_vptr_fieldno (type)
 
    If this is a stubbed struct (i.e. declared as struct foo *), see if
    we can find a full definition in some other file. If so, copy this
 
    If this is a stubbed struct (i.e. declared as struct foo *), see if
    we can find a full definition in some other file. If so, copy this

-   definition, so we can use it in future.  If not, set a flag so we 
-   don't waste too much time in future.  (FIXME, this doesn't seem
-   to be happening...)
+   definition, so we can use it in future.  There used to be a comment (but
+   not any code) that if we don't find a full definition, we'd set a flag
+   so we don't spend time in the future checking the same type.  That would
+   be a mistake, though--we might load in more symbols which contain a
+   full definition for the type.

 
    This used to be coded as a macro, but I don't think it is called 
 
    This used to be coded as a macro, but I don't think it is called 

-   often enough to merit such treatment.
-*/
+   often enough to merit such treatment.  */

 
 struct complaint stub_noname_complaint =
   {"stub type has NULL name", 0, 0};
 
 struct complaint stub_noname_complaint =
   {"stub type has NULL name", 0, 0};


@@ -707,17 +958,45 @@ check_stub_type (type)
   if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
     {
       char* name = type_name_no_tag (type);
   if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
     {
       char* name = type_name_no_tag (type);

+      /* FIXME: shouldn't we separately check the TYPE_NAME and the
+        TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
+        as appropriate?  (this code was written before TYPE_NAME and
+        TYPE_TAG_NAME were separate).  */

       struct symbol *sym;
       if (name == NULL)
        {
       struct symbol *sym;
       if (name == NULL)
        {

-         complain (&stub_noname_complaint, 0);
+         complain (&stub_noname_complaint);

          return;
        }
       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, 
                           (struct symtab **) NULL);
       if (sym)
        {
          return;
        }
       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, 
                           (struct symtab **) NULL);
       if (sym)
        {

-         memcpy ((char *)type, (char *)SYMBOL_TYPE(sym), sizeof (struct type));
+         memcpy ((char *)type,
+                 (char *)SYMBOL_TYPE(sym),
+                 sizeof (struct type));
+       }
+    }
+
+  if (TYPE_FLAGS (type) & TYPE_FLAG_TARGET_STUB)
+    {
+      struct type *range_type;
+
+      check_stub_type (TYPE_TARGET_TYPE (type));
+      if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_STUB)
+         && TYPE_CODE (type) == TYPE_CODE_ARRAY
+         && TYPE_NFIELDS (type) == 1
+         && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
+             == TYPE_CODE_RANGE))
+       {
+         /* Now recompute the length of the array type, based on its
+            number of elements and the target type's length.  */
+         TYPE_LENGTH (type) =
+           ((TYPE_FIELD_BITPOS (range_type, 1)
+             - TYPE_FIELD_BITPOS (range_type, 0)
+             + 1)
+            * TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
+         TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;

        }
     }
 }
        }
     }
 }


@@ -740,7 +1019,8 @@ check_stub_method (type, i, j)
 {
   struct fn_field *f;
   char *mangled_name = gdb_mangle_name (type, i, j);
 {
   struct fn_field *f;
   char *mangled_name = gdb_mangle_name (type, i, j);

-  char *demangled_name = cplus_demangle (mangled_name, DMGL_PARAMS);
+  char *demangled_name = cplus_demangle (mangled_name,
+                                        DMGL_PARAMS | DMGL_ANSI);

   char *argtypetext, *p;
   int depth = 0, argcount = 1;
   struct type **argtypes;
   char *argtypetext, *p;
   int depth = 0, argcount = 1;
   struct type **argtypes;


@@ -776,9 +1056,9 @@ check_stub_method (type, i, j)
      NULL [...] or void [end of arglist].  */
 
   argtypes = (struct type **)
      NULL [...] or void [end of arglist].  */
 
   argtypes = (struct type **)

-    obstack_alloc (&TYPE_OBJFILE (type) -> type_obstack,
-                  (argcount+2) * sizeof (struct type *));
+    TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));

   p = argtypetext;
   p = argtypetext;

+  /* FIXME: This is wrong for static member functions.  */

   argtypes[0] = lookup_pointer_type (type);
   argcount = 1;
 
   argtypes[0] = lookup_pointer_type (type);
   argcount = 1;
 


@@ -789,9 +1069,13 @@ check_stub_method (type, i, j)
        {
          if (depth <= 0 && (*p == ',' || *p == ')'))
            {
        {
          if (depth <= 0 && (*p == ',' || *p == ')'))
            {

-             argtypes[argcount] =
-                 parse_and_eval_type (argtypetext, p - argtypetext);
-             argcount += 1;
+             /* Avoid parsing of ellipsis, they will be handled below.  */
+             if (strncmp (argtypetext, "...", p - argtypetext) != 0)
+               {
+                 argtypes[argcount] =
+                     parse_and_eval_type (argtypetext, p - argtypetext);
+                 argcount += 1;
+               }

              argtypetext = p + 1;
            }
 
              argtypetext = p + 1;
            }
 


@@ -808,13 +1092,13 @@ check_stub_method (type, i, j)
        }
     }
 
        }
     }
 

-  if (p[-2] != '.')                    /* ... */
+  if (p[-2] != '.')                    /* Not '...' */

     {
     {

-      argtypes[argcount] = builtin_type_void;  /* Ellist terminator */
+      argtypes[argcount] = builtin_type_void;  /* List terminator */

     }
   else
     {
     }
   else
     {

-      argtypes[argcount] = NULL;               /* List terminator */
+      argtypes[argcount] = NULL;               /* Ellist terminator */

     }
 
   free (demangled_name);
     }
 
   free (demangled_name);


@@ -839,8 +1123,7 @@ allocate_cplus_struct_type (type)
   if (!HAVE_CPLUS_STRUCT (type))
     {
       TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
   if (!HAVE_CPLUS_STRUCT (type))
     {
       TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)

-       obstack_alloc (&current_objfile -> type_obstack,
-                      sizeof (struct cplus_struct_type));
+       TYPE_ALLOC (type, sizeof (struct cplus_struct_type));

       *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
     }
 }
       *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
     }
 }


@@ -893,28 +1176,24 @@ init_type (code, length, flags, name, objfile)
    define fundamental types.
 
    For the formats which don't provide fundamental types, gdb can create
    define fundamental types.
 
    For the formats which don't provide fundamental types, gdb can create

-   such types, using defaults reasonable for the current target machine.
-
-   FIXME:  Some compilers distinguish explicitly signed integral types
-   (signed short, signed int, signed long) from "regular" integral types
-   (short, int, long) in the debugging information.  There is some dis-
-   agreement as to how useful this feature is.  In particular, gcc does
-   not support this.  Also, only some debugging formats allow the
-   distinction to be passed on to a debugger.  For now, we always just
-   use "short", "int", or "long" as the type name, for both the implicit
-   and explicitly signed types.  This also makes life easier for the
-   gdb test suite since we don't have to account for the differences
-   in output depending upon what the compiler and debugging format
-   support.  We will probably have to re-examine the issue when gdb
-   starts taking it's fundamental type information directly from the
-   debugging information supplied by the compiler.  fnf@cygnus.com */
+   such types, using defaults reasonable for the current language and
+   the current target machine.
+
+   NOTE:  This routine is obsolescent.  Each debugging format reader
+   should manage it's own fundamental types, either creating them from
+   suitable defaults or reading them from the debugging information,
+   whichever is appropriate.  The DWARF reader has already been
+   fixed to do this.  Once the other readers are fixed, this routine
+   will go away.  Also note that fundamental types should be managed
+   on a compilation unit basis in a multi-language environment, not
+   on a linkage unit basis as is done here. */
+

 
 struct type *
 lookup_fundamental_type (objfile, typeid)
      struct objfile *objfile;
      int typeid;
 {
 
 struct type *
 lookup_fundamental_type (objfile, typeid)
      struct objfile *objfile;
      int typeid;
 {

-  register struct type *type = NULL;

   register struct type **typep;
   register int nbytes;
 
   register struct type **typep;
   register int nbytes;
 


@@ -922,186 +1201,460 @@ lookup_fundamental_type (objfile, typeid)
     {
       error ("internal error - invalid fundamental type id %d", typeid);
     }
     {
       error ("internal error - invalid fundamental type id %d", typeid);
     }

-  else
+
+  /* If this is the first time we need a fundamental type for this objfile
+     then we need to initialize the vector of type pointers. */
+  
+  if (objfile -> fundamental_types == NULL)
+    {
+      nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
+      objfile -> fundamental_types = (struct type **)
+       obstack_alloc (&objfile -> type_obstack, nbytes);
+      memset ((char *) objfile -> fundamental_types, 0, nbytes);
+    }
+
+  /* Look for this particular type in the fundamental type vector.  If one is
+     not found, create and install one appropriate for the current language. */
+
+  typep = objfile -> fundamental_types + typeid;
+  if (*typep == NULL)

     {
     {

-      /* If this is the first time we */
-      if (objfile -> fundamental_types == NULL)
+      *typep = create_fundamental_type (objfile, typeid);
+    }
+
+  return (*typep);
+}
+
+int
+can_dereference (t)
+     struct type *t;
+{
+  /* FIXME: Should we return true for references as well as pointers?  */
+  return
+    (t != NULL
+     && TYPE_CODE (t) == TYPE_CODE_PTR
+     && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
+}
+
+#if MAINTENANCE_CMDS
+
+static void
+print_bit_vector (bits, nbits)
+     B_TYPE *bits;
+     int nbits;
+{
+  int bitno;
+
+  for (bitno = 0; bitno < nbits; bitno++)
+    {
+      if ((bitno % 8) == 0)

        {
        {

-         nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
-         objfile -> fundamental_types = (struct type **)
-           obstack_alloc (&objfile -> type_obstack, nbytes);
-         (void) memset ((char *)objfile -> fundamental_types, 0, nbytes);
+         puts_filtered (" ");

        }
        }

-      typep = objfile -> fundamental_types + typeid;
-      if ((type = *typep) == NULL)
+      if (B_TST (bits, bitno))
+       {
+         printf_filtered ("1");
+       }
+      else
+       {
+         printf_filtered ("0");
+       }
+    }
+}
+
+/* The args list is a strange beast.  It is either terminated by a NULL
+   pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
+   type for normal fixed argcount functions.  (FIXME someday)
+   Also note the first arg should be the "this" pointer, we may not want to
+   include it since we may get into a infinitely recursive situation. */
+
+static void
+print_arg_types (args, spaces)
+     struct type **args;
+     int spaces;
+{
+  if (args != NULL)
+    {
+      while (*args != NULL)

        {
        {

-         switch (typeid)
+         recursive_dump_type (*args, spaces + 2);
+         if ((*args++) -> code == TYPE_CODE_VOID)

            {
            {

-             default:
-               error ("internal error: unhandled type id %d", typeid);
-               break;
-             case FT_VOID:
-               type = init_type (TYPE_CODE_VOID,
-                                 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "void", objfile);
-               break;
-             case FT_BOOLEAN:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_INT_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_UNSIGNED,
-                                 "boolean", objfile);
-               break;
-             case FT_STRING:
-               type = init_type (TYPE_CODE_PASCAL_ARRAY,
-                                 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "string", objfile);
-               break;
-             case FT_CHAR:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "char", objfile);
-               break;
-             case FT_SIGNED_CHAR:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_SIGNED,
-                                 "signed char", objfile);
-               break;
-             case FT_UNSIGNED_CHAR:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_UNSIGNED,
-                                 "unsigned char", objfile);
-               break;
-             case FT_SHORT:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_SHORT_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "short", objfile);
-               break;
-             case FT_SIGNED_SHORT:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_SHORT_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_SIGNED,
-                                 "short", objfile);    /* FIXME -fnf */
-               break;
-             case FT_UNSIGNED_SHORT:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_SHORT_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_UNSIGNED,
-                                 "unsigned short", objfile);
-               break;
-             case FT_INTEGER:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_INT_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "int", objfile);
-               break;
-             case FT_SIGNED_INTEGER:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_INT_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_SIGNED,
-                                 "int", objfile);      /* FIXME -fnf */
-               break;
-             case FT_UNSIGNED_INTEGER:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_INT_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_UNSIGNED,
-                                 "unsigned int", objfile);
-               break;
-             case FT_FIXED_DECIMAL:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_INT_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "fixed decimal", objfile);
-               break;
-             case FT_LONG:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_LONG_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "long", objfile);
-               break;
-             case FT_SIGNED_LONG:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_LONG_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_SIGNED,
-                                 "long", objfile);     /* FIXME -fnf */
-               break;
-             case FT_UNSIGNED_LONG:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_LONG_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_UNSIGNED,
-                                 "unsigned long", objfile);
-               break;
-             case FT_LONG_LONG:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "long long", objfile);
-               break;
-             case FT_SIGNED_LONG_LONG:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_SIGNED,
-                                 "signed long long", objfile);
-               break;
-             case FT_UNSIGNED_LONG_LONG:
-               type = init_type (TYPE_CODE_INT,
-                                 TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
-                                 TYPE_FLAG_UNSIGNED,
-                                 "unsigned long long", objfile);
-               break;
-             case FT_FLOAT:
-               type = init_type (TYPE_CODE_FLT,
-                                 TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "float", objfile);
-               break;
-             case FT_DBL_PREC_FLOAT:
-               type = init_type (TYPE_CODE_FLT,
-                                 TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "double", objfile);
-               break;
-             case FT_FLOAT_DECIMAL:
-               type = init_type (TYPE_CODE_FLT,
-                                 TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "floating decimal", objfile);
-               break;
-             case FT_EXT_PREC_FLOAT:
-               type = init_type (TYPE_CODE_FLT,
-                                 TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "long double", objfile);
-               break;
-             case FT_COMPLEX:
-               type = init_type (TYPE_CODE_FLT,
-                                 TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "complex", objfile);
-               break;
-             case FT_DBL_PREC_COMPLEX:
-               type = init_type (TYPE_CODE_FLT,
-                                 TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "double complex", objfile);
-               break;
-             case FT_EXT_PREC_COMPLEX:
-               type = init_type (TYPE_CODE_FLT,
-                                 TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
-                                 0,
-                                 "long double complex", objfile);
-               break;
+             break;

            }
            }

-         /* Install the newly created type in the objfile's fundamental_types
-            vector. */
-         *typep = type;

        }
     }
        }
     }

-  return (type);

 }
 
 }
 

+static void
+dump_fn_fieldlists (type, spaces)
+     struct type *type;
+     int spaces;
+{
+  int method_idx;
+  int overload_idx;
+  struct fn_field *f;
+
+  printfi_filtered (spaces, "fn_fieldlists ");
+  gdb_print_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
+  printf_filtered ("\n");
+  for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
+    {
+      f = TYPE_FN_FIELDLIST1 (type, method_idx);
+      printfi_filtered (spaces + 2, "[%d] name '%s' (",
+                       method_idx,
+                       TYPE_FN_FIELDLIST_NAME (type, method_idx));
+      gdb_print_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
+                        gdb_stdout);
+      printf_filtered (") length %d\n",
+                      TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
+      for (overload_idx = 0;
+          overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
+          overload_idx++)
+       {
+         printfi_filtered (spaces + 4, "[%d] physname '%s' (",
+                           overload_idx,
+                           TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
+         gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
+                            gdb_stdout);
+         printf_filtered (")\n");
+         printfi_filtered (spaces + 8, "type ");
+         gdb_print_address (TYPE_FN_FIELD_TYPE (f, overload_idx), gdb_stdout);
+         printf_filtered ("\n");
+
+         recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
+                              spaces + 8 + 2);
+
+         printfi_filtered (spaces + 8, "args ");
+         gdb_print_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout);
+         printf_filtered ("\n");
+
+         print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
+         printfi_filtered (spaces + 8, "fcontext ");
+         gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
+                            gdb_stdout);
+         printf_filtered ("\n");
+
+         printfi_filtered (spaces + 8, "is_const %d\n",
+                           TYPE_FN_FIELD_CONST (f, overload_idx));
+         printfi_filtered (spaces + 8, "is_volatile %d\n",
+                           TYPE_FN_FIELD_VOLATILE (f, overload_idx));
+         printfi_filtered (spaces + 8, "is_private %d\n",
+                           TYPE_FN_FIELD_PRIVATE (f, overload_idx));
+         printfi_filtered (spaces + 8, "is_protected %d\n",
+                           TYPE_FN_FIELD_PROTECTED (f, overload_idx));
+         printfi_filtered (spaces + 8, "is_stub %d\n",
+                           TYPE_FN_FIELD_STUB (f, overload_idx));
+         printfi_filtered (spaces + 8, "voffset %u\n",
+                           TYPE_FN_FIELD_VOFFSET (f, overload_idx));
+       }
+    }
+}
+
+static void
+print_cplus_stuff (type, spaces)
+     struct type *type;
+     int spaces;
+{
+  printfi_filtered (spaces, "n_baseclasses %d\n",
+                   TYPE_N_BASECLASSES (type));
+  printfi_filtered (spaces, "nfn_fields %d\n",
+                   TYPE_NFN_FIELDS (type));
+  printfi_filtered (spaces, "nfn_fields_total %d\n",
+                   TYPE_NFN_FIELDS_TOTAL (type));
+  if (TYPE_N_BASECLASSES (type) > 0)
+    {
+      printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
+                       TYPE_N_BASECLASSES (type));
+      gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type), gdb_stdout);
+      printf_filtered (")");
+
+      print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
+                       TYPE_N_BASECLASSES (type));
+      puts_filtered ("\n");
+    }
+  if (TYPE_NFIELDS (type) > 0)
+    {
+      if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
+       {
+         printfi_filtered (spaces, "private_field_bits (%d bits at *",
+                           TYPE_NFIELDS (type));
+         gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type), gdb_stdout);
+         printf_filtered (")");
+         print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
+                           TYPE_NFIELDS (type));
+         puts_filtered ("\n");
+       }
+      if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
+       {
+         printfi_filtered (spaces, "protected_field_bits (%d bits at *",
+                           TYPE_NFIELDS (type));
+         gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type), gdb_stdout);
+         printf_filtered (")");
+         print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
+                           TYPE_NFIELDS (type));
+         puts_filtered ("\n");
+       }
+    }
+  if (TYPE_NFN_FIELDS (type) > 0)
+    {
+      dump_fn_fieldlists (type, spaces);
+    }
+}
+
+void
+recursive_dump_type (type, spaces)
+     struct type *type;
+     int spaces;
+{
+  int idx;
+
+  printfi_filtered (spaces, "type node ");
+  gdb_print_address (type, gdb_stdout);
+  printf_filtered ("\n");
+  printfi_filtered (spaces, "name '%s' (",
+                   TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
+  gdb_print_address (TYPE_NAME (type), gdb_stdout);
+  printf_filtered (")\n");
+  if (TYPE_TAG_NAME (type) != NULL)
+    {
+      printfi_filtered (spaces, "tagname '%s' (",
+                       TYPE_TAG_NAME (type));
+      gdb_print_address (TYPE_TAG_NAME (type), gdb_stdout);
+      printf_filtered (")\n");
+    }
+  printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
+  switch (TYPE_CODE (type))
+    {
+      case TYPE_CODE_UNDEF:
+        printf_filtered ("(TYPE_CODE_UNDEF)");
+       break;
+      case TYPE_CODE_PTR:
+       printf_filtered ("(TYPE_CODE_PTR)");
+       break;
+      case TYPE_CODE_ARRAY:
+       printf_filtered ("(TYPE_CODE_ARRAY)");
+       break;
+      case TYPE_CODE_STRUCT:
+       printf_filtered ("(TYPE_CODE_STRUCT)");
+       break;
+      case TYPE_CODE_UNION:
+       printf_filtered ("(TYPE_CODE_UNION)");
+       break;
+      case TYPE_CODE_ENUM:
+       printf_filtered ("(TYPE_CODE_ENUM)");
+       break;
+      case TYPE_CODE_FUNC:
+       printf_filtered ("(TYPE_CODE_FUNC)");
+       break;
+      case TYPE_CODE_INT:
+       printf_filtered ("(TYPE_CODE_INT)");
+       break;
+      case TYPE_CODE_FLT:
+       printf_filtered ("(TYPE_CODE_FLT)");
+       break;
+      case TYPE_CODE_VOID:
+       printf_filtered ("(TYPE_CODE_VOID)");
+       break;
+      case TYPE_CODE_SET:
+       printf_filtered ("(TYPE_CODE_SET)");
+       break;
+      case TYPE_CODE_RANGE:
+       printf_filtered ("(TYPE_CODE_RANGE)");
+       break;
+      case TYPE_CODE_STRING:
+       printf_filtered ("(TYPE_CODE_STRING)");
+       break;
+      case TYPE_CODE_ERROR:
+       printf_filtered ("(TYPE_CODE_ERROR)");
+       break;
+      case TYPE_CODE_MEMBER:
+       printf_filtered ("(TYPE_CODE_MEMBER)");
+       break;
+      case TYPE_CODE_METHOD:
+       printf_filtered ("(TYPE_CODE_METHOD)");
+       break;
+      case TYPE_CODE_REF:
+       printf_filtered ("(TYPE_CODE_REF)");
+       break;
+      case TYPE_CODE_CHAR:
+       printf_filtered ("(TYPE_CODE_CHAR)");
+       break;
+      case TYPE_CODE_BOOL:
+       printf_filtered ("(TYPE_CODE_BOOL)");
+       break;
+      default:
+       printf_filtered ("(UNKNOWN TYPE CODE)");
+       break;
+    }
+  puts_filtered ("\n");
+  printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
+  printfi_filtered (spaces, "objfile ");
+  gdb_print_address (TYPE_OBJFILE (type), gdb_stdout);
+  printf_filtered ("\n");
+  printfi_filtered (spaces, "target_type ");
+  gdb_print_address (TYPE_TARGET_TYPE (type), gdb_stdout);
+  printf_filtered ("\n");
+  if (TYPE_TARGET_TYPE (type) != NULL)
+    {
+      recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
+    }
+  printfi_filtered (spaces, "pointer_type ");
+  gdb_print_address (TYPE_POINTER_TYPE (type), gdb_stdout);
+  printf_filtered ("\n");
+  printfi_filtered (spaces, "reference_type ");
+  gdb_print_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
+  printf_filtered ("\n");
+  printfi_filtered (spaces, "function_type ");
+  gdb_print_address (TYPE_FUNCTION_TYPE (type), gdb_stdout);
+  printf_filtered ("\n");
+  printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
+  if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
+    {
+      puts_filtered (" TYPE_FLAG_UNSIGNED");
+    }
+  if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
+    {
+      puts_filtered (" TYPE_FLAG_STUB");
+    }
+  puts_filtered ("\n");
+  printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
+  gdb_print_address (TYPE_FIELDS (type), gdb_stdout);
+  puts_filtered ("\n");
+  for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
+    {
+      printfi_filtered (spaces + 2,
+                       "[%d] bitpos %d bitsize %d type ",
+                       idx, TYPE_FIELD_BITPOS (type, idx),
+                       TYPE_FIELD_BITSIZE (type, idx));
+      gdb_print_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
+      printf_filtered (" name '%s' (",
+                      TYPE_FIELD_NAME (type, idx) != NULL
+                      ? TYPE_FIELD_NAME (type, idx)
+                      : "<NULL>");
+      gdb_print_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
+      printf_filtered (")\n");
+      if (TYPE_FIELD_TYPE (type, idx) != NULL)
+       {
+         recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
+       }
+    }
+  printfi_filtered (spaces, "vptr_basetype ");
+  gdb_print_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
+  puts_filtered ("\n");
+  if (TYPE_VPTR_BASETYPE (type) != NULL)
+    {
+      recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
+    }
+  printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
+  switch (TYPE_CODE (type))
+    {
+      case TYPE_CODE_METHOD:
+      case TYPE_CODE_FUNC:
+       printfi_filtered (spaces, "arg_types ");
+       gdb_print_address (TYPE_ARG_TYPES (type), gdb_stdout);
+       puts_filtered ("\n");
+       print_arg_types (TYPE_ARG_TYPES (type), spaces);
+       break;
+
+      case TYPE_CODE_STRUCT:
+       printfi_filtered (spaces, "cplus_stuff ");
+       gdb_print_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
+       puts_filtered ("\n");
+       print_cplus_stuff (type, spaces);
+       break;
+
+      default:
+       /* We have to pick one of the union types to be able print and test
+          the value.  Pick cplus_struct_type, even though we know it isn't
+          any particular one. */
+       printfi_filtered (spaces, "type_specific ");
+       gdb_print_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
+       if (TYPE_CPLUS_SPECIFIC (type) != NULL)
+         {
+           printf_filtered (" (unknown data form)");
+         }
+       printf_filtered ("\n");
+       break;
+
+    }
+}
+
+#endif /* MAINTENANCE_CMDS */
+
+void
+_initialize_gdbtypes ()
+{
+  builtin_type_void =
+    init_type (TYPE_CODE_VOID, 1,
+              0,
+              "void", (struct objfile *) NULL);
+  builtin_type_char =
+    init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+              0,
+              "char", (struct objfile *) NULL);
+  builtin_type_signed_char =
+    init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+              0,
+              "signed char", (struct objfile *) NULL);
+  builtin_type_unsigned_char =
+    init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+              TYPE_FLAG_UNSIGNED,
+              "unsigned char", (struct objfile *) NULL);
+  builtin_type_short =
+    init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
+              0,
+              "short", (struct objfile *) NULL);
+  builtin_type_unsigned_short =
+    init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
+              TYPE_FLAG_UNSIGNED,
+              "unsigned short", (struct objfile *) NULL);
+  builtin_type_int =
+    init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+              0,
+              "int", (struct objfile *) NULL);
+  builtin_type_unsigned_int =
+    init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+              TYPE_FLAG_UNSIGNED,
+              "unsigned int", (struct objfile *) NULL);
+  builtin_type_long =
+    init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
+              0,
+              "long", (struct objfile *) NULL);
+  builtin_type_unsigned_long =
+    init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
+              TYPE_FLAG_UNSIGNED,
+              "unsigned long", (struct objfile *) NULL);
+  builtin_type_long_long =
+    init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
+              0,
+              "long long", (struct objfile *) NULL);
+  builtin_type_unsigned_long_long = 
+    init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
+              TYPE_FLAG_UNSIGNED,
+              "unsigned long long", (struct objfile *) NULL);
+  builtin_type_float =
+    init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
+              0,
+              "float", (struct objfile *) NULL);
+  builtin_type_double =
+    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
+              0,
+              "double", (struct objfile *) NULL);
+  builtin_type_long_double =
+    init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
+              0,
+              "long double", (struct objfile *) NULL);
+  builtin_type_complex =
+    init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
+              0,
+              "complex", (struct objfile *) NULL);
+  builtin_type_double_complex =
+    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
+              0,
+              "double complex", (struct objfile *) NULL);
+  builtin_type_string =
+    init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+              0,
+              "string", (struct objfile *) NULL);
+}