gdb/gdbtypes.h

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