1 /* Internal type definitions for GDB. 2 3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 4 2002, 2003, 2004, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. 5 6 Contributed by Cygnus Support, using pieces from other GDB modules. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #if !defined (GDBTYPES_H) 24 #define GDBTYPES_H 1 25 26 #include "hashtab.h" 27 28 /* Forward declarations for prototypes. */ 29 struct field; 30 struct block; 31 struct value_print_options; 32 struct language_defn; 33 34 /* Some macros for char-based bitfields. */ 35 36 #define B_SET(a,x) ((a)[(x)>>3] |= (1 << ((x)&7))) 37 #define B_CLR(a,x) ((a)[(x)>>3] &= ~(1 << ((x)&7))) 38 #define B_TST(a,x) ((a)[(x)>>3] & (1 << ((x)&7))) 39 #define B_TYPE unsigned char 40 #define B_BYTES(x) ( 1 + ((x)>>3) ) 41 #define B_CLRALL(a,x) memset ((a), 0, B_BYTES(x)) 42 43 /* Different kinds of data types are distinguished by the `code' field. */ 44 45 enum type_code 46 { 47 TYPE_CODE_UNDEF, /* Not used; catches errors */ 48 TYPE_CODE_PTR, /* Pointer type */ 49 50 /* Array type with lower & upper bounds. 51 52 Regardless of the language, GDB represents multidimensional 53 array types the way C does: as arrays of arrays. So an 54 instance of a GDB array type T can always be seen as a series 55 of instances of TYPE_TARGET_TYPE (T) laid out sequentially in 56 memory. 57 58 Row-major languages like C lay out multi-dimensional arrays so 59 that incrementing the rightmost index in a subscripting 60 expression results in the smallest change in the address of the 61 element referred to. Column-major languages like Fortran lay 62 them out so that incrementing the leftmost index results in the 63 smallest change. 64 65 This means that, in column-major languages, working our way 66 from type to target type corresponds to working through indices 67 from right to left, not left to right. */ 68 TYPE_CODE_ARRAY, 69 70 TYPE_CODE_STRUCT, /* C struct or Pascal record */ 71 TYPE_CODE_UNION, /* C union or Pascal variant part */ 72 TYPE_CODE_ENUM, /* Enumeration type */ 73 TYPE_CODE_FLAGS, /* Bit flags type */ 74 TYPE_CODE_FUNC, /* Function type */ 75 TYPE_CODE_INT, /* Integer type */ 76 77 /* Floating type. This is *NOT* a complex type. Beware, there are parts 78 of GDB which bogusly assume that TYPE_CODE_FLT can mean complex. */ 79 TYPE_CODE_FLT, 80 81 /* Void type. The length field specifies the length (probably always 82 one) which is used in pointer arithmetic involving pointers to 83 this type, but actually dereferencing such a pointer is invalid; 84 a void type has no length and no actual representation in memory 85 or registers. A pointer to a void type is a generic pointer. */ 86 TYPE_CODE_VOID, 87 88 TYPE_CODE_SET, /* Pascal sets */ 89 TYPE_CODE_RANGE, /* Range (integers within spec'd bounds) */ 90 91 /* A string type which is like an array of character but prints 92 differently (at least for (the deleted) CHILL). It does not 93 contain a length field as Pascal strings (for many Pascals, 94 anyway) do; if we want to deal with such strings, we should use 95 a new type code. */ 96 TYPE_CODE_STRING, 97 98 /* String of bits; like TYPE_CODE_SET but prints differently (at 99 least for (the deleted) CHILL). */ 100 TYPE_CODE_BITSTRING, 101 102 /* Unknown type. The length field is valid if we were able to 103 deduce that much about the type, or 0 if we don't even know that. */ 104 TYPE_CODE_ERROR, 105 106 /* C++ */ 107 TYPE_CODE_METHOD, /* Method type */ 108 109 /* Pointer-to-member-function type. This describes how to access a 110 particular member function of a class (possibly a virtual 111 member function). The representation may vary between different 112 C++ ABIs. */ 113 TYPE_CODE_METHODPTR, 114 115 /* Pointer-to-member type. This is the offset within a class to some 116 particular data member. The only currently supported representation 117 uses an unbiased offset, with -1 representing NULL; this is used 118 by the Itanium C++ ABI (used by GCC on all platforms). */ 119 TYPE_CODE_MEMBERPTR, 120 121 TYPE_CODE_REF, /* C++ Reference types */ 122 123 TYPE_CODE_CHAR, /* *real* character type */ 124 125 /* Boolean type. 0 is false, 1 is true, and other values are non-boolean 126 (e.g. FORTRAN "logical" used as unsigned int). */ 127 TYPE_CODE_BOOL, 128 129 /* Fortran */ 130 TYPE_CODE_COMPLEX, /* Complex float */ 131 132 TYPE_CODE_TYPEDEF, 133 TYPE_CODE_TEMPLATE, /* C++ template */ 134 TYPE_CODE_TEMPLATE_ARG, /* C++ template arg */ 135 136 TYPE_CODE_NAMESPACE, /* C++ namespace. */ 137 138 TYPE_CODE_DECFLOAT, /* Decimal floating point. */ 139 140 /* Internal function type. */ 141 TYPE_CODE_INTERNAL_FUNCTION 142 }; 143 144 /* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an 145 alias for TYPE_CODE_STRUCT. This is for DWARF, which has a distinct 146 "class" attribute. Perhaps we should actually have a separate TYPE_CODE 147 so that we can print "class" or "struct" depending on what the debug 148 info said. It's not clear we should bother. */ 149 150 #define TYPE_CODE_CLASS TYPE_CODE_STRUCT 151 152 /* Some constants representing each bit field in the main_type. See 153 the bit-field-specific macros, below, for documentation of each 154 constant in this enum. These enum values are only used with 155 init_type. Note that the values are chosen not to conflict with 156 type_instance_flag_value; this lets init_type error-check its 157 input. */ 158 159 enum type_flag_value 160 { 161 TYPE_FLAG_UNSIGNED = (1 << 6), 162 TYPE_FLAG_NOSIGN = (1 << 7), 163 TYPE_FLAG_STUB = (1 << 8), 164 TYPE_FLAG_TARGET_STUB = (1 << 9), 165 TYPE_FLAG_STATIC = (1 << 10), 166 TYPE_FLAG_PROTOTYPED = (1 << 11), 167 TYPE_FLAG_INCOMPLETE = (1 << 12), 168 TYPE_FLAG_VARARGS = (1 << 13), 169 TYPE_FLAG_VECTOR = (1 << 14), 170 TYPE_FLAG_FIXED_INSTANCE = (1 << 15), 171 TYPE_FLAG_STUB_SUPPORTED = (1 << 16), 172 TYPE_FLAG_NOTTEXT = (1 << 17), 173 174 /* Used for error-checking. */ 175 TYPE_FLAG_MIN = TYPE_FLAG_UNSIGNED 176 }; 177 178 /* Some bits for the type's instance_flags word. See the macros below 179 for documentation on each bit. Note that if you add a value here, 180 you must update the enum type_flag_value as well. */ 181 enum type_instance_flag_value 182 { 183 TYPE_INSTANCE_FLAG_CONST = (1 << 0), 184 TYPE_INSTANCE_FLAG_VOLATILE = (1 << 1), 185 TYPE_INSTANCE_FLAG_CODE_SPACE = (1 << 2), 186 TYPE_INSTANCE_FLAG_DATA_SPACE = (1 << 3), 187 TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 = (1 << 4), 188 TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2 = (1 << 5) 189 }; 190 191 /* Unsigned integer type. If this is not set for a TYPE_CODE_INT, the 192 type is signed (unless TYPE_FLAG_NOSIGN (below) is set). */ 193 194 #define TYPE_UNSIGNED(t) (TYPE_MAIN_TYPE (t)->flag_unsigned) 195 196 /* No sign for this type. In C++, "char", "signed char", and "unsigned 197 char" are distinct types; so we need an extra flag to indicate the 198 absence of a sign! */ 199 200 #define TYPE_NOSIGN(t) (TYPE_MAIN_TYPE (t)->flag_nosign) 201 202 /* This appears in a type's flags word if it is a stub type (e.g., if 203 someone referenced a type that wasn't defined in a source file 204 via (struct sir_not_appearing_in_this_film *)). */ 205 206 #define TYPE_STUB(t) (TYPE_MAIN_TYPE (t)->flag_stub) 207 208 /* The target type of this type is a stub type, and this type needs to 209 be updated if it gets un-stubbed in check_typedef. 210 Used for arrays and ranges, in which TYPE_LENGTH of the array/range 211 gets set based on the TYPE_LENGTH of the target type. 212 Also, set for TYPE_CODE_TYPEDEF. */ 213 214 #define TYPE_TARGET_STUB(t) (TYPE_MAIN_TYPE (t)->flag_target_stub) 215 216 /* Static type. If this is set, the corresponding type had 217 * a static modifier. 218 * Note: This may be unnecessary, since static data members 219 * are indicated by other means (bitpos == -1) 220 */ 221 222 #define TYPE_STATIC(t) (TYPE_MAIN_TYPE (t)->flag_static) 223 224 /* This is a function type which appears to have a prototype. We need this 225 for function calls in order to tell us if it's necessary to coerce the args, 226 or to just do the standard conversions. This is used with a short field. */ 227 228 #define TYPE_PROTOTYPED(t) (TYPE_MAIN_TYPE (t)->flag_prototyped) 229 230 /* This flag is used to indicate that processing for this type 231 is incomplete. 232 233 (Mostly intended for HP platforms, where class methods, for 234 instance, can be encountered before their classes in the debug 235 info; the incomplete type has to be marked so that the class and 236 the method can be assigned correct types.) */ 237 238 #define TYPE_INCOMPLETE(t) (TYPE_MAIN_TYPE (t)->flag_incomplete) 239 240 /* FIXME drow/2002-06-03: Only used for methods, but applies as well 241 to functions. */ 242 243 #define TYPE_VARARGS(t) (TYPE_MAIN_TYPE (t)->flag_varargs) 244 245 /* Identify a vector type. Gcc is handling this by adding an extra 246 attribute to the array type. We slurp that in as a new flag of a 247 type. This is used only in dwarf2read.c. */ 248 #define TYPE_VECTOR(t) (TYPE_MAIN_TYPE (t)->flag_vector) 249 250 /* The debugging formats (especially STABS) do not contain enough information 251 to represent all Ada types---especially those whose size depends on 252 dynamic quantities. Therefore, the GNAT Ada compiler includes 253 extra information in the form of additional type definitions 254 connected by naming conventions. This flag indicates that the 255 type is an ordinary (unencoded) GDB type that has been created from 256 the necessary run-time information, and does not need further 257 interpretation. Optionally marks ordinary, fixed-size GDB type. */ 258 259 #define TYPE_FIXED_INSTANCE(t) (TYPE_MAIN_TYPE (t)->flag_fixed_instance) 260 261 /* This debug target supports TYPE_STUB(t). In the unsupported case we have to 262 rely on NFIELDS to be zero etc., see TYPE_IS_OPAQUE (). 263 TYPE_STUB(t) with !TYPE_STUB_SUPPORTED(t) may exist if we only guessed 264 the TYPE_STUB(t) value (see dwarfread.c). */ 265 266 #define TYPE_STUB_SUPPORTED(t) (TYPE_MAIN_TYPE (t)->flag_stub_supported) 267 268 /* Not textual. By default, GDB treats all single byte integers as 269 characters (or elements of strings) unless this flag is set. */ 270 271 #define TYPE_NOTTEXT(t) (TYPE_MAIN_TYPE (t)->flag_nottext) 272 273 /* Type owner. If TYPE_OBJFILE_OWNED is true, the type is owned by 274 the objfile retrieved as TYPE_OBJFILE. Otherweise, the type is 275 owned by an architecture; TYPE_OBJFILE is NULL in this case. */ 276 277 #define TYPE_OBJFILE_OWNED(t) (TYPE_MAIN_TYPE (t)->flag_objfile_owned) 278 #define TYPE_OWNER(t) TYPE_MAIN_TYPE(t)->owner 279 #define TYPE_OBJFILE(t) (TYPE_OBJFILE_OWNED(t)? TYPE_OWNER(t).objfile : NULL) 280 281 /* Constant type. If this is set, the corresponding type has a 282 * const modifier. 283 */ 284 285 #define TYPE_CONST(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CONST) 286 287 /* Volatile type. If this is set, the corresponding type has a 288 * volatile modifier. 289 */ 290 291 #define TYPE_VOLATILE(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_VOLATILE) 292 293 /* Instruction-space delimited type. This is for Harvard architectures 294 which have separate instruction and data address spaces (and perhaps 295 others). 296 297 GDB usually defines a flat address space that is a superset of the 298 architecture's two (or more) address spaces, but this is an extension 299 of the architecture's model. 300 301 If TYPE_FLAG_INST is set, an object of the corresponding type 302 resides in instruction memory, even if its address (in the extended 303 flat address space) does not reflect this. 304 305 Similarly, if TYPE_FLAG_DATA is set, then an object of the 306 corresponding type resides in the data memory space, even if 307 this is not indicated by its (flat address space) address. 308 309 If neither flag is set, the default space for functions / methods 310 is instruction space, and for data objects is data memory. */ 311 312 #define TYPE_CODE_SPACE(t) \ 313 (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CODE_SPACE) 314 315 #define TYPE_DATA_SPACE(t) \ 316 (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_DATA_SPACE) 317 318 /* Address class flags. Some environments provide for pointers whose 319 size is different from that of a normal pointer or address types 320 where the bits are interpreted differently than normal addresses. The 321 TYPE_FLAG_ADDRESS_CLASS_n flags may be used in target specific 322 ways to represent these different types of address classes. */ 323 #define TYPE_ADDRESS_CLASS_1(t) (TYPE_INSTANCE_FLAGS(t) \ 324 & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1) 325 #define TYPE_ADDRESS_CLASS_2(t) (TYPE_INSTANCE_FLAGS(t) \ 326 & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2) 327 #define TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL \ 328 (TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2) 329 #define TYPE_ADDRESS_CLASS_ALL(t) (TYPE_INSTANCE_FLAGS(t) \ 330 & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) 331 332 /* Determine which field of the union main_type.fields[x].loc is used. */ 333 334 enum field_loc_kind 335 { 336 FIELD_LOC_KIND_BITPOS, /* bitpos */ 337 FIELD_LOC_KIND_PHYSADDR, /* physaddr */ 338 FIELD_LOC_KIND_PHYSNAME, /* physname */ 339 FIELD_LOC_KIND_DWARF_BLOCK /* dwarf_block */ 340 }; 341 342 /* This structure is space-critical. 343 Its layout has been tweaked to reduce the space used. */ 344 345 struct main_type 346 { 347 /* Code for kind of type */ 348 349 ENUM_BITFIELD(type_code) code : 8; 350 351 /* Flags about this type. These fields appear at this location 352 because they packs nicely here. See the TYPE_* macros for 353 documentation about these fields. */ 354 355 unsigned int flag_unsigned : 1; 356 unsigned int flag_nosign : 1; 357 unsigned int flag_stub : 1; 358 unsigned int flag_target_stub : 1; 359 unsigned int flag_static : 1; 360 unsigned int flag_prototyped : 1; 361 unsigned int flag_incomplete : 1; 362 unsigned int flag_varargs : 1; 363 unsigned int flag_vector : 1; 364 unsigned int flag_stub_supported : 1; 365 unsigned int flag_nottext : 1; 366 unsigned int flag_fixed_instance : 1; 367 unsigned int flag_objfile_owned : 1; 368 369 /* Number of fields described for this type. This field appears at 370 this location because it packs nicely here. */ 371 372 short nfields; 373 374 /* Field number of the virtual function table pointer in 375 VPTR_BASETYPE. If -1, we were unable to find the virtual 376 function table pointer in initial symbol reading, and 377 get_vptr_fieldno should be called to find it if possible. 378 get_vptr_fieldno will update this field if possible. 379 Otherwise the value is left at -1. 380 381 Unused if this type does not have virtual functions. 382 383 This field appears at this location because it packs nicely here. */ 384 385 short vptr_fieldno; 386 387 /* Name of this type, or NULL if none. 388 389 This is used for printing only, except by poorly designed C++ code. 390 For looking up a name, look for a symbol in the VAR_DOMAIN. */ 391 392 char *name; 393 394 /* Tag name for this type, or NULL if none. This means that the 395 name of the type consists of a keyword followed by the tag name. 396 Which keyword is determined by the type code ("struct" for 397 TYPE_CODE_STRUCT, etc.). As far as I know C/C++ are the only languages 398 with this feature. 399 400 This is used for printing only, except by poorly designed C++ code. 401 For looking up a name, look for a symbol in the STRUCT_DOMAIN. 402 One more legitimate use is that if TYPE_FLAG_STUB is set, this is 403 the name to use to look for definitions in other files. */ 404 405 char *tag_name; 406 407 /* Every type is now associated with a particular objfile, and the 408 type is allocated on the objfile_obstack for that objfile. One problem 409 however, is that there are times when gdb allocates new types while 410 it is not in the process of reading symbols from a particular objfile. 411 Fortunately, these happen when the type being created is a derived 412 type of an existing type, such as in lookup_pointer_type(). So 413 we can just allocate the new type using the same objfile as the 414 existing type, but to do this we need a backpointer to the objfile 415 from the existing type. Yes this is somewhat ugly, but without 416 major overhaul of the internal type system, it can't be avoided 417 for now. */ 418 419 union type_owner 420 { 421 struct objfile *objfile; 422 struct gdbarch *gdbarch; 423 } owner; 424 425 /* For a pointer type, describes the type of object pointed to. 426 For an array type, describes the type of the elements. 427 For a function or method type, describes the type of the return value. 428 For a range type, describes the type of the full range. 429 For a complex type, describes the type of each coordinate. 430 Unused otherwise. */ 431 432 struct type *target_type; 433 434 /* For structure and union types, a description of each field. 435 For set and pascal array types, there is one "field", 436 whose type is the domain type of the set or array. 437 For range types, there are two "fields", 438 the minimum and maximum values (both inclusive). 439 For enum types, each possible value is described by one "field". 440 For a function or method type, a "field" for each parameter. 441 For C++ classes, there is one field for each base class (if it is 442 a derived class) plus one field for each class data member. Member 443 functions are recorded elsewhere. 444 445 Using a pointer to a separate array of fields 446 allows all types to have the same size, which is useful 447 because we can allocate the space for a type before 448 we know what to put in it. */ 449 450 struct field 451 { 452 union field_location 453 { 454 /* Position of this field, counting in bits from start of 455 containing structure. 456 For gdbarch_bits_big_endian=1 targets, it is the bit offset to the MSB. 457 For gdbarch_bits_big_endian=0 targets, it is the bit offset to the LSB. 458 For a range bound or enum value, this is the value itself. */ 459 460 int bitpos; 461 462 /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr 463 is the location (in the target) of the static field. 464 Otherwise, physname is the mangled label of the static field. */ 465 466 CORE_ADDR physaddr; 467 char *physname; 468 469 /* The field location can be computed by evaluating the following DWARF 470 block. This can be used in Fortran variable-length arrays, for 471 instance. */ 472 473 struct dwarf2_locexpr_baton *dwarf_block; 474 } 475 loc; 476 477 /* For a function or member type, this is 1 if the argument is marked 478 artificial. Artificial arguments should not be shown to the 479 user. For TYPE_CODE_RANGE it is set if the specific bound is not 480 defined. */ 481 unsigned int artificial : 1; 482 483 /* Discriminant for union field_location. */ 484 ENUM_BITFIELD(field_loc_kind) loc_kind : 2; 485 486 /* Size of this field, in bits, or zero if not packed. 487 For an unpacked field, the field's type's length 488 says how many bytes the field occupies. */ 489 490 unsigned int bitsize : 29; 491 492 /* In a struct or union type, type of this field. 493 In a function or member type, type of this argument. 494 In an array type, the domain-type of the array. */ 495 496 struct type *type; 497 498 /* Name of field, value or argument. 499 NULL for range bounds, array domains, and member function 500 arguments. */ 501 502 char *name; 503 504 } *fields; 505 506 /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE 507 is the base class which defined the virtual function table pointer. 508 509 For types that are pointer to member types (TYPE_CODE_METHODPTR, 510 TYPE_CODE_MEMBERPTR), VPTR_BASETYPE is the type that this pointer 511 is a member of. 512 513 For method types (TYPE_CODE_METHOD), VPTR_BASETYPE is the aggregate 514 type that contains the method. 515 516 Unused otherwise. */ 517 518 struct type *vptr_basetype; 519 520 /* Slot to point to additional language-specific fields of this type. */ 521 522 union type_specific 523 { 524 /* CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to point to 525 cplus_struct_default, a default static instance of a struct 526 cplus_struct_type. */ 527 528 struct cplus_struct_type *cplus_stuff; 529 530 /* FLOATFORMAT is for TYPE_CODE_FLT. It is a pointer to two 531 floatformat objects that describe the floating-point value 532 that resides within the type. The first is for big endian 533 targets and the second is for little endian targets. */ 534 535 const struct floatformat **floatformat; 536 537 /* For TYPE_CODE_FUNC types, the calling convention for targets 538 supporting multiple ABIs. Right now this is only fetched from 539 the Dwarf-2 DW_AT_calling_convention attribute. */ 540 unsigned calling_convention; 541 } type_specific; 542 }; 543 544 /* A ``struct type'' describes a particular instance of a type, with 545 some particular qualification. */ 546 struct type 547 { 548 /* Type that is a pointer to this type. 549 NULL if no such pointer-to type is known yet. 550 The debugger may add the address of such a type 551 if it has to construct one later. */ 552 553 struct type *pointer_type; 554 555 /* C++: also need a reference type. */ 556 557 struct type *reference_type; 558 559 /* Variant chain. This points to a type that differs from this one only 560 in qualifiers and length. Currently, the possible qualifiers are 561 const, volatile, code-space, data-space, and address class. The 562 length may differ only when one of the address class flags are set. 563 The variants are linked in a circular ring and share MAIN_TYPE. */ 564 struct type *chain; 565 566 /* Flags specific to this instance of the type, indicating where 567 on the ring we are. */ 568 int instance_flags; 569 570 /* Length of storage for a value of this type. This is what 571 sizeof(type) would return; use it for address arithmetic, 572 memory reads and writes, etc. This size includes padding. For 573 example, an i386 extended-precision floating point value really 574 only occupies ten bytes, but most ABI's declare its size to be 575 12 bytes, to preserve alignment. A `struct type' representing 576 such a floating-point type would have a `length' value of 12, 577 even though the last two bytes are unused. 578 579 There's a bit of a host/target mess here, if you're concerned 580 about machines whose bytes aren't eight bits long, or who don't 581 have byte-addressed memory. Various places pass this to memcpy 582 and such, meaning it must be in units of host bytes. Various 583 other places expect they can calculate addresses by adding it 584 and such, meaning it must be in units of target bytes. For 585 some DSP targets, in which HOST_CHAR_BIT will (presumably) be 8 586 and TARGET_CHAR_BIT will be (say) 32, this is a problem. 587 588 One fix would be to make this field in bits (requiring that it 589 always be a multiple of HOST_CHAR_BIT and TARGET_CHAR_BIT) --- 590 the other choice would be to make it consistently in units of 591 HOST_CHAR_BIT. However, this would still fail to address 592 machines based on a ternary or decimal representation. */ 593 594 unsigned length; 595 596 /* Core type, shared by a group of qualified types. */ 597 struct main_type *main_type; 598 }; 599 600 #define NULL_TYPE ((struct type *) 0) 601 602 /* C++ language-specific information for TYPE_CODE_STRUCT and TYPE_CODE_UNION 603 nodes. */ 604 605 struct cplus_struct_type 606 { 607 /* Number of base classes this type derives from. The baseclasses are 608 stored in the first N_BASECLASSES fields (i.e. the `fields' field of 609 the struct type). I think only the `type' field of such a field has 610 any meaning. */ 611 612 short n_baseclasses; 613 614 /* Number of methods with unique names. All overloaded methods with 615 the same name count only once. */ 616 617 short nfn_fields; 618 619 /* Number of methods described for this type, not including the 620 methods that it derives from. */ 621 622 short nfn_fields_total; 623 624 /* The "declared_type" field contains a code saying how the 625 user really declared this type, e.g., "class s", "union s", 626 "struct s". 627 The 3 above things come out from the C++ compiler looking like classes, 628 but we keep track of the real declaration so we can give 629 the correct information on "ptype". (Note: TEMPLATE may not 630 belong in this list...) */ 631 632 #define DECLARED_TYPE_CLASS 0 633 #define DECLARED_TYPE_UNION 1 634 #define DECLARED_TYPE_STRUCT 2 635 #define DECLARED_TYPE_TEMPLATE 3 636 short declared_type; /* One of the above codes */ 637 638 /* For derived classes, the number of base classes is given by n_baseclasses 639 and virtual_field_bits is a bit vector containing one bit per base class. 640 If the base class is virtual, the corresponding bit will be set. 641 I.E, given: 642 643 class A{}; 644 class B{}; 645 class C : public B, public virtual A {}; 646 647 B is a baseclass of C; A is a virtual baseclass for C. 648 This is a C++ 2.0 language feature. */ 649 650 B_TYPE *virtual_field_bits; 651 652 /* For classes with private fields, the number of fields is given by 653 nfields and private_field_bits is a bit vector containing one bit 654 per field. 655 If the field is private, the corresponding bit will be set. */ 656 657 B_TYPE *private_field_bits; 658 659 /* For classes with protected fields, the number of fields is given by 660 nfields and protected_field_bits is a bit vector containing one bit 661 per field. 662 If the field is private, the corresponding bit will be set. */ 663 664 B_TYPE *protected_field_bits; 665 666 /* for classes with fields to be ignored, either this is optimized out 667 or this field has length 0 */ 668 669 B_TYPE *ignore_field_bits; 670 671 /* For classes, structures, and unions, a description of each field, 672 which consists of an overloaded name, followed by the types of 673 arguments that the method expects, and then the name after it 674 has been renamed to make it distinct. 675 676 fn_fieldlists points to an array of nfn_fields of these. */ 677 678 struct fn_fieldlist 679 { 680 681 /* The overloaded name. */ 682 683 char *name; 684 685 /* The number of methods with this name. */ 686 687 int length; 688 689 /* The list of methods. */ 690 691 struct fn_field 692 { 693 694 /* If is_stub is clear, this is the mangled name which we can 695 look up to find the address of the method (FIXME: it would 696 be cleaner to have a pointer to the struct symbol here 697 instead). */ 698 699 /* If is_stub is set, this is the portion of the mangled 700 name which specifies the arguments. For example, "ii", 701 if there are two int arguments, or "" if there are no 702 arguments. See gdb_mangle_name for the conversion from this 703 format to the one used if is_stub is clear. */ 704 705 char *physname; 706 707 /* The function type for the method. 708 (This comment used to say "The return value of the method", 709 but that's wrong. The function type 710 is expected here, i.e. something with TYPE_CODE_FUNC, 711 and *not* the return-value type). */ 712 713 struct type *type; 714 715 /* For virtual functions. 716 First baseclass that defines this virtual function. */ 717 718 struct type *fcontext; 719 720 /* Attributes. */ 721 722 unsigned int is_const:1; 723 unsigned int is_volatile:1; 724 unsigned int is_private:1; 725 unsigned int is_protected:1; 726 unsigned int is_public:1; 727 unsigned int is_abstract:1; 728 unsigned int is_static:1; 729 unsigned int is_final:1; 730 unsigned int is_synchronized:1; 731 unsigned int is_native:1; 732 unsigned int is_artificial:1; 733 734 /* A stub method only has some fields valid (but they are enough 735 to reconstruct the rest of the fields). */ 736 unsigned int is_stub:1; 737 738 /* Unused. */ 739 unsigned int dummy:4; 740 741 /* Index into that baseclass's virtual function table, 742 minus 2; else if static: VOFFSET_STATIC; else: 0. */ 743 744 unsigned int voffset:16; 745 746 #define VOFFSET_STATIC 1 747 748 } 749 *fn_fields; 750 751 } 752 *fn_fieldlists; 753 754 /* If this "struct type" describes a template, then it 755 * has arguments. "template_args" points to an array of 756 * template arg descriptors, of length "ntemplate_args". 757 * The only real information in each of these template arg descriptors 758 * is a name. "type" will typically just point to a "struct type" with 759 * the placeholder TYPE_CODE_TEMPLATE_ARG type. 760 */ 761 short ntemplate_args; 762 struct template_arg 763 { 764 char *name; 765 struct type *type; 766 } 767 *template_args; 768 769 /* Pointer to information about enclosing scope, if this is a 770 * local type. If it is not a local type, this is NULL 771 */ 772 struct local_type_info 773 { 774 char *file; 775 int line; 776 } 777 *localtype_ptr; 778 }; 779 780 /* Struct used in computing virtual base list */ 781 struct vbase 782 { 783 struct type *vbasetype; /* pointer to virtual base */ 784 struct vbase *next; /* next in chain */ 785 }; 786 787 /* Struct used for ranking a function for overload resolution */ 788 struct badness_vector 789 { 790 int length; 791 int *rank; 792 }; 793 794 /* The default value of TYPE_CPLUS_SPECIFIC(T) points to the 795 this shared static structure. */ 796 797 extern const struct cplus_struct_type cplus_struct_default; 798 799 extern void allocate_cplus_struct_type (struct type *); 800 801 #define INIT_CPLUS_SPECIFIC(type) \ 802 (TYPE_CPLUS_SPECIFIC(type)=(struct cplus_struct_type*)&cplus_struct_default) 803 #define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type) 804 #define HAVE_CPLUS_STRUCT(type) \ 805 (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default) 806 807 #define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags 808 #define TYPE_MAIN_TYPE(thistype) (thistype)->main_type 809 #define TYPE_NAME(thistype) TYPE_MAIN_TYPE(thistype)->name 810 #define TYPE_TAG_NAME(type) TYPE_MAIN_TYPE(type)->tag_name 811 #define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type 812 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type 813 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type 814 #define TYPE_CHAIN(thistype) (thistype)->chain 815 /* Note that if thistype is a TYPEDEF type, you have to call check_typedef. 816 But check_typedef does set the TYPE_LENGTH of the TYPEDEF type, 817 so you only have to call check_typedef once. Since allocate_value 818 calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */ 819 #define TYPE_LENGTH(thistype) (thistype)->length 820 /* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you want the real 821 type, you need to do TYPE_CODE (check_type (this_type)). */ 822 #define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code 823 #define TYPE_NFIELDS(thistype) TYPE_MAIN_TYPE(thistype)->nfields 824 #define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->fields 825 #define TYPE_TEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->template_args 826 827 #define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0) 828 #define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0) 829 #define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1) 830 831 /* Moto-specific stuff for FORTRAN arrays */ 832 833 #define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype) \ 834 (TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),1)) 835 #define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \ 836 (TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),0)) 837 838 #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \ 839 (TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype)))) 840 841 #define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \ 842 (TYPE_LOW_BOUND(TYPE_INDEX_TYPE((arraytype)))) 843 844 /* C++ */ 845 846 #define TYPE_VPTR_BASETYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype 847 #define TYPE_DOMAIN_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->vptr_basetype 848 #define TYPE_VPTR_FIELDNO(thistype) TYPE_MAIN_TYPE(thistype)->vptr_fieldno 849 #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields 850 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields 851 #define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total 852 #define TYPE_NTEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->ntemplate_args 853 #define TYPE_DECLARED_TYPE(thistype) TYPE_CPLUS_SPECIFIC(thistype)->declared_type 854 #define TYPE_TYPE_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific 855 #define TYPE_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff 856 #define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat 857 #define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.calling_convention 858 #define TYPE_BASECLASS(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].type 859 #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses 860 #define TYPE_BASECLASS_NAME(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].name 861 #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index) 862 #define BASETYPE_VIA_PUBLIC(thistype, index) \ 863 ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index))) 864 865 #define BASETYPE_VIA_VIRTUAL(thistype, index) \ 866 (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \ 867 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index))) 868 869 #define FIELD_TYPE(thisfld) ((thisfld).type) 870 #define FIELD_NAME(thisfld) ((thisfld).name) 871 #define FIELD_LOC_KIND(thisfld) ((thisfld).loc_kind) 872 #define FIELD_BITPOS(thisfld) ((thisfld).loc.bitpos) 873 #define FIELD_STATIC_PHYSNAME(thisfld) ((thisfld).loc.physname) 874 #define FIELD_STATIC_PHYSADDR(thisfld) ((thisfld).loc.physaddr) 875 #define FIELD_DWARF_BLOCK(thisfld) ((thisfld).loc.dwarf_block) 876 #define SET_FIELD_BITPOS(thisfld, bitpos) \ 877 (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_BITPOS, \ 878 FIELD_BITPOS (thisfld) = (bitpos)) 879 #define SET_FIELD_PHYSNAME(thisfld, name) \ 880 (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSNAME, \ 881 FIELD_STATIC_PHYSNAME (thisfld) = (name)) 882 #define SET_FIELD_PHYSADDR(thisfld, addr) \ 883 (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSADDR, \ 884 FIELD_STATIC_PHYSADDR (thisfld) = (addr)) 885 #define SET_FIELD_DWARF_BLOCK(thisfld, addr) \ 886 (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_DWARF_BLOCK, \ 887 FIELD_DWARF_BLOCK (thisfld) = (addr)) 888 #define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial) 889 #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize) 890 891 #define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->fields[n] 892 #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n)) 893 #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n)) 894 #define TYPE_FIELD_LOC_KIND(thistype, n) FIELD_LOC_KIND (TYPE_FIELD (thistype, n)) 895 #define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS (TYPE_FIELD (thistype, n)) 896 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_STATIC_PHYSNAME (TYPE_FIELD (thistype, n)) 897 #define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_STATIC_PHYSADDR (TYPE_FIELD (thistype, n)) 898 #define TYPE_FIELD_DWARF_BLOCK(thistype, n) FIELD_DWARF_BLOCK (TYPE_FIELD (thistype, n)) 899 #define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL(TYPE_FIELD(thistype,n)) 900 #define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE(TYPE_FIELD(thistype,n)) 901 #define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE(TYPE_FIELD(thistype,n))!=0) 902 #define TYPE_TEMPLATE_ARG(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->template_args[n] 903 904 #define TYPE_FIELD_PRIVATE_BITS(thistype) \ 905 TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits 906 #define TYPE_FIELD_PROTECTED_BITS(thistype) \ 907 TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits 908 #define TYPE_FIELD_IGNORE_BITS(thistype) \ 909 TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits 910 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \ 911 TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits 912 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \ 913 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)) 914 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \ 915 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)) 916 #define SET_TYPE_FIELD_IGNORE(thistype, n) \ 917 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)) 918 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \ 919 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)) 920 #define TYPE_FIELD_PRIVATE(thistype, n) \ 921 (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \ 922 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))) 923 #define TYPE_FIELD_PROTECTED(thistype, n) \ 924 (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \ 925 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))) 926 #define TYPE_FIELD_IGNORE(thistype, n) \ 927 (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \ 928 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))) 929 #define TYPE_FIELD_VIRTUAL(thistype, n) \ 930 (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \ 931 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))) 932 933 #define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists 934 #define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n] 935 #define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields 936 #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name 937 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length 938 939 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n] 940 #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname 941 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type 942 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_FIELDS ((thisfn)[n].type) 943 #define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const) 944 #define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile) 945 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private) 946 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected) 947 #define TYPE_FN_FIELD_PUBLIC(thisfn, n) ((thisfn)[n].is_public) 948 #define TYPE_FN_FIELD_STATIC(thisfn, n) ((thisfn)[n].is_static) 949 #define TYPE_FN_FIELD_FINAL(thisfn, n) ((thisfn)[n].is_final) 950 #define TYPE_FN_FIELD_SYNCHRONIZED(thisfn, n) ((thisfn)[n].is_synchronized) 951 #define TYPE_FN_FIELD_NATIVE(thisfn, n) ((thisfn)[n].is_native) 952 #define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n) ((thisfn)[n].is_artificial) 953 #define TYPE_FN_FIELD_ABSTRACT(thisfn, n) ((thisfn)[n].is_abstract) 954 #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub) 955 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext) 956 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2) 957 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1) 958 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC) 959 960 #define TYPE_LOCALTYPE_PTR(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr) 961 #define TYPE_LOCALTYPE_FILE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->file) 962 #define TYPE_LOCALTYPE_LINE(thistype) (TYPE_CPLUS_SPECIFIC(thistype)->localtype_ptr->line) 963 964 #define TYPE_IS_OPAQUE(thistype) (((TYPE_CODE (thistype) == TYPE_CODE_STRUCT) || \ 965 (TYPE_CODE (thistype) == TYPE_CODE_UNION)) && \ 966 (TYPE_NFIELDS (thistype) == 0) && \ 967 (TYPE_CPLUS_SPECIFIC (thistype) && (TYPE_NFN_FIELDS (thistype) == 0)) && \ 968 (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype))) 969 970 struct builtin_type 971 { 972 /* Integral types. */ 973 974 /* Implicit size/sign (based on the the architecture's ABI). */ 975 struct type *builtin_void; 976 struct type *builtin_char; 977 struct type *builtin_short; 978 struct type *builtin_int; 979 struct type *builtin_long; 980 struct type *builtin_signed_char; 981 struct type *builtin_unsigned_char; 982 struct type *builtin_unsigned_short; 983 struct type *builtin_unsigned_int; 984 struct type *builtin_unsigned_long; 985 struct type *builtin_float; 986 struct type *builtin_double; 987 struct type *builtin_long_double; 988 struct type *builtin_complex; 989 struct type *builtin_double_complex; 990 struct type *builtin_string; 991 struct type *builtin_bool; 992 struct type *builtin_long_long; 993 struct type *builtin_unsigned_long_long; 994 struct type *builtin_decfloat; 995 struct type *builtin_decdouble; 996 struct type *builtin_declong; 997 998 /* "True" character types. 999 We use these for the '/c' print format, because c_char is just a 1000 one-byte integral type, which languages less laid back than C 1001 will print as ... well, a one-byte integral type. */ 1002 struct type *builtin_true_char; 1003 struct type *builtin_true_unsigned_char; 1004 1005 /* Explicit sizes - see C9X <intypes.h> for naming scheme. The "int0" 1006 is for when an architecture needs to describe a register that has 1007 no size. */ 1008 struct type *builtin_int0; 1009 struct type *builtin_int8; 1010 struct type *builtin_uint8; 1011 struct type *builtin_int16; 1012 struct type *builtin_uint16; 1013 struct type *builtin_int32; 1014 struct type *builtin_uint32; 1015 struct type *builtin_int64; 1016 struct type *builtin_uint64; 1017 struct type *builtin_int128; 1018 struct type *builtin_uint128; 1019 1020 1021 /* Pointer types. */ 1022 1023 /* `pointer to data' type. Some target platforms use an implicitly 1024 {sign,zero} -extended 32-bit ABI pointer on a 64-bit ISA. */ 1025 struct type *builtin_data_ptr; 1026 1027 /* `pointer to function (returning void)' type. Harvard 1028 architectures mean that ABI function and code pointers are not 1029 interconvertible. Similarly, since ANSI, C standards have 1030 explicitly said that pointers to functions and pointers to data 1031 are not interconvertible --- that is, you can't cast a function 1032 pointer to void * and back, and expect to get the same value. 1033 However, all function pointer types are interconvertible, so void 1034 (*) () can server as a generic function pointer. */ 1035 struct type *builtin_func_ptr; 1036 1037 1038 /* Special-purpose types. */ 1039 1040 /* This type is used to represent a GDB internal function. */ 1041 struct type *internal_fn; 1042 }; 1043 1044 /* Return the type table for the specified architecture. */ 1045 extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch); 1046 1047 1048 /* Per-objfile types used by symbol readers. */ 1049 1050 struct objfile_type 1051 { 1052 /* Basic types based on the objfile architecture. */ 1053 struct type *builtin_void; 1054 struct type *builtin_char; 1055 struct type *builtin_short; 1056 struct type *builtin_int; 1057 struct type *builtin_long; 1058 struct type *builtin_long_long; 1059 struct type *builtin_signed_char; 1060 struct type *builtin_unsigned_char; 1061 struct type *builtin_unsigned_short; 1062 struct type *builtin_unsigned_int; 1063 struct type *builtin_unsigned_long; 1064 struct type *builtin_unsigned_long_long; 1065 struct type *builtin_float; 1066 struct type *builtin_double; 1067 struct type *builtin_long_double; 1068 1069 /* This type is used to represent symbol addresses. */ 1070 struct type *builtin_core_addr; 1071 1072 /* This type represents a type that was unrecognized in symbol read-in. */ 1073 struct type *builtin_error; 1074 1075 /* Types used for symbols with no debug information. */ 1076 struct type *nodebug_text_symbol; 1077 struct type *nodebug_data_symbol; 1078 struct type *nodebug_unknown_symbol; 1079 struct type *nodebug_tls_symbol; 1080 }; 1081 1082 /* Return the type table for the specified objfile. */ 1083 extern const struct objfile_type *objfile_type (struct objfile *objfile); 1084 1085 1086 /* Explicit floating-point formats. See "floatformat.h". */ 1087 extern const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]; 1088 extern const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]; 1089 extern const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN]; 1090 extern const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN]; 1091 extern const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN]; 1092 extern const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN]; 1093 extern const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN]; 1094 extern const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN]; 1095 extern const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN]; 1096 extern const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN]; 1097 extern const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN]; 1098 1099 1100 /* Maximum and minimum values of built-in types */ 1101 1102 #define MAX_OF_TYPE(t) \ 1103 (TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) \ 1104 : MAX_OF_SIZE(TYPE_LENGTH(t))) 1105 1106 #define MIN_OF_TYPE(t) \ 1107 (TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) \ 1108 : MIN_OF_SIZE(TYPE_LENGTH(t))) 1109 1110 /* Allocate space for storing data associated with a particular type. 1111 We ensure that the space is allocated using the same mechanism that 1112 was used to allocate the space for the type structure itself. I.E. 1113 if the type is on an objfile's objfile_obstack, then the space for data 1114 associated with that type will also be allocated on the objfile_obstack. 1115 If the type is not associated with any particular objfile (such as 1116 builtin types), then the data space will be allocated with xmalloc, 1117 the same as for the type structure. */ 1118 1119 #define TYPE_ALLOC(t,size) \ 1120 (TYPE_OBJFILE_OWNED (t) \ 1121 ? obstack_alloc (&TYPE_OBJFILE (t) -> objfile_obstack, size) \ 1122 : xmalloc (size)) 1123 1124 #define TYPE_ZALLOC(t,size) \ 1125 (TYPE_OBJFILE_OWNED (t) \ 1126 ? memset (obstack_alloc (&TYPE_OBJFILE (t)->objfile_obstack, size), \ 1127 0, size) \ 1128 : xzalloc (size)) 1129 1130 /* Use alloc_type to allocate a type owned by an objfile. 1131 Use alloc_type_arch to allocate a type owned by an architecture. 1132 Use alloc_type_copy to allocate a type with the same owner as a 1133 pre-existing template type, no matter whether objfile or gdbarch. */ 1134 extern struct type *alloc_type (struct objfile *); 1135 extern struct type *alloc_type_arch (struct gdbarch *); 1136 extern struct type *alloc_type_copy (const struct type *); 1137 1138 /* Return the type's architecture. For types owned by an architecture, 1139 that architecture is returned. For types owned by an objfile, that 1140 objfile's architecture is returned. */ 1141 extern struct gdbarch *get_type_arch (const struct type *); 1142 1143 /* Helper function to construct objfile-owned types. */ 1144 extern struct type *init_type (enum type_code, int, int, char *, 1145 struct objfile *); 1146 1147 /* Helper functions to construct architecture-owned types. */ 1148 extern struct type *arch_type (struct gdbarch *, enum type_code, int, char *); 1149 extern struct type *arch_integer_type (struct gdbarch *, int, int, char *); 1150 extern struct type *arch_character_type (struct gdbarch *, int, int, char *); 1151 extern struct type *arch_boolean_type (struct gdbarch *, int, int, char *); 1152 extern struct type *arch_float_type (struct gdbarch *, int, char *, 1153 const struct floatformat **); 1154 extern struct type *arch_complex_type (struct gdbarch *, char *, 1155 struct type *); 1156 1157 /* Helper functions to construct a struct or record type. An 1158 initially empty type is created using arch_composite_type(). 1159 Fields are then added using append_struct_type_field(). A union 1160 type has its size set to the largest field. A struct type has each 1161 field packed against the previous. */ 1162 1163 extern struct type *arch_composite_type (struct gdbarch *gdbarch, 1164 char *name, enum type_code code); 1165 extern void append_composite_type_field (struct type *t, char *name, 1166 struct type *field); 1167 extern void append_composite_type_field_aligned (struct type *t, 1168 char *name, 1169 struct type *field, 1170 int alignment); 1171 1172 /* Helper functions to construct a bit flags type. An initially empty 1173 type is created using arch_flag_type(). Flags are then added using 1174 append_flag_type_flag(). */ 1175 extern struct type *arch_flags_type (struct gdbarch *gdbarch, 1176 char *name, int length); 1177 extern void append_flags_type_flag (struct type *type, int bitpos, char *name); 1178 1179 extern void make_vector_type (struct type *array_type); 1180 extern struct type *init_vector_type (struct type *elt_type, int n); 1181 1182 extern struct type *lookup_reference_type (struct type *); 1183 1184 extern struct type *make_reference_type (struct type *, struct type **); 1185 1186 extern struct type *make_cv_type (int, int, struct type *, struct type **); 1187 1188 extern void replace_type (struct type *, struct type *); 1189 1190 extern int address_space_name_to_int (struct gdbarch *, char *); 1191 1192 extern const char *address_space_int_to_name (struct gdbarch *, int); 1193 1194 extern struct type *make_type_with_address_space (struct type *type, 1195 int space_identifier); 1196 1197 extern struct type *lookup_memberptr_type (struct type *, struct type *); 1198 1199 extern struct type *lookup_methodptr_type (struct type *); 1200 1201 extern void smash_to_method_type (struct type *type, struct type *domain, 1202 struct type *to_type, struct field *args, 1203 int nargs, int varargs); 1204 1205 extern void smash_to_memberptr_type (struct type *, struct type *, 1206 struct type *); 1207 1208 extern struct type *allocate_stub_method (struct type *); 1209 1210 extern char *type_name_no_tag (const struct type *); 1211 1212 extern struct type *lookup_struct_elt_type (struct type *, char *, int); 1213 1214 extern struct type *make_pointer_type (struct type *, struct type **); 1215 1216 extern struct type *lookup_pointer_type (struct type *); 1217 1218 extern struct type *make_function_type (struct type *, struct type **); 1219 1220 extern struct type *lookup_function_type (struct type *); 1221 1222 extern struct type *create_range_type (struct type *, struct type *, int, 1223 int); 1224 1225 extern struct type *create_array_type (struct type *, struct type *, 1226 struct type *); 1227 extern struct type *lookup_array_range_type (struct type *, int, int); 1228 1229 extern struct type *create_string_type (struct type *, struct type *, 1230 struct type *); 1231 extern struct type *lookup_string_range_type (struct type *, int, int); 1232 1233 extern struct type *create_set_type (struct type *, struct type *); 1234 1235 extern struct type *lookup_unsigned_typename (const struct language_defn *, 1236 struct gdbarch *,char *); 1237 1238 extern struct type *lookup_signed_typename (const struct language_defn *, 1239 struct gdbarch *,char *); 1240 1241 extern struct type *check_typedef (struct type *); 1242 1243 #define CHECK_TYPEDEF(TYPE) \ 1244 do { \ 1245 (TYPE) = check_typedef (TYPE); \ 1246 } while (0) 1247 1248 extern void check_stub_method_group (struct type *, int); 1249 1250 extern char *gdb_mangle_name (struct type *, int, int); 1251 1252 extern struct type *lookup_typename (const struct language_defn *, 1253 struct gdbarch *, char *, 1254 struct block *, int); 1255 1256 extern struct type *lookup_template_type (char *, struct type *, 1257 struct block *); 1258 1259 extern int get_vptr_fieldno (struct type *, struct type **); 1260 1261 extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *); 1262 1263 extern int is_ancestor (struct type *, struct type *); 1264 1265 /* Overload resolution */ 1266 1267 #define LENGTH_MATCH(bv) ((bv)->rank[0]) 1268 1269 /* Badness if parameter list length doesn't match arg list length */ 1270 #define LENGTH_MISMATCH_BADNESS 100 1271 /* Dummy badness value for nonexistent parameter positions */ 1272 #define TOO_FEW_PARAMS_BADNESS 100 1273 /* Badness if no conversion among types */ 1274 #define INCOMPATIBLE_TYPE_BADNESS 100 1275 1276 /* Badness of integral promotion */ 1277 #define INTEGER_PROMOTION_BADNESS 1 1278 /* Badness of floating promotion */ 1279 #define FLOAT_PROMOTION_BADNESS 1 1280 /* Badness of integral conversion */ 1281 #define INTEGER_CONVERSION_BADNESS 2 1282 /* Badness of floating conversion */ 1283 #define FLOAT_CONVERSION_BADNESS 2 1284 /* Badness of integer<->floating conversions */ 1285 #define INT_FLOAT_CONVERSION_BADNESS 2 1286 /* Badness of converting to a boolean */ 1287 #define BOOLEAN_CONVERSION_BADNESS 2 1288 /* Badness of pointer conversion */ 1289 #define POINTER_CONVERSION_BADNESS 2 1290 /* Badness of conversion of pointer to void pointer */ 1291 #define VOID_PTR_CONVERSION_BADNESS 2 1292 /* Badness of converting derived to base class */ 1293 #define BASE_CONVERSION_BADNESS 2 1294 /* Badness of converting from non-reference to reference */ 1295 #define REFERENCE_CONVERSION_BADNESS 2 1296 1297 /* Non-standard conversions allowed by the debugger */ 1298 /* Converting a pointer to an int is usually OK */ 1299 #define NS_POINTER_CONVERSION_BADNESS 10 1300 1301 1302 extern int compare_badness (struct badness_vector *, struct badness_vector *); 1303 1304 extern struct badness_vector *rank_function (struct type **, int, 1305 struct type **, int); 1306 1307 extern int rank_one_type (struct type *, struct type *); 1308 1309 extern void recursive_dump_type (struct type *, int); 1310 1311 extern int field_is_static (struct field *); 1312 1313 /* printcmd.c */ 1314 1315 extern void print_scalar_formatted (const void *, struct type *, 1316 const struct value_print_options *, 1317 int, struct ui_file *); 1318 1319 extern int can_dereference (struct type *); 1320 1321 extern int is_integral_type (struct type *); 1322 1323 extern void maintenance_print_type (char *, int); 1324 1325 extern htab_t create_copied_types_hash (struct objfile *objfile); 1326 1327 extern struct type *copy_type_recursive (struct objfile *objfile, 1328 struct type *type, 1329 htab_t copied_types); 1330 1331 extern struct type *copy_type (const struct type *type); 1332 1333 #endif /* GDBTYPES_H */ 1334