Modified Files:

[binutils.git] / gdb / gdbtypes.h

diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 293b4175ab3cc645e19779c7a67e5e8de019c06d..62fe1ab262ab5c3cde090bfabeb9901dd450f9a1 100644 (file)
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -21,9 +21,11 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #if !defined (GDBTYPES_H)
 #define GDBTYPES_H 1
 
 #if !defined (GDBTYPES_H)
 #define GDBTYPES_H 1
 

-/* When gdb creates fundamental types, it uses one of the following
-   type identifiers.  The identifiers are used to index a vector of
-   pointers to any types that are created. */
+/* Codes for `fundamental types'.  This is a monstrosity based on the
+   bogus notion that there are certain compiler-independent
+   `fundamental types'.  None of these is well-defined (how big is
+   FT_SHORT?  Does it depend on the language?  How does the
+   language-specific code know which type to correlate to FT_SHORT?)  */

 
 #define FT_VOID                        0
 #define FT_BOOLEAN             1
 
 #define FT_VOID                        0
 #define FT_BOOLEAN             1


@@ -49,8 +51,21 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define FT_DBL_PREC_COMPLEX    21
 #define FT_EXT_PREC_COMPLEX    22
 #define FT_STRING              23
 #define FT_DBL_PREC_COMPLEX    21
 #define FT_EXT_PREC_COMPLEX    22
 #define FT_STRING              23

+#define FT_FIXED_DECIMAL       24
+#define FT_FLOAT_DECIMAL       25
+#define FT_BYTE                        26
+#define FT_UNSIGNED_BYTE       27

 
 

-#define FT_NUM_MEMBERS         24
+#define FT_NUM_MEMBERS         28      /* Highest FT_* above, plus one. */
+
+/* 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.  */
 
 
 /* Different kinds of data types are distinguished by the `code' field.  */
 


@@ -58,45 +73,83 @@ enum type_code
 {
   TYPE_CODE_UNDEF,             /* Not used; catches errors */
   TYPE_CODE_PTR,               /* Pointer type */
 {
   TYPE_CODE_UNDEF,             /* Not used; catches errors */
   TYPE_CODE_PTR,               /* Pointer type */

-  TYPE_CODE_ARRAY,             /* Array type, lower bound zero */
+  TYPE_CODE_ARRAY,             /* Array type with lower & upper bounds. */

   TYPE_CODE_STRUCT,            /* C struct or Pascal record */
   TYPE_CODE_UNION,             /* C union or Pascal variant part */
   TYPE_CODE_ENUM,              /* Enumeration type */
   TYPE_CODE_FUNC,              /* Function type */
   TYPE_CODE_INT,               /* Integer type */
   TYPE_CODE_STRUCT,            /* C struct or Pascal record */
   TYPE_CODE_UNION,             /* C union or Pascal variant part */
   TYPE_CODE_ENUM,              /* Enumeration type */
   TYPE_CODE_FUNC,              /* Function type */
   TYPE_CODE_INT,               /* Integer type */

-  TYPE_CODE_FLT,               /* Floating type */
-  TYPE_CODE_VOID,              /* Void type (values zero length) */
+
+  /* Floating type.  This is *NOT* a complex type.  Complex types, when
+     we have them, will have their own type code (or TYPE_CODE_ERROR if
+     we can parse a complex type but not manipulate it).  There are parts
+     of GDB which bogusly assume that TYPE_CODE_FLT can mean complex.  */
+  TYPE_CODE_FLT,
+
+  /* Void type.  The length field specifies the length (probably always
+     one) which is used in pointer arithmetic involving pointers to
+     this type, but actually dereferencing such a pointer is invalid;
+     a void type has no length and no actual representation in memory
+     or registers.  A pointer to a void type is a generic pointer.  */
+  TYPE_CODE_VOID,
+

   TYPE_CODE_SET,               /* Pascal sets */
   TYPE_CODE_RANGE,             /* Range (integers within spec'd bounds) */
   TYPE_CODE_SET,               /* Pascal sets */
   TYPE_CODE_RANGE,             /* Range (integers within spec'd bounds) */

-  TYPE_CODE_PASCAL_ARRAY,      /* Array with explicit type of index */
-  TYPE_CODE_ERROR,              /* Unknown type */
+
+  /* A string type which is like an array of character but prints
+     differently (at least for CHILL).  It does not contain a length
+     field as Pascal strings (for many Pascals, anyway) do; if we want
+     to deal with such strings, we should use a new type code.  */
+  TYPE_CODE_STRING,
+
+  /* String of bits; like TYPE_CODE_SET but prints differently (at least
+     for CHILL).  */
+  TYPE_CODE_BITSTRING,
+
+  /* Unknown type.  The length field is valid if we were able to
+     deduce that much about the type, or 0 if we don't even know that.  */
+  TYPE_CODE_ERROR,

 
   /* C++ */
   TYPE_CODE_MEMBER,            /* Member type */
   TYPE_CODE_METHOD,            /* Method type */
   TYPE_CODE_REF,               /* C++ Reference types */
 
 
   /* C++ */
   TYPE_CODE_MEMBER,            /* Member type */
   TYPE_CODE_METHOD,            /* Method type */
   TYPE_CODE_REF,               /* C++ Reference types */
 

-  /* Modula-2 */

   TYPE_CODE_CHAR,              /* *real* character type */
   TYPE_CODE_CHAR,              /* *real* character type */

-  TYPE_CODE_BOOL               /* Builtin Modula-2 BOOLEAN */
+
+  /* Boolean type.  0 is false, 1 is true, and other values are non-boolean
+     (e.g. FORTRAN "logical" used as unsigned int).  */
+  TYPE_CODE_BOOL

 };
 
 };
 

-/* Some bits for the type's flags word. */
+/* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an
+   alias for TYPE_CODE_STRUCT.  This is for DWARF, which has a distinct
+   "class" attribute.  Perhaps we should actually have a separate TYPE_CODE
+   so that we can print "class" or "struct" depending on what the debug
+   info said.  It's not clear we should bother.  */

 
 

-/* Explicitly unsigned integer type */
+#define TYPE_CODE_CLASS TYPE_CODE_STRUCT

 
 

-#define TYPE_FLAG_UNSIGNED     (1 << 0)
+/* Some bits for the type's flags word. */

 
 

-/* Explicity signed integer type */
+/* Unsigned integer type.  If this is not set for a TYPE_CODE_INT, the
+   type is signed.  */

 
 

-#define TYPE_FLAG_SIGNED       (1 << 1)
+#define TYPE_FLAG_UNSIGNED     (1 << 0)

 
 

-/* This appears in a type's flags word if it is a stub type (eg. if
+/* This appears in a type's flags word if it is a stub type (e.g., if

    someone referenced a type that wasn't defined in a source file
    via (struct sir_not_appearing_in_this_film *)).  */
 
 #define TYPE_FLAG_STUB         (1 << 2)
 
    someone referenced a type that wasn't defined in a source file
    via (struct sir_not_appearing_in_this_film *)).  */
 
 #define TYPE_FLAG_STUB         (1 << 2)
 

+/* The target type of this type is a stub type, and this type needs to
+   be updated if it gets un-stubbed in check_stub_type.  Currently only
+   used for arrays, in which TYPE_LENGTH of the array gets set based
+   on the TYPE_LENGTH of the target type.  */
+
+#define TYPE_FLAG_TARGET_STUB (1 << 3)
+

 struct type
 {
 
 struct type
 {
 


@@ -105,12 +158,27 @@ struct type
   enum type_code code;
 
   /* Name of this type, or NULL if none.
   enum type_code code;
 
   /* Name of this type, or NULL if none.

+

      This is used for printing only, except by poorly designed C++ code.
      This is used for printing only, except by poorly designed C++ code.

-     Type names specified as input are defined by symbols.  */
+     For looking up a name, look for a symbol in the VAR_NAMESPACE.  */

 
   char *name;
 
 
   char *name;
 

-  /* Length in bytes of storage for a value of this type */
+  /* 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_NAMESPACE.
+     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;
+
+  /* Length, in units of TARGET_CHAR_BIT bits,
+     of storage for a value of this type */

 
   unsigned length;
 
 
   unsigned length;
 


@@ -168,6 +236,9 @@ struct type
      For range types, there are two "fields",
      the minimum and maximum values (both inclusive).
      For enum types, each possible value is described by one "field".
      For range types, there are two "fields",
      the minimum and maximum values (both inclusive).
      For enum types, each possible value is described by one "field".

+     For C++ classes, there is one field for each base class (if it is
+     a derived class) plus one field for each class data member.  Member
+     functions are recorded elsewhere.

 
      Using a pointer to a separate array of fields
      allows all types to have the same size, which is useful
 
      Using a pointer to a separate array of fields
      allows all types to have the same size, which is useful


@@ -180,15 +251,20 @@ struct type
       /* Position of this field, counting in bits from start of
         containing structure.  For a function type, this is the
         position in the argument list of this argument.
       /* Position of this field, counting in bits from start of
         containing structure.  For a function type, this is the
         position in the argument list of this argument.

-        For a range bound or enum value, this is the value itself.  */
+        For a range bound or enum value, this is the value itself.
+        (FIXME:  What about ranges larger than host int size?)
+        For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB.
+        For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB. */

 
       int bitpos;
 
       /* Size of this field, in bits, or zero if not packed.
         For an unpacked field, the field's type's length
         says how many bytes the field occupies.  */
 
       int bitpos;
 
       /* Size of this field, in bits, or zero if not packed.
         For an unpacked field, the field's type's length
         says how many bytes the field occupies.  */

+      /* FIXME: This is abused by TYPE_FIELD_STATIC_PHYSNAME to contain 
+        a pointer, so it has to be long.  */

 
 

-      int bitsize;
+      long bitsize;

 
       /* In a struct or enum type, type of this field.
         In a function type, type of this argument.
 
       /* In a struct or enum type, type of this field.
         In a function type, type of this argument.


@@ -204,8 +280,7 @@ struct type
     } *fields;
 
   /* For types with virtual functions, VPTR_BASETYPE is the base class which
     } *fields;
 
   /* For types with virtual functions, VPTR_BASETYPE is the base class which

-     defined the virtual function table pointer.  VPTR_FIELDNO is
-     the field number of that pointer in the structure.
+     defined the virtual function table pointer.  

 
      For types that are pointer to member types, VPTR_BASETYPE
      is the type that this pointer is a member of.
 
      For types that are pointer to member types, VPTR_BASETYPE
      is the type that this pointer is a member of.


@@ -214,6 +289,13 @@ struct type
 
   struct type *vptr_basetype;
 
 
   struct type *vptr_basetype;
 

+  /* 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
+     fill_in_vptr_fieldno should be called to find it if possible.
+
+     Unused if this type does not have virtual functions.  */
+

   int vptr_fieldno;
 
   /* Slot to point to additional language-specific fields of this type.  */
   int vptr_fieldno;
 
   /* Slot to point to additional language-specific fields of this type.  */


@@ -225,7 +307,9 @@ struct type
 
       struct type **arg_types;
 
 
       struct type **arg_types;
 

-      /* CPLUS_STUFF is for TYPE_CODE_STRUCT.  */
+      /* CPLUS_STUFF is for TYPE_CODE_STRUCT.  It is initialized to point to
+        cplus_struct_default, a default static instance of a struct
+        cplus_struct_type. */

 
       struct cplus_struct_type *cplus_stuff;
 
 
       struct cplus_struct_type *cplus_stuff;
 


@@ -239,30 +323,62 @@ struct type
 
 struct cplus_struct_type
 {
 
 struct cplus_struct_type
 {

+  /* Number of base classes this type derives from.  The baseclasses are
+     stored in the first N_BASECLASSES fields (i.e. the `fields' field of
+     the struct type).  I think only the `type' field of such a field has
+     any meaning.  */

 
 

-  B_TYPE *virtual_field_bits; /* if base class is virtual */
-
-  B_TYPE *private_field_bits;
-
-  B_TYPE *protected_field_bits;
+  short n_baseclasses;

 
 

-  /* Number of methods described for this type */
+  /* Number of methods with unique names.  All overloaded methods with
+     the same name count only once. */

 
   short nfn_fields;
 
 
   short nfn_fields;
 

-  /* Number of base classes this type derives from. */
-
-  short n_baseclasses;
-

   /* Number of methods described for this type plus all the
      methods that it derives from.  */
 
   int nfn_fields_total;
 
   /* Number of methods described for this type plus all the
      methods that it derives from.  */
 
   int nfn_fields_total;
 

+  /* For derived classes, the number of base classes is given by n_baseclasses
+     and virtual_field_bits is a bit vector containing one bit per base class.
+     If the base class is virtual, the corresponding bit will be set.
+     I.E, given:
+
+       class A{};
+       class B{};
+       class C : public B, public virtual A {};
+
+     B is a baseclass of C; A is a virtual baseclass for C.
+     This is a C++ 2.0 language feature. */
+
+  B_TYPE *virtual_field_bits;
+
+  /* For classes with private fields, the number of fields is given by
+     nfields and private_field_bits is a bit vector containing one bit
+     per field.
+     If the field is private, the corresponding bit will be set. */
+
+  B_TYPE *private_field_bits;
+
+  /* For classes with protected fields, the number of fields is given by
+     nfields and protected_field_bits is a bit vector containing one bit
+     per field.
+     If the field is private, the corresponding bit will be set. */
+
+  B_TYPE *protected_field_bits;
+
+  /* for classes with fields to be ignored, either this is optimized out
+     or this field has length 0 */
+
+  B_TYPE *ignore_field_bits;
+

   /* 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
   /* 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.  */
+     has been renamed to make it distinct.
+
+     fn_fieldlists points to an array of nfn_fields of these. */

 
   struct fn_fieldlist
     {
 
   struct fn_fieldlist
     {


@@ -280,34 +396,53 @@ struct cplus_struct_type
       struct fn_field
        {
 
       struct fn_field
        {
 

+         /* If is_stub is clear, this is the mangled name which we can
+            look up to find the address of the method (FIXME: it would
+            be cleaner to have a pointer to the struct symbol here
+            instead).  */
+
+         /* If is_stub is set, this is the portion of the mangled
+            name which specifies the arguments.  For example, "ii",
+            if there are two int arguments, or "" if there are no
+            arguments.  See gdb_mangle_name for the conversion from this
+            format to the one used if is_stub is clear.  */
+
+         char *physname;
+

          /* The return value of the method */
 
          struct type *type;
 
          /* The return value of the method */
 
          struct type *type;
 

-         /* The argument list */
+         /* The argument list.  Only valid if is_stub is clear.  Contains
+            the type of each argument, including `this', and ending with
+            a NULL pointer after the last argument.  Should not contain
+            a `this' pointer for static member functions.  */

 
          struct type **args;
 
 
          struct type **args;
 

-         /* The name after it has been processed */
-
-         char *physname;
-
-         /* For virtual functions.   */
-         /* First baseclass that defines this virtual function.   */
+         /* For virtual functions.
+            First baseclass that defines this virtual function.   */

 
          struct type *fcontext;
 
 
          struct type *fcontext;
 

+         /* Attributes. */
+

          unsigned int is_const : 1;
          unsigned int is_volatile : 1;
          unsigned int is_private : 1;
          unsigned int is_protected : 1;
          unsigned int is_const : 1;
          unsigned int is_volatile : 1;
          unsigned int is_private : 1;
          unsigned int is_protected : 1;

+
+         /* A stub method only has some fields valid (but they are enough
+            to reconstruct the rest of the fields).  */

          unsigned int is_stub : 1;
          unsigned int is_stub : 1;

+
+         /* Unused.  */

          unsigned int dummy : 3;
 
          /* Index into that baseclass's virtual function table,
             minus 2; else if static: VOFFSET_STATIC; else: 0.  */
 
          unsigned int dummy : 3;
 
          /* Index into that baseclass's virtual function table,
             minus 2; else if static: VOFFSET_STATIC; else: 0.  */
 

-         unsigned voffset : 24;
+         unsigned int voffset : 24;

 
 #        define VOFFSET_STATIC 1
 
 
 #        define VOFFSET_STATIC 1
 


@@ -315,9 +450,6 @@ struct cplus_struct_type
 
     } *fn_fieldlists;
 
 
     } *fn_fieldlists;
 

-  unsigned char via_protected;
-
-  unsigned char via_public;

 };
 
 /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
 };
 
 /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the


@@ -335,6 +467,7 @@ allocate_cplus_struct_type PARAMS ((struct type *));
   (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
 
 #define TYPE_NAME(thistype) (thistype)->name
   (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
 
 #define TYPE_NAME(thistype) (thistype)->name

+#define TYPE_TAG_NAME(type) ((type)->tag_name)

 #define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
 #define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type


@@ -347,6 +480,12 @@ allocate_cplus_struct_type PARAMS ((struct type *));
 #define TYPE_NFIELDS(thistype) (thistype)->nfields
 #define TYPE_FIELDS(thistype) (thistype)->fields
 
 #define TYPE_NFIELDS(thistype) (thistype)->nfields
 #define TYPE_FIELDS(thistype) (thistype)->fields
 

+#define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0)
+#define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1)
+/* If TYPE_DUMMY_RANGE is true for a range type, it was allocated
+   by force_to_range_type. */
+#define TYPE_DUMMY_RANGE(type) ((type)->vptr_fieldno)
+

 /* C++ */
 
 #define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype
 /* C++ */
 
 #define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype


@@ -378,12 +517,16 @@ allocate_cplus_struct_type PARAMS ((struct type *));
   TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
   TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
   TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
   TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits

+#define TYPE_FIELD_IGNORE_BITS(thistype) \
+  TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits

 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
   TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
   TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))

+#define SET_TYPE_FIELD_IGNORE(thistype, n) \
+  B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))

 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 #define TYPE_FIELD_PRIVATE(thistype, n) \
 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 #define TYPE_FIELD_PRIVATE(thistype, n) \


@@ -392,6 +535,9 @@ allocate_cplus_struct_type PARAMS ((struct type *));
 #define TYPE_FIELD_PROTECTED(thistype, n) \
   (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
 #define TYPE_FIELD_PROTECTED(thistype, n) \
   (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))

+#define TYPE_FIELD_IGNORE(thistype, n) \
+  (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \
+    : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)))

 #define TYPE_FIELD_VIRTUAL(thistype, n) \
        B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 
 #define TYPE_FIELD_VIRTUAL(thistype, n) \
        B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 


@@ -405,17 +551,18 @@ allocate_cplus_struct_type PARAMS ((struct type *));
 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
 
 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
 
 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]

-#define TYPE_FN_FIELD_NAME(thisfn, n) (thisfn)[n].name
+#define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname

 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)
 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)

-#define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
-#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
-#define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
-#define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
-#define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
-#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
+#define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
+#define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)

 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)

+#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
+#define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
+#define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
+#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
+#define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)

 
 extern struct type *builtin_type_void;
 extern struct type *builtin_type_char;
 
 extern struct type *builtin_type_void;
 extern struct type *builtin_type_char;


@@ -432,6 +579,7 @@ extern struct type *builtin_type_double;
 extern struct type *builtin_type_long_double;
 extern struct type *builtin_type_complex;
 extern struct type *builtin_type_double_complex;
 extern struct type *builtin_type_long_double;
 extern struct type *builtin_type_complex;
 extern struct type *builtin_type_double_complex;

+extern struct type *builtin_type_string;

 
 /* This type represents a type that was unrecognized in symbol
    read-in.  */
 
 /* This type represents a type that was unrecognized in symbol
    read-in.  */


@@ -449,19 +597,13 @@ extern struct type *builtin_type_m2_card;
 extern struct type *builtin_type_m2_real;
 extern struct type *builtin_type_m2_bool;
 
 extern struct type *builtin_type_m2_real;
 extern struct type *builtin_type_m2_bool;
 

-/* LONG_LONG is defined if the host has "long long".  */
-
-#ifdef LONG_LONG
-
-#define BUILTIN_TYPE_LONGEST builtin_type_long_long
-#define BUILTIN_TYPE_UNSIGNED_LONGEST builtin_type_unsigned_long_long
-
-#else /* not LONG_LONG.  */
-
-#define BUILTIN_TYPE_LONGEST builtin_type_long
-#define BUILTIN_TYPE_UNSIGNED_LONGEST builtin_type_unsigned_long
+/* Chill types */

 
 

-#endif /* not LONG_LONG.  */
+extern struct type *builtin_type_chill_bool;
+extern struct type *builtin_type_chill_char;
+extern struct type *builtin_type_chill_long;
+extern struct type *builtin_type_chill_ulong;
+extern struct type *builtin_type_chill_real;

 
 /* Maximum and minimum values of built-in types */
 
 
 /* Maximum and minimum values of built-in types */
 


@@ -473,6 +615,20 @@ extern struct type *builtin_type_m2_bool;
    TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \
     : MIN_OF_SIZE(TYPE_LENGTH(t))
 
    TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \
     : MIN_OF_SIZE(TYPE_LENGTH(t))
 

+/* Allocate space for storing data associated with a particular type.
+   We ensure that the space is allocated using the same mechanism that
+   was used to allocate the space for the type structure itself.  I.E.
+   if the type is on an objfile's type_obstack, then the space for data
+   associated with that type will also be allocated on the type_obstack.
+   If the type is not associated with any particular objfile (such as
+   builtin types), then the data space will be allocated with xmalloc,
+   the same as for the type structure. */
+
+#define TYPE_ALLOC(t,size)  \
+   (TYPE_OBJFILE (t) != NULL  \
+    ? obstack_alloc (&TYPE_OBJFILE (t) -> type_obstack, size) \
+    : xmalloc (size))
+

 extern struct type *
 alloc_type PARAMS ((struct objfile *));
 
 extern struct type *
 alloc_type PARAMS ((struct objfile *));
 


@@ -482,6 +638,9 @@ init_type PARAMS ((enum type_code, int, int, char *, struct objfile *));
 extern struct type *
 lookup_reference_type PARAMS ((struct type *));
 
 extern struct type *
 lookup_reference_type PARAMS ((struct type *));
 

+extern struct type *
+make_reference_type PARAMS ((struct type *, struct type **));
+

 extern struct type *
 lookup_member_type PARAMS ((struct type *, struct type *));
 
 extern struct type *
 lookup_member_type PARAMS ((struct type *, struct type *));
 


@@ -501,18 +660,36 @@ type_name_no_tag PARAMS ((const struct type *));
 extern struct type *
 lookup_struct_elt_type PARAMS ((struct type *, char *, int));
 
 extern struct type *
 lookup_struct_elt_type PARAMS ((struct type *, char *, int));
 

+extern struct type *
+make_pointer_type PARAMS ((struct type *, struct type **));
+

 extern struct type *
 lookup_pointer_type PARAMS ((struct type *));
 
 extern struct type *
 lookup_pointer_type PARAMS ((struct type *));
 

+extern struct type *
+make_function_type PARAMS ((struct type *, struct type **));
+

 extern struct type *
 lookup_function_type PARAMS ((struct type *));
 
 extern struct type *
 extern struct type *
 lookup_function_type PARAMS ((struct type *));
 
 extern struct type *

-create_array_type PARAMS ((struct type *, int));
+create_range_type PARAMS ((struct type *, struct type *, int, int));
+
+extern struct type *
+create_array_type PARAMS ((struct type *, struct type *, struct type *));
+
+extern struct type *
+create_string_type PARAMS ((struct type *, struct type *));
+
+extern struct type *
+create_set_type PARAMS ((struct type *, struct type *));

 
 extern struct type *
 lookup_unsigned_typename PARAMS ((char *));
 
 
 extern struct type *
 lookup_unsigned_typename PARAMS ((char *));
 

+extern struct type *
+lookup_signed_typename PARAMS ((char *));
+

 extern void
 check_stub_type PARAMS ((struct type *));
 
 extern void
 check_stub_type PARAMS ((struct type *));
 


@@ -528,9 +705,6 @@ gdb_mangle_name PARAMS ((struct type *, int, int));
 extern struct type *
 builtin_type PARAMS ((char **));
 
 extern struct type *
 builtin_type PARAMS ((char **));
 

-extern struct type *
-error_type PARAMS ((char **));
-

 extern struct type *
 lookup_typename PARAMS ((char *, struct block *, int));
 
 extern struct type *
 lookup_typename PARAMS ((char *, struct block *, int));
 


@@ -540,9 +714,22 @@ lookup_template_type PARAMS ((char *, struct type *, struct block *));
 extern struct type *
 lookup_fundamental_type PARAMS ((struct objfile *, int));
 
 extern struct type *
 lookup_fundamental_type PARAMS ((struct objfile *, int));
 

+extern void
+fill_in_vptr_fieldno PARAMS ((struct type *));
+
+#if MAINTENANCE_CMDS
+extern void recursive_dump_type PARAMS ((struct type *, int));
+#endif
+

 /* printcmd.c */
 
 extern void
 /* printcmd.c */
 
 extern void

-print_scalar_formatted PARAMS ((char *, struct type *, int, int, FILE *));
+print_scalar_formatted PARAMS ((char *, struct type *, int, int, GDB_FILE *));
+
+extern int can_dereference PARAMS ((struct type *));
+
+#if MAINTENANCE_CMDS
+extern void maintenance_print_type PARAMS ((char *, int));
+#endif

 
 #endif /* GDBTYPES_H */
 
 #endif /* GDBTYPES_H */