sys/types.h cleanup
[deliverable/binutils-gdb.git] / gdb / gdbtypes.c
index 3b29c54b45808a4d40053639af343ac1707c244d..e18a0d249f865bf6d4ef3fafdb3aff3aef478067 100644 (file)
@@ -1,8 +1,6 @@
 /* Support routines for manipulating internal types for GDB.
 
-   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
-   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-   Free Software Foundation, Inc.
+   Copyright (C) 1992-2013 Free Software Foundation, Inc.
 
    Contributed by Cygnus Support, using pieces from other GDB modules.
 
@@ -22,7 +20,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
-#include "gdb_string.h"
+#include <string.h>
 #include "bfd.h"
 #include "symtab.h"
 #include "symfile.h"
 #include "demangle.h"
 #include "complaints.h"
 #include "gdbcmd.h"
-#include "wrapper.h"
 #include "cp-abi.h"
 #include "gdb_assert.h"
 #include "hashtab.h"
-
+#include "exceptions.h"
+#include "cp-support.h"
 
 /* Initialize BADNESS constants.  */
 
-const struct rank LENGTH_MISMATCH_BADNESS = {100};
-
-const struct rank TOO_FEW_PARAMS_BADNESS = {100};
-const struct rank INCOMPATIBLE_TYPE_BADNESS = {100};
+const struct rank LENGTH_MISMATCH_BADNESS = {100,0};
 
-const struct rank EXACT_MATCH_BADNESS = {0};
+const struct rank TOO_FEW_PARAMS_BADNESS = {100,0};
+const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0};
 
-const struct rank INTEGER_PROMOTION_BADNESS = {1};
-const struct rank FLOAT_PROMOTION_BADNESS = {1};
-const struct rank BASE_PTR_CONVERSION_BADNESS = {1};
-const struct rank INTEGER_CONVERSION_BADNESS = {2};
-const struct rank FLOAT_CONVERSION_BADNESS = {2};
-const struct rank INT_FLOAT_CONVERSION_BADNESS = {2};
-const struct rank VOID_PTR_CONVERSION_BADNESS = {2};
-const struct rank BOOL_PTR_CONVERSION_BADNESS = {3};
-const struct rank BASE_CONVERSION_BADNESS = {2};
-const struct rank REFERENCE_CONVERSION_BADNESS = {2};
+const struct rank EXACT_MATCH_BADNESS = {0,0};
 
-const struct rank NS_POINTER_CONVERSION_BADNESS = {10};
+const struct rank INTEGER_PROMOTION_BADNESS = {1,0};
+const struct rank FLOAT_PROMOTION_BADNESS = {1,0};
+const struct rank BASE_PTR_CONVERSION_BADNESS = {1,0};
+const struct rank INTEGER_CONVERSION_BADNESS = {2,0};
+const struct rank FLOAT_CONVERSION_BADNESS = {2,0};
+const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0};
+const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0};
+const struct rank BOOL_CONVERSION_BADNESS = {3,0};
+const struct rank BASE_CONVERSION_BADNESS = {2,0};
+const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
+const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0};
+const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
+const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,0};
 
 /* Floatformat pairs.  */
 const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = {
@@ -109,23 +108,37 @@ const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
   &floatformat_vax_d
 };
 const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
-  &floatformat_ibm_long_double,
-  &floatformat_ibm_long_double
+  &floatformat_ibm_long_double_big,
+  &floatformat_ibm_long_double_little
 };
 
+/* Should opaque types be resolved?  */
+
+static int opaque_type_resolution = 1;
+
+/* A flag to enable printing of debugging information of C++
+   overloading.  */
+
+unsigned int overload_debug = 0;
+
+/* A flag to enable strict type checking.  */
+
+static int strict_type_checking = 1;
+
+/* A function to show whether opaque types are resolved.  */
 
-int opaque_type_resolution = 1;
 static void
 show_opaque_type_resolution (struct ui_file *file, int from_tty,
                             struct cmd_list_element *c, 
                             const char *value)
 {
-  fprintf_filtered (file, _("\
-Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
+  fprintf_filtered (file, _("Resolution of opaque struct/class/union types "
+                           "(if set before loading symbols) is %s.\n"),
                    value);
 }
 
-int overload_debug = 0;
+/* A function to show whether C++ overload debugging is enabled.  */
+
 static void
 show_overload_debug (struct ui_file *file, int from_tty,
                     struct cmd_list_element *c, const char *value)
@@ -134,18 +147,16 @@ show_overload_debug (struct ui_file *file, int from_tty,
                    value);
 }
 
-struct extra
-  {
-    char str[128];
-    int len;
-  };                           /* Maximum extension is 128!  FIXME  */
-
-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);
+/* A function to show the status of strict type checking.  */
 
+static void
+show_strict_type_checking (struct ui_file *file, int from_tty,
+                          struct cmd_list_element *c, const char *value)
+{
+  fprintf_filtered (file, _("Strict type checking is %s.\n"), value);
+}
 
+\f
 /* Allocate a new OBJFILE-associated type structure and fill it
    with some defaults.  Space for the type structure is allocated
    on the objfile's objfile_obstack.  */
@@ -228,6 +239,20 @@ get_type_arch (const struct type *type)
     return TYPE_OWNER (type).gdbarch;
 }
 
+/* See gdbtypes.h.  */
+
+struct type *
+get_target_type (struct type *type)
+{
+  if (type != NULL)
+    {
+      type = TYPE_TARGET_TYPE (type);
+      if (type != NULL)
+       type = check_typedef (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
@@ -255,6 +280,7 @@ alloc_type_instance (struct type *oldtype)
 
 /* Clear all remnants of the previous type at TYPE, in preparation for
    replacing it with something else.  Preserve owner information.  */
+
 static void
 smash_type (struct type *type)
 {
@@ -315,8 +341,7 @@ make_pointer_type (struct type *type, struct type **typeptr)
   TYPE_TARGET_TYPE (ntype) = type;
   TYPE_POINTER_TYPE (type) = ntype;
 
-  /* FIXME!  Assume the machine has only one representation for
-     pointers!  */
+  /* FIXME!  Assumes the machine has only one representation for pointers!  */
 
   TYPE_LENGTH (ntype)
     = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
@@ -327,9 +352,6 @@ make_pointer_type (struct type *type, struct type **typeptr)
      gdbarch_address_to_pointer.  */
   TYPE_UNSIGNED (ntype) = 1;
 
-  if (!TYPE_POINTER_TYPE (type))       /* Remember it, if don't have one.  */
-    TYPE_POINTER_TYPE (type) = ntype;
-
   /* Update the length of all the other variants of this type.  */
   chain = TYPE_CHAIN (ntype);
   while (chain != ntype)
@@ -450,10 +472,11 @@ make_function_type (struct type *type, struct type **typeptr)
   TYPE_LENGTH (ntype) = 1;
   TYPE_CODE (ntype) = TYPE_CODE_FUNC;
 
+  INIT_FUNC_SPECIFIC (ntype);
+
   return ntype;
 }
 
-
 /* Given a type TYPE, return a type of functions that return that type.
    May need to construct such a type if this is the first use.  */
 
@@ -463,9 +486,47 @@ lookup_function_type (struct type *type)
   return make_function_type (type, (struct type **) 0);
 }
 
+/* Given a type TYPE and argument types, return the appropriate
+   function type.  If the final type in PARAM_TYPES is NULL, make a
+   varargs function.  */
+
+struct type *
+lookup_function_type_with_arguments (struct type *type,
+                                    int nparams,
+                                    struct type **param_types)
+{
+  struct type *fn = make_function_type (type, (struct type **) 0);
+  int i;
+
+  if (nparams > 0)
+    {
+      if (param_types[nparams - 1] == NULL)
+       {
+         --nparams;
+         TYPE_VARARGS (fn) = 1;
+       }
+      else if (TYPE_CODE (check_typedef (param_types[nparams - 1]))
+              == TYPE_CODE_VOID)
+       {
+         --nparams;
+         /* Caller should have ensured this.  */
+         gdb_assert (nparams == 0);
+         TYPE_PROTOTYPED (fn) = 1;
+       }
+    }
+
+  TYPE_NFIELDS (fn) = nparams;
+  TYPE_FIELDS (fn) = TYPE_ZALLOC (fn, nparams * sizeof (struct field));
+  for (i = 0; i < nparams; ++i)
+    TYPE_FIELD_TYPE (fn, i) = param_types[i];
+
+  return fn;
+}
+
 /* Identify address space identifier by name --
    return the integer flag defined in gdbtypes.h.  */
-extern int
+
+int
 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
 {
   int type_flags;
@@ -587,6 +648,7 @@ make_type_with_address_space (struct type *type, int space_flag)
    in the same objfile.  Otherwise, allocate fresh memory for the new
    type whereever TYPE lives.  If TYPEPTR is non-zero, set it to the
    new type we construct.  */
+
 struct type *
 make_cv_type (int cnst, int voltl, 
              struct type *type, 
@@ -630,6 +692,17 @@ make_cv_type (int cnst, int voltl,
   return ntype;
 }
 
+/* Make a 'restrict'-qualified version of TYPE.  */
+
+struct type *
+make_restrict_type (struct type *type)
+{
+  return make_qualified_type (type,
+                             (TYPE_INSTANCE_FLAGS (type)
+                              | TYPE_INSTANCE_FLAG_RESTRICT),
+                             NULL);
+}
+
 /* 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.
@@ -639,6 +712,7 @@ make_cv_type (int cnst, int voltl,
    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)
 {
@@ -773,16 +847,16 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
       if (TYPE_NFIELDS (type) > 0)
        {
          /* The enums may not be sorted by value, so search all
-            entries */
+            entries */
          int i;
 
-         *lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
+         *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
          for (i = 0; i < TYPE_NFIELDS (type); i++)
            {
-             if (TYPE_FIELD_BITPOS (type, i) < *lowp)
-               *lowp = TYPE_FIELD_BITPOS (type, i);
-             if (TYPE_FIELD_BITPOS (type, i) > *highp)
-               *highp = TYPE_FIELD_BITPOS (type, i);
+             if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
+               *lowp = TYPE_FIELD_ENUMVAL (type, i);
+             if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
+               *highp = TYPE_FIELD_ENUMVAL (type, i);
            }
 
          /* Set unsigned indicator if warranted.  */
@@ -828,7 +902,7 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
    and lower bound.  Save the low bound into LOW_BOUND if not NULL.
    Save the high bound into HIGH_BOUND if not NULL.
 
-   Return 1 if the operation was successful. Return zero otherwise,
+   Return 1 if the operation was successful.  Return zero otherwise,
    in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
 
    We now simply use get_discrete_bounds call to get the values
@@ -908,7 +982,7 @@ create_array_type (struct type *result_type,
   TYPE_INDEX_TYPE (result_type) = range_type;
   TYPE_VPTR_FIELDNO (result_type) = -1;
 
-  /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
+  /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
   if (TYPE_LENGTH (result_type) == 0)
     TYPE_TARGET_STUB (result_type) = 1;
 
@@ -917,7 +991,7 @@ create_array_type (struct type *result_type,
 
 struct type *
 lookup_array_range_type (struct type *element_type,
-                        int low_bound, int high_bound)
+                        LONGEST low_bound, LONGEST high_bound)
 {
   struct gdbarch *gdbarch = get_type_arch (element_type);
   struct type *index_type = builtin_type (gdbarch)->builtin_int;
@@ -953,7 +1027,7 @@ create_string_type (struct type *result_type,
 
 struct type *
 lookup_string_range_type (struct type *string_char_type,
-                         int low_bound, int high_bound)
+                         LONGEST low_bound, LONGEST high_bound)
 {
   struct type *result_type;
 
@@ -1093,7 +1167,7 @@ smash_to_method_type (struct type *type, struct type *domain,
 /* Return a typename for a struct/union/enum type without "struct ",
    "union ", or "enum ".  If the type has a NULL name, return NULL.  */
 
-char *
+const char *
 type_name_no_tag (const struct type *type)
 {
   if (TYPE_TAG_NAME (type) != NULL)
@@ -1105,41 +1179,61 @@ type_name_no_tag (const struct type *type)
   return TYPE_NAME (type);
 }
 
+/* A wrapper of type_name_no_tag which calls error if the type is anonymous.
+   Since GCC PR debug/47510 DWARF provides associated information to detect the
+   anonymous class linkage name from its typedef.
+
+   Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
+   apply it itself.  */
+
+const char *
+type_name_no_tag_or_error (struct type *type)
+{
+  struct type *saved_type = type;
+  const char *name;
+  struct objfile *objfile;
+
+  CHECK_TYPEDEF (type);
+
+  name = type_name_no_tag (type);
+  if (name != NULL)
+    return name;
+
+  name = type_name_no_tag (saved_type);
+  objfile = TYPE_OBJFILE (saved_type);
+  error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
+        name ? name : "<anonymous>",
+        objfile ? objfile_name (objfile) : "<arch>");
+}
+
 /* Lookup a typedef or primitive type named NAME, visible in lexical
    block BLOCK.  If NOERR is nonzero, return zero if NAME is not
    suitably defined.  */
 
 struct type *
 lookup_typename (const struct language_defn *language,
-                struct gdbarch *gdbarch, char *name,
+                struct gdbarch *gdbarch, const char *name,
                 const struct block *block, int noerr)
 {
   struct symbol *sym;
-  struct type *tmp;
+  struct type *type;
 
   sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
-  if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
-    {
-      tmp = language_lookup_primitive_type_by_name (language, gdbarch, name);
-      if (tmp)
-       {
-         return tmp;
-       }
-      else if (!tmp && noerr)
-       {
-         return NULL;
-       }
-      else
-       {
-         error (_("No type named %s."), name);
-       }
-    }
-  return (SYMBOL_TYPE (sym));
+  if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+    return SYMBOL_TYPE (sym);
+
+  type = language_lookup_primitive_type_by_name (language, gdbarch, name);
+  if (type)
+    return type;
+
+  if (noerr)
+    return NULL;
+  error (_("No type named %s."), name);
 }
 
 struct type *
 lookup_unsigned_typename (const struct language_defn *language,
-                         struct gdbarch *gdbarch, char *name)
+                         struct gdbarch *gdbarch, const char *name)
 {
   char *uns = alloca (strlen (name) + 10);
 
@@ -1150,7 +1244,7 @@ lookup_unsigned_typename (const struct language_defn *language,
 
 struct type *
 lookup_signed_typename (const struct language_defn *language,
-                       struct gdbarch *gdbarch, char *name)
+                       struct gdbarch *gdbarch, const char *name)
 {
   struct type *t;
   char *uns = alloca (strlen (name) + 8);
@@ -1168,7 +1262,7 @@ lookup_signed_typename (const struct language_defn *language,
    visible in lexical block BLOCK.  */
 
 struct type *
-lookup_struct (char *name, struct block *block)
+lookup_struct (const char *name, const struct block *block)
 {
   struct symbol *sym;
 
@@ -1190,7 +1284,7 @@ lookup_struct (char *name, struct block *block)
    visible in lexical block BLOCK.  */
 
 struct type *
-lookup_union (char *name, struct block *block)
+lookup_union (const char *name, const struct block *block)
 {
   struct symbol *sym;
   struct type *t;
@@ -1210,12 +1304,11 @@ lookup_union (char *name, struct block *block)
         name);
 }
 
-
 /* Lookup an enum type named "enum NAME",
    visible in lexical block BLOCK.  */
 
 struct type *
-lookup_enum (char *name, struct block *block)
+lookup_enum (const char *name, const struct block *block)
 {
   struct symbol *sym;
 
@@ -1237,7 +1330,7 @@ lookup_enum (char *name, struct block *block)
 
 struct type *
 lookup_template_type (char *name, struct type *type, 
-                     struct block *block)
+                     const struct block *block)
 {
   struct symbol *sym;
   char *nam = (char *) 
@@ -1246,7 +1339,7 @@ lookup_template_type (char *name, struct type *type,
   strcpy (nam, name);
   strcat (nam, "<");
   strcat (nam, TYPE_NAME (type));
-  strcat (nam, " >");  /* FIXME, extra space still introduced in gcc? */
+  strcat (nam, " >");  /* FIXME, extra space still introduced in gcc?  */
 
   sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
 
@@ -1275,7 +1368,7 @@ lookup_template_type (char *name, struct type *type,
    If NAME is the name of a baseclass type, return that type.  */
 
 struct type *
-lookup_struct_elt_type (struct type *type, char *name, int noerr)
+lookup_struct_elt_type (struct type *type, const char *name, int noerr)
 {
   int i;
   char *typename;
@@ -1300,7 +1393,7 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr)
 #if 0
   /* FIXME: This change put in by Michael seems incorrect for the case
      where the structure tag name is the same as the member name.
-     I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
+     I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
      foo; } bell;" Disabled by fnf.  */
   {
     char *typename;
@@ -1313,7 +1406,7 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr)
 
   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
     {
-      char *t_field_name = TYPE_FIELD_NAME (type, i);
+      const char *t_field_name = TYPE_FIELD_NAME (type, i);
 
       if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
        {
@@ -1384,7 +1477,7 @@ get_vptr_fieldno (struct type *type, struct type **basetypep)
          if (fieldno >= 0)
            {
              /* If the type comes from a different objfile we can't cache
-                it, it may have a different lifetime. PR 2384 */
+                it, it may have a different lifetime.  PR 2384 */
              if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
                {
                  TYPE_VPTR_FIELDNO (type) = fieldno;
@@ -1426,11 +1519,15 @@ stub_noname_complaint (void)
    not been computed and we're either in the middle of reading symbols, or
    there was no name for the typedef in the debug info.
 
+   NOTE: Lookup of opaque types can throw errors for invalid symbol files.
+   QUITs in the symbol reading code can also throw.
+   Thus this function can throw an exception.
+
    If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
    the target type.
 
    If this is a stubbed struct (i.e. declared as struct foo *), see if
-   we can find a full definition in some other file. If so, copy this
+   we can find a full definition in some other file.  If so, copy this
    definition, so we can use it in future.  There used to be a comment
    (but not any code) that if we don't find a full definition, we'd
    set a flag so we don't spend time in the future checking the same
@@ -1451,7 +1548,7 @@ check_typedef (struct type *type)
     {
       if (!TYPE_TARGET_TYPE (type))
        {
-         char *name;
+         const char *name;
          struct symbol *sym;
 
          /* It is dangerous to call lookup_symbol if we are currently
@@ -1514,7 +1611,7 @@ check_typedef (struct type *type)
       && opaque_type_resolution 
       && !currently_reading_symtab)
     {
-      char *name = type_name_no_tag (type);
+      const char *name = type_name_no_tag (type);
       struct type *newtype;
 
       if (name == NULL)
@@ -1548,7 +1645,7 @@ check_typedef (struct type *type)
      types.  */
   else if (TYPE_STUB (type) && !currently_reading_symtab)
     {
-      char *name = type_name_no_tag (type);
+      const char *name = type_name_no_tag (type);
       /* FIXME: shouldn't we separately check the TYPE_NAME and the
          TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
          as appropriate?  (this code was written before TYPE_NAME and
@@ -1582,7 +1679,7 @@ check_typedef (struct type *type)
 
       if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
        {
-         /* Empty.  */
+         /* Nothing we can do.  */
        }
       else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
               && TYPE_NFIELDS (type) == 1
@@ -1592,7 +1689,7 @@ check_typedef (struct type *type)
          /* Now recompute the length of the array type, based on its
             number of elements and the target type's length.
             Watch out for Ada null Ada arrays where the high bound
-            is smaller than the low bound. */
+            is smaller than the low bound.  */
          const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
          const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
          ULONGEST len;
@@ -1606,12 +1703,12 @@ check_typedef (struct type *type)
                 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
                 which is technically not guaranteed by C, but is usually true
                 (because it would be true if x were unsigned with its
-                high-order bit on). It uses the fact that
+                high-order bit on).  It uses the fact that
                 high_bound-low_bound is always representable in
                 ULONGEST and that if high_bound-low_bound+1 overflows,
                 it overflows to 0.  We must change these tests if we 
                 decide to increase the representation of TYPE_LENGTH
-                from unsigned int to ULONGEST. */
+                from unsigned int to ULONGEST.  */
              ULONGEST ulow = low_bound, uhigh = high_bound;
              ULONGEST tlen = TYPE_LENGTH (target_type);
 
@@ -1645,14 +1742,20 @@ static struct type *
 safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
 {
   struct ui_file *saved_gdb_stderr;
-  struct type *type;
+  struct type *type = NULL; /* Initialize to keep gcc happy.  */
+  volatile struct gdb_exception except;
 
   /* 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))
+  TRY_CATCH (except, RETURN_MASK_ERROR)
+    {
+      type = parse_and_eval_type (p, length);
+    }
+
+  if (except.reason < 0)
     type = builtin_type (gdbarch)->builtin_void;
 
   /* Stop suppressing error messages.  */
@@ -1678,8 +1781,8 @@ check_stub_method (struct type *type, int method_id, int signature_id)
   struct gdbarch *gdbarch = get_type_arch (type);
   struct fn_field *f;
   char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
-  char *demangled_name = cplus_demangle (mangled_name,
-                                        DMGL_PARAMS | DMGL_ANSI);
+  char *demangled_name = gdb_demangle (mangled_name,
+                                      DMGL_PARAMS | DMGL_ANSI);
   char *argtypetext, *p;
   int depth = 0, argcount = 1;
   struct field *argtypes;
@@ -1736,7 +1839,7 @@ check_stub_method (struct type *type, int method_id, int signature_id)
       argcount = 1;
     }
 
-  if (*p != ')')               /* () means no args, skip while */
+  if (*p != ')')               /* () means no args, skip while */
     {
       depth = 0;
       while (*p)
@@ -1852,6 +1955,7 @@ const struct gnat_aux_type gnat_aux_default =
 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
    and allocate the associated gnat-specific data.  The gnat-specific
    data is also initialized to gnat_aux_default.  */
+
 void
 allocate_gnat_aux_type (struct type *type)
 {
@@ -1861,17 +1965,15 @@ allocate_gnat_aux_type (struct type *type)
   *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
 }
 
-
 /* Helper function to initialize the standard scalar types.
 
-   If NAME is non-NULL, then we make a copy of the string pointed
-   to by name in the objfile_obstack for that objfile, and initialize
-   the type name to that copy.  There are places (mipsread.c in particular),
-   where init_type is called with a NULL value for NAME).  */
+   If NAME is non-NULL, then it is used to initialize the type name.
+   Note that NAME is not copied; it is required to have a lifetime at
+   least as long as OBJFILE.  */
 
 struct type *
 init_type (enum type_code code, int length, int flags,
-          char *name, struct objfile *objfile)
+          const char *name, struct objfile *objfile)
 {
   struct type *type;
 
@@ -1902,10 +2004,10 @@ init_type (enum type_code code, int length, int flags,
     TYPE_STUB_SUPPORTED (type) = 1;
   if (flags & TYPE_FLAG_FIXED_INSTANCE)
     TYPE_FIXED_INSTANCE (type) = 1;
+  if (flags & TYPE_FLAG_GNU_IFUNC)
+    TYPE_GNU_IFUNC (type) = 1;
 
-  if (name)
-    TYPE_NAME (type) = obsavestring (name, strlen (name),
-                                    &objfile->objfile_obstack);
+  TYPE_NAME (type) = name;
 
   /* C++ fancies.  */
 
@@ -1923,11 +2025,13 @@ init_type (enum type_code code, int length, int flags,
         TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
         break;
       case TYPE_CODE_FUNC:
-        TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CALLING_CONVENTION;
+       INIT_FUNC_SPECIFIC (type);
         break;
     }
   return type;
 }
+\f
+/* Queries on types.  */
 
 int
 can_dereference (struct type *t)
@@ -1955,6 +2059,67 @@ is_integral_type (struct type *t)
         || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
 }
 
+/* Return true if TYPE is scalar.  */
+
+static int
+is_scalar_type (struct type *type)
+{
+  CHECK_TYPEDEF (type);
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_ARRAY:
+    case TYPE_CODE_STRUCT:
+    case TYPE_CODE_UNION:
+    case TYPE_CODE_SET:
+    case TYPE_CODE_STRING:
+      return 0;
+    default:
+      return 1;
+    }
+}
+
+/* Return true if T is scalar, or a composite type which in practice has
+   the memory layout of a scalar type.  E.g., an array or struct with only
+   one scalar element inside it, or a union with only scalar elements.  */
+
+int
+is_scalar_type_recursive (struct type *t)
+{
+  CHECK_TYPEDEF (t);
+
+  if (is_scalar_type (t))
+    return 1;
+  /* Are we dealing with an array or string of known dimensions?  */
+  else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
+           || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
+          && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
+    {
+      LONGEST low_bound, high_bound;
+      struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
+
+      get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
+
+      return high_bound == low_bound && is_scalar_type_recursive (elt_type);
+    }
+  /* Are we dealing with a struct with one element?  */
+  else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
+    return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
+  else if (TYPE_CODE (t) == TYPE_CODE_UNION)
+    {
+      int i, n = TYPE_NFIELDS (t);
+
+      /* If all elements of the union are scalar, then the union is scalar.  */
+      for (i = 0; i < n; i++)
+       if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
+         return 0;
+
+      return 1;
+    }
+
+  return 0;
+}
+
 /* A helper function which returns true if types A and B represent the
    "same" class type.  This is true if the types have the same main
    type, or the same name.  */
@@ -1967,32 +2132,50 @@ class_types_same_p (const struct type *a, const struct type *b)
              && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
 }
 
-/* Check whether BASE is an ancestor or base class of DCLASS
-   Return 1 if so, and 0 if not.  If PUBLIC is 1 then only public
-   ancestors are considered, and the function returns 1 only if
-   BASE is a public ancestor of DCLASS.  */
+/* If BASE is an ancestor of DCLASS return the distance between them.
+   otherwise return -1;
+   eg:
+
+   class A {};
+   class B: public A {};
+   class C: public B {};
+   class D: C {};
+
+   distance_to_ancestor (A, A, 0) = 0
+   distance_to_ancestor (A, B, 0) = 1
+   distance_to_ancestor (A, C, 0) = 2
+   distance_to_ancestor (A, D, 0) = 3
+
+   If PUBLIC is 1 then only public ancestors are considered,
+   and the function returns the distance only if BASE is a public ancestor
+   of DCLASS.
+   Eg:
+
+   distance_to_ancestor (A, D, 1) = -1.  */
 
 static int
-do_is_ancestor (struct type *base, struct type *dclass, int public)
+distance_to_ancestor (struct type *base, struct type *dclass, int public)
 {
   int i;
+  int d;
 
   CHECK_TYPEDEF (base);
   CHECK_TYPEDEF (dclass);
 
   if (class_types_same_p (base, dclass))
-    return 1;
+    return 0;
 
   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
     {
       if (public && ! BASETYPE_VIA_PUBLIC (dclass, i))
        continue;
 
-      if (do_is_ancestor (base, TYPE_BASECLASS (dclass, i), public))
-       return 1;
+      d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public);
+      if (d >= 0)
+       return 1 + d;
     }
 
-  return 0;
+  return -1;
 }
 
 /* Check whether BASE is an ancestor or base class or DCLASS
@@ -2004,7 +2187,7 @@ do_is_ancestor (struct type *base, struct type *dclass, int public)
 int
 is_ancestor (struct type *base, struct type *dclass)
 {
-  return do_is_ancestor (base, dclass, 0);
+  return distance_to_ancestor (base, dclass, 0) >= 0;
 }
 
 /* Like is_ancestor, but only returns true when BASE is a public
@@ -2013,7 +2196,7 @@ is_ancestor (struct type *base, struct type *dclass)
 int
 is_public_ancestor (struct type *base, struct type *dclass)
 {
-  return do_is_ancestor (base, dclass, 1);
+  return distance_to_ancestor (base, dclass, 1) >= 0;
 }
 
 /* A helper function for is_unique_ancestor.  */
@@ -2021,7 +2204,8 @@ is_public_ancestor (struct type *base, struct type *dclass)
 static int
 is_unique_ancestor_worker (struct type *base, struct type *dclass,
                           int *offset,
-                          const bfd_byte *contents, CORE_ADDR address)
+                          const gdb_byte *valaddr, int embedded_offset,
+                          CORE_ADDR address, struct value *val)
 {
   int i, count = 0;
 
@@ -2030,11 +2214,13 @@ is_unique_ancestor_worker (struct type *base, struct type *dclass,
 
   for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
     {
-      struct type *iter = check_typedef (TYPE_BASECLASS (dclass, i));
-      int this_offset = baseclass_offset (dclass, i, contents, address);
+      struct type *iter;
+      int this_offset;
 
-      if (this_offset == -1)
-       error (_("virtual baseclass botch"));
+      iter = check_typedef (TYPE_BASECLASS (dclass, i));
+
+      this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
+                                     address, val);
 
       if (class_types_same_p (base, iter))
        {
@@ -2056,8 +2242,9 @@ is_unique_ancestor_worker (struct type *base, struct type *dclass,
        }
       else
        count += is_unique_ancestor_worker (base, iter, offset,
-                                           contents + this_offset,
-                                           address + this_offset);
+                                           valaddr,
+                                           embedded_offset + this_offset,
+                                           address, val);
     }
 
   return count;
@@ -2072,11 +2259,13 @@ is_unique_ancestor (struct type *base, struct value *val)
   int offset = -1;
 
   return is_unique_ancestor_worker (base, value_type (val), &offset,
-                                   value_contents (val),
-                                   value_address (val)) == 1;
+                                   value_contents_for_printing (val),
+                                   value_embedded_offset (val),
+                                   value_address (val), val) == 1;
 }
 
 \f
+/* Overload resolution.  */
 
 /* Return the sum of the rank of A with the rank of B.  */
 
@@ -2085,6 +2274,7 @@ sum_ranks (struct rank a, struct rank b)
 {
   struct rank c;
   c.rank = a.rank + b.rank;
+  c.subrank = a.subrank + b.subrank;
   return c;
 }
 
@@ -2097,15 +2287,23 @@ int
 compare_ranks (struct rank a, struct rank b)
 {
   if (a.rank == b.rank)
-    return 0;
+    {
+      if (a.subrank == b.subrank)
+       return 0;
+      if (a.subrank < b.subrank)
+       return 1;
+      if (a.subrank > b.subrank)
+       return -1;
+    }
 
   if (a.rank < b.rank)
     return 1;
 
+  /* a.rank > b.rank */
   return -1;
 }
 
-/* Functions for overload resolution begin here */
+/* Functions for overload resolution begin here */
 
 /* Compare two badness vectors A and B and return the result.
    0 => A and B are identical
@@ -2159,14 +2357,14 @@ compare_badness (struct badness_vector *a, struct badness_vector *b)
 
 struct badness_vector *
 rank_function (struct type **parms, int nparms, 
-              struct type **args, int nargs)
+              struct value **args, int nargs)
 {
   int i;
   struct badness_vector *bv;
   int min_len = nparms < nargs ? nparms : nargs;
 
   bv = xmalloc (sizeof (struct badness_vector));
-  bv->length = nargs + 1;      /* add 1 for the length-match rank */
+  bv->length = nargs + 1;      /* add 1 for the length-match rank */
   bv->rank = xmalloc ((nargs + 1) * sizeof (int));
 
   /* First compare the lengths of the supplied lists.
@@ -2180,11 +2378,12 @@ rank_function (struct type **parms, int nparms,
                      ? LENGTH_MISMATCH_BADNESS
                      : EXACT_MATCH_BADNESS;
 
-  /* Now rank all the parameters of the candidate function */
+  /* 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], value_type (args[i - 1]),
+                                args[i - 1]);
 
-  /* If more arguments than parameters, add dummy entries */
+  /* If more arguments than parameters, add dummy entries */
   for (i = min_len + 1; i <= nargs; i++)
     bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
 
@@ -2232,7 +2431,7 @@ integer_types_same_name_p (const char *first, const char *second)
 /* Compares type A to type B returns 1 if the represent the same type
    0 otherwise.  */
 
-static int
+int
 types_equal (struct type *a, struct type *b)
 {
   /* Identical type pointers.  */
@@ -2261,12 +2460,10 @@ types_equal (struct type *a, struct type *b)
     return types_equal (TYPE_TARGET_TYPE (a),
                         TYPE_TARGET_TYPE (b));
 
-  /*
-     Well, damnit, if the names are exactly the same, I'll say they
+  /* 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.
-  */
+     really are the same.  */
 
   if (TYPE_NAME (a) && TYPE_NAME (b)
       && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
@@ -2276,6 +2473,25 @@ types_equal (struct type *a, struct type *b)
   if (a == b)
     return 1;
 
+  /* Two function types are equal if their argument and return types
+     are equal.  */
+  if (TYPE_CODE (a) == TYPE_CODE_FUNC)
+    {
+      int i;
+
+      if (TYPE_NFIELDS (a) != TYPE_NFIELDS (b))
+       return 0;
+      
+      if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b)))
+       return 0;
+
+      for (i = 0; i < TYPE_NFIELDS (a); ++i)
+       if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i)))
+         return 0;
+
+      return 1;
+    }
+
   return 0;
 }
 
@@ -2283,6 +2499,7 @@ types_equal (struct type *a, struct type *b)
  * PARM is intended to be the parameter type of a function; and
  * ARG is the supplied argument's type.  This function tests if
  * the latter can be converted to the former.
+ * VALUE is the argument's value or NULL if none (or called recursively)
  *
  * Return 0 if they are identical types;
  * Otherwise, return an integer which corresponds to how compatible
@@ -2290,8 +2507,9 @@ types_equal (struct type *a, struct type *b)
  * Generally the "bad" conversions are all uniformly assigned a 100.  */
 
 struct rank
-rank_one_type (struct type *parm, struct type *arg)
+rank_one_type (struct type *parm, struct type *arg, struct value *value)
 {
+  struct rank rank = {0,0};
 
   if (types_equal (parm, arg))
     return EXACT_MATCH_BADNESS;
@@ -2305,10 +2523,10 @@ rank_one_type (struct type *parm, struct type *arg)
   /* See through references, since we can almost make non-references
      references.  */
   if (TYPE_CODE (arg) == TYPE_CODE_REF)
-    return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg)),
+    return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
                        REFERENCE_CONVERSION_BADNESS));
   if (TYPE_CODE (parm) == TYPE_CODE_REF)
-    return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg),
+    return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
                        REFERENCE_CONVERSION_BADNESS));
   if (overload_debug)
   /* Debugging only.  */
@@ -2317,7 +2535,7 @@ rank_one_type (struct type *parm, struct type *arg)
                      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 */
 
   switch (TYPE_CODE (parm))
     {
@@ -2332,9 +2550,11 @@ rank_one_type (struct type *parm, struct type *arg)
            return VOID_PTR_CONVERSION_BADNESS;
 
          /* (b) pointer to ancestor-pointer conversion.  */
-         if (is_ancestor (TYPE_TARGET_TYPE (parm),
-                                 TYPE_TARGET_TYPE (arg)))
-           return BASE_PTR_CONVERSION_BADNESS;
+         rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
+                                              TYPE_TARGET_TYPE (arg),
+                                              0);
+         if (rank.subrank >= 0)
+           return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
 
          return INCOMPATIBLE_TYPE_BADNESS;
        case TYPE_CODE_ARRAY:
@@ -2343,8 +2563,24 @@ rank_one_type (struct type *parm, struct type *arg)
            return EXACT_MATCH_BADNESS;
          return INCOMPATIBLE_TYPE_BADNESS;
        case TYPE_CODE_FUNC:
-         return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
+         return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
        case TYPE_CODE_INT:
+         if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT)
+           {
+             if (value_as_long (value) == 0)
+               {
+                 /* Null pointer conversion: allow it to be cast to a pointer.
+                    [4.10.1 of C++ standard draft n3290]  */
+                 return NULL_POINTER_CONVERSION_BADNESS;
+               }
+             else
+               {
+                 /* If type checking is disabled, allow the conversion.  */
+                 if (!strict_type_checking)
+                   return NS_INTEGER_POINTER_CONVERSION_BADNESS;
+               }
+           }
+         /* fall through  */
        case TYPE_CODE_ENUM:
        case TYPE_CODE_FLAGS:
        case TYPE_CODE_CHAR:
@@ -2359,7 +2595,7 @@ rank_one_type (struct type *parm, struct type *arg)
        case TYPE_CODE_PTR:
        case TYPE_CODE_ARRAY:
          return rank_one_type (TYPE_TARGET_TYPE (parm), 
-                               TYPE_TARGET_TYPE (arg));
+                               TYPE_TARGET_TYPE (arg), NULL);
        default:
          return INCOMPATIBLE_TYPE_BADNESS;
        }
@@ -2367,7 +2603,7 @@ rank_one_type (struct type *parm, struct type *arg)
       switch (TYPE_CODE (arg))
        {
        case TYPE_CODE_PTR:     /* funcptr -> func */
-         return rank_one_type (parm, TYPE_TARGET_TYPE (arg));
+         return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
        default:
          return INCOMPATIBLE_TYPE_BADNESS;
        }
@@ -2381,7 +2617,7 @@ rank_one_type (struct type *parm, struct type *arg)
                 signed and unsigned ints.  */
              if (TYPE_NOSIGN (parm))
                {
-                 /* This case only for character types */
+                 /* This case only for character types */
                  if (TYPE_NOSIGN (arg))
                    return EXACT_MATCH_BADNESS; /* plain char -> plain char */
                  else          /* signed/unsigned char -> plain char */
@@ -2400,9 +2636,11 @@ rank_one_type (struct type *parm, struct type *arg)
                                                          "int")
                               && integer_types_same_name_p (TYPE_NAME (parm),
                                                             "long"))
-                       return INTEGER_PROMOTION_BADNESS;       /* unsigned int -> unsigned long */
+                       /* unsigned int -> unsigned long */
+                       return INTEGER_PROMOTION_BADNESS;
                      else
-                       return INTEGER_CONVERSION_BADNESS;      /* unsigned long -> unsigned int */
+                       /* unsigned long -> unsigned int */
+                       return INTEGER_CONVERSION_BADNESS;
                    }
                  else
                    {
@@ -2410,9 +2648,11 @@ rank_one_type (struct type *parm, struct type *arg)
                                                     "long")
                          && integer_types_same_name_p (TYPE_NAME (parm), 
                                                        "int"))
-                       return INTEGER_CONVERSION_BADNESS;      /* signed long -> unsigned int */
+                       /* signed long -> unsigned int */
+                       return INTEGER_CONVERSION_BADNESS;
                      else
-                       return INTEGER_CONVERSION_BADNESS;      /* signed int/long -> unsigned int/long */
+                       /* signed int/long -> unsigned int/long */
+                       return INTEGER_CONVERSION_BADNESS;
                    }
                }
              else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
@@ -2522,14 +2762,23 @@ rank_one_type (struct type *parm, struct type *arg)
     case TYPE_CODE_BOOL:
       switch (TYPE_CODE (arg))
        {
+         /* n3290 draft, section 4.12.1 (conv.bool):
+
+            "A prvalue of arithmetic, unscoped enumeration, pointer, or
+            pointer to member type can be converted to a prvalue of type
+            bool.  A zero value, null pointer value, or null member pointer
+            value is converted to false; any other value is converted to
+            true.  A prvalue of type std::nullptr_t can be converted to a
+            prvalue of type bool; the resulting value is false."  */
        case TYPE_CODE_INT:
        case TYPE_CODE_CHAR:
-       case TYPE_CODE_RANGE:
        case TYPE_CODE_ENUM:
        case TYPE_CODE_FLT:
-         return INCOMPATIBLE_TYPE_BADNESS;
+       case TYPE_CODE_MEMBERPTR:
        case TYPE_CODE_PTR:
-         return BOOL_PTR_CONVERSION_BADNESS;
+         return BOOL_CONVERSION_BADNESS;
+       case TYPE_CODE_RANGE:
+         return INCOMPATIBLE_TYPE_BADNESS;
        case TYPE_CODE_BOOL:
          return EXACT_MATCH_BADNESS;
        default:
@@ -2568,13 +2817,14 @@ rank_one_type (struct type *parm, struct type *arg)
        }
       break;
     case TYPE_CODE_STRUCT:
-      /* currently same as TYPE_CODE_CLASS */
+      /* currently same as TYPE_CODE_CLASS */
       switch (TYPE_CODE (arg))
        {
        case TYPE_CODE_STRUCT:
          /* Check for derivation */
-         if (is_ancestor (parm, arg))
-           return BASE_CONVERSION_BADNESS;
+         rank.subrank = distance_to_ancestor (parm, arg, 0);
+         if (rank.subrank >= 0)
+           return sum_ranks (BASE_CONVERSION_BADNESS, rank);
          /* else fall through */
        default:
          return INCOMPATIBLE_TYPE_BADNESS;
@@ -2618,7 +2868,7 @@ rank_one_type (struct type *parm, struct type *arg)
          /* Not in C++ */
        case TYPE_CODE_SET:
          return rank_one_type (TYPE_FIELD_TYPE (parm, 0), 
-                               TYPE_FIELD_TYPE (arg, 0));
+                               TYPE_FIELD_TYPE (arg, 0), NULL);
        default:
          return INCOMPATIBLE_TYPE_BADNESS;
        }
@@ -2629,8 +2879,9 @@ rank_one_type (struct type *parm, struct type *arg)
     }                          /* switch (TYPE_CODE (arg)) */
 }
 
-
-/* End of functions for overload resolution */
+/* End of functions for overload resolution.  */
+\f
+/* Routines to pretty-print types.  */
 
 static void
 print_bit_vector (B_TYPE *bits, int nbits)
@@ -2753,8 +3004,6 @@ print_cplus_stuff (struct type *type, int spaces)
                    TYPE_N_BASECLASSES (type));
   printfi_filtered (spaces, "nfn_fields %d\n",
                    TYPE_NFN_FIELDS (type));
-  printfi_filtered (spaces, "nfn_fields_total %d\n",
-                   TYPE_NFN_FIELDS_TOTAL (type));
   if (TYPE_N_BASECLASSES (type) > 0)
     {
       printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
@@ -2900,9 +3149,6 @@ recursive_dump_type (struct type *type, int spaces)
     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;
@@ -2992,6 +3238,10 @@ recursive_dump_type (struct type *type, int spaces)
     {
       puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
     }
+  if (TYPE_RESTRICT (type))
+    {
+      puts_filtered (" TYPE_FLAG_RESTRICT");
+    }
   puts_filtered ("\n");
 
   printfi_filtered (spaces, "flags");
@@ -3052,10 +3302,15 @@ recursive_dump_type (struct type *type, int spaces)
   puts_filtered ("\n");
   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
     {
-      printfi_filtered (spaces + 2,
-                       "[%d] bitpos %d bitsize %d type ",
-                       idx, TYPE_FIELD_BITPOS (type, idx),
-                       TYPE_FIELD_BITSIZE (type, idx));
+      if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+       printfi_filtered (spaces + 2,
+                         "[%d] enumval %s type ",
+                         idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
+      else
+       printfi_filtered (spaces + 2,
+                         "[%d] bitpos %d bitsize %d type ",
+                         idx, TYPE_FIELD_BITPOS (type, idx),
+                         TYPE_FIELD_BITSIZE (type, idx));
       gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
       printf_filtered (" name '%s' (",
                       TYPE_FIELD_NAME (type, idx) != NULL
@@ -3074,7 +3329,8 @@ recursive_dump_type (struct type *type, int spaces)
                        plongest (TYPE_LOW_BOUND (type)), 
                        TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
                        plongest (TYPE_HIGH_BOUND (type)),
-                       TYPE_HIGH_BOUND_UNDEFINED (type) ? " (undefined)" : "");
+                       TYPE_HIGH_BOUND_UNDEFINED (type) 
+                       ? " (undefined)" : "");
     }
   printfi_filtered (spaces, "vptr_basetype ");
   gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
@@ -3128,16 +3384,17 @@ recursive_dump_type (struct type *type, int spaces)
        puts_filtered ("\n");
        break;
 
-      case TYPE_SPECIFIC_CALLING_CONVENTION:
+      case TYPE_SPECIFIC_FUNC:
        printfi_filtered (spaces, "calling_convention %d\n",
                           TYPE_CALLING_CONVENTION (type));
+       /* tail_call_list is not printed.  */
        break;
     }
 
   if (spaces == 0)
     obstack_free (&dont_print_type_obstack, NULL);
 }
-
+\f
 /* Trivial helpers for the libiberty hash table, for mapping one
    type to another.  */
 
@@ -3205,7 +3462,8 @@ copy_type_recursive (struct objfile *objfile,
 
   /* We must add the new type to the hash table immediately, in case
      we encounter this type again during a recursive call below.  */
-  stored = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
+  stored
+    = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
   stored->old = type;
   stored->new = new_type;
   *slot = stored;
@@ -3249,6 +3507,10 @@ copy_type_recursive (struct objfile *objfile,
              SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
                                TYPE_FIELD_BITPOS (type, i));
              break;
+           case FIELD_LOC_KIND_ENUMVAL:
+             SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
+                                TYPE_FIELD_ENUMVAL (type, i));
+             break;
            case FIELD_LOC_KIND_PHYSADDR:
              SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
                                  TYPE_FIELD_STATIC_PHYSADDR (type, i));
@@ -3266,7 +3528,7 @@ copy_type_recursive (struct objfile *objfile,
        }
     }
 
-  /* For range types, copy the bounds information. */
+  /* For range types, copy the bounds information.  */
   if (TYPE_CODE (type) == TYPE_CODE_RANGE)
     {
       TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
@@ -3321,12 +3583,12 @@ copy_type (const struct type *type)
 
   return new_type;
 }
-
-
+\f
 /* Helper functions to initialize architecture-specific types.  */
 
 /* Allocate a type structure associated with GDBARCH and set its
    CODE, LENGTH, and NAME fields.  */
+
 struct type *
 arch_type (struct gdbarch *gdbarch,
           enum type_code code, int length, char *name)
@@ -3346,6 +3608,7 @@ arch_type (struct gdbarch *gdbarch,
 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
+
 struct type *
 arch_integer_type (struct gdbarch *gdbarch,
                   int bit, int unsigned_p, char *name)
@@ -3364,6 +3627,7 @@ arch_integer_type (struct gdbarch *gdbarch,
 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
+
 struct type *
 arch_character_type (struct gdbarch *gdbarch,
                     int bit, int unsigned_p, char *name)
@@ -3380,6 +3644,7 @@ arch_character_type (struct gdbarch *gdbarch,
 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
    BIT is the type size in bits.  If UNSIGNED_P is non-zero, set
    the type's TYPE_UNSIGNED flag.  NAME is the type name.  */
+
 struct type *
 arch_boolean_type (struct gdbarch *gdbarch,
                   int bit, int unsigned_p, char *name)
@@ -3397,6 +3662,7 @@ arch_boolean_type (struct gdbarch *gdbarch,
    BIT is the type size in bits; if BIT equals -1, the size is
    determined by the floatformat.  NAME is the type name.  Set the
    TYPE_FLOATFORMAT from FLOATFORMATS.  */
+
 struct type *
 arch_float_type (struct gdbarch *gdbarch,
                 int bit, char *name, const struct floatformat **floatformats)
@@ -3418,6 +3684,7 @@ arch_float_type (struct gdbarch *gdbarch,
 
 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
    NAME is the type name.  TARGET_TYPE is the component float type.  */
+
 struct type *
 arch_complex_type (struct gdbarch *gdbarch,
                   char *name, struct type *target_type)
@@ -3432,6 +3699,7 @@ arch_complex_type (struct gdbarch *gdbarch,
 
 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
    NAME is the type name.  LENGTH is the size of the flag word in bytes.  */
+
 struct type *
 arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
 {
@@ -3448,6 +3716,7 @@ arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
 
 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
    position BITPOS is called NAME.  */
+
 void
 append_flags_type_flag (struct type *type, int bitpos, char *name)
 {
@@ -3458,17 +3727,18 @@ append_flags_type_flag (struct type *type, int bitpos, char *name)
   if (name)
     {
       TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
-      TYPE_FIELD_BITPOS (type, bitpos) = bitpos;
+      SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos);
     }
   else
     {
       /* Don't show this field to the user.  */
-      TYPE_FIELD_BITPOS (type, bitpos) = -1;
+      SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1);
     }
 }
 
 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
    specified by CODE) associated with GDBARCH.  NAME is the type name.  */
+
 struct type *
 arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
 {
@@ -3484,6 +3754,7 @@ arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
 /* Add new field with name NAME and type FIELD to composite type T.
    Do not set the field's position or adjust the type's length;
    the caller should do so.  Return the new field.  */
+
 struct field *
 append_composite_type_field_raw (struct type *t, char *name,
                                 struct type *field)
@@ -3502,6 +3773,7 @@ append_composite_type_field_raw (struct type *t, char *name,
 
 /* Add new field with name NAME and type FIELD to composite type T.
    ALIGNMENT (if non-zero) specifies the minimum field alignment.  */
+
 void
 append_composite_type_field_aligned (struct type *t, char *name,
                                     struct type *field, int alignment)
@@ -3518,18 +3790,22 @@ append_composite_type_field_aligned (struct type *t, char *name,
       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_TYPE (f[-1]))
-                                   * TARGET_CHAR_BIT));
+         SET_FIELD_BITPOS (f[0],
+                           (FIELD_BITPOS (f[-1])
+                            + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
+                               * TARGET_CHAR_BIT)));
 
          if (alignment)
            {
-             int left = FIELD_BITPOS (f[0]) % (alignment * TARGET_CHAR_BIT);
+             int left;
+
+             alignment *= TARGET_CHAR_BIT;
+             left = FIELD_BITPOS (f[0]) % alignment;
 
              if (left)
                {
-                 FIELD_BITPOS (f[0]) += left;
-                 TYPE_LENGTH (t) += left / TARGET_CHAR_BIT;
+                 SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
+                 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
                }
            }
        }
@@ -3537,6 +3813,7 @@ append_composite_type_field_aligned (struct type *t, char *name,
 }
 
 /* Add new field with name NAME and type FIELD to composite type T.  */
+
 void
 append_composite_type_field (struct type *t, char *name,
                             struct type *field)
@@ -3544,7 +3821,6 @@ append_composite_type_field (struct type *t, char *name,
   append_composite_type_field_aligned (t, name, field, 0);
 }
 
-
 static struct gdbarch_data *gdbtypes_data;
 
 const struct builtin_type *
@@ -3670,6 +3946,8 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
     = lookup_pointer_type (builtin_type->builtin_void);
   builtin_type->builtin_func_ptr
     = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
+  builtin_type->builtin_func_func
+    = lookup_function_type (builtin_type->builtin_func_ptr);
 
   /* This type represents a GDB internal function.  */
   builtin_type->internal_fn
@@ -3679,7 +3957,6 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
   return builtin_type;
 }
 
-
 /* This set of objfile-based types is intended to be used by symbol
    readers as basic types.  */
 
@@ -3783,6 +4060,18 @@ objfile_type (struct objfile *objfile)
                 "<text variable, no debug info>", objfile);
   TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
     = objfile_type->builtin_int;
+  objfile_type->nodebug_text_gnu_ifunc_symbol
+    = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC,
+                "<text gnu-indirect-function variable, no debug info>",
+                objfile);
+  TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
+    = objfile_type->nodebug_text_symbol;
+  objfile_type->nodebug_got_plt_symbol
+    = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0,
+                "<text from jump slot in .got.plt, no debug info>",
+                objfile);
+  TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol)
+    = objfile_type->nodebug_text_symbol;
   objfile_type->nodebug_data_symbol
     = init_type (TYPE_CODE_INT,
                 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
@@ -3796,9 +4085,7 @@ objfile_type (struct objfile *objfile)
                 "<thread local variable, no debug info>", objfile);
 
   /* 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 same.
 
      The upshot is:
      - gdb's `struct type' always describes the target's
@@ -3811,12 +4098,6 @@ objfile_type (struct objfile *objfile)
        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, objfile_type->builtin_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
@@ -3831,28 +4112,40 @@ objfile_type (struct objfile *objfile)
   return objfile_type;
 }
 
+extern initialize_file_ftype _initialize_gdbtypes;
 
-extern void _initialize_gdbtypes (void);
 void
 _initialize_gdbtypes (void)
 {
   gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
   objfile_type_data = register_objfile_data ();
 
-  add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, _("\
-Set debugging of C++ overloading."), _("\
-Show debugging of C++ overloading."), _("\
-When enabled, ranking of the functions is displayed."),
-                           NULL,
-                           show_overload_debug,
-                           &setdebuglist, &showdebuglist);
+  add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug,
+                            _("Set debugging of C++ overloading."),
+                            _("Show debugging of C++ overloading."),
+                            _("When enabled, ranking of the "
+                              "functions is displayed."),
+                            NULL,
+                            show_overload_debug,
+                            &setdebuglist, &showdebuglist);
 
   /* Add user knob for controlling resolution of opaque types.  */
   add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
-                          &opaque_type_resolution, _("\
-Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\
-Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL,
-                          NULL,
+                          &opaque_type_resolution,
+                          _("Set resolution of opaque struct/class/union"
+                            " types (if set before loading symbols)."),
+                          _("Show resolution of opaque struct/class/union"
+                            " types (if set before loading symbols)."),
+                          NULL, NULL,
                           show_opaque_type_resolution,
                           &setlist, &showlist);
+
+  /* Add an option to permit non-strict type checking.  */
+  add_setshow_boolean_cmd ("type", class_support,
+                          &strict_type_checking,
+                          _("Set strict type checking."),
+                          _("Show strict type checking."),
+                          NULL, NULL,
+                          show_strict_type_checking,
+                          &setchecklist, &showchecklist);
 }
This page took 0.084263 seconds and 4 git commands to generate.