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