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