gdb/gdbtypes.h

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