Add support for target specific command line switches to old-style simualtors.

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

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 290d4fe09c54d69b531ac7c243900f038c89059e..e8ba96d10385fee485f76e07c6a451adb880c00b 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -71,6 +71,18 @@ struct type *builtin_type_uint64;
 struct type *builtin_type_int128;
 struct type *builtin_type_uint128;
 struct type *builtin_type_bool;
 struct type *builtin_type_int128;
 struct type *builtin_type_uint128;
 struct type *builtin_type_bool;

+
+/* 128 bit long vector types */
+struct type *builtin_type_v4_float;
+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_v4si;
 struct type *builtin_type_v16qi;
 struct type *builtin_type_v4sf;
 struct type *builtin_type_v4si;
 struct type *builtin_type_v16qi;


@@ -123,7 +135,8 @@ 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 *
 alloc_type (struct objfile *objfile)
 
 struct type *
 alloc_type (struct objfile *objfile)


@@ -134,27 +147,73 @@ alloc_type (struct objfile *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_AS_TYPE (type) = type;  /* ditto */
+  TYPE_CHAIN (type) = type;    /* Chain back to itself.  */
+
+  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);
 }
 
 
   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.
 /* 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.


@@ -190,7 +249,7 @@ make_pointer_type (struct type *type, struct 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;
     }
 


@@ -257,7 +316,7 @@ make_reference_type (struct type *type, struct 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;
     }
 


@@ -306,7 +365,7 @@ make_function_type (struct type *type, struct 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;
     }
 


@@ -356,45 +415,63 @@ address_space_int_to_name (int space_flag)
     return NULL;
 }
 
     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. */
+/* 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 *
 
 struct type *

-make_type_with_address_space (struct type *type, int space_flag)
+make_qualified_type (struct type *type, int new_flags,
+                    struct type *storage)

 {
   struct type *ntype;
 
   ntype = type;
   do {
 {
   struct type *ntype;
 
   ntype = type;
   do {

-    if ((ntype->flags & space_flag) != 0)
+    if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)

       return ntype;
       return ntype;

-    ntype = TYPE_AS_TYPE (ntype);
+    ntype = TYPE_CHAIN (ntype);

   } while (ntype != type);
 
   } 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));
+  /* 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
 
   /* 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). */
+     the new type.  */

   TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
   TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
   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;
+  /* 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;

 
 

-  /* Now set the address-space flag, and return the new type. */
-  ntype->flags |= space_flag;

   return ntype;
 }
 
   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").
+
+   This is for Harvard architectures. */
+
+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))
+                  | 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


@@ -413,142 +490,60 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
   register struct type *tmp_type = type;       /* tmp type */
   struct objfile *objfile;
 
   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 ((TYPE_CONST (ntype) == cnst) &&
-         (TYPE_VOLATILE (ntype) == voltl))
-       {
-         if (typeptr == 0)
-           return ntype;
-         else if (*typeptr == 0)
-           {
-             *typeptr = ntype; /* Tracking alloc, and we have new type.  */
-             return ntype;
-           }
-       }
-      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;
-    }
-
-  /* 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 */
-  TYPE_AS_TYPE (ntype) = ntype;                /* Need new address-space kind. */
-  /* Note: TYPE_TARGET_TYPE can be left as is */
-
-  /* Set flags appropriately */

   if (cnst)
   if (cnst)

-    TYPE_FLAGS (ntype) |= TYPE_FLAG_CONST;
-  else
-    TYPE_FLAGS (ntype) &= ~TYPE_FLAG_CONST;
+    new_flags |= TYPE_FLAG_CONST;

 
   if (voltl)
 
   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;
+    new_flags |= TYPE_FLAG_VOLATILE;

 
 

-  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)
+  if (typeptr && *typeptr != NULL)

     {
     {

-      /* Save cv_flags.  */
-      cv_flags = TYPE_FLAGS (ntype) & (TYPE_FLAG_VOLATILE | TYPE_FLAG_CONST);
+      /* 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.  */

 
 

-      /* 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));
+      gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)
+                 || TYPE_STUB (*typeptr));
+      if (TYPE_OBJFILE (*typeptr) != TYPE_OBJFILE (type))
+       {
+         TYPE_MAIN_TYPE (*typeptr)
+           = TYPE_ALLOC (*typeptr, sizeof (struct main_type));
+         *TYPE_MAIN_TYPE (*typeptr)
+           = *TYPE_MAIN_TYPE (type);
+       }
+    }
+  
+  ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL);

 
 

-      /* 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;
+  if (typeptr != NULL)
+    *typeptr = ntype;

 
 

-      TYPE_AS_TYPE (ntype) = ntype;
-    }
+  return ntype;

 }
 
 }
 

-/* Replace the contents of ntype with the type *type.
+/* 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
 
    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.  For example, Daniel Jacobowitz has suggested moving
-   the fields common to a set of c/v variants into their own object,
-   which the variants would share.
-
-   This function does not handle the replacement type being
-   cv-qualified; it could be easily fixed to, but it would be better
-   to just change the whole approach.  */
+   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;
 
 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;
+  *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);

 
 

-  finish_cv_type (ntype);
+  /* 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++.
 }
 
 /* Implement direct support for MEMBER_TYPE in GNU C++.


@@ -809,19 +804,31 @@ init_simd_type (char *name,
   return simd_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_vec128 (void)
 {
   /* Construct a type for the 128 bit registers.  The type we're
      building is this: */
 #if 0
 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
+ union __gdb_builtin_type_vec128 

   {
   {

-    struct __builtin_v16qi v16qi;
-    struct __builtin_v8hi v8hi;
-    struct __builtin_v4si v4si;
-    struct __builtin_v4sf v4sf;
-    uint128_t uint128;
+    int128_t uint128;
+    float v4_float[4];
+    int32_t v4_int32[4];
+    int16_t v8_int16[8];
+    int8_t v16_int8[16];

   };
 #endif
 
   };
 #endif
 


@@ -829,10 +836,10 @@ build_builtin_type_vec128 (void)
 
   t = init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION);
   append_composite_type_field (t, "uint128", builtin_type_int128);
 
   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);
+  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);

 
   return t;
 }
 
   return t;
 }


@@ -855,7 +862,7 @@ smash_to_member_type (struct type *type, struct type *domain,
 
   objfile = TYPE_OBJFILE (type);
 
 
   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;


@@ -878,7 +885,7 @@ smash_to_method_type (struct type *type, struct type *domain,
 
   objfile = TYPE_OBJFILE (type);
 
 
   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;


@@ -912,7 +919,7 @@ lookup_primitive_typename (char *name)
 
   for (p = current_language->la_builtin_type_vector; *p != NULL; 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);
        }


@@ -1057,10 +1064,10 @@ struct type *
 lookup_template_type (char *name, struct type *type, struct block *block)
 {
   struct symbol *sym;
 lookup_template_type (char *name, struct type *type, struct block *block)
 {
   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);


@@ -1487,8 +1494,8 @@ add_mangled_type (struct extra *pextras, struct type *t)
        complain (&msg, tcode);
       }
     }
        complain (&msg, 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
 }
 
 #if 0


@@ -1625,9 +1632,16 @@ check_stub_method (struct type *type, int method_id, int signature_id)
   argtypes = (struct type **)
     TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));
   p = argtypetext;
   argtypes = (struct type **)
     TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));
   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] = lookup_pointer_type (type);
+      argcount = 1;
+    }

 
   if (*p != ')')               /* () means no args, skip while */
     {
 
   if (*p != ')')               /* () means no args, skip while */
     {


@@ -1670,8 +1684,6 @@ check_stub_method (struct type *type, int method_id, int signature_id)
 
   xfree (demangled_name);
 
 
   xfree (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.  */
   TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
 
   /* Now update the old "stub" type into a real type.  */


@@ -2684,7 +2696,7 @@ print_arg_types (struct type **args, int spaces)
       while (*args != NULL)
        {
          recursive_dump_type (*args, spaces + 2);
       while (*args != NULL)
        {
          recursive_dump_type (*args, spaces + 2);

-         if ((*args++)->code == TYPE_CODE_VOID)
+         if (TYPE_CODE (*args++) == TYPE_CODE_VOID)

            {
              break;
            }
            {
              break;
            }


@@ -2982,12 +2994,27 @@ 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);
+  printfi_filtered (spaces, "type_chain ");
+  gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);

   printf_filtered ("\n");
   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");
+    }
+  puts_filtered ("\n");

   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
   if (TYPE_UNSIGNED (type))
     {
   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
   if (TYPE_UNSIGNED (type))
     {


@@ -3009,14 +3036,6 @@ recursive_dump_type (struct type *type, int spaces)
     {
       puts_filtered (" TYPE_FLAG_STATIC");
     }
     {
       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_PROTOTYPED (type))
     {
       puts_filtered (" TYPE_FLAG_PROTOTYPED");


@@ -3025,14 +3044,6 @@ recursive_dump_type (struct type *type, int spaces)
     {
       puts_filtered (" TYPE_FLAG_INCOMPLETE");
     }
     {
       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");
   if (TYPE_VARARGS (type))
     {
       puts_filtered (" TYPE_FLAG_VARARGS");


@@ -3288,9 +3299,19 @@ build_gdbtypes (void)
   builtin_type_v2si
     = init_simd_type ("__builtin_v2si", builtin_type_int32, "f", 2);
 
   builtin_type_v2si
     = init_simd_type ("__builtin_v2si", builtin_type_int32, "f", 2);
 

+  /* 128 bit vectors.  */
+  builtin_type_v4_float = init_vector_type (builtin_type_float, 4);
+  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. */
   /* Vector types. */

-  builtin_type_vec128
-    = build_builtin_type_vec128 ();
+  builtin_type_vec128 = build_builtin_type_vec128 ();

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


@@ -3379,6 +3400,14 @@ _initialize_gdbtypes (void)
   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_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_v4_float, 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_void_data_ptr);
   REGISTER_GDBARCH_SWAP (builtin_type_void_func_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);