gdb/gdbtypes.h

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