1/* Support for printing C and C++ types for GDB, the GNU debugger. 2 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 3 1999, 2000, 2001, 2002, 2003, 2006, 2007 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20#include "defs.h" 21#include "gdb_obstack.h" 22#include "bfd.h" /* Binary File Description */ 23#include "symtab.h" 24#include "gdbtypes.h" 25#include "expression.h" 26#include "value.h" 27#include "gdbcore.h" 28#include "target.h" 29#include "language.h" 30#include "demangle.h" 31#include "c-lang.h" 32#include "typeprint.h" 33#include "cp-abi.h" 34 35#include "gdb_string.h" 36#include <errno.h> 37 38static void cp_type_print_method_args (struct type *mtype, char *prefix, 39 char *varstring, int staticp, 40 struct ui_file *stream); 41 42static void c_type_print_args (struct type *, struct ui_file *); 43 44static void cp_type_print_derivation_info (struct ui_file *, struct type *); 45 46static void c_type_print_varspec_prefix (struct type *, struct ui_file *, int, 47 int, int); 48 49/* Print "const", "volatile", or address space modifiers. */ 50static void c_type_print_modifier (struct type *, struct ui_file *, 51 int, int); 52 53 54 55 56/* LEVEL is the depth to indent lines by. */ 57 58void 59c_print_type (struct type *type, char *varstring, struct ui_file *stream, 60 int show, int level) 61{ 62 enum type_code code; 63 int demangled_args; 64 int need_post_space; 65 66 if (show > 0) 67 CHECK_TYPEDEF (type); 68 69 c_type_print_base (type, stream, show, level); 70 code = TYPE_CODE (type); 71 if ((varstring != NULL && *varstring != '\0') 72 || 73 /* Need a space if going to print stars or brackets; 74 but not if we will print just a type name. */ 75 ((show > 0 || TYPE_NAME (type) == 0) 76 && 77 (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC 78 || code == TYPE_CODE_METHOD 79 || code == TYPE_CODE_ARRAY 80 || code == TYPE_CODE_MEMBERPTR 81 || code == TYPE_CODE_METHODPTR 82 || code == TYPE_CODE_REF))) 83 fputs_filtered (" ", stream); 84 need_post_space = (varstring != NULL && strcmp (varstring, "") != 0); 85 c_type_print_varspec_prefix (type, stream, show, 0, need_post_space); 86 87 if (varstring != NULL) 88 { 89 fputs_filtered (varstring, stream); 90 91 /* For demangled function names, we have the arglist as part of the name, 92 so don't print an additional pair of ()'s */ 93 94 demangled_args = strchr (varstring, '(') != NULL; 95 c_type_print_varspec_suffix (type, stream, show, 0, demangled_args); 96 } 97} 98 99/* If TYPE is a derived type, then print out derivation information. 100 Print only the actual base classes of this type, not the base classes 101 of the base classes. I.E. for the derivation hierarchy: 102 103 class A { int a; }; 104 class B : public A {int b; }; 105 class C : public B {int c; }; 106 107 Print the type of class C as: 108 109 class C : public B { 110 int c; 111 } 112 113 Not as the following (like gdb used to), which is not legal C++ syntax for 114 derived types and may be confused with the multiple inheritance form: 115 116 class C : public B : public A { 117 int c; 118 } 119 120 In general, gdb should try to print the types as closely as possible to 121 the form that they appear in the source code. 122 Note that in case of protected derivation gcc will not say 'protected' 123 but 'private'. The HP's aCC compiler emits specific information for 124 derivation via protected inheritance, so gdb can print it out */ 125 126static void 127cp_type_print_derivation_info (struct ui_file *stream, struct type *type) 128{ 129 char *name; 130 int i; 131 132 for (i = 0; i < TYPE_N_BASECLASSES (type); i++) 133 { 134 fputs_filtered (i == 0 ? ": " : ", ", stream); 135 fprintf_filtered (stream, "%s%s ", 136 BASETYPE_VIA_PUBLIC (type, i) ? "public" 137 : (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"), 138 BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : ""); 139 name = type_name_no_tag (TYPE_BASECLASS (type, i)); 140 fprintf_filtered (stream, "%s", name ? name : "(null)"); 141 } 142 if (i > 0) 143 { 144 fputs_filtered (" ", stream); 145 } 146} 147 148/* Print the C++ method arguments ARGS to the file STREAM. */ 149 150static void 151cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring, 152 int staticp, struct ui_file *stream) 153{ 154 struct field *args = TYPE_FIELDS (mtype); 155 int nargs = TYPE_NFIELDS (mtype); 156 int varargs = TYPE_VARARGS (mtype); 157 int i; 158 159 fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI); 160 fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI); 161 fputs_filtered ("(", stream); 162 163 /* Skip the class variable. */ 164 i = staticp ? 0 : 1; 165 if (nargs > i) 166 { 167 while (i < nargs) 168 { 169 type_print (args[i++].type, "", stream, 0); 170 171 if (i == nargs && varargs) 172 fprintf_filtered (stream, ", ..."); 173 else if (i < nargs) 174 fprintf_filtered (stream, ", "); 175 } 176 } 177 else if (varargs) 178 fprintf_filtered (stream, "..."); 179 else if (current_language->la_language == language_cplus) 180 fprintf_filtered (stream, "void"); 181 182 fprintf_filtered (stream, ")"); 183} 184 185 186/* Print any asterisks or open-parentheses needed before the 187 variable name (to describe its type). 188 189 On outermost call, pass 0 for PASSED_A_PTR. 190 On outermost call, SHOW > 0 means should ignore 191 any typename for TYPE and show its details. 192 SHOW is always zero on recursive calls. 193 194 NEED_POST_SPACE is non-zero when a space will be be needed 195 between a trailing qualifier and a field, variable, or function 196 name. */ 197 198void 199c_type_print_varspec_prefix (struct type *type, struct ui_file *stream, 200 int show, int passed_a_ptr, int need_post_space) 201{ 202 char *name; 203 if (type == 0) 204 return; 205 206 if (TYPE_NAME (type) && show <= 0) 207 return; 208 209 QUIT; 210 211 switch (TYPE_CODE (type)) 212 { 213 case TYPE_CODE_PTR: 214 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 1); 215 fprintf_filtered (stream, "*"); 216 c_type_print_modifier (type, stream, 1, need_post_space); 217 break; 218 219 case TYPE_CODE_MEMBERPTR: 220 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0); 221 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type)); 222 if (name) 223 fputs_filtered (name, stream); 224 else 225 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr); 226 fprintf_filtered (stream, "::*"); 227 break; 228 229 case TYPE_CODE_METHODPTR: 230 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0); 231 fprintf_filtered (stream, "("); 232 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type)); 233 if (name) 234 fputs_filtered (name, stream); 235 else 236 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr); 237 fprintf_filtered (stream, "::*"); 238 break; 239 240 case TYPE_CODE_REF: 241 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 0); 242 fprintf_filtered (stream, "&"); 243 c_type_print_modifier (type, stream, 1, need_post_space); 244 break; 245 246 case TYPE_CODE_METHOD: 247 case TYPE_CODE_FUNC: 248 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0); 249 if (passed_a_ptr) 250 fprintf_filtered (stream, "("); 251 break; 252 253 case TYPE_CODE_ARRAY: 254 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0); 255 if (passed_a_ptr) 256 fprintf_filtered (stream, "("); 257 break; 258 259 case TYPE_CODE_TYPEDEF: 260 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0); 261 break; 262 263 case TYPE_CODE_UNDEF: 264 case TYPE_CODE_STRUCT: 265 case TYPE_CODE_UNION: 266 case TYPE_CODE_ENUM: 267 case TYPE_CODE_INT: 268 case TYPE_CODE_FLT: 269 case TYPE_CODE_VOID: 270 case TYPE_CODE_ERROR: 271 case TYPE_CODE_CHAR: 272 case TYPE_CODE_BOOL: 273 case TYPE_CODE_SET: 274 case TYPE_CODE_RANGE: 275 case TYPE_CODE_STRING: 276 case TYPE_CODE_BITSTRING: 277 case TYPE_CODE_COMPLEX: 278 case TYPE_CODE_TEMPLATE: 279 case TYPE_CODE_NAMESPACE: 280 /* These types need no prefix. They are listed here so that 281 gcc -Wall will reveal any types that haven't been handled. */ 282 break; 283 default: 284 error (_("type not handled in c_type_print_varspec_prefix()")); 285 break; 286 } 287} 288 289/* Print out "const" and "volatile" attributes. 290 TYPE is a pointer to the type being printed out. 291 STREAM is the output destination. 292 NEED_SPACE = 1 indicates an initial white space is needed */ 293 294static void 295c_type_print_modifier (struct type *type, struct ui_file *stream, 296 int need_pre_space, int need_post_space) 297{ 298 int did_print_modifier = 0; 299 const char *address_space_id; 300 301 /* We don't print `const' qualifiers for references --- since all 302 operators affect the thing referenced, not the reference itself, 303 every reference is `const'. */ 304 if (TYPE_CONST (type) 305 && TYPE_CODE (type) != TYPE_CODE_REF) 306 { 307 if (need_pre_space) 308 fprintf_filtered (stream, " "); 309 fprintf_filtered (stream, "const"); 310 did_print_modifier = 1; 311 } 312 313 if (TYPE_VOLATILE (type)) 314 { 315 if (did_print_modifier || need_pre_space) 316 fprintf_filtered (stream, " "); 317 fprintf_filtered (stream, "volatile"); 318 did_print_modifier = 1; 319 } 320 321 address_space_id = address_space_int_to_name (TYPE_INSTANCE_FLAGS (type)); 322 if (address_space_id) 323 { 324 if (did_print_modifier || need_pre_space) 325 fprintf_filtered (stream, " "); 326 fprintf_filtered (stream, "@%s", address_space_id); 327 did_print_modifier = 1; 328 } 329 330 if (did_print_modifier && need_post_space) 331 fprintf_filtered (stream, " "); 332} 333 334 335/* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD 336 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this" 337 in non-static methods, are displayed. */ 338 339static void 340c_type_print_args (struct type *type, struct ui_file *stream) 341{ 342 int i, len; 343 struct field *args; 344 int printed_any = 0; 345 346 fprintf_filtered (stream, "("); 347 args = TYPE_FIELDS (type); 348 len = TYPE_NFIELDS (type); 349 350 for (i = 0; i < TYPE_NFIELDS (type); i++) 351 { 352 if (printed_any) 353 { 354 fprintf_filtered (stream, ", "); 355 wrap_here (" "); 356 } 357 358 c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0); 359 printed_any = 1; 360 } 361 362 if (printed_any && TYPE_VARARGS (type)) 363 { 364 /* Print out a trailing ellipsis for varargs functions. Ignore 365 TYPE_VARARGS if the function has no named arguments; that 366 represents unprototyped (K&R style) C functions. */ 367 if (printed_any && TYPE_VARARGS (type)) 368 { 369 fprintf_filtered (stream, ", "); 370 wrap_here (" "); 371 fprintf_filtered (stream, "..."); 372 } 373 } 374 else if (!printed_any 375 && (TYPE_PROTOTYPED (type) 376 || current_language->la_language == language_cplus)) 377 fprintf_filtered (stream, "void"); 378 379 fprintf_filtered (stream, ")"); 380} 381 382 383/* Return true iff the j'th overloading of the i'th method of TYPE 384 is a type conversion operator, like `operator int () { ... }'. 385 When listing a class's methods, we don't print the return type of 386 such operators. */ 387static int 388is_type_conversion_operator (struct type *type, int i, int j) 389{ 390 /* I think the whole idea of recognizing type conversion operators 391 by their name is pretty terrible. But I don't think our present 392 data structure gives us any other way to tell. If you know of 393 some other way, feel free to rewrite this function. */ 394 char *name = TYPE_FN_FIELDLIST_NAME (type, i); 395 396 if (strncmp (name, "operator", 8) != 0) 397 return 0; 398 399 name += 8; 400 if (! strchr (" \t\f\n\r", *name)) 401 return 0; 402 403 while (strchr (" \t\f\n\r", *name)) 404 name++; 405 406 if (!('a' <= *name && *name <= 'z') 407 && !('A' <= *name && *name <= 'Z') 408 && *name != '_') 409 /* If this doesn't look like the start of an identifier, then it 410 isn't a type conversion operator. */ 411 return 0; 412 else if (strncmp (name, "new", 3) == 0) 413 name += 3; 414 else if (strncmp (name, "delete", 6) == 0) 415 name += 6; 416 else 417 /* If it doesn't look like new or delete, it's a type conversion 418 operator. */ 419 return 1; 420 421 /* Is that really the end of the name? */ 422 if (('a' <= *name && *name <= 'z') 423 || ('A' <= *name && *name <= 'Z') 424 || ('0' <= *name && *name <= '9') 425 || *name == '_') 426 /* No, so the identifier following "operator" must be a type name, 427 and this is a type conversion operator. */ 428 return 1; 429 430 /* That was indeed the end of the name, so it was `operator new' or 431 `operator delete', neither of which are type conversion operators. */ 432 return 0; 433} 434 435 436/* Given a C++ qualified identifier QID, strip off the qualifiers, 437 yielding the unqualified name. The return value is a pointer into 438 the original string. 439 440 It's a pity we don't have this information in some more structured 441 form. Even the author of this function feels that writing little 442 parsers like this everywhere is stupid. */ 443static char * 444remove_qualifiers (char *qid) 445{ 446 int quoted = 0; /* zero if we're not in quotes; 447 '"' if we're in a double-quoted string; 448 '\'' if we're in a single-quoted string. */ 449 int depth = 0; /* number of unclosed parens we've seen */ 450 char *parenstack = (char *) alloca (strlen (qid)); 451 char *scan; 452 char *last = 0; /* The character after the rightmost 453 `::' token we've seen so far. */ 454 455 for (scan = qid; *scan; scan++) 456 { 457 if (quoted) 458 { 459 if (*scan == quoted) 460 quoted = 0; 461 else if (*scan == '\\' && *(scan + 1)) 462 scan++; 463 } 464 else if (scan[0] == ':' && scan[1] == ':') 465 { 466 /* If we're inside parenthesis (i.e., an argument list) or 467 angle brackets (i.e., a list of template arguments), then 468 we don't record the position of this :: token, since it's 469 not relevant to the top-level structure we're trying 470 to operate on. */ 471 if (depth == 0) 472 { 473 last = scan + 2; 474 scan++; 475 } 476 } 477 else if (*scan == '"' || *scan == '\'') 478 quoted = *scan; 479 else if (*scan == '(') 480 parenstack[depth++] = ')'; 481 else if (*scan == '[') 482 parenstack[depth++] = ']'; 483 /* We're going to treat <> as a pair of matching characters, 484 since we're more likely to see those in template id's than 485 real less-than characters. What a crock. */ 486 else if (*scan == '<') 487 parenstack[depth++] = '>'; 488 else if (*scan == ')' || *scan == ']' || *scan == '>') 489 { 490 if (depth > 0 && parenstack[depth - 1] == *scan) 491 depth--; 492 else 493 { 494 /* We're going to do a little error recovery here. If we 495 don't find a match for *scan on the paren stack, but 496 there is something lower on the stack that does match, we 497 pop the stack to that point. */ 498 int i; 499 500 for (i = depth - 1; i >= 0; i--) 501 if (parenstack[i] == *scan) 502 { 503 depth = i; 504 break; 505 } 506 } 507 } 508 } 509 510 if (last) 511 return last; 512 else 513 /* We didn't find any :: tokens at the top level, so declare the 514 whole thing an unqualified identifier. */ 515 return qid; 516} 517 518 519/* Print any array sizes, function arguments or close parentheses 520 needed after the variable name (to describe its type). 521 Args work like c_type_print_varspec_prefix. */ 522 523void 524c_type_print_varspec_suffix (struct type *type, struct ui_file *stream, 525 int show, int passed_a_ptr, int demangled_args) 526{ 527 if (type == 0) 528 return; 529 530 if (TYPE_NAME (type) && show <= 0) 531 return; 532 533 QUIT; 534 535 switch (TYPE_CODE (type)) 536 { 537 case TYPE_CODE_ARRAY: 538 if (passed_a_ptr) 539 fprintf_filtered (stream, ")"); 540 541 fprintf_filtered (stream, "["); 542 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0 543 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED) 544 fprintf_filtered (stream, "%d", 545 (TYPE_LENGTH (type) 546 / TYPE_LENGTH (TYPE_TARGET_TYPE (type)))); 547 fprintf_filtered (stream, "]"); 548 549 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show, 550 0, 0); 551 break; 552 553 case TYPE_CODE_MEMBERPTR: 554 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show, 555 0, 0); 556 break; 557 558 case TYPE_CODE_METHODPTR: 559 fprintf_filtered (stream, ")"); 560 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show, 561 0, 0); 562 break; 563 564 case TYPE_CODE_PTR: 565 case TYPE_CODE_REF: 566 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show, 567 1, 0); 568 break; 569 570 case TYPE_CODE_METHOD: 571 case TYPE_CODE_FUNC: 572 if (passed_a_ptr) 573 fprintf_filtered (stream, ")"); 574 if (!demangled_args) 575 c_type_print_args (type, stream); 576 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show, 577 passed_a_ptr, 0); 578 break; 579 580 case TYPE_CODE_TYPEDEF: 581 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show, 582 passed_a_ptr, 0); 583 break; 584 585 case TYPE_CODE_UNDEF: 586 case TYPE_CODE_STRUCT: 587 case TYPE_CODE_UNION: 588 case TYPE_CODE_ENUM: 589 case TYPE_CODE_INT: 590 case TYPE_CODE_FLT: 591 case TYPE_CODE_VOID: 592 case TYPE_CODE_ERROR: 593 case TYPE_CODE_CHAR: 594 case TYPE_CODE_BOOL: 595 case TYPE_CODE_SET: 596 case TYPE_CODE_RANGE: 597 case TYPE_CODE_STRING: 598 case TYPE_CODE_BITSTRING: 599 case TYPE_CODE_COMPLEX: 600 case TYPE_CODE_TEMPLATE: 601 case TYPE_CODE_NAMESPACE: 602 /* These types do not need a suffix. They are listed so that 603 gcc -Wall will report types that may not have been considered. */ 604 break; 605 default: 606 error (_("type not handled in c_type_print_varspec_suffix()")); 607 break; 608 } 609} 610 611/* Print the name of the type (or the ultimate pointer target, 612 function value or array element), or the description of a 613 structure or union. 614 615 SHOW positive means print details about the type (e.g. enum values), 616 and print structure elements passing SHOW - 1 for show. 617 SHOW negative means just print the type name or struct tag if there is one. 618 If there is no name, print something sensible but concise like 619 "struct {...}". 620 SHOW zero means just print the type name or struct tag if there is one. 621 If there is no name, print something sensible but not as concise like 622 "struct {int x; int y;}". 623 624 LEVEL is the number of spaces to indent by. 625 We increase it for some recursive calls. */ 626 627void 628c_type_print_base (struct type *type, struct ui_file *stream, int show, 629 int level) 630{ 631 int i; 632 int len, real_len; 633 int lastval; 634 char *mangled_name; 635 char *demangled_name; 636 char *demangled_no_static; 637 enum 638 { 639 s_none, s_public, s_private, s_protected 640 } 641 section_type; 642 int need_access_label = 0; 643 int j, len2; 644 645 QUIT; 646 647 wrap_here (" "); 648 if (type == NULL) 649 { 650 fputs_filtered (_("<type unknown>"), stream); 651 return; 652 } 653 654 /* When SHOW is zero or less, and there is a valid type name, then always 655 just print the type name directly from the type. */ 656 /* If we have "typedef struct foo {. . .} bar;" do we want to print it 657 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend 658 to expect things like "class5 *foo" rather than "struct class5 *foo". */ 659 660 if (show <= 0 661 && TYPE_NAME (type) != NULL) 662 { 663 c_type_print_modifier (type, stream, 0, 1); 664 fputs_filtered (TYPE_NAME (type), stream); 665 return; 666 } 667 668 CHECK_TYPEDEF (type); 669 670 switch (TYPE_CODE (type)) 671 { 672 case TYPE_CODE_TYPEDEF: 673 case TYPE_CODE_ARRAY: 674 case TYPE_CODE_PTR: 675 case TYPE_CODE_MEMBERPTR: 676 case TYPE_CODE_REF: 677 case TYPE_CODE_FUNC: 678 case TYPE_CODE_METHOD: 679 case TYPE_CODE_METHODPTR: 680 c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level); 681 break; 682 683 case TYPE_CODE_STRUCT: 684 c_type_print_modifier (type, stream, 0, 1); 685 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value, 686 * so we use another means for distinguishing them. 687 */ 688 if (HAVE_CPLUS_STRUCT (type)) 689 { 690 switch (TYPE_DECLARED_TYPE (type)) 691 { 692 case DECLARED_TYPE_CLASS: 693 fprintf_filtered (stream, "class "); 694 break; 695 case DECLARED_TYPE_UNION: 696 fprintf_filtered (stream, "union "); 697 break; 698 case DECLARED_TYPE_STRUCT: 699 fprintf_filtered (stream, "struct "); 700 break; 701 default: 702 /* If there is a CPLUS_STRUCT, assume class if not 703 * otherwise specified in the declared_type field. 704 */ 705 fprintf_filtered (stream, "class "); 706 break; 707 } /* switch */ 708 } 709 else 710 { 711 /* If not CPLUS_STRUCT, then assume it's a C struct */ 712 fprintf_filtered (stream, "struct "); 713 } 714 goto struct_union; 715 716 case TYPE_CODE_UNION: 717 c_type_print_modifier (type, stream, 0, 1); 718 fprintf_filtered (stream, "union "); 719 720 struct_union: 721 722 /* Print the tag if it exists. 723 * The HP aCC compiler emits 724 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}" 725 * tag for unnamed struct/union/enum's, which we don't 726 * want to print. 727 */ 728 if (TYPE_TAG_NAME (type) != NULL && 729 strncmp (TYPE_TAG_NAME (type), "{unnamed", 8)) 730 { 731 fputs_filtered (TYPE_TAG_NAME (type), stream); 732 if (show > 0) 733 fputs_filtered (" ", stream); 734 } 735 wrap_here (" "); 736 if (show < 0) 737 { 738 /* If we just printed a tag name, no need to print anything else. */ 739 if (TYPE_TAG_NAME (type) == NULL) 740 fprintf_filtered (stream, "{...}"); 741 } 742 else if (show > 0 || TYPE_TAG_NAME (type) == NULL) 743 { 744 cp_type_print_derivation_info (stream, type); 745 746 fprintf_filtered (stream, "{\n"); 747 if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0)) 748 { 749 if (TYPE_STUB (type)) 750 fprintfi_filtered (level + 4, stream, _("<incomplete type>\n")); 751 else 752 fprintfi_filtered (level + 4, stream, _("<no data fields>\n")); 753 } 754 755 /* Start off with no specific section type, so we can print 756 one for the first field we find, and use that section type 757 thereafter until we find another type. */ 758 759 section_type = s_none; 760 761 /* For a class, if all members are private, there's no need 762 for a "private:" label; similarly, for a struct or union 763 masquerading as a class, if all members are public, there's 764 no need for a "public:" label. */ 765 766 if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_CLASS) || 767 (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_TEMPLATE)) 768 { 769 QUIT; 770 len = TYPE_NFIELDS (type); 771 for (i = TYPE_N_BASECLASSES (type); i < len; i++) 772 if (!TYPE_FIELD_PRIVATE (type, i)) 773 { 774 need_access_label = 1; 775 break; 776 } 777 QUIT; 778 if (!need_access_label) 779 { 780 len2 = TYPE_NFN_FIELDS (type); 781 for (j = 0; j < len2; j++) 782 { 783 len = TYPE_FN_FIELDLIST_LENGTH (type, j); 784 for (i = 0; i < len; i++) 785 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i)) 786 { 787 need_access_label = 1; 788 break; 789 } 790 if (need_access_label) 791 break; 792 } 793 } 794 } 795 else if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_STRUCT) || 796 (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION)) 797 { 798 QUIT; 799 len = TYPE_NFIELDS (type); 800 for (i = TYPE_N_BASECLASSES (type); i < len; i++) 801 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i)) 802 { 803 need_access_label = 1; 804 break; 805 } 806 QUIT; 807 if (!need_access_label) 808 { 809 len2 = TYPE_NFN_FIELDS (type); 810 for (j = 0; j < len2; j++) 811 { 812 QUIT; 813 len = TYPE_FN_FIELDLIST_LENGTH (type, j); 814 for (i = 0; i < len; i++) 815 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i) || 816 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i)) 817 { 818 need_access_label = 1; 819 break; 820 } 821 if (need_access_label) 822 break; 823 } 824 } 825 } 826 827 /* If there is a base class for this type, 828 do not print the field that it occupies. */ 829 830 len = TYPE_NFIELDS (type); 831 for (i = TYPE_N_BASECLASSES (type); i < len; i++) 832 { 833 QUIT; 834 /* Don't print out virtual function table. */ 835 /* HP ANSI C++ case */ 836 if (TYPE_HAS_VTABLE (type) 837 && (strncmp (TYPE_FIELD_NAME (type, i), "__vfp", 5) == 0)) 838 continue; 839 /* Other compilers */ 840 if (strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5) == 0 841 && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5])) 842 continue; 843 844 /* If this is a C++ class we can print the various C++ section 845 labels. */ 846 847 if (HAVE_CPLUS_STRUCT (type) && need_access_label) 848 { 849 if (TYPE_FIELD_PROTECTED (type, i)) 850 { 851 if (section_type != s_protected) 852 { 853 section_type = s_protected; 854 fprintfi_filtered (level + 2, stream, 855 "protected:\n"); 856 } 857 } 858 else if (TYPE_FIELD_PRIVATE (type, i)) 859 { 860 if (section_type != s_private) 861 { 862 section_type = s_private; 863 fprintfi_filtered (level + 2, stream, "private:\n"); 864 } 865 } 866 else 867 { 868 if (section_type != s_public) 869 { 870 section_type = s_public; 871 fprintfi_filtered (level + 2, stream, "public:\n"); 872 } 873 } 874 } 875 876 print_spaces_filtered (level + 4, stream); 877 if (TYPE_FIELD_STATIC (type, i)) 878 { 879 fprintf_filtered (stream, "static "); 880 } 881 c_print_type (TYPE_FIELD_TYPE (type, i), 882 TYPE_FIELD_NAME (type, i), 883 stream, show - 1, level + 4); 884 if (!TYPE_FIELD_STATIC (type, i) 885 && TYPE_FIELD_PACKED (type, i)) 886 { 887 /* It is a bitfield. This code does not attempt 888 to look at the bitpos and reconstruct filler, 889 unnamed fields. This would lead to misleading 890 results if the compiler does not put out fields 891 for such things (I don't know what it does). */ 892 fprintf_filtered (stream, " : %d", 893 TYPE_FIELD_BITSIZE (type, i)); 894 } 895 fprintf_filtered (stream, ";\n"); 896 } 897 898 /* If there are both fields and methods, put a blank line 899 between them. Make sure to count only method that we will 900 display; artificial methods will be hidden. */ 901 len = TYPE_NFN_FIELDS (type); 902 real_len = 0; 903 for (i = 0; i < len; i++) 904 { 905 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i); 906 int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i); 907 int j; 908 for (j = 0; j < len2; j++) 909 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j)) 910 real_len++; 911 } 912 if (real_len > 0 && section_type != s_none) 913 fprintf_filtered (stream, "\n"); 914 915 /* C++: print out the methods */ 916 for (i = 0; i < len; i++) 917 { 918 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i); 919 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i); 920 char *method_name = TYPE_FN_FIELDLIST_NAME (type, i); 921 char *name = type_name_no_tag (type); 922 int is_constructor = name && strcmp (method_name, name) == 0; 923 for (j = 0; j < len2; j++) 924 { 925 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); 926 int is_full_physname_constructor = 927 is_constructor_name (physname) 928 || is_destructor_name (physname) 929 || method_name[0] == '~'; 930 931 /* Do not print out artificial methods. */ 932 if (TYPE_FN_FIELD_ARTIFICIAL (f, j)) 933 continue; 934 935 QUIT; 936 if (TYPE_FN_FIELD_PROTECTED (f, j)) 937 { 938 if (section_type != s_protected) 939 { 940 section_type = s_protected; 941 fprintfi_filtered (level + 2, stream, 942 "protected:\n"); 943 } 944 } 945 else if (TYPE_FN_FIELD_PRIVATE (f, j)) 946 { 947 if (section_type != s_private) 948 { 949 section_type = s_private; 950 fprintfi_filtered (level + 2, stream, "private:\n"); 951 } 952 } 953 else 954 { 955 if (section_type != s_public) 956 { 957 section_type = s_public; 958 fprintfi_filtered (level + 2, stream, "public:\n"); 959 } 960 } 961 962 print_spaces_filtered (level + 4, stream); 963 if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) 964 fprintf_filtered (stream, "virtual "); 965 else if (TYPE_FN_FIELD_STATIC_P (f, j)) 966 fprintf_filtered (stream, "static "); 967 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0) 968 { 969 /* Keep GDB from crashing here. */ 970 fprintf_filtered (stream, _("<undefined type> %s;\n"), 971 TYPE_FN_FIELD_PHYSNAME (f, j)); 972 break; 973 } 974 else if (!is_constructor && /* constructors don't have declared types */ 975 !is_full_physname_constructor && /* " " */ 976 !is_type_conversion_operator (type, i, j)) 977 { 978 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)), 979 "", stream, -1); 980 fputs_filtered (" ", stream); 981 } 982 if (TYPE_FN_FIELD_STUB (f, j)) 983 /* Build something we can demangle. */ 984 mangled_name = gdb_mangle_name (type, i, j); 985 else 986 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j); 987 988 demangled_name = 989 cplus_demangle (mangled_name, 990 DMGL_ANSI | DMGL_PARAMS); 991 if (demangled_name == NULL) 992 { 993 /* in some cases (for instance with the HP demangling), 994 if a function has more than 10 arguments, 995 the demangling will fail. 996 Let's try to reconstruct the function signature from 997 the symbol information */ 998 if (!TYPE_FN_FIELD_STUB (f, j)) 999 { 1000 int staticp = TYPE_FN_FIELD_STATIC_P (f, j); 1001 struct type *mtype = TYPE_FN_FIELD_TYPE (f, j); 1002 cp_type_print_method_args (mtype, 1003 "", 1004 method_name, 1005 staticp, 1006 stream); 1007 } 1008 else 1009 fprintf_filtered (stream, _("<badly mangled name '%s'>"), 1010 mangled_name); 1011 } 1012 else 1013 { 1014 char *p; 1015 char *demangled_no_class 1016 = remove_qualifiers (demangled_name); 1017 1018 /* get rid of the `static' appended by the demangler */ 1019 p = strstr (demangled_no_class, " static"); 1020 if (p != NULL) 1021 { 1022 int length = p - demangled_no_class; 1023 demangled_no_static = (char *) xmalloc (length + 1); 1024 strncpy (demangled_no_static, demangled_no_class, length); 1025 *(demangled_no_static + length) = '\0'; 1026 fputs_filtered (demangled_no_static, stream); 1027 xfree (demangled_no_static); 1028 } 1029 else 1030 fputs_filtered (demangled_no_class, stream); 1031 xfree (demangled_name); 1032 } 1033 1034 if (TYPE_FN_FIELD_STUB (f, j)) 1035 xfree (mangled_name); 1036 1037 fprintf_filtered (stream, ";\n"); 1038 } 1039 } 1040 1041 fprintfi_filtered (level, stream, "}"); 1042 1043 if (TYPE_LOCALTYPE_PTR (type) && show >= 0) 1044 fprintfi_filtered (level, stream, _(" (Local at %s:%d)\n"), 1045 TYPE_LOCALTYPE_FILE (type), 1046 TYPE_LOCALTYPE_LINE (type)); 1047 } 1048 if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE) 1049 goto go_back; 1050 break; 1051 1052 case TYPE_CODE_ENUM: 1053 c_type_print_modifier (type, stream, 0, 1); 1054 fprintf_filtered (stream, "enum "); 1055 /* Print the tag name if it exists. 1056 The aCC compiler emits a spurious 1057 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}" 1058 tag for unnamed struct/union/enum's, which we don't 1059 want to print. */ 1060 if (TYPE_TAG_NAME (type) != NULL && 1061 strncmp (TYPE_TAG_NAME (type), "{unnamed", 8)) 1062 { 1063 fputs_filtered (TYPE_TAG_NAME (type), stream); 1064 if (show > 0) 1065 fputs_filtered (" ", stream); 1066 } 1067 1068 wrap_here (" "); 1069 if (show < 0) 1070 { 1071 /* If we just printed a tag name, no need to print anything else. */ 1072 if (TYPE_TAG_NAME (type) == NULL) 1073 fprintf_filtered (stream, "{...}"); 1074 } 1075 else if (show > 0 || TYPE_TAG_NAME (type) == NULL) 1076 { 1077 fprintf_filtered (stream, "{"); 1078 len = TYPE_NFIELDS (type); 1079 lastval = 0; 1080 for (i = 0; i < len; i++) 1081 { 1082 QUIT; 1083 if (i) 1084 fprintf_filtered (stream, ", "); 1085 wrap_here (" "); 1086 fputs_filtered (TYPE_FIELD_NAME (type, i), stream); 1087 if (lastval != TYPE_FIELD_BITPOS (type, i)) 1088 { 1089 fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i)); 1090 lastval = TYPE_FIELD_BITPOS (type, i); 1091 } 1092 lastval++; 1093 } 1094 fprintf_filtered (stream, "}"); 1095 } 1096 break; 1097 1098 case TYPE_CODE_VOID: 1099 fprintf_filtered (stream, "void"); 1100 break; 1101 1102 case TYPE_CODE_UNDEF: 1103 fprintf_filtered (stream, _("struct <unknown>")); 1104 break; 1105 1106 case TYPE_CODE_ERROR: 1107 fprintf_filtered (stream, _("<unknown type>")); 1108 break; 1109 1110 case TYPE_CODE_RANGE: 1111 /* This should not occur */ 1112 fprintf_filtered (stream, _("<range type>")); 1113 break; 1114 1115 case TYPE_CODE_TEMPLATE: 1116 /* Called on "ptype t" where "t" is a template. 1117 Prints the template header (with args), e.g.: 1118 template <class T1, class T2> class " 1119 and then merges with the struct/union/class code to 1120 print the rest of the definition. */ 1121 c_type_print_modifier (type, stream, 0, 1); 1122 fprintf_filtered (stream, "template <"); 1123 for (i = 0; i < TYPE_NTEMPLATE_ARGS (type); i++) 1124 { 1125 struct template_arg templ_arg; 1126 templ_arg = TYPE_TEMPLATE_ARG (type, i); 1127 fprintf_filtered (stream, "class %s", templ_arg.name); 1128 if (i < TYPE_NTEMPLATE_ARGS (type) - 1) 1129 fprintf_filtered (stream, ", "); 1130 } 1131 fprintf_filtered (stream, "> class "); 1132 /* Yuck, factor this out to a subroutine so we can call 1133 it and return to the point marked with the "goback:" label... - RT */ 1134 goto struct_union; 1135 go_back: 1136 if (TYPE_NINSTANTIATIONS (type) > 0) 1137 { 1138 fprintf_filtered (stream, _("\ntemplate instantiations:\n")); 1139 for (i = 0; i < TYPE_NINSTANTIATIONS (type); i++) 1140 { 1141 fprintf_filtered (stream, " "); 1142 c_type_print_base (TYPE_INSTANTIATION (type, i), stream, 0, level); 1143 if (i < TYPE_NINSTANTIATIONS (type) - 1) 1144 fprintf_filtered (stream, "\n"); 1145 } 1146 } 1147 break; 1148 1149 case TYPE_CODE_NAMESPACE: 1150 fputs_filtered ("namespace ", stream); 1151 fputs_filtered (TYPE_TAG_NAME (type), stream); 1152 break; 1153 1154 default: 1155 /* Handle types not explicitly handled by the other cases, 1156 such as fundamental types. For these, just print whatever 1157 the type name is, as recorded in the type itself. If there 1158 is no type name, then complain. */ 1159 if (TYPE_NAME (type) != NULL) 1160 { 1161 c_type_print_modifier (type, stream, 0, 1); 1162 fputs_filtered (TYPE_NAME (type), stream); 1163 } 1164 else 1165 { 1166 /* At least for dump_symtab, it is important that this not be 1167 an error (). */ 1168 fprintf_filtered (stream, _("<invalid type code %d>"), 1169 TYPE_CODE (type)); 1170 } 1171 break; 1172 } 1173} 1174