Merge GDB 7.5.1

gdb/gdbtypes.h

 /* Internal type definitions for GDB.
 
    Copyright (C) 1992-2004, 2006-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 12 matching lines @@
 #define GDBTYPES_H 1
 
 #include "hashtab.h"
 
 /* Forward declarations for prototypes.  */
 struct field;
 struct block;
 struct value_print_options;
 struct language_defn;
 
+/* These declarations are DWARF-specific as some of the gdbtypes.h data types
+   are already DWARF-specific.  */
+
+/* Offset relative to the start of its containing CU (compilation unit).  */
+typedef struct
+{
+  unsigned int cu_off;
+} cu_offset;
+
+/* Offset relative to the start of its .debug_info or .debug_types section.  */
+typedef struct
+{
+  unsigned int sect_off;
+} sect_offset;
+
 /* Some macros for char-based bitfields.  */
 
 #define B_SET(a,x)      ((a)[(x)>>3] |= (1 << ((x)&7)))
 #define B_CLR(a,x)      ((a)[(x)>>3] &= ~(1 << ((x)&7)))
 #define B_TST(a,x)      ((a)[(x)>>3] & (1 << ((x)&7)))
 #define B_TYPE          unsigned char
 #define B_BYTES(x)      ( 1 + ((x)>>3) )
 #define B_CLRALL(a,x)   memset ((a), 0, B_BYTES(x))
 
 /* Different kinds of data types are distinguished by the `code' field.  */
@@ skipping 240 matching lines @@
 #define TYPE_OBJFILE_OWNED(t) (TYPE_MAIN_TYPE (t)->flag_objfile_owned)
 #define TYPE_OWNER(t) TYPE_MAIN_TYPE(t)->owner
 #define TYPE_OBJFILE(t) (TYPE_OBJFILE_OWNED(t)? TYPE_OWNER(t).objfile : NULL)
 
 /* True if this type was declared using the "class" keyword.  This is
    only valid for C++ structure types, and only used for displaying
    the type.  If false, the structure was declared as a "struct".  */
 
 #define TYPE_DECLARED_CLASS(t) (TYPE_MAIN_TYPE (t)->flag_declared_class)
 
+/* True if this type is a "flag" enum.  A flag enum is one where all
+   the values are pairwise disjoint when "and"ed together.  This
+   affects how enum values are printed.  */
+
+#define TYPE_FLAG_ENUM(t) (TYPE_MAIN_TYPE (t)->flag_flag_enum)
+
 /* Constant type.  If this is set, the corresponding type has a
    const modifier.  */
 
 #define TYPE_CONST(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CONST)
 
 /* Volatile type.  If this is set, the corresponding type has a
    volatile modifier.  */
 
 #define TYPE_VOLATILE(t) \
   (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_VOLATILE)
@@ skipping 35 matching lines @@
 #define TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL \
   (TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2)
 #define TYPE_ADDRESS_CLASS_ALL(t) (TYPE_INSTANCE_FLAGS(t) \
                                    & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
 
 /* Determine which field of the union main_type.fields[x].loc is used.  */
 
 enum field_loc_kind
   {
     FIELD_LOC_KIND_BITPOS,      /* bitpos */
+    FIELD_LOC_KIND_ENUMVAL,     /* enumval */
     FIELD_LOC_KIND_PHYSADDR,    /* physaddr */
     FIELD_LOC_KIND_PHYSNAME,    /* physname */
     FIELD_LOC_KIND_DWARF_BLOCK  /* dwarf_block */
   };
 
 /* A discriminant to determine which field in the main_type.type_specific
    union is being used, if any.
 
    For types such as TYPE_CODE_FLT or TYPE_CODE_FUNC, the use of this
    discriminant is really redundant, as we know from the type code
@@ skipping 35 matching lines @@
   unsigned int flag_varargs : 1;
   unsigned int flag_vector : 1;
   unsigned int flag_stub_supported : 1;
   unsigned int flag_gnu_ifunc : 1;
   unsigned int flag_fixed_instance : 1;
   unsigned int flag_objfile_owned : 1;
   /* True if this type was declared with "class" rather than
      "struct".  */
   unsigned int flag_declared_class : 1;
 
+  /* True if this is an enum type with disjoint values.  This affects
+     how the enum is printed.  */
+
+  unsigned int flag_flag_enum : 1;
+
   /* A discriminant telling us which field of the type_specific union
      is being used for this type, if any.  */
   ENUM_BITFIELD(type_specific_kind) type_specific_field : 3;
 
   /* Number of fields described for this type.  This field appears at
      this location because it packs nicely here.  */
 
   short nfields;
 
   /* Field number of the virtual function table pointer in
      VPTR_BASETYPE.  If -1, we were unable to find the virtual
      function table pointer in initial symbol reading, and
      get_vptr_fieldno should be called to find it if possible.
      get_vptr_fieldno will update this field if possible.
      Otherwise the value is left at -1.
 
      Unused if this type does not have virtual functions.
 
      This field appears at this location because it packs nicely here.  */
 
   short vptr_fieldno;
 
   /* Name of this type, or NULL if none.
 
      This is used for printing only, except by poorly designed C++ code.
-     For looking up a name, look for a symbol in the VAR_DOMAIN.  */
+     For looking up a name, look for a symbol in the VAR_DOMAIN.
+     This is generally allocated in the objfile's obstack.
+     However coffread.c uses malloc.  */
 
-  char *name;
+  const char *name;
 
   /* Tag name for this type, or NULL if none.  This means that the
      name of the type consists of a keyword followed by the tag name.
      Which keyword is determined by the type code ("struct" for
      TYPE_CODE_STRUCT, etc.).  As far as I know C/C++ are the only languages
      with this feature.
 
      This is used for printing only, except by poorly designed C++ code.
      For looking up a name, look for a symbol in the STRUCT_DOMAIN.
      One more legitimate use is that if TYPE_FLAG_STUB is set, this is
      the name to use to look for definitions in other files.  */
 
-  char *tag_name;
+  const char *tag_name;
 
   /* Every type is now associated with a particular objfile, and the
      type is allocated on the objfile_obstack for that objfile.  One problem
      however, is that there are times when gdb allocates new types while
      it is not in the process of reading symbols from a particular objfile.
      Fortunately, these happen when the type being created is a derived
      type of an existing type, such as in lookup_pointer_type().  So
      we can just allocate the new type using the same objfile as the
      existing type, but to do this we need a backpointer to the objfile
      from the existing type.  Yes this is somewhat ugly, but without
@@ skipping 37 matching lines @@
   union 
   {
     struct field
     {
       union field_location
       {
         /* Position of this field, counting in bits from start of
            containing structure.  For gdbarch_bits_big_endian=1
            targets, it is the bit offset to the MSB.  For
            gdbarch_bits_big_endian=0 targets, it is the bit offset to
-           the LSB.  For a range bound or enum value, this is the
-           value itself.  */
+           the LSB.  */
 
         int bitpos;
 
+        /* Enum value.  */
+        LONGEST enumval;
+
         /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr
            is the location (in the target) of the static field.
            Otherwise, physname is the mangled label of the static field.  */
 
         CORE_ADDR physaddr;
         const char *physname;
 
         /* The field location can be computed by evaluating the following DWARF
            block.  Its DATA is allocated on objfile_obstack - no CU load is
            needed to access it.  */
 
         struct dwarf2_locexpr_baton *dwarf_block;
       }
       loc;
 
       /* For a function or member type, this is 1 if the argument is marked
          artificial.  Artificial arguments should not be shown to the
          user.  For TYPE_CODE_RANGE it is set if the specific bound is not
          defined.  */
       unsigned int artificial : 1;
 
       /* Discriminant for union field_location.  */
-      ENUM_BITFIELD(field_loc_kind) loc_kind : 2;
+      ENUM_BITFIELD(field_loc_kind) loc_kind : 3;
 
       /* Size of this field, in bits, or zero if not packed.
          If non-zero in an array type, indicates the element size in
          bits (used only in Ada at the moment).
          For an unpacked field, the field's type's length
          says how many bytes the field occupies.  */
 
-      unsigned int bitsize : 29;
+      unsigned int bitsize : 28;
 
       /* In a struct or union type, type of this field.
          In a function or member type, type of this argument.
          In an array type, the domain-type of the array.  */
 
       struct type *type;
 
       /* Name of field, value or argument.
          NULL for range bounds, array domains, and member function
          arguments.  */
 
-      char *name;
+      const char *name;
     } *fields;
 
     /* Union member used for range types.  */
 
     struct range_bounds
     {
       /* Low bound of range.  */
 
       LONGEST low;
 
@@ skipping 127 matching lines @@
        the struct type).  I think only the `type' field of such a field has
        any meaning.  */
 
     short n_baseclasses;
 
     /* Number of methods with unique names.  All overloaded methods with
        the same name count only once.  */
 
     short nfn_fields;
 
-    /* Number of methods described for this type, not including the
-       methods that it derives from.  */
-
-    short nfn_fields_total;
-
     /* Number of template arguments.  */
     unsigned short n_template_arguments;
 
     /* One if this struct is a dynamic class, as defined by the
        Itanium C++ ABI: if it requires a virtual table pointer,
        because it or any of its base classes have one or more virtual
        member functions or virtual base classes.  Minus one if not
        dynamic.  Zero if not yet computed.  */
     int is_dynamic : 2;
 
@@ skipping 37 matching lines @@
     /* For classes, structures, and unions, a description of each field,
        which consists of an overloaded name, followed by the types of
        arguments that the method expects, and then the name after it
        has been renamed to make it distinct.
 
        fn_fieldlists points to an array of nfn_fields of these.  */
 
     struct fn_fieldlist
       {
 
-        /* The overloaded name.  */
+        /* The overloaded name.
+           This is generally allocated in the objfile's obstack.
+           However stabsread.c sometimes uses malloc.  */
 
-        char *name;
+        const char *name;
 
         /* The number of methods with this name.  */
 
         int length;
 
         /* The list of methods.  */
 
         struct fn_field
           {
 
@@ skipping 78 matching lines @@
       }
     *typedef_field;
     unsigned typedef_field_count;
 
     /* The template arguments.  This is an array with
        N_TEMPLATE_ARGUMENTS elements.  This is NULL for non-template
        classes.  */
     struct symbol **template_arguments;
   };
 
-/* Struct used in computing virtual base list.  */
-struct vbase
-  {
-    struct type *vbasetype;     /* pointer to virtual base */
-    struct vbase *next;         /* next in chain */
-  };
-
 /* Struct used to store conversion rankings.  */
 struct rank
   {
     short rank;
 
     /* When two conversions are of the same type and therefore have the same
        rank, subrank is used to differentiate the two.
        Eg: Two derived-class-pointer to base-class-pointer conversions would
        both have base pointer conversion rank, but the conversion with the
        shorter distance to the ancestor is preferable.  'subrank' would be used
@@ skipping 26 matching lines @@
     unsigned calling_convention;
 
     /* Only those DW_TAG_GNU_call_site's in this function that have
        DW_AT_GNU_tail_call set are linked in this list.  Function without its
        tail call list complete (DW_AT_GNU_all_tail_call_sites or its superset
        DW_AT_GNU_all_call_sites) has TAIL_CALL_LIST NULL, even if some
        DW_TAG_GNU_call_site's exist in such function. */
     struct call_site *tail_call_list;
   };
 
+/* struct call_site_parameter can be referenced in callees by several ways.  */
+
+enum call_site_parameter_kind
+{
+  /* Use field call_site_parameter.u.dwarf_reg.  */
+  CALL_SITE_PARAMETER_DWARF_REG,
+
+  /* Use field call_site_parameter.u.fb_offset.  */
+  CALL_SITE_PARAMETER_FB_OFFSET,
+
+  /* Use field call_site_parameter.u.param_offset.  */
+  CALL_SITE_PARAMETER_PARAM_OFFSET
+};
+
 /* A place where a function gets called from, represented by
    DW_TAG_GNU_call_site.  It can be looked up from symtab->call_site_htab.  */
 
 struct call_site
   {
     /* Address of the first instruction after this call.  It must be the first
        field as we overload core_addr_hash and core_addr_eq for it.  */
     CORE_ADDR pc;
 
     /* List successor with head in FUNC_TYPE.TAIL_CALL_LIST.  */
     struct call_site *tail_call_next;
 
     /* Describe DW_AT_GNU_call_site_target.  Missing attribute uses
        FIELD_LOC_KIND_DWARF_BLOCK with FIELD_DWARF_BLOCK == NULL.  */
     struct
       {
         union field_location loc;
 
         /* Discriminant for union field_location.  */
-        ENUM_BITFIELD(field_loc_kind) loc_kind : 2;
+        ENUM_BITFIELD(field_loc_kind) loc_kind : 3;
       }
     target;
 
     /* Size of the PARAMETER array.  */
     unsigned parameter_count;
 
     /* CU of the function where the call is located.  It gets used for DWARF
        blocks execution in the parameter array below.  */
     struct dwarf2_per_cu_data *per_cu;
 
     /* Describe DW_TAG_GNU_call_site's DW_TAG_formal_parameter.  */
     struct call_site_parameter
       {
-        /* DW_TAG_formal_parameter's DW_AT_location's DW_OP_regX as DWARF
-           register number, for register passed parameters.  If -1 then use
-           fb_offset.  */
-        int dwarf_reg;
+        ENUM_BITFIELD (call_site_parameter_kind) kind : 2;
 
-        /* Offset from the callee's frame base, for stack passed parameters.
-           This equals offset from the caller's stack pointer.  Valid only if
-           DWARF_REGNUM is -1.  */
-        CORE_ADDR fb_offset;
+        union call_site_parameter_u
+          {
+            /* DW_TAG_formal_parameter's DW_AT_location's DW_OP_regX as DWARF
+               register number, for register passed parameters.  */
+            int dwarf_reg;
+
+            /* Offset from the callee's frame base, for stack passed parameters.
+               This equals offset from the caller's stack pointer.  */
+            CORE_ADDR fb_offset;
+
+            /* Offset relative to the start of this PER_CU to
+               DW_TAG_formal_parameter which is referenced by both caller and
+               the callee.  */
+            cu_offset param_offset;
+          }
+        u;
 
         /* DW_TAG_formal_parameter's DW_AT_GNU_call_site_value.  It is never
            NULL.  */
         const gdb_byte *value;
         size_t value_size;
 
         /* DW_TAG_formal_parameter's DW_AT_GNU_call_site_data_value.  It may be
            NULL if not provided by DWARF.  */
         const gdb_byte *data_value;
         size_t data_value_size;
@@ skipping 79 matching lines @@
 #define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
    (TYPE_LOW_BOUND(TYPE_INDEX_TYPE((arraytype))))
 
 /* C++ */
 
 #define TYPE_VPTR_BASETYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype
 #define TYPE_DOMAIN_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype
 #define TYPE_VPTR_FIELDNO(thistype) TYPE_MAIN_TYPE(thistype)->vptr_fieldno
 #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields
 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
-#define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total
 #define TYPE_SPECIFIC_FIELD(thistype) \
   TYPE_MAIN_TYPE(thistype)->type_specific_field
 #define TYPE_TYPE_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific
 /* We need this tap-dance with the TYPE_RAW_SPECIFIC because of the case
    where we're trying to print an Ada array using the C language.
    In that case, there is no "cplus_stuff", but the C language assumes
    that there is.  What we do, in that case, is pretend that there is
    an implicit one which is the default cplus stuff.  */
 #define TYPE_CPLUS_SPECIFIC(thistype) \
    (!HAVE_CPLUS_STRUCT(thistype) \
@@ skipping 14 matching lines @@
 #define TYPE_CPLUS_DYNAMIC(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_dynamic
 #define TYPE_CPLUS_REALLY_JAVA(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_java
 
 #define BASETYPE_VIA_VIRTUAL(thistype, index) \
   (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index)))
 
 #define FIELD_TYPE(thisfld) ((thisfld).type)
 #define FIELD_NAME(thisfld) ((thisfld).name)
 #define FIELD_LOC_KIND(thisfld) ((thisfld).loc_kind)
-#define FIELD_BITPOS(thisfld) ((thisfld).loc.bitpos)
+#define FIELD_BITPOS_LVAL(thisfld) ((thisfld).loc.bitpos)
+#define FIELD_BITPOS(thisfld) (FIELD_BITPOS_LVAL (thisfld) + 0)
+#define FIELD_ENUMVAL_LVAL(thisfld) ((thisfld).loc.enumval)
+#define FIELD_ENUMVAL(thisfld) (FIELD_ENUMVAL_LVAL (thisfld) + 0)
 #define FIELD_STATIC_PHYSNAME(thisfld) ((thisfld).loc.physname)
 #define FIELD_STATIC_PHYSADDR(thisfld) ((thisfld).loc.physaddr)
 #define FIELD_DWARF_BLOCK(thisfld) ((thisfld).loc.dwarf_block)
 #define SET_FIELD_BITPOS(thisfld, bitpos)                       \
   (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_BITPOS,            \
-   FIELD_BITPOS (thisfld) = (bitpos))
+   FIELD_BITPOS_LVAL (thisfld) = (bitpos))
+#define SET_FIELD_ENUMVAL(thisfld, enumval)                     \
+  (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_ENUMVAL,           \
+   FIELD_ENUMVAL_LVAL (thisfld) = (enumval))
 #define SET_FIELD_PHYSNAME(thisfld, name)                       \
   (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSNAME,          \
    FIELD_STATIC_PHYSNAME (thisfld) = (name))
 #define SET_FIELD_PHYSADDR(thisfld, addr)                       \
   (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSADDR,          \
    FIELD_STATIC_PHYSADDR (thisfld) = (addr))
 #define SET_FIELD_DWARF_BLOCK(thisfld, addr)                    \
   (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_DWARF_BLOCK,       \
    FIELD_DWARF_BLOCK (thisfld) = (addr))
 #define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial)
 #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
 
 #define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields[n]
 #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n))
 #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n))
 #define TYPE_FIELD_LOC_KIND(thistype, n) FIELD_LOC_KIND (TYPE_FIELD (thistype, n))
 #define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS (TYPE_FIELD (thistype, n))
+#define TYPE_FIELD_ENUMVAL(thistype, n) FIELD_ENUMVAL (TYPE_FIELD (thistype, n))
 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_STATIC_PHYSNAME (TYPE_FIELD (thistype, n))
 #define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_STATIC_PHYSADDR (TYPE_FIELD (thistype, n))
 #define TYPE_FIELD_DWARF_BLOCK(thistype, n) FIELD_DWARF_BLOCK (TYPE_FIELD (thistype, n))
 #define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL(TYPE_FIELD(thistype,n))
 #define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE(TYPE_FIELD(thistype,n))
 #define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE(TYPE_FIELD(thistype,n))!=0)
 
 #define TYPE_FIELD_PRIVATE_BITS(thistype) \
   TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
@@ skipping 327 matching lines @@
                                   struct type *to_type, struct field *args,
                                   int nargs, int varargs);
 
 extern void smash_to_memberptr_type (struct type *, struct type *,
                                      struct type *);
 
 extern void smash_to_methodptr_type (struct type *, struct type *);
 
 extern struct type *allocate_stub_method (struct type *);
 
-extern char *type_name_no_tag (const struct type *);
+extern const char *type_name_no_tag (const struct type *);
 
 extern const char *type_name_no_tag_or_error (struct type *type);
 
 extern struct type *lookup_struct_elt_type (struct type *, char *, int);
 
 extern struct type *make_pointer_type (struct type *, struct type **);
 
 extern struct type *lookup_pointer_type (struct type *);
 
 extern struct type *make_function_type (struct type *, struct type **);
 
 extern struct type *lookup_function_type (struct type *);
 
+extern struct type *lookup_function_type_with_arguments (struct type *,
+                                                         int,
+                                                         struct type **);
+
 extern struct type *create_range_type (struct type *, struct type *, LONGEST,
                                        LONGEST);
 
 extern struct type *create_array_type (struct type *, struct type *,
                                        struct type *);
 extern struct type *lookup_array_range_type (struct type *, int, int);
 
 extern struct type *create_string_type (struct type *, struct type *,
                                         struct type *);
 extern struct type *lookup_string_range_type (struct type *, int, int);
 
 extern struct type *create_set_type (struct type *, struct type *);
 
 extern struct type *lookup_unsigned_typename (const struct language_defn *,
-                                              struct gdbarch *,char *);
+                                              struct gdbarch *, const char *);
 
 extern struct type *lookup_signed_typename (const struct language_defn *,
-                                            struct gdbarch *,char *);
+                                            struct gdbarch *, const char *);
 
 extern struct type *check_typedef (struct type *);
 
 #define CHECK_TYPEDEF(TYPE)                     \
   do {                                          \
     (TYPE) = check_typedef (TYPE);              \
   } while (0)
 
 extern void check_stub_method_group (struct type *, int);
 
@@ skipping 96 matching lines @@
 
 extern htab_t create_copied_types_hash (struct objfile *objfile);
 
 extern struct type *copy_type_recursive (struct objfile *objfile,
                                          struct type *type,
                                          htab_t copied_types);
 
 extern struct type *copy_type (const struct type *type);
 
 #endif /* GDBTYPES_H */