gdb/gdbtypes.h

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