gdb/gdbtypes.h

   1 /* Internal type definitions for GDB.
   2
   3    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   4    2002, 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
   5
   6    Contributed by Cygnus Support, using pieces from other GDB modules.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #if !defined (GDBTYPES_H)
  24 #define GDBTYPES_H 1
  25
  26 #include "hashtab.h"
  27
  28 /* Forward declarations for prototypes.  */
  29 struct field;
  30 struct block;
  31
  32 /* Codes for `fundamental types'.  This is a monstrosity based on the
  33    bogus notion that there are certain compiler-independent
  34    `fundamental types'.  None of these is well-defined (how big is
  35    FT_SHORT?  Does it depend on the language?  How does the
  36    language-specific code know which type to correlate to FT_SHORT?)  */
  37
  38 #define FT_VOID                 0
  39 #define FT_BOOLEAN              1
  40 #define FT_CHAR                 2       /* we use this for not-unsigned C/C++ chars */
  41 #define FT_SIGNED_CHAR          3       /* we use this for C++ signed chars */
  42 #define FT_UNSIGNED_CHAR        4       /* we use this for C/C++ unsigned chars */
  43 #define FT_SHORT                5
  44 #define FT_SIGNED_SHORT         6
  45 #define FT_UNSIGNED_SHORT       7
  46 #define FT_INTEGER              8
  47 #define FT_SIGNED_INTEGER       9
  48 #define FT_UNSIGNED_INTEGER     10
  49 #define FT_LONG                 11
  50 #define FT_SIGNED_LONG          12
  51 #define FT_UNSIGNED_LONG        13
  52 #define FT_LONG_LONG            14
  53 #define FT_SIGNED_LONG_LONG     15
  54 #define FT_UNSIGNED_LONG_LONG   16
  55 #define FT_FLOAT                17
  56 #define FT_DBL_PREC_FLOAT       18
  57 #define FT_EXT_PREC_FLOAT       19
  58 #define FT_COMPLEX              20
  59 #define FT_DBL_PREC_COMPLEX     21
  60 #define FT_EXT_PREC_COMPLEX     22
  61 #define FT_STRING               23
  62 #define FT_FIXED_DECIMAL        24
  63 #define FT_FLOAT_DECIMAL        25
  64 #define FT_BYTE                 26
  65 #define FT_UNSIGNED_BYTE        27
  66 #define FT_TEMPLATE_ARG         28
  67
  68 /* The following three fundamental types are for decimal floating point.  */
  69 #define FT_DECFLOAT             29
  70 #define FT_DBL_PREC_DECFLOAT    30
  71 #define FT_EXT_PREC_DECFLOAT    31
  72
  73 #define FT_NUM_MEMBERS          32      /* Highest FT_* above, plus one. */
  74
  75 /* Some macros for char-based bitfields.  */
  76
  77 #define B_SET(a,x)      ((a)[(x)>>3] |= (1 << ((x)&7)))
  78 #define B_CLR(a,x)      ((a)[(x)>>3] &= ~(1 << ((x)&7)))
  79 #define B_TST(a,x)      ((a)[(x)>>3] & (1 << ((x)&7)))
  80 #define B_TYPE          unsigned char
  81 #define B_BYTES(x)      ( 1 + ((x)>>3) )
  82 #define B_CLRALL(a,x)   memset ((a), 0, B_BYTES(x))
  83
  84 /* Different kinds of data types are distinguished by the `code' field.  */
  85
  86 enum type_code
  87   {
  88     TYPE_CODE_UNDEF,            /* Not used; catches errors */
  89     TYPE_CODE_PTR,              /* Pointer type */
  90
  91     /* Array type with lower & upper bounds.
  92
  93        Regardless of the language, GDB represents multidimensional
  94        array types the way C does: as arrays of arrays.  So an
  95        instance of a GDB array type T can always be seen as a series
  96        of instances of TYPE_TARGET_TYPE (T) laid out sequentially in
  97        memory.
  98
  99        Row-major languages like C lay out multi-dimensional arrays so
 100        that incrementing the rightmost index in a subscripting
 101        expression results in the smallest change in the address of the
 102        element referred to.  Column-major languages like Fortran lay
 103        them out so that incrementing the leftmost index results in the
 104        smallest change.
 105
 106        This means that, in column-major languages, working our way
 107        from type to target type corresponds to working through indices
 108        from right to left, not left to right.  */
 109     TYPE_CODE_ARRAY,
 110
 111     TYPE_CODE_STRUCT,           /* C struct or Pascal record */
 112     TYPE_CODE_UNION,            /* C union or Pascal variant part */
 113     TYPE_CODE_ENUM,             /* Enumeration type */
 114     TYPE_CODE_FLAGS,            /* Bit flags type */
 115     TYPE_CODE_FUNC,             /* Function type */
 116     TYPE_CODE_INT,              /* Integer type */
 117
 118     /* Floating type.  This is *NOT* a complex type.  Beware, there are parts
 119        of GDB which bogusly assume that TYPE_CODE_FLT can mean complex.  */
 120     TYPE_CODE_FLT,
 121
 122     /* Void type.  The length field specifies the length (probably always
 123        one) which is used in pointer arithmetic involving pointers to
 124        this type, but actually dereferencing such a pointer is invalid;
 125        a void type has no length and no actual representation in memory
 126        or registers.  A pointer to a void type is a generic pointer.  */
 127     TYPE_CODE_VOID,
 128
 129     TYPE_CODE_SET,              /* Pascal sets */
 130     TYPE_CODE_RANGE,            /* Range (integers within spec'd bounds) */
 131
 132     /* A string type which is like an array of character but prints
 133        differently (at least for (the deleted) CHILL).  It does not
 134        contain a length field as Pascal strings (for many Pascals,
 135        anyway) do; if we want to deal with such strings, we should use
 136        a new type code.  */
 137     TYPE_CODE_STRING,
 138
 139     /* String of bits; like TYPE_CODE_SET but prints differently (at
 140        least for (the deleted) CHILL).  */
 141     TYPE_CODE_BITSTRING,
 142
 143     /* Unknown type.  The length field is valid if we were able to
 144        deduce that much about the type, or 0 if we don't even know that.  */
 145     TYPE_CODE_ERROR,
 146
 147     /* C++ */
 148     TYPE_CODE_METHOD,           /* Method type */
 149
 150     /* Pointer-to-member-function type.  This describes how to access a
 151        particular member function of a class (possibly a virtual
 152        member function).  The representation may vary between different
 153        C++ ABIs.  */
 154     TYPE_CODE_METHODPTR,
 155
 156     /* Pointer-to-member type.  This is the offset within a class to some
 157        particular data member.  The only currently supported representation
 158        uses an unbiased offset, with -1 representing NULL; this is used
 159        by the Itanium C++ ABI (used by GCC on all platforms).  */
 160     TYPE_CODE_MEMBERPTR,
 161
 162     TYPE_CODE_REF,              /* C++ Reference types */
 163
 164     TYPE_CODE_CHAR,             /* *real* character type */
 165
 166     /* Boolean type.  0 is false, 1 is true, and other values are non-boolean
 167        (e.g. FORTRAN "logical" used as unsigned int).  */
 168     TYPE_CODE_BOOL,
 169
 170     /* Fortran */
 171     TYPE_CODE_COMPLEX,          /* Complex float */
 172
 173     TYPE_CODE_TYPEDEF,
 174     TYPE_CODE_TEMPLATE,         /* C++ template */
 175     TYPE_CODE_TEMPLATE_ARG,     /* C++ template arg */
 176
 177     TYPE_CODE_NAMESPACE,        /* C++ namespace.  */
 178
 179     TYPE_CODE_DECFLOAT          /* Decimal floating point.  */
 180   };
 181
 182 /* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an
 183    alias for TYPE_CODE_STRUCT.  This is for DWARF, which has a distinct
 184    "class" attribute.  Perhaps we should actually have a separate TYPE_CODE
 185    so that we can print "class" or "struct" depending on what the debug
 186    info said.  It's not clear we should bother.  */
 187
 188 #define TYPE_CODE_CLASS TYPE_CODE_STRUCT
 189
 190 /* Some bits for the type's flags word, and macros to test them. */
 191
 192 /* Unsigned integer type.  If this is not set for a TYPE_CODE_INT, the
 193    type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */
 194
 195 #define TYPE_FLAG_UNSIGNED      (1 << 0)
 196 #define TYPE_UNSIGNED(t)        (TYPE_FLAGS (t) & TYPE_FLAG_UNSIGNED)
 197
 198 /* No sign for this type.  In C++, "char", "signed char", and "unsigned
 199    char" are distinct types; so we need an extra flag to indicate the
 200    absence of a sign! */
 201
 202 #define TYPE_FLAG_NOSIGN        (1 << 1)
 203 #define TYPE_NOSIGN(t)          (TYPE_FLAGS (t) & TYPE_FLAG_NOSIGN)
 204
 205 /* This appears in a type's flags word if it is a stub type (e.g., if
 206    someone referenced a type that wasn't defined in a source file
 207    via (struct sir_not_appearing_in_this_film *)).  */
 208
 209 #define TYPE_FLAG_STUB          (1 << 2)
 210 #define TYPE_STUB(t)            (TYPE_FLAGS (t) & TYPE_FLAG_STUB)
 211
 212 /* The target type of this type is a stub type, and this type needs to
 213    be updated if it gets un-stubbed in check_typedef.
 214    Used for arrays and ranges, in which TYPE_LENGTH of the array/range
 215    gets set based on the TYPE_LENGTH of the target type.
 216    Also, set for TYPE_CODE_TYPEDEF. */
 217
 218 #define TYPE_FLAG_TARGET_STUB   (1 << 3)
 219 #define TYPE_TARGET_STUB(t)     (TYPE_FLAGS (t) & TYPE_FLAG_TARGET_STUB)
 220
 221 /* Static type.  If this is set, the corresponding type had
 222  * a static modifier.
 223  * Note: This may be unnecessary, since static data members
 224  * are indicated by other means (bitpos == -1)
 225  */
 226
 227 #define TYPE_FLAG_STATIC        (1 << 4)
 228 #define TYPE_STATIC(t)          (TYPE_FLAGS (t) & TYPE_FLAG_STATIC)
 229
 230 /* Constant type.  If this is set, the corresponding type has a
 231  * const modifier.
 232  */
 233
 234 #define TYPE_FLAG_CONST         (1 << 5)
 235 #define TYPE_CONST(t)           (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_CONST)
 236
 237 /* Volatile type.  If this is set, the corresponding type has a
 238  * volatile modifier.
 239  */
 240
 241 #define TYPE_FLAG_VOLATILE      (1 << 6)
 242 #define TYPE_VOLATILE(t)        (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_VOLATILE)
 243
 244
 245 /* This is a function type which appears to have a prototype.  We need this
 246    for function calls in order to tell us if it's necessary to coerce the args,
 247    or to just do the standard conversions.  This is used with a short field. */
 248
 249 #define TYPE_FLAG_PROTOTYPED    (1 << 7)
 250 #define TYPE_PROTOTYPED(t)      (TYPE_FLAGS (t) & TYPE_FLAG_PROTOTYPED)
 251
 252 /* This flag is used to indicate that processing for this type
 253    is incomplete.
 254
 255    (Mostly intended for HP platforms, where class methods, for
 256    instance, can be encountered before their classes in the debug
 257    info; the incomplete type has to be marked so that the class and
 258    the method can be assigned correct types.) */
 259
 260 #define TYPE_FLAG_INCOMPLETE    (1 << 8)
 261 #define TYPE_INCOMPLETE(t)      (TYPE_FLAGS (t) & TYPE_FLAG_INCOMPLETE)
 262
 263 /* Instruction-space delimited type.  This is for Harvard architectures
 264    which have separate instruction and data address spaces (and perhaps
 265    others).
 266
 267    GDB usually defines a flat address space that is a superset of the
 268    architecture's two (or more) address spaces, but this is an extension
 269    of the architecture's model.
 270
 271    If TYPE_FLAG_INST is set, an object of the corresponding type
 272    resides in instruction memory, even if its address (in the extended
 273    flat address space) does not reflect this.
 274
 275    Similarly, if TYPE_FLAG_DATA is set, then an object of the
 276    corresponding type resides in the data memory space, even if
 277    this is not indicated by its (flat address space) address.
 278
 279    If neither flag is set, the default space for functions / methods
 280    is instruction space, and for data objects is data memory.  */
 281
 282 #define TYPE_FLAG_CODE_SPACE    (1 << 9)
 283 #define TYPE_CODE_SPACE(t)      (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_CODE_SPACE)
 284
 285 #define TYPE_FLAG_DATA_SPACE    (1 << 10)
 286 #define TYPE_DATA_SPACE(t)      (TYPE_INSTANCE_FLAGS (t) & TYPE_FLAG_DATA_SPACE)
 287
 288 /* FIXME drow/2002-06-03:  Only used for methods, but applies as well
 289    to functions.  */
 290
 291 #define TYPE_FLAG_VARARGS       (1 << 11)
 292 #define TYPE_VARARGS(t)         (TYPE_FLAGS (t) & TYPE_FLAG_VARARGS)
 293
 294 /* Identify a vector type.  Gcc is handling this by adding an extra
 295    attribute to the array type.  We slurp that in as a new flag of a
 296    type.  This is used only in dwarf2read.c.  */
 297 #define TYPE_FLAG_VECTOR        (1 << 12)
 298 #define TYPE_VECTOR(t)          (TYPE_FLAGS (t) & TYPE_FLAG_VECTOR)
 299
 300 /* Address class flags.  Some environments provide for pointers whose
 301    size is different from that of a normal pointer or address types
 302    where the bits are interpreted differently than normal addresses.  The
 303    TYPE_FLAG_ADDRESS_CLASS_n flags may be used in target specific
 304    ways to represent these different types of address classes.  */
 305 #define TYPE_FLAG_ADDRESS_CLASS_1 (1 << 13)
 306 #define TYPE_ADDRESS_CLASS_1(t) (TYPE_INSTANCE_FLAGS(t) \
 307                                  & TYPE_FLAG_ADDRESS_CLASS_1)
 308 #define TYPE_FLAG_ADDRESS_CLASS_2 (1 << 14)
 309 #define TYPE_ADDRESS_CLASS_2(t) (TYPE_INSTANCE_FLAGS(t) \
 310                                  & TYPE_FLAG_ADDRESS_CLASS_2)
 311 #define TYPE_FLAG_ADDRESS_CLASS_ALL (TYPE_FLAG_ADDRESS_CLASS_1 \
 312                                      | TYPE_FLAG_ADDRESS_CLASS_2)
 313 #define TYPE_ADDRESS_CLASS_ALL(t) (TYPE_INSTANCE_FLAGS(t) \
 314                                    & TYPE_FLAG_ADDRESS_CLASS_ALL)
 315
 316 /* The debugging formats (especially STABS) do not contain enough information
 317    to represent all Ada types---especially those whose size depends on
 318    dynamic quantities.  Therefore, the GNAT Ada compiler includes
 319    extra information in the form of additional type definitions
 320    connected by naming conventions.  This flag indicates that the
 321    type is an ordinary (unencoded) GDB type that has been created from
 322    the necessary run-time information, and does not need further
 323    interpretation. Optionally marks ordinary, fixed-size GDB type. */
 324
 325 #define TYPE_FLAG_FIXED_INSTANCE (1 << 15)
 326
 327 /* This debug target supports TYPE_STUB(t).  In the unsupported case we have to
 328    rely on NFIELDS to be zero etc., see TYPE_IS_OPAQUE ().
 329    TYPE_STUB(t) with !TYPE_STUB_SUPPORTED(t) may exist if we only guessed
 330    the TYPE_STUB(t) value (see dwarfread.c).  */
 331
 332 #define TYPE_FLAG_STUB_SUPPORTED (1 << 16)
 333 #define TYPE_STUB_SUPPORTED(t)   (TYPE_FLAGS (t) & TYPE_FLAG_STUB_SUPPORTED)
 334
 335 /* Not textual.  By default, GDB treats all single byte integers as
 336    characters (or elements of strings) unless this flag is set.  */
 337
 338 #define TYPE_FLAG_NOTTEXT       (1 << 17)
 339 #define TYPE_NOTTEXT(t)         (TYPE_FLAGS (t) & TYPE_FLAG_NOTTEXT)
 340
 341 /*  Array bound type.  */
 342 enum array_bound_type
 343 {
 344   BOUND_SIMPLE = 0,
 345   BOUND_BY_VALUE_IN_REG,
 346   BOUND_BY_REF_IN_REG,
 347   BOUND_BY_VALUE_ON_STACK,
 348   BOUND_BY_REF_ON_STACK,
 349   BOUND_CANNOT_BE_DETERMINED
 350 };
 351
 352 /* This structure is space-critical.
 353    Its layout has been tweaked to reduce the space used.  */
 354
 355 struct main_type
 356 {
 357   /* Code for kind of type */
 358
 359   ENUM_BITFIELD(type_code) code : 8;
 360
 361   /* Array bounds.  These fields appear at this location because
 362      they pack nicely here.  */
 363
 364   ENUM_BITFIELD(array_bound_type) upper_bound_type : 4;
 365   ENUM_BITFIELD(array_bound_type) lower_bound_type : 4;
 366
 367   /* Name of this type, or NULL if none.
 368
 369      This is used for printing only, except by poorly designed C++ code.
 370      For looking up a name, look for a symbol in the VAR_DOMAIN.  */
 371
 372   char *name;
 373
 374   /* Tag name for this type, or NULL if none.  This means that the
 375      name of the type consists of a keyword followed by the tag name.
 376      Which keyword is determined by the type code ("struct" for
 377      TYPE_CODE_STRUCT, etc.).  As far as I know C/C++ are the only languages
 378      with this feature.
 379
 380      This is used for printing only, except by poorly designed C++ code.
 381      For looking up a name, look for a symbol in the STRUCT_DOMAIN.
 382      One more legitimate use is that if TYPE_FLAG_STUB is set, this is
 383      the name to use to look for definitions in other files.  */
 384
 385   char *tag_name;
 386
 387   /* Every type is now associated with a particular objfile, and the
 388      type is allocated on the objfile_obstack for that objfile.  One problem
 389      however, is that there are times when gdb allocates new types while
 390      it is not in the process of reading symbols from a particular objfile.
 391      Fortunately, these happen when the type being created is a derived
 392      type of an existing type, such as in lookup_pointer_type().  So
 393      we can just allocate the new type using the same objfile as the
 394      existing type, but to do this we need a backpointer to the objfile
 395      from the existing type.  Yes this is somewhat ugly, but without
 396      major overhaul of the internal type system, it can't be avoided
 397      for now. */
 398
 399   struct objfile *objfile;
 400
 401   /* For a pointer type, describes the type of object pointed to.
 402      For an array type, describes the type of the elements.
 403      For a function or method type, describes the type of the return value.
 404      For a range type, describes the type of the full range.
 405      For a complex type, describes the type of each coordinate.
 406      Unused otherwise.  */
 407
 408   struct type *target_type;
 409
 410   /* Flags about this type.  */
 411
 412   int flags;
 413
 414   /* Number of fields described for this type */
 415
 416   short nfields;
 417
 418   /* Field number of the virtual function table pointer in
 419      VPTR_BASETYPE.  If -1, we were unable to find the virtual
 420      function table pointer in initial symbol reading, and
 421      fill_in_vptr_fieldno should be called to find it if possible.
 422
 423      Unused if this type does not have virtual functions.  */
 424
 425   short vptr_fieldno;
 426
 427   /* For structure and union types, a description of each field.
 428      For set and pascal array types, there is one "field",
 429      whose type is the domain type of the set or array.
 430      For range types, there are two "fields",
 431      the minimum and maximum values (both inclusive).
 432      For enum types, each possible value is described by one "field".
 433      For a function or method type, a "field" for each parameter.
 434      For C++ classes, there is one field for each base class (if it is
 435      a derived class) plus one field for each class data member.  Member
 436      functions are recorded elsewhere.
 437
 438      Using a pointer to a separate array of fields
 439      allows all types to have the same size, which is useful
 440      because we can allocate the space for a type before
 441      we know what to put in it.  */
 442
 443   struct field
 444   {
 445     union field_location
 446     {
 447       /* Position of this field, counting in bits from start of
 448          containing structure.
 449          For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB.
 450          For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB.
 451          For a range bound or enum value, this is the value itself. */
 452
 453       int bitpos;
 454
 455       /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr
 456          is the location (in the target) of the static field.
 457          Otherwise, physname is the mangled label of the static field. */
 458
 459       CORE_ADDR physaddr;
 460       char *physname;
 461     }
 462     loc;
 463
 464     /* For a function or member type, this is 1 if the argument is marked
 465        artificial.  Artificial arguments should not be shown to the
 466        user.  */
 467     unsigned int artificial : 1;
 468
 469     /* This flag is zero for non-static fields, 1 for fields whose location
 470        is specified by the label loc.physname, and 2 for fields whose location
 471        is specified by loc.physaddr.  */
 472
 473     unsigned int static_kind : 2;
 474
 475     /* Size of this field, in bits, or zero if not packed.
 476        For an unpacked field, the field's type's length
 477        says how many bytes the field occupies.  */
 478
 479     unsigned int bitsize : 29;
 480
 481     /* In a struct or union type, type of this field.
 482        In a function or member type, type of this argument.
 483        In an array type, the domain-type of the array.  */
 484
 485     struct type *type;
 486
 487     /* Name of field, value or argument.
 488        NULL for range bounds, array domains, and member function
 489        arguments.  */
 490
 491     char *name;
 492
 493   } *fields;
 494
 495   /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE
 496      is the base class which defined the virtual function table pointer.
 497
 498      For types that are pointer to member types (TYPE_CODE_METHODPTR,
 499      TYPE_CODE_MEMBERPTR), VPTR_BASETYPE is the type that this pointer
 500      is a member of.
 501
 502      For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate
 503      type that contains the method.
 504
 505      Unused otherwise.  */
 506
 507   struct type *vptr_basetype;
 508
 509   /* Slot to point to additional language-specific fields of this type.  */
 510
 511   union type_specific
 512   {
 513     /* CPLUS_STUFF is for TYPE_CODE_STRUCT.  It is initialized to point to
 514        cplus_struct_default, a default static instance of a struct
 515        cplus_struct_type. */
 516
 517     struct cplus_struct_type *cplus_stuff;
 518
 519     /* FLOATFORMAT is for TYPE_CODE_FLT.  It is a pointer to two
 520        floatformat objects that describe the floating-point value
 521        that resides within the type.  The first is for big endian
 522        targets and the second is for little endian targets.  */
 523
 524     const struct floatformat **floatformat;
 525   } type_specific;
 526 };
 527
 528 /* A ``struct type'' describes a particular instance of a type, with
 529    some particular qualification.  */
 530 struct type
 531 {
 532   /* Type that is a pointer to this type.
 533      NULL if no such pointer-to type is known yet.
 534      The debugger may add the address of such a type
 535      if it has to construct one later.  */
 536
 537   struct type *pointer_type;
 538
 539   /* C++: also need a reference type.  */
 540
 541   struct type *reference_type;
 542
 543   /* Variant chain.  This points to a type that differs from this one only
 544      in qualifiers and length.  Currently, the possible qualifiers are
 545      const, volatile, code-space, data-space, and address class.  The
 546      length may differ only when one of the address class flags are set.
 547      The variants are linked in a circular ring and share MAIN_TYPE.  */
 548   struct type *chain;
 549
 550   /* Flags specific to this instance of the type, indicating where
 551      on the ring we are.  */
 552   int instance_flags;
 553
 554   /* Length of storage for a value of this type.  This is what
 555      sizeof(type) would return; use it for address arithmetic,
 556      memory reads and writes, etc.  This size includes padding.  For
 557      example, an i386 extended-precision floating point value really
 558      only occupies ten bytes, but most ABI's declare its size to be
 559      12 bytes, to preserve alignment.  A `struct type' representing
 560      such a floating-point type would have a `length' value of 12,
 561      even though the last two bytes are unused.
 562
 563      There's a bit of a host/target mess here, if you're concerned
 564      about machines whose bytes aren't eight bits long, or who don't
 565      have byte-addressed memory.  Various places pass this to memcpy
 566      and such, meaning it must be in units of host bytes.  Various
 567      other places expect they can calculate addresses by adding it
 568      and such, meaning it must be in units of target bytes.  For
 569      some DSP targets, in which HOST_CHAR_BIT will (presumably) be 8
 570      and TARGET_CHAR_BIT will be (say) 32, this is a problem.
 571
 572      One fix would be to make this field in bits (requiring that it
 573      always be a multiple of HOST_CHAR_BIT and TARGET_CHAR_BIT) ---
 574      the other choice would be to make it consistently in units of
 575      HOST_CHAR_BIT.  However, this would still fail to address
 576      machines based on a ternary or decimal representation.  */
 577
 578   unsigned length;
 579
 580   /* Core type, shared by a group of qualified types.  */
 581   struct main_type *main_type;
 582 };
 583
 584 #define NULL_TYPE ((struct type *) 0)
 585
 586 /* C++ language-specific information for TYPE_CODE_STRUCT and TYPE_CODE_UNION
 587    nodes.  */
 588
 589 struct cplus_struct_type
 590   {
 591     /* Number of base classes this type derives from.  The baseclasses are
 592        stored in the first N_BASECLASSES fields (i.e. the `fields' field of
 593        the struct type).  I think only the `type' field of such a field has
 594        any meaning.  */
 595
 596     short n_baseclasses;
 597
 598     /* Number of methods with unique names.  All overloaded methods with
 599        the same name count only once. */
 600
 601     short nfn_fields;
 602
 603     /* Number of methods described for this type, not including the
 604        methods that it derives from.  */
 605
 606     short nfn_fields_total;
 607
 608     /* The "declared_type" field contains a code saying how the
 609        user really declared this type, e.g., "class s", "union s",
 610        "struct s".
 611        The 3 above things come out from the C++ compiler looking like classes,
 612        but we keep track of the real declaration so we can give
 613        the correct information on "ptype". (Note: TEMPLATE may not
 614        belong in this list...)  */
 615
 616 #define DECLARED_TYPE_CLASS 0
 617 #define DECLARED_TYPE_UNION 1
 618 #define DECLARED_TYPE_STRUCT 2
 619 #define DECLARED_TYPE_TEMPLATE 3
 620     short declared_type;        /* One of the above codes */
 621
 622     /* For derived classes, the number of base classes is given by n_baseclasses
 623        and virtual_field_bits is a bit vector containing one bit per base class.
 624        If the base class is virtual, the corresponding bit will be set.
 625        I.E, given:
 626
 627        class A{};
 628        class B{};
 629        class C : public B, public virtual A {};
 630
 631        B is a baseclass of C; A is a virtual baseclass for C.
 632        This is a C++ 2.0 language feature. */
 633
 634     B_TYPE *virtual_field_bits;
 635
 636     /* For classes with private fields, the number of fields is given by
 637        nfields and private_field_bits is a bit vector containing one bit
 638        per field.
 639        If the field is private, the corresponding bit will be set. */
 640
 641     B_TYPE *private_field_bits;
 642
 643     /* For classes with protected fields, the number of fields is given by
 644        nfields and protected_field_bits is a bit vector containing one bit
 645        per field.
 646        If the field is private, the corresponding bit will be set. */
 647
 648     B_TYPE *protected_field_bits;
 649
 650     /* for classes with fields to be ignored, either this is optimized out
 651        or this field has length 0 */
 652
 653     B_TYPE *ignore_field_bits;
 654
 655     /* For classes, structures, and unions, a description of each field,
 656        which consists of an overloaded name, followed by the types of
 657        arguments that the method expects, and then the name after it
 658        has been renamed to make it distinct.
 659
 660        fn_fieldlists points to an array of nfn_fields of these. */
 661
 662     struct fn_fieldlist
 663       {
 664
 665         /* The overloaded name.  */
 666
 667         char *name;
 668
 669         /* The number of methods with this name.  */
 670
 671         int length;
 672
 673         /* The list of methods.  */
 674
 675         struct fn_field
 676           {
 677
 678             /* If is_stub is clear, this is the mangled name which we can
 679                look up to find the address of the method (FIXME: it would
 680                be cleaner to have a pointer to the struct symbol here
 681                instead).  */
 682
 683             /* If is_stub is set, this is the portion of the mangled
 684                name which specifies the arguments.  For example, "ii",
 685                if there are two int arguments, or "" if there are no
 686                arguments.  See gdb_mangle_name for the conversion from this
 687                format to the one used if is_stub is clear.  */
 688
 689             char *physname;
 690
 691             /* The function type for the method.
 692                (This comment used to say "The return value of the method",
 693                but that's wrong. The function type
 694                is expected here, i.e. something with TYPE_CODE_FUNC,
 695                and *not* the return-value type). */
 696
 697             struct type *type;
 698
 699             /* For virtual functions.
 700                First baseclass that defines this virtual function.   */
 701
 702             struct type *fcontext;
 703
 704             /* Attributes. */
 705
 706             unsigned int is_const:1;
 707             unsigned int is_volatile:1;
 708             unsigned int is_private:1;
 709             unsigned int is_protected:1;
 710             unsigned int is_public:1;
 711             unsigned int is_abstract:1;
 712             unsigned int is_static:1;
 713             unsigned int is_final:1;
 714             unsigned int is_synchronized:1;
 715             unsigned int is_native:1;
 716             unsigned int is_artificial:1;
 717
 718             /* A stub method only has some fields valid (but they are enough
 719                to reconstruct the rest of the fields).  */
 720             unsigned int is_stub:1;
 721
 722             /* C++ method that is inlined */
 723             unsigned int is_inlined:1;
 724
 725             /* Unused.  */
 726             unsigned int dummy:3;
 727
 728             /* Index into that baseclass's virtual function table,
 729                minus 2; else if static: VOFFSET_STATIC; else: 0.  */
 730
 731             unsigned int voffset:16;
 732
 733 #define VOFFSET_STATIC 1
 734
 735           }
 736          *fn_fields;
 737
 738       }
 739      *fn_fieldlists;
 740
 741     /* If this "struct type" describes a template, then it
 742      * has arguments. "template_args" points to an array of
 743      * template arg descriptors, of length "ntemplate_args".
 744      * The only real information in each of these template arg descriptors
 745      * is a name. "type" will typically just point to a "struct type" with
 746      * the placeholder TYPE_CODE_TEMPLATE_ARG type.
 747      */
 748     short ntemplate_args;
 749     struct template_arg
 750       {
 751         char *name;
 752         struct type *type;
 753       }
 754      *template_args;
 755
 756     /* If this "struct type" describes a template, it has a list
 757      * of instantiations. "instantiations" is a pointer to an array
 758      * of type's, one representing each instantiation. There
 759      * are "ninstantiations" elements in this array.
 760      */
 761     short ninstantiations;
 762     struct type **instantiations;
 763
 764     /* The following points to information relevant to the runtime model
 765      * of the compiler.
 766      * Currently being used only for HP's ANSI C++ compiler.
 767      * (This type may have to be changed/enhanced for other compilers.)
 768      *
 769      * RUNTIME_PTR is NULL if there is no runtime information (currently
 770      * this means the type was not compiled by HP aCC).
 771      *
 772      * Fields in structure pointed to:
 773      * ->HAS_VTABLE : 0 => no virtual table, 1 => vtable present
 774      *
 775      * ->PRIMARY_BASE points to the first non-virtual base class that has
 776      * a virtual table.
 777      *
 778      * ->VIRTUAL_BASE_LIST points to a list of struct type * pointers that
 779      * point to the type information for all virtual bases among this type's
 780      * ancestors.
 781      */
 782     struct runtime_info
 783       {
 784         short has_vtable;
 785         struct type *primary_base;
 786         struct type **virtual_base_list;
 787       }
 788      *runtime_ptr;
 789
 790     /* Pointer to information about enclosing scope, if this is a
 791      * local type.  If it is not a local type, this is NULL
 792      */
 793     struct local_type_info
 794       {
 795         char *file;
 796         int line;
 797       }
 798      *localtype_ptr;
 799   };
 800
 801 /* Struct used in computing virtual base list */
 802 struct vbase
 803   {
 804     struct type *vbasetype;     /* pointer to virtual base */
 805     struct vbase *next;         /* next in chain */
 806   };
 807
 808 /* Struct used for ranking a function for overload resolution */
 809 struct badness_vector
 810   {
 811     int length;
 812     int *rank;
 813   };
 814
 815 /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
 816    this shared static structure. */
 817
 818 extern const struct cplus_struct_type cplus_struct_default;
 819
 820 extern void allocate_cplus_struct_type (struct type *);
 821
 822 #define INIT_CPLUS_SPECIFIC(type) \
 823   (TYPE_CPLUS_SPECIFIC(type)=(struct cplus_struct_type*)&cplus_struct_default)
 824 #define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
 825 #define HAVE_CPLUS_STRUCT(type) \
 826   (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
 827
 828 #define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags
 829 #define TYPE_MAIN_TYPE(thistype) (thistype)->main_type
 830 #define TYPE_NAME(thistype) TYPE_MAIN_TYPE(thistype)->name
 831 #define TYPE_TAG_NAME(type) TYPE_MAIN_TYPE(type)->tag_name
 832 #define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type
 833 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
 834 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
 835 #define TYPE_CHAIN(thistype) (thistype)->chain
 836 /* Note that if thistype is a TYPEDEF type, you have to call check_typedef.
 837    But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
 838    so you only have to call check_typedef once.  Since allocate_value
 839    calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe.  */
 840 #define TYPE_LENGTH(thistype) (thistype)->length
 841 #define TYPE_OBJFILE(thistype) TYPE_MAIN_TYPE(thistype)->objfile
 842 #define TYPE_FLAGS(thistype) TYPE_MAIN_TYPE(thistype)->flags
 843 /* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you want the real
 844    type, you need to do TYPE_CODE (check_type (this_type)). */
 845 #define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code
 846 #define TYPE_NFIELDS(thistype) TYPE_MAIN_TYPE(thistype)->nfields
 847 #define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->fields
 848 #define TYPE_TEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->template_args
 849 #define TYPE_INSTANTIATIONS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->instantiations
 850
 851 #define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0)
 852 #define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0)
 853 #define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1)
 854
 855 /* Moto-specific stuff for FORTRAN arrays */
 856
 857 #define TYPE_ARRAY_UPPER_BOUND_TYPE(thistype) \
 858         TYPE_MAIN_TYPE(thistype)->upper_bound_type
 859 #define TYPE_ARRAY_LOWER_BOUND_TYPE(thistype) \
 860         TYPE_MAIN_TYPE(thistype)->lower_bound_type
 861
 862 #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
 863    (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),1))
 864
 865 #define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
 866    (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),0))
 867
 868 /* C++ */
 869
 870 #define TYPE_VPTR_BASETYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype
 871 #define TYPE_DOMAIN_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype
 872 #define TYPE_VPTR_FIELDNO(thistype) TYPE_MAIN_TYPE(thistype)->vptr_fieldno
 873 #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields
 874 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
 875 #define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total
 876 #define TYPE_NTEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ntemplate_args
 877 #define TYPE_NINSTANTIATIONS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ninstantiations
 878 #define TYPE_DECLARED_TYPE(thistype) TYPE_CPLUS_SPECIFIC(thistype)->declared_type
 879 #define TYPE_TYPE_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific
 880 #define TYPE_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
 881 #define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
 882 #define TYPE_BASECLASS(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].type
 883 #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
 884 #define TYPE_BASECLASS_NAME(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].name
 885 #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index)
 886 #define BASETYPE_VIA_PUBLIC(thistype, index) \
 887   ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index)))
 888
 889 #define BASETYPE_VIA_VIRTUAL(thistype, index) \
 890   (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
 891     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index)))
 892
 893 #define FIELD_TYPE(thisfld) ((thisfld).type)
 894 #define FIELD_NAME(thisfld) ((thisfld).name)
 895 #define FIELD_BITPOS(thisfld) ((thisfld).loc.bitpos)
 896 #define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial)
 897 #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
 898 #define FIELD_STATIC_KIND(thisfld) ((thisfld).static_kind)
 899 #define FIELD_PHYSNAME(thisfld) ((thisfld).loc.physname)
 900 #define FIELD_PHYSADDR(thisfld) ((thisfld).loc.physaddr)
 901 #define SET_FIELD_PHYSNAME(thisfld, name) \
 902   ((thisfld).static_kind = 1, FIELD_PHYSNAME(thisfld) = (name))
 903 #define SET_FIELD_PHYSADDR(thisfld, name) \
 904   ((thisfld).static_kind = 2, FIELD_PHYSADDR(thisfld) = (name))
 905 #define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->fields[n]
 906 #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n))
 907 #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n))
 908 #define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS(TYPE_FIELD(thistype,n))
 909 #define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL(TYPE_FIELD(thistype,n))
 910 #define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE(TYPE_FIELD(thistype,n))
 911 #define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE(TYPE_FIELD(thistype,n))!=0)
 912 #define TYPE_TEMPLATE_ARG(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->template_args[n]
 913 #define TYPE_INSTANTIATION(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->instantiations[n]
 914
 915 #define TYPE_FIELD_PRIVATE_BITS(thistype) \
 916   TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
 917 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
 918   TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
 919 #define TYPE_FIELD_IGNORE_BITS(thistype) \
 920   TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits
 921 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
 922   TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
 923 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
 924   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
 925 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
 926   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
 927 #define SET_TYPE_FIELD_IGNORE(thistype, n) \
 928   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))
 929 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
 930   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 931 #define TYPE_FIELD_PRIVATE(thistype, n) \
 932   (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \
 933     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)))
 934 #define TYPE_FIELD_PROTECTED(thistype, n) \
 935   (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
 936     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
 937 #define TYPE_FIELD_IGNORE(thistype, n) \
 938   (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \
 939     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)))
 940 #define TYPE_FIELD_VIRTUAL(thistype, n) \
 941   (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
 942     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)))
 943
 944 #define TYPE_FIELD_STATIC(thistype, n) (TYPE_MAIN_TYPE (thistype)->fields[n].static_kind != 0)
 945 #define TYPE_FIELD_STATIC_KIND(thistype, n) TYPE_MAIN_TYPE (thistype)->fields[n].static_kind
 946 #define TYPE_FIELD_STATIC_HAS_ADDR(thistype, n) (TYPE_MAIN_TYPE (thistype)->fields[n].static_kind == 2)
 947 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_PHYSNAME(TYPE_FIELD(thistype, n))
 948 #define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_PHYSADDR(TYPE_FIELD(thistype, n))
 949
 950 #define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
 951 #define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
 952 #define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
 953 #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
 954 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
 955
 956 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
 957 #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
 958 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
 959 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_FIELDS ((thisfn)[n].type)
 960 #define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
 961 #define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
 962 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
 963 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
 964 #define TYPE_FN_FIELD_PUBLIC(thisfn, n) ((thisfn)[n].is_public)
 965 #define TYPE_FN_FIELD_STATIC(thisfn, n) ((thisfn)[n].is_static)
 966 #define TYPE_FN_FIELD_FINAL(thisfn, n) ((thisfn)[n].is_final)
 967 #define TYPE_FN_FIELD_SYNCHRONIZED(thisfn, n) ((thisfn)[n].is_synchronized)
 968 #define TYPE_FN_FIELD_NATIVE(thisfn, n) ((thisfn)[n].is_native)
 969 #define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n) ((thisfn)[n].is_artificial)
 970 #define TYPE_FN_FIELD_ABSTRACT(thisfn, n) ((thisfn)[n].is_abstract)
 971 #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
 972 #define TYPE_FN_FIELD_INLINED(thisfn, n) ((thisfn)[n].is_inlined)
 973 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
 974 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
 975 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
 976 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
 977
 978 #define TYPE_RUNTIME_PTR(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->runtime_ptr)
 979 #define TYPE_VTABLE(thistype) (TYPE_RUNTIME_PTR(thistype)->has_vtable)
 980 #define TYPE_HAS_VTABLE(thistype) (TYPE_RUNTIME_PTR(thistype) && TYPE_VTABLE(thistype))
 981 #define TYPE_PRIMARY_BASE(thistype) (TYPE_RUNTIME_PTR(thistype)->primary_base)
 982 #define TYPE_VIRTUAL_BASE_LIST(thistype) (TYPE_RUNTIME_PTR(thistype)->virtual_base_list)
 983
 984 #define TYPE_LOCALTYPE_PTR(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr)
 985 #define TYPE_LOCALTYPE_FILE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->file)
 986 #define TYPE_LOCALTYPE_LINE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->line)
 987
 988 #define TYPE_IS_OPAQUE(thistype) (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) ||        \
 989                                    (TYPE_CODE (thistype) == TYPE_CODE_UNION))        && \
 990                                   (TYPE_NFIELDS (thistype) == 0)                     && \
 991                                   (TYPE_CPLUS_SPECIFIC (thistype) && (TYPE_NFN_FIELDS (thistype) == 0)) && \
 992                                   (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype)))
 993
 994 struct builtin_type
 995 {
 996   /* Address/pointer types.  */
 997
 998   /* `pointer to data' type.  Some target platforms use an implicitly
 999      {sign,zero} -extended 32-bit ABI pointer on a 64-bit ISA.  */
1000   struct type *builtin_data_ptr;
1001
1002   /* `pointer to function (returning void)' type.  Harvard
1003      architectures mean that ABI function and code pointers are not
1004      interconvertible.  Similarly, since ANSI, C standards have
1005      explicitly said that pointers to functions and pointers to data
1006      are not interconvertible --- that is, you can't cast a function
1007      pointer to void * and back, and expect to get the same value.
1008      However, all function pointer types are interconvertible, so void
1009      (*) () can server as a generic function pointer.  */
1010   struct type *builtin_func_ptr;
1011
1012   /* The target CPU's address type.  This is the ISA address size.  */
1013   struct type *builtin_core_addr;
1014
1015
1016   /* Types used for symbols with no debug information.  */
1017   struct type *nodebug_text_symbol;
1018   struct type *nodebug_data_symbol;
1019   struct type *nodebug_unknown_symbol;
1020   struct type *nodebug_tls_symbol;
1021
1022
1023   /* Integral types.  */
1024
1025   /* We use these for the '/c' print format, because c_char is just a
1026      one-byte integral type, which languages less laid back than C
1027      will print as ... well, a one-byte integral type.  */
1028   struct type *builtin_true_char;
1029   struct type *builtin_true_unsigned_char;
1030
1031   /* Implicit size/sign (based on the the architecture's ABI).  */
1032   struct type *builtin_void;
1033   struct type *builtin_char;
1034   struct type *builtin_short;
1035   struct type *builtin_int;
1036   struct type *builtin_long;
1037   struct type *builtin_signed_char;
1038   struct type *builtin_unsigned_char;
1039   struct type *builtin_unsigned_short;
1040   struct type *builtin_unsigned_int;
1041   struct type *builtin_unsigned_long;
1042   struct type *builtin_float;
1043   struct type *builtin_double;
1044   struct type *builtin_long_double;
1045   struct type *builtin_complex;
1046   struct type *builtin_double_complex;
1047   struct type *builtin_string;
1048   struct type *builtin_bool;
1049   struct type *builtin_long_long;
1050   struct type *builtin_unsigned_long_long;
1051   struct type *builtin_decfloat;
1052   struct type *builtin_decdouble;
1053   struct type *builtin_declong;
1054 };
1055
1056 /* Return the type table for the specified architecture.  */
1057 extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch);
1058
1059 /* Compatibility macros to access types for the current architecture.  */
1060 #define builtin_type_void_data_ptr \
1061         (builtin_type (current_gdbarch)->builtin_data_ptr)
1062 #define builtin_type_void_func_ptr \
1063         (builtin_type (current_gdbarch)->builtin_func_ptr)
1064 #define builtin_type_CORE_ADDR \
1065         (builtin_type (current_gdbarch)->builtin_core_addr)
1066 #define builtin_type_true_char \
1067         (builtin_type (current_gdbarch)->builtin_true_char)
1068 #define builtin_type_void \
1069         (builtin_type (current_gdbarch)->builtin_void)
1070 #define builtin_type_char \
1071         (builtin_type (current_gdbarch)->builtin_char)
1072 #define builtin_type_short \
1073         (builtin_type (current_gdbarch)->builtin_short)
1074 #define builtin_type_int \
1075         (builtin_type (current_gdbarch)->builtin_int)
1076 #define builtin_type_long \
1077         (builtin_type (current_gdbarch)->builtin_long)
1078 #define builtin_type_signed_char \
1079         (builtin_type (current_gdbarch)->builtin_signed_char)
1080 #define builtin_type_unsigned_char \
1081         (builtin_type (current_gdbarch)->builtin_unsigned_char)
1082 #define builtin_type_unsigned_short \
1083         (builtin_type (current_gdbarch)->builtin_unsigned_short)
1084 #define builtin_type_unsigned_int \
1085         (builtin_type (current_gdbarch)->builtin_unsigned_int)
1086 #define builtin_type_unsigned_long \
1087         (builtin_type (current_gdbarch)->builtin_unsigned_long)
1088 #define builtin_type_float \
1089         (builtin_type (current_gdbarch)->builtin_float)
1090 #define builtin_type_double \
1091         (builtin_type (current_gdbarch)->builtin_double)
1092 #define builtin_type_long_double \
1093         (builtin_type (current_gdbarch)->builtin_long_double)
1094 #define builtin_type_complex \
1095         (builtin_type (current_gdbarch)->builtin_complex)
1096 #define builtin_type_double_complex \
1097         (builtin_type (current_gdbarch)->builtin_double_complex)
1098 #define builtin_type_string \
1099         (builtin_type (current_gdbarch)->builtin_string)
1100 #define builtin_type_bool \
1101         (builtin_type (current_gdbarch)->builtin_bool)
1102 #define builtin_type_long_long \
1103         (builtin_type (current_gdbarch)->builtin_long_long)
1104 #define builtin_type_unsigned_long_long \
1105         (builtin_type (current_gdbarch)->builtin_unsigned_long_long)
1106
1107
1108 /* Explicit sizes - see C9X <intypes.h> for naming scheme.  The "int0"
1109    is for when an architecture needs to describe a register that has
1110    no size.  */
1111 extern struct type *builtin_type_int0;
1112 extern struct type *builtin_type_int8;
1113 extern struct type *builtin_type_uint8;
1114 extern struct type *builtin_type_int16;
1115 extern struct type *builtin_type_uint16;
1116 extern struct type *builtin_type_int32;
1117 extern struct type *builtin_type_uint32;
1118 extern struct type *builtin_type_int64;
1119 extern struct type *builtin_type_uint64;
1120 extern struct type *builtin_type_int128;
1121 extern struct type *builtin_type_uint128;
1122
1123 /* Explicit floating-point formats.  See "floatformat.h".  */
1124 extern const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN];
1125 extern const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN];
1126 extern const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN];
1127 extern const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN];
1128 extern const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN];
1129 extern const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN];
1130 extern const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN];
1131 extern const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN];
1132 extern const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN];
1133 extern const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN];
1134
1135 extern struct type *builtin_type_ieee_single;
1136 extern struct type *builtin_type_ieee_double;
1137 extern struct type *builtin_type_i387_ext;
1138 extern struct type *builtin_type_m68881_ext;
1139 extern struct type *builtin_type_arm_ext;
1140 extern struct type *builtin_type_ia64_spill;
1141 extern struct type *builtin_type_ia64_quad;
1142
1143 /* This type represents a type that was unrecognized in symbol
1144    read-in.  */
1145
1146 extern struct type *builtin_type_error;
1147
1148
1149 /* Modula-2 types */
1150
1151 struct builtin_m2_type
1152 {
1153   struct type *builtin_char;
1154   struct type *builtin_int;
1155   struct type *builtin_card;
1156   struct type *builtin_real;
1157   struct type *builtin_bool;
1158 };
1159
1160 /* Return the Modula-2 type table for the specified architecture.  */
1161 extern const struct builtin_m2_type *builtin_m2_type (struct gdbarch *gdbarch);
1162
1163 /* Compatibility macros to access types for the current architecture.  */
1164 #define builtin_type_m2_char \
1165         (builtin_m2_type (current_gdbarch)->builtin_char)
1166 #define builtin_type_m2_int \
1167         (builtin_m2_type (current_gdbarch)->builtin_int)
1168 #define builtin_type_m2_card \
1169         (builtin_m2_type (current_gdbarch)->builtin_card)
1170 #define builtin_type_m2_real \
1171         (builtin_m2_type (current_gdbarch)->builtin_real)
1172 #define builtin_type_m2_bool \
1173         (builtin_m2_type (current_gdbarch)->builtin_bool)
1174
1175
1176 /* Fortran (F77) types */
1177
1178 struct builtin_f_type
1179 {
1180   struct type *builtin_character;
1181   struct type *builtin_integer;
1182   struct type *builtin_integer_s2;
1183   struct type *builtin_logical;
1184   struct type *builtin_logical_s1;
1185   struct type *builtin_logical_s2;
1186   struct type *builtin_real;
1187   struct type *builtin_real_s8;
1188   struct type *builtin_real_s16;
1189   struct type *builtin_complex_s8;
1190   struct type *builtin_complex_s16;
1191   struct type *builtin_complex_s32;
1192   struct type *builtin_void;
1193 };
1194
1195 /* Return the Fortran type table for the specified architecture.  */
1196 extern const struct builtin_f_type *builtin_f_type (struct gdbarch *gdbarch);
1197
1198 /* Compatibility macros to access types for the current architecture.  */
1199 #define builtin_type_f_character \
1200         (builtin_f_type (current_gdbarch)->builtin_character)
1201 #define builtin_type_f_integer \
1202         (builtin_f_type (current_gdbarch)->builtin_integer)
1203 #define builtin_type_f_integer_s2 \
1204         (builtin_f_type (current_gdbarch)->builtin_integer_s2)
1205 #define builtin_type_f_logical \
1206         (builtin_f_type (current_gdbarch)->builtin_logical)
1207 #define builtin_type_f_logical_s1 \
1208         (builtin_f_type (current_gdbarch)->builtin_logical_s1)
1209 #define builtin_type_f_logical_s2 \
1210         (builtin_f_type (current_gdbarch)->builtin_logical_s2)
1211 #define builtin_type_f_real \
1212         (builtin_f_type (current_gdbarch)->builtin_real)
1213 #define builtin_type_f_real_s8 \
1214         (builtin_f_type (current_gdbarch)->builtin_real_s8)
1215 #define builtin_type_f_real_s16 \
1216         (builtin_f_type (current_gdbarch)->builtin_real_s16)
1217 #define builtin_type_f_complex_s8 \
1218         (builtin_f_type (current_gdbarch)->builtin_complex_s8)
1219 #define builtin_type_f_complex_s16 \
1220         (builtin_f_type (current_gdbarch)->builtin_complex_s16)
1221 #define builtin_type_f_complex_s32 \
1222         (builtin_f_type (current_gdbarch)->builtin_complex_s32)
1223 #define builtin_type_f_void \
1224         (builtin_f_type (current_gdbarch)->builtin_void)
1225
1226
1227 /* RTTI for C++ */
1228 /* extern struct type *builtin_type_cxx_typeinfo; */
1229
1230 /* Maximum and minimum values of built-in types */
1231
1232 #define MAX_OF_TYPE(t)  \
1233    (TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) \
1234     : MAX_OF_SIZE(TYPE_LENGTH(t)))
1235
1236 #define MIN_OF_TYPE(t)  \
1237    (TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \
1238     : MIN_OF_SIZE(TYPE_LENGTH(t)))
1239
1240 /* Allocate space for storing data associated with a particular type.
1241    We ensure that the space is allocated using the same mechanism that
1242    was used to allocate the space for the type structure itself.  I.E.
1243    if the type is on an objfile's objfile_obstack, then the space for data
1244    associated with that type will also be allocated on the objfile_obstack.
1245    If the type is not associated with any particular objfile (such as
1246    builtin types), then the data space will be allocated with xmalloc,
1247    the same as for the type structure. */
1248
1249 #define TYPE_ALLOC(t,size)  \
1250    (TYPE_OBJFILE (t) != NULL  \
1251     ? obstack_alloc (&TYPE_OBJFILE (t) -> objfile_obstack, size) \
1252     : xmalloc (size))
1253
1254 #define TYPE_ZALLOC(t,size)  \
1255    (TYPE_OBJFILE (t) != NULL  \
1256     ? memset (obstack_alloc (&TYPE_OBJFILE (t)->objfile_obstack, size),  \
1257               0, size)  \
1258     : xzalloc (size))
1259
1260 extern struct type *alloc_type (struct objfile *);
1261
1262 extern struct type *init_type (enum type_code, int, int, char *,
1263                                struct objfile *);
1264
1265 /* Helper functions to construct a struct or record type.  An
1266    initially empty type is created using init_composite_type().
1267    Fields are then added using append_struct_type_field().  A union
1268    type has its size set to the largest field.  A struct type has each
1269    field packed against the previous.  */
1270
1271 extern struct type *init_composite_type (char *name, enum type_code code);
1272 extern void append_composite_type_field (struct type *t, char *name,
1273                                          struct type *field);
1274
1275 /* Helper functions to construct a bit flags type.  An initially empty
1276    type is created using init_flag_type().  Flags are then added using
1277    append_flag_type_flag().  */
1278 extern struct type *init_flags_type (char *name, int length);
1279 extern void append_flags_type_flag (struct type *type, int bitpos, char *name);
1280
1281 extern void make_vector_type (struct type *array_type);
1282 extern struct type *init_vector_type (struct type *elt_type, int n);
1283
1284 extern struct type *lookup_reference_type (struct type *);
1285
1286 extern struct type *make_reference_type (struct type *, struct type **);
1287
1288 extern struct type *make_cv_type (int, int, struct type *, struct type **);
1289
1290 extern void replace_type (struct type *, struct type *);
1291
1292 extern int address_space_name_to_int (char *);
1293
1294 extern const char *address_space_int_to_name (int);
1295
1296 extern struct type *make_type_with_address_space (struct type *type,
1297                                                   int space_identifier);
1298
1299 extern struct type *lookup_memberptr_type (struct type *, struct type *);
1300
1301 extern struct type *lookup_methodptr_type (struct type *);
1302
1303 extern void smash_to_method_type (struct type *type, struct type *domain,
1304                                   struct type *to_type, struct field *args,
1305                                   int nargs, int varargs);
1306
1307 extern void smash_to_memberptr_type (struct type *, struct type *,
1308                                      struct type *);
1309
1310 extern struct type *allocate_stub_method (struct type *);
1311
1312 extern char *type_name_no_tag (const struct type *);
1313
1314 extern struct type *lookup_struct_elt_type (struct type *, char *, int);
1315
1316 extern struct type *make_pointer_type (struct type *, struct type **);
1317
1318 extern struct type *lookup_pointer_type (struct type *);
1319
1320 extern struct type *make_function_type (struct type *, struct type **);
1321
1322 extern struct type *lookup_function_type (struct type *);
1323
1324 extern struct type *create_range_type (struct type *, struct type *, int,
1325                                        int);
1326
1327 extern struct type *create_array_type (struct type *, struct type *,
1328                                        struct type *);
1329
1330 extern struct type *create_string_type (struct type *, struct type *);
1331
1332 extern struct type *create_set_type (struct type *, struct type *);
1333
1334 extern struct type *lookup_unsigned_typename (char *);
1335
1336 extern struct type *lookup_signed_typename (char *);
1337
1338 extern struct type *check_typedef (struct type *);
1339
1340 #define CHECK_TYPEDEF(TYPE) (TYPE) = check_typedef (TYPE)
1341
1342 extern void check_stub_method_group (struct type *, int);
1343
1344 extern char *gdb_mangle_name (struct type *, int, int);
1345
1346 extern struct type *lookup_typename (char *, struct block *, int);
1347
1348 extern struct type *lookup_template_type (char *, struct type *,
1349                                           struct block *);
1350
1351 extern struct type *lookup_fundamental_type (struct objfile *, int);
1352
1353 extern void fill_in_vptr_fieldno (struct type *);
1354
1355 extern int get_destructor_fn_field (struct type *, int *, int *);
1356
1357 extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *);
1358
1359 extern int is_ancestor (struct type *, struct type *);
1360
1361 extern int has_vtable (struct type *);
1362
1363 extern struct type *primary_base_class (struct type *);
1364
1365 extern int virtual_base_list_length (struct type *);
1366 extern int virtual_base_list_length_skip_primaries (struct type *);
1367
1368 extern int virtual_base_index (struct type *, struct type *);
1369 extern int virtual_base_index_skip_primaries (struct type *, struct type *);
1370
1371
1372 extern int class_index_in_primary_list (struct type *);
1373
1374 extern int count_virtual_fns (struct type *);
1375
1376 /* Constants for HP/Taligent ANSI C++ runtime model */
1377
1378 /* Where virtual function entries begin in the
1379  * virtual table, in the non-RRBC vtable format.
1380  * First 4 are the metavtable pointer, top offset,
1381  * typeinfo pointer, and dup base info pointer */
1382 #define HP_ACC_VFUNC_START        4
1383
1384 /* (Negative) Offset where virtual base offset entries begin
1385  * in the virtual table. Skips over metavtable pointer and
1386  * the self-offset entry.
1387  * NOTE: NEGATE THIS BEFORE USING! The virtual base offsets
1388  * appear before the address point of the vtable (the slot
1389  * pointed to by the object's vtable pointer), i.e. at lower
1390  * addresses than the vtable pointer. */
1391 #define HP_ACC_VBASE_START        2
1392
1393 /* (Positive) Offset where the pointer to the typeinfo
1394  * object is present in the virtual table */
1395 #define HP_ACC_TYPEINFO_OFFSET    2
1396
1397 /* (Positive) Offset where the ``top offset'' entry of
1398  * the virtual table is */
1399 #define HP_ACC_TOP_OFFSET_OFFSET  1
1400
1401 /* Overload resolution */
1402
1403 #define LENGTH_MATCH(bv) ((bv)->rank[0])
1404
1405 /* Badness if parameter list length doesn't match arg list length */
1406 #define LENGTH_MISMATCH_BADNESS      100
1407 /* Dummy badness value for nonexistent parameter positions */
1408 #define TOO_FEW_PARAMS_BADNESS       100
1409 /* Badness if no conversion among types */
1410 #define INCOMPATIBLE_TYPE_BADNESS    100
1411
1412 /* Badness of integral promotion */
1413 #define INTEGER_PROMOTION_BADNESS      1
1414 /* Badness of floating promotion */
1415 #define FLOAT_PROMOTION_BADNESS        1
1416 /* Badness of integral conversion */
1417 #define INTEGER_CONVERSION_BADNESS     2
1418 /* Badness of floating conversion */
1419 #define FLOAT_CONVERSION_BADNESS       2
1420 /* Badness of integer<->floating conversions */
1421 #define INT_FLOAT_CONVERSION_BADNESS   2
1422 /* Badness of converting to a boolean */
1423 #define BOOLEAN_CONVERSION_BADNESS     2
1424 /* Badness of pointer conversion */
1425 #define POINTER_CONVERSION_BADNESS     2
1426 /* Badness of conversion of pointer to void pointer */
1427 #define VOID_PTR_CONVERSION_BADNESS    2
1428 /* Badness of converting derived to base class */
1429 #define BASE_CONVERSION_BADNESS        2
1430 /* Badness of converting from non-reference to reference */
1431 #define REFERENCE_CONVERSION_BADNESS   2
1432
1433 /* Non-standard conversions allowed by the debugger */
1434 /* Converting a pointer to an int is usually OK */
1435 #define NS_POINTER_CONVERSION_BADNESS 10
1436
1437
1438 extern int compare_badness (struct badness_vector *, struct badness_vector *);
1439
1440 extern struct badness_vector *rank_function (struct type **, int,
1441                                              struct type **, int);
1442
1443 extern int rank_one_type (struct type *, struct type *);
1444
1445 extern void recursive_dump_type (struct type *, int);
1446
1447 /* printcmd.c */
1448
1449 extern void print_scalar_formatted (const void *, struct type *, int, int,
1450                                     struct ui_file *);
1451
1452 extern int can_dereference (struct type *);
1453
1454 extern int is_integral_type (struct type *);
1455
1456 extern void maintenance_print_type (char *, int);
1457
1458 extern htab_t create_copied_types_hash (struct objfile *objfile);
1459
1460 extern struct type *copy_type_recursive (struct objfile *objfile,
1461                                          struct type *type,
1462                                          htab_t copied_types);
1463
1464 #endif /* GDBTYPES_H */