gdbtypes.h revision 1.1.1.9
1 2/* Internal type definitions for GDB. 3 4 Copyright (C) 1992-2020 Free Software Foundation, Inc. 5 6 Contributed by Cygnus Support, using pieces from other GDB modules. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23#if !defined (GDBTYPES_H) 24#define GDBTYPES_H 1 25 26/* * \page gdbtypes GDB Types 27 28 GDB represents all the different kinds of types in programming 29 languages using a common representation defined in gdbtypes.h. 30 31 The main data structure is main_type; it consists of a code (such 32 as #TYPE_CODE_ENUM for enumeration types), a number of 33 generally-useful fields such as the printable name, and finally a 34 field main_type::type_specific that is a union of info specific to 35 particular languages or other special cases (such as calling 36 convention). 37 38 The available type codes are defined in enum #type_code. The enum 39 includes codes both for types that are common across a variety 40 of languages, and for types that are language-specific. 41 42 Most accesses to type fields go through macros such as 43 #TYPE_CODE(thistype) and #TYPE_FN_FIELD_CONST(thisfn, n). These are 44 written such that they can be used as both rvalues and lvalues. 45 */ 46 47#include "hashtab.h" 48#include "gdbsupport/array-view.h" 49#include "gdbsupport/offset-type.h" 50#include "gdbsupport/enum-flags.h" 51#include "gdbsupport/underlying.h" 52#include "gdbsupport/print-utils.h" 53#include "dwarf2.h" 54#include "gdb_obstack.h" 55 56/* Forward declarations for prototypes. */ 57struct field; 58struct block; 59struct value_print_options; 60struct language_defn; 61struct dwarf2_per_cu_data; 62struct dwarf2_per_objfile; 63 64/* These declarations are DWARF-specific as some of the gdbtypes.h data types 65 are already DWARF-specific. */ 66 67/* * Offset relative to the start of its containing CU (compilation 68 unit). */ 69DEFINE_OFFSET_TYPE (cu_offset, unsigned int); 70 71/* * Offset relative to the start of its .debug_info or .debug_types 72 section. */ 73DEFINE_OFFSET_TYPE (sect_offset, uint64_t); 74 75static inline char * 76sect_offset_str (sect_offset offset) 77{ 78 return hex_string (to_underlying (offset)); 79} 80 81/* Some macros for char-based bitfields. */ 82 83#define B_SET(a,x) ((a)[(x)>>3] |= (1 << ((x)&7))) 84#define B_CLR(a,x) ((a)[(x)>>3] &= ~(1 << ((x)&7))) 85#define B_TST(a,x) ((a)[(x)>>3] & (1 << ((x)&7))) 86#define B_TYPE unsigned char 87#define B_BYTES(x) ( 1 + ((x)>>3) ) 88#define B_CLRALL(a,x) memset ((a), 0, B_BYTES(x)) 89 90/* * Different kinds of data types are distinguished by the `code' 91 field. */ 92 93enum type_code 94 { 95 TYPE_CODE_BITSTRING = -1, /**< Deprecated */ 96 TYPE_CODE_UNDEF = 0, /**< Not used; catches errors */ 97 TYPE_CODE_PTR, /**< Pointer type */ 98 99 /* * Array type with lower & upper bounds. 100 101 Regardless of the language, GDB represents multidimensional 102 array types the way C does: as arrays of arrays. So an 103 instance of a GDB array type T can always be seen as a series 104 of instances of TYPE_TARGET_TYPE (T) laid out sequentially in 105 memory. 106 107 Row-major languages like C lay out multi-dimensional arrays so 108 that incrementing the rightmost index in a subscripting 109 expression results in the smallest change in the address of the 110 element referred to. Column-major languages like Fortran lay 111 them out so that incrementing the leftmost index results in the 112 smallest change. 113 114 This means that, in column-major languages, working our way 115 from type to target type corresponds to working through indices 116 from right to left, not left to right. */ 117 TYPE_CODE_ARRAY, 118 119 TYPE_CODE_STRUCT, /**< C struct or Pascal record */ 120 TYPE_CODE_UNION, /**< C union or Pascal variant part */ 121 TYPE_CODE_ENUM, /**< Enumeration type */ 122 TYPE_CODE_FLAGS, /**< Bit flags type */ 123 TYPE_CODE_FUNC, /**< Function type */ 124 TYPE_CODE_INT, /**< Integer type */ 125 126 /* * Floating type. This is *NOT* a complex type. */ 127 TYPE_CODE_FLT, 128 129 /* * Void type. The length field specifies the length (probably 130 always one) which is used in pointer arithmetic involving 131 pointers to this type, but actually dereferencing such a 132 pointer is invalid; a void type has no length and no actual 133 representation in memory or registers. A pointer to a void 134 type is a generic pointer. */ 135 TYPE_CODE_VOID, 136 137 TYPE_CODE_SET, /**< Pascal sets */ 138 TYPE_CODE_RANGE, /**< Range (integers within spec'd bounds). */ 139 140 /* * A string type which is like an array of character but prints 141 differently. It does not contain a length field as Pascal 142 strings (for many Pascals, anyway) do; if we want to deal with 143 such strings, we should use a new type code. */ 144 TYPE_CODE_STRING, 145 146 /* * Unknown type. The length field is valid if we were able to 147 deduce that much about the type, or 0 if we don't even know 148 that. */ 149 TYPE_CODE_ERROR, 150 151 /* C++ */ 152 TYPE_CODE_METHOD, /**< Method type */ 153 154 /* * Pointer-to-member-function type. This describes how to access a 155 particular member function of a class (possibly a virtual 156 member function). The representation may vary between different 157 C++ ABIs. */ 158 TYPE_CODE_METHODPTR, 159 160 /* * Pointer-to-member type. This is the offset within a class to 161 some particular data member. The only currently supported 162 representation uses an unbiased offset, with -1 representing 163 NULL; this is used by the Itanium C++ ABI (used by GCC on all 164 platforms). */ 165 TYPE_CODE_MEMBERPTR, 166 167 TYPE_CODE_REF, /**< C++ Reference types */ 168 169 TYPE_CODE_RVALUE_REF, /**< C++ rvalue reference types */ 170 171 TYPE_CODE_CHAR, /**< *real* character type */ 172 173 /* * Boolean type. 0 is false, 1 is true, and other values are 174 non-boolean (e.g. FORTRAN "logical" used as unsigned int). */ 175 TYPE_CODE_BOOL, 176 177 /* Fortran */ 178 TYPE_CODE_COMPLEX, /**< Complex float */ 179 180 TYPE_CODE_TYPEDEF, 181 182 TYPE_CODE_NAMESPACE, /**< C++ namespace. */ 183 184 TYPE_CODE_DECFLOAT, /**< Decimal floating point. */ 185 186 TYPE_CODE_MODULE, /**< Fortran module. */ 187 188 /* * Internal function type. */ 189 TYPE_CODE_INTERNAL_FUNCTION, 190 191 /* * Methods implemented in extension languages. */ 192 TYPE_CODE_XMETHOD 193 }; 194 195/* * Some bits for the type's instance_flags word. See the macros 196 below for documentation on each bit. */ 197 198enum type_instance_flag_value : unsigned 199{ 200 TYPE_INSTANCE_FLAG_CONST = (1 << 0), 201 TYPE_INSTANCE_FLAG_VOLATILE = (1 << 1), 202 TYPE_INSTANCE_FLAG_CODE_SPACE = (1 << 2), 203 TYPE_INSTANCE_FLAG_DATA_SPACE = (1 << 3), 204 TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 = (1 << 4), 205 TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2 = (1 << 5), 206 TYPE_INSTANCE_FLAG_NOTTEXT = (1 << 6), 207 TYPE_INSTANCE_FLAG_RESTRICT = (1 << 7), 208 TYPE_INSTANCE_FLAG_ATOMIC = (1 << 8) 209}; 210 211DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); 212 213/* * Unsigned integer type. If this is not set for a TYPE_CODE_INT, 214 the type is signed (unless TYPE_NOSIGN (below) is set). */ 215 216#define TYPE_UNSIGNED(t) (TYPE_MAIN_TYPE (t)->flag_unsigned) 217 218/* * No sign for this type. In C++, "char", "signed char", and 219 "unsigned char" are distinct types; so we need an extra flag to 220 indicate the absence of a sign! */ 221 222#define TYPE_NOSIGN(t) (TYPE_MAIN_TYPE (t)->flag_nosign) 223 224/* * A compiler may supply dwarf instrumentation 225 that indicates the desired endian interpretation of the variable 226 differs from the native endian representation. */ 227 228#define TYPE_ENDIANITY_NOT_DEFAULT(t) (TYPE_MAIN_TYPE (t)->flag_endianity_not_default) 229 230/* * This appears in a type's flags word if it is a stub type (e.g., 231 if someone referenced a type that wasn't defined in a source file 232 via (struct sir_not_appearing_in_this_film *)). */ 233 234#define TYPE_STUB(t) (TYPE_MAIN_TYPE (t)->flag_stub) 235 236/* * The target type of this type is a stub type, and this type needs 237 to be updated if it gets un-stubbed in check_typedef. Used for 238 arrays and ranges, in which TYPE_LENGTH of the array/range gets set 239 based on the TYPE_LENGTH of the target type. Also, set for 240 TYPE_CODE_TYPEDEF. */ 241 242#define TYPE_TARGET_STUB(t) (TYPE_MAIN_TYPE (t)->flag_target_stub) 243 244/* * This is a function type which appears to have a prototype. We 245 need this for function calls in order to tell us if it's necessary 246 to coerce the args, or to just do the standard conversions. This 247 is used with a short field. */ 248 249#define TYPE_PROTOTYPED(t) (TYPE_MAIN_TYPE (t)->flag_prototyped) 250 251/* * FIXME drow/2002-06-03: Only used for methods, but applies as well 252 to functions. */ 253 254#define TYPE_VARARGS(t) (TYPE_MAIN_TYPE (t)->flag_varargs) 255 256/* * Identify a vector type. Gcc is handling this by adding an extra 257 attribute to the array type. We slurp that in as a new flag of a 258 type. This is used only in dwarf2read.c. */ 259#define TYPE_VECTOR(t) (TYPE_MAIN_TYPE (t)->flag_vector) 260 261/* * The debugging formats (especially STABS) do not contain enough 262 information to represent all Ada types---especially those whose 263 size depends on dynamic quantities. Therefore, the GNAT Ada 264 compiler includes extra information in the form of additional type 265 definitions connected by naming conventions. This flag indicates 266 that the type is an ordinary (unencoded) GDB type that has been 267 created from the necessary run-time information, and does not need 268 further interpretation. Optionally marks ordinary, fixed-size GDB 269 type. */ 270 271#define TYPE_FIXED_INSTANCE(t) (TYPE_MAIN_TYPE (t)->flag_fixed_instance) 272 273/* * This debug target supports TYPE_STUB(t). In the unsupported case 274 we have to rely on NFIELDS to be zero etc., see TYPE_IS_OPAQUE(). 275 TYPE_STUB(t) with !TYPE_STUB_SUPPORTED(t) may exist if we only 276 guessed the TYPE_STUB(t) value (see dwarfread.c). */ 277 278#define TYPE_STUB_SUPPORTED(t) (TYPE_MAIN_TYPE (t)->flag_stub_supported) 279 280/* * Not textual. By default, GDB treats all single byte integers as 281 characters (or elements of strings) unless this flag is set. */ 282 283#define TYPE_NOTTEXT(t) (TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_NOTTEXT) 284 285/* * Used only for TYPE_CODE_FUNC where it specifies the real function 286 address is returned by this function call. TYPE_TARGET_TYPE 287 determines the final returned function type to be presented to 288 user. */ 289 290#define TYPE_GNU_IFUNC(t) (TYPE_MAIN_TYPE (t)->flag_gnu_ifunc) 291 292/* * Type owner. If TYPE_OBJFILE_OWNED is true, the type is owned by 293 the objfile retrieved as TYPE_OBJFILE. Otherwise, the type is 294 owned by an architecture; TYPE_OBJFILE is NULL in this case. */ 295 296#define TYPE_OBJFILE_OWNED(t) (TYPE_MAIN_TYPE (t)->flag_objfile_owned) 297#define TYPE_OWNER(t) TYPE_MAIN_TYPE(t)->owner 298#define TYPE_OBJFILE(t) (TYPE_OBJFILE_OWNED(t)? TYPE_OWNER(t).objfile : NULL) 299 300/* * True if this type was declared using the "class" keyword. This is 301 only valid for C++ structure and enum types. If false, a structure 302 was declared as a "struct"; if true it was declared "class". For 303 enum types, this is true when "enum class" or "enum struct" was 304 used to declare the type.. */ 305 306#define TYPE_DECLARED_CLASS(t) (TYPE_MAIN_TYPE (t)->flag_declared_class) 307 308/* * True if this type is a "flag" enum. A flag enum is one where all 309 the values are pairwise disjoint when "and"ed together. This 310 affects how enum values are printed. */ 311 312#define TYPE_FLAG_ENUM(t) (TYPE_MAIN_TYPE (t)->flag_flag_enum) 313 314/* * Constant type. If this is set, the corresponding type has a 315 const modifier. */ 316 317#define TYPE_CONST(t) ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CONST) != 0) 318 319/* * Volatile type. If this is set, the corresponding type has a 320 volatile modifier. */ 321 322#define TYPE_VOLATILE(t) \ 323 ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_VOLATILE) != 0) 324 325/* * Restrict type. If this is set, the corresponding type has a 326 restrict modifier. */ 327 328#define TYPE_RESTRICT(t) \ 329 ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_RESTRICT) != 0) 330 331/* * Atomic type. If this is set, the corresponding type has an 332 _Atomic modifier. */ 333 334#define TYPE_ATOMIC(t) \ 335 ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_ATOMIC) != 0) 336 337/* * True if this type represents either an lvalue or lvalue reference type. */ 338 339#define TYPE_IS_REFERENCE(t) \ 340 ((t)->code () == TYPE_CODE_REF || (t)->code () == TYPE_CODE_RVALUE_REF) 341 342/* * True if this type is allocatable. */ 343#define TYPE_IS_ALLOCATABLE(t) \ 344 ((t)->dyn_prop (DYN_PROP_ALLOCATED) != NULL) 345 346/* * True if this type has variant parts. */ 347#define TYPE_HAS_VARIANT_PARTS(t) \ 348 ((t)->dyn_prop (DYN_PROP_VARIANT_PARTS) != nullptr) 349 350/* * True if this type has a dynamic length. */ 351#define TYPE_HAS_DYNAMIC_LENGTH(t) \ 352 ((t)->dyn_prop (DYN_PROP_BYTE_SIZE) != nullptr) 353 354/* * Instruction-space delimited type. This is for Harvard architectures 355 which have separate instruction and data address spaces (and perhaps 356 others). 357 358 GDB usually defines a flat address space that is a superset of the 359 architecture's two (or more) address spaces, but this is an extension 360 of the architecture's model. 361 362 If TYPE_INSTANCE_FLAG_CODE_SPACE is set, an object of the corresponding type 363 resides in instruction memory, even if its address (in the extended 364 flat address space) does not reflect this. 365 366 Similarly, if TYPE_INSTANCE_FLAG_DATA_SPACE is set, then an object of the 367 corresponding type resides in the data memory space, even if 368 this is not indicated by its (flat address space) address. 369 370 If neither flag is set, the default space for functions / methods 371 is instruction space, and for data objects is data memory. */ 372 373#define TYPE_CODE_SPACE(t) \ 374 ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_CODE_SPACE) != 0) 375 376#define TYPE_DATA_SPACE(t) \ 377 ((TYPE_INSTANCE_FLAGS (t) & TYPE_INSTANCE_FLAG_DATA_SPACE) != 0) 378 379/* * Address class flags. Some environments provide for pointers 380 whose size is different from that of a normal pointer or address 381 types where the bits are interpreted differently than normal 382 addresses. The TYPE_INSTANCE_FLAG_ADDRESS_CLASS_n flags may be used in 383 target specific ways to represent these different types of address 384 classes. */ 385 386#define TYPE_ADDRESS_CLASS_1(t) (TYPE_INSTANCE_FLAGS(t) \ 387 & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1) 388#define TYPE_ADDRESS_CLASS_2(t) (TYPE_INSTANCE_FLAGS(t) \ 389 & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2) 390#define TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL \ 391 (TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2) 392#define TYPE_ADDRESS_CLASS_ALL(t) (TYPE_INSTANCE_FLAGS(t) \ 393 & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) 394 395/* * Information about a single discriminant. */ 396 397struct discriminant_range 398{ 399 /* * The range of values for the variant. This is an inclusive 400 range. */ 401 ULONGEST low, high; 402 403 /* * Return true if VALUE is contained in this range. IS_UNSIGNED 404 is true if this should be an unsigned comparison; false for 405 signed. */ 406 bool contains (ULONGEST value, bool is_unsigned) const 407 { 408 if (is_unsigned) 409 return value >= low && value <= high; 410 LONGEST valuel = (LONGEST) value; 411 return valuel >= (LONGEST) low && valuel <= (LONGEST) high; 412 } 413}; 414 415struct variant_part; 416 417/* * A single variant. A variant has a list of discriminant values. 418 When the discriminator matches one of these, the variant is 419 enabled. Each variant controls zero or more fields; and may also 420 control other variant parts as well. This struct corresponds to 421 DW_TAG_variant in DWARF. */ 422 423struct variant : allocate_on_obstack 424{ 425 /* * The discriminant ranges for this variant. */ 426 gdb::array_view<discriminant_range> discriminants; 427 428 /* * The fields controlled by this variant. This is inclusive on 429 the low end and exclusive on the high end. A variant may not 430 control any fields, in which case the two values will be equal. 431 These are indexes into the type's array of fields. */ 432 int first_field; 433 int last_field; 434 435 /* * Variant parts controlled by this variant. */ 436 gdb::array_view<variant_part> parts; 437 438 /* * Return true if this is the default variant. The default 439 variant can be recognized because it has no associated 440 discriminants. */ 441 bool is_default () const 442 { 443 return discriminants.empty (); 444 } 445 446 /* * Return true if this variant matches VALUE. IS_UNSIGNED is true 447 if this should be an unsigned comparison; false for signed. */ 448 bool matches (ULONGEST value, bool is_unsigned) const; 449}; 450 451/* * A variant part. Each variant part has an optional discriminant 452 and holds an array of variants. This struct corresponds to 453 DW_TAG_variant_part in DWARF. */ 454 455struct variant_part : allocate_on_obstack 456{ 457 /* * The index of the discriminant field in the outer type. This is 458 an index into the type's array of fields. If this is -1, there 459 is no discriminant, and only the default variant can be 460 considered to be selected. */ 461 int discriminant_index; 462 463 /* * True if this discriminant is unsigned; false if signed. This 464 comes from the type of the discriminant. */ 465 bool is_unsigned; 466 467 /* * The variants that are controlled by this variant part. Note 468 that these will always be sorted by field number. */ 469 gdb::array_view<variant> variants; 470}; 471 472 473enum dynamic_prop_kind 474{ 475 PROP_UNDEFINED, /* Not defined. */ 476 PROP_CONST, /* Constant. */ 477 PROP_ADDR_OFFSET, /* Address offset. */ 478 PROP_LOCEXPR, /* Location expression. */ 479 PROP_LOCLIST, /* Location list. */ 480 PROP_VARIANT_PARTS, /* Variant parts. */ 481 PROP_TYPE, /* Type. */ 482}; 483 484union dynamic_prop_data 485{ 486 /* Storage for constant property. */ 487 488 LONGEST const_val; 489 490 /* Storage for dynamic property. */ 491 492 void *baton; 493 494 /* Storage of variant parts for a type. A type with variant parts 495 has all its fields "linearized" -- stored in a single field 496 array, just as if they had all been declared that way. The 497 variant parts are attached via a dynamic property, and then are 498 used to control which fields end up in the final type during 499 dynamic type resolution. */ 500 501 const gdb::array_view<variant_part> *variant_parts; 502 503 /* Once a variant type is resolved, we may want to be able to go 504 from the resolved type to the original type. In this case we 505 rewrite the property's kind and set this field. */ 506 507 struct type *original_type; 508}; 509 510/* * Used to store a dynamic property. */ 511 512struct dynamic_prop 513{ 514 dynamic_prop_kind kind () const 515 { 516 return m_kind; 517 } 518 519 void set_undefined () 520 { 521 m_kind = PROP_UNDEFINED; 522 } 523 524 LONGEST const_val () const 525 { 526 gdb_assert (m_kind == PROP_CONST); 527 528 return m_data.const_val; 529 } 530 531 void set_const_val (LONGEST const_val) 532 { 533 m_kind = PROP_CONST; 534 m_data.const_val = const_val; 535 } 536 537 void *baton () const 538 { 539 gdb_assert (m_kind == PROP_LOCEXPR 540 || m_kind == PROP_LOCLIST 541 || m_kind == PROP_ADDR_OFFSET); 542 543 return m_data.baton; 544 } 545 546 void set_locexpr (void *baton) 547 { 548 m_kind = PROP_LOCEXPR; 549 m_data.baton = baton; 550 } 551 552 void set_loclist (void *baton) 553 { 554 m_kind = PROP_LOCLIST; 555 m_data.baton = baton; 556 } 557 558 void set_addr_offset (void *baton) 559 { 560 m_kind = PROP_ADDR_OFFSET; 561 m_data.baton = baton; 562 } 563 564 const gdb::array_view<variant_part> *variant_parts () const 565 { 566 gdb_assert (m_kind == PROP_VARIANT_PARTS); 567 568 return m_data.variant_parts; 569 } 570 571 void set_variant_parts (gdb::array_view<variant_part> *variant_parts) 572 { 573 m_kind = PROP_VARIANT_PARTS; 574 m_data.variant_parts = variant_parts; 575 } 576 577 struct type *original_type () const 578 { 579 gdb_assert (m_kind == PROP_TYPE); 580 581 return m_data.original_type; 582 } 583 584 void set_original_type (struct type *original_type) 585 { 586 m_kind = PROP_TYPE; 587 m_data.original_type = original_type; 588 } 589 590 /* Determine which field of the union dynamic_prop.data is used. */ 591 enum dynamic_prop_kind m_kind; 592 593 /* Storage for dynamic or static value. */ 594 union dynamic_prop_data m_data; 595}; 596 597/* Compare two dynamic_prop objects for equality. dynamic_prop 598 instances are equal iff they have the same type and storage. */ 599extern bool operator== (const dynamic_prop &l, const dynamic_prop &r); 600 601/* Compare two dynamic_prop objects for inequality. */ 602static inline bool operator!= (const dynamic_prop &l, const dynamic_prop &r) 603{ 604 return !(l == r); 605} 606 607/* * Define a type's dynamic property node kind. */ 608enum dynamic_prop_node_kind 609{ 610 /* A property providing a type's data location. 611 Evaluating this field yields to the location of an object's data. */ 612 DYN_PROP_DATA_LOCATION, 613 614 /* A property representing DW_AT_allocated. The presence of this attribute 615 indicates that the object of the type can be allocated/deallocated. */ 616 DYN_PROP_ALLOCATED, 617 618 /* A property representing DW_AT_associated. The presence of this attribute 619 indicated that the object of the type can be associated. */ 620 DYN_PROP_ASSOCIATED, 621 622 /* A property providing an array's byte stride. */ 623 DYN_PROP_BYTE_STRIDE, 624 625 /* A property holding variant parts. */ 626 DYN_PROP_VARIANT_PARTS, 627 628 /* A property holding the size of the type. */ 629 DYN_PROP_BYTE_SIZE, 630}; 631 632/* * List for dynamic type attributes. */ 633struct dynamic_prop_list 634{ 635 /* The kind of dynamic prop in this node. */ 636 enum dynamic_prop_node_kind prop_kind; 637 638 /* The dynamic property itself. */ 639 struct dynamic_prop prop; 640 641 /* A pointer to the next dynamic property. */ 642 struct dynamic_prop_list *next; 643}; 644 645/* * Determine which field of the union main_type.fields[x].loc is 646 used. */ 647 648enum field_loc_kind 649 { 650 FIELD_LOC_KIND_BITPOS, /**< bitpos */ 651 FIELD_LOC_KIND_ENUMVAL, /**< enumval */ 652 FIELD_LOC_KIND_PHYSADDR, /**< physaddr */ 653 FIELD_LOC_KIND_PHYSNAME, /**< physname */ 654 FIELD_LOC_KIND_DWARF_BLOCK /**< dwarf_block */ 655 }; 656 657/* * A discriminant to determine which field in the 658 main_type.type_specific union is being used, if any. 659 660 For types such as TYPE_CODE_FLT, the use of this 661 discriminant is really redundant, as we know from the type code 662 which field is going to be used. As such, it would be possible to 663 reduce the size of this enum in order to save a bit or two for 664 other fields of struct main_type. But, since we still have extra 665 room , and for the sake of clarity and consistency, we treat all fields 666 of the union the same way. */ 667 668enum type_specific_kind 669{ 670 TYPE_SPECIFIC_NONE, 671 TYPE_SPECIFIC_CPLUS_STUFF, 672 TYPE_SPECIFIC_GNAT_STUFF, 673 TYPE_SPECIFIC_FLOATFORMAT, 674 /* Note: This is used by TYPE_CODE_FUNC and TYPE_CODE_METHOD. */ 675 TYPE_SPECIFIC_FUNC, 676 TYPE_SPECIFIC_SELF_TYPE 677}; 678 679union type_owner 680{ 681 struct objfile *objfile; 682 struct gdbarch *gdbarch; 683}; 684 685union field_location 686{ 687 /* * Position of this field, counting in bits from start of 688 containing structure. For big-endian targets, it is the bit 689 offset to the MSB. For little-endian targets, it is the bit 690 offset to the LSB. */ 691 692 LONGEST bitpos; 693 694 /* * Enum value. */ 695 LONGEST enumval; 696 697 /* * For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then 698 physaddr is the location (in the target) of the static 699 field. Otherwise, physname is the mangled label of the 700 static field. */ 701 702 CORE_ADDR physaddr; 703 const char *physname; 704 705 /* * The field location can be computed by evaluating the 706 following DWARF block. Its DATA is allocated on 707 objfile_obstack - no CU load is needed to access it. */ 708 709 struct dwarf2_locexpr_baton *dwarf_block; 710}; 711 712struct field 713{ 714 struct type *type () const 715 { 716 return this->m_type; 717 } 718 719 void set_type (struct type *type) 720 { 721 this->m_type = type; 722 } 723 724 union field_location loc; 725 726 /* * For a function or member type, this is 1 if the argument is 727 marked artificial. Artificial arguments should not be shown 728 to the user. For TYPE_CODE_RANGE it is set if the specific 729 bound is not defined. */ 730 731 unsigned int artificial : 1; 732 733 /* * Discriminant for union field_location. */ 734 735 ENUM_BITFIELD(field_loc_kind) loc_kind : 3; 736 737 /* * Size of this field, in bits, or zero if not packed. 738 If non-zero in an array type, indicates the element size in 739 bits (used only in Ada at the moment). 740 For an unpacked field, the field's type's length 741 says how many bytes the field occupies. */ 742 743 unsigned int bitsize : 28; 744 745 /* * In a struct or union type, type of this field. 746 - In a function or member type, type of this argument. 747 - In an array type, the domain-type of the array. */ 748 749 struct type *m_type; 750 751 /* * Name of field, value or argument. 752 NULL for range bounds, array domains, and member function 753 arguments. */ 754 755 const char *name; 756}; 757 758struct range_bounds 759{ 760 ULONGEST bit_stride () const 761 { 762 if (this->flag_is_byte_stride) 763 return this->stride.const_val () * 8; 764 else 765 return this->stride.const_val (); 766 } 767 768 /* * Low bound of range. */ 769 770 struct dynamic_prop low; 771 772 /* * High bound of range. */ 773 774 struct dynamic_prop high; 775 776 /* The stride value for this range. This can be stored in bits or bytes 777 based on the value of BYTE_STRIDE_P. It is optional to have a stride 778 value, if this range has no stride value defined then this will be set 779 to the constant zero. */ 780 781 struct dynamic_prop stride; 782 783 /* * The bias. Sometimes a range value is biased before storage. 784 The bias is added to the stored bits to form the true value. */ 785 786 LONGEST bias; 787 788 /* True if HIGH range bound contains the number of elements in the 789 subrange. This affects how the final high bound is computed. */ 790 791 unsigned int flag_upper_bound_is_count : 1; 792 793 /* True if LOW or/and HIGH are resolved into a static bound from 794 a dynamic one. */ 795 796 unsigned int flag_bound_evaluated : 1; 797 798 /* If this is true this STRIDE is in bytes, otherwise STRIDE is in bits. */ 799 800 unsigned int flag_is_byte_stride : 1; 801}; 802 803/* Compare two range_bounds objects for equality. Simply does 804 memberwise comparison. */ 805extern bool operator== (const range_bounds &l, const range_bounds &r); 806 807/* Compare two range_bounds objects for inequality. */ 808static inline bool operator!= (const range_bounds &l, const range_bounds &r) 809{ 810 return !(l == r); 811} 812 813union type_specific 814{ 815 /* * CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to 816 point to cplus_struct_default, a default static instance of a 817 struct cplus_struct_type. */ 818 819 struct cplus_struct_type *cplus_stuff; 820 821 /* * GNAT_STUFF is for types for which the GNAT Ada compiler 822 provides additional information. */ 823 824 struct gnat_aux_type *gnat_stuff; 825 826 /* * FLOATFORMAT is for TYPE_CODE_FLT. It is a pointer to a 827 floatformat object that describes the floating-point value 828 that resides within the type. */ 829 830 const struct floatformat *floatformat; 831 832 /* * For TYPE_CODE_FUNC and TYPE_CODE_METHOD types. */ 833 834 struct func_type *func_stuff; 835 836 /* * For types that are pointer to member types (TYPE_CODE_METHODPTR, 837 TYPE_CODE_MEMBERPTR), SELF_TYPE is the type that this pointer 838 is a member of. */ 839 840 struct type *self_type; 841}; 842 843/* * Main structure representing a type in GDB. 844 845 This structure is space-critical. Its layout has been tweaked to 846 reduce the space used. */ 847 848struct main_type 849{ 850 /* * Code for kind of type. */ 851 852 ENUM_BITFIELD(type_code) code : 8; 853 854 /* * Flags about this type. These fields appear at this location 855 because they packs nicely here. See the TYPE_* macros for 856 documentation about these fields. */ 857 858 unsigned int flag_unsigned : 1; 859 unsigned int flag_nosign : 1; 860 unsigned int flag_stub : 1; 861 unsigned int flag_target_stub : 1; 862 unsigned int flag_prototyped : 1; 863 unsigned int flag_varargs : 1; 864 unsigned int flag_vector : 1; 865 unsigned int flag_stub_supported : 1; 866 unsigned int flag_gnu_ifunc : 1; 867 unsigned int flag_fixed_instance : 1; 868 unsigned int flag_objfile_owned : 1; 869 unsigned int flag_endianity_not_default : 1; 870 871 /* * True if this type was declared with "class" rather than 872 "struct". */ 873 874 unsigned int flag_declared_class : 1; 875 876 /* * True if this is an enum type with disjoint values. This 877 affects how the enum is printed. */ 878 879 unsigned int flag_flag_enum : 1; 880 881 /* * A discriminant telling us which field of the type_specific 882 union is being used for this type, if any. */ 883 884 ENUM_BITFIELD(type_specific_kind) type_specific_field : 3; 885 886 /* * Number of fields described for this type. This field appears 887 at this location because it packs nicely here. */ 888 889 short nfields; 890 891 /* * Name of this type, or NULL if none. 892 893 This is used for printing only. For looking up a name, look for 894 a symbol in the VAR_DOMAIN. This is generally allocated in the 895 objfile's obstack. However coffread.c uses malloc. */ 896 897 const char *name; 898 899 /* * Every type is now associated with a particular objfile, and the 900 type is allocated on the objfile_obstack for that objfile. One 901 problem however, is that there are times when gdb allocates new 902 types while it is not in the process of reading symbols from a 903 particular objfile. Fortunately, these happen when the type 904 being created is a derived type of an existing type, such as in 905 lookup_pointer_type(). So we can just allocate the new type 906 using the same objfile as the existing type, but to do this we 907 need a backpointer to the objfile from the existing type. Yes 908 this is somewhat ugly, but without major overhaul of the internal 909 type system, it can't be avoided for now. */ 910 911 union type_owner owner; 912 913 /* * For a pointer type, describes the type of object pointed to. 914 - For an array type, describes the type of the elements. 915 - For a function or method type, describes the type of the return value. 916 - For a range type, describes the type of the full range. 917 - For a complex type, describes the type of each coordinate. 918 - For a special record or union type encoding a dynamic-sized type 919 in GNAT, a memoized pointer to a corresponding static version of 920 the type. 921 - Unused otherwise. */ 922 923 struct type *target_type; 924 925 /* * For structure and union types, a description of each field. 926 For set and pascal array types, there is one "field", 927 whose type is the domain type of the set or array. 928 For range types, there are two "fields", 929 the minimum and maximum values (both inclusive). 930 For enum types, each possible value is described by one "field". 931 For a function or method type, a "field" for each parameter. 932 For C++ classes, there is one field for each base class (if it is 933 a derived class) plus one field for each class data member. Member 934 functions are recorded elsewhere. 935 936 Using a pointer to a separate array of fields 937 allows all types to have the same size, which is useful 938 because we can allocate the space for a type before 939 we know what to put in it. */ 940 941 union 942 { 943 struct field *fields; 944 945 /* * Union member used for range types. */ 946 947 struct range_bounds *bounds; 948 949 /* If this is a scalar type, then this is its corresponding 950 complex type. */ 951 struct type *complex_type; 952 953 } flds_bnds; 954 955 /* * Slot to point to additional language-specific fields of this 956 type. */ 957 958 union type_specific type_specific; 959 960 /* * Contains all dynamic type properties. */ 961 struct dynamic_prop_list *dyn_prop_list; 962}; 963 964/* * Number of bits allocated for alignment. */ 965 966#define TYPE_ALIGN_BITS 8 967 968/* * A ``struct type'' describes a particular instance of a type, with 969 some particular qualification. */ 970 971struct type 972{ 973 /* Get the type code of this type. 974 975 Note that the code can be TYPE_CODE_TYPEDEF, so if you want the real 976 type, you need to do `check_typedef (type)->code ()`. */ 977 type_code code () const 978 { 979 return this->main_type->code; 980 } 981 982 /* Set the type code of this type. */ 983 void set_code (type_code code) 984 { 985 this->main_type->code = code; 986 } 987 988 /* Get the name of this type. */ 989 const char *name () const 990 { 991 return this->main_type->name; 992 } 993 994 /* Set the name of this type. */ 995 void set_name (const char *name) 996 { 997 this->main_type->name = name; 998 } 999 1000 /* Get the number of fields of this type. */ 1001 int num_fields () const 1002 { 1003 return this->main_type->nfields; 1004 } 1005 1006 /* Set the number of fields of this type. */ 1007 void set_num_fields (int num_fields) 1008 { 1009 this->main_type->nfields = num_fields; 1010 } 1011 1012 /* Get the fields array of this type. */ 1013 struct field *fields () const 1014 { 1015 return this->main_type->flds_bnds.fields; 1016 } 1017 1018 /* Get the field at index IDX. */ 1019 struct field &field (int idx) const 1020 { 1021 return this->fields ()[idx]; 1022 } 1023 1024 /* Set the fields array of this type. */ 1025 void set_fields (struct field *fields) 1026 { 1027 this->main_type->flds_bnds.fields = fields; 1028 } 1029 1030 type *index_type () const 1031 { 1032 return this->field (0).type (); 1033 } 1034 1035 void set_index_type (type *index_type) 1036 { 1037 this->field (0).set_type (index_type); 1038 } 1039 1040 /* Get the bounds bounds of this type. The type must be a range type. */ 1041 range_bounds *bounds () const 1042 { 1043 switch (this->code ()) 1044 { 1045 case TYPE_CODE_RANGE: 1046 return this->main_type->flds_bnds.bounds; 1047 1048 case TYPE_CODE_ARRAY: 1049 case TYPE_CODE_STRING: 1050 return this->index_type ()->bounds (); 1051 1052 default: 1053 gdb_assert_not_reached 1054 ("type::bounds called on type with invalid code"); 1055 } 1056 } 1057 1058 /* Set the bounds of this type. The type must be a range type. */ 1059 void set_bounds (range_bounds *bounds) 1060 { 1061 gdb_assert (this->code () == TYPE_CODE_RANGE); 1062 1063 this->main_type->flds_bnds.bounds = bounds; 1064 } 1065 1066 ULONGEST bit_stride () const 1067 { 1068 return this->bounds ()->bit_stride (); 1069 } 1070 1071 /* * Return the dynamic property of the requested KIND from this type's 1072 list of dynamic properties. */ 1073 dynamic_prop *dyn_prop (dynamic_prop_node_kind kind) const; 1074 1075 /* * Given a dynamic property PROP of a given KIND, add this dynamic 1076 property to this type. 1077 1078 This function assumes that this type is objfile-owned. */ 1079 void add_dyn_prop (dynamic_prop_node_kind kind, dynamic_prop prop); 1080 1081 /* * Remove dynamic property of kind KIND from this type, if it exists. */ 1082 void remove_dyn_prop (dynamic_prop_node_kind kind); 1083 1084 /* * Type that is a pointer to this type. 1085 NULL if no such pointer-to type is known yet. 1086 The debugger may add the address of such a type 1087 if it has to construct one later. */ 1088 1089 struct type *pointer_type; 1090 1091 /* * C++: also need a reference type. */ 1092 1093 struct type *reference_type; 1094 1095 /* * A C++ rvalue reference type added in C++11. */ 1096 1097 struct type *rvalue_reference_type; 1098 1099 /* * Variant chain. This points to a type that differs from this 1100 one only in qualifiers and length. Currently, the possible 1101 qualifiers are const, volatile, code-space, data-space, and 1102 address class. The length may differ only when one of the 1103 address class flags are set. The variants are linked in a 1104 circular ring and share MAIN_TYPE. */ 1105 1106 struct type *chain; 1107 1108 /* * The alignment for this type. Zero means that the alignment was 1109 not specified in the debug info. Note that this is stored in a 1110 funny way: as the log base 2 (plus 1) of the alignment; so a 1111 value of 1 means the alignment is 1, and a value of 9 means the 1112 alignment is 256. */ 1113 1114 unsigned align_log2 : TYPE_ALIGN_BITS; 1115 1116 /* * Flags specific to this instance of the type, indicating where 1117 on the ring we are. 1118 1119 For TYPE_CODE_TYPEDEF the flags of the typedef type should be 1120 binary or-ed with the target type, with a special case for 1121 address class and space class. For example if this typedef does 1122 not specify any new qualifiers, TYPE_INSTANCE_FLAGS is 0 and the 1123 instance flags are completely inherited from the target type. No 1124 qualifiers can be cleared by the typedef. See also 1125 check_typedef. */ 1126 unsigned instance_flags : 9; 1127 1128 /* * Length of storage for a value of this type. The value is the 1129 expression in host bytes of what sizeof(type) would return. This 1130 size includes padding. For example, an i386 extended-precision 1131 floating point value really only occupies ten bytes, but most 1132 ABI's declare its size to be 12 bytes, to preserve alignment. 1133 A `struct type' representing such a floating-point type would 1134 have a `length' value of 12, even though the last two bytes are 1135 unused. 1136 1137 Since this field is expressed in host bytes, its value is appropriate 1138 to pass to memcpy and such (it is assumed that GDB itself always runs 1139 on an 8-bits addressable architecture). However, when using it for 1140 target address arithmetic (e.g. adding it to a target address), the 1141 type_length_units function should be used in order to get the length 1142 expressed in target addressable memory units. */ 1143 1144 ULONGEST length; 1145 1146 /* * Core type, shared by a group of qualified types. */ 1147 1148 struct main_type *main_type; 1149}; 1150 1151struct fn_fieldlist 1152{ 1153 1154 /* * The overloaded name. 1155 This is generally allocated in the objfile's obstack. 1156 However stabsread.c sometimes uses malloc. */ 1157 1158 const char *name; 1159 1160 /* * The number of methods with this name. */ 1161 1162 int length; 1163 1164 /* * The list of methods. */ 1165 1166 struct fn_field *fn_fields; 1167}; 1168 1169 1170 1171struct fn_field 1172{ 1173 /* * If is_stub is clear, this is the mangled name which we can look 1174 up to find the address of the method (FIXME: it would be cleaner 1175 to have a pointer to the struct symbol here instead). 1176 1177 If is_stub is set, this is the portion of the mangled name which 1178 specifies the arguments. For example, "ii", if there are two int 1179 arguments, or "" if there are no arguments. See gdb_mangle_name 1180 for the conversion from this format to the one used if is_stub is 1181 clear. */ 1182 1183 const char *physname; 1184 1185 /* * The function type for the method. 1186 1187 (This comment used to say "The return value of the method", but 1188 that's wrong. The function type is expected here, i.e. something 1189 with TYPE_CODE_METHOD, and *not* the return-value type). */ 1190 1191 struct type *type; 1192 1193 /* * For virtual functions. First baseclass that defines this 1194 virtual function. */ 1195 1196 struct type *fcontext; 1197 1198 /* Attributes. */ 1199 1200 unsigned int is_const:1; 1201 unsigned int is_volatile:1; 1202 unsigned int is_private:1; 1203 unsigned int is_protected:1; 1204 unsigned int is_artificial:1; 1205 1206 /* * A stub method only has some fields valid (but they are enough 1207 to reconstruct the rest of the fields). */ 1208 1209 unsigned int is_stub:1; 1210 1211 /* * True if this function is a constructor, false otherwise. */ 1212 1213 unsigned int is_constructor : 1; 1214 1215 /* * True if this function is deleted, false otherwise. */ 1216 1217 unsigned int is_deleted : 1; 1218 1219 /* * DW_AT_defaulted attribute for this function. The value is one 1220 of the DW_DEFAULTED constants. */ 1221 1222 ENUM_BITFIELD (dwarf_defaulted_attribute) defaulted : 2; 1223 1224 /* * Unused. */ 1225 1226 unsigned int dummy:6; 1227 1228 /* * Index into that baseclass's virtual function table, minus 2; 1229 else if static: VOFFSET_STATIC; else: 0. */ 1230 1231 unsigned int voffset:16; 1232 1233#define VOFFSET_STATIC 1 1234 1235}; 1236 1237struct decl_field 1238{ 1239 /* * Unqualified name to be prefixed by owning class qualified 1240 name. */ 1241 1242 const char *name; 1243 1244 /* * Type this typedef named NAME represents. */ 1245 1246 struct type *type; 1247 1248 /* * True if this field was declared protected, false otherwise. */ 1249 unsigned int is_protected : 1; 1250 1251 /* * True if this field was declared private, false otherwise. */ 1252 unsigned int is_private : 1; 1253}; 1254 1255/* * C++ language-specific information for TYPE_CODE_STRUCT and 1256 TYPE_CODE_UNION nodes. */ 1257 1258struct cplus_struct_type 1259 { 1260 /* * Number of base classes this type derives from. The 1261 baseclasses are stored in the first N_BASECLASSES fields 1262 (i.e. the `fields' field of the struct type). The only fields 1263 of struct field that are used are: type, name, loc.bitpos. */ 1264 1265 short n_baseclasses; 1266 1267 /* * Field number of the virtual function table pointer in VPTR_BASETYPE. 1268 All access to this field must be through TYPE_VPTR_FIELDNO as one 1269 thing it does is check whether the field has been initialized. 1270 Initially TYPE_RAW_CPLUS_SPECIFIC has the value of cplus_struct_default, 1271 which for portability reasons doesn't initialize this field. 1272 TYPE_VPTR_FIELDNO returns -1 for this case. 1273 1274 If -1, we were unable to find the virtual function table pointer in 1275 initial symbol reading, and get_vptr_fieldno should be called to find 1276 it if possible. get_vptr_fieldno will update this field if possible. 1277 Otherwise the value is left at -1. 1278 1279 Unused if this type does not have virtual functions. */ 1280 1281 short vptr_fieldno; 1282 1283 /* * Number of methods with unique names. All overloaded methods 1284 with the same name count only once. */ 1285 1286 short nfn_fields; 1287 1288 /* * Number of template arguments. */ 1289 1290 unsigned short n_template_arguments; 1291 1292 /* * One if this struct is a dynamic class, as defined by the 1293 Itanium C++ ABI: if it requires a virtual table pointer, 1294 because it or any of its base classes have one or more virtual 1295 member functions or virtual base classes. Minus one if not 1296 dynamic. Zero if not yet computed. */ 1297 1298 int is_dynamic : 2; 1299 1300 /* * The calling convention for this type, fetched from the 1301 DW_AT_calling_convention attribute. The value is one of the 1302 DW_CC constants. */ 1303 1304 ENUM_BITFIELD (dwarf_calling_convention) calling_convention : 8; 1305 1306 /* * The base class which defined the virtual function table pointer. */ 1307 1308 struct type *vptr_basetype; 1309 1310 /* * For derived classes, the number of base classes is given by 1311 n_baseclasses and virtual_field_bits is a bit vector containing 1312 one bit per base class. If the base class is virtual, the 1313 corresponding bit will be set. 1314 I.E, given: 1315 1316 class A{}; 1317 class B{}; 1318 class C : public B, public virtual A {}; 1319 1320 B is a baseclass of C; A is a virtual baseclass for C. 1321 This is a C++ 2.0 language feature. */ 1322 1323 B_TYPE *virtual_field_bits; 1324 1325 /* * For classes with private fields, the number of fields is 1326 given by nfields and private_field_bits is a bit vector 1327 containing one bit per field. 1328 1329 If the field is private, the corresponding bit will be set. */ 1330 1331 B_TYPE *private_field_bits; 1332 1333 /* * For classes with protected fields, the number of fields is 1334 given by nfields and protected_field_bits is a bit vector 1335 containing one bit per field. 1336 1337 If the field is private, the corresponding bit will be set. */ 1338 1339 B_TYPE *protected_field_bits; 1340 1341 /* * For classes with fields to be ignored, either this is 1342 optimized out or this field has length 0. */ 1343 1344 B_TYPE *ignore_field_bits; 1345 1346 /* * For classes, structures, and unions, a description of each 1347 field, which consists of an overloaded name, followed by the 1348 types of arguments that the method expects, and then the name 1349 after it has been renamed to make it distinct. 1350 1351 fn_fieldlists points to an array of nfn_fields of these. */ 1352 1353 struct fn_fieldlist *fn_fieldlists; 1354 1355 /* * typedefs defined inside this class. typedef_field points to 1356 an array of typedef_field_count elements. */ 1357 1358 struct decl_field *typedef_field; 1359 1360 unsigned typedef_field_count; 1361 1362 /* * The nested types defined by this type. nested_types points to 1363 an array of nested_types_count elements. */ 1364 1365 struct decl_field *nested_types; 1366 1367 unsigned nested_types_count; 1368 1369 /* * The template arguments. This is an array with 1370 N_TEMPLATE_ARGUMENTS elements. This is NULL for non-template 1371 classes. */ 1372 1373 struct symbol **template_arguments; 1374 }; 1375 1376/* * Struct used to store conversion rankings. */ 1377 1378struct rank 1379 { 1380 short rank; 1381 1382 /* * When two conversions are of the same type and therefore have 1383 the same rank, subrank is used to differentiate the two. 1384 1385 Eg: Two derived-class-pointer to base-class-pointer conversions 1386 would both have base pointer conversion rank, but the 1387 conversion with the shorter distance to the ancestor is 1388 preferable. 'subrank' would be used to reflect that. */ 1389 1390 short subrank; 1391 }; 1392 1393/* * Used for ranking a function for overload resolution. */ 1394 1395typedef std::vector<rank> badness_vector; 1396 1397/* * GNAT Ada-specific information for various Ada types. */ 1398 1399struct gnat_aux_type 1400 { 1401 /* * Parallel type used to encode information about dynamic types 1402 used in Ada (such as variant records, variable-size array, 1403 etc). */ 1404 struct type* descriptive_type; 1405 }; 1406 1407/* * For TYPE_CODE_FUNC and TYPE_CODE_METHOD types. */ 1408 1409struct func_type 1410 { 1411 /* * The calling convention for targets supporting multiple ABIs. 1412 Right now this is only fetched from the Dwarf-2 1413 DW_AT_calling_convention attribute. The value is one of the 1414 DW_CC constants. */ 1415 1416 ENUM_BITFIELD (dwarf_calling_convention) calling_convention : 8; 1417 1418 /* * Whether this function normally returns to its caller. It is 1419 set from the DW_AT_noreturn attribute if set on the 1420 DW_TAG_subprogram. */ 1421 1422 unsigned int is_noreturn : 1; 1423 1424 /* * Only those DW_TAG_call_site's in this function that have 1425 DW_AT_call_tail_call set are linked in this list. Function 1426 without its tail call list complete 1427 (DW_AT_call_all_tail_calls or its superset 1428 DW_AT_call_all_calls) has TAIL_CALL_LIST NULL, even if some 1429 DW_TAG_call_site's exist in such function. */ 1430 1431 struct call_site *tail_call_list; 1432 1433 /* * For method types (TYPE_CODE_METHOD), the aggregate type that 1434 contains the method. */ 1435 1436 struct type *self_type; 1437 }; 1438 1439/* struct call_site_parameter can be referenced in callees by several ways. */ 1440 1441enum call_site_parameter_kind 1442{ 1443 /* * Use field call_site_parameter.u.dwarf_reg. */ 1444 CALL_SITE_PARAMETER_DWARF_REG, 1445 1446 /* * Use field call_site_parameter.u.fb_offset. */ 1447 CALL_SITE_PARAMETER_FB_OFFSET, 1448 1449 /* * Use field call_site_parameter.u.param_offset. */ 1450 CALL_SITE_PARAMETER_PARAM_OFFSET 1451}; 1452 1453struct call_site_target 1454{ 1455 union field_location loc; 1456 1457 /* * Discriminant for union field_location. */ 1458 1459 ENUM_BITFIELD(field_loc_kind) loc_kind : 3; 1460}; 1461 1462union call_site_parameter_u 1463{ 1464 /* * DW_TAG_formal_parameter's DW_AT_location's DW_OP_regX 1465 as DWARF register number, for register passed 1466 parameters. */ 1467 1468 int dwarf_reg; 1469 1470 /* * Offset from the callee's frame base, for stack passed 1471 parameters. This equals offset from the caller's stack 1472 pointer. */ 1473 1474 CORE_ADDR fb_offset; 1475 1476 /* * Offset relative to the start of this PER_CU to 1477 DW_TAG_formal_parameter which is referenced by both 1478 caller and the callee. */ 1479 1480 cu_offset param_cu_off; 1481}; 1482 1483struct call_site_parameter 1484{ 1485 ENUM_BITFIELD (call_site_parameter_kind) kind : 2; 1486 1487 union call_site_parameter_u u; 1488 1489 /* * DW_TAG_formal_parameter's DW_AT_call_value. It is never NULL. */ 1490 1491 const gdb_byte *value; 1492 size_t value_size; 1493 1494 /* * DW_TAG_formal_parameter's DW_AT_call_data_value. 1495 It may be NULL if not provided by DWARF. */ 1496 1497 const gdb_byte *data_value; 1498 size_t data_value_size; 1499}; 1500 1501/* * A place where a function gets called from, represented by 1502 DW_TAG_call_site. It can be looked up from symtab->call_site_htab. */ 1503 1504struct call_site 1505 { 1506 /* * Address of the first instruction after this call. It must be 1507 the first field as we overload core_addr_hash and core_addr_eq 1508 for it. */ 1509 1510 CORE_ADDR pc; 1511 1512 /* * List successor with head in FUNC_TYPE.TAIL_CALL_LIST. */ 1513 1514 struct call_site *tail_call_next; 1515 1516 /* * Describe DW_AT_call_target. Missing attribute uses 1517 FIELD_LOC_KIND_DWARF_BLOCK with FIELD_DWARF_BLOCK == NULL. */ 1518 1519 struct call_site_target target; 1520 1521 /* * Size of the PARAMETER array. */ 1522 1523 unsigned parameter_count; 1524 1525 /* * CU of the function where the call is located. It gets used 1526 for DWARF blocks execution in the parameter array below. */ 1527 1528 dwarf2_per_cu_data *per_cu; 1529 1530 /* objfile of the function where the call is located. */ 1531 1532 dwarf2_per_objfile *per_objfile; 1533 1534 /* * Describe DW_TAG_call_site's DW_TAG_formal_parameter. */ 1535 1536 struct call_site_parameter parameter[1]; 1537 }; 1538 1539/* * The default value of TYPE_CPLUS_SPECIFIC(T) points to this shared 1540 static structure. */ 1541 1542extern const struct cplus_struct_type cplus_struct_default; 1543 1544extern void allocate_cplus_struct_type (struct type *); 1545 1546#define INIT_CPLUS_SPECIFIC(type) \ 1547 (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF, \ 1548 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type*) \ 1549 &cplus_struct_default) 1550 1551#define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type) 1552 1553#define HAVE_CPLUS_STRUCT(type) \ 1554 (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF \ 1555 && TYPE_RAW_CPLUS_SPECIFIC (type) != &cplus_struct_default) 1556 1557#define INIT_NONE_SPECIFIC(type) \ 1558 (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_NONE, \ 1559 TYPE_MAIN_TYPE (type)->type_specific = {}) 1560 1561extern const struct gnat_aux_type gnat_aux_default; 1562 1563extern void allocate_gnat_aux_type (struct type *); 1564 1565#define INIT_GNAT_SPECIFIC(type) \ 1566 (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF, \ 1567 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *) &gnat_aux_default) 1568#define ALLOCATE_GNAT_AUX_TYPE(type) allocate_gnat_aux_type (type) 1569/* * A macro that returns non-zero if the type-specific data should be 1570 read as "gnat-stuff". */ 1571#define HAVE_GNAT_AUX_INFO(type) \ 1572 (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_GNAT_STUFF) 1573 1574/* * True if TYPE is known to be an Ada type of some kind. */ 1575#define ADA_TYPE_P(type) \ 1576 (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_GNAT_STUFF \ 1577 || (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE \ 1578 && TYPE_FIXED_INSTANCE (type))) 1579 1580#define INIT_FUNC_SPECIFIC(type) \ 1581 (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FUNC, \ 1582 TYPE_MAIN_TYPE (type)->type_specific.func_stuff = (struct func_type *) \ 1583 TYPE_ZALLOC (type, \ 1584 sizeof (*TYPE_MAIN_TYPE (type)->type_specific.func_stuff))) 1585 1586#define TYPE_INSTANCE_FLAGS(thistype) (thistype)->instance_flags 1587#define TYPE_MAIN_TYPE(thistype) (thistype)->main_type 1588#define TYPE_TARGET_TYPE(thistype) TYPE_MAIN_TYPE(thistype)->target_type 1589#define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type 1590#define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type 1591#define TYPE_RVALUE_REFERENCE_TYPE(thistype) (thistype)->rvalue_reference_type 1592#define TYPE_CHAIN(thistype) (thistype)->chain 1593/* * Note that if thistype is a TYPEDEF type, you have to call check_typedef. 1594 But check_typedef does set the TYPE_LENGTH of the TYPEDEF type, 1595 so you only have to call check_typedef once. Since allocate_value 1596 calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */ 1597#define TYPE_LENGTH(thistype) (thistype)->length 1598 1599/* * Return the alignment of the type in target addressable memory 1600 units, or 0 if no alignment was specified. */ 1601#define TYPE_RAW_ALIGN(thistype) type_raw_align (thistype) 1602 1603/* * Return the alignment of the type in target addressable memory 1604 units, or 0 if no alignment was specified. */ 1605extern unsigned type_raw_align (struct type *); 1606 1607/* * Return the alignment of the type in target addressable memory 1608 units. Return 0 if the alignment cannot be determined; but note 1609 that this makes an effort to compute the alignment even it it was 1610 not specified in the debug info. */ 1611extern unsigned type_align (struct type *); 1612 1613/* * Set the alignment of the type. The alignment must be a power of 1614 2. Returns false if the given value does not fit in the available 1615 space in struct type. */ 1616extern bool set_type_align (struct type *, ULONGEST); 1617 1618/* Property accessors for the type data location. */ 1619#define TYPE_DATA_LOCATION(thistype) \ 1620 ((thistype)->dyn_prop (DYN_PROP_DATA_LOCATION)) 1621#define TYPE_DATA_LOCATION_BATON(thistype) \ 1622 TYPE_DATA_LOCATION (thistype)->data.baton 1623#define TYPE_DATA_LOCATION_ADDR(thistype) \ 1624 (TYPE_DATA_LOCATION (thistype)->const_val ()) 1625#define TYPE_DATA_LOCATION_KIND(thistype) \ 1626 (TYPE_DATA_LOCATION (thistype)->kind ()) 1627#define TYPE_DYNAMIC_LENGTH(thistype) \ 1628 ((thistype)->dyn_prop (DYN_PROP_BYTE_SIZE)) 1629 1630/* Property accessors for the type allocated/associated. */ 1631#define TYPE_ALLOCATED_PROP(thistype) \ 1632 ((thistype)->dyn_prop (DYN_PROP_ALLOCATED)) 1633#define TYPE_ASSOCIATED_PROP(thistype) \ 1634 ((thistype)->dyn_prop (DYN_PROP_ASSOCIATED)) 1635 1636/* C++ */ 1637 1638#define TYPE_SELF_TYPE(thistype) internal_type_self_type (thistype) 1639/* Do not call this, use TYPE_SELF_TYPE. */ 1640extern struct type *internal_type_self_type (struct type *); 1641extern void set_type_self_type (struct type *, struct type *); 1642 1643extern int internal_type_vptr_fieldno (struct type *); 1644extern void set_type_vptr_fieldno (struct type *, int); 1645extern struct type *internal_type_vptr_basetype (struct type *); 1646extern void set_type_vptr_basetype (struct type *, struct type *); 1647#define TYPE_VPTR_FIELDNO(thistype) internal_type_vptr_fieldno (thistype) 1648#define TYPE_VPTR_BASETYPE(thistype) internal_type_vptr_basetype (thistype) 1649 1650#define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields 1651#define TYPE_SPECIFIC_FIELD(thistype) \ 1652 TYPE_MAIN_TYPE(thistype)->type_specific_field 1653/* We need this tap-dance with the TYPE_RAW_SPECIFIC because of the case 1654 where we're trying to print an Ada array using the C language. 1655 In that case, there is no "cplus_stuff", but the C language assumes 1656 that there is. What we do, in that case, is pretend that there is 1657 an implicit one which is the default cplus stuff. */ 1658#define TYPE_CPLUS_SPECIFIC(thistype) \ 1659 (!HAVE_CPLUS_STRUCT(thistype) \ 1660 ? (struct cplus_struct_type*)&cplus_struct_default \ 1661 : TYPE_RAW_CPLUS_SPECIFIC(thistype)) 1662#define TYPE_RAW_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff 1663#define TYPE_CPLUS_CALLING_CONVENTION(thistype) \ 1664 TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff->calling_convention 1665#define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat 1666#define TYPE_GNAT_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.gnat_stuff 1667#define TYPE_DESCRIPTIVE_TYPE(thistype) TYPE_GNAT_SPECIFIC(thistype)->descriptive_type 1668#define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->calling_convention 1669#define TYPE_NO_RETURN(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->is_noreturn 1670#define TYPE_TAIL_CALL_LIST(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->tail_call_list 1671#define TYPE_BASECLASS(thistype,index) ((thistype)->field (index).type ()) 1672#define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses 1673#define TYPE_BASECLASS_NAME(thistype,index) TYPE_FIELD_NAME(thistype, index) 1674#define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index) 1675#define BASETYPE_VIA_PUBLIC(thistype, index) \ 1676 ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index))) 1677#define TYPE_CPLUS_DYNAMIC(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_dynamic 1678 1679#define BASETYPE_VIA_VIRTUAL(thistype, index) \ 1680 (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \ 1681 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index))) 1682 1683#define FIELD_NAME(thisfld) ((thisfld).name) 1684#define FIELD_LOC_KIND(thisfld) ((thisfld).loc_kind) 1685#define FIELD_BITPOS_LVAL(thisfld) ((thisfld).loc.bitpos) 1686#define FIELD_BITPOS(thisfld) (FIELD_BITPOS_LVAL (thisfld) + 0) 1687#define FIELD_ENUMVAL_LVAL(thisfld) ((thisfld).loc.enumval) 1688#define FIELD_ENUMVAL(thisfld) (FIELD_ENUMVAL_LVAL (thisfld) + 0) 1689#define FIELD_STATIC_PHYSNAME(thisfld) ((thisfld).loc.physname) 1690#define FIELD_STATIC_PHYSADDR(thisfld) ((thisfld).loc.physaddr) 1691#define FIELD_DWARF_BLOCK(thisfld) ((thisfld).loc.dwarf_block) 1692#define SET_FIELD_BITPOS(thisfld, bitpos) \ 1693 (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_BITPOS, \ 1694 FIELD_BITPOS_LVAL (thisfld) = (bitpos)) 1695#define SET_FIELD_ENUMVAL(thisfld, enumval) \ 1696 (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_ENUMVAL, \ 1697 FIELD_ENUMVAL_LVAL (thisfld) = (enumval)) 1698#define SET_FIELD_PHYSNAME(thisfld, name) \ 1699 (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSNAME, \ 1700 FIELD_STATIC_PHYSNAME (thisfld) = (name)) 1701#define SET_FIELD_PHYSADDR(thisfld, addr) \ 1702 (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_PHYSADDR, \ 1703 FIELD_STATIC_PHYSADDR (thisfld) = (addr)) 1704#define SET_FIELD_DWARF_BLOCK(thisfld, addr) \ 1705 (FIELD_LOC_KIND (thisfld) = FIELD_LOC_KIND_DWARF_BLOCK, \ 1706 FIELD_DWARF_BLOCK (thisfld) = (addr)) 1707#define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial) 1708#define FIELD_BITSIZE(thisfld) ((thisfld).bitsize) 1709 1710#define TYPE_FIELD_NAME(thistype, n) FIELD_NAME((thistype)->field (n)) 1711#define TYPE_FIELD_LOC_KIND(thistype, n) FIELD_LOC_KIND ((thistype)->field (n)) 1712#define TYPE_FIELD_BITPOS(thistype, n) FIELD_BITPOS ((thistype)->field (n)) 1713#define TYPE_FIELD_ENUMVAL(thistype, n) FIELD_ENUMVAL ((thistype)->field (n)) 1714#define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) FIELD_STATIC_PHYSNAME ((thistype)->field (n)) 1715#define TYPE_FIELD_STATIC_PHYSADDR(thistype, n) FIELD_STATIC_PHYSADDR ((thistype)->field (n)) 1716#define TYPE_FIELD_DWARF_BLOCK(thistype, n) FIELD_DWARF_BLOCK ((thistype)->field (n)) 1717#define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL((thistype)->field (n)) 1718#define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE((thistype)->field (n)) 1719#define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE((thistype)->field (n))!=0) 1720 1721#define TYPE_FIELD_PRIVATE_BITS(thistype) \ 1722 TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits 1723#define TYPE_FIELD_PROTECTED_BITS(thistype) \ 1724 TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits 1725#define TYPE_FIELD_IGNORE_BITS(thistype) \ 1726 TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits 1727#define TYPE_FIELD_VIRTUAL_BITS(thistype) \ 1728 TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits 1729#define SET_TYPE_FIELD_PRIVATE(thistype, n) \ 1730 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)) 1731#define SET_TYPE_FIELD_PROTECTED(thistype, n) \ 1732 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)) 1733#define SET_TYPE_FIELD_IGNORE(thistype, n) \ 1734 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)) 1735#define SET_TYPE_FIELD_VIRTUAL(thistype, n) \ 1736 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)) 1737#define TYPE_FIELD_PRIVATE(thistype, n) \ 1738 (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \ 1739 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))) 1740#define TYPE_FIELD_PROTECTED(thistype, n) \ 1741 (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \ 1742 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))) 1743#define TYPE_FIELD_IGNORE(thistype, n) \ 1744 (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \ 1745 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))) 1746#define TYPE_FIELD_VIRTUAL(thistype, n) \ 1747 (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \ 1748 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))) 1749 1750#define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists 1751#define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n] 1752#define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields 1753#define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name 1754#define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length 1755 1756#define TYPE_N_TEMPLATE_ARGUMENTS(thistype) \ 1757 TYPE_CPLUS_SPECIFIC (thistype)->n_template_arguments 1758#define TYPE_TEMPLATE_ARGUMENTS(thistype) \ 1759 TYPE_CPLUS_SPECIFIC (thistype)->template_arguments 1760#define TYPE_TEMPLATE_ARGUMENT(thistype, n) \ 1761 TYPE_CPLUS_SPECIFIC (thistype)->template_arguments[n] 1762 1763#define TYPE_FN_FIELD(thisfn, n) (thisfn)[n] 1764#define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname 1765#define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type 1766#define TYPE_FN_FIELD_ARGS(thisfn, n) (((thisfn)[n].type)->fields ()) 1767#define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const) 1768#define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile) 1769#define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private) 1770#define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected) 1771#define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n) ((thisfn)[n].is_artificial) 1772#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub) 1773#define TYPE_FN_FIELD_CONSTRUCTOR(thisfn, n) ((thisfn)[n].is_constructor) 1774#define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext) 1775#define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2) 1776#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1) 1777#define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC) 1778#define TYPE_FN_FIELD_DEFAULTED(thisfn, n) ((thisfn)[n].defaulted) 1779#define TYPE_FN_FIELD_DELETED(thisfn, n) ((thisfn)[n].is_deleted) 1780 1781/* Accessors for typedefs defined by a class. */ 1782#define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \ 1783 TYPE_CPLUS_SPECIFIC (thistype)->typedef_field 1784#define TYPE_TYPEDEF_FIELD(thistype, n) \ 1785 TYPE_CPLUS_SPECIFIC (thistype)->typedef_field[n] 1786#define TYPE_TYPEDEF_FIELD_NAME(thistype, n) \ 1787 TYPE_TYPEDEF_FIELD (thistype, n).name 1788#define TYPE_TYPEDEF_FIELD_TYPE(thistype, n) \ 1789 TYPE_TYPEDEF_FIELD (thistype, n).type 1790#define TYPE_TYPEDEF_FIELD_COUNT(thistype) \ 1791 TYPE_CPLUS_SPECIFIC (thistype)->typedef_field_count 1792#define TYPE_TYPEDEF_FIELD_PROTECTED(thistype, n) \ 1793 TYPE_TYPEDEF_FIELD (thistype, n).is_protected 1794#define TYPE_TYPEDEF_FIELD_PRIVATE(thistype, n) \ 1795 TYPE_TYPEDEF_FIELD (thistype, n).is_private 1796 1797#define TYPE_NESTED_TYPES_ARRAY(thistype) \ 1798 TYPE_CPLUS_SPECIFIC (thistype)->nested_types 1799#define TYPE_NESTED_TYPES_FIELD(thistype, n) \ 1800 TYPE_CPLUS_SPECIFIC (thistype)->nested_types[n] 1801#define TYPE_NESTED_TYPES_FIELD_NAME(thistype, n) \ 1802 TYPE_NESTED_TYPES_FIELD (thistype, n).name 1803#define TYPE_NESTED_TYPES_FIELD_TYPE(thistype, n) \ 1804 TYPE_NESTED_TYPES_FIELD (thistype, n).type 1805#define TYPE_NESTED_TYPES_COUNT(thistype) \ 1806 TYPE_CPLUS_SPECIFIC (thistype)->nested_types_count 1807#define TYPE_NESTED_TYPES_FIELD_PROTECTED(thistype, n) \ 1808 TYPE_NESTED_TYPES_FIELD (thistype, n).is_protected 1809#define TYPE_NESTED_TYPES_FIELD_PRIVATE(thistype, n) \ 1810 TYPE_NESTED_TYPES_FIELD (thistype, n).is_private 1811 1812#define TYPE_IS_OPAQUE(thistype) \ 1813 ((((thistype)->code () == TYPE_CODE_STRUCT) \ 1814 || ((thistype)->code () == TYPE_CODE_UNION)) \ 1815 && ((thistype)->num_fields () == 0) \ 1816 && (!HAVE_CPLUS_STRUCT (thistype) \ 1817 || TYPE_NFN_FIELDS (thistype) == 0) \ 1818 && (TYPE_STUB (thistype) || !TYPE_STUB_SUPPORTED (thistype))) 1819 1820/* * A helper macro that returns the name of a type or "unnamed type" 1821 if the type has no name. */ 1822 1823#define TYPE_SAFE_NAME(type) \ 1824 (type->name () != nullptr ? type->name () : _("<unnamed type>")) 1825 1826/* * A helper macro that returns the name of an error type. If the 1827 type has a name, it is used; otherwise, a default is used. */ 1828 1829#define TYPE_ERROR_NAME(type) \ 1830 (type->name () ? type->name () : _("<error type>")) 1831 1832/* Given TYPE, return its floatformat. */ 1833const struct floatformat *floatformat_from_type (const struct type *type); 1834 1835struct builtin_type 1836{ 1837 /* Integral types. */ 1838 1839 /* Implicit size/sign (based on the architecture's ABI). */ 1840 struct type *builtin_void; 1841 struct type *builtin_char; 1842 struct type *builtin_short; 1843 struct type *builtin_int; 1844 struct type *builtin_long; 1845 struct type *builtin_signed_char; 1846 struct type *builtin_unsigned_char; 1847 struct type *builtin_unsigned_short; 1848 struct type *builtin_unsigned_int; 1849 struct type *builtin_unsigned_long; 1850 struct type *builtin_bfloat16; 1851 struct type *builtin_half; 1852 struct type *builtin_float; 1853 struct type *builtin_double; 1854 struct type *builtin_long_double; 1855 struct type *builtin_complex; 1856 struct type *builtin_double_complex; 1857 struct type *builtin_string; 1858 struct type *builtin_bool; 1859 struct type *builtin_long_long; 1860 struct type *builtin_unsigned_long_long; 1861 struct type *builtin_decfloat; 1862 struct type *builtin_decdouble; 1863 struct type *builtin_declong; 1864 1865 /* "True" character types. 1866 We use these for the '/c' print format, because c_char is just a 1867 one-byte integral type, which languages less laid back than C 1868 will print as ... well, a one-byte integral type. */ 1869 struct type *builtin_true_char; 1870 struct type *builtin_true_unsigned_char; 1871 1872 /* Explicit sizes - see C9X <intypes.h> for naming scheme. The "int0" 1873 is for when an architecture needs to describe a register that has 1874 no size. */ 1875 struct type *builtin_int0; 1876 struct type *builtin_int8; 1877 struct type *builtin_uint8; 1878 struct type *builtin_int16; 1879 struct type *builtin_uint16; 1880 struct type *builtin_int24; 1881 struct type *builtin_uint24; 1882 struct type *builtin_int32; 1883 struct type *builtin_uint32; 1884 struct type *builtin_int64; 1885 struct type *builtin_uint64; 1886 struct type *builtin_int128; 1887 struct type *builtin_uint128; 1888 1889 /* Wide character types. */ 1890 struct type *builtin_char16; 1891 struct type *builtin_char32; 1892 struct type *builtin_wchar; 1893 1894 /* Pointer types. */ 1895 1896 /* * `pointer to data' type. Some target platforms use an implicitly 1897 {sign,zero} -extended 32-bit ABI pointer on a 64-bit ISA. */ 1898 struct type *builtin_data_ptr; 1899 1900 /* * `pointer to function (returning void)' type. Harvard 1901 architectures mean that ABI function and code pointers are not 1902 interconvertible. Similarly, since ANSI, C standards have 1903 explicitly said that pointers to functions and pointers to data 1904 are not interconvertible --- that is, you can't cast a function 1905 pointer to void * and back, and expect to get the same value. 1906 However, all function pointer types are interconvertible, so void 1907 (*) () can server as a generic function pointer. */ 1908 1909 struct type *builtin_func_ptr; 1910 1911 /* * `function returning pointer to function (returning void)' type. 1912 The final void return type is not significant for it. */ 1913 1914 struct type *builtin_func_func; 1915 1916 /* Special-purpose types. */ 1917 1918 /* * This type is used to represent a GDB internal function. */ 1919 1920 struct type *internal_fn; 1921 1922 /* * This type is used to represent an xmethod. */ 1923 struct type *xmethod; 1924}; 1925 1926/* * Return the type table for the specified architecture. */ 1927 1928extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch); 1929 1930/* * Per-objfile types used by symbol readers. */ 1931 1932struct objfile_type 1933{ 1934 /* Basic types based on the objfile architecture. */ 1935 struct type *builtin_void; 1936 struct type *builtin_char; 1937 struct type *builtin_short; 1938 struct type *builtin_int; 1939 struct type *builtin_long; 1940 struct type *builtin_long_long; 1941 struct type *builtin_signed_char; 1942 struct type *builtin_unsigned_char; 1943 struct type *builtin_unsigned_short; 1944 struct type *builtin_unsigned_int; 1945 struct type *builtin_unsigned_long; 1946 struct type *builtin_unsigned_long_long; 1947 struct type *builtin_half; 1948 struct type *builtin_float; 1949 struct type *builtin_double; 1950 struct type *builtin_long_double; 1951 1952 /* * This type is used to represent symbol addresses. */ 1953 struct type *builtin_core_addr; 1954 1955 /* * This type represents a type that was unrecognized in symbol 1956 read-in. */ 1957 struct type *builtin_error; 1958 1959 /* * Types used for symbols with no debug information. */ 1960 struct type *nodebug_text_symbol; 1961 struct type *nodebug_text_gnu_ifunc_symbol; 1962 struct type *nodebug_got_plt_symbol; 1963 struct type *nodebug_data_symbol; 1964 struct type *nodebug_unknown_symbol; 1965 struct type *nodebug_tls_symbol; 1966}; 1967 1968/* * Return the type table for the specified objfile. */ 1969 1970extern const struct objfile_type *objfile_type (struct objfile *objfile); 1971 1972/* Explicit floating-point formats. See "floatformat.h". */ 1973extern const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN]; 1974extern const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]; 1975extern const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]; 1976extern const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN]; 1977extern const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN]; 1978extern const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN]; 1979extern const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN]; 1980extern const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN]; 1981extern const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN]; 1982extern const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN]; 1983extern const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN]; 1984extern const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN]; 1985extern const struct floatformat *floatformats_bfloat16[BFD_ENDIAN_UNKNOWN]; 1986 1987/* Allocate space for storing data associated with a particular 1988 type. We ensure that the space is allocated using the same 1989 mechanism that was used to allocate the space for the type 1990 structure itself. I.e. if the type is on an objfile's 1991 objfile_obstack, then the space for data associated with that type 1992 will also be allocated on the objfile_obstack. If the type is 1993 associated with a gdbarch, then the space for data associated with that 1994 type will also be allocated on the gdbarch_obstack. 1995 1996 If a type is not associated with neither an objfile or a gdbarch then 1997 you should not use this macro to allocate space for data, instead you 1998 should call xmalloc directly, and ensure the memory is correctly freed 1999 when it is no longer needed. */ 2000 2001#define TYPE_ALLOC(t,size) \ 2002 (obstack_alloc ((TYPE_OBJFILE_OWNED (t) \ 2003 ? &TYPE_OBJFILE (t)->objfile_obstack \ 2004 : gdbarch_obstack (TYPE_OWNER (t).gdbarch)), \ 2005 size)) 2006 2007 2008/* See comment on TYPE_ALLOC. */ 2009 2010#define TYPE_ZALLOC(t,size) (memset (TYPE_ALLOC (t, size), 0, size)) 2011 2012/* Use alloc_type to allocate a type owned by an objfile. Use 2013 alloc_type_arch to allocate a type owned by an architecture. Use 2014 alloc_type_copy to allocate a type with the same owner as a 2015 pre-existing template type, no matter whether objfile or 2016 gdbarch. */ 2017extern struct type *alloc_type (struct objfile *); 2018extern struct type *alloc_type_arch (struct gdbarch *); 2019extern struct type *alloc_type_copy (const struct type *); 2020 2021/* * Return the type's architecture. For types owned by an 2022 architecture, that architecture is returned. For types owned by an 2023 objfile, that objfile's architecture is returned. */ 2024 2025extern struct gdbarch *get_type_arch (const struct type *); 2026 2027/* * This returns the target type (or NULL) of TYPE, also skipping 2028 past typedefs. */ 2029 2030extern struct type *get_target_type (struct type *type); 2031 2032/* Return the equivalent of TYPE_LENGTH, but in number of target 2033 addressable memory units of the associated gdbarch instead of bytes. */ 2034 2035extern unsigned int type_length_units (struct type *type); 2036 2037/* * Helper function to construct objfile-owned types. */ 2038 2039extern struct type *init_type (struct objfile *, enum type_code, int, 2040 const char *); 2041extern struct type *init_integer_type (struct objfile *, int, int, 2042 const char *); 2043extern struct type *init_character_type (struct objfile *, int, int, 2044 const char *); 2045extern struct type *init_boolean_type (struct objfile *, int, int, 2046 const char *); 2047extern struct type *init_float_type (struct objfile *, int, const char *, 2048 const struct floatformat **, 2049 enum bfd_endian = BFD_ENDIAN_UNKNOWN); 2050extern struct type *init_decfloat_type (struct objfile *, int, const char *); 2051extern struct type *init_complex_type (const char *, struct type *); 2052extern struct type *init_pointer_type (struct objfile *, int, const char *, 2053 struct type *); 2054 2055/* Helper functions to construct architecture-owned types. */ 2056extern struct type *arch_type (struct gdbarch *, enum type_code, int, 2057 const char *); 2058extern struct type *arch_integer_type (struct gdbarch *, int, int, 2059 const char *); 2060extern struct type *arch_character_type (struct gdbarch *, int, int, 2061 const char *); 2062extern struct type *arch_boolean_type (struct gdbarch *, int, int, 2063 const char *); 2064extern struct type *arch_float_type (struct gdbarch *, int, const char *, 2065 const struct floatformat **); 2066extern struct type *arch_decfloat_type (struct gdbarch *, int, const char *); 2067extern struct type *arch_pointer_type (struct gdbarch *, int, const char *, 2068 struct type *); 2069 2070/* Helper functions to construct a struct or record type. An 2071 initially empty type is created using arch_composite_type(). 2072 Fields are then added using append_composite_type_field*(). A union 2073 type has its size set to the largest field. A struct type has each 2074 field packed against the previous. */ 2075 2076extern struct type *arch_composite_type (struct gdbarch *gdbarch, 2077 const char *name, enum type_code code); 2078extern void append_composite_type_field (struct type *t, const char *name, 2079 struct type *field); 2080extern void append_composite_type_field_aligned (struct type *t, 2081 const char *name, 2082 struct type *field, 2083 int alignment); 2084struct field *append_composite_type_field_raw (struct type *t, const char *name, 2085 struct type *field); 2086 2087/* Helper functions to construct a bit flags type. An initially empty 2088 type is created using arch_flag_type(). Flags are then added using 2089 append_flag_type_field() and append_flag_type_flag(). */ 2090extern struct type *arch_flags_type (struct gdbarch *gdbarch, 2091 const char *name, int bit); 2092extern void append_flags_type_field (struct type *type, 2093 int start_bitpos, int nr_bits, 2094 struct type *field_type, const char *name); 2095extern void append_flags_type_flag (struct type *type, int bitpos, 2096 const char *name); 2097 2098extern void make_vector_type (struct type *array_type); 2099extern struct type *init_vector_type (struct type *elt_type, int n); 2100 2101extern struct type *lookup_reference_type (struct type *, enum type_code); 2102extern struct type *lookup_lvalue_reference_type (struct type *); 2103extern struct type *lookup_rvalue_reference_type (struct type *); 2104 2105 2106extern struct type *make_reference_type (struct type *, struct type **, 2107 enum type_code); 2108 2109extern struct type *make_cv_type (int, int, struct type *, struct type **); 2110 2111extern struct type *make_restrict_type (struct type *); 2112 2113extern struct type *make_unqualified_type (struct type *); 2114 2115extern struct type *make_atomic_type (struct type *); 2116 2117extern void replace_type (struct type *, struct type *); 2118 2119extern int address_space_name_to_int (struct gdbarch *, const char *); 2120 2121extern const char *address_space_int_to_name (struct gdbarch *, int); 2122 2123extern struct type *make_type_with_address_space (struct type *type, 2124 int space_identifier); 2125 2126extern struct type *lookup_memberptr_type (struct type *, struct type *); 2127 2128extern struct type *lookup_methodptr_type (struct type *); 2129 2130extern void smash_to_method_type (struct type *type, struct type *self_type, 2131 struct type *to_type, struct field *args, 2132 int nargs, int varargs); 2133 2134extern void smash_to_memberptr_type (struct type *, struct type *, 2135 struct type *); 2136 2137extern void smash_to_methodptr_type (struct type *, struct type *); 2138 2139extern struct type *allocate_stub_method (struct type *); 2140 2141extern const char *type_name_or_error (struct type *type); 2142 2143struct struct_elt 2144{ 2145 /* The field of the element, or NULL if no element was found. */ 2146 struct field *field; 2147 2148 /* The bit offset of the element in the parent structure. */ 2149 LONGEST offset; 2150}; 2151 2152/* Given a type TYPE, lookup the field and offset of the component named 2153 NAME. 2154 2155 TYPE can be either a struct or union, or a pointer or reference to 2156 a struct or union. If it is a pointer or reference, its target 2157 type is automatically used. Thus '.' and '->' are interchangable, 2158 as specified for the definitions of the expression element types 2159 STRUCTOP_STRUCT and STRUCTOP_PTR. 2160 2161 If NOERR is nonzero, the returned structure will have field set to 2162 NULL if there is no component named NAME. 2163 2164 If the component NAME is a field in an anonymous substructure of 2165 TYPE, the returned offset is a "global" offset relative to TYPE 2166 rather than an offset within the substructure. */ 2167 2168extern struct_elt lookup_struct_elt (struct type *, const char *, int); 2169 2170/* Given a type TYPE, lookup the type of the component named NAME. 2171 2172 TYPE can be either a struct or union, or a pointer or reference to 2173 a struct or union. If it is a pointer or reference, its target 2174 type is automatically used. Thus '.' and '->' are interchangable, 2175 as specified for the definitions of the expression element types 2176 STRUCTOP_STRUCT and STRUCTOP_PTR. 2177 2178 If NOERR is nonzero, return NULL if there is no component named 2179 NAME. */ 2180 2181extern struct type *lookup_struct_elt_type (struct type *, const char *, int); 2182 2183extern struct type *make_pointer_type (struct type *, struct type **); 2184 2185extern struct type *lookup_pointer_type (struct type *); 2186 2187extern struct type *make_function_type (struct type *, struct type **); 2188 2189extern struct type *lookup_function_type (struct type *); 2190 2191extern struct type *lookup_function_type_with_arguments (struct type *, 2192 int, 2193 struct type **); 2194 2195extern struct type *create_static_range_type (struct type *, struct type *, 2196 LONGEST, LONGEST); 2197 2198 2199extern struct type *create_array_type_with_stride 2200 (struct type *, struct type *, struct type *, 2201 struct dynamic_prop *, unsigned int); 2202 2203extern struct type *create_range_type (struct type *, struct type *, 2204 const struct dynamic_prop *, 2205 const struct dynamic_prop *, 2206 LONGEST); 2207 2208/* Like CREATE_RANGE_TYPE but also sets up a stride. When BYTE_STRIDE_P 2209 is true the value in STRIDE is a byte stride, otherwise STRIDE is a bit 2210 stride. */ 2211 2212extern struct type * create_range_type_with_stride 2213 (struct type *result_type, struct type *index_type, 2214 const struct dynamic_prop *low_bound, 2215 const struct dynamic_prop *high_bound, LONGEST bias, 2216 const struct dynamic_prop *stride, bool byte_stride_p); 2217 2218extern struct type *create_array_type (struct type *, struct type *, 2219 struct type *); 2220 2221extern struct type *lookup_array_range_type (struct type *, LONGEST, LONGEST); 2222 2223extern struct type *create_string_type (struct type *, struct type *, 2224 struct type *); 2225extern struct type *lookup_string_range_type (struct type *, LONGEST, LONGEST); 2226 2227extern struct type *create_set_type (struct type *, struct type *); 2228 2229extern struct type *lookup_unsigned_typename (const struct language_defn *, 2230 const char *); 2231 2232extern struct type *lookup_signed_typename (const struct language_defn *, 2233 const char *); 2234 2235extern void get_unsigned_type_max (struct type *, ULONGEST *); 2236 2237extern void get_signed_type_minmax (struct type *, LONGEST *, LONGEST *); 2238 2239/* * Resolve all dynamic values of a type e.g. array bounds to static values. 2240 ADDR specifies the location of the variable the type is bound to. 2241 If TYPE has no dynamic properties return TYPE; otherwise a new type with 2242 static properties is returned. */ 2243extern struct type *resolve_dynamic_type 2244 (struct type *type, gdb::array_view<const gdb_byte> valaddr, 2245 CORE_ADDR addr); 2246 2247/* * Predicate if the type has dynamic values, which are not resolved yet. */ 2248extern int is_dynamic_type (struct type *type); 2249 2250extern struct type *check_typedef (struct type *); 2251 2252extern void check_stub_method_group (struct type *, int); 2253 2254extern char *gdb_mangle_name (struct type *, int, int); 2255 2256extern struct type *lookup_typename (const struct language_defn *, 2257 const char *, const struct block *, int); 2258 2259extern struct type *lookup_template_type (const char *, struct type *, 2260 const struct block *); 2261 2262extern int get_vptr_fieldno (struct type *, struct type **); 2263 2264extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *); 2265 2266extern int get_array_bounds (struct type *type, LONGEST *low_bound, 2267 LONGEST *high_bound); 2268 2269extern int discrete_position (struct type *type, LONGEST val, LONGEST *pos); 2270 2271extern int class_types_same_p (const struct type *, const struct type *); 2272 2273extern int is_ancestor (struct type *, struct type *); 2274 2275extern int is_public_ancestor (struct type *, struct type *); 2276 2277extern int is_unique_ancestor (struct type *, struct value *); 2278 2279/* Overload resolution */ 2280 2281/* * Badness if parameter list length doesn't match arg list length. */ 2282extern const struct rank LENGTH_MISMATCH_BADNESS; 2283 2284/* * Dummy badness value for nonexistent parameter positions. */ 2285extern const struct rank TOO_FEW_PARAMS_BADNESS; 2286/* * Badness if no conversion among types. */ 2287extern const struct rank INCOMPATIBLE_TYPE_BADNESS; 2288 2289/* * Badness of an exact match. */ 2290extern const struct rank EXACT_MATCH_BADNESS; 2291 2292/* * Badness of integral promotion. */ 2293extern const struct rank INTEGER_PROMOTION_BADNESS; 2294/* * Badness of floating promotion. */ 2295extern const struct rank FLOAT_PROMOTION_BADNESS; 2296/* * Badness of converting a derived class pointer 2297 to a base class pointer. */ 2298extern const struct rank BASE_PTR_CONVERSION_BADNESS; 2299/* * Badness of integral conversion. */ 2300extern const struct rank INTEGER_CONVERSION_BADNESS; 2301/* * Badness of floating conversion. */ 2302extern const struct rank FLOAT_CONVERSION_BADNESS; 2303/* * Badness of integer<->floating conversions. */ 2304extern const struct rank INT_FLOAT_CONVERSION_BADNESS; 2305/* * Badness of conversion of pointer to void pointer. */ 2306extern const struct rank VOID_PTR_CONVERSION_BADNESS; 2307/* * Badness of conversion to boolean. */ 2308extern const struct rank BOOL_CONVERSION_BADNESS; 2309/* * Badness of converting derived to base class. */ 2310extern const struct rank BASE_CONVERSION_BADNESS; 2311/* * Badness of converting from non-reference to reference. Subrank 2312 is the type of reference conversion being done. */ 2313extern const struct rank REFERENCE_CONVERSION_BADNESS; 2314extern const struct rank REFERENCE_SEE_THROUGH_BADNESS; 2315/* * Conversion to rvalue reference. */ 2316#define REFERENCE_CONVERSION_RVALUE 1 2317/* * Conversion to const lvalue reference. */ 2318#define REFERENCE_CONVERSION_CONST_LVALUE 2 2319 2320/* * Badness of converting integer 0 to NULL pointer. */ 2321extern const struct rank NULL_POINTER_CONVERSION; 2322/* * Badness of cv-conversion. Subrank is a flag describing the conversions 2323 being done. */ 2324extern const struct rank CV_CONVERSION_BADNESS; 2325#define CV_CONVERSION_CONST 1 2326#define CV_CONVERSION_VOLATILE 2 2327 2328/* Non-standard conversions allowed by the debugger */ 2329 2330/* * Converting a pointer to an int is usually OK. */ 2331extern const struct rank NS_POINTER_CONVERSION_BADNESS; 2332 2333/* * Badness of converting a (non-zero) integer constant 2334 to a pointer. */ 2335extern const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS; 2336 2337extern struct rank sum_ranks (struct rank a, struct rank b); 2338extern int compare_ranks (struct rank a, struct rank b); 2339 2340extern int compare_badness (const badness_vector &, 2341 const badness_vector &); 2342 2343extern badness_vector rank_function (gdb::array_view<type *> parms, 2344 gdb::array_view<value *> args); 2345 2346extern struct rank rank_one_type (struct type *, struct type *, 2347 struct value *); 2348 2349extern void recursive_dump_type (struct type *, int); 2350 2351extern int field_is_static (struct field *); 2352 2353/* printcmd.c */ 2354 2355extern void print_scalar_formatted (const gdb_byte *, struct type *, 2356 const struct value_print_options *, 2357 int, struct ui_file *); 2358 2359extern int can_dereference (struct type *); 2360 2361extern int is_integral_type (struct type *); 2362 2363extern int is_floating_type (struct type *); 2364 2365extern int is_scalar_type (struct type *type); 2366 2367extern int is_scalar_type_recursive (struct type *); 2368 2369extern int class_or_union_p (const struct type *); 2370 2371extern void maintenance_print_type (const char *, int); 2372 2373extern htab_t create_copied_types_hash (struct objfile *objfile); 2374 2375extern struct type *copy_type_recursive (struct objfile *objfile, 2376 struct type *type, 2377 htab_t copied_types); 2378 2379extern struct type *copy_type (const struct type *type); 2380 2381extern bool types_equal (struct type *, struct type *); 2382 2383extern bool types_deeply_equal (struct type *, struct type *); 2384 2385extern int type_not_allocated (const struct type *type); 2386 2387extern int type_not_associated (const struct type *type); 2388 2389/* * When the type includes explicit byte ordering, return that. 2390 Otherwise, the byte ordering from gdbarch_byte_order for 2391 get_type_arch is returned. */ 2392 2393extern enum bfd_endian type_byte_order (const struct type *type); 2394 2395/* A flag to enable printing of debugging information of C++ 2396 overloading. */ 2397 2398extern unsigned int overload_debug; 2399 2400#endif /* GDBTYPES_H */ 2401