1 /* Support routines for manipulating internal types for GDB. 2 3 Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. 4 5 Contributed by Cygnus Support, using pieces from other GDB modules. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "gdb_string.h" 24 #include "bfd.h" 25 #include "symtab.h" 26 #include "symfile.h" 27 #include "objfiles.h" 28 #include "gdbtypes.h" 29 #include "expression.h" 30 #include "language.h" 31 #include "target.h" 32 #include "value.h" 33 #include "demangle.h" 34 #include "complaints.h" 35 #include "gdbcmd.h" 36 #include "wrapper.h" 37 #include "cp-abi.h" 38 #include "gdb_assert.h" 39 #include "hashtab.h" 40 41 42 /* Initialize BADNESS constants. */ 43 44 const struct rank LENGTH_MISMATCH_BADNESS = {100,0}; 45 46 const struct rank TOO_FEW_PARAMS_BADNESS = {100,0}; 47 const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0}; 48 49 const struct rank EXACT_MATCH_BADNESS = {0,0}; 50 51 const struct rank INTEGER_PROMOTION_BADNESS = {1,0}; 52 const struct rank FLOAT_PROMOTION_BADNESS = {1,0}; 53 const struct rank BASE_PTR_CONVERSION_BADNESS = {1,0}; 54 const struct rank INTEGER_CONVERSION_BADNESS = {2,0}; 55 const struct rank FLOAT_CONVERSION_BADNESS = {2,0}; 56 const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0}; 57 const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0}; 58 const struct rank BOOL_PTR_CONVERSION_BADNESS = {3,0}; 59 const struct rank BASE_CONVERSION_BADNESS = {2,0}; 60 const struct rank REFERENCE_CONVERSION_BADNESS = {2,0}; 61 const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0}; 62 const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0}; 63 64 /* Floatformat pairs. */ 65 const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = { 66 &floatformat_ieee_half_big, 67 &floatformat_ieee_half_little 68 }; 69 const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = { 70 &floatformat_ieee_single_big, 71 &floatformat_ieee_single_little 72 }; 73 const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = { 74 &floatformat_ieee_double_big, 75 &floatformat_ieee_double_little 76 }; 77 const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = { 78 &floatformat_ieee_double_big, 79 &floatformat_ieee_double_littlebyte_bigword 80 }; 81 const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = { 82 &floatformat_i387_ext, 83 &floatformat_i387_ext 84 }; 85 const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = { 86 &floatformat_m68881_ext, 87 &floatformat_m68881_ext 88 }; 89 const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = { 90 &floatformat_arm_ext_big, 91 &floatformat_arm_ext_littlebyte_bigword 92 }; 93 const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = { 94 &floatformat_ia64_spill_big, 95 &floatformat_ia64_spill_little 96 }; 97 const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = { 98 &floatformat_ia64_quad_big, 99 &floatformat_ia64_quad_little 100 }; 101 const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = { 102 &floatformat_vax_f, 103 &floatformat_vax_f 104 }; 105 const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = { 106 &floatformat_vax_d, 107 &floatformat_vax_d 108 }; 109 const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = { 110 &floatformat_ibm_long_double, 111 &floatformat_ibm_long_double 112 }; 113 114 115 int opaque_type_resolution = 1; 116 static void 117 show_opaque_type_resolution (struct ui_file *file, int from_tty, 118 struct cmd_list_element *c, 119 const char *value) 120 { 121 fprintf_filtered (file, _("Resolution of opaque struct/class/union types " 122 "(if set before loading symbols) is %s.\n"), 123 value); 124 } 125 126 int overload_debug = 0; 127 static void 128 show_overload_debug (struct ui_file *file, int from_tty, 129 struct cmd_list_element *c, const char *value) 130 { 131 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"), 132 value); 133 } 134 135 struct extra 136 { 137 char str[128]; 138 int len; 139 }; /* Maximum extension is 128! FIXME */ 140 141 static void print_bit_vector (B_TYPE *, int); 142 static void print_arg_types (struct field *, int, int); 143 static void dump_fn_fieldlists (struct type *, int); 144 static void print_cplus_stuff (struct type *, int); 145 146 147 /* Allocate a new OBJFILE-associated type structure and fill it 148 with some defaults. Space for the type structure is allocated 149 on the objfile's objfile_obstack. */ 150 151 struct type * 152 alloc_type (struct objfile *objfile) 153 { 154 struct type *type; 155 156 gdb_assert (objfile != NULL); 157 158 /* Alloc the structure and start off with all fields zeroed. */ 159 type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type); 160 TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack, 161 struct main_type); 162 OBJSTAT (objfile, n_types++); 163 164 TYPE_OBJFILE_OWNED (type) = 1; 165 TYPE_OWNER (type).objfile = objfile; 166 167 /* Initialize the fields that might not be zero. */ 168 169 TYPE_CODE (type) = TYPE_CODE_UNDEF; 170 TYPE_VPTR_FIELDNO (type) = -1; 171 TYPE_CHAIN (type) = type; /* Chain back to itself. */ 172 173 return type; 174 } 175 176 /* Allocate a new GDBARCH-associated type structure and fill it 177 with some defaults. Space for the type structure is allocated 178 on the heap. */ 179 180 struct type * 181 alloc_type_arch (struct gdbarch *gdbarch) 182 { 183 struct type *type; 184 185 gdb_assert (gdbarch != NULL); 186 187 /* Alloc the structure and start off with all fields zeroed. */ 188 189 type = XZALLOC (struct type); 190 TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type); 191 192 TYPE_OBJFILE_OWNED (type) = 0; 193 TYPE_OWNER (type).gdbarch = gdbarch; 194 195 /* Initialize the fields that might not be zero. */ 196 197 TYPE_CODE (type) = TYPE_CODE_UNDEF; 198 TYPE_VPTR_FIELDNO (type) = -1; 199 TYPE_CHAIN (type) = type; /* Chain back to itself. */ 200 201 return type; 202 } 203 204 /* If TYPE is objfile-associated, allocate a new type structure 205 associated with the same objfile. If TYPE is gdbarch-associated, 206 allocate a new type structure associated with the same gdbarch. */ 207 208 struct type * 209 alloc_type_copy (const struct type *type) 210 { 211 if (TYPE_OBJFILE_OWNED (type)) 212 return alloc_type (TYPE_OWNER (type).objfile); 213 else 214 return alloc_type_arch (TYPE_OWNER (type).gdbarch); 215 } 216 217 /* If TYPE is gdbarch-associated, return that architecture. 218 If TYPE is objfile-associated, return that objfile's architecture. */ 219 220 struct gdbarch * 221 get_type_arch (const struct type *type) 222 { 223 if (TYPE_OBJFILE_OWNED (type)) 224 return get_objfile_arch (TYPE_OWNER (type).objfile); 225 else 226 return TYPE_OWNER (type).gdbarch; 227 } 228 229 230 /* Alloc a new type instance structure, fill it with some defaults, 231 and point it at OLDTYPE. Allocate the new type instance from the 232 same place as OLDTYPE. */ 233 234 static struct type * 235 alloc_type_instance (struct type *oldtype) 236 { 237 struct type *type; 238 239 /* Allocate the structure. */ 240 241 if (! TYPE_OBJFILE_OWNED (oldtype)) 242 type = XZALLOC (struct type); 243 else 244 type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack, 245 struct type); 246 247 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype); 248 249 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */ 250 251 return type; 252 } 253 254 /* Clear all remnants of the previous type at TYPE, in preparation for 255 replacing it with something else. Preserve owner information. */ 256 static void 257 smash_type (struct type *type) 258 { 259 int objfile_owned = TYPE_OBJFILE_OWNED (type); 260 union type_owner owner = TYPE_OWNER (type); 261 262 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type)); 263 264 /* Restore owner information. */ 265 TYPE_OBJFILE_OWNED (type) = objfile_owned; 266 TYPE_OWNER (type) = owner; 267 268 /* For now, delete the rings. */ 269 TYPE_CHAIN (type) = type; 270 271 /* For now, leave the pointer/reference types alone. */ 272 } 273 274 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points 275 to a pointer to memory where the pointer type should be stored. 276 If *TYPEPTR is zero, update it to point to the pointer type we return. 277 We allocate new memory if needed. */ 278 279 struct type * 280 make_pointer_type (struct type *type, struct type **typeptr) 281 { 282 struct type *ntype; /* New type */ 283 struct type *chain; 284 285 ntype = TYPE_POINTER_TYPE (type); 286 287 if (ntype) 288 { 289 if (typeptr == 0) 290 return ntype; /* Don't care about alloc, 291 and have new type. */ 292 else if (*typeptr == 0) 293 { 294 *typeptr = ntype; /* Tracking alloc, and have new type. */ 295 return ntype; 296 } 297 } 298 299 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ 300 { 301 ntype = alloc_type_copy (type); 302 if (typeptr) 303 *typeptr = ntype; 304 } 305 else /* We have storage, but need to reset it. */ 306 { 307 ntype = *typeptr; 308 chain = TYPE_CHAIN (ntype); 309 smash_type (ntype); 310 TYPE_CHAIN (ntype) = chain; 311 } 312 313 TYPE_TARGET_TYPE (ntype) = type; 314 TYPE_POINTER_TYPE (type) = ntype; 315 316 /* FIXME! Assume the machine has only one representation for 317 pointers! */ 318 319 TYPE_LENGTH (ntype) 320 = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; 321 TYPE_CODE (ntype) = TYPE_CODE_PTR; 322 323 /* Mark pointers as unsigned. The target converts between pointers 324 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and 325 gdbarch_address_to_pointer. */ 326 TYPE_UNSIGNED (ntype) = 1; 327 328 if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */ 329 TYPE_POINTER_TYPE (type) = ntype; 330 331 /* Update the length of all the other variants of this type. */ 332 chain = TYPE_CHAIN (ntype); 333 while (chain != ntype) 334 { 335 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype); 336 chain = TYPE_CHAIN (chain); 337 } 338 339 return ntype; 340 } 341 342 /* Given a type TYPE, return a type of pointers to that type. 343 May need to construct such a type if this is the first use. */ 344 345 struct type * 346 lookup_pointer_type (struct type *type) 347 { 348 return make_pointer_type (type, (struct type **) 0); 349 } 350 351 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, 352 points to a pointer to memory where the reference type should be 353 stored. If *TYPEPTR is zero, update it to point to the reference 354 type we return. We allocate new memory if needed. */ 355 356 struct type * 357 make_reference_type (struct type *type, struct type **typeptr) 358 { 359 struct type *ntype; /* New type */ 360 struct type *chain; 361 362 ntype = TYPE_REFERENCE_TYPE (type); 363 364 if (ntype) 365 { 366 if (typeptr == 0) 367 return ntype; /* Don't care about alloc, 368 and have new type. */ 369 else if (*typeptr == 0) 370 { 371 *typeptr = ntype; /* Tracking alloc, and have new type. */ 372 return ntype; 373 } 374 } 375 376 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ 377 { 378 ntype = alloc_type_copy (type); 379 if (typeptr) 380 *typeptr = ntype; 381 } 382 else /* We have storage, but need to reset it. */ 383 { 384 ntype = *typeptr; 385 chain = TYPE_CHAIN (ntype); 386 smash_type (ntype); 387 TYPE_CHAIN (ntype) = chain; 388 } 389 390 TYPE_TARGET_TYPE (ntype) = type; 391 TYPE_REFERENCE_TYPE (type) = ntype; 392 393 /* FIXME! Assume the machine has only one representation for 394 references, and that it matches the (only) representation for 395 pointers! */ 396 397 TYPE_LENGTH (ntype) = 398 gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; 399 TYPE_CODE (ntype) = TYPE_CODE_REF; 400 401 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */ 402 TYPE_REFERENCE_TYPE (type) = ntype; 403 404 /* Update the length of all the other variants of this type. */ 405 chain = TYPE_CHAIN (ntype); 406 while (chain != ntype) 407 { 408 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype); 409 chain = TYPE_CHAIN (chain); 410 } 411 412 return ntype; 413 } 414 415 /* Same as above, but caller doesn't care about memory allocation 416 details. */ 417 418 struct type * 419 lookup_reference_type (struct type *type) 420 { 421 return make_reference_type (type, (struct type **) 0); 422 } 423 424 /* Lookup a function type that returns type TYPE. TYPEPTR, if 425 nonzero, points to a pointer to memory where the function type 426 should be stored. If *TYPEPTR is zero, update it to point to the 427 function type we return. We allocate new memory if needed. */ 428 429 struct type * 430 make_function_type (struct type *type, struct type **typeptr) 431 { 432 struct type *ntype; /* New type */ 433 434 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ 435 { 436 ntype = alloc_type_copy (type); 437 if (typeptr) 438 *typeptr = ntype; 439 } 440 else /* We have storage, but need to reset it. */ 441 { 442 ntype = *typeptr; 443 smash_type (ntype); 444 } 445 446 TYPE_TARGET_TYPE (ntype) = type; 447 448 TYPE_LENGTH (ntype) = 1; 449 TYPE_CODE (ntype) = TYPE_CODE_FUNC; 450 451 INIT_FUNC_SPECIFIC (ntype); 452 453 return ntype; 454 } 455 456 457 /* Given a type TYPE, return a type of functions that return that type. 458 May need to construct such a type if this is the first use. */ 459 460 struct type * 461 lookup_function_type (struct type *type) 462 { 463 return make_function_type (type, (struct type **) 0); 464 } 465 466 /* Identify address space identifier by name -- 467 return the integer flag defined in gdbtypes.h. */ 468 extern int 469 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier) 470 { 471 int type_flags; 472 473 /* Check for known address space delimiters. */ 474 if (!strcmp (space_identifier, "code")) 475 return TYPE_INSTANCE_FLAG_CODE_SPACE; 476 else if (!strcmp (space_identifier, "data")) 477 return TYPE_INSTANCE_FLAG_DATA_SPACE; 478 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch) 479 && gdbarch_address_class_name_to_type_flags (gdbarch, 480 space_identifier, 481 &type_flags)) 482 return type_flags; 483 else 484 error (_("Unknown address space specifier: \"%s\""), space_identifier); 485 } 486 487 /* Identify address space identifier by integer flag as defined in 488 gdbtypes.h -- return the string version of the adress space name. */ 489 490 const char * 491 address_space_int_to_name (struct gdbarch *gdbarch, int space_flag) 492 { 493 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE) 494 return "code"; 495 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE) 496 return "data"; 497 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) 498 && gdbarch_address_class_type_flags_to_name_p (gdbarch)) 499 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag); 500 else 501 return NULL; 502 } 503 504 /* Create a new type with instance flags NEW_FLAGS, based on TYPE. 505 506 If STORAGE is non-NULL, create the new type instance there. 507 STORAGE must be in the same obstack as TYPE. */ 508 509 static struct type * 510 make_qualified_type (struct type *type, int new_flags, 511 struct type *storage) 512 { 513 struct type *ntype; 514 515 ntype = type; 516 do 517 { 518 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags) 519 return ntype; 520 ntype = TYPE_CHAIN (ntype); 521 } 522 while (ntype != type); 523 524 /* Create a new type instance. */ 525 if (storage == NULL) 526 ntype = alloc_type_instance (type); 527 else 528 { 529 /* If STORAGE was provided, it had better be in the same objfile 530 as TYPE. Otherwise, we can't link it into TYPE's cv chain: 531 if one objfile is freed and the other kept, we'd have 532 dangling pointers. */ 533 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage)); 534 535 ntype = storage; 536 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type); 537 TYPE_CHAIN (ntype) = ntype; 538 } 539 540 /* Pointers or references to the original type are not relevant to 541 the new type. */ 542 TYPE_POINTER_TYPE (ntype) = (struct type *) 0; 543 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0; 544 545 /* Chain the new qualified type to the old type. */ 546 TYPE_CHAIN (ntype) = TYPE_CHAIN (type); 547 TYPE_CHAIN (type) = ntype; 548 549 /* Now set the instance flags and return the new type. */ 550 TYPE_INSTANCE_FLAGS (ntype) = new_flags; 551 552 /* Set length of new type to that of the original type. */ 553 TYPE_LENGTH (ntype) = TYPE_LENGTH (type); 554 555 return ntype; 556 } 557 558 /* Make an address-space-delimited variant of a type -- a type that 559 is identical to the one supplied except that it has an address 560 space attribute attached to it (such as "code" or "data"). 561 562 The space attributes "code" and "data" are for Harvard 563 architectures. The address space attributes are for architectures 564 which have alternately sized pointers or pointers with alternate 565 representations. */ 566 567 struct type * 568 make_type_with_address_space (struct type *type, int space_flag) 569 { 570 int new_flags = ((TYPE_INSTANCE_FLAGS (type) 571 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE 572 | TYPE_INSTANCE_FLAG_DATA_SPACE 573 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)) 574 | space_flag); 575 576 return make_qualified_type (type, new_flags, NULL); 577 } 578 579 /* Make a "c-v" variant of a type -- a type that is identical to the 580 one supplied except that it may have const or volatile attributes 581 CNST is a flag for setting the const attribute 582 VOLTL is a flag for setting the volatile attribute 583 TYPE is the base type whose variant we are creating. 584 585 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to 586 storage to hold the new qualified type; *TYPEPTR and TYPE must be 587 in the same objfile. Otherwise, allocate fresh memory for the new 588 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the 589 new type we construct. */ 590 struct type * 591 make_cv_type (int cnst, int voltl, 592 struct type *type, 593 struct type **typeptr) 594 { 595 struct type *ntype; /* New type */ 596 597 int new_flags = (TYPE_INSTANCE_FLAGS (type) 598 & ~(TYPE_INSTANCE_FLAG_CONST 599 | TYPE_INSTANCE_FLAG_VOLATILE)); 600 601 if (cnst) 602 new_flags |= TYPE_INSTANCE_FLAG_CONST; 603 604 if (voltl) 605 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE; 606 607 if (typeptr && *typeptr != NULL) 608 { 609 /* TYPE and *TYPEPTR must be in the same objfile. We can't have 610 a C-V variant chain that threads across objfiles: if one 611 objfile gets freed, then the other has a broken C-V chain. 612 613 This code used to try to copy over the main type from TYPE to 614 *TYPEPTR if they were in different objfiles, but that's 615 wrong, too: TYPE may have a field list or member function 616 lists, which refer to types of their own, etc. etc. The 617 whole shebang would need to be copied over recursively; you 618 can't have inter-objfile pointers. The only thing to do is 619 to leave stub types as stub types, and look them up afresh by 620 name each time you encounter them. */ 621 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)); 622 } 623 624 ntype = make_qualified_type (type, new_flags, 625 typeptr ? *typeptr : NULL); 626 627 if (typeptr != NULL) 628 *typeptr = ntype; 629 630 return ntype; 631 } 632 633 /* Replace the contents of ntype with the type *type. This changes the 634 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus 635 the changes are propogated to all types in the TYPE_CHAIN. 636 637 In order to build recursive types, it's inevitable that we'll need 638 to update types in place --- but this sort of indiscriminate 639 smashing is ugly, and needs to be replaced with something more 640 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not 641 clear if more steps are needed. */ 642 void 643 replace_type (struct type *ntype, struct type *type) 644 { 645 struct type *chain; 646 647 /* These two types had better be in the same objfile. Otherwise, 648 the assignment of one type's main type structure to the other 649 will produce a type with references to objects (names; field 650 lists; etc.) allocated on an objfile other than its own. */ 651 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype)); 652 653 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type); 654 655 /* The type length is not a part of the main type. Update it for 656 each type on the variant chain. */ 657 chain = ntype; 658 do 659 { 660 /* Assert that this element of the chain has no address-class bits 661 set in its flags. Such type variants might have type lengths 662 which are supposed to be different from the non-address-class 663 variants. This assertion shouldn't ever be triggered because 664 symbol readers which do construct address-class variants don't 665 call replace_type(). */ 666 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0); 667 668 TYPE_LENGTH (chain) = TYPE_LENGTH (type); 669 chain = TYPE_CHAIN (chain); 670 } 671 while (ntype != chain); 672 673 /* Assert that the two types have equivalent instance qualifiers. 674 This should be true for at least all of our debug readers. */ 675 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type)); 676 } 677 678 /* Implement direct support for MEMBER_TYPE in GNU C++. 679 May need to construct such a type if this is the first use. 680 The TYPE is the type of the member. The DOMAIN is the type 681 of the aggregate that the member belongs to. */ 682 683 struct type * 684 lookup_memberptr_type (struct type *type, struct type *domain) 685 { 686 struct type *mtype; 687 688 mtype = alloc_type_copy (type); 689 smash_to_memberptr_type (mtype, domain, type); 690 return mtype; 691 } 692 693 /* Return a pointer-to-method type, for a method of type TO_TYPE. */ 694 695 struct type * 696 lookup_methodptr_type (struct type *to_type) 697 { 698 struct type *mtype; 699 700 mtype = alloc_type_copy (to_type); 701 smash_to_methodptr_type (mtype, to_type); 702 return mtype; 703 } 704 705 /* Allocate a stub method whose return type is TYPE. This apparently 706 happens for speed of symbol reading, since parsing out the 707 arguments to the method is cpu-intensive, the way we are doing it. 708 So, we will fill in arguments later. This always returns a fresh 709 type. */ 710 711 struct type * 712 allocate_stub_method (struct type *type) 713 { 714 struct type *mtype; 715 716 mtype = alloc_type_copy (type); 717 TYPE_CODE (mtype) = TYPE_CODE_METHOD; 718 TYPE_LENGTH (mtype) = 1; 719 TYPE_STUB (mtype) = 1; 720 TYPE_TARGET_TYPE (mtype) = type; 721 /* _DOMAIN_TYPE (mtype) = unknown yet */ 722 return mtype; 723 } 724 725 /* Create a range type using either a blank type supplied in 726 RESULT_TYPE, or creating a new type, inheriting the objfile from 727 INDEX_TYPE. 728 729 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND 730 to HIGH_BOUND, inclusive. 731 732 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make 733 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */ 734 735 struct type * 736 create_range_type (struct type *result_type, struct type *index_type, 737 LONGEST low_bound, LONGEST high_bound) 738 { 739 if (result_type == NULL) 740 result_type = alloc_type_copy (index_type); 741 TYPE_CODE (result_type) = TYPE_CODE_RANGE; 742 TYPE_TARGET_TYPE (result_type) = index_type; 743 if (TYPE_STUB (index_type)) 744 TYPE_TARGET_STUB (result_type) = 1; 745 else 746 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type)); 747 TYPE_RANGE_DATA (result_type) = (struct range_bounds *) 748 TYPE_ZALLOC (result_type, sizeof (struct range_bounds)); 749 TYPE_LOW_BOUND (result_type) = low_bound; 750 TYPE_HIGH_BOUND (result_type) = high_bound; 751 752 if (low_bound >= 0) 753 TYPE_UNSIGNED (result_type) = 1; 754 755 return result_type; 756 } 757 758 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type 759 TYPE. Return 1 if type is a range type, 0 if it is discrete (and 760 bounds will fit in LONGEST), or -1 otherwise. */ 761 762 int 763 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) 764 { 765 CHECK_TYPEDEF (type); 766 switch (TYPE_CODE (type)) 767 { 768 case TYPE_CODE_RANGE: 769 *lowp = TYPE_LOW_BOUND (type); 770 *highp = TYPE_HIGH_BOUND (type); 771 return 1; 772 case TYPE_CODE_ENUM: 773 if (TYPE_NFIELDS (type) > 0) 774 { 775 /* The enums may not be sorted by value, so search all 776 entries. */ 777 int i; 778 779 *lowp = *highp = TYPE_FIELD_BITPOS (type, 0); 780 for (i = 0; i < TYPE_NFIELDS (type); i++) 781 { 782 if (TYPE_FIELD_BITPOS (type, i) < *lowp) 783 *lowp = TYPE_FIELD_BITPOS (type, i); 784 if (TYPE_FIELD_BITPOS (type, i) > *highp) 785 *highp = TYPE_FIELD_BITPOS (type, i); 786 } 787 788 /* Set unsigned indicator if warranted. */ 789 if (*lowp >= 0) 790 { 791 TYPE_UNSIGNED (type) = 1; 792 } 793 } 794 else 795 { 796 *lowp = 0; 797 *highp = -1; 798 } 799 return 0; 800 case TYPE_CODE_BOOL: 801 *lowp = 0; 802 *highp = 1; 803 return 0; 804 case TYPE_CODE_INT: 805 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */ 806 return -1; 807 if (!TYPE_UNSIGNED (type)) 808 { 809 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1)); 810 *highp = -*lowp - 1; 811 return 0; 812 } 813 /* ... fall through for unsigned ints ... */ 814 case TYPE_CODE_CHAR: 815 *lowp = 0; 816 /* This round-about calculation is to avoid shifting by 817 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work 818 if TYPE_LENGTH (type) == sizeof (LONGEST). */ 819 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1); 820 *highp = (*highp - 1) | *highp; 821 return 0; 822 default: 823 return -1; 824 } 825 } 826 827 /* Assuming TYPE is a simple, non-empty array type, compute its upper 828 and lower bound. Save the low bound into LOW_BOUND if not NULL. 829 Save the high bound into HIGH_BOUND if not NULL. 830 831 Return 1 if the operation was successful. Return zero otherwise, 832 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified. 833 834 We now simply use get_discrete_bounds call to get the values 835 of the low and high bounds. 836 get_discrete_bounds can return three values: 837 1, meaning that index is a range, 838 0, meaning that index is a discrete type, 839 or -1 for failure. */ 840 841 int 842 get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) 843 { 844 struct type *index = TYPE_INDEX_TYPE (type); 845 LONGEST low = 0; 846 LONGEST high = 0; 847 int res; 848 849 if (index == NULL) 850 return 0; 851 852 res = get_discrete_bounds (index, &low, &high); 853 if (res == -1) 854 return 0; 855 856 /* Check if the array bounds are undefined. */ 857 if (res == 1 858 && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type)) 859 || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type)))) 860 return 0; 861 862 if (low_bound) 863 *low_bound = low; 864 865 if (high_bound) 866 *high_bound = high; 867 868 return 1; 869 } 870 871 /* Create an array type using either a blank type supplied in 872 RESULT_TYPE, or creating a new type, inheriting the objfile from 873 RANGE_TYPE. 874 875 Elements will be of type ELEMENT_TYPE, the indices will be of type 876 RANGE_TYPE. 877 878 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make 879 sure it is TYPE_CODE_UNDEF before we bash it into an array 880 type? */ 881 882 struct type * 883 create_array_type (struct type *result_type, 884 struct type *element_type, 885 struct type *range_type) 886 { 887 LONGEST low_bound, high_bound; 888 889 if (result_type == NULL) 890 result_type = alloc_type_copy (range_type); 891 892 TYPE_CODE (result_type) = TYPE_CODE_ARRAY; 893 TYPE_TARGET_TYPE (result_type) = element_type; 894 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) 895 low_bound = high_bound = 0; 896 CHECK_TYPEDEF (element_type); 897 /* Be careful when setting the array length. Ada arrays can be 898 empty arrays with the high_bound being smaller than the low_bound. 899 In such cases, the array length should be zero. */ 900 if (high_bound < low_bound) 901 TYPE_LENGTH (result_type) = 0; 902 else 903 TYPE_LENGTH (result_type) = 904 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1); 905 TYPE_NFIELDS (result_type) = 1; 906 TYPE_FIELDS (result_type) = 907 (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field)); 908 TYPE_INDEX_TYPE (result_type) = range_type; 909 TYPE_VPTR_FIELDNO (result_type) = -1; 910 911 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */ 912 if (TYPE_LENGTH (result_type) == 0) 913 TYPE_TARGET_STUB (result_type) = 1; 914 915 return result_type; 916 } 917 918 struct type * 919 lookup_array_range_type (struct type *element_type, 920 int low_bound, int high_bound) 921 { 922 struct gdbarch *gdbarch = get_type_arch (element_type); 923 struct type *index_type = builtin_type (gdbarch)->builtin_int; 924 struct type *range_type 925 = create_range_type (NULL, index_type, low_bound, high_bound); 926 927 return create_array_type (NULL, element_type, range_type); 928 } 929 930 /* Create a string type using either a blank type supplied in 931 RESULT_TYPE, or creating a new type. String types are similar 932 enough to array of char types that we can use create_array_type to 933 build the basic type and then bash it into a string type. 934 935 For fixed length strings, the range type contains 0 as the lower 936 bound and the length of the string minus one as the upper bound. 937 938 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make 939 sure it is TYPE_CODE_UNDEF before we bash it into a string 940 type? */ 941 942 struct type * 943 create_string_type (struct type *result_type, 944 struct type *string_char_type, 945 struct type *range_type) 946 { 947 result_type = create_array_type (result_type, 948 string_char_type, 949 range_type); 950 TYPE_CODE (result_type) = TYPE_CODE_STRING; 951 return result_type; 952 } 953 954 struct type * 955 lookup_string_range_type (struct type *string_char_type, 956 int low_bound, int high_bound) 957 { 958 struct type *result_type; 959 960 result_type = lookup_array_range_type (string_char_type, 961 low_bound, high_bound); 962 TYPE_CODE (result_type) = TYPE_CODE_STRING; 963 return result_type; 964 } 965 966 struct type * 967 create_set_type (struct type *result_type, struct type *domain_type) 968 { 969 if (result_type == NULL) 970 result_type = alloc_type_copy (domain_type); 971 972 TYPE_CODE (result_type) = TYPE_CODE_SET; 973 TYPE_NFIELDS (result_type) = 1; 974 TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field)); 975 976 if (!TYPE_STUB (domain_type)) 977 { 978 LONGEST low_bound, high_bound, bit_length; 979 980 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0) 981 low_bound = high_bound = 0; 982 bit_length = high_bound - low_bound + 1; 983 TYPE_LENGTH (result_type) 984 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT; 985 if (low_bound >= 0) 986 TYPE_UNSIGNED (result_type) = 1; 987 } 988 TYPE_FIELD_TYPE (result_type, 0) = domain_type; 989 990 return result_type; 991 } 992 993 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE 994 and any array types nested inside it. */ 995 996 void 997 make_vector_type (struct type *array_type) 998 { 999 struct type *inner_array, *elt_type; 1000 int flags; 1001 1002 /* Find the innermost array type, in case the array is 1003 multi-dimensional. */ 1004 inner_array = array_type; 1005 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) 1006 inner_array = TYPE_TARGET_TYPE (inner_array); 1007 1008 elt_type = TYPE_TARGET_TYPE (inner_array); 1009 if (TYPE_CODE (elt_type) == TYPE_CODE_INT) 1010 { 1011 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT; 1012 elt_type = make_qualified_type (elt_type, flags, NULL); 1013 TYPE_TARGET_TYPE (inner_array) = elt_type; 1014 } 1015 1016 TYPE_VECTOR (array_type) = 1; 1017 } 1018 1019 struct type * 1020 init_vector_type (struct type *elt_type, int n) 1021 { 1022 struct type *array_type; 1023 1024 array_type = lookup_array_range_type (elt_type, 0, n - 1); 1025 make_vector_type (array_type); 1026 return array_type; 1027 } 1028 1029 /* Smash TYPE to be a type of pointers to members of DOMAIN with type 1030 TO_TYPE. A member pointer is a wierd thing -- it amounts to a 1031 typed offset into a struct, e.g. "an int at offset 8". A MEMBER 1032 TYPE doesn't include the offset (that's the value of the MEMBER 1033 itself), but does include the structure type into which it points 1034 (for some reason). 1035 1036 When "smashing" the type, we preserve the objfile that the old type 1037 pointed to, since we aren't changing where the type is actually 1038 allocated. */ 1039 1040 void 1041 smash_to_memberptr_type (struct type *type, struct type *domain, 1042 struct type *to_type) 1043 { 1044 smash_type (type); 1045 TYPE_TARGET_TYPE (type) = to_type; 1046 TYPE_DOMAIN_TYPE (type) = domain; 1047 /* Assume that a data member pointer is the same size as a normal 1048 pointer. */ 1049 TYPE_LENGTH (type) 1050 = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT; 1051 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR; 1052 } 1053 1054 /* Smash TYPE to be a type of pointer to methods type TO_TYPE. 1055 1056 When "smashing" the type, we preserve the objfile that the old type 1057 pointed to, since we aren't changing where the type is actually 1058 allocated. */ 1059 1060 void 1061 smash_to_methodptr_type (struct type *type, struct type *to_type) 1062 { 1063 smash_type (type); 1064 TYPE_TARGET_TYPE (type) = to_type; 1065 TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type); 1066 TYPE_LENGTH (type) = cplus_method_ptr_size (to_type); 1067 TYPE_CODE (type) = TYPE_CODE_METHODPTR; 1068 } 1069 1070 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE. 1071 METHOD just means `function that gets an extra "this" argument'. 1072 1073 When "smashing" the type, we preserve the objfile that the old type 1074 pointed to, since we aren't changing where the type is actually 1075 allocated. */ 1076 1077 void 1078 smash_to_method_type (struct type *type, struct type *domain, 1079 struct type *to_type, struct field *args, 1080 int nargs, int varargs) 1081 { 1082 smash_type (type); 1083 TYPE_TARGET_TYPE (type) = to_type; 1084 TYPE_DOMAIN_TYPE (type) = domain; 1085 TYPE_FIELDS (type) = args; 1086 TYPE_NFIELDS (type) = nargs; 1087 if (varargs) 1088 TYPE_VARARGS (type) = 1; 1089 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */ 1090 TYPE_CODE (type) = TYPE_CODE_METHOD; 1091 } 1092 1093 /* Return a typename for a struct/union/enum type without "struct ", 1094 "union ", or "enum ". If the type has a NULL name, return NULL. */ 1095 1096 char * 1097 type_name_no_tag (const struct type *type) 1098 { 1099 if (TYPE_TAG_NAME (type) != NULL) 1100 return TYPE_TAG_NAME (type); 1101 1102 /* Is there code which expects this to return the name if there is 1103 no tag name? My guess is that this is mainly used for C++ in 1104 cases where the two will always be the same. */ 1105 return TYPE_NAME (type); 1106 } 1107 1108 /* A wrapper of type_name_no_tag which calls error if the type is anonymous. 1109 Since GCC PR debug/47510 DWARF provides associated information to detect the 1110 anonymous class linkage name from its typedef. 1111 1112 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will 1113 apply it itself. */ 1114 1115 const char * 1116 type_name_no_tag_or_error (struct type *type) 1117 { 1118 struct type *saved_type = type; 1119 const char *name; 1120 struct objfile *objfile; 1121 1122 CHECK_TYPEDEF (type); 1123 1124 name = type_name_no_tag (type); 1125 if (name != NULL) 1126 return name; 1127 1128 name = type_name_no_tag (saved_type); 1129 objfile = TYPE_OBJFILE (saved_type); 1130 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"), 1131 name ? name : "<anonymous>", objfile ? objfile->name : "<arch>"); 1132 } 1133 1134 /* Lookup a typedef or primitive type named NAME, visible in lexical 1135 block BLOCK. If NOERR is nonzero, return zero if NAME is not 1136 suitably defined. */ 1137 1138 struct type * 1139 lookup_typename (const struct language_defn *language, 1140 struct gdbarch *gdbarch, const char *name, 1141 const struct block *block, int noerr) 1142 { 1143 struct symbol *sym; 1144 struct type *tmp; 1145 1146 sym = lookup_symbol (name, block, VAR_DOMAIN, 0); 1147 if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF) 1148 { 1149 tmp = language_lookup_primitive_type_by_name (language, gdbarch, name); 1150 if (tmp) 1151 { 1152 return tmp; 1153 } 1154 else if (!tmp && noerr) 1155 { 1156 return NULL; 1157 } 1158 else 1159 { 1160 error (_("No type named %s."), name); 1161 } 1162 } 1163 return (SYMBOL_TYPE (sym)); 1164 } 1165 1166 struct type * 1167 lookup_unsigned_typename (const struct language_defn *language, 1168 struct gdbarch *gdbarch, char *name) 1169 { 1170 char *uns = alloca (strlen (name) + 10); 1171 1172 strcpy (uns, "unsigned "); 1173 strcpy (uns + 9, name); 1174 return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0); 1175 } 1176 1177 struct type * 1178 lookup_signed_typename (const struct language_defn *language, 1179 struct gdbarch *gdbarch, char *name) 1180 { 1181 struct type *t; 1182 char *uns = alloca (strlen (name) + 8); 1183 1184 strcpy (uns, "signed "); 1185 strcpy (uns + 7, name); 1186 t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1); 1187 /* If we don't find "signed FOO" just try again with plain "FOO". */ 1188 if (t != NULL) 1189 return t; 1190 return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0); 1191 } 1192 1193 /* Lookup a structure type named "struct NAME", 1194 visible in lexical block BLOCK. */ 1195 1196 struct type * 1197 lookup_struct (const char *name, struct block *block) 1198 { 1199 struct symbol *sym; 1200 1201 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0); 1202 1203 if (sym == NULL) 1204 { 1205 error (_("No struct type named %s."), name); 1206 } 1207 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) 1208 { 1209 error (_("This context has class, union or enum %s, not a struct."), 1210 name); 1211 } 1212 return (SYMBOL_TYPE (sym)); 1213 } 1214 1215 /* Lookup a union type named "union NAME", 1216 visible in lexical block BLOCK. */ 1217 1218 struct type * 1219 lookup_union (const char *name, struct block *block) 1220 { 1221 struct symbol *sym; 1222 struct type *t; 1223 1224 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0); 1225 1226 if (sym == NULL) 1227 error (_("No union type named %s."), name); 1228 1229 t = SYMBOL_TYPE (sym); 1230 1231 if (TYPE_CODE (t) == TYPE_CODE_UNION) 1232 return t; 1233 1234 /* If we get here, it's not a union. */ 1235 error (_("This context has class, struct or enum %s, not a union."), 1236 name); 1237 } 1238 1239 1240 /* Lookup an enum type named "enum NAME", 1241 visible in lexical block BLOCK. */ 1242 1243 struct type * 1244 lookup_enum (const char *name, struct block *block) 1245 { 1246 struct symbol *sym; 1247 1248 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0); 1249 if (sym == NULL) 1250 { 1251 error (_("No enum type named %s."), name); 1252 } 1253 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM) 1254 { 1255 error (_("This context has class, struct or union %s, not an enum."), 1256 name); 1257 } 1258 return (SYMBOL_TYPE (sym)); 1259 } 1260 1261 /* Lookup a template type named "template NAME<TYPE>", 1262 visible in lexical block BLOCK. */ 1263 1264 struct type * 1265 lookup_template_type (char *name, struct type *type, 1266 struct block *block) 1267 { 1268 struct symbol *sym; 1269 char *nam = (char *) 1270 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4); 1271 1272 strcpy (nam, name); 1273 strcat (nam, "<"); 1274 strcat (nam, TYPE_NAME (type)); 1275 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */ 1276 1277 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0); 1278 1279 if (sym == NULL) 1280 { 1281 error (_("No template type named %s."), name); 1282 } 1283 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) 1284 { 1285 error (_("This context has class, union or enum %s, not a struct."), 1286 name); 1287 } 1288 return (SYMBOL_TYPE (sym)); 1289 } 1290 1291 /* Given a type TYPE, lookup the type of the component of type named 1292 NAME. 1293 1294 TYPE can be either a struct or union, or a pointer or reference to 1295 a struct or union. If it is a pointer or reference, its target 1296 type is automatically used. Thus '.' and '->' are interchangable, 1297 as specified for the definitions of the expression element types 1298 STRUCTOP_STRUCT and STRUCTOP_PTR. 1299 1300 If NOERR is nonzero, return zero if NAME is not suitably defined. 1301 If NAME is the name of a baseclass type, return that type. */ 1302 1303 struct type * 1304 lookup_struct_elt_type (struct type *type, char *name, int noerr) 1305 { 1306 int i; 1307 char *typename; 1308 1309 for (;;) 1310 { 1311 CHECK_TYPEDEF (type); 1312 if (TYPE_CODE (type) != TYPE_CODE_PTR 1313 && TYPE_CODE (type) != TYPE_CODE_REF) 1314 break; 1315 type = TYPE_TARGET_TYPE (type); 1316 } 1317 1318 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 1319 && TYPE_CODE (type) != TYPE_CODE_UNION) 1320 { 1321 typename = type_to_string (type); 1322 make_cleanup (xfree, typename); 1323 error (_("Type %s is not a structure or union type."), typename); 1324 } 1325 1326 #if 0 1327 /* FIXME: This change put in by Michael seems incorrect for the case 1328 where the structure tag name is the same as the member name. 1329 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int 1330 foo; } bell;" Disabled by fnf. */ 1331 { 1332 char *typename; 1333 1334 typename = type_name_no_tag (type); 1335 if (typename != NULL && strcmp (typename, name) == 0) 1336 return type; 1337 } 1338 #endif 1339 1340 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--) 1341 { 1342 char *t_field_name = TYPE_FIELD_NAME (type, i); 1343 1344 if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) 1345 { 1346 return TYPE_FIELD_TYPE (type, i); 1347 } 1348 else if (!t_field_name || *t_field_name == '\0') 1349 { 1350 struct type *subtype 1351 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1); 1352 1353 if (subtype != NULL) 1354 return subtype; 1355 } 1356 } 1357 1358 /* OK, it's not in this class. Recursively check the baseclasses. */ 1359 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) 1360 { 1361 struct type *t; 1362 1363 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1); 1364 if (t != NULL) 1365 { 1366 return t; 1367 } 1368 } 1369 1370 if (noerr) 1371 { 1372 return NULL; 1373 } 1374 1375 typename = type_to_string (type); 1376 make_cleanup (xfree, typename); 1377 error (_("Type %s has no component named %s."), typename, name); 1378 } 1379 1380 /* Lookup the vptr basetype/fieldno values for TYPE. 1381 If found store vptr_basetype in *BASETYPEP if non-NULL, and return 1382 vptr_fieldno. Also, if found and basetype is from the same objfile, 1383 cache the results. 1384 If not found, return -1 and ignore BASETYPEP. 1385 Callers should be aware that in some cases (for example, 1386 the type or one of its baseclasses is a stub type and we are 1387 debugging a .o file, or the compiler uses DWARF-2 and is not GCC), 1388 this function will not be able to find the 1389 virtual function table pointer, and vptr_fieldno will remain -1 and 1390 vptr_basetype will remain NULL or incomplete. */ 1391 1392 int 1393 get_vptr_fieldno (struct type *type, struct type **basetypep) 1394 { 1395 CHECK_TYPEDEF (type); 1396 1397 if (TYPE_VPTR_FIELDNO (type) < 0) 1398 { 1399 int i; 1400 1401 /* We must start at zero in case the first (and only) baseclass 1402 is virtual (and hence we cannot share the table pointer). */ 1403 for (i = 0; i < TYPE_N_BASECLASSES (type); i++) 1404 { 1405 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); 1406 int fieldno; 1407 struct type *basetype; 1408 1409 fieldno = get_vptr_fieldno (baseclass, &basetype); 1410 if (fieldno >= 0) 1411 { 1412 /* If the type comes from a different objfile we can't cache 1413 it, it may have a different lifetime. PR 2384 */ 1414 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype)) 1415 { 1416 TYPE_VPTR_FIELDNO (type) = fieldno; 1417 TYPE_VPTR_BASETYPE (type) = basetype; 1418 } 1419 if (basetypep) 1420 *basetypep = basetype; 1421 return fieldno; 1422 } 1423 } 1424 1425 /* Not found. */ 1426 return -1; 1427 } 1428 else 1429 { 1430 if (basetypep) 1431 *basetypep = TYPE_VPTR_BASETYPE (type); 1432 return TYPE_VPTR_FIELDNO (type); 1433 } 1434 } 1435 1436 static void 1437 stub_noname_complaint (void) 1438 { 1439 complaint (&symfile_complaints, _("stub type has NULL name")); 1440 } 1441 1442 /* Find the real type of TYPE. This function returns the real type, 1443 after removing all layers of typedefs, and completing opaque or stub 1444 types. Completion changes the TYPE argument, but stripping of 1445 typedefs does not. 1446 1447 Instance flags (e.g. const/volatile) are preserved as typedefs are 1448 stripped. If necessary a new qualified form of the underlying type 1449 is created. 1450 1451 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has 1452 not been computed and we're either in the middle of reading symbols, or 1453 there was no name for the typedef in the debug info. 1454 1455 NOTE: Lookup of opaque types can throw errors for invalid symbol files. 1456 QUITs in the symbol reading code can also throw. 1457 Thus this function can throw an exception. 1458 1459 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of 1460 the target type. 1461 1462 If this is a stubbed struct (i.e. declared as struct foo *), see if 1463 we can find a full definition in some other file. If so, copy this 1464 definition, so we can use it in future. There used to be a comment 1465 (but not any code) that if we don't find a full definition, we'd 1466 set a flag so we don't spend time in the future checking the same 1467 type. That would be a mistake, though--we might load in more 1468 symbols which contain a full definition for the type. */ 1469 1470 struct type * 1471 check_typedef (struct type *type) 1472 { 1473 struct type *orig_type = type; 1474 /* While we're removing typedefs, we don't want to lose qualifiers. 1475 E.g., const/volatile. */ 1476 int instance_flags = TYPE_INSTANCE_FLAGS (type); 1477 1478 gdb_assert (type); 1479 1480 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) 1481 { 1482 if (!TYPE_TARGET_TYPE (type)) 1483 { 1484 char *name; 1485 struct symbol *sym; 1486 1487 /* It is dangerous to call lookup_symbol if we are currently 1488 reading a symtab. Infinite recursion is one danger. */ 1489 if (currently_reading_symtab) 1490 return make_qualified_type (type, instance_flags, NULL); 1491 1492 name = type_name_no_tag (type); 1493 /* FIXME: shouldn't we separately check the TYPE_NAME and 1494 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or 1495 VAR_DOMAIN as appropriate? (this code was written before 1496 TYPE_NAME and TYPE_TAG_NAME were separate). */ 1497 if (name == NULL) 1498 { 1499 stub_noname_complaint (); 1500 return make_qualified_type (type, instance_flags, NULL); 1501 } 1502 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0); 1503 if (sym) 1504 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym); 1505 else /* TYPE_CODE_UNDEF */ 1506 TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type)); 1507 } 1508 type = TYPE_TARGET_TYPE (type); 1509 1510 /* Preserve the instance flags as we traverse down the typedef chain. 1511 1512 Handling address spaces/classes is nasty, what do we do if there's a 1513 conflict? 1514 E.g., what if an outer typedef marks the type as class_1 and an inner 1515 typedef marks the type as class_2? 1516 This is the wrong place to do such error checking. We leave it to 1517 the code that created the typedef in the first place to flag the 1518 error. We just pick the outer address space (akin to letting the 1519 outer cast in a chain of casting win), instead of assuming 1520 "it can't happen". */ 1521 { 1522 const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE 1523 | TYPE_INSTANCE_FLAG_DATA_SPACE); 1524 const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL; 1525 int new_instance_flags = TYPE_INSTANCE_FLAGS (type); 1526 1527 /* Treat code vs data spaces and address classes separately. */ 1528 if ((instance_flags & ALL_SPACES) != 0) 1529 new_instance_flags &= ~ALL_SPACES; 1530 if ((instance_flags & ALL_CLASSES) != 0) 1531 new_instance_flags &= ~ALL_CLASSES; 1532 1533 instance_flags |= new_instance_flags; 1534 } 1535 } 1536 1537 /* If this is a struct/class/union with no fields, then check 1538 whether a full definition exists somewhere else. This is for 1539 systems where a type definition with no fields is issued for such 1540 types, instead of identifying them as stub types in the first 1541 place. */ 1542 1543 if (TYPE_IS_OPAQUE (type) 1544 && opaque_type_resolution 1545 && !currently_reading_symtab) 1546 { 1547 char *name = type_name_no_tag (type); 1548 struct type *newtype; 1549 1550 if (name == NULL) 1551 { 1552 stub_noname_complaint (); 1553 return make_qualified_type (type, instance_flags, NULL); 1554 } 1555 newtype = lookup_transparent_type (name); 1556 1557 if (newtype) 1558 { 1559 /* If the resolved type and the stub are in the same 1560 objfile, then replace the stub type with the real deal. 1561 But if they're in separate objfiles, leave the stub 1562 alone; we'll just look up the transparent type every time 1563 we call check_typedef. We can't create pointers between 1564 types allocated to different objfiles, since they may 1565 have different lifetimes. Trying to copy NEWTYPE over to 1566 TYPE's objfile is pointless, too, since you'll have to 1567 move over any other types NEWTYPE refers to, which could 1568 be an unbounded amount of stuff. */ 1569 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type)) 1570 type = make_qualified_type (newtype, 1571 TYPE_INSTANCE_FLAGS (type), 1572 type); 1573 else 1574 type = newtype; 1575 } 1576 } 1577 /* Otherwise, rely on the stub flag being set for opaque/stubbed 1578 types. */ 1579 else if (TYPE_STUB (type) && !currently_reading_symtab) 1580 { 1581 char *name = type_name_no_tag (type); 1582 /* FIXME: shouldn't we separately check the TYPE_NAME and the 1583 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN 1584 as appropriate? (this code was written before TYPE_NAME and 1585 TYPE_TAG_NAME were separate). */ 1586 struct symbol *sym; 1587 1588 if (name == NULL) 1589 { 1590 stub_noname_complaint (); 1591 return make_qualified_type (type, instance_flags, NULL); 1592 } 1593 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0); 1594 if (sym) 1595 { 1596 /* Same as above for opaque types, we can replace the stub 1597 with the complete type only if they are in the same 1598 objfile. */ 1599 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type)) 1600 type = make_qualified_type (SYMBOL_TYPE (sym), 1601 TYPE_INSTANCE_FLAGS (type), 1602 type); 1603 else 1604 type = SYMBOL_TYPE (sym); 1605 } 1606 } 1607 1608 if (TYPE_TARGET_STUB (type)) 1609 { 1610 struct type *range_type; 1611 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type)); 1612 1613 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type)) 1614 { 1615 /* Nothing we can do. */ 1616 } 1617 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY 1618 && TYPE_NFIELDS (type) == 1 1619 && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type)) 1620 == TYPE_CODE_RANGE)) 1621 { 1622 /* Now recompute the length of the array type, based on its 1623 number of elements and the target type's length. 1624 Watch out for Ada null Ada arrays where the high bound 1625 is smaller than the low bound. */ 1626 const LONGEST low_bound = TYPE_LOW_BOUND (range_type); 1627 const LONGEST high_bound = TYPE_HIGH_BOUND (range_type); 1628 ULONGEST len; 1629 1630 if (high_bound < low_bound) 1631 len = 0; 1632 else 1633 { 1634 /* For now, we conservatively take the array length to be 0 1635 if its length exceeds UINT_MAX. The code below assumes 1636 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1, 1637 which is technically not guaranteed by C, but is usually true 1638 (because it would be true if x were unsigned with its 1639 high-order bit on). It uses the fact that 1640 high_bound-low_bound is always representable in 1641 ULONGEST and that if high_bound-low_bound+1 overflows, 1642 it overflows to 0. We must change these tests if we 1643 decide to increase the representation of TYPE_LENGTH 1644 from unsigned int to ULONGEST. */ 1645 ULONGEST ulow = low_bound, uhigh = high_bound; 1646 ULONGEST tlen = TYPE_LENGTH (target_type); 1647 1648 len = tlen * (uhigh - ulow + 1); 1649 if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh 1650 || len > UINT_MAX) 1651 len = 0; 1652 } 1653 TYPE_LENGTH (type) = len; 1654 TYPE_TARGET_STUB (type) = 0; 1655 } 1656 else if (TYPE_CODE (type) == TYPE_CODE_RANGE) 1657 { 1658 TYPE_LENGTH (type) = TYPE_LENGTH (target_type); 1659 TYPE_TARGET_STUB (type) = 0; 1660 } 1661 } 1662 1663 type = make_qualified_type (type, instance_flags, NULL); 1664 1665 /* Cache TYPE_LENGTH for future use. */ 1666 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type); 1667 1668 return type; 1669 } 1670 1671 /* Parse a type expression in the string [P..P+LENGTH). If an error 1672 occurs, silently return a void type. */ 1673 1674 static struct type * 1675 safe_parse_type (struct gdbarch *gdbarch, char *p, int length) 1676 { 1677 struct ui_file *saved_gdb_stderr; 1678 struct type *type; 1679 1680 /* Suppress error messages. */ 1681 saved_gdb_stderr = gdb_stderr; 1682 gdb_stderr = ui_file_new (); 1683 1684 /* Call parse_and_eval_type() without fear of longjmp()s. */ 1685 if (!gdb_parse_and_eval_type (p, length, &type)) 1686 type = builtin_type (gdbarch)->builtin_void; 1687 1688 /* Stop suppressing error messages. */ 1689 ui_file_delete (gdb_stderr); 1690 gdb_stderr = saved_gdb_stderr; 1691 1692 return type; 1693 } 1694 1695 /* Ugly hack to convert method stubs into method types. 1696 1697 He ain't kiddin'. This demangles the name of the method into a 1698 string including argument types, parses out each argument type, 1699 generates a string casting a zero to that type, evaluates the 1700 string, and stuffs the resulting type into an argtype vector!!! 1701 Then it knows the type of the whole function (including argument 1702 types for overloading), which info used to be in the stab's but was 1703 removed to hack back the space required for them. */ 1704 1705 static void 1706 check_stub_method (struct type *type, int method_id, int signature_id) 1707 { 1708 struct gdbarch *gdbarch = get_type_arch (type); 1709 struct fn_field *f; 1710 char *mangled_name = gdb_mangle_name (type, method_id, signature_id); 1711 char *demangled_name = cplus_demangle (mangled_name, 1712 DMGL_PARAMS | DMGL_ANSI); 1713 char *argtypetext, *p; 1714 int depth = 0, argcount = 1; 1715 struct field *argtypes; 1716 struct type *mtype; 1717 1718 /* Make sure we got back a function string that we can use. */ 1719 if (demangled_name) 1720 p = strchr (demangled_name, '('); 1721 else 1722 p = NULL; 1723 1724 if (demangled_name == NULL || p == NULL) 1725 error (_("Internal: Cannot demangle mangled name `%s'."), 1726 mangled_name); 1727 1728 /* Now, read in the parameters that define this type. */ 1729 p += 1; 1730 argtypetext = p; 1731 while (*p) 1732 { 1733 if (*p == '(' || *p == '<') 1734 { 1735 depth += 1; 1736 } 1737 else if (*p == ')' || *p == '>') 1738 { 1739 depth -= 1; 1740 } 1741 else if (*p == ',' && depth == 0) 1742 { 1743 argcount += 1; 1744 } 1745 1746 p += 1; 1747 } 1748 1749 /* If we read one argument and it was ``void'', don't count it. */ 1750 if (strncmp (argtypetext, "(void)", 6) == 0) 1751 argcount -= 1; 1752 1753 /* We need one extra slot, for the THIS pointer. */ 1754 1755 argtypes = (struct field *) 1756 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field)); 1757 p = argtypetext; 1758 1759 /* Add THIS pointer for non-static methods. */ 1760 f = TYPE_FN_FIELDLIST1 (type, method_id); 1761 if (TYPE_FN_FIELD_STATIC_P (f, signature_id)) 1762 argcount = 0; 1763 else 1764 { 1765 argtypes[0].type = lookup_pointer_type (type); 1766 argcount = 1; 1767 } 1768 1769 if (*p != ')') /* () means no args, skip while. */ 1770 { 1771 depth = 0; 1772 while (*p) 1773 { 1774 if (depth <= 0 && (*p == ',' || *p == ')')) 1775 { 1776 /* Avoid parsing of ellipsis, they will be handled below. 1777 Also avoid ``void'' as above. */ 1778 if (strncmp (argtypetext, "...", p - argtypetext) != 0 1779 && strncmp (argtypetext, "void", p - argtypetext) != 0) 1780 { 1781 argtypes[argcount].type = 1782 safe_parse_type (gdbarch, argtypetext, p - argtypetext); 1783 argcount += 1; 1784 } 1785 argtypetext = p + 1; 1786 } 1787 1788 if (*p == '(' || *p == '<') 1789 { 1790 depth += 1; 1791 } 1792 else if (*p == ')' || *p == '>') 1793 { 1794 depth -= 1; 1795 } 1796 1797 p += 1; 1798 } 1799 } 1800 1801 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name; 1802 1803 /* Now update the old "stub" type into a real type. */ 1804 mtype = TYPE_FN_FIELD_TYPE (f, signature_id); 1805 TYPE_DOMAIN_TYPE (mtype) = type; 1806 TYPE_FIELDS (mtype) = argtypes; 1807 TYPE_NFIELDS (mtype) = argcount; 1808 TYPE_STUB (mtype) = 0; 1809 TYPE_FN_FIELD_STUB (f, signature_id) = 0; 1810 if (p[-2] == '.') 1811 TYPE_VARARGS (mtype) = 1; 1812 1813 xfree (demangled_name); 1814 } 1815 1816 /* This is the external interface to check_stub_method, above. This 1817 function unstubs all of the signatures for TYPE's METHOD_ID method 1818 name. After calling this function TYPE_FN_FIELD_STUB will be 1819 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be 1820 correct. 1821 1822 This function unfortunately can not die until stabs do. */ 1823 1824 void 1825 check_stub_method_group (struct type *type, int method_id) 1826 { 1827 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id); 1828 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id); 1829 int j, found_stub = 0; 1830 1831 for (j = 0; j < len; j++) 1832 if (TYPE_FN_FIELD_STUB (f, j)) 1833 { 1834 found_stub = 1; 1835 check_stub_method (type, method_id, j); 1836 } 1837 1838 /* GNU v3 methods with incorrect names were corrected when we read 1839 in type information, because it was cheaper to do it then. The 1840 only GNU v2 methods with incorrect method names are operators and 1841 destructors; destructors were also corrected when we read in type 1842 information. 1843 1844 Therefore the only thing we need to handle here are v2 operator 1845 names. */ 1846 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0) 1847 { 1848 int ret; 1849 char dem_opname[256]; 1850 1851 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, 1852 method_id), 1853 dem_opname, DMGL_ANSI); 1854 if (!ret) 1855 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, 1856 method_id), 1857 dem_opname, 0); 1858 if (ret) 1859 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname); 1860 } 1861 } 1862 1863 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */ 1864 const struct cplus_struct_type cplus_struct_default = { }; 1865 1866 void 1867 allocate_cplus_struct_type (struct type *type) 1868 { 1869 if (HAVE_CPLUS_STRUCT (type)) 1870 /* Structure was already allocated. Nothing more to do. */ 1871 return; 1872 1873 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF; 1874 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *) 1875 TYPE_ALLOC (type, sizeof (struct cplus_struct_type)); 1876 *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default; 1877 } 1878 1879 const struct gnat_aux_type gnat_aux_default = 1880 { NULL }; 1881 1882 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF, 1883 and allocate the associated gnat-specific data. The gnat-specific 1884 data is also initialized to gnat_aux_default. */ 1885 void 1886 allocate_gnat_aux_type (struct type *type) 1887 { 1888 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF; 1889 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *) 1890 TYPE_ALLOC (type, sizeof (struct gnat_aux_type)); 1891 *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default; 1892 } 1893 1894 1895 /* Helper function to initialize the standard scalar types. 1896 1897 If NAME is non-NULL, then we make a copy of the string pointed 1898 to by name in the objfile_obstack for that objfile, and initialize 1899 the type name to that copy. There are places (mipsread.c in particular), 1900 where init_type is called with a NULL value for NAME). */ 1901 1902 struct type * 1903 init_type (enum type_code code, int length, int flags, 1904 char *name, struct objfile *objfile) 1905 { 1906 struct type *type; 1907 1908 type = alloc_type (objfile); 1909 TYPE_CODE (type) = code; 1910 TYPE_LENGTH (type) = length; 1911 1912 gdb_assert (!(flags & (TYPE_FLAG_MIN - 1))); 1913 if (flags & TYPE_FLAG_UNSIGNED) 1914 TYPE_UNSIGNED (type) = 1; 1915 if (flags & TYPE_FLAG_NOSIGN) 1916 TYPE_NOSIGN (type) = 1; 1917 if (flags & TYPE_FLAG_STUB) 1918 TYPE_STUB (type) = 1; 1919 if (flags & TYPE_FLAG_TARGET_STUB) 1920 TYPE_TARGET_STUB (type) = 1; 1921 if (flags & TYPE_FLAG_STATIC) 1922 TYPE_STATIC (type) = 1; 1923 if (flags & TYPE_FLAG_PROTOTYPED) 1924 TYPE_PROTOTYPED (type) = 1; 1925 if (flags & TYPE_FLAG_INCOMPLETE) 1926 TYPE_INCOMPLETE (type) = 1; 1927 if (flags & TYPE_FLAG_VARARGS) 1928 TYPE_VARARGS (type) = 1; 1929 if (flags & TYPE_FLAG_VECTOR) 1930 TYPE_VECTOR (type) = 1; 1931 if (flags & TYPE_FLAG_STUB_SUPPORTED) 1932 TYPE_STUB_SUPPORTED (type) = 1; 1933 if (flags & TYPE_FLAG_FIXED_INSTANCE) 1934 TYPE_FIXED_INSTANCE (type) = 1; 1935 if (flags & TYPE_FLAG_GNU_IFUNC) 1936 TYPE_GNU_IFUNC (type) = 1; 1937 1938 if (name) 1939 TYPE_NAME (type) = obsavestring (name, strlen (name), 1940 &objfile->objfile_obstack); 1941 1942 /* C++ fancies. */ 1943 1944 if (name && strcmp (name, "char") == 0) 1945 TYPE_NOSIGN (type) = 1; 1946 1947 switch (code) 1948 { 1949 case TYPE_CODE_STRUCT: 1950 case TYPE_CODE_UNION: 1951 case TYPE_CODE_NAMESPACE: 1952 INIT_CPLUS_SPECIFIC (type); 1953 break; 1954 case TYPE_CODE_FLT: 1955 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT; 1956 break; 1957 case TYPE_CODE_FUNC: 1958 INIT_FUNC_SPECIFIC (type); 1959 break; 1960 } 1961 return type; 1962 } 1963 1964 int 1965 can_dereference (struct type *t) 1966 { 1967 /* FIXME: Should we return true for references as well as 1968 pointers? */ 1969 CHECK_TYPEDEF (t); 1970 return 1971 (t != NULL 1972 && TYPE_CODE (t) == TYPE_CODE_PTR 1973 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID); 1974 } 1975 1976 int 1977 is_integral_type (struct type *t) 1978 { 1979 CHECK_TYPEDEF (t); 1980 return 1981 ((t != NULL) 1982 && ((TYPE_CODE (t) == TYPE_CODE_INT) 1983 || (TYPE_CODE (t) == TYPE_CODE_ENUM) 1984 || (TYPE_CODE (t) == TYPE_CODE_FLAGS) 1985 || (TYPE_CODE (t) == TYPE_CODE_CHAR) 1986 || (TYPE_CODE (t) == TYPE_CODE_RANGE) 1987 || (TYPE_CODE (t) == TYPE_CODE_BOOL))); 1988 } 1989 1990 /* Return true if TYPE is scalar. */ 1991 1992 static int 1993 is_scalar_type (struct type *type) 1994 { 1995 CHECK_TYPEDEF (type); 1996 1997 switch (TYPE_CODE (type)) 1998 { 1999 case TYPE_CODE_ARRAY: 2000 case TYPE_CODE_STRUCT: 2001 case TYPE_CODE_UNION: 2002 case TYPE_CODE_SET: 2003 case TYPE_CODE_STRING: 2004 case TYPE_CODE_BITSTRING: 2005 return 0; 2006 default: 2007 return 1; 2008 } 2009 } 2010 2011 /* Return true if T is scalar, or a composite type which in practice has 2012 the memory layout of a scalar type. E.g., an array or struct with only 2013 one scalar element inside it, or a union with only scalar elements. */ 2014 2015 int 2016 is_scalar_type_recursive (struct type *t) 2017 { 2018 CHECK_TYPEDEF (t); 2019 2020 if (is_scalar_type (t)) 2021 return 1; 2022 /* Are we dealing with an array or string of known dimensions? */ 2023 else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY 2024 || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1 2025 && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE) 2026 { 2027 LONGEST low_bound, high_bound; 2028 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t)); 2029 2030 get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound); 2031 2032 return high_bound == low_bound && is_scalar_type_recursive (elt_type); 2033 } 2034 /* Are we dealing with a struct with one element? */ 2035 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1) 2036 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0)); 2037 else if (TYPE_CODE (t) == TYPE_CODE_UNION) 2038 { 2039 int i, n = TYPE_NFIELDS (t); 2040 2041 /* If all elements of the union are scalar, then the union is scalar. */ 2042 for (i = 0; i < n; i++) 2043 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i))) 2044 return 0; 2045 2046 return 1; 2047 } 2048 2049 return 0; 2050 } 2051 2052 /* A helper function which returns true if types A and B represent the 2053 "same" class type. This is true if the types have the same main 2054 type, or the same name. */ 2055 2056 int 2057 class_types_same_p (const struct type *a, const struct type *b) 2058 { 2059 return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b) 2060 || (TYPE_NAME (a) && TYPE_NAME (b) 2061 && !strcmp (TYPE_NAME (a), TYPE_NAME (b)))); 2062 } 2063 2064 /* If BASE is an ancestor of DCLASS return the distance between them. 2065 otherwise return -1; 2066 eg: 2067 2068 class A {}; 2069 class B: public A {}; 2070 class C: public B {}; 2071 class D: C {}; 2072 2073 distance_to_ancestor (A, A, 0) = 0 2074 distance_to_ancestor (A, B, 0) = 1 2075 distance_to_ancestor (A, C, 0) = 2 2076 distance_to_ancestor (A, D, 0) = 3 2077 2078 If PUBLIC is 1 then only public ancestors are considered, 2079 and the function returns the distance only if BASE is a public ancestor 2080 of DCLASS. 2081 Eg: 2082 2083 distance_to_ancestor (A, D, 1) = -1. */ 2084 2085 static int 2086 distance_to_ancestor (struct type *base, struct type *dclass, int public) 2087 { 2088 int i; 2089 int d; 2090 2091 CHECK_TYPEDEF (base); 2092 CHECK_TYPEDEF (dclass); 2093 2094 if (class_types_same_p (base, dclass)) 2095 return 0; 2096 2097 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++) 2098 { 2099 if (public && ! BASETYPE_VIA_PUBLIC (dclass, i)) 2100 continue; 2101 2102 d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public); 2103 if (d >= 0) 2104 return 1 + d; 2105 } 2106 2107 return -1; 2108 } 2109 2110 /* Check whether BASE is an ancestor or base class or DCLASS 2111 Return 1 if so, and 0 if not. 2112 Note: If BASE and DCLASS are of the same type, this function 2113 will return 1. So for some class A, is_ancestor (A, A) will 2114 return 1. */ 2115 2116 int 2117 is_ancestor (struct type *base, struct type *dclass) 2118 { 2119 return distance_to_ancestor (base, dclass, 0) >= 0; 2120 } 2121 2122 /* Like is_ancestor, but only returns true when BASE is a public 2123 ancestor of DCLASS. */ 2124 2125 int 2126 is_public_ancestor (struct type *base, struct type *dclass) 2127 { 2128 return distance_to_ancestor (base, dclass, 1) >= 0; 2129 } 2130 2131 /* A helper function for is_unique_ancestor. */ 2132 2133 static int 2134 is_unique_ancestor_worker (struct type *base, struct type *dclass, 2135 int *offset, 2136 const gdb_byte *valaddr, int embedded_offset, 2137 CORE_ADDR address, struct value *val) 2138 { 2139 int i, count = 0; 2140 2141 CHECK_TYPEDEF (base); 2142 CHECK_TYPEDEF (dclass); 2143 2144 for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i) 2145 { 2146 struct type *iter; 2147 int this_offset; 2148 2149 iter = check_typedef (TYPE_BASECLASS (dclass, i)); 2150 2151 this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset, 2152 address, val); 2153 2154 if (class_types_same_p (base, iter)) 2155 { 2156 /* If this is the first subclass, set *OFFSET and set count 2157 to 1. Otherwise, if this is at the same offset as 2158 previous instances, do nothing. Otherwise, increment 2159 count. */ 2160 if (*offset == -1) 2161 { 2162 *offset = this_offset; 2163 count = 1; 2164 } 2165 else if (this_offset == *offset) 2166 { 2167 /* Nothing. */ 2168 } 2169 else 2170 ++count; 2171 } 2172 else 2173 count += is_unique_ancestor_worker (base, iter, offset, 2174 valaddr, 2175 embedded_offset + this_offset, 2176 address, val); 2177 } 2178 2179 return count; 2180 } 2181 2182 /* Like is_ancestor, but only returns true if BASE is a unique base 2183 class of the type of VAL. */ 2184 2185 int 2186 is_unique_ancestor (struct type *base, struct value *val) 2187 { 2188 int offset = -1; 2189 2190 return is_unique_ancestor_worker (base, value_type (val), &offset, 2191 value_contents_for_printing (val), 2192 value_embedded_offset (val), 2193 value_address (val), val) == 1; 2194 } 2195 2196 2197 2198 /* Return the sum of the rank of A with the rank of B. */ 2199 2200 struct rank 2201 sum_ranks (struct rank a, struct rank b) 2202 { 2203 struct rank c; 2204 c.rank = a.rank + b.rank; 2205 c.subrank = a.subrank + b.subrank; 2206 return c; 2207 } 2208 2209 /* Compare rank A and B and return: 2210 0 if a = b 2211 1 if a is better than b 2212 -1 if b is better than a. */ 2213 2214 int 2215 compare_ranks (struct rank a, struct rank b) 2216 { 2217 if (a.rank == b.rank) 2218 { 2219 if (a.subrank == b.subrank) 2220 return 0; 2221 if (a.subrank < b.subrank) 2222 return 1; 2223 if (a.subrank > b.subrank) 2224 return -1; 2225 } 2226 2227 if (a.rank < b.rank) 2228 return 1; 2229 2230 /* a.rank > b.rank */ 2231 return -1; 2232 } 2233 2234 /* Functions for overload resolution begin here. */ 2235 2236 /* Compare two badness vectors A and B and return the result. 2237 0 => A and B are identical 2238 1 => A and B are incomparable 2239 2 => A is better than B 2240 3 => A is worse than B */ 2241 2242 int 2243 compare_badness (struct badness_vector *a, struct badness_vector *b) 2244 { 2245 int i; 2246 int tmp; 2247 short found_pos = 0; /* any positives in c? */ 2248 short found_neg = 0; /* any negatives in c? */ 2249 2250 /* differing lengths => incomparable */ 2251 if (a->length != b->length) 2252 return 1; 2253 2254 /* Subtract b from a */ 2255 for (i = 0; i < a->length; i++) 2256 { 2257 tmp = compare_ranks (b->rank[i], a->rank[i]); 2258 if (tmp > 0) 2259 found_pos = 1; 2260 else if (tmp < 0) 2261 found_neg = 1; 2262 } 2263 2264 if (found_pos) 2265 { 2266 if (found_neg) 2267 return 1; /* incomparable */ 2268 else 2269 return 3; /* A > B */ 2270 } 2271 else 2272 /* no positives */ 2273 { 2274 if (found_neg) 2275 return 2; /* A < B */ 2276 else 2277 return 0; /* A == B */ 2278 } 2279 } 2280 2281 /* Rank a function by comparing its parameter types (PARMS, length 2282 NPARMS), to the types of an argument list (ARGS, length NARGS). 2283 Return a pointer to a badness vector. This has NARGS + 1 2284 entries. */ 2285 2286 struct badness_vector * 2287 rank_function (struct type **parms, int nparms, 2288 struct value **args, int nargs) 2289 { 2290 int i; 2291 struct badness_vector *bv; 2292 int min_len = nparms < nargs ? nparms : nargs; 2293 2294 bv = xmalloc (sizeof (struct badness_vector)); 2295 bv->length = nargs + 1; /* add 1 for the length-match rank. */ 2296 bv->rank = xmalloc ((nargs + 1) * sizeof (int)); 2297 2298 /* First compare the lengths of the supplied lists. 2299 If there is a mismatch, set it to a high value. */ 2300 2301 /* pai/1997-06-03 FIXME: when we have debug info about default 2302 arguments and ellipsis parameter lists, we should consider those 2303 and rank the length-match more finely. */ 2304 2305 LENGTH_MATCH (bv) = (nargs != nparms) 2306 ? LENGTH_MISMATCH_BADNESS 2307 : EXACT_MATCH_BADNESS; 2308 2309 /* Now rank all the parameters of the candidate function. */ 2310 for (i = 1; i <= min_len; i++) 2311 bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]), 2312 args[i - 1]); 2313 2314 /* If more arguments than parameters, add dummy entries. */ 2315 for (i = min_len + 1; i <= nargs; i++) 2316 bv->rank[i] = TOO_FEW_PARAMS_BADNESS; 2317 2318 return bv; 2319 } 2320 2321 /* Compare the names of two integer types, assuming that any sign 2322 qualifiers have been checked already. We do it this way because 2323 there may be an "int" in the name of one of the types. */ 2324 2325 static int 2326 integer_types_same_name_p (const char *first, const char *second) 2327 { 2328 int first_p, second_p; 2329 2330 /* If both are shorts, return 1; if neither is a short, keep 2331 checking. */ 2332 first_p = (strstr (first, "short") != NULL); 2333 second_p = (strstr (second, "short") != NULL); 2334 if (first_p && second_p) 2335 return 1; 2336 if (first_p || second_p) 2337 return 0; 2338 2339 /* Likewise for long. */ 2340 first_p = (strstr (first, "long") != NULL); 2341 second_p = (strstr (second, "long") != NULL); 2342 if (first_p && second_p) 2343 return 1; 2344 if (first_p || second_p) 2345 return 0; 2346 2347 /* Likewise for char. */ 2348 first_p = (strstr (first, "char") != NULL); 2349 second_p = (strstr (second, "char") != NULL); 2350 if (first_p && second_p) 2351 return 1; 2352 if (first_p || second_p) 2353 return 0; 2354 2355 /* They must both be ints. */ 2356 return 1; 2357 } 2358 2359 /* Compares type A to type B returns 1 if the represent the same type 2360 0 otherwise. */ 2361 2362 static int 2363 types_equal (struct type *a, struct type *b) 2364 { 2365 /* Identical type pointers. */ 2366 /* However, this still doesn't catch all cases of same type for b 2367 and a. The reason is that builtin types are different from 2368 the same ones constructed from the object. */ 2369 if (a == b) 2370 return 1; 2371 2372 /* Resolve typedefs */ 2373 if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF) 2374 a = check_typedef (a); 2375 if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF) 2376 b = check_typedef (b); 2377 2378 /* If after resolving typedefs a and b are not of the same type 2379 code then they are not equal. */ 2380 if (TYPE_CODE (a) != TYPE_CODE (b)) 2381 return 0; 2382 2383 /* If a and b are both pointers types or both reference types then 2384 they are equal of the same type iff the objects they refer to are 2385 of the same type. */ 2386 if (TYPE_CODE (a) == TYPE_CODE_PTR 2387 || TYPE_CODE (a) == TYPE_CODE_REF) 2388 return types_equal (TYPE_TARGET_TYPE (a), 2389 TYPE_TARGET_TYPE (b)); 2390 2391 /* Well, damnit, if the names are exactly the same, I'll say they 2392 are exactly the same. This happens when we generate method 2393 stubs. The types won't point to the same address, but they 2394 really are the same. */ 2395 2396 if (TYPE_NAME (a) && TYPE_NAME (b) 2397 && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0) 2398 return 1; 2399 2400 /* Check if identical after resolving typedefs. */ 2401 if (a == b) 2402 return 1; 2403 2404 return 0; 2405 } 2406 2407 /* Compare one type (PARM) for compatibility with another (ARG). 2408 * PARM is intended to be the parameter type of a function; and 2409 * ARG is the supplied argument's type. This function tests if 2410 * the latter can be converted to the former. 2411 * VALUE is the argument's value or NULL if none (or called recursively) 2412 * 2413 * Return 0 if they are identical types; 2414 * Otherwise, return an integer which corresponds to how compatible 2415 * PARM is to ARG. The higher the return value, the worse the match. 2416 * Generally the "bad" conversions are all uniformly assigned a 100. */ 2417 2418 struct rank 2419 rank_one_type (struct type *parm, struct type *arg, struct value *value) 2420 { 2421 struct rank rank = {0,0}; 2422 2423 if (types_equal (parm, arg)) 2424 return EXACT_MATCH_BADNESS; 2425 2426 /* Resolve typedefs */ 2427 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF) 2428 parm = check_typedef (parm); 2429 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF) 2430 arg = check_typedef (arg); 2431 2432 /* See through references, since we can almost make non-references 2433 references. */ 2434 if (TYPE_CODE (arg) == TYPE_CODE_REF) 2435 return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL), 2436 REFERENCE_CONVERSION_BADNESS)); 2437 if (TYPE_CODE (parm) == TYPE_CODE_REF) 2438 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL), 2439 REFERENCE_CONVERSION_BADNESS)); 2440 if (overload_debug) 2441 /* Debugging only. */ 2442 fprintf_filtered (gdb_stderr, 2443 "------ Arg is %s [%d], parm is %s [%d]\n", 2444 TYPE_NAME (arg), TYPE_CODE (arg), 2445 TYPE_NAME (parm), TYPE_CODE (parm)); 2446 2447 /* x -> y means arg of type x being supplied for parameter of type y. */ 2448 2449 switch (TYPE_CODE (parm)) 2450 { 2451 case TYPE_CODE_PTR: 2452 switch (TYPE_CODE (arg)) 2453 { 2454 case TYPE_CODE_PTR: 2455 2456 /* Allowed pointer conversions are: 2457 (a) pointer to void-pointer conversion. */ 2458 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID) 2459 return VOID_PTR_CONVERSION_BADNESS; 2460 2461 /* (b) pointer to ancestor-pointer conversion. */ 2462 rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm), 2463 TYPE_TARGET_TYPE (arg), 2464 0); 2465 if (rank.subrank >= 0) 2466 return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank); 2467 2468 return INCOMPATIBLE_TYPE_BADNESS; 2469 case TYPE_CODE_ARRAY: 2470 if (types_equal (TYPE_TARGET_TYPE (parm), 2471 TYPE_TARGET_TYPE (arg))) 2472 return EXACT_MATCH_BADNESS; 2473 return INCOMPATIBLE_TYPE_BADNESS; 2474 case TYPE_CODE_FUNC: 2475 return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL); 2476 case TYPE_CODE_INT: 2477 if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT 2478 && value_as_long (value) == 0) 2479 { 2480 /* Null pointer conversion: allow it to be cast to a pointer. 2481 [4.10.1 of C++ standard draft n3290] */ 2482 return NULL_POINTER_CONVERSION_BADNESS; 2483 } 2484 /* fall through */ 2485 case TYPE_CODE_ENUM: 2486 case TYPE_CODE_FLAGS: 2487 case TYPE_CODE_CHAR: 2488 case TYPE_CODE_RANGE: 2489 case TYPE_CODE_BOOL: 2490 default: 2491 return INCOMPATIBLE_TYPE_BADNESS; 2492 } 2493 case TYPE_CODE_ARRAY: 2494 switch (TYPE_CODE (arg)) 2495 { 2496 case TYPE_CODE_PTR: 2497 case TYPE_CODE_ARRAY: 2498 return rank_one_type (TYPE_TARGET_TYPE (parm), 2499 TYPE_TARGET_TYPE (arg), NULL); 2500 default: 2501 return INCOMPATIBLE_TYPE_BADNESS; 2502 } 2503 case TYPE_CODE_FUNC: 2504 switch (TYPE_CODE (arg)) 2505 { 2506 case TYPE_CODE_PTR: /* funcptr -> func */ 2507 return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL); 2508 default: 2509 return INCOMPATIBLE_TYPE_BADNESS; 2510 } 2511 case TYPE_CODE_INT: 2512 switch (TYPE_CODE (arg)) 2513 { 2514 case TYPE_CODE_INT: 2515 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm)) 2516 { 2517 /* Deal with signed, unsigned, and plain chars and 2518 signed and unsigned ints. */ 2519 if (TYPE_NOSIGN (parm)) 2520 { 2521 /* This case only for character types. */ 2522 if (TYPE_NOSIGN (arg)) 2523 return EXACT_MATCH_BADNESS; /* plain char -> plain char */ 2524 else /* signed/unsigned char -> plain char */ 2525 return INTEGER_CONVERSION_BADNESS; 2526 } 2527 else if (TYPE_UNSIGNED (parm)) 2528 { 2529 if (TYPE_UNSIGNED (arg)) 2530 { 2531 /* unsigned int -> unsigned int, or 2532 unsigned long -> unsigned long */ 2533 if (integer_types_same_name_p (TYPE_NAME (parm), 2534 TYPE_NAME (arg))) 2535 return EXACT_MATCH_BADNESS; 2536 else if (integer_types_same_name_p (TYPE_NAME (arg), 2537 "int") 2538 && integer_types_same_name_p (TYPE_NAME (parm), 2539 "long")) 2540 /* unsigned int -> unsigned long */ 2541 return INTEGER_PROMOTION_BADNESS; 2542 else 2543 /* unsigned long -> unsigned int */ 2544 return INTEGER_CONVERSION_BADNESS; 2545 } 2546 else 2547 { 2548 if (integer_types_same_name_p (TYPE_NAME (arg), 2549 "long") 2550 && integer_types_same_name_p (TYPE_NAME (parm), 2551 "int")) 2552 /* signed long -> unsigned int */ 2553 return INTEGER_CONVERSION_BADNESS; 2554 else 2555 /* signed int/long -> unsigned int/long */ 2556 return INTEGER_CONVERSION_BADNESS; 2557 } 2558 } 2559 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg)) 2560 { 2561 if (integer_types_same_name_p (TYPE_NAME (parm), 2562 TYPE_NAME (arg))) 2563 return EXACT_MATCH_BADNESS; 2564 else if (integer_types_same_name_p (TYPE_NAME (arg), 2565 "int") 2566 && integer_types_same_name_p (TYPE_NAME (parm), 2567 "long")) 2568 return INTEGER_PROMOTION_BADNESS; 2569 else 2570 return INTEGER_CONVERSION_BADNESS; 2571 } 2572 else 2573 return INTEGER_CONVERSION_BADNESS; 2574 } 2575 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm)) 2576 return INTEGER_PROMOTION_BADNESS; 2577 else 2578 return INTEGER_CONVERSION_BADNESS; 2579 case TYPE_CODE_ENUM: 2580 case TYPE_CODE_FLAGS: 2581 case TYPE_CODE_CHAR: 2582 case TYPE_CODE_RANGE: 2583 case TYPE_CODE_BOOL: 2584 return INTEGER_PROMOTION_BADNESS; 2585 case TYPE_CODE_FLT: 2586 return INT_FLOAT_CONVERSION_BADNESS; 2587 case TYPE_CODE_PTR: 2588 return NS_POINTER_CONVERSION_BADNESS; 2589 default: 2590 return INCOMPATIBLE_TYPE_BADNESS; 2591 } 2592 break; 2593 case TYPE_CODE_ENUM: 2594 switch (TYPE_CODE (arg)) 2595 { 2596 case TYPE_CODE_INT: 2597 case TYPE_CODE_CHAR: 2598 case TYPE_CODE_RANGE: 2599 case TYPE_CODE_BOOL: 2600 case TYPE_CODE_ENUM: 2601 return INTEGER_CONVERSION_BADNESS; 2602 case TYPE_CODE_FLT: 2603 return INT_FLOAT_CONVERSION_BADNESS; 2604 default: 2605 return INCOMPATIBLE_TYPE_BADNESS; 2606 } 2607 break; 2608 case TYPE_CODE_CHAR: 2609 switch (TYPE_CODE (arg)) 2610 { 2611 case TYPE_CODE_RANGE: 2612 case TYPE_CODE_BOOL: 2613 case TYPE_CODE_ENUM: 2614 return INTEGER_CONVERSION_BADNESS; 2615 case TYPE_CODE_FLT: 2616 return INT_FLOAT_CONVERSION_BADNESS; 2617 case TYPE_CODE_INT: 2618 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm)) 2619 return INTEGER_CONVERSION_BADNESS; 2620 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm)) 2621 return INTEGER_PROMOTION_BADNESS; 2622 /* >>> !! else fall through !! <<< */ 2623 case TYPE_CODE_CHAR: 2624 /* Deal with signed, unsigned, and plain chars for C++ and 2625 with int cases falling through from previous case. */ 2626 if (TYPE_NOSIGN (parm)) 2627 { 2628 if (TYPE_NOSIGN (arg)) 2629 return EXACT_MATCH_BADNESS; 2630 else 2631 return INTEGER_CONVERSION_BADNESS; 2632 } 2633 else if (TYPE_UNSIGNED (parm)) 2634 { 2635 if (TYPE_UNSIGNED (arg)) 2636 return EXACT_MATCH_BADNESS; 2637 else 2638 return INTEGER_PROMOTION_BADNESS; 2639 } 2640 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg)) 2641 return EXACT_MATCH_BADNESS; 2642 else 2643 return INTEGER_CONVERSION_BADNESS; 2644 default: 2645 return INCOMPATIBLE_TYPE_BADNESS; 2646 } 2647 break; 2648 case TYPE_CODE_RANGE: 2649 switch (TYPE_CODE (arg)) 2650 { 2651 case TYPE_CODE_INT: 2652 case TYPE_CODE_CHAR: 2653 case TYPE_CODE_RANGE: 2654 case TYPE_CODE_BOOL: 2655 case TYPE_CODE_ENUM: 2656 return INTEGER_CONVERSION_BADNESS; 2657 case TYPE_CODE_FLT: 2658 return INT_FLOAT_CONVERSION_BADNESS; 2659 default: 2660 return INCOMPATIBLE_TYPE_BADNESS; 2661 } 2662 break; 2663 case TYPE_CODE_BOOL: 2664 switch (TYPE_CODE (arg)) 2665 { 2666 case TYPE_CODE_INT: 2667 case TYPE_CODE_CHAR: 2668 case TYPE_CODE_RANGE: 2669 case TYPE_CODE_ENUM: 2670 case TYPE_CODE_FLT: 2671 return INCOMPATIBLE_TYPE_BADNESS; 2672 case TYPE_CODE_PTR: 2673 return BOOL_PTR_CONVERSION_BADNESS; 2674 case TYPE_CODE_BOOL: 2675 return EXACT_MATCH_BADNESS; 2676 default: 2677 return INCOMPATIBLE_TYPE_BADNESS; 2678 } 2679 break; 2680 case TYPE_CODE_FLT: 2681 switch (TYPE_CODE (arg)) 2682 { 2683 case TYPE_CODE_FLT: 2684 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm)) 2685 return FLOAT_PROMOTION_BADNESS; 2686 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm)) 2687 return EXACT_MATCH_BADNESS; 2688 else 2689 return FLOAT_CONVERSION_BADNESS; 2690 case TYPE_CODE_INT: 2691 case TYPE_CODE_BOOL: 2692 case TYPE_CODE_ENUM: 2693 case TYPE_CODE_RANGE: 2694 case TYPE_CODE_CHAR: 2695 return INT_FLOAT_CONVERSION_BADNESS; 2696 default: 2697 return INCOMPATIBLE_TYPE_BADNESS; 2698 } 2699 break; 2700 case TYPE_CODE_COMPLEX: 2701 switch (TYPE_CODE (arg)) 2702 { /* Strictly not needed for C++, but... */ 2703 case TYPE_CODE_FLT: 2704 return FLOAT_PROMOTION_BADNESS; 2705 case TYPE_CODE_COMPLEX: 2706 return EXACT_MATCH_BADNESS; 2707 default: 2708 return INCOMPATIBLE_TYPE_BADNESS; 2709 } 2710 break; 2711 case TYPE_CODE_STRUCT: 2712 /* currently same as TYPE_CODE_CLASS. */ 2713 switch (TYPE_CODE (arg)) 2714 { 2715 case TYPE_CODE_STRUCT: 2716 /* Check for derivation */ 2717 rank.subrank = distance_to_ancestor (parm, arg, 0); 2718 if (rank.subrank >= 0) 2719 return sum_ranks (BASE_CONVERSION_BADNESS, rank); 2720 /* else fall through */ 2721 default: 2722 return INCOMPATIBLE_TYPE_BADNESS; 2723 } 2724 break; 2725 case TYPE_CODE_UNION: 2726 switch (TYPE_CODE (arg)) 2727 { 2728 case TYPE_CODE_UNION: 2729 default: 2730 return INCOMPATIBLE_TYPE_BADNESS; 2731 } 2732 break; 2733 case TYPE_CODE_MEMBERPTR: 2734 switch (TYPE_CODE (arg)) 2735 { 2736 default: 2737 return INCOMPATIBLE_TYPE_BADNESS; 2738 } 2739 break; 2740 case TYPE_CODE_METHOD: 2741 switch (TYPE_CODE (arg)) 2742 { 2743 2744 default: 2745 return INCOMPATIBLE_TYPE_BADNESS; 2746 } 2747 break; 2748 case TYPE_CODE_REF: 2749 switch (TYPE_CODE (arg)) 2750 { 2751 2752 default: 2753 return INCOMPATIBLE_TYPE_BADNESS; 2754 } 2755 2756 break; 2757 case TYPE_CODE_SET: 2758 switch (TYPE_CODE (arg)) 2759 { 2760 /* Not in C++ */ 2761 case TYPE_CODE_SET: 2762 return rank_one_type (TYPE_FIELD_TYPE (parm, 0), 2763 TYPE_FIELD_TYPE (arg, 0), NULL); 2764 default: 2765 return INCOMPATIBLE_TYPE_BADNESS; 2766 } 2767 break; 2768 case TYPE_CODE_VOID: 2769 default: 2770 return INCOMPATIBLE_TYPE_BADNESS; 2771 } /* switch (TYPE_CODE (arg)) */ 2772 } 2773 2774 2775 /* End of functions for overload resolution. */ 2776 2777 static void 2778 print_bit_vector (B_TYPE *bits, int nbits) 2779 { 2780 int bitno; 2781 2782 for (bitno = 0; bitno < nbits; bitno++) 2783 { 2784 if ((bitno % 8) == 0) 2785 { 2786 puts_filtered (" "); 2787 } 2788 if (B_TST (bits, bitno)) 2789 printf_filtered (("1")); 2790 else 2791 printf_filtered (("0")); 2792 } 2793 } 2794 2795 /* Note the first arg should be the "this" pointer, we may not want to 2796 include it since we may get into a infinitely recursive 2797 situation. */ 2798 2799 static void 2800 print_arg_types (struct field *args, int nargs, int spaces) 2801 { 2802 if (args != NULL) 2803 { 2804 int i; 2805 2806 for (i = 0; i < nargs; i++) 2807 recursive_dump_type (args[i].type, spaces + 2); 2808 } 2809 } 2810 2811 int 2812 field_is_static (struct field *f) 2813 { 2814 /* "static" fields are the fields whose location is not relative 2815 to the address of the enclosing struct. It would be nice to 2816 have a dedicated flag that would be set for static fields when 2817 the type is being created. But in practice, checking the field 2818 loc_kind should give us an accurate answer. */ 2819 return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME 2820 || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR); 2821 } 2822 2823 static void 2824 dump_fn_fieldlists (struct type *type, int spaces) 2825 { 2826 int method_idx; 2827 int overload_idx; 2828 struct fn_field *f; 2829 2830 printfi_filtered (spaces, "fn_fieldlists "); 2831 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout); 2832 printf_filtered ("\n"); 2833 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++) 2834 { 2835 f = TYPE_FN_FIELDLIST1 (type, method_idx); 2836 printfi_filtered (spaces + 2, "[%d] name '%s' (", 2837 method_idx, 2838 TYPE_FN_FIELDLIST_NAME (type, method_idx)); 2839 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx), 2840 gdb_stdout); 2841 printf_filtered (_(") length %d\n"), 2842 TYPE_FN_FIELDLIST_LENGTH (type, method_idx)); 2843 for (overload_idx = 0; 2844 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx); 2845 overload_idx++) 2846 { 2847 printfi_filtered (spaces + 4, "[%d] physname '%s' (", 2848 overload_idx, 2849 TYPE_FN_FIELD_PHYSNAME (f, overload_idx)); 2850 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx), 2851 gdb_stdout); 2852 printf_filtered (")\n"); 2853 printfi_filtered (spaces + 8, "type "); 2854 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx), 2855 gdb_stdout); 2856 printf_filtered ("\n"); 2857 2858 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx), 2859 spaces + 8 + 2); 2860 2861 printfi_filtered (spaces + 8, "args "); 2862 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), 2863 gdb_stdout); 2864 printf_filtered ("\n"); 2865 2866 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), 2867 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, 2868 overload_idx)), 2869 spaces); 2870 printfi_filtered (spaces + 8, "fcontext "); 2871 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx), 2872 gdb_stdout); 2873 printf_filtered ("\n"); 2874 2875 printfi_filtered (spaces + 8, "is_const %d\n", 2876 TYPE_FN_FIELD_CONST (f, overload_idx)); 2877 printfi_filtered (spaces + 8, "is_volatile %d\n", 2878 TYPE_FN_FIELD_VOLATILE (f, overload_idx)); 2879 printfi_filtered (spaces + 8, "is_private %d\n", 2880 TYPE_FN_FIELD_PRIVATE (f, overload_idx)); 2881 printfi_filtered (spaces + 8, "is_protected %d\n", 2882 TYPE_FN_FIELD_PROTECTED (f, overload_idx)); 2883 printfi_filtered (spaces + 8, "is_stub %d\n", 2884 TYPE_FN_FIELD_STUB (f, overload_idx)); 2885 printfi_filtered (spaces + 8, "voffset %u\n", 2886 TYPE_FN_FIELD_VOFFSET (f, overload_idx)); 2887 } 2888 } 2889 } 2890 2891 static void 2892 print_cplus_stuff (struct type *type, int spaces) 2893 { 2894 printfi_filtered (spaces, "n_baseclasses %d\n", 2895 TYPE_N_BASECLASSES (type)); 2896 printfi_filtered (spaces, "nfn_fields %d\n", 2897 TYPE_NFN_FIELDS (type)); 2898 printfi_filtered (spaces, "nfn_fields_total %d\n", 2899 TYPE_NFN_FIELDS_TOTAL (type)); 2900 if (TYPE_N_BASECLASSES (type) > 0) 2901 { 2902 printfi_filtered (spaces, "virtual_field_bits (%d bits at *", 2903 TYPE_N_BASECLASSES (type)); 2904 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type), 2905 gdb_stdout); 2906 printf_filtered (")"); 2907 2908 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type), 2909 TYPE_N_BASECLASSES (type)); 2910 puts_filtered ("\n"); 2911 } 2912 if (TYPE_NFIELDS (type) > 0) 2913 { 2914 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL) 2915 { 2916 printfi_filtered (spaces, 2917 "private_field_bits (%d bits at *", 2918 TYPE_NFIELDS (type)); 2919 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), 2920 gdb_stdout); 2921 printf_filtered (")"); 2922 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type), 2923 TYPE_NFIELDS (type)); 2924 puts_filtered ("\n"); 2925 } 2926 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL) 2927 { 2928 printfi_filtered (spaces, 2929 "protected_field_bits (%d bits at *", 2930 TYPE_NFIELDS (type)); 2931 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), 2932 gdb_stdout); 2933 printf_filtered (")"); 2934 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type), 2935 TYPE_NFIELDS (type)); 2936 puts_filtered ("\n"); 2937 } 2938 } 2939 if (TYPE_NFN_FIELDS (type) > 0) 2940 { 2941 dump_fn_fieldlists (type, spaces); 2942 } 2943 } 2944 2945 /* Print the contents of the TYPE's type_specific union, assuming that 2946 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */ 2947 2948 static void 2949 print_gnat_stuff (struct type *type, int spaces) 2950 { 2951 struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type); 2952 2953 recursive_dump_type (descriptive_type, spaces + 2); 2954 } 2955 2956 static struct obstack dont_print_type_obstack; 2957 2958 void 2959 recursive_dump_type (struct type *type, int spaces) 2960 { 2961 int idx; 2962 2963 if (spaces == 0) 2964 obstack_begin (&dont_print_type_obstack, 0); 2965 2966 if (TYPE_NFIELDS (type) > 0 2967 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0)) 2968 { 2969 struct type **first_dont_print 2970 = (struct type **) obstack_base (&dont_print_type_obstack); 2971 2972 int i = (struct type **) 2973 obstack_next_free (&dont_print_type_obstack) - first_dont_print; 2974 2975 while (--i >= 0) 2976 { 2977 if (type == first_dont_print[i]) 2978 { 2979 printfi_filtered (spaces, "type node "); 2980 gdb_print_host_address (type, gdb_stdout); 2981 printf_filtered (_(" <same as already seen type>\n")); 2982 return; 2983 } 2984 } 2985 2986 obstack_ptr_grow (&dont_print_type_obstack, type); 2987 } 2988 2989 printfi_filtered (spaces, "type node "); 2990 gdb_print_host_address (type, gdb_stdout); 2991 printf_filtered ("\n"); 2992 printfi_filtered (spaces, "name '%s' (", 2993 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>"); 2994 gdb_print_host_address (TYPE_NAME (type), gdb_stdout); 2995 printf_filtered (")\n"); 2996 printfi_filtered (spaces, "tagname '%s' (", 2997 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>"); 2998 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout); 2999 printf_filtered (")\n"); 3000 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type)); 3001 switch (TYPE_CODE (type)) 3002 { 3003 case TYPE_CODE_UNDEF: 3004 printf_filtered ("(TYPE_CODE_UNDEF)"); 3005 break; 3006 case TYPE_CODE_PTR: 3007 printf_filtered ("(TYPE_CODE_PTR)"); 3008 break; 3009 case TYPE_CODE_ARRAY: 3010 printf_filtered ("(TYPE_CODE_ARRAY)"); 3011 break; 3012 case TYPE_CODE_STRUCT: 3013 printf_filtered ("(TYPE_CODE_STRUCT)"); 3014 break; 3015 case TYPE_CODE_UNION: 3016 printf_filtered ("(TYPE_CODE_UNION)"); 3017 break; 3018 case TYPE_CODE_ENUM: 3019 printf_filtered ("(TYPE_CODE_ENUM)"); 3020 break; 3021 case TYPE_CODE_FLAGS: 3022 printf_filtered ("(TYPE_CODE_FLAGS)"); 3023 break; 3024 case TYPE_CODE_FUNC: 3025 printf_filtered ("(TYPE_CODE_FUNC)"); 3026 break; 3027 case TYPE_CODE_INT: 3028 printf_filtered ("(TYPE_CODE_INT)"); 3029 break; 3030 case TYPE_CODE_FLT: 3031 printf_filtered ("(TYPE_CODE_FLT)"); 3032 break; 3033 case TYPE_CODE_VOID: 3034 printf_filtered ("(TYPE_CODE_VOID)"); 3035 break; 3036 case TYPE_CODE_SET: 3037 printf_filtered ("(TYPE_CODE_SET)"); 3038 break; 3039 case TYPE_CODE_RANGE: 3040 printf_filtered ("(TYPE_CODE_RANGE)"); 3041 break; 3042 case TYPE_CODE_STRING: 3043 printf_filtered ("(TYPE_CODE_STRING)"); 3044 break; 3045 case TYPE_CODE_BITSTRING: 3046 printf_filtered ("(TYPE_CODE_BITSTRING)"); 3047 break; 3048 case TYPE_CODE_ERROR: 3049 printf_filtered ("(TYPE_CODE_ERROR)"); 3050 break; 3051 case TYPE_CODE_MEMBERPTR: 3052 printf_filtered ("(TYPE_CODE_MEMBERPTR)"); 3053 break; 3054 case TYPE_CODE_METHODPTR: 3055 printf_filtered ("(TYPE_CODE_METHODPTR)"); 3056 break; 3057 case TYPE_CODE_METHOD: 3058 printf_filtered ("(TYPE_CODE_METHOD)"); 3059 break; 3060 case TYPE_CODE_REF: 3061 printf_filtered ("(TYPE_CODE_REF)"); 3062 break; 3063 case TYPE_CODE_CHAR: 3064 printf_filtered ("(TYPE_CODE_CHAR)"); 3065 break; 3066 case TYPE_CODE_BOOL: 3067 printf_filtered ("(TYPE_CODE_BOOL)"); 3068 break; 3069 case TYPE_CODE_COMPLEX: 3070 printf_filtered ("(TYPE_CODE_COMPLEX)"); 3071 break; 3072 case TYPE_CODE_TYPEDEF: 3073 printf_filtered ("(TYPE_CODE_TYPEDEF)"); 3074 break; 3075 case TYPE_CODE_NAMESPACE: 3076 printf_filtered ("(TYPE_CODE_NAMESPACE)"); 3077 break; 3078 default: 3079 printf_filtered ("(UNKNOWN TYPE CODE)"); 3080 break; 3081 } 3082 puts_filtered ("\n"); 3083 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type)); 3084 if (TYPE_OBJFILE_OWNED (type)) 3085 { 3086 printfi_filtered (spaces, "objfile "); 3087 gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout); 3088 } 3089 else 3090 { 3091 printfi_filtered (spaces, "gdbarch "); 3092 gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout); 3093 } 3094 printf_filtered ("\n"); 3095 printfi_filtered (spaces, "target_type "); 3096 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout); 3097 printf_filtered ("\n"); 3098 if (TYPE_TARGET_TYPE (type) != NULL) 3099 { 3100 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2); 3101 } 3102 printfi_filtered (spaces, "pointer_type "); 3103 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout); 3104 printf_filtered ("\n"); 3105 printfi_filtered (spaces, "reference_type "); 3106 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout); 3107 printf_filtered ("\n"); 3108 printfi_filtered (spaces, "type_chain "); 3109 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout); 3110 printf_filtered ("\n"); 3111 printfi_filtered (spaces, "instance_flags 0x%x", 3112 TYPE_INSTANCE_FLAGS (type)); 3113 if (TYPE_CONST (type)) 3114 { 3115 puts_filtered (" TYPE_FLAG_CONST"); 3116 } 3117 if (TYPE_VOLATILE (type)) 3118 { 3119 puts_filtered (" TYPE_FLAG_VOLATILE"); 3120 } 3121 if (TYPE_CODE_SPACE (type)) 3122 { 3123 puts_filtered (" TYPE_FLAG_CODE_SPACE"); 3124 } 3125 if (TYPE_DATA_SPACE (type)) 3126 { 3127 puts_filtered (" TYPE_FLAG_DATA_SPACE"); 3128 } 3129 if (TYPE_ADDRESS_CLASS_1 (type)) 3130 { 3131 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1"); 3132 } 3133 if (TYPE_ADDRESS_CLASS_2 (type)) 3134 { 3135 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2"); 3136 } 3137 puts_filtered ("\n"); 3138 3139 printfi_filtered (spaces, "flags"); 3140 if (TYPE_UNSIGNED (type)) 3141 { 3142 puts_filtered (" TYPE_FLAG_UNSIGNED"); 3143 } 3144 if (TYPE_NOSIGN (type)) 3145 { 3146 puts_filtered (" TYPE_FLAG_NOSIGN"); 3147 } 3148 if (TYPE_STUB (type)) 3149 { 3150 puts_filtered (" TYPE_FLAG_STUB"); 3151 } 3152 if (TYPE_TARGET_STUB (type)) 3153 { 3154 puts_filtered (" TYPE_FLAG_TARGET_STUB"); 3155 } 3156 if (TYPE_STATIC (type)) 3157 { 3158 puts_filtered (" TYPE_FLAG_STATIC"); 3159 } 3160 if (TYPE_PROTOTYPED (type)) 3161 { 3162 puts_filtered (" TYPE_FLAG_PROTOTYPED"); 3163 } 3164 if (TYPE_INCOMPLETE (type)) 3165 { 3166 puts_filtered (" TYPE_FLAG_INCOMPLETE"); 3167 } 3168 if (TYPE_VARARGS (type)) 3169 { 3170 puts_filtered (" TYPE_FLAG_VARARGS"); 3171 } 3172 /* This is used for things like AltiVec registers on ppc. Gcc emits 3173 an attribute for the array type, which tells whether or not we 3174 have a vector, instead of a regular array. */ 3175 if (TYPE_VECTOR (type)) 3176 { 3177 puts_filtered (" TYPE_FLAG_VECTOR"); 3178 } 3179 if (TYPE_FIXED_INSTANCE (type)) 3180 { 3181 puts_filtered (" TYPE_FIXED_INSTANCE"); 3182 } 3183 if (TYPE_STUB_SUPPORTED (type)) 3184 { 3185 puts_filtered (" TYPE_STUB_SUPPORTED"); 3186 } 3187 if (TYPE_NOTTEXT (type)) 3188 { 3189 puts_filtered (" TYPE_NOTTEXT"); 3190 } 3191 puts_filtered ("\n"); 3192 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type)); 3193 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout); 3194 puts_filtered ("\n"); 3195 for (idx = 0; idx < TYPE_NFIELDS (type); idx++) 3196 { 3197 printfi_filtered (spaces + 2, 3198 "[%d] bitpos %d bitsize %d type ", 3199 idx, TYPE_FIELD_BITPOS (type, idx), 3200 TYPE_FIELD_BITSIZE (type, idx)); 3201 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout); 3202 printf_filtered (" name '%s' (", 3203 TYPE_FIELD_NAME (type, idx) != NULL 3204 ? TYPE_FIELD_NAME (type, idx) 3205 : "<NULL>"); 3206 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout); 3207 printf_filtered (")\n"); 3208 if (TYPE_FIELD_TYPE (type, idx) != NULL) 3209 { 3210 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4); 3211 } 3212 } 3213 if (TYPE_CODE (type) == TYPE_CODE_RANGE) 3214 { 3215 printfi_filtered (spaces, "low %s%s high %s%s\n", 3216 plongest (TYPE_LOW_BOUND (type)), 3217 TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "", 3218 plongest (TYPE_HIGH_BOUND (type)), 3219 TYPE_HIGH_BOUND_UNDEFINED (type) 3220 ? " (undefined)" : ""); 3221 } 3222 printfi_filtered (spaces, "vptr_basetype "); 3223 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout); 3224 puts_filtered ("\n"); 3225 if (TYPE_VPTR_BASETYPE (type) != NULL) 3226 { 3227 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2); 3228 } 3229 printfi_filtered (spaces, "vptr_fieldno %d\n", 3230 TYPE_VPTR_FIELDNO (type)); 3231 3232 switch (TYPE_SPECIFIC_FIELD (type)) 3233 { 3234 case TYPE_SPECIFIC_CPLUS_STUFF: 3235 printfi_filtered (spaces, "cplus_stuff "); 3236 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), 3237 gdb_stdout); 3238 puts_filtered ("\n"); 3239 print_cplus_stuff (type, spaces); 3240 break; 3241 3242 case TYPE_SPECIFIC_GNAT_STUFF: 3243 printfi_filtered (spaces, "gnat_stuff "); 3244 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout); 3245 puts_filtered ("\n"); 3246 print_gnat_stuff (type, spaces); 3247 break; 3248 3249 case TYPE_SPECIFIC_FLOATFORMAT: 3250 printfi_filtered (spaces, "floatformat "); 3251 if (TYPE_FLOATFORMAT (type) == NULL) 3252 puts_filtered ("(null)"); 3253 else 3254 { 3255 puts_filtered ("{ "); 3256 if (TYPE_FLOATFORMAT (type)[0] == NULL 3257 || TYPE_FLOATFORMAT (type)[0]->name == NULL) 3258 puts_filtered ("(null)"); 3259 else 3260 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name); 3261 3262 puts_filtered (", "); 3263 if (TYPE_FLOATFORMAT (type)[1] == NULL 3264 || TYPE_FLOATFORMAT (type)[1]->name == NULL) 3265 puts_filtered ("(null)"); 3266 else 3267 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name); 3268 3269 puts_filtered (" }"); 3270 } 3271 puts_filtered ("\n"); 3272 break; 3273 3274 case TYPE_SPECIFIC_FUNC: 3275 printfi_filtered (spaces, "calling_convention %d\n", 3276 TYPE_CALLING_CONVENTION (type)); 3277 /* tail_call_list is not printed. */ 3278 break; 3279 } 3280 3281 if (spaces == 0) 3282 obstack_free (&dont_print_type_obstack, NULL); 3283 } 3284 3285 /* Trivial helpers for the libiberty hash table, for mapping one 3286 type to another. */ 3287 3288 struct type_pair 3289 { 3290 struct type *old, *new; 3291 }; 3292 3293 static hashval_t 3294 type_pair_hash (const void *item) 3295 { 3296 const struct type_pair *pair = item; 3297 3298 return htab_hash_pointer (pair->old); 3299 } 3300 3301 static int 3302 type_pair_eq (const void *item_lhs, const void *item_rhs) 3303 { 3304 const struct type_pair *lhs = item_lhs, *rhs = item_rhs; 3305 3306 return lhs->old == rhs->old; 3307 } 3308 3309 /* Allocate the hash table used by copy_type_recursive to walk 3310 types without duplicates. We use OBJFILE's obstack, because 3311 OBJFILE is about to be deleted. */ 3312 3313 htab_t 3314 create_copied_types_hash (struct objfile *objfile) 3315 { 3316 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq, 3317 NULL, &objfile->objfile_obstack, 3318 hashtab_obstack_allocate, 3319 dummy_obstack_deallocate); 3320 } 3321 3322 /* Recursively copy (deep copy) TYPE, if it is associated with 3323 OBJFILE. Return a new type allocated using malloc, a saved type if 3324 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is 3325 not associated with OBJFILE. */ 3326 3327 struct type * 3328 copy_type_recursive (struct objfile *objfile, 3329 struct type *type, 3330 htab_t copied_types) 3331 { 3332 struct type_pair *stored, pair; 3333 void **slot; 3334 struct type *new_type; 3335 3336 if (! TYPE_OBJFILE_OWNED (type)) 3337 return type; 3338 3339 /* This type shouldn't be pointing to any types in other objfiles; 3340 if it did, the type might disappear unexpectedly. */ 3341 gdb_assert (TYPE_OBJFILE (type) == objfile); 3342 3343 pair.old = type; 3344 slot = htab_find_slot (copied_types, &pair, INSERT); 3345 if (*slot != NULL) 3346 return ((struct type_pair *) *slot)->new; 3347 3348 new_type = alloc_type_arch (get_type_arch (type)); 3349 3350 /* We must add the new type to the hash table immediately, in case 3351 we encounter this type again during a recursive call below. */ 3352 stored 3353 = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair)); 3354 stored->old = type; 3355 stored->new = new_type; 3356 *slot = stored; 3357 3358 /* Copy the common fields of types. For the main type, we simply 3359 copy the entire thing and then update specific fields as needed. */ 3360 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type); 3361 TYPE_OBJFILE_OWNED (new_type) = 0; 3362 TYPE_OWNER (new_type).gdbarch = get_type_arch (type); 3363 3364 if (TYPE_NAME (type)) 3365 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type)); 3366 if (TYPE_TAG_NAME (type)) 3367 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type)); 3368 3369 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type); 3370 TYPE_LENGTH (new_type) = TYPE_LENGTH (type); 3371 3372 /* Copy the fields. */ 3373 if (TYPE_NFIELDS (type)) 3374 { 3375 int i, nfields; 3376 3377 nfields = TYPE_NFIELDS (type); 3378 TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field); 3379 for (i = 0; i < nfields; i++) 3380 { 3381 TYPE_FIELD_ARTIFICIAL (new_type, i) = 3382 TYPE_FIELD_ARTIFICIAL (type, i); 3383 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i); 3384 if (TYPE_FIELD_TYPE (type, i)) 3385 TYPE_FIELD_TYPE (new_type, i) 3386 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i), 3387 copied_types); 3388 if (TYPE_FIELD_NAME (type, i)) 3389 TYPE_FIELD_NAME (new_type, i) = 3390 xstrdup (TYPE_FIELD_NAME (type, i)); 3391 switch (TYPE_FIELD_LOC_KIND (type, i)) 3392 { 3393 case FIELD_LOC_KIND_BITPOS: 3394 SET_FIELD_BITPOS (TYPE_FIELD (new_type, i), 3395 TYPE_FIELD_BITPOS (type, i)); 3396 break; 3397 case FIELD_LOC_KIND_PHYSADDR: 3398 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i), 3399 TYPE_FIELD_STATIC_PHYSADDR (type, i)); 3400 break; 3401 case FIELD_LOC_KIND_PHYSNAME: 3402 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i), 3403 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type, 3404 i))); 3405 break; 3406 default: 3407 internal_error (__FILE__, __LINE__, 3408 _("Unexpected type field location kind: %d"), 3409 TYPE_FIELD_LOC_KIND (type, i)); 3410 } 3411 } 3412 } 3413 3414 /* For range types, copy the bounds information. */ 3415 if (TYPE_CODE (type) == TYPE_CODE_RANGE) 3416 { 3417 TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds)); 3418 *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type); 3419 } 3420 3421 /* Copy pointers to other types. */ 3422 if (TYPE_TARGET_TYPE (type)) 3423 TYPE_TARGET_TYPE (new_type) = 3424 copy_type_recursive (objfile, 3425 TYPE_TARGET_TYPE (type), 3426 copied_types); 3427 if (TYPE_VPTR_BASETYPE (type)) 3428 TYPE_VPTR_BASETYPE (new_type) = 3429 copy_type_recursive (objfile, 3430 TYPE_VPTR_BASETYPE (type), 3431 copied_types); 3432 /* Maybe copy the type_specific bits. 3433 3434 NOTE drow/2005-12-09: We do not copy the C++-specific bits like 3435 base classes and methods. There's no fundamental reason why we 3436 can't, but at the moment it is not needed. */ 3437 3438 if (TYPE_CODE (type) == TYPE_CODE_FLT) 3439 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type); 3440 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT 3441 || TYPE_CODE (type) == TYPE_CODE_UNION 3442 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE) 3443 INIT_CPLUS_SPECIFIC (new_type); 3444 3445 return new_type; 3446 } 3447 3448 /* Make a copy of the given TYPE, except that the pointer & reference 3449 types are not preserved. 3450 3451 This function assumes that the given type has an associated objfile. 3452 This objfile is used to allocate the new type. */ 3453 3454 struct type * 3455 copy_type (const struct type *type) 3456 { 3457 struct type *new_type; 3458 3459 gdb_assert (TYPE_OBJFILE_OWNED (type)); 3460 3461 new_type = alloc_type_copy (type); 3462 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type); 3463 TYPE_LENGTH (new_type) = TYPE_LENGTH (type); 3464 memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type), 3465 sizeof (struct main_type)); 3466 3467 return new_type; 3468 } 3469 3470 3471 /* Helper functions to initialize architecture-specific types. */ 3472 3473 /* Allocate a type structure associated with GDBARCH and set its 3474 CODE, LENGTH, and NAME fields. */ 3475 struct type * 3476 arch_type (struct gdbarch *gdbarch, 3477 enum type_code code, int length, char *name) 3478 { 3479 struct type *type; 3480 3481 type = alloc_type_arch (gdbarch); 3482 TYPE_CODE (type) = code; 3483 TYPE_LENGTH (type) = length; 3484 3485 if (name) 3486 TYPE_NAME (type) = xstrdup (name); 3487 3488 return type; 3489 } 3490 3491 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH. 3492 BIT is the type size in bits. If UNSIGNED_P is non-zero, set 3493 the type's TYPE_UNSIGNED flag. NAME is the type name. */ 3494 struct type * 3495 arch_integer_type (struct gdbarch *gdbarch, 3496 int bit, int unsigned_p, char *name) 3497 { 3498 struct type *t; 3499 3500 t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name); 3501 if (unsigned_p) 3502 TYPE_UNSIGNED (t) = 1; 3503 if (name && strcmp (name, "char") == 0) 3504 TYPE_NOSIGN (t) = 1; 3505 3506 return t; 3507 } 3508 3509 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH. 3510 BIT is the type size in bits. If UNSIGNED_P is non-zero, set 3511 the type's TYPE_UNSIGNED flag. NAME is the type name. */ 3512 struct type * 3513 arch_character_type (struct gdbarch *gdbarch, 3514 int bit, int unsigned_p, char *name) 3515 { 3516 struct type *t; 3517 3518 t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name); 3519 if (unsigned_p) 3520 TYPE_UNSIGNED (t) = 1; 3521 3522 return t; 3523 } 3524 3525 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH. 3526 BIT is the type size in bits. If UNSIGNED_P is non-zero, set 3527 the type's TYPE_UNSIGNED flag. NAME is the type name. */ 3528 struct type * 3529 arch_boolean_type (struct gdbarch *gdbarch, 3530 int bit, int unsigned_p, char *name) 3531 { 3532 struct type *t; 3533 3534 t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name); 3535 if (unsigned_p) 3536 TYPE_UNSIGNED (t) = 1; 3537 3538 return t; 3539 } 3540 3541 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH. 3542 BIT is the type size in bits; if BIT equals -1, the size is 3543 determined by the floatformat. NAME is the type name. Set the 3544 TYPE_FLOATFORMAT from FLOATFORMATS. */ 3545 struct type * 3546 arch_float_type (struct gdbarch *gdbarch, 3547 int bit, char *name, const struct floatformat **floatformats) 3548 { 3549 struct type *t; 3550 3551 if (bit == -1) 3552 { 3553 gdb_assert (floatformats != NULL); 3554 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL); 3555 bit = floatformats[0]->totalsize; 3556 } 3557 gdb_assert (bit >= 0); 3558 3559 t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name); 3560 TYPE_FLOATFORMAT (t) = floatformats; 3561 return t; 3562 } 3563 3564 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH. 3565 NAME is the type name. TARGET_TYPE is the component float type. */ 3566 struct type * 3567 arch_complex_type (struct gdbarch *gdbarch, 3568 char *name, struct type *target_type) 3569 { 3570 struct type *t; 3571 3572 t = arch_type (gdbarch, TYPE_CODE_COMPLEX, 3573 2 * TYPE_LENGTH (target_type), name); 3574 TYPE_TARGET_TYPE (t) = target_type; 3575 return t; 3576 } 3577 3578 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH. 3579 NAME is the type name. LENGTH is the size of the flag word in bytes. */ 3580 struct type * 3581 arch_flags_type (struct gdbarch *gdbarch, char *name, int length) 3582 { 3583 int nfields = length * TARGET_CHAR_BIT; 3584 struct type *type; 3585 3586 type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name); 3587 TYPE_UNSIGNED (type) = 1; 3588 TYPE_NFIELDS (type) = nfields; 3589 TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field)); 3590 3591 return type; 3592 } 3593 3594 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at 3595 position BITPOS is called NAME. */ 3596 void 3597 append_flags_type_flag (struct type *type, int bitpos, char *name) 3598 { 3599 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS); 3600 gdb_assert (bitpos < TYPE_NFIELDS (type)); 3601 gdb_assert (bitpos >= 0); 3602 3603 if (name) 3604 { 3605 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name); 3606 TYPE_FIELD_BITPOS (type, bitpos) = bitpos; 3607 } 3608 else 3609 { 3610 /* Don't show this field to the user. */ 3611 TYPE_FIELD_BITPOS (type, bitpos) = -1; 3612 } 3613 } 3614 3615 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as 3616 specified by CODE) associated with GDBARCH. NAME is the type name. */ 3617 struct type * 3618 arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code) 3619 { 3620 struct type *t; 3621 3622 gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION); 3623 t = arch_type (gdbarch, code, 0, NULL); 3624 TYPE_TAG_NAME (t) = name; 3625 INIT_CPLUS_SPECIFIC (t); 3626 return t; 3627 } 3628 3629 /* Add new field with name NAME and type FIELD to composite type T. 3630 Do not set the field's position or adjust the type's length; 3631 the caller should do so. Return the new field. */ 3632 struct field * 3633 append_composite_type_field_raw (struct type *t, char *name, 3634 struct type *field) 3635 { 3636 struct field *f; 3637 3638 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1; 3639 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t), 3640 sizeof (struct field) * TYPE_NFIELDS (t)); 3641 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]); 3642 memset (f, 0, sizeof f[0]); 3643 FIELD_TYPE (f[0]) = field; 3644 FIELD_NAME (f[0]) = name; 3645 return f; 3646 } 3647 3648 /* Add new field with name NAME and type FIELD to composite type T. 3649 ALIGNMENT (if non-zero) specifies the minimum field alignment. */ 3650 void 3651 append_composite_type_field_aligned (struct type *t, char *name, 3652 struct type *field, int alignment) 3653 { 3654 struct field *f = append_composite_type_field_raw (t, name, field); 3655 3656 if (TYPE_CODE (t) == TYPE_CODE_UNION) 3657 { 3658 if (TYPE_LENGTH (t) < TYPE_LENGTH (field)) 3659 TYPE_LENGTH (t) = TYPE_LENGTH (field); 3660 } 3661 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT) 3662 { 3663 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field); 3664 if (TYPE_NFIELDS (t) > 1) 3665 { 3666 FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1]) 3667 + (TYPE_LENGTH (FIELD_TYPE (f[-1])) 3668 * TARGET_CHAR_BIT)); 3669 3670 if (alignment) 3671 { 3672 int left; 3673 3674 alignment *= TARGET_CHAR_BIT; 3675 left = FIELD_BITPOS (f[0]) % alignment; 3676 3677 if (left) 3678 { 3679 FIELD_BITPOS (f[0]) += (alignment - left); 3680 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT; 3681 } 3682 } 3683 } 3684 } 3685 } 3686 3687 /* Add new field with name NAME and type FIELD to composite type T. */ 3688 void 3689 append_composite_type_field (struct type *t, char *name, 3690 struct type *field) 3691 { 3692 append_composite_type_field_aligned (t, name, field, 0); 3693 } 3694 3695 3696 static struct gdbarch_data *gdbtypes_data; 3697 3698 const struct builtin_type * 3699 builtin_type (struct gdbarch *gdbarch) 3700 { 3701 return gdbarch_data (gdbarch, gdbtypes_data); 3702 } 3703 3704 static void * 3705 gdbtypes_post_init (struct gdbarch *gdbarch) 3706 { 3707 struct builtin_type *builtin_type 3708 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type); 3709 3710 /* Basic types. */ 3711 builtin_type->builtin_void 3712 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); 3713 builtin_type->builtin_char 3714 = arch_integer_type (gdbarch, TARGET_CHAR_BIT, 3715 !gdbarch_char_signed (gdbarch), "char"); 3716 builtin_type->builtin_signed_char 3717 = arch_integer_type (gdbarch, TARGET_CHAR_BIT, 3718 0, "signed char"); 3719 builtin_type->builtin_unsigned_char 3720 = arch_integer_type (gdbarch, TARGET_CHAR_BIT, 3721 1, "unsigned char"); 3722 builtin_type->builtin_short 3723 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), 3724 0, "short"); 3725 builtin_type->builtin_unsigned_short 3726 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), 3727 1, "unsigned short"); 3728 builtin_type->builtin_int 3729 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 3730 0, "int"); 3731 builtin_type->builtin_unsigned_int 3732 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 3733 1, "unsigned int"); 3734 builtin_type->builtin_long 3735 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 3736 0, "long"); 3737 builtin_type->builtin_unsigned_long 3738 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 3739 1, "unsigned long"); 3740 builtin_type->builtin_long_long 3741 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), 3742 0, "long long"); 3743 builtin_type->builtin_unsigned_long_long 3744 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), 3745 1, "unsigned long long"); 3746 builtin_type->builtin_float 3747 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), 3748 "float", gdbarch_float_format (gdbarch)); 3749 builtin_type->builtin_double 3750 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), 3751 "double", gdbarch_double_format (gdbarch)); 3752 builtin_type->builtin_long_double 3753 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), 3754 "long double", gdbarch_long_double_format (gdbarch)); 3755 builtin_type->builtin_complex 3756 = arch_complex_type (gdbarch, "complex", 3757 builtin_type->builtin_float); 3758 builtin_type->builtin_double_complex 3759 = arch_complex_type (gdbarch, "double complex", 3760 builtin_type->builtin_double); 3761 builtin_type->builtin_string 3762 = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string"); 3763 builtin_type->builtin_bool 3764 = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool"); 3765 3766 /* The following three are about decimal floating point types, which 3767 are 32-bits, 64-bits and 128-bits respectively. */ 3768 builtin_type->builtin_decfloat 3769 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32"); 3770 builtin_type->builtin_decdouble 3771 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64"); 3772 builtin_type->builtin_declong 3773 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128"); 3774 3775 /* "True" character types. */ 3776 builtin_type->builtin_true_char 3777 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character"); 3778 builtin_type->builtin_true_unsigned_char 3779 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character"); 3780 3781 /* Fixed-size integer types. */ 3782 builtin_type->builtin_int0 3783 = arch_integer_type (gdbarch, 0, 0, "int0_t"); 3784 builtin_type->builtin_int8 3785 = arch_integer_type (gdbarch, 8, 0, "int8_t"); 3786 builtin_type->builtin_uint8 3787 = arch_integer_type (gdbarch, 8, 1, "uint8_t"); 3788 builtin_type->builtin_int16 3789 = arch_integer_type (gdbarch, 16, 0, "int16_t"); 3790 builtin_type->builtin_uint16 3791 = arch_integer_type (gdbarch, 16, 1, "uint16_t"); 3792 builtin_type->builtin_int32 3793 = arch_integer_type (gdbarch, 32, 0, "int32_t"); 3794 builtin_type->builtin_uint32 3795 = arch_integer_type (gdbarch, 32, 1, "uint32_t"); 3796 builtin_type->builtin_int64 3797 = arch_integer_type (gdbarch, 64, 0, "int64_t"); 3798 builtin_type->builtin_uint64 3799 = arch_integer_type (gdbarch, 64, 1, "uint64_t"); 3800 builtin_type->builtin_int128 3801 = arch_integer_type (gdbarch, 128, 0, "int128_t"); 3802 builtin_type->builtin_uint128 3803 = arch_integer_type (gdbarch, 128, 1, "uint128_t"); 3804 TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |= 3805 TYPE_INSTANCE_FLAG_NOTTEXT; 3806 TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |= 3807 TYPE_INSTANCE_FLAG_NOTTEXT; 3808 3809 /* Wide character types. */ 3810 builtin_type->builtin_char16 3811 = arch_integer_type (gdbarch, 16, 0, "char16_t"); 3812 builtin_type->builtin_char32 3813 = arch_integer_type (gdbarch, 32, 0, "char32_t"); 3814 3815 3816 /* Default data/code pointer types. */ 3817 builtin_type->builtin_data_ptr 3818 = lookup_pointer_type (builtin_type->builtin_void); 3819 builtin_type->builtin_func_ptr 3820 = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void)); 3821 builtin_type->builtin_func_func 3822 = lookup_function_type (builtin_type->builtin_func_ptr); 3823 3824 /* This type represents a GDB internal function. */ 3825 builtin_type->internal_fn 3826 = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0, 3827 "<internal function>"); 3828 3829 return builtin_type; 3830 } 3831 3832 3833 /* This set of objfile-based types is intended to be used by symbol 3834 readers as basic types. */ 3835 3836 static const struct objfile_data *objfile_type_data; 3837 3838 const struct objfile_type * 3839 objfile_type (struct objfile *objfile) 3840 { 3841 struct gdbarch *gdbarch; 3842 struct objfile_type *objfile_type 3843 = objfile_data (objfile, objfile_type_data); 3844 3845 if (objfile_type) 3846 return objfile_type; 3847 3848 objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack, 3849 1, struct objfile_type); 3850 3851 /* Use the objfile architecture to determine basic type properties. */ 3852 gdbarch = get_objfile_arch (objfile); 3853 3854 /* Basic types. */ 3855 objfile_type->builtin_void 3856 = init_type (TYPE_CODE_VOID, 1, 3857 0, 3858 "void", objfile); 3859 3860 objfile_type->builtin_char 3861 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 3862 (TYPE_FLAG_NOSIGN 3863 | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)), 3864 "char", objfile); 3865 objfile_type->builtin_signed_char 3866 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 3867 0, 3868 "signed char", objfile); 3869 objfile_type->builtin_unsigned_char 3870 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 3871 TYPE_FLAG_UNSIGNED, 3872 "unsigned char", objfile); 3873 objfile_type->builtin_short 3874 = init_type (TYPE_CODE_INT, 3875 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, 3876 0, "short", objfile); 3877 objfile_type->builtin_unsigned_short 3878 = init_type (TYPE_CODE_INT, 3879 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, 3880 TYPE_FLAG_UNSIGNED, "unsigned short", objfile); 3881 objfile_type->builtin_int 3882 = init_type (TYPE_CODE_INT, 3883 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 3884 0, "int", objfile); 3885 objfile_type->builtin_unsigned_int 3886 = init_type (TYPE_CODE_INT, 3887 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 3888 TYPE_FLAG_UNSIGNED, "unsigned int", objfile); 3889 objfile_type->builtin_long 3890 = init_type (TYPE_CODE_INT, 3891 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, 3892 0, "long", objfile); 3893 objfile_type->builtin_unsigned_long 3894 = init_type (TYPE_CODE_INT, 3895 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, 3896 TYPE_FLAG_UNSIGNED, "unsigned long", objfile); 3897 objfile_type->builtin_long_long 3898 = init_type (TYPE_CODE_INT, 3899 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT, 3900 0, "long long", objfile); 3901 objfile_type->builtin_unsigned_long_long 3902 = init_type (TYPE_CODE_INT, 3903 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT, 3904 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile); 3905 3906 objfile_type->builtin_float 3907 = init_type (TYPE_CODE_FLT, 3908 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 3909 0, "float", objfile); 3910 TYPE_FLOATFORMAT (objfile_type->builtin_float) 3911 = gdbarch_float_format (gdbarch); 3912 objfile_type->builtin_double 3913 = init_type (TYPE_CODE_FLT, 3914 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 3915 0, "double", objfile); 3916 TYPE_FLOATFORMAT (objfile_type->builtin_double) 3917 = gdbarch_double_format (gdbarch); 3918 objfile_type->builtin_long_double 3919 = init_type (TYPE_CODE_FLT, 3920 gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT, 3921 0, "long double", objfile); 3922 TYPE_FLOATFORMAT (objfile_type->builtin_long_double) 3923 = gdbarch_long_double_format (gdbarch); 3924 3925 /* This type represents a type that was unrecognized in symbol read-in. */ 3926 objfile_type->builtin_error 3927 = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile); 3928 3929 /* The following set of types is used for symbols with no 3930 debug information. */ 3931 objfile_type->nodebug_text_symbol 3932 = init_type (TYPE_CODE_FUNC, 1, 0, 3933 "<text variable, no debug info>", objfile); 3934 TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol) 3935 = objfile_type->builtin_int; 3936 objfile_type->nodebug_text_gnu_ifunc_symbol 3937 = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC, 3938 "<text gnu-indirect-function variable, no debug info>", 3939 objfile); 3940 TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol) 3941 = objfile_type->nodebug_text_symbol; 3942 objfile_type->nodebug_got_plt_symbol 3943 = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0, 3944 "<text from jump slot in .got.plt, no debug info>", 3945 objfile); 3946 TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol) 3947 = objfile_type->nodebug_text_symbol; 3948 objfile_type->nodebug_data_symbol 3949 = init_type (TYPE_CODE_INT, 3950 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0, 3951 "<data variable, no debug info>", objfile); 3952 objfile_type->nodebug_unknown_symbol 3953 = init_type (TYPE_CODE_INT, 1, 0, 3954 "<variable (not text or data), no debug info>", objfile); 3955 objfile_type->nodebug_tls_symbol 3956 = init_type (TYPE_CODE_INT, 3957 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0, 3958 "<thread local variable, no debug info>", objfile); 3959 3960 /* NOTE: on some targets, addresses and pointers are not necessarily 3961 the same --- for example, on the D10V, pointers are 16 bits long, 3962 but addresses are 32 bits long. See doc/gdbint.texinfo, 3963 ``Pointers Are Not Always Addresses''. 3964 3965 The upshot is: 3966 - gdb's `struct type' always describes the target's 3967 representation. 3968 - gdb's `struct value' objects should always hold values in 3969 target form. 3970 - gdb's CORE_ADDR values are addresses in the unified virtual 3971 address space that the assembler and linker work with. Thus, 3972 since target_read_memory takes a CORE_ADDR as an argument, it 3973 can access any memory on the target, even if the processor has 3974 separate code and data address spaces. 3975 3976 So, for example: 3977 - If v is a value holding a D10V code pointer, its contents are 3978 in target form: a big-endian address left-shifted two bits. 3979 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as 3980 sizeof (void *) == 2 on the target. 3981 3982 In this context, objfile_type->builtin_core_addr is a bit odd: 3983 it's a target type for a value the target will never see. It's 3984 only used to hold the values of (typeless) linker symbols, which 3985 are indeed in the unified virtual address space. */ 3986 3987 objfile_type->builtin_core_addr 3988 = init_type (TYPE_CODE_INT, 3989 gdbarch_addr_bit (gdbarch) / 8, 3990 TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile); 3991 3992 set_objfile_data (objfile, objfile_type_data, objfile_type); 3993 return objfile_type; 3994 } 3995 3996 3997 extern void _initialize_gdbtypes (void); 3998 void 3999 _initialize_gdbtypes (void) 4000 { 4001 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init); 4002 objfile_type_data = register_objfile_data (); 4003 4004 add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, 4005 _("Set debugging of C++ overloading."), 4006 _("Show debugging of C++ overloading."), 4007 _("When enabled, ranking of the " 4008 "functions is displayed."), 4009 NULL, 4010 show_overload_debug, 4011 &setdebuglist, &showdebuglist); 4012 4013 /* Add user knob for controlling resolution of opaque types. */ 4014 add_setshow_boolean_cmd ("opaque-type-resolution", class_support, 4015 &opaque_type_resolution, 4016 _("Set resolution of opaque struct/class/union" 4017 " types (if set before loading symbols)."), 4018 _("Show resolution of opaque struct/class/union" 4019 " types (if set before loading symbols)."), 4020 NULL, NULL, 4021 show_opaque_type_resolution, 4022 &setlist, &showlist); 4023 } 4024