gdb/gdbtypes.h

   1 /* Internal type definitions for GDB.
   2    Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4    Contributed by Cygnus Support, using pieces from other GDB modules.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #if !defined (GDBTYPES_H)
  24 #define GDBTYPES_H 1
  25
  26 /* Forward declarations for prototypes.  */
  27 struct block;
  28
  29 /* Codes for `fundamental types'.  This is a monstrosity based on the
  30    bogus notion that there are certain compiler-independent
  31    `fundamental types'.  None of these is well-defined (how big is
  32    FT_SHORT?  Does it depend on the language?  How does the
  33    language-specific code know which type to correlate to FT_SHORT?)  */
  34
  35 #define FT_VOID                 0
  36 #define FT_BOOLEAN              1
  37 #define FT_CHAR                 2       /* we use this for not-unsigned C/C++ chars */
  38 #define FT_SIGNED_CHAR          3       /* we use this for C++ signed chars */
  39 #define FT_UNSIGNED_CHAR        4       /* we use this for C/C++ unsigned chars */
  40 #define FT_SHORT                5
  41 #define FT_SIGNED_SHORT         6
  42 #define FT_UNSIGNED_SHORT       7
  43 #define FT_INTEGER              8
  44 #define FT_SIGNED_INTEGER       9
  45 #define FT_UNSIGNED_INTEGER     10
  46 #define FT_LONG                 11
  47 #define FT_SIGNED_LONG          12
  48 #define FT_UNSIGNED_LONG        13
  49 #define FT_LONG_LONG            14
  50 #define FT_SIGNED_LONG_LONG     15
  51 #define FT_UNSIGNED_LONG_LONG   16
  52 #define FT_FLOAT                17
  53 #define FT_DBL_PREC_FLOAT       18
  54 #define FT_EXT_PREC_FLOAT       19
  55 #define FT_COMPLEX              20
  56 #define FT_DBL_PREC_COMPLEX     21
  57 #define FT_EXT_PREC_COMPLEX     22
  58 #define FT_STRING               23
  59 #define FT_FIXED_DECIMAL        24
  60 #define FT_FLOAT_DECIMAL        25
  61 #define FT_BYTE                 26
  62 #define FT_UNSIGNED_BYTE        27
  63 #define FT_TEMPLATE_ARG         28
  64
  65 #define FT_NUM_MEMBERS          29      /* Highest FT_* above, plus one. */
  66
  67 /* Some macros for char-based bitfields.  */
  68
  69 #define B_SET(a,x)      ((a)[(x)>>3] |= (1 << ((x)&7)))
  70 #define B_CLR(a,x)      ((a)[(x)>>3] &= ~(1 << ((x)&7)))
  71 #define B_TST(a,x)      ((a)[(x)>>3] & (1 << ((x)&7)))
  72 #define B_TYPE          unsigned char
  73 #define B_BYTES(x)      ( 1 + ((x)>>3) )
  74 #define B_CLRALL(a,x)   memset ((a), 0, B_BYTES(x))
  75
  76 /* Different kinds of data types are distinguished by the `code' field.  */
  77
  78 enum type_code
  79   {
  80     TYPE_CODE_UNDEF,            /* Not used; catches errors */
  81     TYPE_CODE_PTR,              /* Pointer type */
  82     TYPE_CODE_ARRAY,            /* Array type with lower & upper bounds. */
  83     TYPE_CODE_STRUCT,           /* C struct or Pascal record */
  84     TYPE_CODE_UNION,            /* C union or Pascal variant part */
  85     TYPE_CODE_ENUM,             /* Enumeration type */
  86     TYPE_CODE_FUNC,             /* Function type */
  87     TYPE_CODE_INT,              /* Integer type */
  88
  89     /* Floating type.  This is *NOT* a complex type.  Beware, there are parts
  90        of GDB which bogusly assume that TYPE_CODE_FLT can mean complex.  */
  91     TYPE_CODE_FLT,
  92
  93     /* Void type.  The length field specifies the length (probably always
  94        one) which is used in pointer arithmetic involving pointers to
  95        this type, but actually dereferencing such a pointer is invalid;
  96        a void type has no length and no actual representation in memory
  97        or registers.  A pointer to a void type is a generic pointer.  */
  98     TYPE_CODE_VOID,
  99
 100     TYPE_CODE_SET,              /* Pascal sets */
 101     TYPE_CODE_RANGE,            /* Range (integers within spec'd bounds) */
 102
 103     /* A string type which is like an array of character but prints
 104        differently (at least for CHILL).  It does not contain a length
 105        field as Pascal strings (for many Pascals, anyway) do; if we want
 106        to deal with such strings, we should use a new type code.  */
 107     TYPE_CODE_STRING,
 108
 109     /* String of bits; like TYPE_CODE_SET but prints differently (at least
 110        for CHILL).  */
 111     TYPE_CODE_BITSTRING,
 112
 113     /* Unknown type.  The length field is valid if we were able to
 114        deduce that much about the type, or 0 if we don't even know that.  */
 115     TYPE_CODE_ERROR,
 116
 117     /* C++ */
 118     TYPE_CODE_MEMBER,           /* Member type */
 119     TYPE_CODE_METHOD,           /* Method type */
 120     TYPE_CODE_REF,              /* C++ Reference types */
 121
 122     TYPE_CODE_CHAR,             /* *real* character type */
 123
 124     /* Boolean type.  0 is false, 1 is true, and other values are non-boolean
 125        (e.g. FORTRAN "logical" used as unsigned int).  */
 126     TYPE_CODE_BOOL,
 127
 128     /* Fortran */
 129     TYPE_CODE_COMPLEX,          /* Complex float */
 130
 131     TYPE_CODE_TYPEDEF,
 132     TYPE_CODE_TEMPLATE,         /* C++ template */
 133     TYPE_CODE_TEMPLATE_ARG      /* C++ template arg */
 134
 135   };
 136
 137 /* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an
 138    alias for TYPE_CODE_STRUCT.  This is for DWARF, which has a distinct
 139    "class" attribute.  Perhaps we should actually have a separate TYPE_CODE
 140    so that we can print "class" or "struct" depending on what the debug
 141    info said.  It's not clear we should bother.  */
 142
 143 #define TYPE_CODE_CLASS TYPE_CODE_STRUCT
 144
 145 /* Some bits for the type's flags word. */
 146
 147 /* Unsigned integer type.  If this is not set for a TYPE_CODE_INT, the
 148    type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */
 149
 150 #define TYPE_FLAG_UNSIGNED      (1 << 0)
 151
 152 /* No sign for this type.  In C++, "char", "signed char", and "unsigned
 153    char" are distinct types; so we need an extra flag to indicate the
 154    absence of a sign! */
 155
 156 #define TYPE_FLAG_NOSIGN        (1 << 1)
 157
 158 /* This appears in a type's flags word if it is a stub type (e.g., if
 159    someone referenced a type that wasn't defined in a source file
 160    via (struct sir_not_appearing_in_this_film *)).  */
 161
 162 #define TYPE_FLAG_STUB          (1 << 2)
 163
 164 /* The target type of this type is a stub type, and this type needs to
 165    be updated if it gets un-stubbed in check_typedef.
 166    Used for arrays and ranges, in which TYPE_LENGTH of the array/range
 167    gets set based on the TYPE_LENGTH of the target type.
 168    Also, set for TYPE_CODE_TYPEDEF. */
 169
 170 #define TYPE_FLAG_TARGET_STUB (1 << 3)
 171
 172 /* Static type.  If this is set, the corresponding type had
 173  * a static modifier.
 174  * Note: This may be unnecessary, since static data members
 175  * are indicated by other means (bitpos == -1)
 176  */
 177
 178 #define TYPE_FLAG_STATIC (1 << 4)
 179
 180 /* Constant type.  If this is set, the corresponding type has a
 181  * const modifier.
 182  */
 183
 184 #define TYPE_FLAG_CONST (1 << 5)
 185
 186 /* Volatile type.  If this is set, the corresponding type has a
 187  * volatile modifier.
 188  */
 189
 190 #define TYPE_FLAG_VOLATILE (1 << 6)
 191
 192
 193 /* This is a function type which appears to have a prototype.  We need this
 194    for function calls in order to tell us if it's necessary to coerce the args,
 195    or to just do the standard conversions.  This is used with a short field. */
 196
 197 #define TYPE_FLAG_PROTOTYPED (1 << 7)
 198
 199 /* This flag is used to indicate that processing for this type
 200    is incomplete.
 201
 202    (Mostly intended for HP platforms, where class methods, for
 203    instance, can be encountered before their classes in the debug
 204    info; the incomplete type has to be marked so that the class and
 205    the method can be assigned correct types.) */
 206
 207 #define TYPE_FLAG_INCOMPLETE (1 << 8)
 208
 209 /* Instruction-space delimited type.  This is for Harvard architectures
 210    which have separate instruction and data address spaces (and perhaps
 211    others).
 212
 213    GDB usually defines a flat address space that is a superset of the
 214    architecture's two (or more) address spaces, but this is an extension
 215    of the architecture's model.
 216
 217    If TYPE_FLAG_INST is set, an object of the corresponding type
 218    resides in instruction memory, even if its address (in the extended
 219    flat address space) does not reflect this.
 220
 221    Similarly, if TYPE_FLAG_DATA is set, then an object of the
 222    corresponding type resides in the data memory space, even if
 223    this is not indicated by its (flat address space) address.
 224
 225    If neither flag is set, the default space for functions / methods
 226    is instruction space, and for data objects is data memory.  */
 227
 228 #define TYPE_FLAG_CODE_SPACE (1 << 9)
 229 #define TYPE_FLAG_DATA_SPACE (1 << 10)
 230
 231 /* FIXME: Kludge to mark a varargs function type for C++ member
 232    function argument processing.  Currently only used in dwarf2read.c,
 233    but put it here so we won't accidentally overload the bit with
 234    another flag.  */
 235
 236 #define TYPE_FLAG_VARARGS (1 << 11)
 237
 238 struct type
 239   {
 240
 241     /* Code for kind of type */
 242
 243     enum type_code code;
 244
 245     /* Name of this type, or NULL if none.
 246
 247        This is used for printing only, except by poorly designed C++ code.
 248        For looking up a name, look for a symbol in the VAR_NAMESPACE.  */
 249
 250     char *name;
 251
 252     /* Tag name for this type, or NULL if none.  This means that the
 253        name of the type consists of a keyword followed by the tag name.
 254        Which keyword is determined by the type code ("struct" for
 255        TYPE_CODE_STRUCT, etc.).  As far as I know C/C++ are the only languages
 256        with this feature.
 257
 258        This is used for printing only, except by poorly designed C++ code.
 259        For looking up a name, look for a symbol in the STRUCT_NAMESPACE.
 260        One more legitimate use is that if TYPE_FLAG_STUB is set, this is
 261        the name to use to look for definitions in other files.  */
 262
 263     char *tag_name;
 264
 265     /* Length of storage for a value of this type.  This is what
 266        sizeof(type) would return; use it for address arithmetic,
 267        memory reads and writes, etc.  This size includes padding.  For
 268        example, an i386 extended-precision floating point value really
 269        only occupies ten bytes, but most ABI's declare its size to be
 270        12 bytes, to preserve alignment.  A `struct type' representing
 271        such a floating-point type would have a `length' value of 12,
 272        even though the last two bytes are unused.
 273
 274        There's a bit of a host/target mess here, if you're concerned
 275        about machines whose bytes aren't eight bits long, or who don't
 276        have byte-addressed memory.  Various places pass this to memcpy
 277        and such, meaning it must be in units of host bytes.  Various
 278        other places expect they can calculate addresses by adding it
 279        and such, meaning it must be in units of target bytes.  For
 280        some DSP targets, in which HOST_CHAR_BIT will (presumably) be 8
 281        and TARGET_CHAR_BIT will be (say) 32, this is a problem.
 282
 283        One fix would be to make this field in bits (requiring that it
 284        always be a multiple of HOST_CHAR_BIT and TARGET_CHAR_BIT) ---
 285        the other choice would be to make it consistently in units of
 286        HOST_CHAR_BIT.  However, this would still fail to address
 287        machines based on a ternary or decimal representation.  */
 288     unsigned length;
 289
 290     /* FIXME, these should probably be restricted to a Fortran-specific
 291        field in some fashion.  */
 292 #define BOUND_CANNOT_BE_DETERMINED   5
 293 #define BOUND_BY_REF_ON_STACK        4
 294 #define BOUND_BY_VALUE_ON_STACK      3
 295 #define BOUND_BY_REF_IN_REG          2
 296 #define BOUND_BY_VALUE_IN_REG        1
 297 #define BOUND_SIMPLE                 0
 298     int upper_bound_type;
 299     int lower_bound_type;
 300
 301     /* Every type is now associated with a particular objfile, and the
 302        type is allocated on the type_obstack for that objfile.  One problem
 303        however, is that there are times when gdb allocates new types while
 304        it is not in the process of reading symbols from a particular objfile.
 305        Fortunately, these happen when the type being created is a derived
 306        type of an existing type, such as in lookup_pointer_type().  So
 307        we can just allocate the new type using the same objfile as the
 308        existing type, but to do this we need a backpointer to the objfile
 309        from the existing type.  Yes this is somewhat ugly, but without
 310        major overhaul of the internal type system, it can't be avoided
 311        for now. */
 312
 313     struct objfile *objfile;
 314
 315     /* For a pointer type, describes the type of object pointed to.
 316        For an array type, describes the type of the elements.
 317        For a function or method type, describes the type of the return value.
 318        For a range type, describes the type of the full range.
 319        For a complex type, describes the type of each coordinate.
 320        Unused otherwise.  */
 321
 322     struct type *target_type;
 323
 324     /* Type that is a pointer to this type.
 325        NULL if no such pointer-to type is known yet.
 326        The debugger may add the address of such a type
 327        if it has to construct one later.  */
 328
 329     struct type *pointer_type;
 330
 331     /* C++: also need a reference type.  */
 332
 333     struct type *reference_type;
 334
 335     /* C-v variant chain. This points to a type that
 336        differs from this one only in a const or volatile
 337        attribute (or both). The various c-v variants
 338        are chained together in a ring. */
 339     struct type *cv_type;
 340
 341     /* Address-space delimited variant chain.  This points to a type
 342        that differs from this one only in an address-space qualifier
 343        attribute.  The otherwise-identical address-space delimited
 344        types are chained together in a ring. */
 345     struct type *as_type;
 346
 347     /* Flags about this type.  */
 348
 349     int flags;
 350
 351     /* Number of fields described for this type */
 352
 353     short nfields;
 354
 355     /* For structure and union types, a description of each field.
 356        For set and pascal array types, there is one "field",
 357        whose type is the domain type of the set or array.
 358        For range types, there are two "fields",
 359        the minimum and maximum values (both inclusive).
 360        For enum types, each possible value is described by one "field".
 361        For a function type, a "field" for each parameter type.
 362        For C++ classes, there is one field for each base class (if it is
 363        a derived class) plus one field for each class data member.  Member
 364        functions are recorded elsewhere.
 365
 366        Using a pointer to a separate array of fields
 367        allows all types to have the same size, which is useful
 368        because we can allocate the space for a type before
 369        we know what to put in it.  */
 370
 371     struct field
 372       {
 373
 374
 375
 376         union field_location
 377           {
 378             /* Position of this field, counting in bits from start of
 379                containing structure.
 380                For BITS_BIG_ENDIAN=1 targets, it is the bit offset to the MSB.
 381                For BITS_BIG_ENDIAN=0 targets, it is the bit offset to the LSB.
 382                For a function type, this is the position in the argument list
 383                of this argument.
 384                For a range bound or enum value, this is the value itself. */
 385
 386             int bitpos;
 387
 388             /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr
 389                is the location (in the target) of the static field.
 390                Otherwise, physname is the mangled label of the static field. */
 391
 392             CORE_ADDR physaddr;
 393             char *physname;
 394           }
 395         loc;
 396
 397         /* Size of this field, in bits, or zero if not packed.
 398            For an unpacked field, the field's type's length
 399            says how many bytes the field occupies.
 400            A value of -1 or -2 indicates a static field;  -1 means the location
 401            is specified by the label loc.physname;  -2 means that loc.physaddr
 402            specifies the actual address. */
 403
 404         int bitsize;
 405
 406         /* In a struct or union type, type of this field.
 407            In a function type, type of this argument.
 408            In an array type, the domain-type of the array.  */
 409
 410         struct type *type;
 411
 412         /* Name of field, value or argument.
 413            NULL for range bounds and array domains.  */
 414
 415         char *name;
 416
 417       }
 418      *fields;
 419
 420     /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE
 421        is the base class which defined the virtual function table pointer.
 422
 423        For types that are pointer to member types (TYPE_CODE_MEMBER),
 424        VPTR_BASETYPE is the type that this pointer is a member of.
 425
 426        For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate
 427        type that contains the method.
 428
 429        Unused otherwise.  */
 430
 431     struct type *vptr_basetype;
 432
 433     /* Field number of the virtual function table pointer in
 434        VPTR_BASETYPE.  If -1, we were unable to find the virtual
 435        function table pointer in initial symbol reading, and
 436        fill_in_vptr_fieldno should be called to find it if possible.
 437
 438        Unused if this type does not have virtual functions.  */
 439
 440     int vptr_fieldno;
 441
 442     /* Slot to point to additional language-specific fields of this type.  */
 443
 444     union type_specific
 445       {
 446
 447         /* ARG_TYPES is for TYPE_CODE_METHOD.
 448            Contains the type of each argument, ending with a void type
 449            after the last argument for normal member functions or a NULL
 450            pointer after the last argument for functions with variable
 451            arguments.  */
 452
 453         struct type **arg_types;
 454
 455         /* CPLUS_STUFF is for TYPE_CODE_STRUCT.  It is initialized to point to
 456            cplus_struct_default, a default static instance of a struct
 457            cplus_struct_type. */
 458
 459         struct cplus_struct_type *cplus_stuff;
 460
 461         /* FLOATFORMAT is for TYPE_CODE_FLT.  It is a pointer to the
 462            floatformat object that describes the floating-point value
 463            that resides within the type.  */
 464
 465         const struct floatformat *floatformat;
 466       }
 467     type_specific;
 468   };
 469
 470 #define NULL_TYPE ((struct type *) 0)
 471
 472 /* C++ language-specific information for TYPE_CODE_STRUCT and TYPE_CODE_UNION
 473    nodes.  */
 474
 475 struct cplus_struct_type
 476   {
 477     /* Number of base classes this type derives from.  The baseclasses are
 478        stored in the first N_BASECLASSES fields (i.e. the `fields' field of
 479        the struct type).  I think only the `type' field of such a field has
 480        any meaning.  */
 481
 482     short n_baseclasses;
 483
 484     /* Number of methods with unique names.  All overloaded methods with
 485        the same name count only once. */
 486
 487     short nfn_fields;
 488
 489     /* Number of methods described for this type, not including the
 490        methods that it derives from.  */
 491
 492     short nfn_fields_total;
 493
 494     /* The "declared_type" field contains a code saying how the
 495        user really declared this type, e.g., "class s", "union s",
 496        "struct s".
 497        The 3 above things come out from the C++ compiler looking like classes,
 498        but we keep track of the real declaration so we can give
 499        the correct information on "ptype". (Note: TEMPLATE may not
 500        belong in this list...)  */
 501
 502 #define DECLARED_TYPE_CLASS 0
 503 #define DECLARED_TYPE_UNION 1
 504 #define DECLARED_TYPE_STRUCT 2
 505 #define DECLARED_TYPE_TEMPLATE 3
 506     short declared_type;        /* One of the above codes */
 507
 508     /* For derived classes, the number of base classes is given by n_baseclasses
 509        and virtual_field_bits is a bit vector containing one bit per base class.
 510        If the base class is virtual, the corresponding bit will be set.
 511        I.E, given:
 512
 513        class A{};
 514        class B{};
 515        class C : public B, public virtual A {};
 516
 517        B is a baseclass of C; A is a virtual baseclass for C.
 518        This is a C++ 2.0 language feature. */
 519
 520     B_TYPE *virtual_field_bits;
 521
 522     /* For classes with private fields, the number of fields is given by
 523        nfields and private_field_bits is a bit vector containing one bit
 524        per field.
 525        If the field is private, the corresponding bit will be set. */
 526
 527     B_TYPE *private_field_bits;
 528
 529     /* For classes with protected fields, the number of fields is given by
 530        nfields and protected_field_bits is a bit vector containing one bit
 531        per field.
 532        If the field is private, the corresponding bit will be set. */
 533
 534     B_TYPE *protected_field_bits;
 535
 536     /* for classes with fields to be ignored, either this is optimized out
 537        or this field has length 0 */
 538
 539     B_TYPE *ignore_field_bits;
 540
 541     /* For classes, structures, and unions, a description of each field,
 542        which consists of an overloaded name, followed by the types of
 543        arguments that the method expects, and then the name after it
 544        has been renamed to make it distinct.
 545
 546        fn_fieldlists points to an array of nfn_fields of these. */
 547
 548     struct fn_fieldlist
 549       {
 550
 551         /* The overloaded name.  */
 552
 553         char *name;
 554
 555         /* The number of methods with this name.  */
 556
 557         int length;
 558
 559         /* The list of methods.  */
 560
 561         struct fn_field
 562           {
 563
 564             /* If is_stub is clear, this is the mangled name which we can
 565                look up to find the address of the method (FIXME: it would
 566                be cleaner to have a pointer to the struct symbol here
 567                instead).  */
 568
 569             /* If is_stub is set, this is the portion of the mangled
 570                name which specifies the arguments.  For example, "ii",
 571                if there are two int arguments, or "" if there are no
 572                arguments.  See gdb_mangle_name for the conversion from this
 573                format to the one used if is_stub is clear.  */
 574
 575             char *physname;
 576
 577             /* The function type for the method.
 578                (This comment used to say "The return value of the method",
 579                but that's wrong. The function type
 580                is expected here, i.e. something with TYPE_CODE_FUNC,
 581                and *not* the return-value type). */
 582
 583             struct type *type;
 584
 585             /* The argument list.  Only valid if is_stub is clear.  Contains
 586                the type of each argument, including `this', and ending with
 587                a NULL pointer after the last argument.  Should not contain
 588                a `this' pointer for static member functions.  */
 589
 590             struct type **args;
 591
 592             /* For virtual functions.
 593                First baseclass that defines this virtual function.   */
 594
 595             struct type *fcontext;
 596
 597             /* Attributes. */
 598
 599             unsigned int is_const:1;
 600             unsigned int is_volatile:1;
 601             unsigned int is_private:1;
 602             unsigned int is_protected:1;
 603             unsigned int is_public:1;
 604             unsigned int is_abstract:1;
 605             unsigned int is_static:1;
 606             unsigned int is_final:1;
 607             unsigned int is_synchronized:1;
 608             unsigned int is_native:1;
 609
 610             /* A stub method only has some fields valid (but they are enough
 611                to reconstruct the rest of the fields).  */
 612             unsigned int is_stub:1;
 613
 614             /* C++ method that is inlined */
 615             unsigned int is_inlined:1;
 616
 617             /* Unused.  */
 618             unsigned int dummy:4;
 619
 620             /* Index into that baseclass's virtual function table,
 621                minus 2; else if static: VOFFSET_STATIC; else: 0.  */
 622
 623             unsigned int voffset:16;
 624
 625 #define VOFFSET_STATIC 1
 626
 627           }
 628          *fn_fields;
 629
 630       }
 631      *fn_fieldlists;
 632
 633     /* If this "struct type" describes a template, then it
 634      * has arguments. "template_args" points to an array of
 635      * template arg descriptors, of length "ntemplate_args".
 636      * The only real information in each of these template arg descriptors
 637      * is a name. "type" will typically just point to a "struct type" with
 638      * the placeholder TYPE_CODE_TEMPLATE_ARG type.
 639      */
 640     short ntemplate_args;
 641     struct template_arg
 642       {
 643         char *name;
 644         struct type *type;
 645       }
 646      *template_args;
 647
 648     /* If this "struct type" describes a template, it has a list
 649      * of instantiations. "instantiations" is a pointer to an array
 650      * of type's, one representing each instantiation. There
 651      * are "ninstantiations" elements in this array.
 652      */
 653     short ninstantiations;
 654     struct type **instantiations;
 655
 656     /* The following points to information relevant to the runtime model
 657      * of the compiler.
 658      * Currently being used only for HP's ANSI C++ compiler.
 659      * (This type may have to be changed/enhanced for other compilers.)
 660      *
 661      * RUNTIME_PTR is NULL if there is no runtime information (currently
 662      * this means the type was not compiled by HP aCC).
 663      *
 664      * Fields in structure pointed to:
 665      * ->HAS_VTABLE : 0 => no virtual table, 1 => vtable present
 666      *
 667      * ->PRIMARY_BASE points to the first non-virtual base class that has
 668      * a virtual table.
 669      *
 670      * ->VIRTUAL_BASE_LIST points to a list of struct type * pointers that
 671      * point to the type information for all virtual bases among this type's
 672      * ancestors.
 673      */
 674     struct runtime_info
 675       {
 676         short has_vtable;
 677         struct type *primary_base;
 678         struct type **virtual_base_list;
 679       }
 680      *runtime_ptr;
 681
 682     /* Pointer to information about enclosing scope, if this is a
 683      * local type.  If it is not a local type, this is NULL
 684      */
 685     struct local_type_info
 686       {
 687         char *file;
 688         int line;
 689       }
 690      *localtype_ptr;
 691   };
 692
 693 /* Struct used in computing virtual base list */
 694 struct vbase
 695   {
 696     struct type *vbasetype;     /* pointer to virtual base */
 697     struct vbase *next;         /* next in chain */
 698   };
 699
 700 /* Struct used for ranking a function for overload resolution */
 701 struct badness_vector
 702   {
 703     int length;
 704     int *rank;
 705   };
 706
 707 /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
 708    this shared static structure. */
 709
 710 extern const struct cplus_struct_type cplus_struct_default;
 711
 712 extern void allocate_cplus_struct_type (struct type *);
 713
 714 #define INIT_CPLUS_SPECIFIC(type) \
 715   (TYPE_CPLUS_SPECIFIC(type)=(struct cplus_struct_type*)&cplus_struct_default)
 716 #define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
 717 #define HAVE_CPLUS_STRUCT(type) \
 718   (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
 719
 720 #define TYPE_NAME(thistype) (thistype)->name
 721 #define TYPE_TAG_NAME(type) ((type)->tag_name)
 722 #define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
 723 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
 724 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
 725 #define TYPE_CV_TYPE(thistype) (thistype)->cv_type
 726 #define TYPE_AS_TYPE(thistype) (thistype)->as_type
 727 /* Note that if thistype is a TYPEDEF type, you have to call check_typedef.
 728    But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
 729    so you only have to call check_typedef once.  Since allocate_value
 730    calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe.  */
 731 #define TYPE_LENGTH(thistype) (thistype)->length
 732 #define TYPE_OBJFILE(thistype) (thistype)->objfile
 733 #define TYPE_FLAGS(thistype) (thistype)->flags
 734 #define TYPE_UNSIGNED(thistype) ((thistype)->flags & TYPE_FLAG_UNSIGNED)
 735 #define TYPE_NOSIGN(thistype) ((thistype)->flags & TYPE_FLAG_NOSIGN)
 736 #define TYPE_CONST(thistype) ((thistype)->flags & TYPE_FLAG_CONST)
 737 #define TYPE_VOLATILE(thistype) ((thistype)->flags & TYPE_FLAG_VOLATILE)
 738 #define TYPE_INCOMPLETE(thistype) ((thistype)->flags & TYPE_FLAG_INCOMPLETE)
 739 /* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you wan the real
 740    type, you need to do TYPE_CODE (check_type (this_type)). */
 741 #define TYPE_CODE(thistype) (thistype)->code
 742 #define TYPE_NFIELDS(thistype) (thistype)->nfields
 743 #define TYPE_FIELDS(thistype) (thistype)->fields
 744 #define TYPE_TEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->template_args
 745 #define TYPE_INSTANTIATIONS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->instantiations
 746
 747 #define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0)
 748 #define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0)
 749 #define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1)
 750
 751 /* Moto-specific stuff for FORTRAN arrays */
 752
 753 #define TYPE_ARRAY_UPPER_BOUND_TYPE(thistype) (thistype)->upper_bound_type
 754 #define TYPE_ARRAY_LOWER_BOUND_TYPE(thistype) (thistype)->lower_bound_type
 755
 756 #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
 757    (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),1))
 758
 759 #define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
 760    (TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),0))
 761
 762 /* C++ */
 763
 764 #define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype
 765 #define TYPE_DOMAIN_TYPE(thistype) (thistype)->vptr_basetype
 766 #define TYPE_VPTR_FIELDNO(thistype) (thistype)->vptr_fieldno
 767 #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields
 768 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
 769 #define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total
 770 #define TYPE_NTEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ntemplate_args
 771 #define TYPE_NINSTANTIATIONS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ninstantiations
 772 #define TYPE_DECLARED_TYPE(thistype) TYPE_CPLUS_SPECIFIC(thistype)->declared_type
 773 #define TYPE_TYPE_SPECIFIC(thistype) (thistype)->type_specific
 774 #define TYPE_ARG_TYPES(thistype) (thistype)->type_specific.arg_types
 775 #define TYPE_CPLUS_SPECIFIC(thistype) (thistype)->type_specific.cplus_stuff
 776 #define TYPE_FLOATFORMAT(thistype) (thistype)->type_specific.floatformat
 777 #define TYPE_BASECLASS(thistype,index) (thistype)->fields[index].type
 778 #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
 779 #define TYPE_BASECLASS_NAME(thistype,index) (thistype)->fields[index].name
 780 #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index)
 781 #define BASETYPE_VIA_PUBLIC(thistype, index) \
 782   ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index)))
 783
 784 #define BASETYPE_VIA_VIRTUAL(thistype, index) \
 785   (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
 786     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index)))
 787
 788 #define FIELD_TYPE(thisfld) ((thisfld).type)
 789 #define FIELD_NAME(thisfld) ((thisfld).name)
 790 #define FIELD_BITPOS(thisfld) ((thisfld).loc.bitpos)
 791 #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
 792 #define FIELD_PHYSNAME(thisfld) ((thisfld).loc.physname)
 793 #define FIELD_PHYSADDR(thisfld) ((thisfld).loc.physaddr)
 794 #define SET_FIELD_PHYSNAME(thisfld, name) \
 795   ((thisfld).bitsize = -1, FIELD_PHYSNAME(thisfld) = (name))
 796 #define SET_FIELD_PHYSADDR(thisfld, name) \
 797   ((thisfld).bitsize = -2, FIELD_PHYSADDR(thisfld) = (name))
 798 #define TYPE_FIELD(thistype, n) (thistype)->fields[n]
 799 #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n))
 800 #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n))
 801 #define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS(TYPE_FIELD(thistype,n))
 802 #define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE(TYPE_FIELD(thistype,n))
 803 #define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE(TYPE_FIELD(thistype,n))!=0)
 804 #define TYPE_TEMPLATE_ARG(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->template_args[n]
 805 #define TYPE_INSTANTIATION(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->instantiations[n]
 806
 807 #define TYPE_FIELD_PRIVATE_BITS(thistype) \
 808   TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
 809 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
 810   TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
 811 #define TYPE_FIELD_IGNORE_BITS(thistype) \
 812   TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits
 813 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
 814   TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
 815 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
 816   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
 817 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
 818   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
 819 #define SET_TYPE_FIELD_IGNORE(thistype, n) \
 820   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))
 821 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
 822   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 823 #define TYPE_FIELD_PRIVATE(thistype, n) \
 824   (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \
 825     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)))
 826 #define TYPE_FIELD_PROTECTED(thistype, n) \
 827   (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
 828     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
 829 #define TYPE_FIELD_IGNORE(thistype, n) \
 830   (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \
 831     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)))
 832 #define TYPE_FIELD_VIRTUAL(thistype, n) \
 833   (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
 834     : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)))
 835
 836 #define TYPE_FIELD_STATIC(thistype, n) ((thistype)->fields[n].bitsize < 0)
 837 #define TYPE_FIELD_STATIC_HAS_ADDR(thistype, n) ((thistype)->fields[n].bitsize == -2)
 838 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_PHYSNAME(TYPE_FIELD(thistype, n))
 839 #define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_PHYSADDR(TYPE_FIELD(thistype, n))
 840
 841 #define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
 842 #define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
 843 #define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
 844 #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
 845 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
 846
 847 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
 848 #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
 849 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
 850 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)
 851 #define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
 852 #define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
 853 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
 854 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
 855 #define TYPE_FN_FIELD_PUBLIC(thisfn, n) ((thisfn)[n].is_public)
 856 #define TYPE_FN_FIELD_STATIC(thisfn, n) ((thisfn)[n].is_static)
 857 #define TYPE_FN_FIELD_FINAL(thisfn, n) ((thisfn)[n].is_final)
 858 #define TYPE_FN_FIELD_SYNCHRONIZED(thisfn, n) ((thisfn)[n].is_synchronized)
 859 #define TYPE_FN_FIELD_NATIVE(thisfn, n) ((thisfn)[n].is_native)
 860 #define TYPE_FN_FIELD_ABSTRACT(thisfn, n) ((thisfn)[n].is_abstract)
 861 #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
 862 #define TYPE_FN_FIELD_INLINED(thisfn, n) ((thisfn)[n].is_inlined)
 863 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
 864 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
 865 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
 866 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
 867
 868 #define TYPE_RUNTIME_PTR(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->runtime_ptr)
 869 #define TYPE_VTABLE(thistype) (TYPE_RUNTIME_PTR(thistype)->has_vtable)
 870 #define TYPE_HAS_VTABLE(thistype) (TYPE_RUNTIME_PTR(thistype) && TYPE_VTABLE(thistype))
 871 #define TYPE_PRIMARY_BASE(thistype) (TYPE_RUNTIME_PTR(thistype)->primary_base)
 872 #define TYPE_VIRTUAL_BASE_LIST(thistype) (TYPE_RUNTIME_PTR(thistype)->virtual_base_list)
 873
 874 #define TYPE_LOCALTYPE_PTR(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr)
 875 #define TYPE_LOCALTYPE_FILE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->file)
 876 #define TYPE_LOCALTYPE_LINE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->line)
 877
 878 #define TYPE_IS_OPAQUE(thistype) (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) ||        \
 879                                    (TYPE_CODE (thistype) == TYPE_CODE_UNION))        && \
 880                                   (TYPE_NFIELDS (thistype) == 0)                     && \
 881                                   (TYPE_CPLUS_SPECIFIC (thistype) && (TYPE_NFN_FIELDS (thistype) == 0)))
 882
 883
 884
 885 /* Implicit sizes */
 886 extern struct type *builtin_type_void;
 887 extern struct type *builtin_type_char;
 888 extern struct type *builtin_type_short;
 889 extern struct type *builtin_type_int;
 890 extern struct type *builtin_type_long;
 891 extern struct type *builtin_type_signed_char;
 892 extern struct type *builtin_type_unsigned_char;
 893 extern struct type *builtin_type_unsigned_short;
 894 extern struct type *builtin_type_unsigned_int;
 895 extern struct type *builtin_type_unsigned_long;
 896 extern struct type *builtin_type_float;
 897 extern struct type *builtin_type_double;
 898 extern struct type *builtin_type_long_double;
 899 extern struct type *builtin_type_complex;
 900 extern struct type *builtin_type_double_complex;
 901 extern struct type *builtin_type_string;
 902 extern struct type *builtin_type_bool;
 903
 904 /* Address/pointer types: */
 905 /* (C) Language `pointer to data' type.  Some target platforms use an
 906    implicitly {sign,zero} -extended 32 bit C language pointer on a 64
 907    bit ISA.  */
 908 extern struct type *builtin_type_void_data_ptr;
 909
 910 /* (C) Language `pointer to function returning void' type.  Since
 911    ANSI, C standards have explicitly said that pointers to functions
 912    and pointers to data are not interconvertible --- that is, you
 913    can't cast a function pointer to void * and back, and expect to get
 914    the same value.  However, all function pointer types are
 915    interconvertible, so void (*) () can server as a generic function
 916    pointer.  */
 917 extern struct type *builtin_type_void_func_ptr;
 918
 919 /* The target CPU's address type.  This is the ISA address size. */
 920 extern struct type *builtin_type_CORE_ADDR;
 921 /* The symbol table address type.  Some object file formats have a 32
 922    bit address type even though the TARGET has a 64 bit pointer type
 923    (cf MIPS). */
 924 extern struct type *builtin_type_bfd_vma;
 925
 926 /* Explicit sizes - see C9X <intypes.h> for naming scheme */
 927 extern struct type *builtin_type_int8;
 928 extern struct type *builtin_type_uint8;
 929 extern struct type *builtin_type_int16;
 930 extern struct type *builtin_type_uint16;
 931 extern struct type *builtin_type_int32;
 932 extern struct type *builtin_type_uint32;
 933 extern struct type *builtin_type_int64;
 934 extern struct type *builtin_type_uint64;
 935 extern struct type *builtin_type_int128;
 936 extern struct type *builtin_type_uint128;
 937
 938 /* SIMD types.  We inherit these names from GCC.  */
 939 extern struct type *builtin_type_v4sf;
 940 extern struct type *builtin_type_v4si;
 941 extern struct type *builtin_type_v8qi;
 942 extern struct type *builtin_type_v4hi;
 943 extern struct type *builtin_type_v2si;
 944
 945 /* Explicit floating-point formats.  See "floatformat.h".  */
 946 extern struct type *builtin_type_ieee_single_big;
 947 extern struct type *builtin_type_ieee_single_little;
 948 extern struct type *builtin_type_ieee_double_big;
 949 extern struct type *builtin_type_ieee_double_little;
 950 extern struct type *builtin_type_ieee_double_littlebyte_bigword;
 951 extern struct type *builtin_type_i387_ext;
 952 extern struct type *builtin_type_m68881_ext;
 953 extern struct type *builtin_type_i960_ext;
 954 extern struct type *builtin_type_m88110_ext;
 955 extern struct type *builtin_type_m88110_harris_ext;
 956 extern struct type *builtin_type_arm_ext_big;
 957 extern struct type *builtin_type_arm_ext_littlebyte_bigword;
 958 extern struct type *builtin_type_ia64_spill_big;
 959 extern struct type *builtin_type_ia64_spill_little;
 960 extern struct type *builtin_type_ia64_quad_big;
 961 extern struct type *builtin_type_ia64_quad_little;
 962
 963 /* We use this for the '/c' print format, because builtin_type_char is
 964    just a one-byte integral type, which languages less laid back than
 965    C will print as ... well, a one-byte integral type.  */
 966 extern struct type *builtin_type_true_char;
 967
 968 /* This type represents a type that was unrecognized in symbol
 969    read-in.  */
 970
 971 extern struct type *builtin_type_error;
 972
 973 extern struct type *builtin_type_long_long;
 974 extern struct type *builtin_type_unsigned_long_long;
 975
 976 /* Modula-2 types */
 977
 978 extern struct type *builtin_type_m2_char;
 979 extern struct type *builtin_type_m2_int;
 980 extern struct type *builtin_type_m2_card;
 981 extern struct type *builtin_type_m2_real;
 982 extern struct type *builtin_type_m2_bool;
 983
 984 /* Chill types */
 985
 986 extern struct type *builtin_type_chill_bool;
 987 extern struct type *builtin_type_chill_char;
 988 extern struct type *builtin_type_chill_long;
 989 extern struct type *builtin_type_chill_ulong;
 990 extern struct type *builtin_type_chill_real;
 991
 992 /* Fortran (F77) types */
 993
 994 extern struct type *builtin_type_f_character;
 995 extern struct type *builtin_type_f_integer;
 996 extern struct type *builtin_type_f_integer_s2;
 997 extern struct type *builtin_type_f_logical;
 998 extern struct type *builtin_type_f_logical_s1;
 999 extern struct type *builtin_type_f_logical_s2;
1000 extern struct type *builtin_type_f_real;
1001 extern struct type *builtin_type_f_real_s8;
1002 extern struct type *builtin_type_f_real_s16;
1003 extern struct type *builtin_type_f_complex_s8;
1004 extern struct type *builtin_type_f_complex_s16;
1005 extern struct type *builtin_type_f_complex_s32;
1006 extern struct type *builtin_type_f_void;
1007
1008 /* RTTI for C++ */
1009 /* extern struct type *builtin_type_cxx_typeinfo; */
1010
1011 /* Maximum and minimum values of built-in types */
1012
1013 #define MAX_OF_TYPE(t)  \
1014    (TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) \
1015     : MAX_OF_SIZE(TYPE_LENGTH(t)))
1016
1017 #define MIN_OF_TYPE(t)  \
1018    (TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \
1019     : MIN_OF_SIZE(TYPE_LENGTH(t)))
1020
1021 /* Allocate space for storing data associated with a particular type.
1022    We ensure that the space is allocated using the same mechanism that
1023    was used to allocate the space for the type structure itself.  I.E.
1024    if the type is on an objfile's type_obstack, then the space for data
1025    associated with that type will also be allocated on the type_obstack.
1026    If the type is not associated with any particular objfile (such as
1027    builtin types), then the data space will be allocated with xmalloc,
1028    the same as for the type structure. */
1029
1030 #define TYPE_ALLOC(t,size)  \
1031    (TYPE_OBJFILE (t) != NULL  \
1032     ? obstack_alloc (&TYPE_OBJFILE (t) -> type_obstack, size) \
1033     : xmalloc (size))
1034
1035 extern struct type *alloc_type (struct objfile *);
1036
1037 extern struct type *init_type (enum type_code, int, int, char *,
1038                                struct objfile *);
1039
1040 extern struct type *lookup_reference_type (struct type *);
1041
1042 extern struct type *make_reference_type (struct type *, struct type **);
1043
1044 extern struct type *make_cv_type (int, int, struct type *, struct type **);
1045
1046 extern void finish_cv_type (struct type *);
1047
1048 extern int address_space_name_to_int (char *);
1049
1050 extern char *address_space_int_to_name (int);
1051
1052 extern struct type *make_type_with_address_space (struct type *type,
1053                                                   int space_identifier);
1054
1055 extern struct type *lookup_member_type (struct type *, struct type *);
1056
1057 extern void
1058 smash_to_method_type (struct type *, struct type *, struct type *,
1059                       struct type **);
1060
1061 extern void
1062 smash_to_member_type (struct type *, struct type *, struct type *);
1063
1064 extern struct type *allocate_stub_method (struct type *);
1065
1066 extern char *type_name_no_tag (const struct type *);
1067
1068 extern struct type *lookup_struct_elt_type (struct type *, char *, int);
1069
1070 extern struct type *make_pointer_type (struct type *, struct type **);
1071
1072 extern struct type *lookup_pointer_type (struct type *);
1073
1074 extern struct type *make_function_type (struct type *, struct type **);
1075
1076 extern struct type *lookup_function_type (struct type *);
1077
1078 extern struct type *create_range_type (struct type *, struct type *, int,
1079                                        int);
1080
1081 extern struct type *create_array_type (struct type *, struct type *,
1082                                        struct type *);
1083
1084 extern struct type *create_string_type (struct type *, struct type *);
1085
1086 extern struct type *create_set_type (struct type *, struct type *);
1087
1088 extern int chill_varying_type (struct type *);
1089
1090 extern struct type *lookup_unsigned_typename (char *);
1091
1092 extern struct type *lookup_signed_typename (char *);
1093
1094 extern struct type *check_typedef (struct type *);
1095
1096 #define CHECK_TYPEDEF(TYPE) (TYPE) = check_typedef (TYPE)
1097
1098 extern void check_stub_method (struct type *, int, int);
1099
1100 extern struct type *lookup_primitive_typename (char *);
1101
1102 extern char *gdb_mangle_name (struct type *, int, int);
1103
1104 extern struct type *builtin_type (char **);
1105
1106 extern struct type *lookup_typename (char *, struct block *, int);
1107
1108 extern struct type *lookup_template_type (char *, struct type *,
1109                                           struct block *);
1110
1111 extern struct type *lookup_fundamental_type (struct objfile *, int);
1112
1113 extern void fill_in_vptr_fieldno (struct type *);
1114
1115 extern int get_destructor_fn_field (struct type *, int *, int *);
1116
1117 extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *);
1118
1119 extern int is_ancestor (struct type *, struct type *);
1120
1121 extern int has_vtable (struct type *);
1122
1123 extern struct type *primary_base_class (struct type *);
1124
1125 extern struct type **virtual_base_list (struct type *);
1126
1127 extern int virtual_base_list_length (struct type *);
1128 extern int virtual_base_list_length_skip_primaries (struct type *);
1129
1130 extern int virtual_base_index (struct type *, struct type *);
1131 extern int virtual_base_index_skip_primaries (struct type *, struct type *);
1132
1133
1134 extern int class_index_in_primary_list (struct type *);
1135
1136 extern int count_virtual_fns (struct type *);
1137
1138 /* Constants for HP/Taligent ANSI C++ runtime model */
1139
1140 /* Where virtual function entries begin in the
1141  * virtual table, in the non-RRBC vtable format.
1142  * First 4 are the metavtable pointer, top offset,
1143  * typeinfo pointer, and dup base info pointer */
1144 #define HP_ACC_VFUNC_START        4
1145
1146 /* (Negative) Offset where virtual base offset entries begin
1147  * in the virtual table. Skips over metavtable pointer and
1148  * the self-offset entry.
1149  * NOTE: NEGATE THIS BEFORE USING! The virtual base offsets
1150  * appear before the address point of the vtable (the slot
1151  * pointed to by the object's vtable pointer), i.e. at lower
1152  * addresses than the vtable pointer. */
1153 #define HP_ACC_VBASE_START        2
1154
1155 /* (Positive) Offset where the pointer to the typeinfo
1156  * object is present in the virtual table */
1157 #define HP_ACC_TYPEINFO_OFFSET    2
1158
1159 /* (Positive) Offset where the ``top offset'' entry of
1160  * the virtual table is */
1161 #define HP_ACC_TOP_OFFSET_OFFSET  1
1162
1163 /* Overload resolution */
1164
1165 #define LENGTH_MATCH(bv) ((bv)->rank[0])
1166
1167 /* Badness if parameter list length doesn't match arg list length */
1168 #define LENGTH_MISMATCH_BADNESS      100
1169 /* Dummy badness value for nonexistent parameter positions */
1170 #define TOO_FEW_PARAMS_BADNESS       100
1171 /* Badness if no conversion among types */
1172 #define INCOMPATIBLE_TYPE_BADNESS    100
1173 /* Badness of coercing large integer to smaller size */
1174 #define INTEGER_COERCION_BADNESS     100
1175 /* Badness of coercing large floating type to smaller size */
1176 #define FLOAT_COERCION_BADNESS       100
1177
1178 /* Badness of integral promotion */
1179 #define INTEGER_PROMOTION_BADNESS      1
1180 /* Badness of floating promotion */
1181 #define FLOAT_PROMOTION_BADNESS        1
1182 /* Badness of integral conversion */
1183 #define INTEGER_CONVERSION_BADNESS     2
1184 /* Badness of floating conversion */
1185 #define FLOAT_CONVERSION_BADNESS       2
1186 /* Badness of integer<->floating conversions */
1187 #define INT_FLOAT_CONVERSION_BADNESS   2
1188 /* Badness of converting to a boolean */
1189 #define BOOLEAN_CONVERSION_BADNESS     2
1190 /* Badness of pointer conversion */
1191 #define POINTER_CONVERSION_BADNESS     2
1192 /* Badness of conversion of pointer to void pointer */
1193 #define VOID_PTR_CONVERSION_BADNESS    2
1194 /* Badness of converting derived to base class */
1195 #define BASE_CONVERSION_BADNESS        2
1196 /* Badness of converting from non-reference to reference */
1197 #define REFERENCE_CONVERSION_BADNESS   2
1198
1199 /* Non-standard conversions allowed by the debugger */
1200 /* Converting a pointer to an int is usually OK */
1201 #define NS_POINTER_CONVERSION_BADNESS 10
1202
1203
1204 extern int compare_badness (struct badness_vector *, struct badness_vector *);
1205
1206 extern struct badness_vector *rank_function (struct type **, int,
1207                                              struct type **, int);
1208
1209 extern int rank_one_type (struct type *, struct type *);
1210
1211 extern void recursive_dump_type (struct type *, int);
1212
1213 /* printcmd.c */
1214
1215 extern void print_scalar_formatted (char *, struct type *, int, int,
1216                                     struct ui_file *);
1217
1218 extern int can_dereference (struct type *);
1219
1220 extern int is_integral_type (struct type *);
1221
1222 extern void maintenance_print_type (char *, int);
1223
1224 #endif /* GDBTYPES_H */