1 /* Helper routines for C++ support in GDB. 2 Copyright (C) 2002-2015 Free Software Foundation, Inc. 3 4 Contributed by MontaVista Software. 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 "cp-support.h" 23 #include "demangle.h" 24 #include "gdbcmd.h" 25 #include "dictionary.h" 26 #include "objfiles.h" 27 #include "frame.h" 28 #include "symtab.h" 29 #include "block.h" 30 #include "complaints.h" 31 #include "gdbtypes.h" 32 #include "expression.h" 33 #include "value.h" 34 #include "cp-abi.h" 35 #include <signal.h> 36 37 #include "safe-ctype.h" 38 39 #define d_left(dc) (dc)->u.s_binary.left 40 #define d_right(dc) (dc)->u.s_binary.right 41 42 /* Functions related to demangled name parsing. */ 43 44 static unsigned int cp_find_first_component_aux (const char *name, 45 int permissive); 46 47 static void demangled_name_complaint (const char *name); 48 49 /* Functions/variables related to overload resolution. */ 50 51 static int sym_return_val_size = -1; 52 static int sym_return_val_index; 53 static struct symbol **sym_return_val; 54 55 static void overload_list_add_symbol (struct symbol *sym, 56 const char *oload_name); 57 58 static void make_symbol_overload_list_using (const char *func_name, 59 const char *the_namespace); 60 61 static void make_symbol_overload_list_qualified (const char *func_name); 62 63 /* The list of "maint cplus" commands. */ 64 65 struct cmd_list_element *maint_cplus_cmd_list = NULL; 66 67 /* The actual commands. */ 68 69 static void maint_cplus_command (char *arg, int from_tty); 70 static void first_component_command (char *arg, int from_tty); 71 72 /* A list of typedefs which should not be substituted by replace_typedefs. */ 73 static const char * const ignore_typedefs[] = 74 { 75 "std::istream", "std::iostream", "std::ostream", "std::string" 76 }; 77 78 static void 79 replace_typedefs (struct demangle_parse_info *info, 80 struct demangle_component *ret_comp, 81 canonicalization_ftype *finder, 82 void *data); 83 84 /* A convenience function to copy STRING into OBSTACK, returning a pointer 85 to the newly allocated string and saving the number of bytes saved in LEN. 86 87 It does not copy the terminating '\0' byte! */ 88 89 static char * 90 copy_string_to_obstack (struct obstack *obstack, const char *string, 91 long *len) 92 { 93 *len = strlen (string); 94 return obstack_copy (obstack, string, *len); 95 } 96 97 /* A cleanup wrapper for cp_demangled_name_parse_free. */ 98 99 static void 100 do_demangled_name_parse_free_cleanup (void *data) 101 { 102 struct demangle_parse_info *info = (struct demangle_parse_info *) data; 103 104 cp_demangled_name_parse_free (info); 105 } 106 107 /* Create a cleanup for C++ name parsing. */ 108 109 struct cleanup * 110 make_cleanup_cp_demangled_name_parse_free (struct demangle_parse_info *info) 111 { 112 return make_cleanup (do_demangled_name_parse_free_cleanup, info); 113 } 114 115 /* Return 1 if STRING is clearly already in canonical form. This 116 function is conservative; things which it does not recognize are 117 assumed to be non-canonical, and the parser will sort them out 118 afterwards. This speeds up the critical path for alphanumeric 119 identifiers. */ 120 121 static int 122 cp_already_canonical (const char *string) 123 { 124 /* Identifier start character [a-zA-Z_]. */ 125 if (!ISIDST (string[0])) 126 return 0; 127 128 /* These are the only two identifiers which canonicalize to other 129 than themselves or an error: unsigned -> unsigned int and 130 signed -> int. */ 131 if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0) 132 return 0; 133 else if (string[0] == 's' && strcmp (&string[1], "igned") == 0) 134 return 0; 135 136 /* Identifier character [a-zA-Z0-9_]. */ 137 while (ISIDNUM (string[1])) 138 string++; 139 140 if (string[1] == '\0') 141 return 1; 142 else 143 return 0; 144 } 145 146 /* Inspect the given RET_COMP for its type. If it is a typedef, 147 replace the node with the typedef's tree. 148 149 Returns 1 if any typedef substitutions were made, 0 otherwise. */ 150 151 static int 152 inspect_type (struct demangle_parse_info *info, 153 struct demangle_component *ret_comp, 154 canonicalization_ftype *finder, 155 void *data) 156 { 157 int i; 158 char *name; 159 struct symbol *sym; 160 161 /* Copy the symbol's name from RET_COMP and look it up 162 in the symbol table. */ 163 name = (char *) alloca (ret_comp->u.s_name.len + 1); 164 memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len); 165 name[ret_comp->u.s_name.len] = '\0'; 166 167 /* Ignore any typedefs that should not be substituted. */ 168 for (i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i) 169 { 170 if (strcmp (name, ignore_typedefs[i]) == 0) 171 return 0; 172 } 173 174 sym = NULL; 175 176 TRY 177 { 178 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0); 179 } 180 CATCH (except, RETURN_MASK_ALL) 181 { 182 return 0; 183 } 184 END_CATCH 185 186 if (sym != NULL) 187 { 188 struct type *otype = SYMBOL_TYPE (sym); 189 190 if (finder != NULL) 191 { 192 const char *new_name = (*finder) (otype, data); 193 194 if (new_name != NULL) 195 { 196 ret_comp->u.s_name.s = new_name; 197 ret_comp->u.s_name.len = strlen (new_name); 198 return 1; 199 } 200 201 return 0; 202 } 203 204 /* If the type is a typedef or namespace alias, replace it. */ 205 if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF 206 || TYPE_CODE (otype) == TYPE_CODE_NAMESPACE) 207 { 208 long len; 209 int is_anon; 210 struct type *type; 211 struct demangle_parse_info *i; 212 struct ui_file *buf; 213 214 /* Get the real type of the typedef. */ 215 type = check_typedef (otype); 216 217 /* If the symbol is a namespace and its type name is no different 218 than the name we looked up, this symbol is not a namespace 219 alias and does not need to be substituted. */ 220 if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE 221 && strcmp (TYPE_NAME (type), name) == 0) 222 return 0; 223 224 is_anon = (TYPE_TAG_NAME (type) == NULL 225 && (TYPE_CODE (type) == TYPE_CODE_ENUM 226 || TYPE_CODE (type) == TYPE_CODE_STRUCT 227 || TYPE_CODE (type) == TYPE_CODE_UNION)); 228 if (is_anon) 229 { 230 struct type *last = otype; 231 232 /* Find the last typedef for the type. */ 233 while (TYPE_TARGET_TYPE (last) != NULL 234 && (TYPE_CODE (TYPE_TARGET_TYPE (last)) 235 == TYPE_CODE_TYPEDEF)) 236 last = TYPE_TARGET_TYPE (last); 237 238 /* If there is only one typedef for this anonymous type, 239 do not substitute it. */ 240 if (type == otype) 241 return 0; 242 else 243 /* Use the last typedef seen as the type for this 244 anonymous type. */ 245 type = last; 246 } 247 248 buf = mem_fileopen (); 249 TRY 250 { 251 type_print (type, "", buf, -1); 252 } 253 254 /* If type_print threw an exception, there is little point 255 in continuing, so just bow out gracefully. */ 256 CATCH (except, RETURN_MASK_ERROR) 257 { 258 ui_file_delete (buf); 259 return 0; 260 } 261 END_CATCH 262 263 name = ui_file_obsavestring (buf, &info->obstack, &len); 264 ui_file_delete (buf); 265 266 /* Turn the result into a new tree. Note that this 267 tree will contain pointers into NAME, so NAME cannot 268 be free'd until all typedef conversion is done and 269 the final result is converted into a string. */ 270 i = cp_demangled_name_to_comp (name, NULL); 271 if (i != NULL) 272 { 273 /* Merge the two trees. */ 274 cp_merge_demangle_parse_infos (info, ret_comp, i); 275 276 /* Replace any newly introduced typedefs -- but not 277 if the type is anonymous (that would lead to infinite 278 looping). */ 279 if (!is_anon) 280 replace_typedefs (info, ret_comp, finder, data); 281 } 282 else 283 { 284 /* This shouldn't happen unless the type printer has 285 output something that the name parser cannot grok. 286 Nonetheless, an ounce of prevention... 287 288 Canonicalize the name again, and store it in the 289 current node (RET_COMP). */ 290 char *canon = cp_canonicalize_string_no_typedefs (name); 291 292 if (canon != NULL) 293 { 294 /* Copy the canonicalization into the obstack and 295 free CANON. */ 296 name = copy_string_to_obstack (&info->obstack, canon, &len); 297 xfree (canon); 298 } 299 300 ret_comp->u.s_name.s = name; 301 ret_comp->u.s_name.len = len; 302 } 303 304 return 1; 305 } 306 } 307 308 return 0; 309 } 310 311 /* Replace any typedefs appearing in the qualified name 312 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse 313 given in INFO. */ 314 315 static void 316 replace_typedefs_qualified_name (struct demangle_parse_info *info, 317 struct demangle_component *ret_comp, 318 canonicalization_ftype *finder, 319 void *data) 320 { 321 long len; 322 char *name; 323 struct ui_file *buf = mem_fileopen (); 324 struct demangle_component *comp = ret_comp; 325 326 /* Walk each node of the qualified name, reconstructing the name of 327 this element. With every node, check for any typedef substitutions. 328 If a substitution has occurred, replace the qualified name node 329 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef- 330 substituted name. */ 331 while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME) 332 { 333 if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME) 334 { 335 struct demangle_component newobj; 336 337 ui_file_write (buf, d_left (comp)->u.s_name.s, 338 d_left (comp)->u.s_name.len); 339 name = ui_file_obsavestring (buf, &info->obstack, &len); 340 newobj.type = DEMANGLE_COMPONENT_NAME; 341 newobj.u.s_name.s = name; 342 newobj.u.s_name.len = len; 343 if (inspect_type (info, &newobj, finder, data)) 344 { 345 char *n, *s; 346 long slen; 347 348 /* A typedef was substituted in NEW. Convert it to a 349 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME 350 node. */ 351 352 ui_file_rewind (buf); 353 n = cp_comp_to_string (&newobj, 100); 354 if (n == NULL) 355 { 356 /* If something went astray, abort typedef substitutions. */ 357 ui_file_delete (buf); 358 return; 359 } 360 361 s = copy_string_to_obstack (&info->obstack, n, &slen); 362 xfree (n); 363 364 d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME; 365 d_left (ret_comp)->u.s_name.s = s; 366 d_left (ret_comp)->u.s_name.len = slen; 367 d_right (ret_comp) = d_right (comp); 368 comp = ret_comp; 369 continue; 370 } 371 } 372 else 373 { 374 /* The current node is not a name, so simply replace any 375 typedefs in it. Then print it to the stream to continue 376 checking for more typedefs in the tree. */ 377 replace_typedefs (info, d_left (comp), finder, data); 378 name = cp_comp_to_string (d_left (comp), 100); 379 if (name == NULL) 380 { 381 /* If something went astray, abort typedef substitutions. */ 382 ui_file_delete (buf); 383 return; 384 } 385 fputs_unfiltered (name, buf); 386 xfree (name); 387 } 388 389 ui_file_write (buf, "::", 2); 390 comp = d_right (comp); 391 } 392 393 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified 394 name assembled above and append the name given by COMP. Then use this 395 reassembled name to check for a typedef. */ 396 397 if (comp->type == DEMANGLE_COMPONENT_NAME) 398 { 399 ui_file_write (buf, comp->u.s_name.s, comp->u.s_name.len); 400 name = ui_file_obsavestring (buf, &info->obstack, &len); 401 402 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node 403 with a DEMANGLE_COMPONENT_NAME node containing the whole 404 name. */ 405 ret_comp->type = DEMANGLE_COMPONENT_NAME; 406 ret_comp->u.s_name.s = name; 407 ret_comp->u.s_name.len = len; 408 inspect_type (info, ret_comp, finder, data); 409 } 410 else 411 replace_typedefs (info, comp, finder, data); 412 413 ui_file_delete (buf); 414 } 415 416 417 /* A function to check const and volatile qualifiers for argument types. 418 419 "Parameter declarations that differ only in the presence 420 or absence of `const' and/or `volatile' are equivalent." 421 C++ Standard N3290, clause 13.1.3 #4. */ 422 423 static void 424 check_cv_qualifiers (struct demangle_component *ret_comp) 425 { 426 while (d_left (ret_comp) != NULL 427 && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST 428 || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE)) 429 { 430 d_left (ret_comp) = d_left (d_left (ret_comp)); 431 } 432 } 433 434 /* Walk the parse tree given by RET_COMP, replacing any typedefs with 435 their basic types. */ 436 437 static void 438 replace_typedefs (struct demangle_parse_info *info, 439 struct demangle_component *ret_comp, 440 canonicalization_ftype *finder, 441 void *data) 442 { 443 if (ret_comp) 444 { 445 if (finder != NULL 446 && (ret_comp->type == DEMANGLE_COMPONENT_NAME 447 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME 448 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE 449 || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)) 450 { 451 char *local_name = cp_comp_to_string (ret_comp, 10); 452 453 if (local_name != NULL) 454 { 455 struct symbol *sym = NULL; 456 457 sym = NULL; 458 TRY 459 { 460 sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0); 461 } 462 CATCH (except, RETURN_MASK_ALL) 463 { 464 } 465 END_CATCH 466 467 xfree (local_name); 468 469 if (sym != NULL) 470 { 471 struct type *otype = SYMBOL_TYPE (sym); 472 const char *new_name = (*finder) (otype, data); 473 474 if (new_name != NULL) 475 { 476 ret_comp->type = DEMANGLE_COMPONENT_NAME; 477 ret_comp->u.s_name.s = new_name; 478 ret_comp->u.s_name.len = strlen (new_name); 479 return; 480 } 481 } 482 } 483 } 484 485 switch (ret_comp->type) 486 { 487 case DEMANGLE_COMPONENT_ARGLIST: 488 check_cv_qualifiers (ret_comp); 489 /* Fall through */ 490 491 case DEMANGLE_COMPONENT_FUNCTION_TYPE: 492 case DEMANGLE_COMPONENT_TEMPLATE: 493 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: 494 case DEMANGLE_COMPONENT_TYPED_NAME: 495 replace_typedefs (info, d_left (ret_comp), finder, data); 496 replace_typedefs (info, d_right (ret_comp), finder, data); 497 break; 498 499 case DEMANGLE_COMPONENT_NAME: 500 inspect_type (info, ret_comp, finder, data); 501 break; 502 503 case DEMANGLE_COMPONENT_QUAL_NAME: 504 replace_typedefs_qualified_name (info, ret_comp, finder, data); 505 break; 506 507 case DEMANGLE_COMPONENT_LOCAL_NAME: 508 case DEMANGLE_COMPONENT_CTOR: 509 case DEMANGLE_COMPONENT_ARRAY_TYPE: 510 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 511 replace_typedefs (info, d_right (ret_comp), finder, data); 512 break; 513 514 case DEMANGLE_COMPONENT_CONST: 515 case DEMANGLE_COMPONENT_RESTRICT: 516 case DEMANGLE_COMPONENT_VOLATILE: 517 case DEMANGLE_COMPONENT_VOLATILE_THIS: 518 case DEMANGLE_COMPONENT_CONST_THIS: 519 case DEMANGLE_COMPONENT_RESTRICT_THIS: 520 case DEMANGLE_COMPONENT_POINTER: 521 case DEMANGLE_COMPONENT_REFERENCE: 522 replace_typedefs (info, d_left (ret_comp), finder, data); 523 break; 524 525 default: 526 break; 527 } 528 } 529 } 530 531 /* Parse STRING and convert it to canonical form, resolving any typedefs. 532 If parsing fails, or if STRING is already canonical, return NULL. 533 Otherwise return the canonical form. The return value is allocated via 534 xmalloc. If FINDER is not NULL, then type components are passed to 535 FINDER to be looked up. DATA is passed verbatim to FINDER. */ 536 537 char * 538 cp_canonicalize_string_full (const char *string, 539 canonicalization_ftype *finder, 540 void *data) 541 { 542 char *ret; 543 unsigned int estimated_len; 544 struct demangle_parse_info *info; 545 546 ret = NULL; 547 estimated_len = strlen (string) * 2; 548 info = cp_demangled_name_to_comp (string, NULL); 549 if (info != NULL) 550 { 551 /* Replace all the typedefs in the tree. */ 552 replace_typedefs (info, info->tree, finder, data); 553 554 /* Convert the tree back into a string. */ 555 ret = cp_comp_to_string (info->tree, estimated_len); 556 gdb_assert (ret != NULL); 557 558 /* Free the parse information. */ 559 cp_demangled_name_parse_free (info); 560 561 /* Finally, compare the original string with the computed 562 name, returning NULL if they are the same. */ 563 if (strcmp (string, ret) == 0) 564 { 565 xfree (ret); 566 return NULL; 567 } 568 } 569 570 return ret; 571 } 572 573 /* Like cp_canonicalize_string_full, but always passes NULL for 574 FINDER. */ 575 576 char * 577 cp_canonicalize_string_no_typedefs (const char *string) 578 { 579 return cp_canonicalize_string_full (string, NULL, NULL); 580 } 581 582 /* Parse STRING and convert it to canonical form. If parsing fails, 583 or if STRING is already canonical, return NULL. Otherwise return 584 the canonical form. The return value is allocated via xmalloc. */ 585 586 char * 587 cp_canonicalize_string (const char *string) 588 { 589 struct demangle_parse_info *info; 590 unsigned int estimated_len; 591 char *ret; 592 593 if (cp_already_canonical (string)) 594 return NULL; 595 596 info = cp_demangled_name_to_comp (string, NULL); 597 if (info == NULL) 598 return NULL; 599 600 estimated_len = strlen (string) * 2; 601 ret = cp_comp_to_string (info->tree, estimated_len); 602 cp_demangled_name_parse_free (info); 603 604 if (ret == NULL) 605 { 606 warning (_("internal error: string \"%s\" failed to be canonicalized"), 607 string); 608 return NULL; 609 } 610 611 if (strcmp (string, ret) == 0) 612 { 613 xfree (ret); 614 return NULL; 615 } 616 617 return ret; 618 } 619 620 /* Convert a mangled name to a demangle_component tree. *MEMORY is 621 set to the block of used memory that should be freed when finished 622 with the tree. DEMANGLED_P is set to the char * that should be 623 freed when finished with the tree, or NULL if none was needed. 624 OPTIONS will be passed to the demangler. */ 625 626 static struct demangle_parse_info * 627 mangled_name_to_comp (const char *mangled_name, int options, 628 void **memory, char **demangled_p) 629 { 630 char *demangled_name; 631 struct demangle_parse_info *info; 632 633 /* If it looks like a v3 mangled name, then try to go directly 634 to trees. */ 635 if (mangled_name[0] == '_' && mangled_name[1] == 'Z') 636 { 637 struct demangle_component *ret; 638 639 ret = cplus_demangle_v3_components (mangled_name, 640 options, memory); 641 if (ret) 642 { 643 info = cp_new_demangle_parse_info (); 644 info->tree = ret; 645 *demangled_p = NULL; 646 return info; 647 } 648 } 649 650 /* If it doesn't, or if that failed, then try to demangle the 651 name. */ 652 demangled_name = gdb_demangle (mangled_name, options); 653 if (demangled_name == NULL) 654 return NULL; 655 656 /* If we could demangle the name, parse it to build the component 657 tree. */ 658 info = cp_demangled_name_to_comp (demangled_name, NULL); 659 660 if (info == NULL) 661 { 662 xfree (demangled_name); 663 return NULL; 664 } 665 666 *demangled_p = demangled_name; 667 return info; 668 } 669 670 /* Return the name of the class containing method PHYSNAME. */ 671 672 char * 673 cp_class_name_from_physname (const char *physname) 674 { 675 void *storage = NULL; 676 char *demangled_name = NULL, *ret; 677 struct demangle_component *ret_comp, *prev_comp, *cur_comp; 678 struct demangle_parse_info *info; 679 int done; 680 681 info = mangled_name_to_comp (physname, DMGL_ANSI, 682 &storage, &demangled_name); 683 if (info == NULL) 684 return NULL; 685 686 done = 0; 687 ret_comp = info->tree; 688 689 /* First strip off any qualifiers, if we have a function or 690 method. */ 691 while (!done) 692 switch (ret_comp->type) 693 { 694 case DEMANGLE_COMPONENT_CONST: 695 case DEMANGLE_COMPONENT_RESTRICT: 696 case DEMANGLE_COMPONENT_VOLATILE: 697 case DEMANGLE_COMPONENT_CONST_THIS: 698 case DEMANGLE_COMPONENT_RESTRICT_THIS: 699 case DEMANGLE_COMPONENT_VOLATILE_THIS: 700 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 701 ret_comp = d_left (ret_comp); 702 break; 703 default: 704 done = 1; 705 break; 706 } 707 708 /* If what we have now is a function, discard the argument list. */ 709 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME) 710 ret_comp = d_left (ret_comp); 711 712 /* If what we have now is a template, strip off the template 713 arguments. The left subtree may be a qualified name. */ 714 if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE) 715 ret_comp = d_left (ret_comp); 716 717 /* What we have now should be a name, possibly qualified. 718 Additional qualifiers could live in the left subtree or the right 719 subtree. Find the last piece. */ 720 done = 0; 721 prev_comp = NULL; 722 cur_comp = ret_comp; 723 while (!done) 724 switch (cur_comp->type) 725 { 726 case DEMANGLE_COMPONENT_QUAL_NAME: 727 case DEMANGLE_COMPONENT_LOCAL_NAME: 728 prev_comp = cur_comp; 729 cur_comp = d_right (cur_comp); 730 break; 731 case DEMANGLE_COMPONENT_TEMPLATE: 732 case DEMANGLE_COMPONENT_NAME: 733 case DEMANGLE_COMPONENT_CTOR: 734 case DEMANGLE_COMPONENT_DTOR: 735 case DEMANGLE_COMPONENT_OPERATOR: 736 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 737 done = 1; 738 break; 739 default: 740 done = 1; 741 cur_comp = NULL; 742 break; 743 } 744 745 ret = NULL; 746 if (cur_comp != NULL && prev_comp != NULL) 747 { 748 /* We want to discard the rightmost child of PREV_COMP. */ 749 *prev_comp = *d_left (prev_comp); 750 /* The ten is completely arbitrary; we don't have a good 751 estimate. */ 752 ret = cp_comp_to_string (ret_comp, 10); 753 } 754 755 xfree (storage); 756 xfree (demangled_name); 757 cp_demangled_name_parse_free (info); 758 return ret; 759 } 760 761 /* Return the child of COMP which is the basename of a method, 762 variable, et cetera. All scope qualifiers are discarded, but 763 template arguments will be included. The component tree may be 764 modified. */ 765 766 static struct demangle_component * 767 unqualified_name_from_comp (struct demangle_component *comp) 768 { 769 struct demangle_component *ret_comp = comp, *last_template; 770 int done; 771 772 done = 0; 773 last_template = NULL; 774 while (!done) 775 switch (ret_comp->type) 776 { 777 case DEMANGLE_COMPONENT_QUAL_NAME: 778 case DEMANGLE_COMPONENT_LOCAL_NAME: 779 ret_comp = d_right (ret_comp); 780 break; 781 case DEMANGLE_COMPONENT_TYPED_NAME: 782 ret_comp = d_left (ret_comp); 783 break; 784 case DEMANGLE_COMPONENT_TEMPLATE: 785 gdb_assert (last_template == NULL); 786 last_template = ret_comp; 787 ret_comp = d_left (ret_comp); 788 break; 789 case DEMANGLE_COMPONENT_CONST: 790 case DEMANGLE_COMPONENT_RESTRICT: 791 case DEMANGLE_COMPONENT_VOLATILE: 792 case DEMANGLE_COMPONENT_CONST_THIS: 793 case DEMANGLE_COMPONENT_RESTRICT_THIS: 794 case DEMANGLE_COMPONENT_VOLATILE_THIS: 795 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 796 ret_comp = d_left (ret_comp); 797 break; 798 case DEMANGLE_COMPONENT_NAME: 799 case DEMANGLE_COMPONENT_CTOR: 800 case DEMANGLE_COMPONENT_DTOR: 801 case DEMANGLE_COMPONENT_OPERATOR: 802 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 803 done = 1; 804 break; 805 default: 806 return NULL; 807 break; 808 } 809 810 if (last_template) 811 { 812 d_left (last_template) = ret_comp; 813 return last_template; 814 } 815 816 return ret_comp; 817 } 818 819 /* Return the name of the method whose linkage name is PHYSNAME. */ 820 821 char * 822 method_name_from_physname (const char *physname) 823 { 824 void *storage = NULL; 825 char *demangled_name = NULL, *ret; 826 struct demangle_component *ret_comp; 827 struct demangle_parse_info *info; 828 829 info = mangled_name_to_comp (physname, DMGL_ANSI, 830 &storage, &demangled_name); 831 if (info == NULL) 832 return NULL; 833 834 ret_comp = unqualified_name_from_comp (info->tree); 835 836 ret = NULL; 837 if (ret_comp != NULL) 838 /* The ten is completely arbitrary; we don't have a good 839 estimate. */ 840 ret = cp_comp_to_string (ret_comp, 10); 841 842 xfree (storage); 843 xfree (demangled_name); 844 cp_demangled_name_parse_free (info); 845 return ret; 846 } 847 848 /* If FULL_NAME is the demangled name of a C++ function (including an 849 arg list, possibly including namespace/class qualifications), 850 return a new string containing only the function name (without the 851 arg list/class qualifications). Otherwise, return NULL. The 852 caller is responsible for freeing the memory in question. */ 853 854 char * 855 cp_func_name (const char *full_name) 856 { 857 char *ret; 858 struct demangle_component *ret_comp; 859 struct demangle_parse_info *info; 860 861 info = cp_demangled_name_to_comp (full_name, NULL); 862 if (!info) 863 return NULL; 864 865 ret_comp = unqualified_name_from_comp (info->tree); 866 867 ret = NULL; 868 if (ret_comp != NULL) 869 ret = cp_comp_to_string (ret_comp, 10); 870 871 cp_demangled_name_parse_free (info); 872 return ret; 873 } 874 875 /* DEMANGLED_NAME is the name of a function, including parameters and 876 (optionally) a return type. Return the name of the function without 877 parameters or return type, or NULL if we can not parse the name. */ 878 879 char * 880 cp_remove_params (const char *demangled_name) 881 { 882 int done = 0; 883 struct demangle_component *ret_comp; 884 struct demangle_parse_info *info; 885 char *ret = NULL; 886 887 if (demangled_name == NULL) 888 return NULL; 889 890 info = cp_demangled_name_to_comp (demangled_name, NULL); 891 if (info == NULL) 892 return NULL; 893 894 /* First strip off any qualifiers, if we have a function or method. */ 895 ret_comp = info->tree; 896 while (!done) 897 switch (ret_comp->type) 898 { 899 case DEMANGLE_COMPONENT_CONST: 900 case DEMANGLE_COMPONENT_RESTRICT: 901 case DEMANGLE_COMPONENT_VOLATILE: 902 case DEMANGLE_COMPONENT_CONST_THIS: 903 case DEMANGLE_COMPONENT_RESTRICT_THIS: 904 case DEMANGLE_COMPONENT_VOLATILE_THIS: 905 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 906 ret_comp = d_left (ret_comp); 907 break; 908 default: 909 done = 1; 910 break; 911 } 912 913 /* What we have now should be a function. Return its name. */ 914 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME) 915 ret = cp_comp_to_string (d_left (ret_comp), 10); 916 917 cp_demangled_name_parse_free (info); 918 return ret; 919 } 920 921 /* Here are some random pieces of trivia to keep in mind while trying 922 to take apart demangled names: 923 924 - Names can contain function arguments or templates, so the process 925 has to be, to some extent recursive: maybe keep track of your 926 depth based on encountering <> and (). 927 928 - Parentheses don't just have to happen at the end of a name: they 929 can occur even if the name in question isn't a function, because 930 a template argument might be a type that's a function. 931 932 - Conversely, even if you're trying to deal with a function, its 933 demangled name might not end with ')': it could be a const or 934 volatile class method, in which case it ends with "const" or 935 "volatile". 936 937 - Parentheses are also used in anonymous namespaces: a variable 938 'foo' in an anonymous namespace gets demangled as "(anonymous 939 namespace)::foo". 940 941 - And operator names can contain parentheses or angle brackets. */ 942 943 /* FIXME: carlton/2003-03-13: We have several functions here with 944 overlapping functionality; can we combine them? Also, do they 945 handle all the above considerations correctly? */ 946 947 948 /* This returns the length of first component of NAME, which should be 949 the demangled name of a C++ variable/function/method/etc. 950 Specifically, it returns the index of the first colon forming the 951 boundary of the first component: so, given 'A::foo' or 'A::B::foo' 952 it returns the 1, and given 'foo', it returns 0. */ 953 954 /* The character in NAME indexed by the return value is guaranteed to 955 always be either ':' or '\0'. */ 956 957 /* NOTE: carlton/2003-03-13: This function is currently only intended 958 for internal use: it's probably not entirely safe when called on 959 user-generated input, because some of the 'index += 2' lines in 960 cp_find_first_component_aux might go past the end of malformed 961 input. */ 962 963 unsigned int 964 cp_find_first_component (const char *name) 965 { 966 return cp_find_first_component_aux (name, 0); 967 } 968 969 /* Helper function for cp_find_first_component. Like that function, 970 it returns the length of the first component of NAME, but to make 971 the recursion easier, it also stops if it reaches an unexpected ')' 972 or '>' if the value of PERMISSIVE is nonzero. */ 973 974 /* Let's optimize away calls to strlen("operator"). */ 975 976 #define LENGTH_OF_OPERATOR 8 977 978 static unsigned int 979 cp_find_first_component_aux (const char *name, int permissive) 980 { 981 unsigned int index = 0; 982 /* Operator names can show up in unexpected places. Since these can 983 contain parentheses or angle brackets, they can screw up the 984 recursion. But not every string 'operator' is part of an 985 operater name: e.g. you could have a variable 'cooperator'. So 986 this variable tells us whether or not we should treat the string 987 'operator' as starting an operator. */ 988 int operator_possible = 1; 989 990 for (;; ++index) 991 { 992 switch (name[index]) 993 { 994 case '<': 995 /* Template; eat it up. The calls to cp_first_component 996 should only return (I hope!) when they reach the '>' 997 terminating the component or a '::' between two 998 components. (Hence the '+ 2'.) */ 999 index += 1; 1000 for (index += cp_find_first_component_aux (name + index, 1); 1001 name[index] != '>'; 1002 index += cp_find_first_component_aux (name + index, 1)) 1003 { 1004 if (name[index] != ':') 1005 { 1006 demangled_name_complaint (name); 1007 return strlen (name); 1008 } 1009 index += 2; 1010 } 1011 operator_possible = 1; 1012 break; 1013 case '(': 1014 /* Similar comment as to '<'. */ 1015 index += 1; 1016 for (index += cp_find_first_component_aux (name + index, 1); 1017 name[index] != ')'; 1018 index += cp_find_first_component_aux (name + index, 1)) 1019 { 1020 if (name[index] != ':') 1021 { 1022 demangled_name_complaint (name); 1023 return strlen (name); 1024 } 1025 index += 2; 1026 } 1027 operator_possible = 1; 1028 break; 1029 case '>': 1030 case ')': 1031 if (permissive) 1032 return index; 1033 else 1034 { 1035 demangled_name_complaint (name); 1036 return strlen (name); 1037 } 1038 case '\0': 1039 case ':': 1040 return index; 1041 case 'o': 1042 /* Operator names can screw up the recursion. */ 1043 if (operator_possible 1044 && strncmp (name + index, "operator", 1045 LENGTH_OF_OPERATOR) == 0) 1046 { 1047 index += LENGTH_OF_OPERATOR; 1048 while (ISSPACE(name[index])) 1049 ++index; 1050 switch (name[index]) 1051 { 1052 /* Skip over one less than the appropriate number of 1053 characters: the for loop will skip over the last 1054 one. */ 1055 case '<': 1056 if (name[index + 1] == '<') 1057 index += 1; 1058 else 1059 index += 0; 1060 break; 1061 case '>': 1062 case '-': 1063 if (name[index + 1] == '>') 1064 index += 1; 1065 else 1066 index += 0; 1067 break; 1068 case '(': 1069 index += 1; 1070 break; 1071 default: 1072 index += 0; 1073 break; 1074 } 1075 } 1076 operator_possible = 0; 1077 break; 1078 case ' ': 1079 case ',': 1080 case '.': 1081 case '&': 1082 case '*': 1083 /* NOTE: carlton/2003-04-18: I'm not sure what the precise 1084 set of relevant characters are here: it's necessary to 1085 include any character that can show up before 'operator' 1086 in a demangled name, and it's safe to include any 1087 character that can't be part of an identifier's name. */ 1088 operator_possible = 1; 1089 break; 1090 default: 1091 operator_possible = 0; 1092 break; 1093 } 1094 } 1095 } 1096 1097 /* Complain about a demangled name that we don't know how to parse. 1098 NAME is the demangled name in question. */ 1099 1100 static void 1101 demangled_name_complaint (const char *name) 1102 { 1103 complaint (&symfile_complaints, 1104 "unexpected demangled name '%s'", name); 1105 } 1106 1107 /* If NAME is the fully-qualified name of a C++ 1108 function/variable/method/etc., this returns the length of its 1109 entire prefix: all of the namespaces and classes that make up its 1110 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns 1111 4, given 'foo', it returns 0. */ 1112 1113 unsigned int 1114 cp_entire_prefix_len (const char *name) 1115 { 1116 unsigned int current_len = cp_find_first_component (name); 1117 unsigned int previous_len = 0; 1118 1119 while (name[current_len] != '\0') 1120 { 1121 gdb_assert (name[current_len] == ':'); 1122 previous_len = current_len; 1123 /* Skip the '::'. */ 1124 current_len += 2; 1125 current_len += cp_find_first_component (name + current_len); 1126 } 1127 1128 return previous_len; 1129 } 1130 1131 /* Overload resolution functions. */ 1132 1133 /* Test to see if SYM is a symbol that we haven't seen corresponding 1134 to a function named OLOAD_NAME. If so, add it to the current 1135 completion list. */ 1136 1137 static void 1138 overload_list_add_symbol (struct symbol *sym, 1139 const char *oload_name) 1140 { 1141 int newsize; 1142 int i; 1143 char *sym_name; 1144 1145 /* If there is no type information, we can't do anything, so 1146 skip. */ 1147 if (SYMBOL_TYPE (sym) == NULL) 1148 return; 1149 1150 /* skip any symbols that we've already considered. */ 1151 for (i = 0; i < sym_return_val_index; ++i) 1152 if (strcmp (SYMBOL_LINKAGE_NAME (sym), 1153 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0) 1154 return; 1155 1156 /* Get the demangled name without parameters */ 1157 sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym)); 1158 if (!sym_name) 1159 return; 1160 1161 /* skip symbols that cannot match */ 1162 if (strcmp (sym_name, oload_name) != 0) 1163 { 1164 xfree (sym_name); 1165 return; 1166 } 1167 1168 xfree (sym_name); 1169 1170 /* We have a match for an overload instance, so add SYM to the 1171 current list of overload instances */ 1172 if (sym_return_val_index + 3 > sym_return_val_size) 1173 { 1174 newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *); 1175 sym_return_val = (struct symbol **) 1176 xrealloc ((char *) sym_return_val, newsize); 1177 } 1178 sym_return_val[sym_return_val_index++] = sym; 1179 sym_return_val[sym_return_val_index] = NULL; 1180 } 1181 1182 /* Return a null-terminated list of pointers to function symbols that 1183 are named FUNC_NAME and are visible within NAMESPACE. */ 1184 1185 struct symbol ** 1186 make_symbol_overload_list (const char *func_name, 1187 const char *the_namespace) 1188 { 1189 struct cleanup *old_cleanups; 1190 const char *name; 1191 1192 sym_return_val_size = 100; 1193 sym_return_val_index = 0; 1194 sym_return_val = xmalloc ((sym_return_val_size + 1) * 1195 sizeof (struct symbol *)); 1196 sym_return_val[0] = NULL; 1197 1198 old_cleanups = make_cleanup (xfree, sym_return_val); 1199 1200 make_symbol_overload_list_using (func_name, the_namespace); 1201 1202 if (the_namespace[0] == '\0') 1203 name = func_name; 1204 else 1205 { 1206 char *concatenated_name 1207 = alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1); 1208 strcpy (concatenated_name, the_namespace); 1209 strcat (concatenated_name, "::"); 1210 strcat (concatenated_name, func_name); 1211 name = concatenated_name; 1212 } 1213 1214 make_symbol_overload_list_qualified (name); 1215 1216 discard_cleanups (old_cleanups); 1217 1218 return sym_return_val; 1219 } 1220 1221 /* Add all symbols with a name matching NAME in BLOCK to the overload 1222 list. */ 1223 1224 static void 1225 make_symbol_overload_list_block (const char *name, 1226 const struct block *block) 1227 { 1228 struct block_iterator iter; 1229 struct symbol *sym; 1230 1231 ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym) 1232 overload_list_add_symbol (sym, name); 1233 } 1234 1235 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */ 1236 1237 static void 1238 make_symbol_overload_list_namespace (const char *func_name, 1239 const char *the_namespace) 1240 { 1241 const char *name; 1242 const struct block *block = NULL; 1243 1244 if (the_namespace[0] == '\0') 1245 name = func_name; 1246 else 1247 { 1248 char *concatenated_name 1249 = alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1); 1250 1251 strcpy (concatenated_name, the_namespace); 1252 strcat (concatenated_name, "::"); 1253 strcat (concatenated_name, func_name); 1254 name = concatenated_name; 1255 } 1256 1257 /* Look in the static block. */ 1258 block = block_static_block (get_selected_block (0)); 1259 if (block) 1260 make_symbol_overload_list_block (name, block); 1261 1262 /* Look in the global block. */ 1263 block = block_global_block (block); 1264 if (block) 1265 make_symbol_overload_list_block (name, block); 1266 1267 } 1268 1269 /* Search the namespace of the given type and namespace of and public 1270 base types. */ 1271 1272 static void 1273 make_symbol_overload_list_adl_namespace (struct type *type, 1274 const char *func_name) 1275 { 1276 char *the_namespace; 1277 const char *type_name; 1278 int i, prefix_len; 1279 1280 while (TYPE_CODE (type) == TYPE_CODE_PTR 1281 || TYPE_CODE (type) == TYPE_CODE_REF 1282 || TYPE_CODE (type) == TYPE_CODE_ARRAY 1283 || TYPE_CODE (type) == TYPE_CODE_TYPEDEF) 1284 { 1285 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) 1286 type = check_typedef(type); 1287 else 1288 type = TYPE_TARGET_TYPE (type); 1289 } 1290 1291 type_name = TYPE_NAME (type); 1292 1293 if (type_name == NULL) 1294 return; 1295 1296 prefix_len = cp_entire_prefix_len (type_name); 1297 1298 if (prefix_len != 0) 1299 { 1300 the_namespace = alloca (prefix_len + 1); 1301 strncpy (the_namespace, type_name, prefix_len); 1302 the_namespace[prefix_len] = '\0'; 1303 1304 make_symbol_overload_list_namespace (func_name, the_namespace); 1305 } 1306 1307 /* Check public base type */ 1308 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 1309 for (i = 0; i < TYPE_N_BASECLASSES (type); i++) 1310 { 1311 if (BASETYPE_VIA_PUBLIC (type, i)) 1312 make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type, 1313 i), 1314 func_name); 1315 } 1316 } 1317 1318 /* Adds the overload list overload candidates for FUNC_NAME found 1319 through argument dependent lookup. */ 1320 1321 struct symbol ** 1322 make_symbol_overload_list_adl (struct type **arg_types, int nargs, 1323 const char *func_name) 1324 { 1325 int i; 1326 1327 gdb_assert (sym_return_val_size != -1); 1328 1329 for (i = 1; i <= nargs; i++) 1330 make_symbol_overload_list_adl_namespace (arg_types[i - 1], 1331 func_name); 1332 1333 return sym_return_val; 1334 } 1335 1336 /* Used for cleanups to reset the "searched" flag in case of an 1337 error. */ 1338 1339 static void 1340 reset_directive_searched (void *data) 1341 { 1342 struct using_direct *direct = data; 1343 direct->searched = 0; 1344 } 1345 1346 /* This applies the using directives to add namespaces to search in, 1347 and then searches for overloads in all of those namespaces. It 1348 adds the symbols found to sym_return_val. Arguments are as in 1349 make_symbol_overload_list. */ 1350 1351 static void 1352 make_symbol_overload_list_using (const char *func_name, 1353 const char *the_namespace) 1354 { 1355 struct using_direct *current; 1356 const struct block *block; 1357 1358 /* First, go through the using directives. If any of them apply, 1359 look in the appropriate namespaces for new functions to match 1360 on. */ 1361 1362 for (block = get_selected_block (0); 1363 block != NULL; 1364 block = BLOCK_SUPERBLOCK (block)) 1365 for (current = block_using (block); 1366 current != NULL; 1367 current = current->next) 1368 { 1369 /* Prevent recursive calls. */ 1370 if (current->searched) 1371 continue; 1372 1373 /* If this is a namespace alias or imported declaration ignore 1374 it. */ 1375 if (current->alias != NULL || current->declaration != NULL) 1376 continue; 1377 1378 if (strcmp (the_namespace, current->import_dest) == 0) 1379 { 1380 /* Mark this import as searched so that the recursive call 1381 does not search it again. */ 1382 struct cleanup *old_chain; 1383 current->searched = 1; 1384 old_chain = make_cleanup (reset_directive_searched, 1385 current); 1386 1387 make_symbol_overload_list_using (func_name, 1388 current->import_src); 1389 1390 current->searched = 0; 1391 discard_cleanups (old_chain); 1392 } 1393 } 1394 1395 /* Now, add names for this namespace. */ 1396 make_symbol_overload_list_namespace (func_name, the_namespace); 1397 } 1398 1399 /* This does the bulk of the work of finding overloaded symbols. 1400 FUNC_NAME is the name of the overloaded function we're looking for 1401 (possibly including namespace info). */ 1402 1403 static void 1404 make_symbol_overload_list_qualified (const char *func_name) 1405 { 1406 struct compunit_symtab *cust; 1407 struct objfile *objfile; 1408 const struct block *b, *surrounding_static_block = 0; 1409 1410 /* Look through the partial symtabs for all symbols which begin by 1411 matching FUNC_NAME. Make sure we read that symbol table in. */ 1412 1413 ALL_OBJFILES (objfile) 1414 { 1415 if (objfile->sf) 1416 objfile->sf->qf->expand_symtabs_for_function (objfile, func_name); 1417 } 1418 1419 /* Search upwards from currently selected frame (so that we can 1420 complete on local vars. */ 1421 1422 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b)) 1423 make_symbol_overload_list_block (func_name, b); 1424 1425 surrounding_static_block = block_static_block (get_selected_block (0)); 1426 1427 /* Go through the symtabs and check the externs and statics for 1428 symbols which match. */ 1429 1430 ALL_COMPUNITS (objfile, cust) 1431 { 1432 QUIT; 1433 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), GLOBAL_BLOCK); 1434 make_symbol_overload_list_block (func_name, b); 1435 } 1436 1437 ALL_COMPUNITS (objfile, cust) 1438 { 1439 QUIT; 1440 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK); 1441 /* Don't do this block twice. */ 1442 if (b == surrounding_static_block) 1443 continue; 1444 make_symbol_overload_list_block (func_name, b); 1445 } 1446 } 1447 1448 /* Lookup the rtti type for a class name. */ 1449 1450 struct type * 1451 cp_lookup_rtti_type (const char *name, struct block *block) 1452 { 1453 struct symbol * rtti_sym; 1454 struct type * rtti_type; 1455 1456 /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417. 1457 Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */ 1458 rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL); 1459 1460 if (rtti_sym == NULL) 1461 { 1462 warning (_("RTTI symbol not found for class '%s'"), name); 1463 return NULL; 1464 } 1465 1466 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF) 1467 { 1468 warning (_("RTTI symbol for class '%s' is not a type"), name); 1469 return NULL; 1470 } 1471 1472 rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym)); 1473 1474 switch (TYPE_CODE (rtti_type)) 1475 { 1476 case TYPE_CODE_STRUCT: 1477 break; 1478 case TYPE_CODE_NAMESPACE: 1479 /* chastain/2003-11-26: the symbol tables often contain fake 1480 symbols for namespaces with the same name as the struct. 1481 This warning is an indication of a bug in the lookup order 1482 or a bug in the way that the symbol tables are populated. */ 1483 warning (_("RTTI symbol for class '%s' is a namespace"), name); 1484 return NULL; 1485 default: 1486 warning (_("RTTI symbol for class '%s' has bad type"), name); 1487 return NULL; 1488 } 1489 1490 return rtti_type; 1491 } 1492 1493 #ifdef HAVE_WORKING_FORK 1494 1495 /* If nonzero, attempt to catch crashes in the demangler and print 1496 useful debugging information. */ 1497 1498 static int catch_demangler_crashes = 1; 1499 1500 /* Stack context and environment for demangler crash recovery. */ 1501 1502 static SIGJMP_BUF gdb_demangle_jmp_buf; 1503 1504 /* If nonzero, attempt to dump core from the signal handler. */ 1505 1506 static int gdb_demangle_attempt_core_dump = 1; 1507 1508 /* Signal handler for gdb_demangle. */ 1509 1510 static void 1511 gdb_demangle_signal_handler (int signo) 1512 { 1513 if (gdb_demangle_attempt_core_dump) 1514 { 1515 if (fork () == 0) 1516 dump_core (); 1517 1518 gdb_demangle_attempt_core_dump = 0; 1519 } 1520 1521 SIGLONGJMP (gdb_demangle_jmp_buf, signo); 1522 } 1523 1524 #endif 1525 1526 /* A wrapper for bfd_demangle. */ 1527 1528 char * 1529 gdb_demangle (const char *name, int options) 1530 { 1531 char *result = NULL; 1532 int crash_signal = 0; 1533 1534 #ifdef HAVE_WORKING_FORK 1535 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 1536 struct sigaction sa, old_sa; 1537 #else 1538 void (*ofunc) (); 1539 #endif 1540 static int core_dump_allowed = -1; 1541 1542 if (core_dump_allowed == -1) 1543 { 1544 core_dump_allowed = can_dump_core (LIMIT_CUR); 1545 1546 if (!core_dump_allowed) 1547 gdb_demangle_attempt_core_dump = 0; 1548 } 1549 1550 if (catch_demangler_crashes) 1551 { 1552 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 1553 sa.sa_handler = gdb_demangle_signal_handler; 1554 sigemptyset (&sa.sa_mask); 1555 #ifdef HAVE_SIGALTSTACK 1556 sa.sa_flags = SA_ONSTACK; 1557 #else 1558 sa.sa_flags = 0; 1559 #endif 1560 sigaction (SIGSEGV, &sa, &old_sa); 1561 #else 1562 ofunc = (void (*)()) signal (SIGSEGV, gdb_demangle_signal_handler); 1563 #endif 1564 1565 crash_signal = SIGSETJMP (gdb_demangle_jmp_buf); 1566 } 1567 #endif 1568 1569 if (crash_signal == 0) 1570 result = bfd_demangle (NULL, name, options); 1571 1572 #ifdef HAVE_WORKING_FORK 1573 if (catch_demangler_crashes) 1574 { 1575 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 1576 sigaction (SIGSEGV, &old_sa, NULL); 1577 #else 1578 signal (SIGSEGV, ofunc); 1579 #endif 1580 1581 if (crash_signal != 0) 1582 { 1583 static int error_reported = 0; 1584 1585 if (!error_reported) 1586 { 1587 char *short_msg, *long_msg; 1588 struct cleanup *back_to; 1589 1590 short_msg = xstrprintf (_("unable to demangle '%s' " 1591 "(demangler failed with signal %d)"), 1592 name, crash_signal); 1593 back_to = make_cleanup (xfree, short_msg); 1594 1595 long_msg = xstrprintf ("%s:%d: %s: %s", __FILE__, __LINE__, 1596 "demangler-warning", short_msg); 1597 make_cleanup (xfree, long_msg); 1598 1599 target_terminal_ours (); 1600 begin_line (); 1601 if (core_dump_allowed) 1602 fprintf_unfiltered (gdb_stderr, 1603 _("%s\nAttempting to dump core.\n"), 1604 long_msg); 1605 else 1606 warn_cant_dump_core (long_msg); 1607 1608 demangler_warning (__FILE__, __LINE__, "%s", short_msg); 1609 1610 do_cleanups (back_to); 1611 1612 error_reported = 1; 1613 } 1614 1615 result = NULL; 1616 } 1617 } 1618 #endif 1619 1620 return result; 1621 } 1622 1623 /* Don't allow just "maintenance cplus". */ 1624 1625 static void 1626 maint_cplus_command (char *arg, int from_tty) 1627 { 1628 printf_unfiltered (_("\"maintenance cplus\" must be followed " 1629 "by the name of a command.\n")); 1630 help_list (maint_cplus_cmd_list, 1631 "maintenance cplus ", 1632 all_commands, gdb_stdout); 1633 } 1634 1635 /* This is a front end for cp_find_first_component, for unit testing. 1636 Be careful when using it: see the NOTE above 1637 cp_find_first_component. */ 1638 1639 static void 1640 first_component_command (char *arg, int from_tty) 1641 { 1642 int len; 1643 char *prefix; 1644 1645 if (!arg) 1646 return; 1647 1648 len = cp_find_first_component (arg); 1649 prefix = alloca (len + 1); 1650 1651 memcpy (prefix, arg, len); 1652 prefix[len] = '\0'; 1653 1654 printf_unfiltered ("%s\n", prefix); 1655 } 1656 1657 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */ 1658 1659 1660 /* Implement "info vtbl". */ 1661 1662 static void 1663 info_vtbl_command (char *arg, int from_tty) 1664 { 1665 struct value *value; 1666 1667 value = parse_and_eval (arg); 1668 cplus_print_vtable (value); 1669 } 1670 1671 void 1672 _initialize_cp_support (void) 1673 { 1674 add_prefix_cmd ("cplus", class_maintenance, 1675 maint_cplus_command, 1676 _("C++ maintenance commands."), 1677 &maint_cplus_cmd_list, 1678 "maintenance cplus ", 1679 0, &maintenancelist); 1680 add_alias_cmd ("cp", "cplus", 1681 class_maintenance, 1, 1682 &maintenancelist); 1683 1684 add_cmd ("first_component", 1685 class_maintenance, 1686 first_component_command, 1687 _("Print the first class/namespace component of NAME."), 1688 &maint_cplus_cmd_list); 1689 1690 add_info ("vtbl", info_vtbl_command, 1691 _("Show the virtual function table for a C++ object.\n\ 1692 Usage: info vtbl EXPRESSION\n\ 1693 Evaluate EXPRESSION and display the virtual function table for the\n\ 1694 resulting object.")); 1695 1696 #ifdef HAVE_WORKING_FORK 1697 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance, 1698 &catch_demangler_crashes, _("\ 1699 Set whether to attempt to catch demangler crashes."), _("\ 1700 Show whether to attempt to catch demangler crashes."), _("\ 1701 If enabled GDB will attempt to catch demangler crashes and\n\ 1702 display the offending symbol."), 1703 NULL, 1704 NULL, 1705 &maintenance_set_cmdlist, 1706 &maintenance_show_cmdlist); 1707 #endif 1708 } 1709