*** empty log message ***

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

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 63bd448293d848a161538da40a4871a5e5d8bd71..fa01f36c50d0b019e300f84bf9a9a9edee038bf7 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.


@@ -34,6 +35,8 @@
 #include "complaints.h"
 #include "gdbcmd.h"
 #include "wrapper.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.  */


@@ -65,13 +68,35 @@ 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_v4sf;
 struct type *builtin_type_v4si;
 struct type *builtin_type_bool;
 struct type *builtin_type_v4sf;
 struct type *builtin_type_v4si;

+struct type *builtin_type_v16qi;

 struct type *builtin_type_v8qi;
 struct type *builtin_type_v8qi;

+struct type *builtin_type_v8hi;

 struct type *builtin_type_v4hi;
 struct type *builtin_type_v2si;
 struct type *builtin_type_v4hi;
 struct type *builtin_type_v2si;

-struct type *builtin_type_ptr;
+struct type *builtin_type_vec128;
+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;
 
 struct type *builtin_type_CORE_ADDR;
 struct type *builtin_type_bfd_vma;
 


@@ -82,7 +107,7 @@ struct extra
   {
     char str[128];
     int len;
   {
     char str[128];
     int len;

-  };                           /* maximum extention is 128! FIXME */
+  };                           /* maximum extension is 128! FIXME */

 
 static void add_name (struct extra *, char *);
 static void add_mangled_type (struct extra *, struct type *);
 
 static void add_name (struct extra *, char *);
 static void add_mangled_type (struct extra *, struct type *);


@@ -125,6 +150,7 @@ alloc_type (struct objfile *objfile)
   TYPE_OBJFILE (type) = objfile;
   TYPE_VPTR_FIELDNO (type) = -1;
   TYPE_CV_TYPE (type) = type;  /* chain back to itself */
   TYPE_OBJFILE (type) = objfile;
   TYPE_VPTR_FIELDNO (type) = -1;
   TYPE_CV_TYPE (type) = type;  /* chain back to itself */

+  TYPE_AS_TYPE (type) = type;  /* ditto */

 
   return (type);
 }
 
   return (type);
 }


@@ -302,6 +328,73 @@ 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)
+{
+  /* 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
+    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. */
+
+extern char *
+address_space_int_to_name (int space_flag)
+{
+  if (space_flag & TYPE_FLAG_CODE_SPACE)
+    return "code";
+  else if (space_flag & TYPE_FLAG_DATA_SPACE)
+    return "data";
+  else
+    return NULL;
+}
+
+/* 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").
+
+   This is for Harvard architectures. */
+
+struct type *
+make_type_with_address_space (struct type *type, int space_flag)
+{
+  struct type *ntype;
+
+  ntype = type;
+  do {
+    if ((ntype->flags & space_flag) != 0)
+      return ntype;
+    ntype = TYPE_AS_TYPE (ntype);
+  } while (ntype != type);
+
+  /* Create a new, duplicate type. */
+  ntype = alloc_type (TYPE_OBJFILE (type));
+  /* Copy original type. */
+  memcpy ((char *) ntype, (char *) type, sizeof (struct type));
+
+  /* Pointers or references to the original type are not relevant to
+     the new type; but if the original type is a pointer, the new type
+     points to the same thing (so TYPE_TARGET_TYPE remains unchanged). */
+  TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
+  TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
+  TYPE_CV_TYPE (ntype) = ntype;
+
+  /* Chain the new address-space-specific type to the old type. */
+  ntype->as_type = type->as_type;
+  type->as_type = ntype;
+
+  /* Now set the address-space flag, and return the new type. */
+  ntype->flags |= space_flag;
+  return ntype;
+}
+

 
 /* 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


@@ -359,6 +452,7 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
   /* 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 */
   /* 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 */

+  TYPE_AS_TYPE (ntype) = ntype;                /* Need new address-space kind. */

   /* Note: TYPE_TARGET_TYPE can be left as is */
 
   /* Set flags appropriately */
   /* Note: TYPE_TARGET_TYPE can be left as is */
 
   /* Set flags appropriately */


@@ -379,8 +473,77 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
   return ntype;
 }
 
   return ntype;
 }
 

+/* When reading in a class type, we may have created references to
+   cv-qualified versions of the type (in method arguments, for
+   instance).  Update everything on the cv ring from the primary
+   type TYPE.
+
+   The only reason we do not need to do the same thing for address
+   spaces is that type readers do not create address space qualified
+   types.  */
+void
+finish_cv_type (struct type *type)
+{
+  struct type *ntype, *cv_type, *ptr_type, *ref_type;
+  int cv_flags;
+
+  gdb_assert (!TYPE_CONST (type) && !TYPE_VOLATILE (type));
+
+  ntype = type;
+  while ((ntype = TYPE_CV_TYPE (ntype)) != type)
+    {
+      /* Save cv_flags.  */
+      cv_flags = TYPE_FLAGS (ntype) & (TYPE_FLAG_VOLATILE | TYPE_FLAG_CONST);
+
+      /* If any reference or pointer types were created, save them too.  */
+      ptr_type = TYPE_POINTER_TYPE (ntype);
+      ref_type = TYPE_REFERENCE_TYPE (ntype);
+
+      /* Don't disturb the CV chain.  */
+      cv_type = TYPE_CV_TYPE (ntype);
+
+      /* Verify that we haven't added any address-space qualified types,
+        for the future.  */
+      gdb_assert (ntype == TYPE_AS_TYPE (ntype));
+
+      /* Copy original type */
+      memcpy ((char *) ntype, (char *) type, sizeof (struct type));
+
+      /* Restore everything.  */
+      TYPE_POINTER_TYPE (ntype) = ptr_type;
+      TYPE_REFERENCE_TYPE (ntype) = ref_type;
+      TYPE_CV_TYPE (ntype) = cv_type;
+      TYPE_FLAGS (ntype) = TYPE_FLAGS (ntype) | cv_flags;
+
+      TYPE_AS_TYPE (ntype) = ntype;
+    }
+}
+
+/* Replace the contents of ntype with the type *type.
+
+   This function should not be necessary, but is due to quirks in the stabs
+   reader.  This should go away.  It does not handle the replacement type
+   being cv-qualified; it could be easily fixed to, but it should go away,
+   remember?  */
+void
+replace_type (struct type *ntype, struct type *type)
+{
+  struct type *cv_chain, *as_chain, *ptr, *ref;
+
+  cv_chain = TYPE_CV_TYPE (ntype);
+  as_chain = TYPE_AS_TYPE (ntype);
+  ptr = TYPE_POINTER_TYPE (ntype);
+  ref = TYPE_REFERENCE_TYPE (ntype);

 
 

+  *ntype = *type;

 
 

+  TYPE_POINTER_TYPE (ntype) = ptr;
+  TYPE_REFERENCE_TYPE (ntype) = ref;
+  TYPE_CV_TYPE (ntype) = cv_chain;
+  TYPE_AS_TYPE (ntype) = as_chain;
+
+  finish_cv_type (ntype);
+}

 
 /* 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.


@@ -408,13 +571,11 @@ 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 */
   /*  _ARG_TYPES (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);
 }
 


@@ -437,7 +598,7 @@ create_range_type (struct type *result_type, struct type *index_type,
     }
   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));


@@ -600,7 +761,7 @@ create_set_type (struct type *result_type, struct 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;


@@ -616,7 +777,6 @@ create_set_type (struct type *result_type, struct 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


@@ -632,28 +792,45 @@ init_simd_type (char *name,
                char *elt_name,
                int n)
 {
                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 *
+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
+  {
+    struct __builtin_v16qi v16qi;
+    struct __builtin_v8hi v8hi;
+    struct __builtin_v4si v4si;
+    struct __builtin_v4sf v4sf;
+    uint128_t uint128;
+  };
+#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, "v4sf", builtin_type_v4sf);
+  append_composite_type_field (t, "v4si", builtin_type_v4si);
+  append_composite_type_field (t, "v8hi", builtin_type_v8hi);
+  append_composite_type_field (t, "v16qi", builtin_type_v16qi);

 
   return t;
 }
 
 
   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
    a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn'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
    a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn't


@@ -1026,7 +1203,7 @@ get_destructor_fn_field (struct type *t, int *method_indexp, int *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;


@@ -1054,9 +1231,11 @@ struct complaint stub_noname_complaint =
 {"stub type has NULL name", 0, 0};
 
 struct type *
 {"stub type has NULL name", 0, 0};
 
 struct type *

-check_typedef (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))


@@ -1089,6 +1268,9 @@ check_typedef (register struct type *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


@@ -1105,12 +1287,10 @@ check_typedef (register struct type *type)
        }
       newtype = lookup_transparent_type (name);
       if (newtype)
        }
       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


@@ -1125,17 +1305,15 @@ check_typedef (register struct type *type)
        }
       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, (struct symtab **) NULL);
       if (sym)
        }
       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


@@ -1164,7 +1342,6 @@ check_typedef (register struct type *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; }
 
 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
 


@@ -1350,9 +1527,8 @@ cfront_mangle_name (struct type *type, int i, int 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;
     }
 }


@@ -1410,6 +1586,8 @@ check_stub_method (struct type *type, int method_id, int signature_id)
   /* Make sure we got back a function string that we can use.  */
   if (demangled_name)
     p = strchr (demangled_name, '(');
   /* 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);


@@ -1484,7 +1662,7 @@ check_stub_method (struct type *type, int method_id, int signature_id)
       argtypes[argcount] = NULL;       /* Ellist terminator */
     }
 
       argtypes[argcount] = NULL;       /* Ellist terminator */
     }
 

-  free (demangled_name);
+  xfree (demangled_name);

 
   f = TYPE_FN_FIELDLIST1 (type, method_id);
 
 
   f = TYPE_FN_FIELDLIST1 (type, method_id);
 


@@ -1547,6 +1725,48 @@ init_type (enum type_code code, int length, int flags, char *name,
   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.
 


@@ -1835,7 +2055,7 @@ virtual_base_list (struct type *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;
     }
 


@@ -1903,12 +2123,12 @@ virtual_base_index (struct type *base, struct type *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;


@@ -1937,14 +2157,14 @@ virtual_base_index_skip_primaries (struct type *base, struct type *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;


@@ -1986,6 +2206,8 @@ count_virtual_fns (struct type *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++)


@@ -2576,6 +2798,35 @@ print_cplus_stuff (struct type *type, int 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


@@ -2616,13 +2867,10 @@ recursive_dump_type (struct type *type, int 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))
     {


@@ -2665,6 +2913,9 @@ recursive_dump_type (struct type *type, int 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;


@@ -2683,15 +2934,32 @@ recursive_dump_type (struct type *type, int 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");


@@ -2708,15 +2976,68 @@ recursive_dump_type (struct type *type, int 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, "cv_type ");
+  gdb_print_host_address (TYPE_CV_TYPE (type), gdb_stdout);
+  printf_filtered ("\n");
+  printfi_filtered (spaces, "as_type ");
+  gdb_print_host_address (TYPE_AS_TYPE (type), gdb_stdout);
+  printf_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_CONST (type))
+    {
+      puts_filtered (" TYPE_FLAG_CONST");
+    }
+  if (TYPE_VOLATILE (type))
+    {
+      puts_filtered (" TYPE_FLAG_VOLATILE");
+    }
+  if (TYPE_PROTOTYPED (type))
+    {
+      puts_filtered (" TYPE_FLAG_PROTOTYPED");
+    }
+  if (TYPE_INCOMPLETE (type))
+    {
+      puts_filtered (" TYPE_FLAG_INCOMPLETE");
+    }
+  if (TYPE_CODE_SPACE (type))
+    {
+      puts_filtered (" TYPE_FLAG_CODE_SPACE");
+    }
+  if (TYPE_DATA_SPACE (type))
+    {
+      puts_filtered (" TYPE_FLAG_DATA_SPACE");
+    }
+  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);


@@ -2764,6 +3085,16 @@ recursive_dump_type (struct type *type, int 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


@@ -2792,9 +3123,9 @@ build_gdbtypes (void)
               "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,


@@ -2843,14 +3174,31 @@ build_gdbtypes (void)
     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,


@@ -2897,6 +3245,14 @@ build_gdbtypes (void)
     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,


@@ -2910,24 +3266,57 @@ build_gdbtypes (void)
      &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);
   builtin_type_v4si
     = init_simd_type ("__builtin_v4si", builtin_type_int32, "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_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);
 
   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);
 

+  /* Vector types. */
+  builtin_type_vec128
+    = build_builtin_type_vec128 ();
+

   /* Pointer/Address types. */
   /* Pointer/Address types. */

-  /* NOTE: At present there is no way of differentiating between at
-     target address and the target C language pointer type type even
-     though the two can be different (cf d10v) */
-  builtin_type_ptr = make_pointer_type (builtin_type_void, NULL);
+
+  /* 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,
   builtin_type_CORE_ADDR =
     init_type (TYPE_CODE_INT, TARGET_ADDR_BIT / 8,
               TYPE_FLAG_UNSIGNED,


@@ -2975,16 +3364,89 @@ _initialize_gdbtypes (void)
   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_v4si, 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_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_v4hi, sizeof (struct type *), NULL);
   register_gdbarch_swap (&builtin_type_v2si, sizeof (struct type *), NULL);

-  REGISTER_GDBARCH_SWAP (builtin_type_ptr);
+  register_gdbarch_swap (&builtin_type_vec128, 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 (builtin_type_CORE_ADDR);
   REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma);
   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\
   add_show_from_set (
                     add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug,
                                  "Set debugging of C++ overloading.\n\