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