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.  */
1023
1024     unsigned calling_convention;
1025
1026     /* * Only those DW_TAG_GNU_call_site's in this function that have
1027        DW_AT_GNU_tail_call set are linked in this list.  Function
1028        without its tail call list complete
1029        (DW_AT_GNU_all_tail_call_sites or its superset
1030        DW_AT_GNU_all_call_sites) has TAIL_CALL_LIST NULL, even if some
1031        DW_TAG_GNU_call_site's exist in such function. */
1032
1033     struct call_site *tail_call_list;
1034   };
1035
1036 /* struct call_site_parameter can be referenced in callees by several ways.  */
1037
1038 enum call_site_parameter_kind
1039 {
1040   /* * Use field call_site_parameter.u.dwarf_reg.  */
1041   CALL_SITE_PARAMETER_DWARF_REG,
1042
1043   /* * Use field call_site_parameter.u.fb_offset.  */
1044   CALL_SITE_PARAMETER_FB_OFFSET,
1045
1046   /* * Use field call_site_parameter.u.param_offset.  */
1047   CALL_SITE_PARAMETER_PARAM_OFFSET
1048 };
1049
1050 /* * A place where a function gets called from, represented by
1051    DW_TAG_GNU_call_site.  It can be looked up from
1052    symtab->call_site_htab.  */
1053
1054 struct call_site
1055   {
1056     /* * Address of the first instruction after this call.  It must be
1057        the first field as we overload core_addr_hash and core_addr_eq
1058        for it.  */
1059
1060     CORE_ADDR pc;
1061
1062     /* * List successor with head in FUNC_TYPE.TAIL_CALL_LIST.  */
1063
1064     struct call_site *tail_call_next;
1065
1066     /* * Describe DW_AT_GNU_call_site_target.  Missing attribute uses
1067        FIELD_LOC_KIND_DWARF_BLOCK with FIELD_DWARF_BLOCK == NULL.  */
1068
1069     struct
1070       {
1071         union field_location loc;
1072
1073         /* * Discriminant for union field_location.  */
1074
1075         ENUM_BITFIELD(field_loc_kind) loc_kind : 3;
1076       }
1077     target;
1078
1079     /* * Size of the PARAMETER array.  */
1080
1081     unsigned parameter_count;
1082
1083     /* * CU of the function where the call is located.  It gets used
1084        for DWARF blocks execution in the parameter array below.  */
1085
1086     struct dwarf2_per_cu_data *per_cu;
1087
1088     /* * Describe DW_TAG_GNU_call_site's DW_TAG_formal_parameter.  */
1089
1090     struct call_site_parameter
1091       {
1092         ENUM_BITFIELD (call_site_parameter_kind) kind : 2;
1093
1094         union call_site_parameter_u
1095           {
1096             /* * DW_TAG_formal_parameter's DW_AT_location's DW_OP_regX
1097                as DWARF register number, for register passed
1098                parameters.  */
1099
1100             int dwarf_reg;
1101
1102             /* * Offset from the callee's frame base, for stack passed
1103                parameters.  This equals offset from the caller's stack
1104                pointer.  */
1105
1106             CORE_ADDR fb_offset;
1107
1108             /* * Offset relative to the start of this PER_CU to
1109                DW_TAG_formal_parameter which is referenced by both
1110                caller and the callee.  */
1111
1112             cu_offset param_offset;
1113           }
1114         u;
1115
1116         /* * DW_TAG_formal_parameter's DW_AT_GNU_call_site_value.  It
1117            is never NULL.  */
1118
1119         const gdb_byte *value;
1120         size_t value_size;
1121
1122         /* * DW_TAG_formal_parameter's DW_AT_GNU_call_site_data_value.
1123            It may be NULL if not provided by DWARF.  */
1124
1125         const gdb_byte *data_value;
1126         size_t data_value_size;
1127       }
1128     parameter[1];
1129   };
1130
1131 /* * The default value of TYPE_CPLUS_SPECIFIC(T) points to this shared
1132    static structure.  */
1133
1134 extern const struct cplus_struct_type cplus_struct_default;
1135
1136 extern void allocate_cplus_struct_type (struct type *);
1137
1138 #define INIT_CPLUS_SPECIFIC(type) \
1139   (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF, \
1140    TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type*) \
1141    &cplus_struct_default)
1142
1143 #define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
1144
1145 #define HAVE_CPLUS_STRUCT(type) \
1146   (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF \
1147    && TYPE_RAW_CPLUS_SPECIFIC (type) !=  &cplus_struct_default)
1148
1149 extern const struct gnat_aux_type gnat_aux_default;
1150
1151 extern void allocate_gnat_aux_type (struct type *);
1152
1153 #define INIT_GNAT_SPECIFIC(type) \
1154   (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF, \
1155    TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *) &gnat_aux_default)
1156 #define ALLOCATE_GNAT_AUX_TYPE(type) allocate_gnat_aux_type (type)
1157 /* * A macro that returns non-zero if the type-specific data should be
1158    read as "gnat-stuff".  */
1159 #define HAVE_GNAT_AUX_INFO(type) \
1160   (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_GNAT_STUFF)
1161
1162 #define INIT_FUNC_SPECIFIC(type)                                               \
1163   (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FUNC,                            \
1164    TYPE_MAIN_TYPE (type)->type_specific.func_stuff                             \
1165      = TYPE_ZALLOC (type,                                                      \
1166                     sizeof (*TYPE_MAIN_TYPE (type)->type_specific.func_stuff)))
1167
1168 #define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags
1169 #define TYPE_MAIN_TYPE(thistype) (thistype)->main_type
1170 #define TYPE_NAME(thistype) TYPE_MAIN_TYPE(thistype)->name
1171 #define TYPE_TAG_NAME(type) TYPE_MAIN_TYPE(type)->tag_name
1172 #define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type
1173 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
1174 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
1175 #define TYPE_CHAIN(thistype) (thistype)->chain
1176 /* * Note that if thistype is a TYPEDEF type, you have to call check_typedef.
1177    But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
1178    so you only have to call check_typedef once.  Since allocate_value
1179    calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe.  */
1180 #define TYPE_LENGTH(thistype) (thistype)->length
1181 /* * Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you want the real
1182    type, you need to do TYPE_CODE (check_type (this_type)).  */
1183 #define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code
1184 #define TYPE_NFIELDS(thistype) TYPE_MAIN_TYPE(thistype)->nfields
1185 #define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields
1186
1187 #define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0)
1188 #define TYPE_RANGE_DATA(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.bounds
1189 #define TYPE_LOW_BOUND(range_type) \
1190   TYPE_RANGE_DATA(range_type)->low.data.const_val
1191 #define TYPE_HIGH_BOUND(range_type) \
1192   TYPE_RANGE_DATA(range_type)->high.data.const_val
1193 #define TYPE_LOW_BOUND_UNDEFINED(range_type) \
1194   (TYPE_RANGE_DATA(range_type)->low.kind == PROP_UNDEFINED)
1195 #define TYPE_HIGH_BOUND_UNDEFINED(range_type) \
1196   (TYPE_RANGE_DATA(range_type)->high.kind == PROP_UNDEFINED)
1197 #define TYPE_HIGH_BOUND_KIND(range_type) \
1198   TYPE_RANGE_DATA(range_type)->high.kind
1199 #define TYPE_LOW_BOUND_KIND(range_type) \
1200   TYPE_RANGE_DATA(range_type)->low.kind
1201
1202 /* Attribute accessors for the type data location.  */
1203 #define TYPE_DATA_LOCATION(thistype) \
1204   TYPE_MAIN_TYPE(thistype)->data_location
1205 #define TYPE_DATA_LOCATION_BATON(thistype) \
1206   TYPE_DATA_LOCATION (thistype)->data.baton
1207 #define TYPE_DATA_LOCATION_ADDR(thistype) \
1208   TYPE_DATA_LOCATION (thistype)->data.const_val
1209 #define TYPE_DATA_LOCATION_KIND(thistype) \
1210   TYPE_DATA_LOCATION (thistype)->kind
1211
1212 /* Moto-specific stuff for FORTRAN arrays.  */
1213
1214 #define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype) \
1215    TYPE_HIGH_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
1216 #define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \
1217    TYPE_LOW_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
1218
1219 #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
1220    (TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype))))
1221
1222 #define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
1223    (TYPE_LOW_BOUND(TYPE_INDEX_TYPE((arraytype))))
1224
1225 /* C++ */
1226
1227 #define TYPE_VPTR_BASETYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype
1228 #define TYPE_DOMAIN_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype
1229 #define TYPE_VPTR_FIELDNO(thistype) TYPE_MAIN_TYPE(thistype)->vptr_fieldno
1230 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
1231 #define TYPE_SPECIFIC_FIELD(thistype) \
1232   TYPE_MAIN_TYPE(thistype)->type_specific_field
1233 #define TYPE_TYPE_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific
1234 /* We need this tap-dance with the TYPE_RAW_SPECIFIC because of the case
1235    where we're trying to print an Ada array using the C language.
1236    In that case, there is no "cplus_stuff", but the C language assumes
1237    that there is.  What we do, in that case, is pretend that there is
1238    an implicit one which is the default cplus stuff.  */
1239 #define TYPE_CPLUS_SPECIFIC(thistype) \
1240    (!HAVE_CPLUS_STRUCT(thistype) \
1241     ? (struct cplus_struct_type*)&cplus_struct_default \
1242     : TYPE_RAW_CPLUS_SPECIFIC(thistype))
1243 #define TYPE_RAW_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
1244 #define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
1245 #define TYPE_GNAT_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.gnat_stuff
1246 #define TYPE_DESCRIPTIVE_TYPE(thistype) TYPE_GNAT_SPECIFIC(thistype)->descriptive_type
1247 #define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->calling_convention
1248 #define TYPE_TAIL_CALL_LIST(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->tail_call_list
1249 #define TYPE_BASECLASS(thistype,index) TYPE_FIELD_TYPE(thistype, index)
1250 #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
1251 #define TYPE_BASECLASS_NAME(thistype,index) TYPE_FIELD_NAME(thistype, index)
1252 #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index)
1253 #define BASETYPE_VIA_PUBLIC(thistype, index) \
1254   ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index)))
1255 #define TYPE_CPLUS_DYNAMIC(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_dynamic
1256 #define TYPE_CPLUS_REALLY_JAVA(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_java
1257
1258 #define BASETYPE_VIA_VIRTUAL(thistype, index) \
1259   (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
1260     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index)))
1261
1262 #define FIELD_TYPE(thisfld) ((thisfld).type)
1263 #define FIELD_NAME(thisfld) ((thisfld).name)
1264 #define FIELD_LOC_KIND(thisfld) ((thisfld).loc_kind)
1265 #define FIELD_BITPOS_LVAL(thisfld) ((thisfld).loc.bitpos)
1266 #define FIELD_BITPOS(thisfld) (FIELD_BITPOS_LVAL (thisfld) + 0)
1267 #define FIELD_ENUMVAL_LVAL(thisfld) ((thisfld).loc.enumval)
1268 #define FIELD_ENUMVAL(thisfld) (FIELD_ENUMVAL_LVAL (thisfld) + 0)
1269 #define FIELD_STATIC_PHYSNAME(thisfld) ((thisfld).loc.physname)
1270 #define FIELD_STATIC_PHYSADDR(thisfld) ((thisfld).loc.physaddr)
1271 #define FIELD_DWARF_BLOCK(thisfld) ((thisfld).loc.dwarf_block)
1272 #define SET_FIELD_BITPOS(thisfld, bitpos)                       \
1273   (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_BITPOS,            \
1274    FIELD_BITPOS_LVAL (thisfld) = (bitpos))
1275 #define SET_FIELD_ENUMVAL(thisfld, enumval)                     \
1276   (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_ENUMVAL,           \
1277    FIELD_ENUMVAL_LVAL (thisfld) = (enumval))
1278 #define SET_FIELD_PHYSNAME(thisfld, name)                       \
1279   (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSNAME,          \
1280    FIELD_STATIC_PHYSNAME (thisfld) = (name))
1281 #define SET_FIELD_PHYSADDR(thisfld, addr)                       \
1282   (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSADDR,          \
1283    FIELD_STATIC_PHYSADDR (thisfld) = (addr))
1284 #define SET_FIELD_DWARF_BLOCK(thisfld, addr)                    \
1285   (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_DWARF_BLOCK,       \
1286    FIELD_DWARF_BLOCK (thisfld) = (addr))
1287 #define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial)
1288 #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
1289
1290 #define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields[n]
1291 #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n))
1292 #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n))
1293 #define TYPE_FIELD_LOC_KIND(thistype, n) FIELD_LOC_KIND (TYPE_FIELD (thistype, n))
1294 #define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS (TYPE_FIELD (thistype, n))
1295 #define TYPE_FIELD_ENUMVAL(thistype, n) FIELD_ENUMVAL (TYPE_FIELD (thistype, n))
1296 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_STATIC_PHYSNAME (TYPE_FIELD (thistype, n))
1297 #define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_STATIC_PHYSADDR (TYPE_FIELD (thistype, n))
1298 #define TYPE_FIELD_DWARF_BLOCK(thistype, n) FIELD_DWARF_BLOCK (TYPE_FIELD (thistype, n))
1299 #define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL(TYPE_FIELD(thistype,n))
1300 #define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE(TYPE_FIELD(thistype,n))
1301 #define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE(TYPE_FIELD(thistype,n))!=0)
1302
1303 #define TYPE_FIELD_PRIVATE_BITS(thistype) \
1304   TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
1305 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
1306   TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
1307 #define TYPE_FIELD_IGNORE_BITS(thistype) \
1308   TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits
1309 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
1310   TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
1311 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
1312   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
1313 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
1314   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
1315 #define SET_TYPE_FIELD_IGNORE(thistype, n) \
1316   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))
1317 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
1318   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
1319 #define TYPE_FIELD_PRIVATE(thistype, n) \
1320   (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \
1321     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)))
1322 #define TYPE_FIELD_PROTECTED(thistype, n) \
1323   (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
1324     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
1325 #define TYPE_FIELD_IGNORE(thistype, n) \
1326   (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \
1327     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)))
1328 #define TYPE_FIELD_VIRTUAL(thistype, n) \
1329   (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
1330     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)))
1331
1332 #define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
1333 #define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
1334 #define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
1335 #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
1336 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
1337
1338 #define TYPE_N_TEMPLATE_ARGUMENTS(thistype) \
1339   TYPE_CPLUS_SPECIFIC (thistype)->n_template_arguments
1340 #define TYPE_TEMPLATE_ARGUMENTS(thistype) \
1341   TYPE_CPLUS_SPECIFIC (thistype)->template_arguments
1342 #define TYPE_TEMPLATE_ARGUMENT(thistype, n) \
1343   TYPE_CPLUS_SPECIFIC (thistype)->template_arguments[n]
1344
1345 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
1346 #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
1347 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
1348 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_FIELDS ((thisfn)[n].type)
1349 #define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
1350 #define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
1351 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
1352 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
1353 #define TYPE_FN_FIELD_PUBLIC(thisfn, n) ((thisfn)[n].is_public)
1354 #define TYPE_FN_FIELD_STATIC(thisfn, n) ((thisfn)[n].is_static)
1355 #define TYPE_FN_FIELD_FINAL(thisfn, n) ((thisfn)[n].is_final)
1356 #define TYPE_FN_FIELD_SYNCHRONIZED(thisfn, n) ((thisfn)[n].is_synchronized)
1357 #define TYPE_FN_FIELD_NATIVE(thisfn, n) ((thisfn)[n].is_native)
1358 #define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n) ((thisfn)[n].is_artificial)
1359 #define TYPE_FN_FIELD_ABSTRACT(thisfn, n) ((thisfn)[n].is_abstract)
1360 #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
1361 #define TYPE_FN_FIELD_CONSTRUCTOR(thisfn, n) ((thisfn)[n].is_constructor)
1362 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
1363 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
1364 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
1365 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
1366
1367 #define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \
1368   TYPE_CPLUS_SPECIFIC (thistype)->typedef_field
1369 #define TYPE_TYPEDEF_FIELD(thistype, n) \
1370   TYPE_CPLUS_SPECIFIC (thistype)->typedef_field[n]
1371 #define TYPE_TYPEDEF_FIELD_NAME(thistype, n) \
1372   TYPE_TYPEDEF_FIELD (thistype, n).name
1373 #define TYPE_TYPEDEF_FIELD_TYPE(thistype, n) \
1374   TYPE_TYPEDEF_FIELD (thistype, n).type
1375 #define TYPE_TYPEDEF_FIELD_COUNT(thistype) \
1376   TYPE_CPLUS_SPECIFIC (thistype)->typedef_field_count
1377
1378 #define TYPE_IS_OPAQUE(thistype) \
1379   (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) \
1380     || (TYPE_CODE (thistype) == TYPE_CODE_UNION)) \
1381    && (TYPE_NFIELDS (thistype) == 0) \
1382    && (!HAVE_CPLUS_STRUCT (thistype) \
1383        || TYPE_NFN_FIELDS (thistype) == 0) \
1384    && (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype)))
1385
1386 /* * A helper macro that returns the name of a type or "unnamed type"
1387    if the type has no name.  */
1388
1389 #define TYPE_SAFE_NAME(type) \
1390   (TYPE_NAME (type) ? TYPE_NAME (type) : _("<unnamed type>"))
1391
1392 /* * A helper macro that returns the name of an error type.  If the
1393    type has a name, it is used; otherwise, a default is used.  */
1394
1395 #define TYPE_ERROR_NAME(type) \
1396   (TYPE_NAME (type) ? TYPE_NAME (type) : _("<error type>"))
1397
1398 struct builtin_type
1399 {
1400   /* Integral types.  */
1401
1402   /* Implicit size/sign (based on the architecture's ABI).  */
1403   struct type *builtin_void;
1404   struct type *builtin_char;
1405   struct type *builtin_short;
1406   struct type *builtin_int;
1407   struct type *builtin_long;
1408   struct type *builtin_signed_char;
1409   struct type *builtin_unsigned_char;
1410   struct type *builtin_unsigned_short;
1411   struct type *builtin_unsigned_int;
1412   struct type *builtin_unsigned_long;
1413   struct type *builtin_float;
1414   struct type *builtin_double;
1415   struct type *builtin_long_double;
1416   struct type *builtin_complex;
1417   struct type *builtin_double_complex;
1418   struct type *builtin_string;
1419   struct type *builtin_bool;
1420   struct type *builtin_long_long;
1421   struct type *builtin_unsigned_long_long;
1422   struct type *builtin_decfloat;
1423   struct type *builtin_decdouble;
1424   struct type *builtin_declong;
1425
1426   /* "True" character types.
1427       We use these for the '/c' print format, because c_char is just a
1428       one-byte integral type, which languages less laid back than C
1429       will print as ... well, a one-byte integral type.  */
1430   struct type *builtin_true_char;
1431   struct type *builtin_true_unsigned_char;
1432
1433   /* Explicit sizes - see C9X <intypes.h> for naming scheme.  The "int0"
1434      is for when an architecture needs to describe a register that has
1435      no size.  */
1436   struct type *builtin_int0;
1437   struct type *builtin_int8;
1438   struct type *builtin_uint8;
1439   struct type *builtin_int16;
1440   struct type *builtin_uint16;
1441   struct type *builtin_int32;
1442   struct type *builtin_uint32;
1443   struct type *builtin_int64;
1444   struct type *builtin_uint64;
1445   struct type *builtin_int128;
1446   struct type *builtin_uint128;
1447
1448   /* Wide character types.  */
1449   struct type *builtin_char16;
1450   struct type *builtin_char32;
1451
1452   /* Pointer types.  */
1453
1454   /* * `pointer to data' type.  Some target platforms use an implicitly
1455      {sign,zero} -extended 32-bit ABI pointer on a 64-bit ISA.  */
1456   struct type *builtin_data_ptr;
1457
1458   /* * `pointer to function (returning void)' type.  Harvard
1459      architectures mean that ABI function and code pointers are not
1460      interconvertible.  Similarly, since ANSI, C standards have
1461      explicitly said that pointers to functions and pointers to data
1462      are not interconvertible --- that is, you can't cast a function
1463      pointer to void * and back, and expect to get the same value.
1464      However, all function pointer types are interconvertible, so void
1465      (*) () can server as a generic function pointer.  */
1466
1467   struct type *builtin_func_ptr;
1468
1469   /* * `function returning pointer to function (returning void)' type.
1470      The final void return type is not significant for it.  */
1471
1472   struct type *builtin_func_func;
1473
1474   /* Special-purpose types.  */
1475
1476   /* * This type is used to represent a GDB internal function.  */
1477
1478   struct type *internal_fn;
1479
1480   /* * This type is used to represent an xmethod.  */
1481   struct type *xmethod;
1482 };
1483
1484 /* * Return the type table for the specified architecture.  */
1485
1486 extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch);
1487
1488 /* * Per-objfile types used by symbol readers.  */
1489
1490 struct objfile_type
1491 {
1492   /* Basic types based on the objfile architecture.  */
1493   struct type *builtin_void;
1494   struct type *builtin_char;
1495   struct type *builtin_short;
1496   struct type *builtin_int;
1497   struct type *builtin_long;
1498   struct type *builtin_long_long;
1499   struct type *builtin_signed_char;
1500   struct type *builtin_unsigned_char;
1501   struct type *builtin_unsigned_short;
1502   struct type *builtin_unsigned_int;
1503   struct type *builtin_unsigned_long;
1504   struct type *builtin_unsigned_long_long;
1505   struct type *builtin_float;
1506   struct type *builtin_double;
1507   struct type *builtin_long_double;
1508
1509   /* * This type is used to represent symbol addresses.  */
1510   struct type *builtin_core_addr;
1511
1512   /* * This type represents a type that was unrecognized in symbol
1513      read-in.  */
1514   struct type *builtin_error;
1515
1516   /* * Types used for symbols with no debug information.  */
1517   struct type *nodebug_text_symbol;
1518   struct type *nodebug_text_gnu_ifunc_symbol;
1519   struct type *nodebug_got_plt_symbol;
1520   struct type *nodebug_data_symbol;
1521   struct type *nodebug_unknown_symbol;
1522   struct type *nodebug_tls_symbol;
1523 };
1524
1525 /* * Return the type table for the specified objfile.  */
1526
1527 extern const struct objfile_type *objfile_type (struct objfile *objfile);
1528
1529 /* Explicit floating-point formats.  See "floatformat.h".  */
1530 extern const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN];
1531 extern const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN];
1532 extern const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN];
1533 extern const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN];
1534 extern const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN];
1535 extern const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN];
1536 extern const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN];
1537 extern const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN];
1538 extern const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN];
1539 extern const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN];
1540 extern const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN];
1541 extern const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN];
1542
1543
1544 /* * Allocate space for storing data associated with a particular
1545    type.  We ensure that the space is allocated using the same
1546    mechanism that was used to allocate the space for the type
1547    structure itself.  I.e.  if the type is on an objfile's
1548    objfile_obstack, then the space for data associated with that type
1549    will also be allocated on the objfile_obstack.  If the type is not
1550    associated with any particular objfile (such as builtin types),
1551    then the data space will be allocated with xmalloc, the same as for
1552    the type structure.  */
1553
1554 #define TYPE_ALLOC(t,size)  \
1555    (TYPE_OBJFILE_OWNED (t) \
1556     ? obstack_alloc (&TYPE_OBJFILE (t) -> objfile_obstack, size) \
1557     : xmalloc (size))
1558
1559 #define TYPE_ZALLOC(t,size)  \
1560    (TYPE_OBJFILE_OWNED (t) \
1561     ? memset (obstack_alloc (&TYPE_OBJFILE (t)->objfile_obstack, size),  \
1562               0, size)  \
1563     : xzalloc (size))
1564
1565 /* Use alloc_type to allocate a type owned by an objfile.  Use
1566    alloc_type_arch to allocate a type owned by an architecture.  Use
1567    alloc_type_copy to allocate a type with the same owner as a
1568    pre-existing template type, no matter whether objfile or
1569    gdbarch.  */
1570 extern struct type *alloc_type (struct objfile *);
1571 extern struct type *alloc_type_arch (struct gdbarch *);
1572 extern struct type *alloc_type_copy (const struct type *);
1573
1574 /* * Return the type's architecture.  For types owned by an
1575    architecture, that architecture is returned.  For types owned by an
1576    objfile, that objfile's architecture is returned.  */
1577
1578 extern struct gdbarch *get_type_arch (const struct type *);
1579
1580 /* * This returns the target type (or NULL) of TYPE, also skipping
1581    past typedefs.  */
1582
1583 extern struct type *get_target_type (struct type *type);
1584
1585 /* * Helper function to construct objfile-owned types.  */
1586
1587 extern struct type *init_type (enum type_code, int, int, const char *,
1588                                struct objfile *);
1589
1590 /* Helper functions to construct architecture-owned types.  */
1591 extern struct type *arch_type (struct gdbarch *, enum type_code, int, char *);
1592 extern struct type *arch_integer_type (struct gdbarch *, int, int, char *);
1593 extern struct type *arch_character_type (struct gdbarch *, int, int, char *);
1594 extern struct type *arch_boolean_type (struct gdbarch *, int, int, char *);
1595 extern struct type *arch_float_type (struct gdbarch *, int, char *,
1596                                      const struct floatformat **);
1597 extern struct type *arch_complex_type (struct gdbarch *, char *,
1598                                        struct type *);
1599
1600 /* Helper functions to construct a struct or record type.  An
1601    initially empty type is created using arch_composite_type().
1602    Fields are then added using append_composite_type_field*().  A union
1603    type has its size set to the largest field.  A struct type has each
1604    field packed against the previous.  */
1605
1606 extern struct type *arch_composite_type (struct gdbarch *gdbarch,
1607                                          char *name, enum type_code code);
1608 extern void append_composite_type_field (struct type *t, char *name,
1609                                          struct type *field);
1610 extern void append_composite_type_field_aligned (struct type *t,
1611                                                  char *name,
1612                                                  struct type *field,
1613                                                  int alignment);
1614 struct field *append_composite_type_field_raw (struct type *t, char *name,
1615                                                struct type *field);
1616
1617 /* Helper functions to construct a bit flags type.  An initially empty
1618    type is created using arch_flag_type().  Flags are then added using
1619    append_flag_type_flag().  */
1620 extern struct type *arch_flags_type (struct gdbarch *gdbarch,
1621                                      char *name, int length);
1622 extern void append_flags_type_flag (struct type *type, int bitpos, char *name);
1623
1624 extern void make_vector_type (struct type *array_type);
1625 extern struct type *init_vector_type (struct type *elt_type, int n);
1626
1627 extern struct type *lookup_reference_type (struct type *);
1628
1629 extern struct type *make_reference_type (struct type *, struct type **);
1630
1631 extern struct type *make_cv_type (int, int, struct type *, struct type **);
1632
1633 extern struct type *make_restrict_type (struct type *);
1634
1635 extern struct type *make_unqualified_type (struct type *);
1636
1637 extern void replace_type (struct type *, struct type *);
1638
1639 extern int address_space_name_to_int (struct gdbarch *, char *);
1640
1641 extern const char *address_space_int_to_name (struct gdbarch *, int);
1642
1643 extern struct type *make_type_with_address_space (struct type *type,
1644                                                   int space_identifier);
1645
1646 extern struct type *lookup_memberptr_type (struct type *, struct type *);
1647
1648 extern struct type *lookup_methodptr_type (struct type *);
1649
1650 extern void smash_to_method_type (struct type *type, struct type *domain,
1651                                   struct type *to_type, struct field *args,
1652                                   int nargs, int varargs);
1653
1654 extern void smash_to_memberptr_type (struct type *, struct type *,
1655                                      struct type *);
1656
1657 extern void smash_to_methodptr_type (struct type *, struct type *);
1658
1659 extern struct type *allocate_stub_method (struct type *);
1660
1661 extern const char *type_name_no_tag (const struct type *);
1662
1663 extern const char *type_name_no_tag_or_error (struct type *type);
1664
1665 extern struct type *lookup_struct_elt_type (struct type *, const char *, int);
1666
1667 extern struct type *make_pointer_type (struct type *, struct type **);
1668
1669 extern struct type *lookup_pointer_type (struct type *);
1670
1671 extern struct type *make_function_type (struct type *, struct type **);
1672
1673 extern struct type *lookup_function_type (struct type *);
1674
1675 extern struct type *lookup_function_type_with_arguments (struct type *,
1676                                                          int,
1677                                                          struct type **);
1678
1679 extern struct type *create_static_range_type (struct type *, struct type *,
1680                                               LONGEST, LONGEST);
1681
1682
1683 extern struct type *create_array_type_with_stride
1684   (struct type *, struct type *, struct type *, unsigned int);
1685
1686 extern struct type *create_range_type (struct type *, struct type *,
1687                                        const struct dynamic_prop *,
1688                                        const struct dynamic_prop *);
1689
1690 extern struct type *create_array_type (struct type *, struct type *,
1691                                        struct type *);
1692
1693 extern struct type *lookup_array_range_type (struct type *, LONGEST, LONGEST);
1694
1695 extern struct type *create_string_type (struct type *, struct type *,
1696                                         struct type *);
1697 extern struct type *lookup_string_range_type (struct type *, LONGEST, LONGEST);
1698
1699 extern struct type *create_set_type (struct type *, struct type *);
1700
1701 extern struct type *lookup_unsigned_typename (const struct language_defn *,
1702                                               struct gdbarch *, const char *);
1703
1704 extern struct type *lookup_signed_typename (const struct language_defn *,
1705                                             struct gdbarch *, const char *);
1706
1707 extern void get_unsigned_type_max (struct type *, ULONGEST *);
1708
1709 extern void get_signed_type_minmax (struct type *, LONGEST *, LONGEST *);
1710
1711 /* * Resolve all dynamic values of a type e.g. array bounds to static values.
1712    ADDR specifies the location of the variable the type is bound to.
1713    If TYPE has no dynamic properties return TYPE; otherwise a new type with
1714    static properties is returned.  */
1715 extern struct type *resolve_dynamic_type (struct type *type, CORE_ADDR addr);
1716
1717 /* * Predicate if the type has dynamic values, which are not resolved yet.  */
1718 extern int is_dynamic_type (struct type *type);
1719
1720 extern struct type *check_typedef (struct type *);
1721
1722 #define CHECK_TYPEDEF(TYPE)                     \
1723   do {                                          \
1724     (TYPE) = check_typedef (TYPE);              \
1725   } while (0)
1726
1727 extern void check_stub_method_group (struct type *, int);
1728
1729 extern char *gdb_mangle_name (struct type *, int, int);
1730
1731 extern struct type *lookup_typename (const struct language_defn *,
1732                                      struct gdbarch *, const char *,
1733                                      const struct block *, int);
1734
1735 extern struct type *lookup_template_type (char *, struct type *,
1736                                           const struct block *);
1737
1738 extern int get_vptr_fieldno (struct type *, struct type **);
1739
1740 extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *);
1741
1742 extern int get_array_bounds (struct type *type, LONGEST *low_bound,
1743                              LONGEST *high_bound);
1744
1745 extern int class_types_same_p (const struct type *, const struct type *);
1746
1747 extern int is_ancestor (struct type *, struct type *);
1748
1749 extern int is_public_ancestor (struct type *, struct type *);
1750
1751 extern int is_unique_ancestor (struct type *, struct value *);
1752
1753 /* Overload resolution */
1754
1755 #define LENGTH_MATCH(bv) ((bv)->rank[0])
1756
1757 /* * Badness if parameter list length doesn't match arg list length.  */
1758 extern const struct rank LENGTH_MISMATCH_BADNESS;
1759
1760 /* * Dummy badness value for nonexistent parameter positions.  */
1761 extern const struct rank TOO_FEW_PARAMS_BADNESS;
1762 /* * Badness if no conversion among types.  */
1763 extern const struct rank INCOMPATIBLE_TYPE_BADNESS;
1764
1765 /* * Badness of an exact match.  */
1766 extern const struct rank EXACT_MATCH_BADNESS;
1767
1768 /* * Badness of integral promotion.  */
1769 extern const struct rank INTEGER_PROMOTION_BADNESS;
1770 /* * Badness of floating promotion.  */
1771 extern const struct rank FLOAT_PROMOTION_BADNESS;
1772 /* * Badness of converting a derived class pointer
1773    to a base class pointer.  */
1774 extern const struct rank BASE_PTR_CONVERSION_BADNESS;
1775 /* * Badness of integral conversion.  */
1776 extern const struct rank INTEGER_CONVERSION_BADNESS;
1777 /* * Badness of floating conversion.  */
1778 extern const struct rank FLOAT_CONVERSION_BADNESS;
1779 /* * Badness of integer<->floating conversions.  */
1780 extern const struct rank INT_FLOAT_CONVERSION_BADNESS;
1781 /* * Badness of conversion of pointer to void pointer.  */
1782 extern const struct rank VOID_PTR_CONVERSION_BADNESS;
1783 /* * Badness of conversion to boolean.  */
1784 extern const struct rank BOOL_CONVERSION_BADNESS;
1785 /* * Badness of converting derived to base class.  */
1786 extern const struct rank BASE_CONVERSION_BADNESS;
1787 /* * Badness of converting from non-reference to reference.  */
1788 extern const struct rank REFERENCE_CONVERSION_BADNESS;
1789 /* * Badness of converting integer 0 to NULL pointer.  */
1790 extern const struct rank NULL_POINTER_CONVERSION;
1791
1792 /* Non-standard conversions allowed by the debugger */
1793
1794 /* * Converting a pointer to an int is usually OK.  */
1795 extern const struct rank NS_POINTER_CONVERSION_BADNESS;
1796
1797 /* * Badness of converting a (non-zero) integer constant
1798    to a pointer.  */
1799 extern const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS;
1800
1801 extern struct rank sum_ranks (struct rank a, struct rank b);
1802 extern int compare_ranks (struct rank a, struct rank b);
1803
1804 extern int compare_badness (struct badness_vector *, struct badness_vector *);
1805
1806 extern struct badness_vector *rank_function (struct type **, int,
1807                                              struct value **, int);
1808
1809 extern struct rank rank_one_type (struct type *, struct type *,
1810                                   struct value *);
1811
1812 extern void recursive_dump_type (struct type *, int);
1813
1814 extern int field_is_static (struct field *);
1815
1816 /* printcmd.c */
1817
1818 extern void print_scalar_formatted (const void *, struct type *,
1819                                     const struct value_print_options *,
1820                                     int, struct ui_file *);
1821
1822 extern int can_dereference (struct type *);
1823
1824 extern int is_integral_type (struct type *);
1825
1826 extern int is_scalar_type_recursive (struct type *);
1827
1828 extern int class_or_union_p (const struct type *);
1829
1830 extern void maintenance_print_type (char *, int);
1831
1832 extern htab_t create_copied_types_hash (struct objfile *objfile);
1833
1834 extern struct type *copy_type_recursive (struct objfile *objfile,
1835                                          struct type *type,
1836                                          htab_t copied_types);
1837
1838 extern struct type *copy_type (const struct type *type);
1839
1840 extern int types_equal (struct type *, struct type *);
1841
1842 extern int types_deeply_equal (struct type *, struct type *);
1843
1844 #endif /* GDBTYPES_H */