gdb/gdbtypes.h

   1 /* Internal type definitions for GDB.
   2    Copyright (C) 1992, 1993, 1994, 1996 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support, using pieces from other GDB modules.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #if !defined (GDBTYPES_H)
  22 #define GDBTYPES_H 1
  23
  24 /* Codes for `fundamental types'.  This is a monstrosity based on the
  25    bogus notion that there are certain compiler-independent
  26    `fundamental types'.  None of these is well-defined (how big is
  27    FT_SHORT?  Does it depend on the language?  How does the
  28    language-specific code know which type to correlate to FT_SHORT?)  */
  29
  30 #define FT_VOID                 0
  31 #define FT_BOOLEAN              1
  32 #define FT_CHAR                 2
  33 #define FT_SIGNED_CHAR          3
  34 #define FT_UNSIGNED_CHAR        4
  35 #define FT_SHORT                5
  36 #define FT_SIGNED_SHORT         6
  37 #define FT_UNSIGNED_SHORT       7
  38 #define FT_INTEGER              8
  39 #define FT_SIGNED_INTEGER       9
  40 #define FT_UNSIGNED_INTEGER     10
  41 #define FT_LONG                 11
  42 #define FT_SIGNED_LONG          12
  43 #define FT_UNSIGNED_LONG        13
  44 #define FT_LONG_LONG            14
  45 #define FT_SIGNED_LONG_LONG     15
  46 #define FT_UNSIGNED_LONG_LONG   16
  47 #define FT_FLOAT                17
  48 #define FT_DBL_PREC_FLOAT       18
  49 #define FT_EXT_PREC_FLOAT       19
  50 #define FT_COMPLEX              20
  51 #define FT_DBL_PREC_COMPLEX     21
  52 #define FT_EXT_PREC_COMPLEX     22
  53 #define FT_STRING               23
  54 #define FT_FIXED_DECIMAL        24
  55 #define FT_FLOAT_DECIMAL        25
  56 #define FT_BYTE                 26
  57 #define FT_UNSIGNED_BYTE        27
  58
  59 #define FT_NUM_MEMBERS          28      /* Highest FT_* above, plus one. */
  60
  61 /* Some macros for char-based bitfields.  */
  62
  63 #define B_SET(a,x)      ((a)[(x)>>3] |= (1 << ((x)&7)))
  64 #define B_CLR(a,x)      ((a)[(x)>>3] &= ~(1 << ((x)&7)))
  65 #define B_TST(a,x)      ((a)[(x)>>3] & (1 << ((x)&7)))
  66 #define B_TYPE          unsigned char
  67 #define B_BYTES(x)      ( 1 + ((x)>>3) )
  68 #define B_CLRALL(a,x)   memset ((a), 0, B_BYTES(x))
  69
  70 /* Different kinds of data types are distinguished by the `code' field.  */
  71
  72 enum type_code
  73 {
  74   TYPE_CODE_UNDEF,              /* Not used; catches errors */
  75   TYPE_CODE_PTR,                /* Pointer type */
  76   TYPE_CODE_ARRAY,              /* Array type with lower & upper bounds. */
  77   TYPE_CODE_STRUCT,             /* C struct or Pascal record */
  78   TYPE_CODE_UNION,              /* C union or Pascal variant part */
  79   TYPE_CODE_ENUM,               /* Enumeration type */
  80   TYPE_CODE_FUNC,               /* Function type */
  81   TYPE_CODE_INT,                /* Integer type */
  82
  83   /* Floating type.  This is *NOT* a complex type.  Beware, there are parts
  84      of GDB which bogusly assume that TYPE_CODE_FLT can mean complex.  */
  85   TYPE_CODE_FLT,
  86
  87   /* Void type.  The length field specifies the length (probably always
  88      one) which is used in pointer arithmetic involving pointers to
  89      this type, but actually dereferencing such a pointer is invalid;
  90      a void type has no length and no actual representation in memory
  91      or registers.  A pointer to a void type is a generic pointer.  */
  92   TYPE_CODE_VOID,
  93
  94   TYPE_CODE_SET,                /* Pascal sets */
  95   TYPE_CODE_RANGE,              /* Range (integers within spec'd bounds) */
  96
  97   /* A string type which is like an array of character but prints
  98      differently (at least for CHILL).  It does not contain a length
  99      field as Pascal strings (for many Pascals, anyway) do; if we want
 100      to deal with such strings, we should use a new type code.  */
 101   TYPE_CODE_STRING,
 102
 103   /* String of bits; like TYPE_CODE_SET but prints differently (at least
 104      for CHILL).  */
 105   TYPE_CODE_BITSTRING,
 106
 107   /* Unknown type.  The length field is valid if we were able to
 108      deduce that much about the type, or 0 if we don't even know that.  */
 109   TYPE_CODE_ERROR,
 110
 111   /* C++ */
 112   TYPE_CODE_MEMBER,             /* Member type */
 113   TYPE_CODE_METHOD,             /* Method type */
 114   TYPE_CODE_REF,                /* C++ Reference types */
 115
 116   TYPE_CODE_CHAR,               /* *real* character type */
 117
 118   /* Boolean type.  0 is false, 1 is true, and other values are non-boolean
 119      (e.g. FORTRAN "logical" used as unsigned int).  */
 120   TYPE_CODE_BOOL,
 121
 122   /* Fortran */
 123   TYPE_CODE_COMPLEX,            /* Complex float */
 124
 125   TYPE_CODE_TYPEDEF
 126 };
 127
 128 /* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an
 129    alias for TYPE_CODE_STRUCT.  This is for DWARF, which has a distinct
 130    "class" attribute.  Perhaps we should actually have a separate TYPE_CODE
 131    so that we can print "class" or "struct" depending on what the debug
 132    info said.  It's not clear we should bother.  */
 133
 134 #define TYPE_CODE_CLASS TYPE_CODE_STRUCT
 135
 136 /* Some bits for the type's flags word. */
 137
 138 /* Unsigned integer type.  If this is not set for a TYPE_CODE_INT, the
 139    type is signed.  */
 140
 141 #define TYPE_FLAG_UNSIGNED      (1 << 0)
 142
 143 /* This appears in a type's flags word if it is a stub type (e.g., if
 144    someone referenced a type that wasn't defined in a source file
 145    via (struct sir_not_appearing_in_this_film *)).  */
 146
 147 #define TYPE_FLAG_STUB          (1 << 2)
 148
 149 /* The target type of this type is a stub type, and this type needs to
 150    be updated if it gets un-stubbed in check_typedef.
 151    Used for arrays and ranges, in which TYPE_LENGTH of the array/range
 152    gets set based on the TYPE_LENGTH of the target type.
 153    Also, set for TYPE_CODE_TYPEDEF. */
 154
 155 #define TYPE_FLAG_TARGET_STUB (1 << 3)
 156
 157 /* This is a function type which appears to have a prototype.  We need this
 158    for function calls in order to tell us if it's necessary to coerce the args,
 159    or to just do the standard conversions.  */
 160
 161 #define TYPE_FLAG_PROTOTYPED (1 << 4)
 162
 163 struct type
 164 {
 165
 166   /* Code for kind of type */
 167
 168   enum type_code code;
 169
 170   /* Name of this type, or NULL if none.
 171
 172      This is used for printing only, except by poorly designed C++ code.
 173      For looking up a name, look for a symbol in the VAR_NAMESPACE.  */
 174
 175   char *name;
 176
 177   /* Tag name for this type, or NULL if none.  This means that the
 178      name of the type consists of a keyword followed by the tag name.
 179      Which keyword is determined by the type code ("struct" for
 180      TYPE_CODE_STRUCT, etc.).  As far as I know C/C++ are the only languages
 181      with this feature.
 182
 183      This is used for printing only, except by poorly designed C++ code.
 184      For looking up a name, look for a symbol in the STRUCT_NAMESPACE.
 185      One more legitimate use is that if TYPE_FLAG_STUB is set, this is
 186      the name to use to look for definitions in other files.  */
 187
 188   char *tag_name;
 189
 190   /* Length of storage for a value of this type.  Various places pass
 191      this to memcpy and such, meaning it must be in units of
 192      HOST_CHAR_BIT.  Various other places expect they can calculate
 193      addresses by adding it and such, meaning it must be in units of
 194      TARGET_CHAR_BIT.  For some DSP targets, in which HOST_CHAR_BIT
 195      will (presumably) be 8 and TARGET_CHAR_BIT will be (say) 32, this
 196      is a problem.  One fix would be to make this field in bits
 197      (requiring that it always be a multiple of HOST_CHAR_BIT and
 198      TARGET_CHAR_BIT)--the other choice would be to make it
 199      consistently in units of HOST_CHAR_BIT.  */
 200
 201   unsigned length;
 202
 203   /* FIXME, these should probably be restricted to a Fortran-specific
 204      field in some fashion.  */
 205 #define BOUND_CANNOT_BE_DETERMINED   5
 206 #define BOUND_BY_REF_ON_STACK        4
 207 #define BOUND_BY_VALUE_ON_STACK      3
 208 #define BOUND_BY_REF_IN_REG          2
 209 #define BOUND_BY_VALUE_IN_REG        1
 210 #define BOUND_SIMPLE                 0
 211   int upper_bound_type;
 212   int lower_bound_type;
 213
 214   /* Every type is now associated with a particular objfile, and the
 215      type is allocated on the type_obstack for that objfile.  One problem
 216      however, is that there are times when gdb allocates new types while
 217      it is not in the process of reading symbols from a particular objfile.
 218      Fortunately, these happen when the type being created is a derived
 219      type of an existing type, such as in lookup_pointer_type().  So
 220      we can just allocate the new type using the same objfile as the
 221      existing type, but to do this we need a backpointer to the objfile
 222      from the existing type.  Yes this is somewhat ugly, but without
 223      major overhaul of the internal type system, it can't be avoided
 224      for now. */
 225
 226   struct objfile *objfile;
 227
 228   /* For a pointer type, describes the type of object pointed to.
 229      For an array type, describes the type of the elements.
 230      For a function or method type, describes the type of the return value.
 231      For a range type, describes the type of the full range.
 232      For a complex type, describes the type of each coordinate.
 233      Unused otherwise.  */
 234
 235   struct type *target_type;
 236
 237   /* Type that is a pointer to this type.
 238      NULL if no such pointer-to type is known yet.
 239      The debugger may add the address of such a type
 240      if it has to construct one later.  */
 241
 242   struct type *pointer_type;
 243
 244   /* C++: also need a reference type.  */
 245
 246   struct type *reference_type;
 247
 248   /* Flags about this type.  */
 249
 250   short flags;
 251
 252   /* Number of fields described for this type */
 253
 254   short nfields;
 255
 256   /* For structure and union types, a description of each field.
 257      For set and pascal array types, there is one "field",
 258      whose type is the domain type of the set or array.
 259      For range types, there are two "fields",
 260      the minimum and maximum values (both inclusive).
 261      For enum types, each possible value is described by one "field".
 262      For a function type, a "field" for each parameter type.
 263      For C++ classes, there is one field for each base class (if it is
 264      a derived class) plus one field for each class data member.  Member
 265      functions are recorded elsewhere.
 266
 267      Using a pointer to a separate array of fields
 268      allows all types to have the same size, which is useful
 269      because we can allocate the space for a type before
 270      we know what to put in it.  */
 271
 272   struct field
 273     {
 274
 275       /* Position of this field, counting in bits from start of
 276          containing structure.  For a function type, this is the
 277          position in the argument list of this argument.
 278          For a range bound or enum value, this is the value itself.
 279          (FIXME:  What about ranges larger than host int size?)
 280          For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB.
 281          For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB. */
 282
 283       int bitpos;
 284
 285       /* Size of this field, in bits, or zero if not packed.
 286          For an unpacked field, the field's type's length
 287          says how many bytes the field occupies.  */
 288       /* FIXME: This is abused by TYPE_FIELD_STATIC_PHYSNAME to contain
 289          a pointer, so it has to be long.  */
 290
 291       long bitsize;
 292
 293       /* In a struct or enum type, type of this field.
 294          In a function type, type of this argument.
 295          In an array type, the domain-type of the array.  */
 296
 297       struct type *type;
 298
 299       /* Name of field, value or argument.
 300          NULL for range bounds and array domains.  */
 301
 302       char *name;
 303
 304     } *fields;
 305
 306   /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE
 307      is the base class which defined the virtual function table pointer.
 308
 309      For types that are pointer to member types (TYPE_CODE_MEMBER),
 310      VPTR_BASETYPE is the type that this pointer is a member of.
 311
 312      For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate
 313      type that contains the method.
 314
 315      Unused otherwise.  */
 316
 317   struct type *vptr_basetype;
 318
 319   /* Field number of the virtual function table pointer in
 320      VPTR_BASETYPE.  If -1, we were unable to find the virtual
 321      function table pointer in initial symbol reading, and
 322      fill_in_vptr_fieldno should be called to find it if possible.
 323
 324      Unused if this type does not have virtual functions.  */
 325
 326   int vptr_fieldno;
 327
 328   /* Slot to point to additional language-specific fields of this type.  */
 329
 330   union type_specific
 331     {
 332
 333       /* ARG_TYPES is for TYPE_CODE_METHOD.
 334          Contains the type of each argument, ending with a void type
 335          after the last argument for normal member functions or a NULL
 336          pointer after the last argument for functions with variable
 337          arguments.  */
 338
 339       struct type **arg_types;
 340
 341       /* CPLUS_STUFF is for TYPE_CODE_STRUCT.  It is initialized to point to
 342          cplus_struct_default, a default static instance of a struct
 343          cplus_struct_type. */
 344
 345       struct cplus_struct_type *cplus_stuff;
 346
 347     } type_specific;
 348 };
 349
 350 #define NULL_TYPE ((struct type *) 0)
 351
 352 /* C++ language-specific information for TYPE_CODE_STRUCT and TYPE_CODE_UNION
 353    nodes.  */
 354
 355 struct cplus_struct_type
 356 {
 357   /* Number of base classes this type derives from.  The baseclasses are
 358      stored in the first N_BASECLASSES fields (i.e. the `fields' field of
 359      the struct type).  I think only the `type' field of such a field has
 360      any meaning.  */
 361
 362   short n_baseclasses;
 363
 364   /* Number of methods with unique names.  All overloaded methods with
 365      the same name count only once. */
 366
 367   short nfn_fields;
 368
 369   /* Number of methods described for this type, not including the
 370      methods that it derives from.  */
 371
 372   int nfn_fields_total;
 373
 374   /* For derived classes, the number of base classes is given by n_baseclasses
 375      and virtual_field_bits is a bit vector containing one bit per base class.
 376      If the base class is virtual, the corresponding bit will be set.
 377      I.E, given:
 378
 379         class A{};
 380         class B{};
 381         class C : public B, public virtual A {};
 382
 383      B is a baseclass of C; A is a virtual baseclass for C.
 384      This is a C++ 2.0 language feature. */
 385
 386   B_TYPE *virtual_field_bits;
 387
 388   /* For classes with private fields, the number of fields is given by
 389      nfields and private_field_bits is a bit vector containing one bit
 390      per field.
 391      If the field is private, the corresponding bit will be set. */
 392
 393   B_TYPE *private_field_bits;
 394
 395   /* For classes with protected fields, the number of fields is given by
 396      nfields and protected_field_bits is a bit vector containing one bit
 397      per field.
 398      If the field is private, the corresponding bit will be set. */
 399
 400   B_TYPE *protected_field_bits;
 401
 402   /* for classes with fields to be ignored, either this is optimized out
 403      or this field has length 0 */
 404
 405   B_TYPE *ignore_field_bits;
 406
 407   /* For classes, structures, and unions, a description of each field,
 408      which consists of an overloaded name, followed by the types of
 409      arguments that the method expects, and then the name after it
 410      has been renamed to make it distinct.
 411
 412      fn_fieldlists points to an array of nfn_fields of these. */
 413
 414   struct fn_fieldlist
 415     {
 416
 417       /* The overloaded name.  */
 418
 419       char *name;
 420
 421       /* The number of methods with this name.  */
 422
 423       int length;
 424
 425       /* The list of methods.  */
 426
 427       struct fn_field
 428         {
 429
 430           /* If is_stub is clear, this is the mangled name which we can
 431              look up to find the address of the method (FIXME: it would
 432              be cleaner to have a pointer to the struct symbol here
 433              instead).  */
 434
 435           /* If is_stub is set, this is the portion of the mangled
 436              name which specifies the arguments.  For example, "ii",
 437              if there are two int arguments, or "" if there are no
 438              arguments.  See gdb_mangle_name for the conversion from this
 439              format to the one used if is_stub is clear.  */
 440
 441           char *physname;
 442
 443           /* The type of the method.  */
 444
 445           struct type *type;
 446
 447           /* For virtual functions.
 448              First baseclass that defines this virtual function.   */
 449
 450           struct type *fcontext;
 451
 452           /* Attributes. */
 453
 454           unsigned int is_const : 1;
 455           unsigned int is_volatile : 1;
 456           unsigned int is_private : 1;
 457           unsigned int is_protected : 1;
 458
 459           /* A stub method only has some fields valid (but they are enough
 460              to reconstruct the rest of the fields).  */
 461           unsigned int is_stub : 1;
 462
 463           /* Unused.  */
 464           unsigned int dummy : 3;
 465
 466           /* Index into that baseclass's virtual function table,
 467              minus 2; else if static: VOFFSET_STATIC; else: 0.  */
 468
 469           unsigned int voffset : 24;
 470
 471 #         define VOFFSET_STATIC 1
 472
 473         } *fn_fields;
 474
 475     } *fn_fieldlists;
 476
 477 };
 478
 479 /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
 480    this shared static structure. */
 481
 482 extern const struct cplus_struct_type cplus_struct_default;
 483
 484 extern void
 485 allocate_cplus_struct_type PARAMS ((struct type *));
 486
 487 #define INIT_CPLUS_SPECIFIC(type) \
 488   (TYPE_CPLUS_SPECIFIC(type)=(struct cplus_struct_type*)&cplus_struct_default)
 489 #define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
 490 #define HAVE_CPLUS_STRUCT(type) \
 491   (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
 492
 493 #define TYPE_NAME(thistype) (thistype)->name
 494 #define TYPE_TAG_NAME(type) ((type)->tag_name)
 495 #define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
 496 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
 497 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
 498 /* Note that if thistype is a TYPEDEF type, you have to call check_typedef.
 499    But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
 500    so you only have to call check_typedef once.  Since allocate_value
 501    calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe.  */
 502 #define TYPE_LENGTH(thistype) (thistype)->length
 503 #define TYPE_OBJFILE(thistype) (thistype)->objfile
 504 #define TYPE_FLAGS(thistype) (thistype)->flags
 505 #define TYPE_UNSIGNED(thistype) ((thistype)->flags & TYPE_FLAG_UNSIGNED)
 506 /* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you wan the real
 507    type, you need to do TYPE_CODE (check_type (this_type)). */
 508 #define TYPE_CODE(thistype) (thistype)->code
 509 #define TYPE_NFIELDS(thistype) (thistype)->nfields
 510 #define TYPE_FIELDS(thistype) (thistype)->fields
 511
 512 #define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0)
 513 #define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0)
 514 #define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1)
 515
 516 /* Moto-specific stuff for FORTRAN arrays */
 517
 518 #define TYPE_ARRAY_UPPER_BOUND_TYPE(thistype) (thistype)->upper_bound_type
 519 #define TYPE_ARRAY_LOWER_BOUND_TYPE(thistype) (thistype)->lower_bound_type
 520
 521 #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
 522    (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),1))
 523
 524 #define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
 525    (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),0))
 526
 527 /* C++ */
 528
 529 #define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype
 530 #define TYPE_DOMAIN_TYPE(thistype) (thistype)->vptr_basetype
 531 #define TYPE_VPTR_FIELDNO(thistype) (thistype)->vptr_fieldno
 532 #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields
 533 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
 534 #define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total
 535 #define TYPE_TYPE_SPECIFIC(thistype) (thistype)->type_specific
 536 #define TYPE_ARG_TYPES(thistype) (thistype)->type_specific.arg_types
 537 #define TYPE_CPLUS_SPECIFIC(thistype) (thistype)->type_specific.cplus_stuff
 538 #define TYPE_BASECLASS(thistype,index) (thistype)->fields[index].type
 539 #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
 540 #define TYPE_BASECLASS_NAME(thistype,index) (thistype)->fields[index].name
 541 #define TYPE_BASECLASS_BITPOS(thistype,index) (thistype)->fields[index].bitpos
 542 #define BASETYPE_VIA_PUBLIC(thistype, index) (!TYPE_FIELD_PRIVATE(thistype, index))
 543 #define BASETYPE_VIA_VIRTUAL(thistype, index) \
 544   B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index))
 545
 546 #define TYPE_FIELD(thistype, n) (thistype)->fields[n]
 547 #define TYPE_FIELD_TYPE(thistype, n) (thistype)->fields[n].type
 548 #define TYPE_FIELD_NAME(thistype, n) (thistype)->fields[n].name
 549 #define TYPE_FIELD_VALUE(thistype, n) (* (int*) &(thistype)->fields[n].type)
 550 #define TYPE_FIELD_BITPOS(thistype, n) (thistype)->fields[n].bitpos
 551 #define TYPE_FIELD_BITSIZE(thistype, n) (thistype)->fields[n].bitsize
 552 #define TYPE_FIELD_PACKED(thistype, n) (thistype)->fields[n].bitsize
 553
 554 #define TYPE_FIELD_PRIVATE_BITS(thistype) \
 555   TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
 556 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
 557   TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
 558 #define TYPE_FIELD_IGNORE_BITS(thistype) \
 559   TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits
 560 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
 561   TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
 562 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
 563   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
 564 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
 565   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
 566 #define SET_TYPE_FIELD_IGNORE(thistype, n) \
 567   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))
 568 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
 569   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 570 #define TYPE_FIELD_PRIVATE(thistype, n) \
 571   (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \
 572     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)))
 573 #define TYPE_FIELD_PROTECTED(thistype, n) \
 574   (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
 575     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
 576 #define TYPE_FIELD_IGNORE(thistype, n) \
 577   (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \
 578     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)))
 579 #define TYPE_FIELD_VIRTUAL(thistype, n) \
 580        B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 581
 582 #define TYPE_FIELD_STATIC(thistype, n) ((thistype)->fields[n].bitpos == -1)
 583 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) ((char *)(thistype)->fields[n].bitsize)
 584
 585 #define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
 586 #define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
 587 #define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
 588 #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
 589 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
 590
 591 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
 592 #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
 593 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
 594 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)
 595 #define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
 596 #define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
 597 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
 598 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
 599 #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
 600 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
 601 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
 602 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
 603 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
 604
 605 extern struct type *builtin_type_void;
 606 extern struct type *builtin_type_char;
 607 extern struct type *builtin_type_short;
 608 extern struct type *builtin_type_int;
 609 extern struct type *builtin_type_long;
 610 extern struct type *builtin_type_signed_char;
 611 extern struct type *builtin_type_unsigned_char;
 612 extern struct type *builtin_type_unsigned_short;
 613 extern struct type *builtin_type_unsigned_int;
 614 extern struct type *builtin_type_unsigned_long;
 615 extern struct type *builtin_type_float;
 616 extern struct type *builtin_type_double;
 617 extern struct type *builtin_type_long_double;
 618 extern struct type *builtin_type_complex;
 619 extern struct type *builtin_type_double_complex;
 620 extern struct type *builtin_type_string;
 621
 622 /* This type represents a type that was unrecognized in symbol
 623    read-in.  */
 624
 625 extern struct type *builtin_type_error;
 626
 627 extern struct type *builtin_type_long_long;
 628 extern struct type *builtin_type_unsigned_long_long;
 629
 630 /* Modula-2 types */
 631
 632 extern struct type *builtin_type_m2_char;
 633 extern struct type *builtin_type_m2_int;
 634 extern struct type *builtin_type_m2_card;
 635 extern struct type *builtin_type_m2_real;
 636 extern struct type *builtin_type_m2_bool;
 637
 638 /* Chill types */
 639
 640 extern struct type *builtin_type_chill_bool;
 641 extern struct type *builtin_type_chill_char;
 642 extern struct type *builtin_type_chill_long;
 643 extern struct type *builtin_type_chill_ulong;
 644 extern struct type *builtin_type_chill_real;
 645
 646 /* Fortran (F77) types */
 647
 648 extern struct type *builtin_type_f_character;
 649 extern struct type *builtin_type_f_integer;
 650 extern struct type *builtin_type_f_logical;
 651 extern struct type *builtin_type_f_logical_s1;
 652 extern struct type *builtin_type_f_logical_s2;
 653 extern struct type *builtin_type_f_integer;
 654 extern struct type *builtin_type_f_integer_s2;
 655 extern struct type *builtin_type_f_real;
 656 extern struct type *builtin_type_f_real_s8;
 657 extern struct type *builtin_type_f_real_s16;
 658 extern struct type *builtin_type_f_complex_s8;
 659 extern struct type *builtin_type_f_complex_s16;
 660 extern struct type *builtin_type_f_complex_s32;
 661 extern struct type *builtin_type_f_void;
 662
 663 /* Maximum and minimum values of built-in types */
 664
 665 #define MAX_OF_TYPE(t)  \
 666    TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) \
 667     : MAX_OF_SIZE(TYPE_LENGTH(t))
 668
 669 #define MIN_OF_TYPE(t)  \
 670    TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \
 671     : MIN_OF_SIZE(TYPE_LENGTH(t))
 672
 673 /* Allocate space for storing data associated with a particular type.
 674    We ensure that the space is allocated using the same mechanism that
 675    was used to allocate the space for the type structure itself.  I.E.
 676    if the type is on an objfile's type_obstack, then the space for data
 677    associated with that type will also be allocated on the type_obstack.
 678    If the type is not associated with any particular objfile (such as
 679    builtin types), then the data space will be allocated with xmalloc,
 680    the same as for the type structure. */
 681
 682 #define TYPE_ALLOC(t,size)  \
 683    (TYPE_OBJFILE (t) != NULL  \
 684     ? obstack_alloc (&TYPE_OBJFILE (t) -> type_obstack, size) \
 685     : xmalloc (size))
 686
 687 extern struct type *
 688 alloc_type PARAMS ((struct objfile *));
 689
 690 extern struct type *
 691 init_type PARAMS ((enum type_code, int, int, char *, struct objfile *));
 692
 693 extern struct type *
 694 lookup_reference_type PARAMS ((struct type *));
 695
 696 extern struct type *
 697 make_reference_type PARAMS ((struct type *, struct type **));
 698
 699 extern struct type *
 700 lookup_member_type PARAMS ((struct type *, struct type *));
 701
 702 extern void
 703 smash_to_method_type PARAMS ((struct type *, struct type *, struct type *,
 704                               struct type **));
 705
 706 extern void
 707 smash_to_member_type PARAMS ((struct type *, struct type *, struct type *));
 708
 709 extern struct type *
 710 allocate_stub_method PARAMS ((struct type *));
 711
 712 extern char *
 713 type_name_no_tag PARAMS ((const struct type *));
 714
 715 extern struct type *
 716 lookup_struct_elt_type PARAMS ((struct type *, char *, int));
 717
 718 extern struct type *
 719 make_pointer_type PARAMS ((struct type *, struct type **));
 720
 721 extern struct type *
 722 lookup_pointer_type PARAMS ((struct type *));
 723
 724 extern struct type *
 725 make_function_type PARAMS ((struct type *, struct type **));
 726
 727 extern struct type *
 728 lookup_function_type PARAMS ((struct type *));
 729
 730 extern struct type *
 731 create_range_type PARAMS ((struct type *, struct type *, int, int));
 732
 733 extern struct type *
 734 create_array_type PARAMS ((struct type *, struct type *, struct type *));
 735
 736 extern struct type *
 737 create_string_type PARAMS ((struct type *, struct type *));
 738
 739 extern struct type *create_set_type PARAMS ((struct type *, struct type *));
 740
 741 extern int chill_varying_type PARAMS ((struct type*));
 742
 743 extern struct type *
 744 lookup_unsigned_typename PARAMS ((char *));
 745
 746 extern struct type *
 747 lookup_signed_typename PARAMS ((char *));
 748
 749 extern struct type *
 750 check_typedef PARAMS ((struct type *));
 751
 752 #define CHECK_TYPEDEF(TYPE) (TYPE) = check_typedef (TYPE)
 753
 754 extern void
 755 check_stub_method PARAMS ((struct type *, int, int));
 756
 757 extern struct type *
 758 lookup_primitive_typename PARAMS ((char *));
 759
 760 extern char *
 761 gdb_mangle_name PARAMS ((struct type *, int, int));
 762
 763 extern struct type *
 764 builtin_type PARAMS ((char **));
 765
 766 extern struct type *
 767 lookup_typename PARAMS ((char *, struct block *, int));
 768
 769 extern struct type *
 770 lookup_template_type PARAMS ((char *, struct type *, struct block *));
 771
 772 extern struct type *
 773 lookup_fundamental_type PARAMS ((struct objfile *, int));
 774
 775 extern void
 776 fill_in_vptr_fieldno PARAMS ((struct type *));
 777
 778 extern int get_destructor_fn_field PARAMS ((struct type *, int *, int *));
 779
 780 extern int get_discrete_bounds PARAMS ((struct type*, LONGEST*, LONGEST*));
 781
 782 #if MAINTENANCE_CMDS
 783 extern void recursive_dump_type PARAMS ((struct type *, int));
 784 #endif
 785
 786 /* printcmd.c */
 787
 788 extern void
 789 print_scalar_formatted PARAMS ((char *, struct type *, int, int, GDB_FILE *));
 790
 791 extern int can_dereference PARAMS ((struct type *));
 792
 793 #if MAINTENANCE_CMDS
 794 extern void maintenance_print_type PARAMS ((char *, int));
 795 #endif
 796
 797 /* typeprint.c */
 798
 799 extern void print_type_scalar PARAMS ((struct type *, LONGEST, GDB_FILE *));
 800
 801 #endif  /* GDBTYPES_H */