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