projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
*** empty log message ***
[deliverable/binutils-gdb.git] / gdb / gdbtypes.c
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index e8917d068554aa33ae2cc3a757886be0bccd0f38..6d3e3a78e052b746a6b4a24bcac97414ec2e8b06 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1,5 +1,6 @@
 /* Support routines for manipulating internal types for GDB.
 /* Support routines for manipulating internal types for GDB.
-   Copyright (C) 1992, 93, 94, 95, 96, 1998 Free Software Foundation, Inc.
+   Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
+   Free Software Foundation, Inc.
    Contributed by Cygnus Support, using pieces from other GDB modules.
 
    This file is part of GDB.
    Contributed by Cygnus Support, using pieces from other GDB modules.
 
    This file is part of GDB.
@@ -33,6 +34,9 @@
 #include "demangle.h"
 #include "complaints.h"
 #include "gdbcmd.h"
 #include "demangle.h"
 #include "complaints.h"
 #include "gdbcmd.h"
+#include "wrapper.h"
+#include "cp-abi.h"
+#include "gdb_assert.h"
 
 /* These variables point to the objects
    representing the predefined C data types.  */
 
 /* These variables point to the objects
    representing the predefined C data types.  */
@@ -64,37 +68,83 @@ struct type *builtin_type_int32;
 struct type *builtin_type_uint32;
 struct type *builtin_type_int64;
 struct type *builtin_type_uint64;
 struct type *builtin_type_uint32;
 struct type *builtin_type_int64;
 struct type *builtin_type_uint64;
+struct type *builtin_type_int128;
+struct type *builtin_type_uint128;
 struct type *builtin_type_bool;
 struct type *builtin_type_bool;
+
+/* 128 bit long vector types */
+struct type *builtin_type_v2_double;
+struct type *builtin_type_v4_float;
+struct type *builtin_type_v2_int64;
+struct type *builtin_type_v4_int32;
+struct type *builtin_type_v8_int16;
+struct type *builtin_type_v16_int8;
+/* 64 bit long vector types */
+struct type *builtin_type_v2_float;
+struct type *builtin_type_v2_int32;
+struct type *builtin_type_v4_int16;
+struct type *builtin_type_v8_int8;
+
 struct type *builtin_type_v4sf;
 struct type *builtin_type_v4sf;
+struct type *builtin_type_v4si;
+struct type *builtin_type_v16qi;
+struct type *builtin_type_v8qi;
+struct type *builtin_type_v8hi;
+struct type *builtin_type_v4hi;
+struct type *builtin_type_v2si;
+struct type *builtin_type_vec64;
+struct type *builtin_type_vec64i;
+struct type *builtin_type_vec128;
+struct type *builtin_type_vec128i;
+struct type *builtin_type_ieee_single_big;
+struct type *builtin_type_ieee_single_little;
+struct type *builtin_type_ieee_double_big;
+struct type *builtin_type_ieee_double_little;
+struct type *builtin_type_ieee_double_littlebyte_bigword;
+struct type *builtin_type_i387_ext;
+struct type *builtin_type_m68881_ext;
+struct type *builtin_type_i960_ext;
+struct type *builtin_type_m88110_ext;
+struct type *builtin_type_m88110_harris_ext;
+struct type *builtin_type_arm_ext_big;
+struct type *builtin_type_arm_ext_littlebyte_bigword;
+struct type *builtin_type_ia64_spill_big;
+struct type *builtin_type_ia64_spill_little;
+struct type *builtin_type_ia64_quad_big;
+struct type *builtin_type_ia64_quad_little;
+struct type *builtin_type_void_data_ptr;
+struct type *builtin_type_void_func_ptr;
+struct type *builtin_type_CORE_ADDR;
+struct type *builtin_type_bfd_vma;
 
 int opaque_type_resolution = 1;
 
 int opaque_type_resolution = 1;
-
+int overload_debug = 0;
 
 struct extra
   {
     char str[128];
     int len;
 
 struct extra
   {
     char str[128];
     int len;
-  };                           /* maximum extention is 128! FIXME */
+  };                           /* maximum extension is 128! FIXME */
 
 
-static void add_name PARAMS ((struct extra *, char *));
-static void add_mangled_type PARAMS ((struct extra *, struct type *));
+static void add_name (struct extra *, char *);
+static void add_mangled_type (struct extra *, struct type *);
 #if 0
 #if 0
-static void cfront_mangle_name PARAMS ((struct type *, int, int));
+static void cfront_mangle_name (struct type *, int, int);
 #endif
 #endif
-static void print_bit_vector PARAMS ((B_TYPE *, int));
-static void print_arg_types PARAMS ((struct type **, int));
-static void dump_fn_fieldlists PARAMS ((struct type *, int));
-static void print_cplus_stuff PARAMS ((struct type *, int));
-static void virtual_base_list_aux PARAMS ((struct type * dclass));
+static void print_bit_vector (B_TYPE *, int);
+static void print_arg_types (struct field *, int, int);
+static void dump_fn_fieldlists (struct type *, int);
+static void print_cplus_stuff (struct type *, int);
+static void virtual_base_list_aux (struct type *dclass);
 
 
 /* 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
-   in that objfile's type_obstack. */
+   in that objfile's type_obstack.  Otherwise allocate the new type structure
+   by xmalloc () (for permanent types).  */
 
 struct type *
 
 struct type *
-alloc_type (objfile)
-     struct objfile *objfile;
+alloc_type (struct objfile *objfile)
 {
   register struct type *type;
 
 {
   register struct type *type;
 
@@ -102,35 +152,80 @@ alloc_type (objfile)
 
   if (objfile == NULL)
     {
 
   if (objfile == NULL)
     {
-      type = (struct type *) xmalloc (sizeof (struct type));
+      type = xmalloc (sizeof (struct type));
+      memset (type, 0, sizeof (struct type));
+      TYPE_MAIN_TYPE (type) = xmalloc (sizeof (struct main_type));
     }
   else
     {
     }
   else
     {
-      type = (struct type *) obstack_alloc (&objfile->type_obstack,
-                                           sizeof (struct type));
+      type = obstack_alloc (&objfile->type_obstack,
+                           sizeof (struct type));
+      memset (type, 0, sizeof (struct type));
+      TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->type_obstack,
+                                            sizeof (struct main_type));
       OBJSTAT (objfile, n_types++);
     }
       OBJSTAT (objfile, n_types++);
     }
-  memset ((char *) type, 0, sizeof (struct type));
+  memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
 
   /* Initialize the fields that might not be zero. */
 
   TYPE_CODE (type) = TYPE_CODE_UNDEF;
   TYPE_OBJFILE (type) = objfile;
   TYPE_VPTR_FIELDNO (type) = -1;
 
   /* Initialize the fields that might not be zero. */
 
   TYPE_CODE (type) = TYPE_CODE_UNDEF;
   TYPE_OBJFILE (type) = objfile;
   TYPE_VPTR_FIELDNO (type) = -1;
-  TYPE_CV_TYPE (type) = type;  /* chain back to itself */
+  TYPE_CHAIN (type) = type;    /* Chain back to itself.  */
 
   return (type);
 }
 
 
   return (type);
 }
 
+/* Alloc a new type instance structure, fill it with some defaults,
+   and point it at OLDTYPE.  Allocate the new type instance from the
+   same place as OLDTYPE.  */
+
+static struct type *
+alloc_type_instance (struct type *oldtype)
+{
+  struct type *type;
+
+  /* Allocate the structure.  */
+
+  if (TYPE_OBJFILE (oldtype) == NULL)
+    {
+      type = xmalloc (sizeof (struct type));
+      memset (type, 0, sizeof (struct type));
+    }
+  else
+    {
+      type = obstack_alloc (&TYPE_OBJFILE (oldtype)->type_obstack,
+                           sizeof (struct type));
+      memset (type, 0, sizeof (struct type));
+    }
+  TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
+
+  TYPE_CHAIN (type) = type;    /* Chain back to itself for now.  */
+
+  return (type);
+}
+
+/* Clear all remnants of the previous type at TYPE, in preparation for
+   replacing it with something else.  */
+static void
+smash_type (struct type *type)
+{
+  memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
+
+  /* For now, delete the rings.  */
+  TYPE_CHAIN (type) = type;
+
+  /* For now, leave the pointer/reference types alone.  */
+}
+
 /* Lookup a pointer to a type TYPE.  TYPEPTR, if nonzero, points
    to a pointer to memory where the pointer type should be stored.
    If *TYPEPTR is zero, update it to point to the pointer type we return.
    We allocate new memory if needed.  */
 
 struct type *
 /* Lookup a pointer to a type TYPE.  TYPEPTR, if nonzero, points
    to a pointer to memory where the pointer type should be stored.
    If *TYPEPTR is zero, update it to point to the pointer type we return.
    We allocate new memory if needed.  */
 
 struct type *
-make_pointer_type (type, typeptr)
-     struct type *type;
-     struct type **typeptr;
+make_pointer_type (struct type *type, struct type **typeptr)
 {
   register struct type *ntype; /* New type */
   struct objfile *objfile;
 {
   register struct type *ntype; /* New type */
   struct objfile *objfile;
@@ -159,7 +254,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));
+      smash_type (ntype);
       TYPE_OBJFILE (ntype) = objfile;
     }
 
       TYPE_OBJFILE (ntype) = objfile;
     }
 
@@ -171,7 +266,9 @@ make_pointer_type (type, typeptr)
   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
   TYPE_CODE (ntype) = TYPE_CODE_PTR;
 
   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
   TYPE_CODE (ntype) = TYPE_CODE_PTR;
 
-  /* pointers are unsigned */
+  /* Mark pointers as unsigned.  The target converts between pointers
+     and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
+     ADDRESS_TO_POINTER(). */
   TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
 
   if (!TYPE_POINTER_TYPE (type))       /* Remember it, if don't have one.  */
   TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
 
   if (!TYPE_POINTER_TYPE (type))       /* Remember it, if don't have one.  */
@@ -184,8 +281,7 @@ make_pointer_type (type, typeptr)
    May need to construct such a type if this is the first use.  */
 
 struct type *
    May need to construct such a type if this is the first use.  */
 
 struct type *
-lookup_pointer_type (type)
-     struct type *type;
+lookup_pointer_type (struct type *type)
 {
   return make_pointer_type (type, (struct type **) 0);
 }
 {
   return make_pointer_type (type, (struct type **) 0);
 }
@@ -196,9 +292,7 @@ lookup_pointer_type (type)
    We allocate new memory if needed.  */
 
 struct type *
    We allocate new memory if needed.  */
 
 struct type *
-make_reference_type (type, typeptr)
-     struct type *type;
-     struct type **typeptr;
+make_reference_type (struct type *type, struct type **typeptr)
 {
   register struct type *ntype; /* New type */
   struct objfile *objfile;
 {
   register struct type *ntype; /* New type */
   struct objfile *objfile;
@@ -227,7 +321,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));
+      smash_type (ntype);
       TYPE_OBJFILE (ntype) = objfile;
     }
 
       TYPE_OBJFILE (ntype) = objfile;
     }
 
@@ -249,8 +343,7 @@ make_reference_type (type, typeptr)
 /* Same as above, but caller doesn't care about memory allocation details.  */
 
 struct type *
 /* Same as above, but caller doesn't care about memory allocation details.  */
 
 struct type *
-lookup_reference_type (type)
-     struct type *type;
+lookup_reference_type (struct type *type)
 {
   return make_reference_type (type, (struct type **) 0);
 }
 {
   return make_reference_type (type, (struct type **) 0);
 }
@@ -261,9 +354,7 @@ lookup_reference_type (type)
    We allocate new memory if needed.  */
 
 struct type *
    We allocate new memory if needed.  */
 
 struct type *
-make_function_type (type, typeptr)
-     struct type *type;
-     struct type **typeptr;
+make_function_type (struct type *type, struct type **typeptr)
 {
   register struct type *ntype; /* New type */
   struct objfile *objfile;
 {
   register struct type *ntype; /* New type */
   struct objfile *objfile;
@@ -279,7 +370,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));
+      smash_type (ntype);
       TYPE_OBJFILE (ntype) = objfile;
     }
 
       TYPE_OBJFILE (ntype) = objfile;
     }
 
@@ -296,12 +387,110 @@ make_function_type (type, typeptr)
    May need to construct such a type if this is the first use.  */
 
 struct type *
    May need to construct such a type if this is the first use.  */
 
 struct type *
-lookup_function_type (type)
-     struct type *type;
+lookup_function_type (struct type *type)
 {
   return make_function_type (type, (struct type **) 0);
 }
 
 {
   return make_function_type (type, (struct type **) 0);
 }
 
+/* Identify address space identifier by name --
+   return the integer flag defined in gdbtypes.h.  */
+extern int
+address_space_name_to_int (char *space_identifier)
+{
+  struct gdbarch *gdbarch = current_gdbarch;
+  int type_flags;
+  /* Check for known address space delimiters. */
+  if (!strcmp (space_identifier, "code"))
+    return TYPE_FLAG_CODE_SPACE;
+  else if (!strcmp (space_identifier, "data"))
+    return TYPE_FLAG_DATA_SPACE;
+  else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
+           && gdbarch_address_class_name_to_type_flags (gdbarch,
+                                                       space_identifier,
+                                                       &type_flags))
+    return type_flags;
+  else
+    error ("Unknown address space specifier: \"%s\"", space_identifier);
+}
+
+/* Identify address space identifier by integer flag as defined in 
+   gdbtypes.h -- return the string version of the adress space name. */
+
+const char *
+address_space_int_to_name (int space_flag)
+{
+  struct gdbarch *gdbarch = current_gdbarch;
+  if (space_flag & TYPE_FLAG_CODE_SPACE)
+    return "code";
+  else if (space_flag & TYPE_FLAG_DATA_SPACE)
+    return "data";
+  else if ((space_flag & TYPE_FLAG_ADDRESS_CLASS_ALL)
+           && gdbarch_address_class_type_flags_to_name_p (gdbarch))
+    return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
+  else
+    return NULL;
+}
+
+/* Create a new type with instance flags NEW_FLAGS, based on TYPE.
+   If STORAGE is non-NULL, create the new type instance there.  */
+
+struct type *
+make_qualified_type (struct type *type, int new_flags,
+                    struct type *storage)
+{
+  struct type *ntype;
+
+  ntype = type;
+  do {
+    if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
+      return ntype;
+    ntype = TYPE_CHAIN (ntype);
+  } while (ntype != type);
+
+  /* Create a new type instance.  */
+  if (storage == NULL)
+    ntype = alloc_type_instance (type);
+  else
+    {
+      ntype = storage;
+      TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
+      TYPE_CHAIN (ntype) = ntype;
+    }
+
+  /* Pointers or references to the original type are not relevant to
+     the new type.  */
+  TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
+  TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
+
+  /* Chain the new qualified type to the old type.  */
+  TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
+  TYPE_CHAIN (type) = ntype;
+
+  /* Now set the instance flags and return the new type.  */
+  TYPE_INSTANCE_FLAGS (ntype) = new_flags;
+
+  return ntype;
+}
+
+/* Make an address-space-delimited variant of a type -- a type that
+   is identical to the one supplied except that it has an address
+   space attribute attached to it (such as "code" or "data").
+
+   The space attributes "code" and "data" are for Harvard architectures.
+   The address space attributes are for architectures which have
+   alternately sized pointers or pointers with alternate representations.  */
+
+struct type *
+make_type_with_address_space (struct type *type, int space_flag)
+{
+  struct type *ntype;
+  int new_flags = ((TYPE_INSTANCE_FLAGS (type)
+                   & ~(TYPE_FLAG_CODE_SPACE | TYPE_FLAG_DATA_SPACE
+                       | TYPE_FLAG_ADDRESS_CLASS_ALL))
+                  | space_flag);
+
+  return make_qualified_type (type, new_flags, NULL);
+}
 
 /* Make a "c-v" variant of a type -- a type that is identical to the
    one supplied except that it may have const or volatile attributes
 
 /* Make a "c-v" variant of a type -- a type that is identical to the
    one supplied except that it may have const or volatile attributes
@@ -314,77 +503,67 @@ lookup_function_type (type)
    We allocate new memory if needed.  */
 
 struct type *
    We allocate new memory if needed.  */
 
 struct type *
-make_cv_type (cnst, voltl, type, typeptr)
-     int cnst;
-     int voltl;
-     struct type *type;
-     struct type **typeptr;
+make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
 {
   register struct type *ntype; /* New type */
   register struct type *tmp_type = type;       /* tmp type */
   struct objfile *objfile;
 
 {
   register struct type *ntype; /* New type */
   register struct type *tmp_type = type;       /* tmp type */
   struct objfile *objfile;
 
-  ntype = TYPE_CV_TYPE (type);
+  int new_flags = (TYPE_INSTANCE_FLAGS (type)
+                  & ~(TYPE_FLAG_CONST | TYPE_FLAG_VOLATILE));
 
 
-  while (ntype != type)
+  if (cnst)
+    new_flags |= TYPE_FLAG_CONST;
+
+  if (voltl)
+    new_flags |= TYPE_FLAG_VOLATILE;
+
+  if (typeptr && *typeptr != NULL)
     {
     {
-      if ((TYPE_CONST (ntype) == cnst) &&
-         (TYPE_VOLATILE (ntype) == voltl))
+      /* Objfile is per-core-type.  This const-qualified type had best
+        belong to the same objfile as the type it is qualifying, unless
+        we are overwriting a stub type, in which case the safest thing
+        to do is to copy the core type into the new objfile.  */
+
+      gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)
+                 || TYPE_STUB (*typeptr));
+      if (TYPE_OBJFILE (*typeptr) != TYPE_OBJFILE (type))
        {
        {
-         if (typeptr == 0)
-           return ntype;
-         else if (*typeptr == 0)
-           {
-             *typeptr = ntype; /* Tracking alloc, and we have new type.  */
-             return ntype;
-           }
+         TYPE_MAIN_TYPE (*typeptr)
+           = TYPE_ALLOC (*typeptr, sizeof (struct main_type));
+         *TYPE_MAIN_TYPE (*typeptr)
+           = *TYPE_MAIN_TYPE (type);
        }
        }
-      tmp_type = ntype;
-      ntype = TYPE_CV_TYPE (ntype);
-    }
-
-  if (typeptr == 0 || *typeptr == 0)   /* We'll need to allocate one.  */
-    {
-      ntype = alloc_type (TYPE_OBJFILE (type));
-      if (typeptr)
-       *typeptr = ntype;
-    }
-  else
-    /* We have storage, but need to reset it.  */
-    {
-      ntype = *typeptr;
-      objfile = TYPE_OBJFILE (ntype);
-      /* memset ((char *) ntype, 0, sizeof (struct type)); */
-      TYPE_OBJFILE (ntype) = objfile;
     }
     }
+  
+  ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL);
 
 
-  /* Copy original type */
-  memcpy ((char *) ntype, (char *) type, sizeof (struct type));
-  /* But zero out fields that shouldn't be copied */
-  TYPE_POINTER_TYPE (ntype) = (struct type *) 0;       /* Need new pointer kind */
-  TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;     /* Need new referene kind */
-  /* Note: TYPE_TARGET_TYPE can be left as is */
-
-  /* Set flags appropriately */
-  if (cnst)
-    TYPE_FLAGS (ntype) |= TYPE_FLAG_CONST;
-  else
-    TYPE_FLAGS (ntype) &= ~TYPE_FLAG_CONST;
-
-  if (voltl)
-    TYPE_FLAGS (ntype) |= TYPE_FLAG_VOLATILE;
-  else
-    TYPE_FLAGS (ntype) &= ~TYPE_FLAG_VOLATILE;
-
-  /* Fix the chain of cv variants */
-  TYPE_CV_TYPE (ntype) = type;
-  TYPE_CV_TYPE (tmp_type) = ntype;
+  if (typeptr != NULL)
+    *typeptr = ntype;
 
   return ntype;
 }
 
 
   return ntype;
 }
 
+/* Replace the contents of ntype with the type *type.  This changes the
+   contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
+   the changes are propogated to all types in the TYPE_CHAIN.
 
 
+   In order to build recursive types, it's inevitable that we'll need
+   to update types in place --- but this sort of indiscriminate
+   smashing is ugly, and needs to be replaced with something more
+   controlled.  TYPE_MAIN_TYPE is a step in this direction; it's not
+   clear if more steps are needed.  */
+void
+replace_type (struct type *ntype, struct type *type)
+{
+  struct type *cv_chain, *as_chain, *ptr, *ref;
 
 
+  *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
+
+  /* Assert that the two types have equivalent instance qualifiers.
+     This should be true for at least all of our debug readers.  */
+  gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
+}
 
 /* Implement direct support for MEMBER_TYPE in GNU C++.
    May need to construct such a type if this is the first use.
 
 /* Implement direct support for MEMBER_TYPE in GNU C++.
    May need to construct such a type if this is the first use.
@@ -392,9 +571,7 @@ make_cv_type (cnst, voltl, type, typeptr)
    of the aggregate that the member belongs to.  */
 
 struct type *
    of the aggregate that the member belongs to.  */
 
 struct type *
-lookup_member_type (type, domain)
-     struct type *type;
-     struct type *domain;
+lookup_member_type (struct type *type, struct type *domain)
 {
   register struct type *mtype;
 
 {
   register struct type *mtype;
 
@@ -410,18 +587,14 @@ lookup_member_type (type, domain)
    This always returns a fresh type.   */
 
 struct type *
    This always returns a fresh type.   */
 
 struct type *
-allocate_stub_method (type)
-     struct type *type;
+allocate_stub_method (struct type *type)
 {
   struct type *mtype;
 
 {
   struct type *mtype;
 
-  mtype = alloc_type (TYPE_OBJFILE (type));
+  mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB, NULL,
+                    TYPE_OBJFILE (type));
   TYPE_TARGET_TYPE (mtype) = type;
   /*  _DOMAIN_TYPE (mtype) = unknown yet */
   TYPE_TARGET_TYPE (mtype) = type;
   /*  _DOMAIN_TYPE (mtype) = unknown yet */
-  /*  _ARG_TYPES (mtype) = unknown yet */
-  TYPE_FLAGS (mtype) = TYPE_FLAG_STUB;
-  TYPE_CODE (mtype) = TYPE_CODE_METHOD;
-  TYPE_LENGTH (mtype) = 1;
   return (mtype);
 }
 
   return (mtype);
 }
 
@@ -435,11 +608,8 @@ allocate_stub_method (type)
    sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
 
 struct type *
    sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
 
 struct type *
-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;
+create_range_type (struct type *result_type, struct type *index_type,
+                  int low_bound, int high_bound)
 {
   if (result_type == NULL)
     {
 {
   if (result_type == NULL)
     {
@@ -447,7 +617,7 @@ create_range_type (result_type, index_type, low_bound, high_bound)
     }
   TYPE_CODE (result_type) = TYPE_CODE_RANGE;
   TYPE_TARGET_TYPE (result_type) = index_type;
     }
   TYPE_CODE (result_type) = TYPE_CODE_RANGE;
   TYPE_TARGET_TYPE (result_type) = index_type;
-  if (TYPE_FLAGS (index_type) & TYPE_FLAG_STUB)
+  if (TYPE_STUB (index_type))
     TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
   else
     TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
     TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
   else
     TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
@@ -471,9 +641,7 @@ create_range_type (result_type, index_type, low_bound, high_bound)
    will fit in LONGEST), or -1 otherwise. */
 
 int
    will fit in LONGEST), or -1 otherwise. */
 
 int
-get_discrete_bounds (type, lowp, highp)
-     struct type *type;
-     LONGEST *lowp, *highp;
+get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
 {
   CHECK_TYPEDEF (type);
   switch (TYPE_CODE (type))
 {
   CHECK_TYPEDEF (type);
   switch (TYPE_CODE (type))
@@ -547,10 +715,8 @@ get_discrete_bounds (type, lowp, highp)
    sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
 
 struct type *
    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;
+create_array_type (struct type *result_type, struct type *element_type,
+                  struct type *range_type)
 {
   LONGEST low_bound, high_bound;
 
 {
   LONGEST low_bound, high_bound;
 
@@ -591,9 +757,7 @@ create_array_type (result_type, element_type, range_type)
    sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
 
 struct type *
    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;
+create_string_type (struct type *result_type, struct type *range_type)
 {
   result_type = create_array_type (result_type,
                                   *current_language->string_char_type,
 {
   result_type = create_array_type (result_type,
                                   *current_language->string_char_type,
@@ -603,9 +767,7 @@ create_string_type (result_type, range_type)
 }
 
 struct type *
 }
 
 struct type *
-create_set_type (result_type, domain_type)
-     struct type *result_type;
-     struct type *domain_type;
+create_set_type (struct type *result_type, struct type *domain_type)
 {
   LONGEST low_bound, high_bound, bit_length;
   if (result_type == NULL)
 {
   LONGEST low_bound, high_bound, bit_length;
   if (result_type == NULL)
@@ -618,7 +780,7 @@ create_set_type (result_type, domain_type)
     TYPE_ALLOC (result_type, 1 * sizeof (struct field));
   memset (TYPE_FIELDS (result_type), 0, sizeof (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))
+  if (!TYPE_STUB (domain_type))
     {
       if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
        low_bound = high_bound = 0;
     {
       if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
        low_bound = high_bound = 0;
@@ -634,7 +796,6 @@ create_set_type (result_type, domain_type)
   return (result_type);
 }
 
   return (result_type);
 }
 
-
 /* Construct and return a type of the form:
        struct NAME { ELT_TYPE ELT_NAME[N]; }
    We use these types for SIMD registers.  For example, the type of
 /* Construct and return a type of the form:
        struct NAME { ELT_TYPE ELT_NAME[N]; }
    We use these types for SIMD registers.  For example, the type of
@@ -644,33 +805,142 @@ create_set_type (result_type, domain_type)
        init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
    The type returned is a permanent type, allocated using malloc; it
    doesn't live in any objfile's obstack.  */
        init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
    The type returned is a permanent type, allocated using malloc; it
    doesn't live in any objfile's obstack.  */
-struct type *
+static struct type *
 init_simd_type (char *name,
                struct type *elt_type,
                char *elt_name,
                int n)
 {
 init_simd_type (char *name,
                struct type *elt_type,
                char *elt_name,
                int n)
 {
+  struct type *simd_type;
+  struct type *array_type;
+  
+  simd_type = init_composite_type (name, TYPE_CODE_STRUCT);
+  array_type = create_array_type (0, elt_type,
+                                 create_range_type (0, builtin_type_int,
+                                                    0, n-1));
+  append_composite_type_field (simd_type, elt_name, array_type);
+  return simd_type;
+}
+
+static struct type *
+init_vector_type (struct type *elt_type, int n)
+{
+  struct type *array_type;
+ 
+  array_type = create_array_type (0, elt_type,
+                                 create_range_type (0, builtin_type_int,
+                                                    0, n-1));
+  TYPE_FLAGS (array_type) |= TYPE_FLAG_VECTOR;
+  return array_type;
+}
+
+static struct type *
+build_builtin_type_vec64 (void)
+{
+  /* Construct a type for the 64 bit registers.  The type we're
+     building is this: */
+#if 0
+  union __gdb_builtin_type_vec64
+  {
+    int64_t uint64;
+    float v2_float[2];
+    int32_t v2_int32[2];
+    int16_t v4_int16[4];
+    int8_t v8_int8[8];
+  };
+#endif
+
+  struct type *t;
+
+  t = init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION);
+  append_composite_type_field (t, "uint64", builtin_type_int64);
+  append_composite_type_field (t, "v2_float", builtin_type_v2_float);
+  append_composite_type_field (t, "v2_int32", builtin_type_v2_int32);
+  append_composite_type_field (t, "v4_int16", builtin_type_v4_int16);
+  append_composite_type_field (t, "v8_int8", builtin_type_v8_int8);
+
+  TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
+  TYPE_NAME (t) = "builtin_type_vec64";
+  return t;
+}
+
+static struct type *
+build_builtin_type_vec64i (void)
+{
+  /* Construct a type for the 64 bit registers.  The type we're
+     building is this: */
+#if 0
+  union __gdb_builtin_type_vec64i 
+  {
+    int64_t uint64;
+    int32_t v2_int32[2];
+    int16_t v4_int16[4];
+    int8_t v8_int8[8];
+  };
+#endif
+
+  struct type *t;
+
+  t = init_composite_type ("__gdb_builtin_type_vec64i", TYPE_CODE_UNION);
+  append_composite_type_field (t, "uint64", builtin_type_int64);
+  append_composite_type_field (t, "v2_int32", builtin_type_v2_int32);
+  append_composite_type_field (t, "v4_int16", builtin_type_v4_int16);
+  append_composite_type_field (t, "v8_int8", builtin_type_v8_int8);
+
+  TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
+  TYPE_NAME (t) = "builtin_type_vec64i";
+  return t;
+}
+
+static struct type *
+build_builtin_type_vec128 (void)
+{
+  /* Construct a type for the 128 bit registers.  The type we're
+     building is this: */
+#if 0
+ union __gdb_builtin_type_vec128 
+  {
+    int128_t uint128;
+    float v4_float[4];
+    int32_t v4_int32[4];
+    int16_t v8_int16[8];
+    int8_t v16_int8[16];
+  };
+#endif
+
   struct type *t;
   struct type *t;
-  struct field *f;
 
 
-  /* Build the field structure.  */
-  f = xmalloc (sizeof (*f));
-  memset (f, 0, sizeof (*f));
-  f->loc.bitpos = 0;
-  f->type = create_array_type (0, elt_type,
-                              create_range_type (0, builtin_type_int,
-                                                 0, n-1));
-  f->name = elt_name;
-
-  /* Build a struct type with that field.  */
-  t = init_type (TYPE_CODE_STRUCT, n * TYPE_LENGTH (elt_type), 0, 0, 0);
-  t->nfields = 1;
-  t->fields = f;
-  t->tag_name = name;
+  t = init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION);
+  append_composite_type_field (t, "uint128", builtin_type_int128);
+  append_composite_type_field (t, "v4_float", builtin_type_v4_float);
+  append_composite_type_field (t, "v4_int32", builtin_type_v4_int32);
+  append_composite_type_field (t, "v8_int16", builtin_type_v8_int16);
+  append_composite_type_field (t, "v16_int8", builtin_type_v16_int8);
 
 
+  TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
+  TYPE_NAME (t) = "builtin_type_vec128";
   return t;
 }
 
   return t;
 }
 
+static struct type *
+build_builtin_type_vec128i (void)
+{
+  /* 128-bit Intel SIMD registers */
+  struct type *t;
+
+  t = init_composite_type ("__gdb_builtin_type_vec128i", TYPE_CODE_UNION);
+  append_composite_type_field (t, "v4_float", builtin_type_v4_float);
+  append_composite_type_field (t, "v2_double", builtin_type_v2_double);
+  append_composite_type_field (t, "v16_int8", builtin_type_v16_int8);
+  append_composite_type_field (t, "v8_int16", builtin_type_v8_int16);
+  append_composite_type_field (t, "v4_int32", builtin_type_v4_int32);
+  append_composite_type_field (t, "v2_int64", builtin_type_v2_int64);
+  append_composite_type_field (t, "uint128", builtin_type_int128);
+
+  TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR;
+  TYPE_NAME (t) = "builtin_type_vec128i";
+  return t;
+}
 
 /* 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
@@ -683,16 +953,14 @@ init_simd_type (char *name,
    allocated.  */
 
 void
    allocated.  */
 
 void
-smash_to_member_type (type, domain, to_type)
-     struct type *type;
-     struct type *domain;
-     struct type *to_type;
+smash_to_member_type (struct type *type, struct type *domain,
+                     struct type *to_type)
 {
   struct objfile *objfile;
 
   objfile = TYPE_OBJFILE (type);
 
 {
   struct objfile *objfile;
 
   objfile = TYPE_OBJFILE (type);
 
-  memset ((char *) type, 0, sizeof (struct type));
+  smash_type (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;
@@ -708,21 +976,22 @@ smash_to_member_type (type, domain, to_type)
    allocated.  */
 
 void
    allocated.  */
 
 void
-smash_to_method_type (type, domain, to_type, args)
-     struct type *type;
-     struct type *domain;
-     struct type *to_type;
-     struct type **args;
+smash_to_method_type (struct type *type, struct type *domain,
+                     struct type *to_type, struct field *args,
+                     int nargs, int varargs)
 {
   struct objfile *objfile;
 
   objfile = TYPE_OBJFILE (type);
 
 {
   struct objfile *objfile;
 
   objfile = TYPE_OBJFILE (type);
 
-  memset ((char *) type, 0, sizeof (struct type));
+  smash_type (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;
-  TYPE_ARG_TYPES (type) = args;
+  TYPE_FIELDS (type) = args;
+  TYPE_NFIELDS (type) = nargs;
+  if (varargs)
+    TYPE_FLAGS (type) |= TYPE_FLAG_VARARGS;
   TYPE_LENGTH (type) = 1;      /* In practice, this is never needed.  */
   TYPE_CODE (type) = TYPE_CODE_METHOD;
 }
   TYPE_LENGTH (type) = 1;      /* In practice, this is never needed.  */
   TYPE_CODE (type) = TYPE_CODE_METHOD;
 }
@@ -731,8 +1000,7 @@ smash_to_method_type (type, domain, to_type, args)
    "union ", or "enum ".  If the type has a NULL name, return NULL.  */
 
 char *
    "union ", or "enum ".  If the type has a NULL name, return NULL.  */
 
 char *
-type_name_no_tag (type)
-     register const struct type *type;
+type_name_no_tag (register const struct type *type)
 {
   if (TYPE_TAG_NAME (type) != NULL)
     return TYPE_TAG_NAME (type);
 {
   if (TYPE_TAG_NAME (type) != NULL)
     return TYPE_TAG_NAME (type);
@@ -747,14 +1015,13 @@ type_name_no_tag (type)
    Return zero if NAME is not a primitive type. */
 
 struct type *
    Return zero if NAME is not a primitive type. */
 
 struct type *
-lookup_primitive_typename (name)
-     char *name;
+lookup_primitive_typename (char *name)
 {
   struct type **const *p;
 
   for (p = current_language->la_builtin_type_vector; *p != NULL; p++)
     {
 {
   struct type **const *p;
 
   for (p = current_language->la_builtin_type_vector; *p != NULL; p++)
     {
-      if (STREQ ((**p)->name, name))
+      if (STREQ (TYPE_NAME (**p), name))
        {
          return (**p);
        }
        {
          return (**p);
        }
@@ -767,10 +1034,7 @@ lookup_primitive_typename (name)
    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
 
 struct type *
    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
 
 struct type *
-lookup_typename (name, block, noerr)
-     char *name;
-     struct block *block;
-     int noerr;
+lookup_typename (char *name, struct block *block, int noerr)
 {
   register struct symbol *sym;
   register struct type *tmp;
 {
   register struct symbol *sym;
   register struct type *tmp;
@@ -796,8 +1060,7 @@ lookup_typename (name, block, noerr)
 }
 
 struct type *
 }
 
 struct type *
-lookup_unsigned_typename (name)
-     char *name;
+lookup_unsigned_typename (char *name)
 {
   char *uns = alloca (strlen (name) + 10);
 
 {
   char *uns = alloca (strlen (name) + 10);
 
@@ -807,8 +1070,7 @@ lookup_unsigned_typename (name)
 }
 
 struct type *
 }
 
 struct type *
-lookup_signed_typename (name)
-     char *name;
+lookup_signed_typename (char *name)
 {
   struct type *t;
   char *uns = alloca (strlen (name) + 8);
 {
   struct type *t;
   char *uns = alloca (strlen (name) + 8);
@@ -826,9 +1088,7 @@ lookup_signed_typename (name)
    visible in lexical block BLOCK.  */
 
 struct type *
    visible in lexical block BLOCK.  */
 
 struct type *
-lookup_struct (name, block)
-     char *name;
-     struct block *block;
+lookup_struct (char *name, struct block *block)
 {
   register struct symbol *sym;
 
 {
   register struct symbol *sym;
 
@@ -850,9 +1110,7 @@ lookup_struct (name, block)
    visible in lexical block BLOCK.  */
 
 struct type *
    visible in lexical block BLOCK.  */
 
 struct type *
-lookup_union (name, block)
-     char *name;
-     struct block *block;
+lookup_union (char *name, struct block *block)
 {
   register struct symbol *sym;
   struct type *t;
 {
   register struct symbol *sym;
   struct type *t;
@@ -884,9 +1142,7 @@ lookup_union (name, block)
    visible in lexical block BLOCK.  */
 
 struct type *
    visible in lexical block BLOCK.  */
 
 struct type *
-lookup_enum (name, block)
-     char *name;
-     struct block *block;
+lookup_enum (char *name, struct block *block)
 {
   register struct symbol *sym;
 
 {
   register struct symbol *sym;
 
@@ -907,16 +1163,13 @@ lookup_enum (name, block)
    visible in lexical block BLOCK.  */
 
 struct type *
    visible in lexical block BLOCK.  */
 
 struct type *
-lookup_template_type (name, type, block)
-     char *name;
-     struct type *type;
-     struct block *block;
+lookup_template_type (char *name, struct type *type, struct block *block)
 {
   struct symbol *sym;
 {
   struct symbol *sym;
-  char *nam = (char *) alloca (strlen (name) + strlen (type->name) + 4);
+  char *nam = (char *) alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
   strcpy (nam, name);
   strcat (nam, "<");
   strcpy (nam, name);
   strcat (nam, "<");
-  strcat (nam, type->name);
+  strcat (nam, TYPE_NAME (type));
   strcat (nam, " >");          /* FIXME, extra space still introduced in gcc? */
 
   sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
   strcat (nam, " >");          /* FIXME, extra space still introduced in gcc? */
 
   sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
@@ -943,10 +1196,7 @@ lookup_template_type (name, type, block)
    If NAME is the name of a baseclass type, return that type.  */
 
 struct type *
    If NAME is the name of a baseclass type, return that type.  */
 
 struct type *
-lookup_struct_elt_type (type, name, noerr)
-     struct type *type;
-     char *name;
-     int noerr;
+lookup_struct_elt_type (struct type *type, char *name, int noerr)
 {
   int i;
 
 {
   int i;
 
@@ -987,7 +1237,7 @@ lookup_struct_elt_type (type, name, noerr)
     {
       char *t_field_name = TYPE_FIELD_NAME (type, i);
 
     {
       char *t_field_name = TYPE_FIELD_NAME (type, i);
 
-      if (t_field_name && STREQ (t_field_name, name))
+      if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
        {
          return TYPE_FIELD_TYPE (type, i);
        }
        {
          return TYPE_FIELD_TYPE (type, i);
        }
@@ -1028,8 +1278,7 @@ lookup_struct_elt_type (type, name, noerr)
    will remain NULL.  */
 
 void
    will remain NULL.  */
 
 void
-fill_in_vptr_fieldno (type)
-     struct type *type;
+fill_in_vptr_fieldno (struct type *type)
 {
   CHECK_TYPEDEF (type);
 
 {
   CHECK_TYPEDEF (type);
 
@@ -1041,13 +1290,12 @@ fill_in_vptr_fieldno (type)
          virtual (and hence we cannot share the table pointer).  */
       for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
        {
          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)
+         struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
+         fill_in_vptr_fieldno (baseclass);
+         if (TYPE_VPTR_FIELDNO (baseclass) >= 0)
            {
            {
-             TYPE_VPTR_FIELDNO (type)
-               = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i));
-             TYPE_VPTR_BASETYPE (type)
-               = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type, i));
+             TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (baseclass);
+             TYPE_VPTR_BASETYPE (type) = TYPE_VPTR_BASETYPE (baseclass);
              break;
            }
        }
              break;
            }
        }
@@ -1058,10 +1306,7 @@ fill_in_vptr_fieldno (type)
    Return 1 if the destructor was found, otherwise, return 0.  */
 
 int
    Return 1 if the destructor was found, otherwise, return 0.  */
 
 int
-get_destructor_fn_field (t, method_indexp, field_indexp)
-     struct type *t;
-     int *method_indexp;
-     int *field_indexp;
+get_destructor_fn_field (struct type *t, int *method_indexp, int *field_indexp)
 {
   int i;
 
 {
   int i;
 
@@ -1072,7 +1317,7 @@ get_destructor_fn_field (t, method_indexp, field_indexp)
 
       for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i); j++)
        {
 
       for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i); j++)
        {
-         if (DESTRUCTOR_PREFIX_P (TYPE_FN_FIELD_PHYSNAME (f, j)))
+         if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f, j)) != 0)
            {
              *method_indexp = i;
              *field_indexp = j;
            {
              *method_indexp = i;
              *field_indexp = j;
@@ -1096,14 +1341,18 @@ get_destructor_fn_field (t, method_indexp, field_indexp)
    This used to be coded as a macro, but I don't think it is called 
    often enough to merit such treatment.  */
 
    This used to be coded as a macro, but I don't think it is called 
    often enough to merit such treatment.  */
 
-struct complaint stub_noname_complaint =
-{"stub type has NULL name", 0, 0};
+static void
+stub_noname_complaint (void)
+{
+  complaint (&symfile_complaints, "stub type has NULL name");
+}
 
 struct type *
 
 struct type *
-check_typedef (type)
-     register struct type *type;
+check_typedef (struct type *type)
 {
   struct type *orig_type = type;
 {
   struct type *orig_type = type;
+  int is_const, is_volatile;
+
   while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
     {
       if (!TYPE_TARGET_TYPE (type))
   while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
     {
       if (!TYPE_TARGET_TYPE (type))
@@ -1123,7 +1372,7 @@ check_typedef (type)
             TYPE_TAG_NAME were separate).  */
          if (name == NULL)
            {
             TYPE_TAG_NAME were separate).  */
          if (name == NULL)
            {
-             complain (&stub_noname_complaint);
+             stub_noname_complaint ();
              return type;
            }
          sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
              return type;
            }
          sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
@@ -1136,6 +1385,9 @@ check_typedef (type)
       type = TYPE_TARGET_TYPE (type);
     }
 
       type = TYPE_TARGET_TYPE (type);
     }
 
+  is_const = TYPE_CONST (type);
+  is_volatile = TYPE_VOLATILE (type);
+
   /* If this is a struct/class/union with no fields, then check whether a
      full definition exists somewhere else.  This is for systems where a
      type definition with no fields is issued for such types, instead of
   /* If this is a struct/class/union with no fields, then check whether a
      full definition exists somewhere else.  This is for systems where a
      type definition with no fields is issued for such types, instead of
@@ -1147,17 +1399,15 @@ check_typedef (type)
       struct type *newtype;
       if (name == NULL)
        {
       struct type *newtype;
       if (name == NULL)
        {
-         complain (&stub_noname_complaint);
+         stub_noname_complaint ();
          return type;
        }
       newtype = lookup_transparent_type (name);
       if (newtype)
          return type;
        }
       newtype = lookup_transparent_type (name);
       if (newtype)
-       {
-         memcpy ((char *) type, (char *) newtype, sizeof (struct type));
-       }
+       make_cv_type (is_const, is_volatile, newtype, &type);
     }
   /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
     }
   /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
-  else if ((TYPE_FLAGS (type) & TYPE_FLAG_STUB) && !currently_reading_symtab)
+  else if (TYPE_STUB (type) && !currently_reading_symtab)
     {
       char *name = type_name_no_tag (type);
       /* FIXME: shouldn't we separately check the TYPE_NAME and the
     {
       char *name = type_name_no_tag (type);
       /* FIXME: shouldn't we separately check the TYPE_NAME and the
@@ -1167,22 +1417,20 @@ check_typedef (type)
       struct symbol *sym;
       if (name == NULL)
        {
       struct symbol *sym;
       if (name == NULL)
        {
-         complain (&stub_noname_complaint);
+         stub_noname_complaint ();
          return type;
        }
       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, (struct symtab **) NULL);
       if (sym)
          return type;
        }
       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, (struct symtab **) NULL);
       if (sym)
-       {
-         memcpy ((char *) type, (char *) SYMBOL_TYPE (sym), sizeof (struct type));
-       }
+       make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym), &type);
     }
 
     }
 
-  if (TYPE_FLAGS (type) & TYPE_FLAG_TARGET_STUB)
+  if (TYPE_TARGET_STUB (type))
     {
       struct type *range_type;
       struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
 
     {
       struct type *range_type;
       struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
 
-      if (TYPE_FLAGS (target_type) & (TYPE_FLAG_STUB | TYPE_FLAG_TARGET_STUB))
+      if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
        {
        }
       else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
        {
        }
       else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
@@ -1211,14 +1459,11 @@ check_typedef (type)
 }
 
 /* New code added to support parsing of Cfront stabs strings */
 }
 
 /* New code added to support parsing of Cfront stabs strings */
-#include <ctype.h>
 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
 
 static void
 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
 
 static void
-add_name (pextras, n)
-     struct extra *pextras;
-     char *n;
+add_name (struct extra *pextras, char *n)
 {
   int nlen;
 
 {
   int nlen;
 
@@ -1229,9 +1474,7 @@ add_name (pextras, n)
 }
 
 static void
 }
 
 static void
-add_mangled_type (pextras, t)
-     struct extra *pextras;
-     struct type *t;
+add_mangled_type (struct extra *pextras, struct type *t)
 {
   enum type_code tcode;
   int tlen, tflags;
 {
   enum type_code tcode;
   int tlen, tflags;
@@ -1271,12 +1514,8 @@ add_mangled_type (pextras, t)
          break;
        default:
          {
          break;
        default:
          {
-
-           static struct complaint msg =
-           {"Bad int type code length x%x\n", 0, 0};
-
-           complain (&msg, tlen);
-
+           complaint (&symfile_complaints, "Bad int type code length x%x",
+                      tlen);
          }
        }
       break;
          }
        }
       break;
@@ -1294,9 +1533,8 @@ add_mangled_type (pextras, t)
          break;
        default:
          {
          break;
        default:
          {
-           static struct complaint msg =
-           {"Bad float type code length x%x\n", 0, 0};
-           complain (&msg, tlen);
+           complaint (&symfile_complaints, "Bad float type code length x%x",
+                      tlen);
          }
        }
       break;
          }
        }
       break;
@@ -1310,9 +1548,8 @@ add_mangled_type (pextras, t)
       break;
     case TYPE_CODE_TYPEDEF:
       {
       break;
     case TYPE_CODE_TYPEDEF:
       {
-       static struct complaint msg =
-       {"Typedefs in overloaded functions not yet supported\n", 0, 0};
-       complain (&msg);
+       complaint (&symfile_complaints,
+                  "Typedefs in overloaded functions not yet supported");
       }
       /* followed by type bytes & name */
       break;
       }
       /* followed by type bytes & name */
       break;
@@ -1350,21 +1587,16 @@ add_mangled_type (pextras, t)
     case TYPE_CODE_ERROR:
     default:
       {
     case TYPE_CODE_ERROR:
     default:
       {
-       static struct complaint msg =
-       {"Unknown type code x%x\n", 0, 0};
-       complain (&msg, tcode);
+       complaint (&symfile_complaints, "Unknown type code x%x", tcode);
       }
     }
       }
     }
-  if (t->target_type)
-    add_mangled_type (pextras, t->target_type);
+  if (TYPE_TARGET_TYPE (t))
+    add_mangled_type (pextras, TYPE_TARGET_TYPE (t));
 }
 
 #if 0
 void
 }
 
 #if 0
 void
-cfront_mangle_name (type, i, j)
-     struct type *type;
-     int i;
-     int j;
+cfront_mangle_name (struct type *type, int i, int 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);
@@ -1404,9 +1636,8 @@ cfront_mangle_name (type, i, j)
          }
       ADD_EXTRA ('\0')
        printf ("add_mangled_type: %s\n", extras.str);  /* FIXME */
          }
       ADD_EXTRA ('\0')
        printf ("add_mangled_type: %s\n", extras.str);  /* FIXME */
-      arm_mangled_name = malloc (strlen (mangled_name) + extras.len);
-      sprintf (arm_mangled_name, "%s%s", mangled_name, extras.str);
-      free (mangled_name);
+      xasprintf (&arm_mangled_name, "%s%s", mangled_name, extras.str);
+      xfree (mangled_name);
       mangled_name = arm_mangled_name;
     }
 }
       mangled_name = arm_mangled_name;
     }
 }
@@ -1415,6 +1646,30 @@ cfront_mangle_name (type, i, j)
 #undef ADD_EXTRA
 /* End of new code added to support parsing of Cfront stabs strings */
 
 #undef ADD_EXTRA
 /* End of new code added to support parsing of Cfront stabs strings */
 
+/* Parse a type expression in the string [P..P+LENGTH).  If an error occurs,
+   silently return builtin_type_void. */
+
+struct type *
+safe_parse_type (char *p, int length)
+{
+  struct ui_file *saved_gdb_stderr;
+  struct type *type;
+
+  /* Suppress error messages. */
+  saved_gdb_stderr = gdb_stderr;
+  gdb_stderr = ui_file_new ();
+
+  /* Call parse_and_eval_type() without fear of longjmp()s. */
+  if (!gdb_parse_and_eval_type (p, length, &type))
+    type = builtin_type_void;
+
+  /* Stop suppressing error messages. */
+  ui_file_delete (gdb_stderr);
+  gdb_stderr = saved_gdb_stderr;
+
+  return type;
+}
+
 /* Ugly hack to convert method stubs into method types.
 
    He ain't kiddin'.  This demangles the name of the method into a string
 /* Ugly hack to convert method stubs into method types.
 
    He ain't kiddin'.  This demangles the name of the method into a string
@@ -1425,11 +1680,8 @@ cfront_mangle_name (type, i, j)
    which info used to be in the stab's but was removed to hack back
    the space required for them.  */
 
    which info used to be in the stab's but was removed to hack back
    the space required for them.  */
 
-void
-check_stub_method (type, method_id, signature_id)
-     struct type *type;
-     int method_id;
-     int signature_id;
+static void
+check_stub_method (struct type *type, int method_id, int signature_id)
 {
   struct fn_field *f;
   char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
 {
   struct fn_field *f;
   char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
@@ -1437,12 +1689,14 @@ check_stub_method (type, method_id, signature_id)
                                         DMGL_PARAMS | DMGL_ANSI);
   char *argtypetext, *p;
   int depth = 0, argcount = 1;
                                         DMGL_PARAMS | DMGL_ANSI);
   char *argtypetext, *p;
   int depth = 0, argcount = 1;
-  struct type **argtypes;
+  struct field *argtypes;
   struct type *mtype;
 
   /* Make sure we got back a function string that we can use.  */
   if (demangled_name)
     p = strchr (demangled_name, '(');
   struct type *mtype;
 
   /* Make sure we got back a function string that we can use.  */
   if (demangled_name)
     p = strchr (demangled_name, '(');
+  else
+    p = NULL;
 
   if (demangled_name == NULL || p == NULL)
     error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
 
   if (demangled_name == NULL || p == NULL)
     error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
@@ -1452,11 +1706,11 @@ check_stub_method (type, method_id, signature_id)
   argtypetext = p;
   while (*p)
     {
   argtypetext = p;
   while (*p)
     {
-      if (*p == '(')
+      if (*p == '(' || *p == '<')
        {
          depth += 1;
        }
        {
          depth += 1;
        }
-      else if (*p == ')')
+      else if (*p == ')' || *p == '>')
        {
          depth -= 1;
        }
        {
          depth -= 1;
        }
@@ -1468,15 +1722,25 @@ check_stub_method (type, method_id, signature_id)
       p += 1;
     }
 
       p += 1;
     }
 
-  /* We need two more slots: one for the THIS pointer, and one for the
-     NULL [...] or void [end of arglist].  */
+  /* If we read one argument and it was ``void'', don't count it.  */
+  if (strncmp (argtypetext, "(void)", 6) == 0)
+    argcount -= 1;
+
+  /* We need one extra slot, for the THIS pointer.  */
 
 
-  argtypes = (struct type **)
-    TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));
+  argtypes = (struct field *)
+    TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
   p = argtypetext;
   p = argtypetext;
-  /* FIXME: This is wrong for static member functions.  */
-  argtypes[0] = lookup_pointer_type (type);
-  argcount = 1;
+
+  /* Add THIS pointer for non-static methods.  */
+  f = TYPE_FN_FIELDLIST1 (type, method_id);
+  if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
+    argcount = 0;
+  else
+    {
+      argtypes[0].type = lookup_pointer_type (type);
+      argcount = 1;
+    }
 
   if (*p != ')')               /* () means no args, skip while */
     {
 
   if (*p != ')')               /* () means no args, skip while */
     {
@@ -1485,21 +1749,23 @@ check_stub_method (type, method_id, signature_id)
        {
          if (depth <= 0 && (*p == ',' || *p == ')'))
            {
        {
          if (depth <= 0 && (*p == ',' || *p == ')'))
            {
-             /* Avoid parsing of ellipsis, they will be handled below.  */
-             if (strncmp (argtypetext, "...", p - argtypetext) != 0)
+             /* Avoid parsing of ellipsis, they will be handled below.
+                Also avoid ``void'' as above.  */
+             if (strncmp (argtypetext, "...", p - argtypetext) != 0
+                 && strncmp (argtypetext, "void", p - argtypetext) != 0)
                {
                {
-                 argtypes[argcount] =
-                   parse_and_eval_type (argtypetext, p - argtypetext);
+                 argtypes[argcount].type =
+                   safe_parse_type (argtypetext, p - argtypetext);
                  argcount += 1;
                }
              argtypetext = p + 1;
            }
 
                  argcount += 1;
                }
              argtypetext = p + 1;
            }
 
-         if (*p == '(')
+         if (*p == '(' || *p == '<')
            {
              depth += 1;
            }
            {
              depth += 1;
            }
-         else if (*p == ')')
+         else if (*p == ')' || *p == '>')
            {
              depth -= 1;
            }
            {
              depth -= 1;
            }
@@ -1508,34 +1774,68 @@ check_stub_method (type, method_id, signature_id)
        }
     }
 
        }
     }
 
-  if (p[-2] != '.')            /* Not '...' */
-    {
-      argtypes[argcount] = builtin_type_void;  /* List terminator */
-    }
-  else
-    {
-      argtypes[argcount] = NULL;       /* Ellist terminator */
-    }
-
-  free (demangled_name);
-
-  f = TYPE_FN_FIELDLIST1 (type, method_id);
-
   TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
 
   /* Now update the old "stub" type into a real type.  */
   mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
   TYPE_DOMAIN_TYPE (mtype) = type;
   TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
 
   /* Now update the old "stub" type into a real type.  */
   mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
   TYPE_DOMAIN_TYPE (mtype) = type;
-  TYPE_ARG_TYPES (mtype) = argtypes;
+  TYPE_FIELDS (mtype) = argtypes;
+  TYPE_NFIELDS (mtype) = argcount;
   TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
   TYPE_FN_FIELD_STUB (f, signature_id) = 0;
   TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
   TYPE_FN_FIELD_STUB (f, signature_id) = 0;
+  if (p[-2] == '.')
+    TYPE_FLAGS (mtype) |= TYPE_FLAG_VARARGS;
+
+  xfree (demangled_name);
+}
+
+/* This is the external interface to check_stub_method, above.  This function
+   unstubs all of the signatures for TYPE's METHOD_ID method name.  After
+   calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
+   and TYPE_FN_FIELDLIST_NAME will be correct.
+
+   This function unfortunately can not die until stabs do.  */
+
+void
+check_stub_method_group (struct type *type, int method_id)
+{
+  int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
+  struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
+  int j, found_stub = 0;
+
+  for (j = 0; j < len; j++)
+    if (TYPE_FN_FIELD_STUB (f, j))
+      {
+       found_stub = 1;
+       check_stub_method (type, method_id, j);
+      }
+
+  /* GNU v3 methods with incorrect names were corrected when we read in
+     type information, because it was cheaper to do it then.  The only GNU v2
+     methods with incorrect method names are operators and destructors;
+     destructors were also corrected when we read in type information.
+
+     Therefore the only thing we need to handle here are v2 operator
+     names.  */
+  if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
+    {
+      int ret;
+      char dem_opname[256];
+
+      ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id),
+                                  dem_opname, DMGL_ANSI);
+      if (!ret)
+       ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id),
+                                    dem_opname, 0);
+      if (ret)
+       TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
+    }
 }
 
 const struct cplus_struct_type cplus_struct_default;
 
 void
 }
 
 const struct cplus_struct_type cplus_struct_default;
 
 void
-allocate_cplus_struct_type (type)
-     struct type *type;
+allocate_cplus_struct_type (struct type *type)
 {
   if (!HAVE_CPLUS_STRUCT (type))
     {
 {
   if (!HAVE_CPLUS_STRUCT (type))
     {
@@ -1553,12 +1853,8 @@ allocate_cplus_struct_type (type)
    in particular, where init_type is called with a NULL value for NAME). */
 
 struct type *
    in particular, where init_type is called with a NULL value for NAME). */
 
 struct type *
-init_type (code, length, flags, name, objfile)
-     enum type_code code;
-     int length;
-     int flags;
-     char *name;
-     struct objfile *objfile;
+init_type (enum type_code code, int length, int flags, char *name,
+          struct objfile *objfile)
 {
   register struct type *type;
 
 {
   register struct type *type;
 
@@ -1585,6 +1881,48 @@ init_type (code, length, flags, name, objfile)
   return (type);
 }
 
   return (type);
 }
 
+/* Helper function.  Create an empty composite type.  */
+
+struct type *
+init_composite_type (char *name, enum type_code code)
+{
+  struct type *t;
+  gdb_assert (code == TYPE_CODE_STRUCT
+             || code == TYPE_CODE_UNION);
+  t = init_type (code, 0, 0, NULL, NULL);
+  TYPE_TAG_NAME (t) = name;
+  return t;
+}
+
+/* Helper function.  Append a field to a composite type.  */
+
+void
+append_composite_type_field (struct type *t, char *name, struct type *field)
+{
+  struct field *f;
+  TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
+  TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
+                             sizeof (struct field) * TYPE_NFIELDS (t));
+  f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
+  memset (f, 0, sizeof f[0]);
+  FIELD_TYPE (f[0]) = field;
+  FIELD_NAME (f[0]) = name;
+  if (TYPE_CODE (t) == TYPE_CODE_UNION)
+    {
+      if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
+       TYPE_LENGTH (t) = TYPE_LENGTH (field);
+    }
+  else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
+    {
+      TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
+      if (TYPE_NFIELDS (t) > 1)
+       {
+         FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1])
+                                + TYPE_LENGTH (field) * TARGET_CHAR_BIT);
+       }
+    }
+}
+
 /* Look up a fundamental type for the specified objfile.
    May need to construct such a type if this is the first use.
 
 /* Look up a fundamental type for the specified objfile.
    May need to construct such a type if this is the first use.
 
@@ -1607,9 +1945,7 @@ init_type (code, length, flags, name, objfile)
 
 
 struct type *
 
 
 struct type *
-lookup_fundamental_type (objfile, typeid)
-     struct objfile *objfile;
-     int typeid;
+lookup_fundamental_type (struct objfile *objfile, int typeid)
 {
   register struct type **typep;
   register int nbytes;
 {
   register struct type **typep;
   register int nbytes;
@@ -1644,8 +1980,7 @@ lookup_fundamental_type (objfile, typeid)
 }
 
 int
 }
 
 int
-can_dereference (t)
-     struct type *t;
+can_dereference (struct type *t)
 {
   /* FIXME: Should we return true for references as well as pointers?  */
   CHECK_TYPEDEF (t);
 {
   /* FIXME: Should we return true for references as well as pointers?  */
   CHECK_TYPEDEF (t);
@@ -1656,8 +1991,7 @@ can_dereference (t)
 }
 
 int
 }
 
 int
-is_integral_type (t)
-     struct type *t;
+is_integral_type (struct type *t)
 {
   CHECK_TYPEDEF (t);
   return
 {
   CHECK_TYPEDEF (t);
   return
@@ -1669,22 +2003,23 @@ is_integral_type (t)
         || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
 }
 
         || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
 }
 
-/* Chill varying string and arrays are represented as follows:
+/* (OBSOLETE) Chill (OBSOLETE) varying string and arrays are
+   represented as follows:
 
    struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
 
 
    struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
 
-   Return true if TYPE is such a Chill varying type. */
+   Return true if TYPE is such a (OBSOLETE) Chill (OBSOLETE) varying
+   type. */
 
 
-int
-chill_varying_type (type)
-     struct type *type;
-{
-  if (TYPE_CODE (type) != TYPE_CODE_STRUCT
-      || TYPE_NFIELDS (type) != 2
-      || strcmp (TYPE_FIELD_NAME (type, 0), "__var_length") != 0)
-    return 0;
-  return 1;
-}
+/* OBSOLETE int */
+/* OBSOLETE chill_varying_type (struct type *type) */
+/* OBSOLETE { */
+/* OBSOLETE   if (TYPE_CODE (type) != TYPE_CODE_STRUCT */
+/* OBSOLETE       || TYPE_NFIELDS (type) != 2 */
+/* OBSOLETE       || strcmp (TYPE_FIELD_NAME (type, 0), "__var_length") != 0) */
+/* OBSOLETE     return 0; */
+/* OBSOLETE   return 1; */
+/* OBSOLETE } */
 
 /* Check whether BASE is an ancestor or base class or DCLASS 
    Return 1 if so, and 0 if not.
 
 /* Check whether BASE is an ancestor or base class or DCLASS 
    Return 1 if so, and 0 if not.
@@ -1693,9 +2028,7 @@ chill_varying_type (type)
    the ancestor relationship even if they're identical */
 
 int
    the ancestor relationship even if they're identical */
 
 int
-is_ancestor (base, dclass)
-     struct type *base;
-     struct type *dclass;
+is_ancestor (struct type *base, struct type *dclass)
 {
   int i;
 
 {
   int i;
 
@@ -1704,6 +2037,9 @@ is_ancestor (base, dclass)
 
   if (base == dclass)
     return 1;
 
   if (base == dclass)
     return 1;
+  if (TYPE_NAME (base) && TYPE_NAME (dclass) &&
+      !strcmp (TYPE_NAME (base), TYPE_NAME (dclass)))
+    return 1;
 
   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
     if (is_ancestor (base, TYPE_BASECLASS (dclass, i)))
 
   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
     if (is_ancestor (base, TYPE_BASECLASS (dclass, i)))
@@ -1719,8 +2055,7 @@ is_ancestor (base, dclass)
    runtime models.  Return 1 => Yes, 0 => No.  */
 
 int
    runtime models.  Return 1 => Yes, 0 => No.  */
 
 int
-has_vtable (dclass)
-     struct type *dclass;
+has_vtable (struct type *dclass)
 {
   /* In the HP ANSI C++ runtime model, a class has a vtable only if it
      has virtual functions or virtual bases.  */
 {
   /* In the HP ANSI C++ runtime model, a class has a vtable only if it
      has virtual functions or virtual bases.  */
@@ -1762,8 +2097,7 @@ has_vtable (dclass)
    and may not work with other runtime models.  */
 
 struct type *
    and may not work with other runtime models.  */
 
 struct type *
-primary_base_class (dclass)
-     struct type *dclass;
+primary_base_class (struct type *dclass)
 {
   /* In HP ANSI C++'s runtime model, a "primary base class" of a class
      is the first directly inherited, non-virtual base class that
 {
   /* In HP ANSI C++'s runtime model, a "primary base class" of a class
      is the first directly inherited, non-virtual base class that
@@ -1795,8 +2129,7 @@ static struct vbase *current_vbase_list = NULL;
    copies the items out in reverse order.  */
 
 static void
    copies the items out in reverse order.  */
 
 static void
-virtual_base_list_aux (dclass)
-     struct type *dclass;
+virtual_base_list_aux (struct type *dclass)
 {
   struct vbase *tmp_vbase;
   register int i;
 {
   struct vbase *tmp_vbase;
   register int i;
@@ -1854,8 +2187,7 @@ virtual_base_list_aux (dclass)
    and then copies the result into an array to save space.  */
 
 struct type **
    and then copies the result into an array to save space.  */
 
 struct type **
-virtual_base_list (dclass)
-     struct type *dclass;
+virtual_base_list (struct type *dclass)
 {
   register struct vbase *tmp_vbase;
   register struct vbase *tmp_vbase_2;
 {
   register struct vbase *tmp_vbase;
   register struct vbase *tmp_vbase_2;
@@ -1881,7 +2213,7 @@ virtual_base_list (dclass)
   while (tmp_vbase)
     {
       tmp_vbase = tmp_vbase->next;
   while (tmp_vbase)
     {
       tmp_vbase = tmp_vbase->next;
-      free (tmp_vbase_2);
+      xfree (tmp_vbase_2);
       tmp_vbase_2 = tmp_vbase;
     }
 
       tmp_vbase_2 = tmp_vbase;
     }
 
@@ -1892,8 +2224,7 @@ virtual_base_list (dclass)
 /* Return the length of the virtual base list of the type DCLASS.  */
 
 int
 /* Return the length of the virtual base list of the type DCLASS.  */
 
 int
-virtual_base_list_length (dclass)
-     struct type *dclass;
+virtual_base_list_length (struct type *dclass)
 {
   register int i;
   register struct vbase *tmp_vbase;
 {
   register int i;
   register struct vbase *tmp_vbase;
@@ -1911,8 +2242,7 @@ virtual_base_list_length (dclass)
    primary base, recursively).  */
 
 int
    primary base, recursively).  */
 
 int
-virtual_base_list_length_skip_primaries (dclass)
-     struct type *dclass;
+virtual_base_list_length_skip_primaries (struct type *dclass)
 {
   register int i;
   register struct vbase *tmp_vbase;
 {
   register int i;
   register struct vbase *tmp_vbase;
@@ -1941,9 +2271,7 @@ virtual_base_list_length_skip_primaries (dclass)
    indicates "not found" or a problem.  */
 
 int
    indicates "not found" or a problem.  */
 
 int
-virtual_base_index (base, dclass)
-     struct type *base;
-     struct type *dclass;
+virtual_base_index (struct type *base, struct type *dclass)
 {
   register struct type *vbase;
   register int i;
 {
   register struct type *vbase;
   register int i;
@@ -1953,12 +2281,12 @@ virtual_base_index (base, dclass)
     return -1;
 
   i = 0;
     return -1;
 
   i = 0;
-  vbase = TYPE_VIRTUAL_BASE_LIST (dclass)[0];
+  vbase = virtual_base_list (dclass)[0];
   while (vbase)
     {
       if (vbase == base)
        break;
   while (vbase)
     {
       if (vbase == base)
        break;
-      vbase = TYPE_VIRTUAL_BASE_LIST (dclass)[++i];
+      vbase = virtual_base_list (dclass)[++i];
     }
 
   return vbase ? i : -1;
     }
 
   return vbase ? i : -1;
@@ -1973,9 +2301,7 @@ virtual_base_index (base, dclass)
    found" or a problem.  */
 
 int
    found" or a problem.  */
 
 int
-virtual_base_index_skip_primaries (base, dclass)
-     struct type *base;
-     struct type *dclass;
+virtual_base_index_skip_primaries (struct type *base, struct type *dclass)
 {
   register struct type *vbase;
   register int i, j;
 {
   register struct type *vbase;
   register int i, j;
@@ -1989,14 +2315,14 @@ virtual_base_index_skip_primaries (base, dclass)
 
   j = -1;
   i = 0;
 
   j = -1;
   i = 0;
-  vbase = TYPE_VIRTUAL_BASE_LIST (dclass)[0];
+  vbase = virtual_base_list (dclass)[0];
   while (vbase)
     {
       if (!primary || (virtual_base_index_skip_primaries (vbase, primary) < 0))
        j++;
       if (vbase == base)
        break;
   while (vbase)
     {
       if (!primary || (virtual_base_index_skip_primaries (vbase, primary) < 0))
        j++;
       if (vbase == base)
        break;
-      vbase = TYPE_VIRTUAL_BASE_LIST (dclass)[++i];
+      vbase = virtual_base_list (dclass)[++i];
     }
 
   return vbase ? j : -1;
     }
 
   return vbase ? j : -1;
@@ -2007,8 +2333,7 @@ virtual_base_index_skip_primaries (base, dclass)
  * Position returned is 0-based. */
 
 int
  * Position returned is 0-based. */
 
 int
-class_index_in_primary_list (dclass)
-     struct type *dclass;
+class_index_in_primary_list (struct type *dclass)
 {
   struct type *pbc;            /* primary base class */
 
 {
   struct type *pbc;            /* primary base class */
 
@@ -2030,8 +2355,7 @@ class_index_in_primary_list (dclass)
  */
 
 int
  */
 
 int
-count_virtual_fns (dclass)
-     struct type *dclass;
+count_virtual_fns (struct type *dclass)
 {
   int fn, oi;                  /* function and overloaded instance indices */
   int vfuncs;                  /* count to return */
 {
   int fn, oi;                  /* function and overloaded instance indices */
   int vfuncs;                  /* count to return */
@@ -2040,6 +2364,8 @@ count_virtual_fns (dclass)
   struct type *pbc = primary_base_class (dclass);
   if (pbc)
     vfuncs = count_virtual_fns (pbc);
   struct type *pbc = primary_base_class (dclass);
   if (pbc)
     vfuncs = count_virtual_fns (pbc);
+  else
+    vfuncs = 0;
 
   for (fn = 0; fn < TYPE_NFN_FIELDS (dclass); fn++)
     for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (dclass, fn); oi++)
 
   for (fn = 0; fn < TYPE_NFN_FIELDS (dclass); fn++)
     for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (dclass, fn); oi++)
@@ -2060,9 +2386,7 @@ count_virtual_fns (dclass)
  * 3 => A is worse than B */
 
 int
  * 3 => A is worse than B */
 
 int
-compare_badness (a, b)
-     struct badness_vector *a;
-     struct badness_vector *b;
+compare_badness (struct badness_vector *a, struct badness_vector *b)
 {
   int i;
   int tmp;
 {
   int i;
   int tmp;
@@ -2105,11 +2429,7 @@ compare_badness (a, b)
  * Return a pointer to a badness vector. This has NARGS + 1 entries. */
 
 struct badness_vector *
  * Return a pointer to a badness vector. This has NARGS + 1 entries. */
 
 struct badness_vector *
-rank_function (parms, nparms, args, nargs)
-     struct type **parms;
-     int nparms;
-     struct type **args;
-     int nargs;
+rank_function (struct type **parms, int nparms, struct type **args, int nargs)
 {
   int i;
   struct badness_vector *bv;
 {
   int i;
   struct badness_vector *bv;
@@ -2130,7 +2450,7 @@ rank_function (parms, nparms, args, nargs)
 
   /* Now rank all the parameters of the candidate function */
   for (i = 1; i <= min_len; i++)
 
   /* Now rank all the parameters of the candidate function */
   for (i = 1; i <= min_len; i++)
-    bv->rank[i] = rank_one_type (parms[i - 1], args[i - 1]);
+    bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);
 
   /* If more arguments than parameters, add dummy entries */
   for (i = min_len + 1; i <= nargs; i++)
 
   /* If more arguments than parameters, add dummy entries */
   for (i = min_len + 1; i <= nargs; i++)
@@ -2150,9 +2470,7 @@ rank_function (parms, nparms, args, nargs)
  * Generally the "bad" conversions are all uniformly assigned a 100 */
 
 int
  * Generally the "bad" conversions are all uniformly assigned a 100 */
 
 int
-rank_one_type (parm, arg)
-     struct type *parm;
-     struct type *arg;
+rank_one_type (struct type *parm, struct type *arg)
 {
   /* Identical type pointers */
   /* However, this still doesn't catch all cases of same type for arg
 {
   /* Identical type pointers */
   /* However, this still doesn't catch all cases of same type for arg
@@ -2167,15 +2485,33 @@ rank_one_type (parm, arg)
   if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
     arg = check_typedef (arg);
 
   if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
     arg = check_typedef (arg);
 
+  /*
+     Well, damnit, if the names are exactly the same,
+     i'll say they are exactly the same. This happens when we generate
+     method stubs. The types won't point to the same address, but they
+     really are the same.
+  */
+
+  if (TYPE_NAME (parm) && TYPE_NAME (arg) &&
+      !strcmp (TYPE_NAME (parm), TYPE_NAME (arg)))
+      return 0;
+
   /* Check if identical after resolving typedefs */
   if (parm == arg)
     return 0;
 
   /* Check if identical after resolving typedefs */
   if (parm == arg)
     return 0;
 
-#if 0
-  /* Debugging only */
-  printf ("------ Arg is %s [%d], parm is %s [%d]\n",
-      TYPE_NAME (arg), TYPE_CODE (arg), TYPE_NAME (parm), TYPE_CODE (parm));
-#endif
+  /* See through references, since we can almost make non-references
+     references. */
+  if (TYPE_CODE (arg) == TYPE_CODE_REF)
+    return (rank_one_type (parm, TYPE_TARGET_TYPE (arg))
+           + REFERENCE_CONVERSION_BADNESS);
+  if (TYPE_CODE (parm) == TYPE_CODE_REF)
+    return (rank_one_type (TYPE_TARGET_TYPE (parm), arg)
+           + REFERENCE_CONVERSION_BADNESS);
+  if (overload_debug)
+  /* Debugging only. */
+    fprintf_filtered (gdb_stderr,"------ Arg is %s [%d], parm is %s [%d]\n",
+        TYPE_NAME (arg), TYPE_CODE (arg), TYPE_NAME (parm), TYPE_CODE (parm));
 
   /* x -> y means arg of type x being supplied for parameter of type y */
 
 
   /* x -> y means arg of type x being supplied for parameter of type y */
 
@@ -2239,16 +2575,16 @@ rank_one_type (parm, arg)
                {
                  if (TYPE_UNSIGNED (arg))
                    {
                {
                  if (TYPE_UNSIGNED (arg))
                    {
-                     if (!strcmp (TYPE_NAME (parm), TYPE_NAME (arg)))
+                     if (!strcmp_iw (TYPE_NAME (parm), TYPE_NAME (arg)))
                        return 0;       /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
                        return 0;       /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
-                     else if (!strcmp (TYPE_NAME (arg), "int") && !strcmp (TYPE_NAME (parm), "long"))
+                     else if (!strcmp_iw (TYPE_NAME (arg), "int") && !strcmp_iw (TYPE_NAME (parm), "long"))
                        return INTEGER_PROMOTION_BADNESS;       /* unsigned int -> unsigned long */
                      else
                        return INTEGER_COERCION_BADNESS;        /* unsigned long -> unsigned int */
                    }
                  else
                    {
                        return INTEGER_PROMOTION_BADNESS;       /* unsigned int -> unsigned long */
                      else
                        return INTEGER_COERCION_BADNESS;        /* unsigned long -> unsigned int */
                    }
                  else
                    {
-                     if (!strcmp (TYPE_NAME (arg), "long") && !strcmp (TYPE_NAME (parm), "int"))
+                     if (!strcmp_iw (TYPE_NAME (arg), "long") && !strcmp_iw (TYPE_NAME (parm), "int"))
                        return INTEGER_COERCION_BADNESS;        /* signed long -> unsigned int */
                      else
                        return INTEGER_CONVERSION_BADNESS;      /* signed int/long -> unsigned int/long */
                        return INTEGER_COERCION_BADNESS;        /* signed long -> unsigned int */
                      else
                        return INTEGER_CONVERSION_BADNESS;      /* signed int/long -> unsigned int/long */
@@ -2256,9 +2592,9 @@ rank_one_type (parm, arg)
                }
              else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
                {
                }
              else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
                {
-                 if (!strcmp (TYPE_NAME (parm), TYPE_NAME (arg)))
+                 if (!strcmp_iw (TYPE_NAME (parm), TYPE_NAME (arg)))
                    return 0;
                    return 0;
-                 else if (!strcmp (TYPE_NAME (arg), "int") && !strcmp (TYPE_NAME (parm), "long"))
+                 else if (!strcmp_iw (TYPE_NAME (arg), "int") && !strcmp_iw (TYPE_NAME (parm), "long"))
                    return INTEGER_PROMOTION_BADNESS;
                  else
                    return INTEGER_COERCION_BADNESS;
                    return INTEGER_PROMOTION_BADNESS;
                  else
                    return INTEGER_COERCION_BADNESS;
@@ -2465,9 +2801,7 @@ rank_one_type (parm, arg)
 /* End of functions for overload resolution */
 
 static void
 /* End of functions for overload resolution */
 
 static void
-print_bit_vector (bits, nbits)
-     B_TYPE *bits;
-     int nbits;
+print_bit_vector (B_TYPE *bits, int nbits)
 {
   int bitno;
 
 {
   int bitno;
 
@@ -2488,34 +2822,23 @@ print_bit_vector (bits, nbits)
     }
 }
 
     }
 }
 
-/* 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. */
+/* 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
 
 static void
-print_arg_types (args, spaces)
-     struct type **args;
-     int spaces;
+print_arg_types (struct field *args, int nargs, int spaces)
 {
   if (args != NULL)
     {
 {
   if (args != NULL)
     {
-      while (*args != NULL)
-       {
-         recursive_dump_type (*args, spaces + 2);
-         if ((*args++)->code == TYPE_CODE_VOID)
-           {
-             break;
-           }
-       }
+      int i;
+
+      for (i = 0; i < nargs; i++)
+       recursive_dump_type (args[i].type, spaces + 2);
     }
 }
 
 static void
     }
 }
 
 static void
-dump_fn_fieldlists (type, spaces)
-     struct type *type;
-     int spaces;
+dump_fn_fieldlists (struct type *type, int spaces)
 {
   int method_idx;
   int overload_idx;
 {
   int method_idx;
   int overload_idx;
@@ -2555,7 +2878,9 @@ dump_fn_fieldlists (type, spaces)
          gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout);
          printf_filtered ("\n");
 
          gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout);
          printf_filtered ("\n");
 
-         print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
+         print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
+                          TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx)),
+                          spaces);
          printfi_filtered (spaces + 8, "fcontext ");
          gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
                                  gdb_stdout);
          printfi_filtered (spaces + 8, "fcontext ");
          gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
                                  gdb_stdout);
@@ -2578,9 +2903,7 @@ dump_fn_fieldlists (type, spaces)
 }
 
 static void
 }
 
 static void
-print_cplus_stuff (type, spaces)
-     struct type *type;
-     int spaces;
+print_cplus_stuff (struct type *type, int spaces)
 {
   printfi_filtered (spaces, "n_baseclasses %d\n",
                    TYPE_N_BASECLASSES (type));
 {
   printfi_filtered (spaces, "n_baseclasses %d\n",
                    TYPE_N_BASECLASSES (type));
@@ -2628,12 +2951,39 @@ print_cplus_stuff (type, spaces)
     }
 }
 
     }
 }
 
+static void
+print_bound_type (int bt)
+{
+  switch (bt)
+    {
+    case BOUND_CANNOT_BE_DETERMINED:
+      printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
+      break;
+    case BOUND_BY_REF_ON_STACK:
+      printf_filtered ("(BOUND_BY_REF_ON_STACK)");
+      break;
+    case BOUND_BY_VALUE_ON_STACK:
+      printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
+      break;
+    case BOUND_BY_REF_IN_REG:
+      printf_filtered ("(BOUND_BY_REF_IN_REG)");
+      break;
+    case BOUND_BY_VALUE_IN_REG:
+      printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
+      break;
+    case BOUND_SIMPLE:
+      printf_filtered ("(BOUND_SIMPLE)");
+      break;
+    default:
+      printf_filtered ("(unknown bound type)");
+      break;
+    }
+}
+
 static struct obstack dont_print_type_obstack;
 
 void
 static struct obstack dont_print_type_obstack;
 
 void
-recursive_dump_type (type, spaces)
-     struct type *type;
-     int spaces;
+recursive_dump_type (struct type *type, int spaces)
 {
   int idx;
 
 {
   int idx;
 
@@ -2670,13 +3020,10 @@ recursive_dump_type (type, spaces)
                    TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
   gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
   printf_filtered (")\n");
                    TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
   gdb_print_host_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_host_address (TYPE_TAG_NAME (type), gdb_stdout);
-      printf_filtered (")\n");
-    }
+  printfi_filtered (spaces, "tagname '%s' (",
+                   TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
+  gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
+  printf_filtered (")\n");
   printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
   switch (TYPE_CODE (type))
     {
   printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
   switch (TYPE_CODE (type))
     {
@@ -2719,6 +3066,9 @@ recursive_dump_type (type, spaces)
     case TYPE_CODE_STRING:
       printf_filtered ("(TYPE_CODE_STRING)");
       break;
     case TYPE_CODE_STRING:
       printf_filtered ("(TYPE_CODE_STRING)");
       break;
+    case TYPE_CODE_BITSTRING:
+      printf_filtered ("(TYPE_CODE_BITSTRING)");
+      break;
     case TYPE_CODE_ERROR:
       printf_filtered ("(TYPE_CODE_ERROR)");
       break;
     case TYPE_CODE_ERROR:
       printf_filtered ("(TYPE_CODE_ERROR)");
       break;
@@ -2737,15 +3087,32 @@ recursive_dump_type (type, spaces)
     case TYPE_CODE_BOOL:
       printf_filtered ("(TYPE_CODE_BOOL)");
       break;
     case TYPE_CODE_BOOL:
       printf_filtered ("(TYPE_CODE_BOOL)");
       break;
+    case TYPE_CODE_COMPLEX:
+      printf_filtered ("(TYPE_CODE_COMPLEX)");
+      break;
     case TYPE_CODE_TYPEDEF:
       printf_filtered ("(TYPE_CODE_TYPEDEF)");
       break;
     case TYPE_CODE_TYPEDEF:
       printf_filtered ("(TYPE_CODE_TYPEDEF)");
       break;
+    case TYPE_CODE_TEMPLATE:
+      printf_filtered ("(TYPE_CODE_TEMPLATE)");
+      break;
+    case TYPE_CODE_TEMPLATE_ARG:
+      printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
+      break;
     default:
       printf_filtered ("(UNKNOWN TYPE CODE)");
       break;
     }
   puts_filtered ("\n");
   printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
     default:
       printf_filtered ("(UNKNOWN TYPE CODE)");
       break;
     }
   puts_filtered ("\n");
   printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
+  printfi_filtered (spaces, "upper_bound_type 0x%x ",
+                   TYPE_ARRAY_UPPER_BOUND_TYPE (type));
+  print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type));
+  puts_filtered ("\n");
+  printfi_filtered (spaces, "lower_bound_type 0x%x ",
+                   TYPE_ARRAY_LOWER_BOUND_TYPE (type));
+  print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type));
+  puts_filtered ("\n");
   printfi_filtered (spaces, "objfile ");
   gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout);
   printf_filtered ("\n");
   printfi_filtered (spaces, "objfile ");
   gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout);
   printf_filtered ("\n");
@@ -2762,15 +3129,75 @@ recursive_dump_type (type, spaces)
   printfi_filtered (spaces, "reference_type ");
   gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
   printf_filtered ("\n");
   printfi_filtered (spaces, "reference_type ");
   gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
   printf_filtered ("\n");
+  printfi_filtered (spaces, "type_chain ");
+  gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
+  printf_filtered ("\n");
+  printfi_filtered (spaces, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type));
+  if (TYPE_CONST (type))
+    {
+      puts_filtered (" TYPE_FLAG_CONST");
+    }
+  if (TYPE_VOLATILE (type))
+    {
+      puts_filtered (" TYPE_FLAG_VOLATILE");
+    }
+  if (TYPE_CODE_SPACE (type))
+    {
+      puts_filtered (" TYPE_FLAG_CODE_SPACE");
+    }
+  if (TYPE_DATA_SPACE (type))
+    {
+      puts_filtered (" TYPE_FLAG_DATA_SPACE");
+    }
+  if (TYPE_ADDRESS_CLASS_1 (type))
+    {
+      puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
+    }
+  if (TYPE_ADDRESS_CLASS_2 (type))
+    {
+      puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
+    }
+  puts_filtered ("\n");
   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
-  if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
+  if (TYPE_UNSIGNED (type))
     {
       puts_filtered (" TYPE_FLAG_UNSIGNED");
     }
     {
       puts_filtered (" TYPE_FLAG_UNSIGNED");
     }
-  if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
+  if (TYPE_NOSIGN (type))
+    {
+      puts_filtered (" TYPE_FLAG_NOSIGN");
+    }
+  if (TYPE_STUB (type))
     {
       puts_filtered (" TYPE_FLAG_STUB");
     }
     {
       puts_filtered (" TYPE_FLAG_STUB");
     }
+  if (TYPE_TARGET_STUB (type))
+    {
+      puts_filtered (" TYPE_FLAG_TARGET_STUB");
+    }
+  if (TYPE_STATIC (type))
+    {
+      puts_filtered (" TYPE_FLAG_STATIC");
+    }
+  if (TYPE_PROTOTYPED (type))
+    {
+      puts_filtered (" TYPE_FLAG_PROTOTYPED");
+    }
+  if (TYPE_INCOMPLETE (type))
+    {
+      puts_filtered (" TYPE_FLAG_INCOMPLETE");
+    }
+  if (TYPE_VARARGS (type))
+    {
+      puts_filtered (" TYPE_FLAG_VARARGS");
+    }
+  /* This is used for things like AltiVec registers on ppc.  Gcc emits
+     an attribute for the array type, which tells whether or not we
+     have a vector, instead of a regular array.  */
+  if (TYPE_VECTOR (type))
+    {
+      puts_filtered (" TYPE_FLAG_VECTOR");
+    }
   puts_filtered ("\n");
   printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
   gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
   puts_filtered ("\n");
   printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
   gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
@@ -2803,14 +3230,6 @@ recursive_dump_type (type, spaces)
   printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
   switch (TYPE_CODE (type))
     {
   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_host_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_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
     case TYPE_CODE_STRUCT:
       printfi_filtered (spaces, "cplus_stuff ");
       gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
@@ -2818,6 +3237,16 @@ recursive_dump_type (type, spaces)
       print_cplus_stuff (type, spaces);
       break;
 
       print_cplus_stuff (type, spaces);
       break;
 
+    case TYPE_CODE_FLT:
+      printfi_filtered (spaces, "floatformat ");
+      if (TYPE_FLOATFORMAT (type) == NULL
+         || TYPE_FLOATFORMAT (type)->name == NULL)
+       puts_filtered ("(null)");
+      else
+       puts_filtered (TYPE_FLOATFORMAT (type)->name);
+      puts_filtered ("\n");
+      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
     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
@@ -2836,9 +3265,9 @@ recursive_dump_type (type, spaces)
     obstack_free (&dont_print_type_obstack, NULL);
 }
 
     obstack_free (&dont_print_type_obstack, NULL);
 }
 
-static void build_gdbtypes PARAMS ((void));
+static void build_gdbtypes (void);
 static void
 static void
-build_gdbtypes ()
+build_gdbtypes (void)
 {
   builtin_type_void =
     init_type (TYPE_CODE_VOID, 1,
 {
   builtin_type_void =
     init_type (TYPE_CODE_VOID, 1,
@@ -2846,9 +3275,9 @@ build_gdbtypes ()
               "void", (struct objfile *) NULL);
   builtin_type_char =
     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
               "void", (struct objfile *) NULL);
   builtin_type_char =
     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-              0,
+              (TYPE_FLAG_NOSIGN
+                | (TARGET_CHAR_SIGNED ? 0 : TYPE_FLAG_UNSIGNED)),
               "char", (struct objfile *) NULL);
               "char", (struct objfile *) NULL);
-  TYPE_FLAGS (builtin_type_char) |= TYPE_FLAG_NOSIGN;
   builtin_type_true_char =
     init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
               0,
   builtin_type_true_char =
     init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
               0,
@@ -2897,14 +3326,31 @@ build_gdbtypes ()
     init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
               0,
               "float", (struct objfile *) NULL);
     init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
               0,
               "float", (struct objfile *) NULL);
+/* vinschen@redhat.com 2002-02-08:
+   The below lines are disabled since they are doing the wrong
+   thing for non-multiarch targets.  They are setting the correct
+   type of floats for the target but while on multiarch targets
+   this is done everytime the architecture changes, it's done on
+   non-multiarch targets only on startup, leaving the wrong values
+   in even if the architecture changes (eg. from big-endian to
+   little-endian).  */
+#if 0
+  TYPE_FLOATFORMAT (builtin_type_float) = TARGET_FLOAT_FORMAT;
+#endif
   builtin_type_double =
     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
               0,
               "double", (struct objfile *) NULL);
   builtin_type_double =
     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
               0,
               "double", (struct objfile *) NULL);
+#if 0
+  TYPE_FLOATFORMAT (builtin_type_double) = TARGET_DOUBLE_FORMAT;
+#endif
   builtin_type_long_double =
     init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
               0,
               "long 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);
+#if 0
+  TYPE_FLOATFORMAT (builtin_type_long_double) = TARGET_LONG_DOUBLE_FORMAT;
+#endif
   builtin_type_complex =
     init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
               0,
   builtin_type_complex =
     init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
               0,
@@ -2951,6 +3397,14 @@ build_gdbtypes ()
     init_type (TYPE_CODE_INT, 64 / 8,
               TYPE_FLAG_UNSIGNED,
               "uint64_t", (struct objfile *) NULL);
     init_type (TYPE_CODE_INT, 64 / 8,
               TYPE_FLAG_UNSIGNED,
               "uint64_t", (struct objfile *) NULL);
+  builtin_type_int128 =
+    init_type (TYPE_CODE_INT, 128 / 8,
+              0,
+              "int128_t", (struct objfile *) NULL);
+  builtin_type_uint128 =
+    init_type (TYPE_CODE_INT, 128 / 8,
+              TYPE_FLAG_UNSIGNED,
+              "uint128_t", (struct objfile *) NULL);
   builtin_type_bool =
     init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
               0,
   builtin_type_bool =
     init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
               0,
@@ -2964,17 +3418,87 @@ build_gdbtypes ()
      &showlist);
   opaque_type_resolution = 1;
 
      &showlist);
   opaque_type_resolution = 1;
 
-
   /* Build SIMD types.  */
   builtin_type_v4sf
     = init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4);
   /* Build SIMD types.  */
   builtin_type_v4sf
     = init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4);
+  builtin_type_v4si
+    = init_simd_type ("__builtin_v4si", builtin_type_int32, "f", 4);
+  builtin_type_v16qi
+    = init_simd_type ("__builtin_v16qi", builtin_type_int8, "f", 16);
+  builtin_type_v8qi
+    = init_simd_type ("__builtin_v8qi", builtin_type_int8, "f", 8);
+  builtin_type_v8hi
+    = init_simd_type ("__builtin_v8hi", builtin_type_int16, "f", 8);
+  builtin_type_v4hi
+    = init_simd_type ("__builtin_v4hi", builtin_type_int16, "f", 4);
+  builtin_type_v2si
+    = init_simd_type ("__builtin_v2si", builtin_type_int32, "f", 2);
+
+  /* 128 bit vectors.  */
+  builtin_type_v2_double = init_vector_type (builtin_type_double, 2);
+  builtin_type_v4_float = init_vector_type (builtin_type_float, 4);
+  builtin_type_v2_int64 = init_vector_type (builtin_type_int64, 2);
+  builtin_type_v4_int32 = init_vector_type (builtin_type_int32, 4);
+  builtin_type_v8_int16 = init_vector_type (builtin_type_int16, 8);
+  builtin_type_v16_int8 = init_vector_type (builtin_type_int8, 16);
+  /* 64 bit vectors.  */
+  builtin_type_v2_float = init_vector_type (builtin_type_float, 2);
+  builtin_type_v2_int32 = init_vector_type (builtin_type_int32, 2);
+  builtin_type_v4_int16 = init_vector_type (builtin_type_int16, 4);
+  builtin_type_v8_int8 = init_vector_type (builtin_type_int8, 8);
+
+  /* Vector types.  */
+  builtin_type_vec64 = build_builtin_type_vec64 ();
+  builtin_type_vec64i = build_builtin_type_vec64i ();
+  builtin_type_vec128 = build_builtin_type_vec128 ();
+  builtin_type_vec128i = build_builtin_type_vec128i ();
+
+  /* Pointer/Address types. */
+
+  /* NOTE: on some targets, addresses and pointers are not necessarily
+     the same --- for example, on the D10V, pointers are 16 bits long,
+     but addresses are 32 bits long.  See doc/gdbint.texinfo,
+     ``Pointers Are Not Always Addresses''.
+
+     The upshot is:
+     - gdb's `struct type' always describes the target's
+       representation.
+     - gdb's `struct value' objects should always hold values in
+       target form.
+     - gdb's CORE_ADDR values are addresses in the unified virtual
+       address space that the assembler and linker work with.  Thus,
+       since target_read_memory takes a CORE_ADDR as an argument, it
+       can access any memory on the target, even if the processor has
+       separate code and data address spaces.
+
+     So, for example:
+     - If v is a value holding a D10V code pointer, its contents are
+       in target form: a big-endian address left-shifted two bits.
+     - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
+       sizeof (void *) == 2 on the target.
+
+     In this context, builtin_type_CORE_ADDR is a bit odd: it's a
+     target type for a value the target will never see.  It's only
+     used to hold the values of (typeless) linker symbols, which are
+     indeed in the unified virtual address space.  */
+  builtin_type_void_data_ptr = make_pointer_type (builtin_type_void, NULL);
+  builtin_type_void_func_ptr
+    = lookup_pointer_type (lookup_function_type (builtin_type_void));
+  builtin_type_CORE_ADDR =
+    init_type (TYPE_CODE_INT, TARGET_ADDR_BIT / 8,
+              TYPE_FLAG_UNSIGNED,
+              "__CORE_ADDR", (struct objfile *) NULL);
+  builtin_type_bfd_vma =
+    init_type (TYPE_CODE_INT, TARGET_BFD_VMA_BIT / 8,
+              TYPE_FLAG_UNSIGNED,
+              "__bfd_vma", (struct objfile *) NULL);
 }
 
 }
 
-
-extern void _initialize_gdbtypes PARAMS ((void));
+extern void _initialize_gdbtypes (void);
 void
 void
-_initialize_gdbtypes ()
+_initialize_gdbtypes (void)
 {
 {
+  struct cmd_list_element *c;
   build_gdbtypes ();
 
   /* FIXME - For the moment, handle types by swapping them in and out.
   build_gdbtypes ();
 
   /* FIXME - For the moment, handle types by swapping them in and out.
@@ -3006,6 +3530,104 @@ _initialize_gdbtypes ()
   register_gdbarch_swap (&builtin_type_uint32, sizeof (struct type *), NULL);
   register_gdbarch_swap (&builtin_type_int64, sizeof (struct type *), NULL);
   register_gdbarch_swap (&builtin_type_uint64, sizeof (struct type *), NULL);
   register_gdbarch_swap (&builtin_type_uint32, sizeof (struct type *), NULL);
   register_gdbarch_swap (&builtin_type_int64, sizeof (struct type *), NULL);
   register_gdbarch_swap (&builtin_type_uint64, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_int128, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_uint128, sizeof (struct type *), NULL);
   register_gdbarch_swap (&builtin_type_v4sf, sizeof (struct type *), NULL);
   register_gdbarch_swap (&builtin_type_v4sf, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v4si, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v16qi, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v8qi, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v8hi, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v4hi, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v2si, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v2_double, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v4_float, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v2_int64, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v4_int32, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v8_int16, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v16_int8, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v2_float, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v2_int32, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v8_int8, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_v4_int16, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_vec128, sizeof (struct type *), NULL);
+  register_gdbarch_swap (&builtin_type_vec128i, sizeof (struct type *), NULL);
+  REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr);
+  REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr);
+  REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR);
+  REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma);
   register_gdbarch_swap (NULL, 0, build_gdbtypes);
   register_gdbarch_swap (NULL, 0, build_gdbtypes);
+
+  /* Note: These types do not need to be swapped - they are target
+     neutral.  */
+  builtin_type_ieee_single_big =
+    init_type (TYPE_CODE_FLT, floatformat_ieee_single_big.totalsize / 8,
+              0, "builtin_type_ieee_single_big", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ieee_single_big) = &floatformat_ieee_single_big;
+  builtin_type_ieee_single_little =
+    init_type (TYPE_CODE_FLT, floatformat_ieee_single_little.totalsize / 8,
+              0, "builtin_type_ieee_single_little", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ieee_single_little) = &floatformat_ieee_single_little;
+  builtin_type_ieee_double_big =
+    init_type (TYPE_CODE_FLT, floatformat_ieee_double_big.totalsize / 8,
+              0, "builtin_type_ieee_double_big", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ieee_double_big) = &floatformat_ieee_double_big;
+  builtin_type_ieee_double_little =
+    init_type (TYPE_CODE_FLT, floatformat_ieee_double_little.totalsize / 8,
+              0, "builtin_type_ieee_double_little", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ieee_double_little) = &floatformat_ieee_double_little;
+  builtin_type_ieee_double_littlebyte_bigword =
+    init_type (TYPE_CODE_FLT, floatformat_ieee_double_littlebyte_bigword.totalsize / 8,
+              0, "builtin_type_ieee_double_littlebyte_bigword", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword) = &floatformat_ieee_double_littlebyte_bigword;
+  builtin_type_i387_ext =
+    init_type (TYPE_CODE_FLT, floatformat_i387_ext.totalsize / 8,
+              0, "builtin_type_i387_ext", NULL);
+  TYPE_FLOATFORMAT (builtin_type_i387_ext) = &floatformat_i387_ext;
+  builtin_type_m68881_ext =
+    init_type (TYPE_CODE_FLT, floatformat_m68881_ext.totalsize / 8,
+              0, "builtin_type_m68881_ext", NULL);
+  TYPE_FLOATFORMAT (builtin_type_m68881_ext) = &floatformat_m68881_ext;
+  builtin_type_i960_ext =
+    init_type (TYPE_CODE_FLT, floatformat_i960_ext.totalsize / 8,
+              0, "builtin_type_i960_ext", NULL);
+  TYPE_FLOATFORMAT (builtin_type_i960_ext) = &floatformat_i960_ext;
+  builtin_type_m88110_ext =
+    init_type (TYPE_CODE_FLT, floatformat_m88110_ext.totalsize / 8,
+              0, "builtin_type_m88110_ext", NULL);
+  TYPE_FLOATFORMAT (builtin_type_m88110_ext) = &floatformat_m88110_ext;
+  builtin_type_m88110_harris_ext =
+    init_type (TYPE_CODE_FLT, floatformat_m88110_harris_ext.totalsize / 8,
+              0, "builtin_type_m88110_harris_ext", NULL);
+  TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext) = &floatformat_m88110_harris_ext;
+  builtin_type_arm_ext_big =
+    init_type (TYPE_CODE_FLT, floatformat_arm_ext_big.totalsize / 8,
+              0, "builtin_type_arm_ext_big", NULL);
+  TYPE_FLOATFORMAT (builtin_type_arm_ext_big) = &floatformat_arm_ext_big;
+  builtin_type_arm_ext_littlebyte_bigword =
+    init_type (TYPE_CODE_FLT, floatformat_arm_ext_littlebyte_bigword.totalsize / 8,
+              0, "builtin_type_arm_ext_littlebyte_bigword", NULL);
+  TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword) = &floatformat_arm_ext_littlebyte_bigword;
+  builtin_type_ia64_spill_big =
+    init_type (TYPE_CODE_FLT, floatformat_ia64_spill_big.totalsize / 8,
+              0, "builtin_type_ia64_spill_big", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ia64_spill_big) = &floatformat_ia64_spill_big;
+  builtin_type_ia64_spill_little =
+    init_type (TYPE_CODE_FLT, floatformat_ia64_spill_little.totalsize / 8,
+              0, "builtin_type_ia64_spill_little", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ia64_spill_little) = &floatformat_ia64_spill_little;
+  builtin_type_ia64_quad_big =
+    init_type (TYPE_CODE_FLT, floatformat_ia64_quad_big.totalsize / 8,
+              0, "builtin_type_ia64_quad_big", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ia64_quad_big) = &floatformat_ia64_quad_big;
+  builtin_type_ia64_quad_little =
+    init_type (TYPE_CODE_FLT, floatformat_ia64_quad_little.totalsize / 8,
+              0, "builtin_type_ia64_quad_little", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ia64_quad_little) = &floatformat_ia64_quad_little;
+
+  add_show_from_set (
+                    add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug,
+                                 "Set debugging of C++ overloading.\n\
+                         When enabled, ranking of the functions\n\
+                         is displayed.", &setdebuglist),
+                    &showdebuglist);
 }
 }
GDB Binutils - Deliverables
This page took 0.051484 seconds and 4 git commands to generate.