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