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