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
 276
 277       union field_location
 278         {
 279           /* Position of this field, counting in bits from start of
 280              containing structure.
 281              For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB.
 282              For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB.
 283              For a function type, this is the position in the argument list
 284              of this argument.
 285              For a range bound or enum value, this is the value itself. */
 286
 287           int bitpos;
 288
 289           /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr
 290              is the location (in the target) of the static field.
 291              Otherwise, physname is the mangled label of the static field. */
 292
 293           CORE_ADDR physaddr;
 294           char* physname;
 295       } loc;
 296
 297       /* Size of this field, in bits, or zero if not packed.
 298          For an unpacked field, the field's type's length
 299          says how many bytes the field occupies.
 300          A value of -1 or -2 indicates a static field;  -1 means the location
 301          is specified by the label loc.physname;  -2 means that loc.physaddr
 302          specifies the actual address. */
 303
 304       int bitsize;
 305
 306       /* In a struct or union type, type of this field.
 307          In a function type, type of this argument.
 308          In an array type, the domain-type of the array.  */
 309
 310       struct type *type;
 311
 312       /* Name of field, value or argument.
 313          NULL for range bounds and array domains.  */
 314
 315       char *name;
 316
 317     } *fields;
 318
 319   /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE
 320      is the base class which defined the virtual function table pointer.
 321
 322      For types that are pointer to member types (TYPE_CODE_MEMBER),
 323      VPTR_BASETYPE is the type that this pointer is a member of.
 324
 325      For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate
 326      type that contains the method.
 327
 328      Unused otherwise.  */
 329
 330   struct type *vptr_basetype;
 331
 332   /* Field number of the virtual function table pointer in
 333      VPTR_BASETYPE.  If -1, we were unable to find the virtual
 334      function table pointer in initial symbol reading, and
 335      fill_in_vptr_fieldno should be called to find it if possible.
 336
 337      Unused if this type does not have virtual functions.  */
 338
 339   int vptr_fieldno;
 340
 341   /* Slot to point to additional language-specific fields of this type.  */
 342
 343   union type_specific
 344     {
 345
 346       /* ARG_TYPES is for TYPE_CODE_METHOD.
 347          Contains the type of each argument, ending with a void type
 348          after the last argument for normal member functions or a NULL
 349          pointer after the last argument for functions with variable
 350          arguments.  */
 351
 352       struct type **arg_types;
 353
 354       /* CPLUS_STUFF is for TYPE_CODE_STRUCT.  It is initialized to point to
 355          cplus_struct_default, a default static instance of a struct
 356          cplus_struct_type. */
 357
 358       struct cplus_struct_type *cplus_stuff;
 359
 360     } type_specific;
 361 };
 362
 363 #define NULL_TYPE ((struct type *) 0)
 364
 365 /* C++ language-specific information for TYPE_CODE_STRUCT and TYPE_CODE_UNION
 366    nodes.  */
 367
 368 struct cplus_struct_type
 369 {
 370   /* Number of base classes this type derives from.  The baseclasses are
 371      stored in the first N_BASECLASSES fields (i.e. the `fields' field of
 372      the struct type).  I think only the `type' field of such a field has
 373      any meaning.  */
 374
 375   short n_baseclasses;
 376
 377   /* Number of methods with unique names.  All overloaded methods with
 378      the same name count only once. */
 379
 380   short nfn_fields;
 381
 382   /* Number of methods described for this type, not including the
 383      methods that it derives from.  */
 384
 385   int nfn_fields_total;
 386
 387   /* For derived classes, the number of base classes is given by n_baseclasses
 388      and virtual_field_bits is a bit vector containing one bit per base class.
 389      If the base class is virtual, the corresponding bit will be set.
 390      I.E, given:
 391
 392         class A{};
 393         class B{};
 394         class C : public B, public virtual A {};
 395
 396      B is a baseclass of C; A is a virtual baseclass for C.
 397      This is a C++ 2.0 language feature. */
 398
 399   B_TYPE *virtual_field_bits;
 400
 401   /* For classes with private fields, the number of fields is given by
 402      nfields and private_field_bits is a bit vector containing one bit
 403      per field.
 404      If the field is private, the corresponding bit will be set. */
 405
 406   B_TYPE *private_field_bits;
 407
 408   /* For classes with protected fields, the number of fields is given by
 409      nfields and protected_field_bits is a bit vector containing one bit
 410      per field.
 411      If the field is private, the corresponding bit will be set. */
 412
 413   B_TYPE *protected_field_bits;
 414
 415   /* for classes with fields to be ignored, either this is optimized out
 416      or this field has length 0 */
 417
 418   B_TYPE *ignore_field_bits;
 419
 420   /* For classes, structures, and unions, a description of each field,
 421      which consists of an overloaded name, followed by the types of
 422      arguments that the method expects, and then the name after it
 423      has been renamed to make it distinct.
 424
 425      fn_fieldlists points to an array of nfn_fields of these. */
 426
 427   struct fn_fieldlist
 428     {
 429
 430       /* The overloaded name.  */
 431
 432       char *name;
 433
 434       /* The number of methods with this name.  */
 435
 436       int length;
 437
 438       /* The list of methods.  */
 439
 440       struct fn_field
 441         {
 442
 443           /* If is_stub is clear, this is the mangled name which we can
 444              look up to find the address of the method (FIXME: it would
 445              be cleaner to have a pointer to the struct symbol here
 446              instead).  */
 447
 448           /* If is_stub is set, this is the portion of the mangled
 449              name which specifies the arguments.  For example, "ii",
 450              if there are two int arguments, or "" if there are no
 451              arguments.  See gdb_mangle_name for the conversion from this
 452              format to the one used if is_stub is clear.  */
 453
 454           char *physname;
 455
 456           /* The type of the method.  */
 457
 458           struct type *type;
 459
 460           /* For virtual functions.
 461              First baseclass that defines this virtual function.   */
 462
 463           struct type *fcontext;
 464
 465           /* Attributes. */
 466
 467           unsigned int is_const : 1;
 468           unsigned int is_volatile : 1;
 469           unsigned int is_private : 1;
 470           unsigned int is_protected : 1;
 471
 472           /* A stub method only has some fields valid (but they are enough
 473              to reconstruct the rest of the fields).  */
 474           unsigned int is_stub : 1;
 475
 476           /* Unused.  */
 477           unsigned int dummy : 3;
 478
 479           /* Index into that baseclass's virtual function table,
 480              minus 2; else if static: VOFFSET_STATIC; else: 0.  */
 481
 482           unsigned int voffset : 24;
 483
 484 #         define VOFFSET_STATIC 1
 485
 486         } *fn_fields;
 487
 488     } *fn_fieldlists;
 489
 490 };
 491
 492 /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
 493    this shared static structure. */
 494
 495 extern const struct cplus_struct_type cplus_struct_default;
 496
 497 extern void
 498 allocate_cplus_struct_type PARAMS ((struct type *));
 499
 500 #define INIT_CPLUS_SPECIFIC(type) \
 501   (TYPE_CPLUS_SPECIFIC(type)=(struct cplus_struct_type*)&cplus_struct_default)
 502 #define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
 503 #define HAVE_CPLUS_STRUCT(type) \
 504   (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
 505
 506 #define TYPE_NAME(thistype) (thistype)->name
 507 #define TYPE_TAG_NAME(type) ((type)->tag_name)
 508 #define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
 509 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
 510 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
 511 /* Note that if thistype is a TYPEDEF type, you have to call check_typedef.
 512    But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
 513    so you only have to call check_typedef once.  Since allocate_value
 514    calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe.  */
 515 #define TYPE_LENGTH(thistype) (thistype)->length
 516 #define TYPE_OBJFILE(thistype) (thistype)->objfile
 517 #define TYPE_FLAGS(thistype) (thistype)->flags
 518 #define TYPE_UNSIGNED(thistype) ((thistype)->flags & TYPE_FLAG_UNSIGNED)
 519 /* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you wan the real
 520    type, you need to do TYPE_CODE (check_type (this_type)). */
 521 #define TYPE_CODE(thistype) (thistype)->code
 522 #define TYPE_NFIELDS(thistype) (thistype)->nfields
 523 #define TYPE_FIELDS(thistype) (thistype)->fields
 524
 525 #define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0)
 526 #define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0)
 527 #define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1)
 528
 529 /* Moto-specific stuff for FORTRAN arrays */
 530
 531 #define TYPE_ARRAY_UPPER_BOUND_TYPE(thistype) (thistype)->upper_bound_type
 532 #define TYPE_ARRAY_LOWER_BOUND_TYPE(thistype) (thistype)->lower_bound_type
 533
 534 #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
 535    (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),1))
 536
 537 #define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
 538    (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),0))
 539
 540 /* C++ */
 541
 542 #define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype
 543 #define TYPE_DOMAIN_TYPE(thistype) (thistype)->vptr_basetype
 544 #define TYPE_VPTR_FIELDNO(thistype) (thistype)->vptr_fieldno
 545 #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields
 546 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
 547 #define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total
 548 #define TYPE_TYPE_SPECIFIC(thistype) (thistype)->type_specific
 549 #define TYPE_ARG_TYPES(thistype) (thistype)->type_specific.arg_types
 550 #define TYPE_CPLUS_SPECIFIC(thistype) (thistype)->type_specific.cplus_stuff
 551 #define TYPE_BASECLASS(thistype,index) (thistype)->fields[index].type
 552 #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
 553 #define TYPE_BASECLASS_NAME(thistype,index) (thistype)->fields[index].name
 554 #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index)
 555 #define BASETYPE_VIA_PUBLIC(thistype, index) (!TYPE_FIELD_PRIVATE(thistype, index))
 556 #define BASETYPE_VIA_VIRTUAL(thistype, index) \
 557   B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index))
 558
 559 #define FIELD_TYPE(thisfld) ((thisfld).type)
 560 #define FIELD_NAME(thisfld) ((thisfld).name)
 561 #define FIELD_BITPOS(thisfld) ((thisfld).loc.bitpos)
 562 #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
 563 #define FIELD_PHYSNAME(thisfld) ((thisfld).loc.physname)
 564 #define FIELD_PHYSADDR(thisfld) ((thisfld).loc.physaddr)
 565 #define SET_FIELD_PHYSNAME(thisfld, name) \
 566   ((thisfld).bitsize = -1, FIELD_PHYSNAME(thisfld) = (name))
 567 #define SET_FIELD_PHYSADDR(thisfld, name) \
 568   ((thisfld).bitsize = -2, FIELD_PHYSADDR(thisfld) = (name))
 569 #define TYPE_FIELD(thistype, n) (thistype)->fields[n]
 570 #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n))
 571 #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n))
 572 #define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS(TYPE_FIELD(thistype,n))
 573 #define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE(TYPE_FIELD(thistype,n))
 574 #define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE(TYPE_FIELD(thistype,n))!=0)
 575
 576 #define TYPE_FIELD_PRIVATE_BITS(thistype) \
 577   TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
 578 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
 579   TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
 580 #define TYPE_FIELD_IGNORE_BITS(thistype) \
 581   TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits
 582 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
 583   TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
 584 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
 585   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
 586 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
 587   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
 588 #define SET_TYPE_FIELD_IGNORE(thistype, n) \
 589   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))
 590 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
 591   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 592 #define TYPE_FIELD_PRIVATE(thistype, n) \
 593   (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \
 594     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)))
 595 #define TYPE_FIELD_PROTECTED(thistype, n) \
 596   (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
 597     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
 598 #define TYPE_FIELD_IGNORE(thistype, n) \
 599   (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \
 600     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)))
 601 #define TYPE_FIELD_VIRTUAL(thistype, n) \
 602        B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 603
 604 #define TYPE_FIELD_STATIC(thistype, n) ((thistype)->fields[n].bitsize < 0)
 605 #define TYPE_FIELD_STATIC_HAS_ADDR(thistype, n) ((thistype)->fields[n].bitsize == -2)
 606 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_PHYSNAME(TYPE_FIELD(thistype, n))
 607 #define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_PHYSADDR(TYPE_FIELD(thistype, n))
 608
 609 #define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
 610 #define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
 611 #define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
 612 #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
 613 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
 614
 615 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
 616 #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
 617 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
 618 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)
 619 #define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
 620 #define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
 621 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
 622 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
 623 #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
 624 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
 625 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
 626 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
 627 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
 628
 629 extern struct type *builtin_type_void;
 630 extern struct type *builtin_type_char;
 631 extern struct type *builtin_type_short;
 632 extern struct type *builtin_type_int;
 633 extern struct type *builtin_type_long;
 634 extern struct type *builtin_type_signed_char;
 635 extern struct type *builtin_type_unsigned_char;
 636 extern struct type *builtin_type_unsigned_short;
 637 extern struct type *builtin_type_unsigned_int;
 638 extern struct type *builtin_type_unsigned_long;
 639 extern struct type *builtin_type_float;
 640 extern struct type *builtin_type_double;
 641 extern struct type *builtin_type_long_double;
 642 extern struct type *builtin_type_complex;
 643 extern struct type *builtin_type_double_complex;
 644 extern struct type *builtin_type_string;
 645
 646 /* This type represents a type that was unrecognized in symbol
 647    read-in.  */
 648
 649 extern struct type *builtin_type_error;
 650
 651 extern struct type *builtin_type_long_long;
 652 extern struct type *builtin_type_unsigned_long_long;
 653
 654 /* Modula-2 types */
 655
 656 extern struct type *builtin_type_m2_char;
 657 extern struct type *builtin_type_m2_int;
 658 extern struct type *builtin_type_m2_card;
 659 extern struct type *builtin_type_m2_real;
 660 extern struct type *builtin_type_m2_bool;
 661
 662 /* Chill types */
 663
 664 extern struct type *builtin_type_chill_bool;
 665 extern struct type *builtin_type_chill_char;
 666 extern struct type *builtin_type_chill_long;
 667 extern struct type *builtin_type_chill_ulong;
 668 extern struct type *builtin_type_chill_real;
 669
 670 /* Fortran (F77) types */
 671
 672 extern struct type *builtin_type_f_character;
 673 extern struct type *builtin_type_f_integer;
 674 extern struct type *builtin_type_f_logical;
 675 extern struct type *builtin_type_f_logical_s1;
 676 extern struct type *builtin_type_f_logical_s2;
 677 extern struct type *builtin_type_f_integer;
 678 extern struct type *builtin_type_f_integer_s2;
 679 extern struct type *builtin_type_f_real;
 680 extern struct type *builtin_type_f_real_s8;
 681 extern struct type *builtin_type_f_real_s16;
 682 extern struct type *builtin_type_f_complex_s8;
 683 extern struct type *builtin_type_f_complex_s16;
 684 extern struct type *builtin_type_f_complex_s32;
 685 extern struct type *builtin_type_f_void;
 686
 687 /* Maximum and minimum values of built-in types */
 688
 689 #define MAX_OF_TYPE(t)  \
 690    TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) \
 691     : MAX_OF_SIZE(TYPE_LENGTH(t))
 692
 693 #define MIN_OF_TYPE(t)  \
 694    TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \
 695     : MIN_OF_SIZE(TYPE_LENGTH(t))
 696
 697 /* Allocate space for storing data associated with a particular type.
 698    We ensure that the space is allocated using the same mechanism that
 699    was used to allocate the space for the type structure itself.  I.E.
 700    if the type is on an objfile's type_obstack, then the space for data
 701    associated with that type will also be allocated on the type_obstack.
 702    If the type is not associated with any particular objfile (such as
 703    builtin types), then the data space will be allocated with xmalloc,
 704    the same as for the type structure. */
 705
 706 #define TYPE_ALLOC(t,size)  \
 707    (TYPE_OBJFILE (t) != NULL  \
 708     ? obstack_alloc (&TYPE_OBJFILE (t) -> type_obstack, size) \
 709     : xmalloc (size))
 710
 711 extern struct type *
 712 alloc_type PARAMS ((struct objfile *));
 713
 714 extern struct type *
 715 init_type PARAMS ((enum type_code, int, int, char *, struct objfile *));
 716
 717 extern struct type *
 718 lookup_reference_type PARAMS ((struct type *));
 719
 720 extern struct type *
 721 make_reference_type PARAMS ((struct type *, struct type **));
 722
 723 extern struct type *
 724 lookup_member_type PARAMS ((struct type *, struct type *));
 725
 726 extern void
 727 smash_to_method_type PARAMS ((struct type *, struct type *, struct type *,
 728                               struct type **));
 729
 730 extern void
 731 smash_to_member_type PARAMS ((struct type *, struct type *, struct type *));
 732
 733 extern struct type *
 734 allocate_stub_method PARAMS ((struct type *));
 735
 736 extern char *
 737 type_name_no_tag PARAMS ((const struct type *));
 738
 739 extern struct type *
 740 lookup_struct_elt_type PARAMS ((struct type *, char *, int));
 741
 742 extern struct type *
 743 make_pointer_type PARAMS ((struct type *, struct type **));
 744
 745 extern struct type *
 746 lookup_pointer_type PARAMS ((struct type *));
 747
 748 extern struct type *
 749 make_function_type PARAMS ((struct type *, struct type **));
 750
 751 extern struct type *
 752 lookup_function_type PARAMS ((struct type *));
 753
 754 extern struct type *
 755 create_range_type PARAMS ((struct type *, struct type *, int, int));
 756
 757 extern struct type *
 758 create_array_type PARAMS ((struct type *, struct type *, struct type *));
 759
 760 extern struct type *
 761 create_string_type PARAMS ((struct type *, struct type *));
 762
 763 extern struct type *create_set_type PARAMS ((struct type *, struct type *));
 764
 765 extern int chill_varying_type PARAMS ((struct type*));
 766
 767 extern struct type *
 768 lookup_unsigned_typename PARAMS ((char *));
 769
 770 extern struct type *
 771 lookup_signed_typename PARAMS ((char *));
 772
 773 extern struct type *
 774 check_typedef PARAMS ((struct type *));
 775
 776 #define CHECK_TYPEDEF(TYPE) (TYPE) = check_typedef (TYPE)
 777
 778 extern void
 779 check_stub_method PARAMS ((struct type *, int, int));
 780
 781 extern struct type *
 782 lookup_primitive_typename PARAMS ((char *));
 783
 784 extern char *
 785 gdb_mangle_name PARAMS ((struct type *, int, int));
 786
 787 extern struct type *
 788 builtin_type PARAMS ((char **));
 789
 790 extern struct type *
 791 lookup_typename PARAMS ((char *, struct block *, int));
 792
 793 extern struct type *
 794 lookup_template_type PARAMS ((char *, struct type *, struct block *));
 795
 796 extern struct type *
 797 lookup_fundamental_type PARAMS ((struct objfile *, int));
 798
 799 extern void
 800 fill_in_vptr_fieldno PARAMS ((struct type *));
 801
 802 extern int get_destructor_fn_field PARAMS ((struct type *, int *, int *));
 803
 804 extern int get_discrete_bounds PARAMS ((struct type*, LONGEST*, LONGEST*));
 805
 806 #if MAINTENANCE_CMDS
 807 extern void recursive_dump_type PARAMS ((struct type *, int));
 808 #endif
 809
 810 /* printcmd.c */
 811
 812 extern void
 813 print_scalar_formatted PARAMS ((char *, struct type *, int, int, GDB_FILE *));
 814
 815 extern int can_dereference PARAMS ((struct type *));
 816
 817 #if MAINTENANCE_CMDS
 818 extern void maintenance_print_type PARAMS ((char *, int));
 819 #endif
 820
 821 /* typeprint.c */
 822
 823 extern void print_type_scalar PARAMS ((struct type *, LONGEST, GDB_FILE *));
 824
 825 #endif  /* GDBTYPES_H */