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