Merge GDB 7.5.1

gdb/gdbtypes.c

 /* Support routines for manipulating internal types for GDB.
 
    Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
 
    Contributed by Cygnus Support, using pieces from other GDB modules.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ skipping 15 matching lines @@
 #include "symfile.h"
 #include "objfiles.h"
 #include "gdbtypes.h"
 #include "expression.h"
 #include "language.h"
 #include "target.h"
 #include "value.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"
 
 /* Initialize BADNESS constants.  */
 
 const struct rank LENGTH_MISMATCH_BADNESS = {100,0};
 
 const struct rank TOO_FEW_PARAMS_BADNESS = {100,0};
 const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0};
 
 const struct rank EXACT_MATCH_BADNESS = {0,0};
 
@@ skipping 405 matching lines @@
 
 /* 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.  */
 
 struct type *
 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
 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
 {
   int type_flags;
 
   /* Check for known address space delimiters.  */
   if (!strcmp (space_identifier, "code"))
     return TYPE_INSTANCE_FLAG_CODE_SPACE;
@@ skipping 293 matching lines @@
       *lowp = TYPE_LOW_BOUND (type);
       *highp = TYPE_HIGH_BOUND (type);
       return 1;
     case TYPE_CODE_ENUM:
       if (TYPE_NFIELDS (type) > 0)
         {
           /* The enums may not be sorted by value, so search all
              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.  */
           if (*lowp >= 0)
             {
               TYPE_UNSIGNED (type) = 1;
             }
         }
       else
         {
@@ skipping 290 matching lines @@
   TYPE_NFIELDS (type) = nargs;
   if (varargs)
     TYPE_VARARGS (type) = 1;
   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
   TYPE_CODE (type) = TYPE_CODE_METHOD;
 }
 
 /* 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)
     return TYPE_TAG_NAME (type);
 
   /* Is there code which expects this to return the name if there is
      no tag name?  My guess is that this is mainly used for C++ in
      cases where the two will always be the same.  */
   return TYPE_NAME (type);
 }
@@ skipping 27 matching lines @@
 /* 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, 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);
 
   strcpy (uns, "unsigned ");
   strcpy (uns + 9, name);
   return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
 }
 
 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);
 
   strcpy (uns, "signed ");
   strcpy (uns + 7, name);
   t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
   /* If we don't find "signed FOO" just try again with plain "FOO".  */
   if (t != NULL)
     return t;
@@ skipping 142 matching lines @@
     char *typename;
 
     typename = type_name_no_tag (type);
     if (typename != NULL && strcmp (typename, name) == 0)
       return type;
   }
 #endif
 
   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))
         {
           return TYPE_FIELD_TYPE (type, i);
         }
      else if (!t_field_name || *t_field_name == '\0')
         {
           struct type *subtype 
             = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
 
@@ skipping 121 matching lines @@
   /* While we're removing typedefs, we don't want to lose qualifiers.
      E.g., const/volatile.  */
   int instance_flags = TYPE_INSTANCE_FLAGS (type);
 
   gdb_assert (type);
 
   while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
     {
       if (!TYPE_TARGET_TYPE (type))
         {
-          char *name;
+          const char *name;
           struct symbol *sym;
 
           /* It is dangerous to call lookup_symbol if we are currently
              reading a symtab.  Infinite recursion is one danger.  */
           if (currently_reading_symtab)
             return make_qualified_type (type, instance_flags, NULL);
 
           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
@@ skipping 42 matching lines @@
   /* 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 identifying them as stub types in the first
      place.  */
 
   if (TYPE_IS_OPAQUE (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)
         {
           stub_noname_complaint ();
           return make_qualified_type (type, instance_flags, NULL);
         }
       newtype = lookup_transparent_type (name);
 
       if (newtype)
@@ skipping 13 matching lines @@
                                         TYPE_INSTANCE_FLAGS (type),
                                         type);
           else
             type = newtype;
         }
     }
   /* Otherwise, rely on the stub flag being set for opaque/stubbed
      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
          TYPE_TAG_NAME were separate).  */
       struct symbol *sym;
 
       if (name == NULL)
         {
           stub_noname_complaint ();
           return make_qualified_type (type, instance_flags, NULL);
@@ skipping 76 matching lines @@
   return type;
 }
 
 /* Parse a type expression in the string [P..P+LENGTH).  If an error
    occurs, silently return a void type.  */
 
 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.  */
   ui_file_delete (gdb_stderr);
   gdb_stderr = saved_gdb_stderr;
 
   return type;
 }
 
 /* Ugly hack to convert method stubs into method types.
@@ skipping 1189 matching lines @@
                             TYPE_FN_FIELD_STUB (f, overload_idx));
           printfi_filtered (spaces + 8, "voffset %u\n",
                             TYPE_FN_FIELD_VOFFSET (f, overload_idx));
         }
     }
 }
 
 static void
 print_cplus_stuff (struct type *type, int spaces)
 {