1 /* Helper routines for C++ support in GDB. 2 Copyright (C) 2002-2019 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 "namespace.h" 36 #include <signal.h> 37 #include "common/gdb_setjmp.h" 38 #include "safe-ctype.h" 39 #include "common/selftest.h" 40 41 #define d_left(dc) (dc)->u.s_binary.left 42 #define d_right(dc) (dc)->u.s_binary.right 43 44 /* Functions related to demangled name parsing. */ 45 46 static unsigned int cp_find_first_component_aux (const char *name, 47 int permissive); 48 49 static void demangled_name_complaint (const char *name); 50 51 /* Functions related to overload resolution. */ 52 53 static void overload_list_add_symbol (struct symbol *sym, 54 const char *oload_name, 55 std::vector<symbol *> *overload_list); 56 57 static void add_symbol_overload_list_using 58 (const char *func_name, const char *the_namespace, 59 std::vector<symbol *> *overload_list); 60 61 static void add_symbol_overload_list_qualified 62 (const char *func_name, 63 std::vector<symbol *> *overload_list); 64 65 /* The list of "maint cplus" commands. */ 66 67 struct cmd_list_element *maint_cplus_cmd_list = NULL; 68 69 /* A list of typedefs which should not be substituted by replace_typedefs. */ 70 static const char * const ignore_typedefs[] = 71 { 72 "std::istream", "std::iostream", "std::ostream", "std::string" 73 }; 74 75 static void 76 replace_typedefs (struct demangle_parse_info *info, 77 struct demangle_component *ret_comp, 78 canonicalization_ftype *finder, 79 void *data); 80 81 /* A convenience function to copy STRING into OBSTACK, returning a pointer 82 to the newly allocated string and saving the number of bytes saved in LEN. 83 84 It does not copy the terminating '\0' byte! */ 85 86 static char * 87 copy_string_to_obstack (struct obstack *obstack, const char *string, 88 long *len) 89 { 90 *len = strlen (string); 91 return (char *) obstack_copy (obstack, string, *len); 92 } 93 94 /* Return 1 if STRING is clearly already in canonical form. This 95 function is conservative; things which it does not recognize are 96 assumed to be non-canonical, and the parser will sort them out 97 afterwards. This speeds up the critical path for alphanumeric 98 identifiers. */ 99 100 static int 101 cp_already_canonical (const char *string) 102 { 103 /* Identifier start character [a-zA-Z_]. */ 104 if (!ISIDST (string[0])) 105 return 0; 106 107 /* These are the only two identifiers which canonicalize to other 108 than themselves or an error: unsigned -> unsigned int and 109 signed -> int. */ 110 if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0) 111 return 0; 112 else if (string[0] == 's' && strcmp (&string[1], "igned") == 0) 113 return 0; 114 115 /* Identifier character [a-zA-Z0-9_]. */ 116 while (ISIDNUM (string[1])) 117 string++; 118 119 if (string[1] == '\0') 120 return 1; 121 else 122 return 0; 123 } 124 125 /* Inspect the given RET_COMP for its type. If it is a typedef, 126 replace the node with the typedef's tree. 127 128 Returns 1 if any typedef substitutions were made, 0 otherwise. */ 129 130 static int 131 inspect_type (struct demangle_parse_info *info, 132 struct demangle_component *ret_comp, 133 canonicalization_ftype *finder, 134 void *data) 135 { 136 char *name; 137 struct symbol *sym; 138 139 /* Copy the symbol's name from RET_COMP and look it up 140 in the symbol table. */ 141 name = (char *) alloca (ret_comp->u.s_name.len + 1); 142 memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len); 143 name[ret_comp->u.s_name.len] = '\0'; 144 145 /* Ignore any typedefs that should not be substituted. */ 146 for (int i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i) 147 { 148 if (strcmp (name, ignore_typedefs[i]) == 0) 149 return 0; 150 } 151 152 sym = NULL; 153 154 TRY 155 { 156 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol; 157 } 158 CATCH (except, RETURN_MASK_ALL) 159 { 160 return 0; 161 } 162 END_CATCH 163 164 if (sym != NULL) 165 { 166 struct type *otype = SYMBOL_TYPE (sym); 167 168 if (finder != NULL) 169 { 170 const char *new_name = (*finder) (otype, data); 171 172 if (new_name != NULL) 173 { 174 ret_comp->u.s_name.s = new_name; 175 ret_comp->u.s_name.len = strlen (new_name); 176 return 1; 177 } 178 179 return 0; 180 } 181 182 /* If the type is a typedef or namespace alias, replace it. */ 183 if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF 184 || TYPE_CODE (otype) == TYPE_CODE_NAMESPACE) 185 { 186 long len; 187 int is_anon; 188 struct type *type; 189 std::unique_ptr<demangle_parse_info> i; 190 191 /* Get the real type of the typedef. */ 192 type = check_typedef (otype); 193 194 /* If the symbol is a namespace and its type name is no different 195 than the name we looked up, this symbol is not a namespace 196 alias and does not need to be substituted. */ 197 if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE 198 && strcmp (TYPE_NAME (type), name) == 0) 199 return 0; 200 201 is_anon = (TYPE_NAME (type) == NULL 202 && (TYPE_CODE (type) == TYPE_CODE_ENUM 203 || TYPE_CODE (type) == TYPE_CODE_STRUCT 204 || TYPE_CODE (type) == TYPE_CODE_UNION)); 205 if (is_anon) 206 { 207 struct type *last = otype; 208 209 /* Find the last typedef for the type. */ 210 while (TYPE_TARGET_TYPE (last) != NULL 211 && (TYPE_CODE (TYPE_TARGET_TYPE (last)) 212 == TYPE_CODE_TYPEDEF)) 213 last = TYPE_TARGET_TYPE (last); 214 215 /* If there is only one typedef for this anonymous type, 216 do not substitute it. */ 217 if (type == otype) 218 return 0; 219 else 220 /* Use the last typedef seen as the type for this 221 anonymous type. */ 222 type = last; 223 } 224 225 string_file buf; 226 TRY 227 { 228 type_print (type, "", &buf, -1); 229 } 230 /* If type_print threw an exception, there is little point 231 in continuing, so just bow out gracefully. */ 232 CATCH (except, RETURN_MASK_ERROR) 233 { 234 return 0; 235 } 236 END_CATCH 237 238 len = buf.size (); 239 name = (char *) obstack_copy0 (&info->obstack, buf.c_str (), len); 240 241 /* Turn the result into a new tree. Note that this 242 tree will contain pointers into NAME, so NAME cannot 243 be free'd until all typedef conversion is done and 244 the final result is converted into a string. */ 245 i = cp_demangled_name_to_comp (name, NULL); 246 if (i != NULL) 247 { 248 /* Merge the two trees. */ 249 cp_merge_demangle_parse_infos (info, ret_comp, i.get ()); 250 251 /* Replace any newly introduced typedefs -- but not 252 if the type is anonymous (that would lead to infinite 253 looping). */ 254 if (!is_anon) 255 replace_typedefs (info, ret_comp, finder, data); 256 } 257 else 258 { 259 /* This shouldn't happen unless the type printer has 260 output something that the name parser cannot grok. 261 Nonetheless, an ounce of prevention... 262 263 Canonicalize the name again, and store it in the 264 current node (RET_COMP). */ 265 std::string canon = cp_canonicalize_string_no_typedefs (name); 266 267 if (!canon.empty ()) 268 { 269 /* Copy the canonicalization into the obstack. */ 270 name = copy_string_to_obstack (&info->obstack, canon.c_str (), &len); 271 } 272 273 ret_comp->u.s_name.s = name; 274 ret_comp->u.s_name.len = len; 275 } 276 277 return 1; 278 } 279 } 280 281 return 0; 282 } 283 284 /* Replace any typedefs appearing in the qualified name 285 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse 286 given in INFO. */ 287 288 static void 289 replace_typedefs_qualified_name (struct demangle_parse_info *info, 290 struct demangle_component *ret_comp, 291 canonicalization_ftype *finder, 292 void *data) 293 { 294 string_file buf; 295 struct demangle_component *comp = ret_comp; 296 297 /* Walk each node of the qualified name, reconstructing the name of 298 this element. With every node, check for any typedef substitutions. 299 If a substitution has occurred, replace the qualified name node 300 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef- 301 substituted name. */ 302 while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME) 303 { 304 if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME) 305 { 306 struct demangle_component newobj; 307 308 buf.write (d_left (comp)->u.s_name.s, d_left (comp)->u.s_name.len); 309 newobj.type = DEMANGLE_COMPONENT_NAME; 310 newobj.u.s_name.s 311 = (char *) obstack_copy0 (&info->obstack, 312 buf.c_str (), buf.size ()); 313 newobj.u.s_name.len = buf.size (); 314 if (inspect_type (info, &newobj, finder, data)) 315 { 316 char *s; 317 long slen; 318 319 /* A typedef was substituted in NEW. Convert it to a 320 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME 321 node. */ 322 323 buf.clear (); 324 gdb::unique_xmalloc_ptr<char> n 325 = cp_comp_to_string (&newobj, 100); 326 if (n == NULL) 327 { 328 /* If something went astray, abort typedef substitutions. */ 329 return; 330 } 331 332 s = copy_string_to_obstack (&info->obstack, n.get (), &slen); 333 334 d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME; 335 d_left (ret_comp)->u.s_name.s = s; 336 d_left (ret_comp)->u.s_name.len = slen; 337 d_right (ret_comp) = d_right (comp); 338 comp = ret_comp; 339 continue; 340 } 341 } 342 else 343 { 344 /* The current node is not a name, so simply replace any 345 typedefs in it. Then print it to the stream to continue 346 checking for more typedefs in the tree. */ 347 replace_typedefs (info, d_left (comp), finder, data); 348 gdb::unique_xmalloc_ptr<char> name 349 = cp_comp_to_string (d_left (comp), 100); 350 if (name == NULL) 351 { 352 /* If something went astray, abort typedef substitutions. */ 353 return; 354 } 355 buf.puts (name.get ()); 356 } 357 358 buf.write ("::", 2); 359 comp = d_right (comp); 360 } 361 362 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified 363 name assembled above and append the name given by COMP. Then use this 364 reassembled name to check for a typedef. */ 365 366 if (comp->type == DEMANGLE_COMPONENT_NAME) 367 { 368 buf.write (comp->u.s_name.s, comp->u.s_name.len); 369 370 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node 371 with a DEMANGLE_COMPONENT_NAME node containing the whole 372 name. */ 373 ret_comp->type = DEMANGLE_COMPONENT_NAME; 374 ret_comp->u.s_name.s 375 = (char *) obstack_copy0 (&info->obstack, 376 buf.c_str (), buf.size ()); 377 ret_comp->u.s_name.len = buf.size (); 378 inspect_type (info, ret_comp, finder, data); 379 } 380 else 381 replace_typedefs (info, comp, finder, data); 382 } 383 384 385 /* A function to check const and volatile qualifiers for argument types. 386 387 "Parameter declarations that differ only in the presence 388 or absence of `const' and/or `volatile' are equivalent." 389 C++ Standard N3290, clause 13.1.3 #4. */ 390 391 static void 392 check_cv_qualifiers (struct demangle_component *ret_comp) 393 { 394 while (d_left (ret_comp) != NULL 395 && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST 396 || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE)) 397 { 398 d_left (ret_comp) = d_left (d_left (ret_comp)); 399 } 400 } 401 402 /* Walk the parse tree given by RET_COMP, replacing any typedefs with 403 their basic types. */ 404 405 static void 406 replace_typedefs (struct demangle_parse_info *info, 407 struct demangle_component *ret_comp, 408 canonicalization_ftype *finder, 409 void *data) 410 { 411 if (ret_comp) 412 { 413 if (finder != NULL 414 && (ret_comp->type == DEMANGLE_COMPONENT_NAME 415 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME 416 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE 417 || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)) 418 { 419 gdb::unique_xmalloc_ptr<char> local_name 420 = cp_comp_to_string (ret_comp, 10); 421 422 if (local_name != NULL) 423 { 424 struct symbol *sym = NULL; 425 426 sym = NULL; 427 TRY 428 { 429 sym = lookup_symbol (local_name.get (), 0, 430 VAR_DOMAIN, 0).symbol; 431 } 432 CATCH (except, RETURN_MASK_ALL) 433 { 434 } 435 END_CATCH 436 437 if (sym != NULL) 438 { 439 struct type *otype = SYMBOL_TYPE (sym); 440 const char *new_name = (*finder) (otype, data); 441 442 if (new_name != NULL) 443 { 444 ret_comp->type = DEMANGLE_COMPONENT_NAME; 445 ret_comp->u.s_name.s = new_name; 446 ret_comp->u.s_name.len = strlen (new_name); 447 return; 448 } 449 } 450 } 451 } 452 453 switch (ret_comp->type) 454 { 455 case DEMANGLE_COMPONENT_ARGLIST: 456 check_cv_qualifiers (ret_comp); 457 /* Fall through */ 458 459 case DEMANGLE_COMPONENT_FUNCTION_TYPE: 460 case DEMANGLE_COMPONENT_TEMPLATE: 461 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: 462 case DEMANGLE_COMPONENT_TYPED_NAME: 463 replace_typedefs (info, d_left (ret_comp), finder, data); 464 replace_typedefs (info, d_right (ret_comp), finder, data); 465 break; 466 467 case DEMANGLE_COMPONENT_NAME: 468 inspect_type (info, ret_comp, finder, data); 469 break; 470 471 case DEMANGLE_COMPONENT_QUAL_NAME: 472 replace_typedefs_qualified_name (info, ret_comp, finder, data); 473 break; 474 475 case DEMANGLE_COMPONENT_LOCAL_NAME: 476 case DEMANGLE_COMPONENT_CTOR: 477 case DEMANGLE_COMPONENT_ARRAY_TYPE: 478 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 479 replace_typedefs (info, d_right (ret_comp), finder, data); 480 break; 481 482 case DEMANGLE_COMPONENT_CONST: 483 case DEMANGLE_COMPONENT_RESTRICT: 484 case DEMANGLE_COMPONENT_VOLATILE: 485 case DEMANGLE_COMPONENT_VOLATILE_THIS: 486 case DEMANGLE_COMPONENT_CONST_THIS: 487 case DEMANGLE_COMPONENT_RESTRICT_THIS: 488 case DEMANGLE_COMPONENT_POINTER: 489 case DEMANGLE_COMPONENT_REFERENCE: 490 case DEMANGLE_COMPONENT_RVALUE_REFERENCE: 491 replace_typedefs (info, d_left (ret_comp), finder, data); 492 break; 493 494 default: 495 break; 496 } 497 } 498 } 499 500 /* Parse STRING and convert it to canonical form, resolving any 501 typedefs. If parsing fails, or if STRING is already canonical, 502 return the empty string. Otherwise return the canonical form. If 503 FINDER is not NULL, then type components are passed to FINDER to be 504 looked up. DATA is passed verbatim to FINDER. */ 505 506 std::string 507 cp_canonicalize_string_full (const char *string, 508 canonicalization_ftype *finder, 509 void *data) 510 { 511 std::string ret; 512 unsigned int estimated_len; 513 std::unique_ptr<demangle_parse_info> info; 514 515 estimated_len = strlen (string) * 2; 516 info = cp_demangled_name_to_comp (string, NULL); 517 if (info != NULL) 518 { 519 /* Replace all the typedefs in the tree. */ 520 replace_typedefs (info.get (), info->tree, finder, data); 521 522 /* Convert the tree back into a string. */ 523 gdb::unique_xmalloc_ptr<char> us = cp_comp_to_string (info->tree, 524 estimated_len); 525 gdb_assert (us); 526 527 ret = us.get (); 528 /* Finally, compare the original string with the computed 529 name, returning NULL if they are the same. */ 530 if (ret == string) 531 return std::string (); 532 } 533 534 return ret; 535 } 536 537 /* Like cp_canonicalize_string_full, but always passes NULL for 538 FINDER. */ 539 540 std::string 541 cp_canonicalize_string_no_typedefs (const char *string) 542 { 543 return cp_canonicalize_string_full (string, NULL, NULL); 544 } 545 546 /* Parse STRING and convert it to canonical form. If parsing fails, 547 or if STRING is already canonical, return the empty string. 548 Otherwise return the canonical form. */ 549 550 std::string 551 cp_canonicalize_string (const char *string) 552 { 553 std::unique_ptr<demangle_parse_info> info; 554 unsigned int estimated_len; 555 556 if (cp_already_canonical (string)) 557 return std::string (); 558 559 info = cp_demangled_name_to_comp (string, NULL); 560 if (info == NULL) 561 return std::string (); 562 563 estimated_len = strlen (string) * 2; 564 gdb::unique_xmalloc_ptr<char> us (cp_comp_to_string (info->tree, 565 estimated_len)); 566 567 if (!us) 568 { 569 warning (_("internal error: string \"%s\" failed to be canonicalized"), 570 string); 571 return std::string (); 572 } 573 574 std::string ret (us.get ()); 575 576 if (ret == string) 577 return std::string (); 578 579 return ret; 580 } 581 582 /* Convert a mangled name to a demangle_component tree. *MEMORY is 583 set to the block of used memory that should be freed when finished 584 with the tree. DEMANGLED_P is set to the char * that should be 585 freed when finished with the tree, or NULL if none was needed. 586 OPTIONS will be passed to the demangler. */ 587 588 static std::unique_ptr<demangle_parse_info> 589 mangled_name_to_comp (const char *mangled_name, int options, 590 void **memory, char **demangled_p) 591 { 592 char *demangled_name; 593 594 /* If it looks like a v3 mangled name, then try to go directly 595 to trees. */ 596 if (mangled_name[0] == '_' && mangled_name[1] == 'Z') 597 { 598 struct demangle_component *ret; 599 600 ret = cplus_demangle_v3_components (mangled_name, 601 options, memory); 602 if (ret) 603 { 604 std::unique_ptr<demangle_parse_info> info (new demangle_parse_info); 605 info->tree = ret; 606 *demangled_p = NULL; 607 return info; 608 } 609 } 610 611 /* If it doesn't, or if that failed, then try to demangle the 612 name. */ 613 demangled_name = gdb_demangle (mangled_name, options); 614 if (demangled_name == NULL) 615 return NULL; 616 617 /* If we could demangle the name, parse it to build the component 618 tree. */ 619 std::unique_ptr<demangle_parse_info> info 620 = cp_demangled_name_to_comp (demangled_name, NULL); 621 622 if (info == NULL) 623 { 624 xfree (demangled_name); 625 return NULL; 626 } 627 628 *demangled_p = demangled_name; 629 return info; 630 } 631 632 /* Return the name of the class containing method PHYSNAME. */ 633 634 char * 635 cp_class_name_from_physname (const char *physname) 636 { 637 void *storage = NULL; 638 char *demangled_name = NULL; 639 gdb::unique_xmalloc_ptr<char> ret; 640 struct demangle_component *ret_comp, *prev_comp, *cur_comp; 641 std::unique_ptr<demangle_parse_info> info; 642 int done; 643 644 info = mangled_name_to_comp (physname, DMGL_ANSI, 645 &storage, &demangled_name); 646 if (info == NULL) 647 return NULL; 648 649 done = 0; 650 ret_comp = info->tree; 651 652 /* First strip off any qualifiers, if we have a function or 653 method. */ 654 while (!done) 655 switch (ret_comp->type) 656 { 657 case DEMANGLE_COMPONENT_CONST: 658 case DEMANGLE_COMPONENT_RESTRICT: 659 case DEMANGLE_COMPONENT_VOLATILE: 660 case DEMANGLE_COMPONENT_CONST_THIS: 661 case DEMANGLE_COMPONENT_RESTRICT_THIS: 662 case DEMANGLE_COMPONENT_VOLATILE_THIS: 663 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 664 ret_comp = d_left (ret_comp); 665 break; 666 default: 667 done = 1; 668 break; 669 } 670 671 /* If what we have now is a function, discard the argument list. */ 672 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME) 673 ret_comp = d_left (ret_comp); 674 675 /* If what we have now is a template, strip off the template 676 arguments. The left subtree may be a qualified name. */ 677 if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE) 678 ret_comp = d_left (ret_comp); 679 680 /* What we have now should be a name, possibly qualified. 681 Additional qualifiers could live in the left subtree or the right 682 subtree. Find the last piece. */ 683 done = 0; 684 prev_comp = NULL; 685 cur_comp = ret_comp; 686 while (!done) 687 switch (cur_comp->type) 688 { 689 case DEMANGLE_COMPONENT_QUAL_NAME: 690 case DEMANGLE_COMPONENT_LOCAL_NAME: 691 prev_comp = cur_comp; 692 cur_comp = d_right (cur_comp); 693 break; 694 case DEMANGLE_COMPONENT_TEMPLATE: 695 case DEMANGLE_COMPONENT_NAME: 696 case DEMANGLE_COMPONENT_CTOR: 697 case DEMANGLE_COMPONENT_DTOR: 698 case DEMANGLE_COMPONENT_OPERATOR: 699 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 700 done = 1; 701 break; 702 default: 703 done = 1; 704 cur_comp = NULL; 705 break; 706 } 707 708 if (cur_comp != NULL && prev_comp != NULL) 709 { 710 /* We want to discard the rightmost child of PREV_COMP. */ 711 *prev_comp = *d_left (prev_comp); 712 /* The ten is completely arbitrary; we don't have a good 713 estimate. */ 714 ret = cp_comp_to_string (ret_comp, 10); 715 } 716 717 xfree (storage); 718 xfree (demangled_name); 719 return ret.release (); 720 } 721 722 /* Return the child of COMP which is the basename of a method, 723 variable, et cetera. All scope qualifiers are discarded, but 724 template arguments will be included. The component tree may be 725 modified. */ 726 727 static struct demangle_component * 728 unqualified_name_from_comp (struct demangle_component *comp) 729 { 730 struct demangle_component *ret_comp = comp, *last_template; 731 int done; 732 733 done = 0; 734 last_template = NULL; 735 while (!done) 736 switch (ret_comp->type) 737 { 738 case DEMANGLE_COMPONENT_QUAL_NAME: 739 case DEMANGLE_COMPONENT_LOCAL_NAME: 740 ret_comp = d_right (ret_comp); 741 break; 742 case DEMANGLE_COMPONENT_TYPED_NAME: 743 ret_comp = d_left (ret_comp); 744 break; 745 case DEMANGLE_COMPONENT_TEMPLATE: 746 gdb_assert (last_template == NULL); 747 last_template = ret_comp; 748 ret_comp = d_left (ret_comp); 749 break; 750 case DEMANGLE_COMPONENT_CONST: 751 case DEMANGLE_COMPONENT_RESTRICT: 752 case DEMANGLE_COMPONENT_VOLATILE: 753 case DEMANGLE_COMPONENT_CONST_THIS: 754 case DEMANGLE_COMPONENT_RESTRICT_THIS: 755 case DEMANGLE_COMPONENT_VOLATILE_THIS: 756 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 757 ret_comp = d_left (ret_comp); 758 break; 759 case DEMANGLE_COMPONENT_NAME: 760 case DEMANGLE_COMPONENT_CTOR: 761 case DEMANGLE_COMPONENT_DTOR: 762 case DEMANGLE_COMPONENT_OPERATOR: 763 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 764 done = 1; 765 break; 766 default: 767 return NULL; 768 break; 769 } 770 771 if (last_template) 772 { 773 d_left (last_template) = ret_comp; 774 return last_template; 775 } 776 777 return ret_comp; 778 } 779 780 /* Return the name of the method whose linkage name is PHYSNAME. */ 781 782 char * 783 method_name_from_physname (const char *physname) 784 { 785 void *storage = NULL; 786 char *demangled_name = NULL; 787 gdb::unique_xmalloc_ptr<char> ret; 788 struct demangle_component *ret_comp; 789 std::unique_ptr<demangle_parse_info> info; 790 791 info = mangled_name_to_comp (physname, DMGL_ANSI, 792 &storage, &demangled_name); 793 if (info == NULL) 794 return NULL; 795 796 ret_comp = unqualified_name_from_comp (info->tree); 797 798 if (ret_comp != NULL) 799 /* The ten is completely arbitrary; we don't have a good 800 estimate. */ 801 ret = cp_comp_to_string (ret_comp, 10); 802 803 xfree (storage); 804 xfree (demangled_name); 805 return ret.release (); 806 } 807 808 /* If FULL_NAME is the demangled name of a C++ function (including an 809 arg list, possibly including namespace/class qualifications), 810 return a new string containing only the function name (without the 811 arg list/class qualifications). Otherwise, return NULL. */ 812 813 gdb::unique_xmalloc_ptr<char> 814 cp_func_name (const char *full_name) 815 { 816 gdb::unique_xmalloc_ptr<char> ret; 817 struct demangle_component *ret_comp; 818 std::unique_ptr<demangle_parse_info> info; 819 820 info = cp_demangled_name_to_comp (full_name, NULL); 821 if (!info) 822 return nullptr; 823 824 ret_comp = unqualified_name_from_comp (info->tree); 825 826 if (ret_comp != NULL) 827 ret = cp_comp_to_string (ret_comp, 10); 828 829 return ret; 830 } 831 832 /* Helper for cp_remove_params. DEMANGLED_NAME is the name of a 833 function, including parameters and (optionally) a return type. 834 Return the name of the function without parameters or return type, 835 or NULL if we can not parse the name. If REQUIRE_PARAMS is false, 836 then tolerate a non-existing or unbalanced parameter list. */ 837 838 static gdb::unique_xmalloc_ptr<char> 839 cp_remove_params_1 (const char *demangled_name, bool require_params) 840 { 841 bool done = false; 842 struct demangle_component *ret_comp; 843 std::unique_ptr<demangle_parse_info> info; 844 gdb::unique_xmalloc_ptr<char> ret; 845 846 if (demangled_name == NULL) 847 return NULL; 848 849 info = cp_demangled_name_to_comp (demangled_name, NULL); 850 if (info == NULL) 851 return NULL; 852 853 /* First strip off any qualifiers, if we have a function or method. */ 854 ret_comp = info->tree; 855 while (!done) 856 switch (ret_comp->type) 857 { 858 case DEMANGLE_COMPONENT_CONST: 859 case DEMANGLE_COMPONENT_RESTRICT: 860 case DEMANGLE_COMPONENT_VOLATILE: 861 case DEMANGLE_COMPONENT_CONST_THIS: 862 case DEMANGLE_COMPONENT_RESTRICT_THIS: 863 case DEMANGLE_COMPONENT_VOLATILE_THIS: 864 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 865 ret_comp = d_left (ret_comp); 866 break; 867 default: 868 done = true; 869 break; 870 } 871 872 /* What we have now should be a function. Return its name. */ 873 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME) 874 ret = cp_comp_to_string (d_left (ret_comp), 10); 875 else if (!require_params 876 && (ret_comp->type == DEMANGLE_COMPONENT_NAME 877 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME 878 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)) 879 ret = cp_comp_to_string (ret_comp, 10); 880 881 return ret; 882 } 883 884 /* DEMANGLED_NAME is the name of a function, including parameters and 885 (optionally) a return type. Return the name of the function 886 without parameters or return type, or NULL if we can not parse the 887 name. */ 888 889 gdb::unique_xmalloc_ptr<char> 890 cp_remove_params (const char *demangled_name) 891 { 892 return cp_remove_params_1 (demangled_name, true); 893 } 894 895 /* See cp-support.h. */ 896 897 gdb::unique_xmalloc_ptr<char> 898 cp_remove_params_if_any (const char *demangled_name, bool completion_mode) 899 { 900 /* Trying to remove parameters from the empty string fails. If 901 we're completing / matching everything, avoid returning NULL 902 which would make callers interpret the result as an error. */ 903 if (demangled_name[0] == '\0' && completion_mode) 904 return gdb::unique_xmalloc_ptr<char> (xstrdup ("")); 905 906 gdb::unique_xmalloc_ptr<char> without_params 907 = cp_remove_params_1 (demangled_name, false); 908 909 if (without_params == NULL && completion_mode) 910 { 911 std::string copy = demangled_name; 912 913 while (!copy.empty ()) 914 { 915 copy.pop_back (); 916 without_params = cp_remove_params_1 (copy.c_str (), false); 917 if (without_params != NULL) 918 break; 919 } 920 } 921 922 return without_params; 923 } 924 925 /* Here are some random pieces of trivia to keep in mind while trying 926 to take apart demangled names: 927 928 - Names can contain function arguments or templates, so the process 929 has to be, to some extent recursive: maybe keep track of your 930 depth based on encountering <> and (). 931 932 - Parentheses don't just have to happen at the end of a name: they 933 can occur even if the name in question isn't a function, because 934 a template argument might be a type that's a function. 935 936 - Conversely, even if you're trying to deal with a function, its 937 demangled name might not end with ')': it could be a const or 938 volatile class method, in which case it ends with "const" or 939 "volatile". 940 941 - Parentheses are also used in anonymous namespaces: a variable 942 'foo' in an anonymous namespace gets demangled as "(anonymous 943 namespace)::foo". 944 945 - And operator names can contain parentheses or angle brackets. */ 946 947 /* FIXME: carlton/2003-03-13: We have several functions here with 948 overlapping functionality; can we combine them? Also, do they 949 handle all the above considerations correctly? */ 950 951 952 /* This returns the length of first component of NAME, which should be 953 the demangled name of a C++ variable/function/method/etc. 954 Specifically, it returns the index of the first colon forming the 955 boundary of the first component: so, given 'A::foo' or 'A::B::foo' 956 it returns the 1, and given 'foo', it returns 0. */ 957 958 /* The character in NAME indexed by the return value is guaranteed to 959 always be either ':' or '\0'. */ 960 961 /* NOTE: carlton/2003-03-13: This function is currently only intended 962 for internal use: it's probably not entirely safe when called on 963 user-generated input, because some of the 'index += 2' lines in 964 cp_find_first_component_aux might go past the end of malformed 965 input. */ 966 967 unsigned int 968 cp_find_first_component (const char *name) 969 { 970 return cp_find_first_component_aux (name, 0); 971 } 972 973 /* Helper function for cp_find_first_component. Like that function, 974 it returns the length of the first component of NAME, but to make 975 the recursion easier, it also stops if it reaches an unexpected ')' 976 or '>' if the value of PERMISSIVE is nonzero. */ 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 return index; 1040 case ':': 1041 /* ':' marks a component iff the next character is also a ':'. 1042 Otherwise it is probably malformed input. */ 1043 if (name[index + 1] == ':') 1044 return index; 1045 break; 1046 case 'o': 1047 /* Operator names can screw up the recursion. */ 1048 if (operator_possible 1049 && startswith (name + index, CP_OPERATOR_STR)) 1050 { 1051 index += CP_OPERATOR_LEN; 1052 while (ISSPACE(name[index])) 1053 ++index; 1054 switch (name[index]) 1055 { 1056 case '\0': 1057 return index; 1058 /* Skip over one less than the appropriate number of 1059 characters: the for loop will skip over the last 1060 one. */ 1061 case '<': 1062 if (name[index + 1] == '<') 1063 index += 1; 1064 else 1065 index += 0; 1066 break; 1067 case '>': 1068 case '-': 1069 if (name[index + 1] == '>') 1070 index += 1; 1071 else 1072 index += 0; 1073 break; 1074 case '(': 1075 index += 1; 1076 break; 1077 default: 1078 index += 0; 1079 break; 1080 } 1081 } 1082 operator_possible = 0; 1083 break; 1084 case ' ': 1085 case ',': 1086 case '.': 1087 case '&': 1088 case '*': 1089 /* NOTE: carlton/2003-04-18: I'm not sure what the precise 1090 set of relevant characters are here: it's necessary to 1091 include any character that can show up before 'operator' 1092 in a demangled name, and it's safe to include any 1093 character that can't be part of an identifier's name. */ 1094 operator_possible = 1; 1095 break; 1096 default: 1097 operator_possible = 0; 1098 break; 1099 } 1100 } 1101 } 1102 1103 /* Complain about a demangled name that we don't know how to parse. 1104 NAME is the demangled name in question. */ 1105 1106 static void 1107 demangled_name_complaint (const char *name) 1108 { 1109 complaint ("unexpected demangled name '%s'", name); 1110 } 1111 1112 /* If NAME is the fully-qualified name of a C++ 1113 function/variable/method/etc., this returns the length of its 1114 entire prefix: all of the namespaces and classes that make up its 1115 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns 1116 4, given 'foo', it returns 0. */ 1117 1118 unsigned int 1119 cp_entire_prefix_len (const char *name) 1120 { 1121 unsigned int current_len = cp_find_first_component (name); 1122 unsigned int previous_len = 0; 1123 1124 while (name[current_len] != '\0') 1125 { 1126 gdb_assert (name[current_len] == ':'); 1127 previous_len = current_len; 1128 /* Skip the '::'. */ 1129 current_len += 2; 1130 current_len += cp_find_first_component (name + current_len); 1131 } 1132 1133 return previous_len; 1134 } 1135 1136 /* Overload resolution functions. */ 1137 1138 /* Test to see if SYM is a symbol that we haven't seen corresponding 1139 to a function named OLOAD_NAME. If so, add it to 1140 OVERLOAD_LIST. */ 1141 1142 static void 1143 overload_list_add_symbol (struct symbol *sym, 1144 const char *oload_name, 1145 std::vector<symbol *> *overload_list) 1146 { 1147 /* If there is no type information, we can't do anything, so 1148 skip. */ 1149 if (SYMBOL_TYPE (sym) == NULL) 1150 return; 1151 1152 /* skip any symbols that we've already considered. */ 1153 for (symbol *listed_sym : *overload_list) 1154 if (strcmp (SYMBOL_LINKAGE_NAME (sym), 1155 SYMBOL_LINKAGE_NAME (listed_sym)) == 0) 1156 return; 1157 1158 /* Get the demangled name without parameters */ 1159 gdb::unique_xmalloc_ptr<char> sym_name 1160 = cp_remove_params (SYMBOL_NATURAL_NAME (sym)); 1161 if (!sym_name) 1162 return; 1163 1164 /* skip symbols that cannot match */ 1165 if (strcmp (sym_name.get (), oload_name) != 0) 1166 return; 1167 1168 overload_list->push_back (sym); 1169 } 1170 1171 /* Return a null-terminated list of pointers to function symbols that 1172 are named FUNC_NAME and are visible within NAMESPACE. */ 1173 1174 struct std::vector<symbol *> 1175 make_symbol_overload_list (const char *func_name, 1176 const char *the_namespace) 1177 { 1178 const char *name; 1179 std::vector<symbol *> overload_list; 1180 1181 overload_list.reserve (100); 1182 1183 add_symbol_overload_list_using (func_name, the_namespace, &overload_list); 1184 1185 if (the_namespace[0] == '\0') 1186 name = func_name; 1187 else 1188 { 1189 char *concatenated_name 1190 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1); 1191 strcpy (concatenated_name, the_namespace); 1192 strcat (concatenated_name, "::"); 1193 strcat (concatenated_name, func_name); 1194 name = concatenated_name; 1195 } 1196 1197 add_symbol_overload_list_qualified (name, &overload_list); 1198 return overload_list; 1199 } 1200 1201 /* Add all symbols with a name matching NAME in BLOCK to the overload 1202 list. */ 1203 1204 static void 1205 add_symbol_overload_list_block (const char *name, 1206 const struct block *block, 1207 std::vector<symbol *> *overload_list) 1208 { 1209 struct block_iterator iter; 1210 struct symbol *sym; 1211 1212 lookup_name_info lookup_name (name, symbol_name_match_type::FULL); 1213 1214 ALL_BLOCK_SYMBOLS_WITH_NAME (block, lookup_name, iter, sym) 1215 overload_list_add_symbol (sym, name, overload_list); 1216 } 1217 1218 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */ 1219 1220 static void 1221 add_symbol_overload_list_namespace (const char *func_name, 1222 const char *the_namespace, 1223 std::vector<symbol *> *overload_list) 1224 { 1225 const char *name; 1226 const struct block *block = NULL; 1227 1228 if (the_namespace[0] == '\0') 1229 name = func_name; 1230 else 1231 { 1232 char *concatenated_name 1233 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1); 1234 1235 strcpy (concatenated_name, the_namespace); 1236 strcat (concatenated_name, "::"); 1237 strcat (concatenated_name, func_name); 1238 name = concatenated_name; 1239 } 1240 1241 /* Look in the static block. */ 1242 block = block_static_block (get_selected_block (0)); 1243 if (block) 1244 add_symbol_overload_list_block (name, block, overload_list); 1245 1246 /* Look in the global block. */ 1247 block = block_global_block (block); 1248 if (block) 1249 add_symbol_overload_list_block (name, block, overload_list); 1250 1251 } 1252 1253 /* Search the namespace of the given type and namespace of and public 1254 base types. */ 1255 1256 static void 1257 add_symbol_overload_list_adl_namespace (struct type *type, 1258 const char *func_name, 1259 std::vector<symbol *> *overload_list) 1260 { 1261 char *the_namespace; 1262 const char *type_name; 1263 int i, prefix_len; 1264 1265 while (TYPE_CODE (type) == TYPE_CODE_PTR 1266 || TYPE_IS_REFERENCE (type) 1267 || TYPE_CODE (type) == TYPE_CODE_ARRAY 1268 || TYPE_CODE (type) == TYPE_CODE_TYPEDEF) 1269 { 1270 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) 1271 type = check_typedef(type); 1272 else 1273 type = TYPE_TARGET_TYPE (type); 1274 } 1275 1276 type_name = TYPE_NAME (type); 1277 1278 if (type_name == NULL) 1279 return; 1280 1281 prefix_len = cp_entire_prefix_len (type_name); 1282 1283 if (prefix_len != 0) 1284 { 1285 the_namespace = (char *) alloca (prefix_len + 1); 1286 strncpy (the_namespace, type_name, prefix_len); 1287 the_namespace[prefix_len] = '\0'; 1288 1289 add_symbol_overload_list_namespace (func_name, the_namespace, 1290 overload_list); 1291 } 1292 1293 /* Check public base type */ 1294 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 1295 for (i = 0; i < TYPE_N_BASECLASSES (type); i++) 1296 { 1297 if (BASETYPE_VIA_PUBLIC (type, i)) 1298 add_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type, i), 1299 func_name, 1300 overload_list); 1301 } 1302 } 1303 1304 /* Adds to OVERLOAD_LIST the overload list overload candidates for 1305 FUNC_NAME found through argument dependent lookup. */ 1306 1307 void 1308 add_symbol_overload_list_adl (gdb::array_view<type *> arg_types, 1309 const char *func_name, 1310 std::vector<symbol *> *overload_list) 1311 { 1312 for (type *arg_type : arg_types) 1313 add_symbol_overload_list_adl_namespace (arg_type, func_name, 1314 overload_list); 1315 } 1316 1317 /* This applies the using directives to add namespaces to search in, 1318 and then searches for overloads in all of those namespaces. It 1319 adds the symbols found to sym_return_val. Arguments are as in 1320 make_symbol_overload_list. */ 1321 1322 static void 1323 add_symbol_overload_list_using (const char *func_name, 1324 const char *the_namespace, 1325 std::vector<symbol *> *overload_list) 1326 { 1327 struct using_direct *current; 1328 const struct block *block; 1329 1330 /* First, go through the using directives. If any of them apply, 1331 look in the appropriate namespaces for new functions to match 1332 on. */ 1333 1334 for (block = get_selected_block (0); 1335 block != NULL; 1336 block = BLOCK_SUPERBLOCK (block)) 1337 for (current = block_using (block); 1338 current != NULL; 1339 current = current->next) 1340 { 1341 /* Prevent recursive calls. */ 1342 if (current->searched) 1343 continue; 1344 1345 /* If this is a namespace alias or imported declaration ignore 1346 it. */ 1347 if (current->alias != NULL || current->declaration != NULL) 1348 continue; 1349 1350 if (strcmp (the_namespace, current->import_dest) == 0) 1351 { 1352 /* Mark this import as searched so that the recursive call 1353 does not search it again. */ 1354 scoped_restore reset_directive_searched 1355 = make_scoped_restore (¤t->searched, 1); 1356 1357 add_symbol_overload_list_using (func_name, 1358 current->import_src, 1359 overload_list); 1360 } 1361 } 1362 1363 /* Now, add names for this namespace. */ 1364 add_symbol_overload_list_namespace (func_name, the_namespace, 1365 overload_list); 1366 } 1367 1368 /* This does the bulk of the work of finding overloaded symbols. 1369 FUNC_NAME is the name of the overloaded function we're looking for 1370 (possibly including namespace info). */ 1371 1372 static void 1373 add_symbol_overload_list_qualified (const char *func_name, 1374 std::vector<symbol *> *overload_list) 1375 { 1376 const struct block *b, *surrounding_static_block = 0; 1377 1378 /* Look through the partial symtabs for all symbols which begin by 1379 matching FUNC_NAME. Make sure we read that symbol table in. */ 1380 1381 for (objfile *objf : current_program_space->objfiles ()) 1382 { 1383 if (objf->sf) 1384 objf->sf->qf->expand_symtabs_for_function (objf, func_name); 1385 } 1386 1387 /* Search upwards from currently selected frame (so that we can 1388 complete on local vars. */ 1389 1390 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b)) 1391 add_symbol_overload_list_block (func_name, b, overload_list); 1392 1393 surrounding_static_block = block_static_block (get_selected_block (0)); 1394 1395 /* Go through the symtabs and check the externs and statics for 1396 symbols which match. */ 1397 1398 for (objfile *objfile : current_program_space->objfiles ()) 1399 { 1400 for (compunit_symtab *cust : objfile->compunits ()) 1401 { 1402 QUIT; 1403 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), GLOBAL_BLOCK); 1404 add_symbol_overload_list_block (func_name, b, overload_list); 1405 } 1406 } 1407 1408 for (objfile *objfile : current_program_space->objfiles ()) 1409 { 1410 for (compunit_symtab *cust : objfile->compunits ()) 1411 { 1412 QUIT; 1413 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK); 1414 /* Don't do this block twice. */ 1415 if (b == surrounding_static_block) 1416 continue; 1417 add_symbol_overload_list_block (func_name, b, overload_list); 1418 } 1419 } 1420 } 1421 1422 /* Lookup the rtti type for a class name. */ 1423 1424 struct type * 1425 cp_lookup_rtti_type (const char *name, struct block *block) 1426 { 1427 struct symbol * rtti_sym; 1428 struct type * rtti_type; 1429 1430 /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417. 1431 Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */ 1432 rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol; 1433 1434 if (rtti_sym == NULL) 1435 { 1436 warning (_("RTTI symbol not found for class '%s'"), name); 1437 return NULL; 1438 } 1439 1440 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF) 1441 { 1442 warning (_("RTTI symbol for class '%s' is not a type"), name); 1443 return NULL; 1444 } 1445 1446 rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym)); 1447 1448 switch (TYPE_CODE (rtti_type)) 1449 { 1450 case TYPE_CODE_STRUCT: 1451 break; 1452 case TYPE_CODE_NAMESPACE: 1453 /* chastain/2003-11-26: the symbol tables often contain fake 1454 symbols for namespaces with the same name as the struct. 1455 This warning is an indication of a bug in the lookup order 1456 or a bug in the way that the symbol tables are populated. */ 1457 warning (_("RTTI symbol for class '%s' is a namespace"), name); 1458 return NULL; 1459 default: 1460 warning (_("RTTI symbol for class '%s' has bad type"), name); 1461 return NULL; 1462 } 1463 1464 return rtti_type; 1465 } 1466 1467 #ifdef HAVE_WORKING_FORK 1468 1469 /* If nonzero, attempt to catch crashes in the demangler and print 1470 useful debugging information. */ 1471 1472 static int catch_demangler_crashes = 1; 1473 1474 /* Stack context and environment for demangler crash recovery. */ 1475 1476 static SIGJMP_BUF gdb_demangle_jmp_buf; 1477 1478 /* If nonzero, attempt to dump core from the signal handler. */ 1479 1480 static int gdb_demangle_attempt_core_dump = 1; 1481 1482 /* Signal handler for gdb_demangle. */ 1483 1484 static void 1485 gdb_demangle_signal_handler (int signo) 1486 { 1487 if (gdb_demangle_attempt_core_dump) 1488 { 1489 if (fork () == 0) 1490 dump_core (); 1491 1492 gdb_demangle_attempt_core_dump = 0; 1493 } 1494 1495 SIGLONGJMP (gdb_demangle_jmp_buf, signo); 1496 } 1497 1498 #endif 1499 1500 /* A wrapper for bfd_demangle. */ 1501 1502 char * 1503 gdb_demangle (const char *name, int options) 1504 { 1505 char *result = NULL; 1506 int crash_signal = 0; 1507 1508 #ifdef HAVE_WORKING_FORK 1509 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 1510 struct sigaction sa, old_sa; 1511 #else 1512 sighandler_t ofunc; 1513 #endif 1514 static int core_dump_allowed = -1; 1515 1516 if (core_dump_allowed == -1) 1517 { 1518 core_dump_allowed = can_dump_core (LIMIT_CUR); 1519 1520 if (!core_dump_allowed) 1521 gdb_demangle_attempt_core_dump = 0; 1522 } 1523 1524 if (catch_demangler_crashes) 1525 { 1526 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 1527 sa.sa_handler = gdb_demangle_signal_handler; 1528 sigemptyset (&sa.sa_mask); 1529 #ifdef HAVE_SIGALTSTACK 1530 sa.sa_flags = SA_ONSTACK; 1531 #else 1532 sa.sa_flags = 0; 1533 #endif 1534 sigaction (SIGSEGV, &sa, &old_sa); 1535 #else 1536 ofunc = signal (SIGSEGV, gdb_demangle_signal_handler); 1537 #endif 1538 1539 crash_signal = SIGSETJMP (gdb_demangle_jmp_buf); 1540 } 1541 #endif 1542 1543 if (crash_signal == 0) 1544 result = bfd_demangle (NULL, name, options); 1545 1546 #ifdef HAVE_WORKING_FORK 1547 if (catch_demangler_crashes) 1548 { 1549 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 1550 sigaction (SIGSEGV, &old_sa, NULL); 1551 #else 1552 signal (SIGSEGV, ofunc); 1553 #endif 1554 1555 if (crash_signal != 0) 1556 { 1557 static int error_reported = 0; 1558 1559 if (!error_reported) 1560 { 1561 std::string short_msg 1562 = string_printf (_("unable to demangle '%s' " 1563 "(demangler failed with signal %d)"), 1564 name, crash_signal); 1565 1566 std::string long_msg 1567 = string_printf ("%s:%d: %s: %s", __FILE__, __LINE__, 1568 "demangler-warning", short_msg.c_str ()); 1569 1570 target_terminal::scoped_restore_terminal_state term_state; 1571 target_terminal::ours_for_output (); 1572 1573 begin_line (); 1574 if (core_dump_allowed) 1575 fprintf_unfiltered (gdb_stderr, 1576 _("%s\nAttempting to dump core.\n"), 1577 long_msg.c_str ()); 1578 else 1579 warn_cant_dump_core (long_msg.c_str ()); 1580 1581 demangler_warning (__FILE__, __LINE__, "%s", short_msg.c_str ()); 1582 1583 error_reported = 1; 1584 } 1585 1586 result = NULL; 1587 } 1588 } 1589 #endif 1590 1591 return result; 1592 } 1593 1594 /* See cp-support.h. */ 1595 1596 int 1597 gdb_sniff_from_mangled_name (const char *mangled, char **demangled) 1598 { 1599 *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI); 1600 return *demangled != NULL; 1601 } 1602 1603 /* See cp-support.h. */ 1604 1605 unsigned int 1606 cp_search_name_hash (const char *search_name) 1607 { 1608 /* cp_entire_prefix_len assumes a fully-qualified name with no 1609 leading "::". */ 1610 if (startswith (search_name, "::")) 1611 search_name += 2; 1612 1613 unsigned int prefix_len = cp_entire_prefix_len (search_name); 1614 if (prefix_len != 0) 1615 search_name += prefix_len + 2; 1616 1617 unsigned int hash = 0; 1618 for (const char *string = search_name; *string != '\0'; ++string) 1619 { 1620 string = skip_spaces (string); 1621 1622 if (*string == '(') 1623 break; 1624 1625 /* Ignore ABI tags such as "[abi:cxx11]. */ 1626 if (*string == '[' 1627 && startswith (string + 1, "abi:") 1628 && string[5] != ':') 1629 break; 1630 1631 hash = SYMBOL_HASH_NEXT (hash, *string); 1632 } 1633 return hash; 1634 } 1635 1636 /* Helper for cp_symbol_name_matches (i.e., symbol_name_matcher_ftype 1637 implementation for symbol_name_match_type::WILD matching). Split 1638 to a separate function for unit-testing convenience. 1639 1640 If SYMBOL_SEARCH_NAME has more scopes than LOOKUP_NAME, we try to 1641 match ignoring the extra leading scopes of SYMBOL_SEARCH_NAME. 1642 This allows conveniently setting breakpoints on functions/methods 1643 inside any namespace/class without specifying the fully-qualified 1644 name. 1645 1646 E.g., these match: 1647 1648 [symbol search name] [lookup name] 1649 foo::bar::func foo::bar::func 1650 foo::bar::func bar::func 1651 foo::bar::func func 1652 1653 While these don't: 1654 1655 [symbol search name] [lookup name] 1656 foo::zbar::func bar::func 1657 foo::bar::func foo::func 1658 1659 See more examples in the test_cp_symbol_name_matches selftest 1660 function below. 1661 1662 See symbol_name_matcher_ftype for description of SYMBOL_SEARCH_NAME 1663 and COMP_MATCH_RES. 1664 1665 LOOKUP_NAME/LOOKUP_NAME_LEN is the name we're looking up. 1666 1667 See strncmp_iw_with_mode for description of MODE. 1668 */ 1669 1670 static bool 1671 cp_symbol_name_matches_1 (const char *symbol_search_name, 1672 const char *lookup_name, 1673 size_t lookup_name_len, 1674 strncmp_iw_mode mode, 1675 completion_match_result *comp_match_res) 1676 { 1677 const char *sname = symbol_search_name; 1678 completion_match_for_lcd *match_for_lcd 1679 = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL); 1680 1681 while (true) 1682 { 1683 if (strncmp_iw_with_mode (sname, lookup_name, lookup_name_len, 1684 mode, language_cplus, match_for_lcd) == 0) 1685 { 1686 if (comp_match_res != NULL) 1687 { 1688 /* Note here we set different MATCH and MATCH_FOR_LCD 1689 strings. This is because with 1690 1691 (gdb) b push_bac[TAB] 1692 1693 we want the completion matches to list 1694 1695 std::vector<int>::push_back(...) 1696 std::vector<char>::push_back(...) 1697 1698 etc., which are SYMBOL_SEARCH_NAMEs, while we want 1699 the input line to auto-complete to 1700 1701 (gdb) push_back(...) 1702 1703 which is SNAME, not to 1704 1705 (gdb) std::vector< 1706 1707 which would be the regular common prefix between all 1708 the matches otherwise. */ 1709 comp_match_res->set_match (symbol_search_name, sname); 1710 } 1711 return true; 1712 } 1713 1714 unsigned int len = cp_find_first_component (sname); 1715 1716 if (sname[len] == '\0') 1717 return false; 1718 1719 gdb_assert (sname[len] == ':'); 1720 /* Skip the '::'. */ 1721 sname += len + 2; 1722 } 1723 } 1724 1725 /* C++ symbol_name_matcher_ftype implementation. */ 1726 1727 static bool 1728 cp_fq_symbol_name_matches (const char *symbol_search_name, 1729 const lookup_name_info &lookup_name, 1730 completion_match_result *comp_match_res) 1731 { 1732 /* Get the demangled name. */ 1733 const std::string &name = lookup_name.cplus ().lookup_name (); 1734 completion_match_for_lcd *match_for_lcd 1735 = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL); 1736 strncmp_iw_mode mode = (lookup_name.completion_mode () 1737 ? strncmp_iw_mode::NORMAL 1738 : strncmp_iw_mode::MATCH_PARAMS); 1739 1740 if (strncmp_iw_with_mode (symbol_search_name, 1741 name.c_str (), name.size (), 1742 mode, language_cplus, match_for_lcd) == 0) 1743 { 1744 if (comp_match_res != NULL) 1745 comp_match_res->set_match (symbol_search_name); 1746 return true; 1747 } 1748 1749 return false; 1750 } 1751 1752 /* C++ symbol_name_matcher_ftype implementation for wild matches. 1753 Defers work to cp_symbol_name_matches_1. */ 1754 1755 static bool 1756 cp_symbol_name_matches (const char *symbol_search_name, 1757 const lookup_name_info &lookup_name, 1758 completion_match_result *comp_match_res) 1759 { 1760 /* Get the demangled name. */ 1761 const std::string &name = lookup_name.cplus ().lookup_name (); 1762 1763 strncmp_iw_mode mode = (lookup_name.completion_mode () 1764 ? strncmp_iw_mode::NORMAL 1765 : strncmp_iw_mode::MATCH_PARAMS); 1766 1767 return cp_symbol_name_matches_1 (symbol_search_name, 1768 name.c_str (), name.size (), 1769 mode, comp_match_res); 1770 } 1771 1772 /* See cp-support.h. */ 1773 1774 symbol_name_matcher_ftype * 1775 cp_get_symbol_name_matcher (const lookup_name_info &lookup_name) 1776 { 1777 switch (lookup_name.match_type ()) 1778 { 1779 case symbol_name_match_type::FULL: 1780 case symbol_name_match_type::EXPRESSION: 1781 case symbol_name_match_type::SEARCH_NAME: 1782 return cp_fq_symbol_name_matches; 1783 case symbol_name_match_type::WILD: 1784 return cp_symbol_name_matches; 1785 } 1786 1787 gdb_assert_not_reached (""); 1788 } 1789 1790 #if GDB_SELF_TEST 1791 1792 namespace selftests { 1793 1794 void 1795 test_cp_symbol_name_matches () 1796 { 1797 #define CHECK_MATCH(SYMBOL, INPUT) \ 1798 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, \ 1799 INPUT, sizeof (INPUT) - 1, \ 1800 strncmp_iw_mode::MATCH_PARAMS, \ 1801 NULL)) 1802 1803 #define CHECK_NOT_MATCH(SYMBOL, INPUT) \ 1804 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, \ 1805 INPUT, sizeof (INPUT) - 1, \ 1806 strncmp_iw_mode::MATCH_PARAMS, \ 1807 NULL)) 1808 1809 /* Like CHECK_MATCH, and also check that INPUT (and all substrings 1810 that start at index 0) completes to SYMBOL. */ 1811 #define CHECK_MATCH_C(SYMBOL, INPUT) \ 1812 do \ 1813 { \ 1814 CHECK_MATCH (SYMBOL, INPUT); \ 1815 for (size_t i = 0; i < sizeof (INPUT) - 1; i++) \ 1816 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, INPUT, i, \ 1817 strncmp_iw_mode::NORMAL, \ 1818 NULL)); \ 1819 } while (0) 1820 1821 /* Like CHECK_NOT_MATCH, and also check that INPUT does NOT complete 1822 to SYMBOL. */ 1823 #define CHECK_NOT_MATCH_C(SYMBOL, INPUT) \ 1824 do \ 1825 { \ 1826 CHECK_NOT_MATCH (SYMBOL, INPUT); \ 1827 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, INPUT, \ 1828 sizeof (INPUT) - 1, \ 1829 strncmp_iw_mode::NORMAL, \ 1830 NULL)); \ 1831 } while (0) 1832 1833 /* Lookup name without parens matches all overloads. */ 1834 CHECK_MATCH_C ("function()", "function"); 1835 CHECK_MATCH_C ("function(int)", "function"); 1836 1837 /* Check whitespace around parameters is ignored. */ 1838 CHECK_MATCH_C ("function()", "function ()"); 1839 CHECK_MATCH_C ("function ( )", "function()"); 1840 CHECK_MATCH_C ("function ()", "function( )"); 1841 CHECK_MATCH_C ("func(int)", "func( int )"); 1842 CHECK_MATCH_C ("func(int)", "func ( int ) "); 1843 CHECK_MATCH_C ("func ( int )", "func( int )"); 1844 CHECK_MATCH_C ("func ( int )", "func ( int ) "); 1845 1846 /* Check symbol name prefixes aren't incorrectly matched. */ 1847 CHECK_NOT_MATCH ("func", "function"); 1848 CHECK_NOT_MATCH ("function", "func"); 1849 CHECK_NOT_MATCH ("function()", "func"); 1850 1851 /* Check that if the lookup name includes parameters, only the right 1852 overload matches. */ 1853 CHECK_MATCH_C ("function(int)", "function(int)"); 1854 CHECK_NOT_MATCH_C ("function(int)", "function()"); 1855 1856 /* Check that whitespace within symbol names is not ignored. */ 1857 CHECK_NOT_MATCH_C ("function", "func tion"); 1858 CHECK_NOT_MATCH_C ("func__tion", "func_ _tion"); 1859 CHECK_NOT_MATCH_C ("func11tion", "func1 1tion"); 1860 1861 /* Check the converse, which can happen with template function, 1862 where the return type is part of the demangled name. */ 1863 CHECK_NOT_MATCH_C ("func tion", "function"); 1864 CHECK_NOT_MATCH_C ("func1 1tion", "func11tion"); 1865 CHECK_NOT_MATCH_C ("func_ _tion", "func__tion"); 1866 1867 /* Within parameters too. */ 1868 CHECK_NOT_MATCH_C ("func(param)", "func(par am)"); 1869 1870 /* Check handling of whitespace around C++ operators. */ 1871 CHECK_NOT_MATCH_C ("operator<<", "opera tor<<"); 1872 CHECK_NOT_MATCH_C ("operator<<", "operator< <"); 1873 CHECK_NOT_MATCH_C ("operator<<", "operator < <"); 1874 CHECK_NOT_MATCH_C ("operator==", "operator= ="); 1875 CHECK_NOT_MATCH_C ("operator==", "operator = ="); 1876 CHECK_MATCH_C ("operator<<", "operator <<"); 1877 CHECK_MATCH_C ("operator<<()", "operator <<"); 1878 CHECK_NOT_MATCH_C ("operator<<()", "operator<<(int)"); 1879 CHECK_NOT_MATCH_C ("operator<<(int)", "operator<<()"); 1880 CHECK_MATCH_C ("operator==", "operator =="); 1881 CHECK_MATCH_C ("operator==()", "operator =="); 1882 CHECK_MATCH_C ("operator <<", "operator<<"); 1883 CHECK_MATCH_C ("operator ==", "operator=="); 1884 CHECK_MATCH_C ("operator bool", "operator bool"); 1885 CHECK_MATCH_C ("operator bool ()", "operator bool"); 1886 CHECK_MATCH_C ("operatorX<<", "operatorX < <"); 1887 CHECK_MATCH_C ("Xoperator<<", "Xoperator < <"); 1888 1889 CHECK_MATCH_C ("operator()(int)", "operator()(int)"); 1890 CHECK_MATCH_C ("operator()(int)", "operator ( ) ( int )"); 1891 CHECK_MATCH_C ("operator()<long>(int)", "operator ( ) < long > ( int )"); 1892 /* The first "()" is not the parameter list. */ 1893 CHECK_NOT_MATCH ("operator()(int)", "operator"); 1894 1895 /* Misc user-defined operator tests. */ 1896 1897 CHECK_NOT_MATCH_C ("operator/=()", "operator ^="); 1898 /* Same length at end of input. */ 1899 CHECK_NOT_MATCH_C ("operator>>", "operator[]"); 1900 /* Same length but not at end of input. */ 1901 CHECK_NOT_MATCH_C ("operator>>()", "operator[]()"); 1902 1903 CHECK_MATCH_C ("base::operator char*()", "base::operator char*()"); 1904 CHECK_MATCH_C ("base::operator char*()", "base::operator char * ()"); 1905 CHECK_MATCH_C ("base::operator char**()", "base::operator char * * ()"); 1906 CHECK_MATCH ("base::operator char**()", "base::operator char * *"); 1907 CHECK_MATCH_C ("base::operator*()", "base::operator*()"); 1908 CHECK_NOT_MATCH_C ("base::operator char*()", "base::operatorc"); 1909 CHECK_NOT_MATCH ("base::operator char*()", "base::operator char"); 1910 CHECK_NOT_MATCH ("base::operator char*()", "base::operat"); 1911 1912 /* Check handling of whitespace around C++ scope operators. */ 1913 CHECK_NOT_MATCH_C ("foo::bar", "foo: :bar"); 1914 CHECK_MATCH_C ("foo::bar", "foo :: bar"); 1915 CHECK_MATCH_C ("foo :: bar", "foo::bar"); 1916 1917 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi()"); 1918 CHECK_MATCH_C ("abc::def::ghi ( )", "abc::def::ghi()"); 1919 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi ( )"); 1920 CHECK_MATCH_C ("function()", "function()"); 1921 CHECK_MATCH_C ("bar::function()", "bar::function()"); 1922 1923 /* Wild matching tests follow. */ 1924 1925 /* Tests matching symbols in some scope. */ 1926 CHECK_MATCH_C ("foo::function()", "function"); 1927 CHECK_MATCH_C ("foo::function(int)", "function"); 1928 CHECK_MATCH_C ("foo::bar::function()", "function"); 1929 CHECK_MATCH_C ("bar::function()", "bar::function"); 1930 CHECK_MATCH_C ("foo::bar::function()", "bar::function"); 1931 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function"); 1932 1933 /* Same, with parameters in the lookup name. */ 1934 CHECK_MATCH_C ("foo::function()", "function()"); 1935 CHECK_MATCH_C ("foo::bar::function()", "function()"); 1936 CHECK_MATCH_C ("foo::function(int)", "function(int)"); 1937 CHECK_MATCH_C ("foo::function()", "foo::function()"); 1938 CHECK_MATCH_C ("foo::bar::function()", "bar::function()"); 1939 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function(int)"); 1940 CHECK_MATCH_C ("bar::function()", "bar::function()"); 1941 1942 CHECK_NOT_MATCH_C ("foo::bar::function(int)", "bar::function()"); 1943 1944 CHECK_MATCH_C ("(anonymous namespace)::bar::function(int)", 1945 "bar::function(int)"); 1946 CHECK_MATCH_C ("foo::(anonymous namespace)::bar::function(int)", 1947 "function(int)"); 1948 1949 /* Lookup scope wider than symbol scope, should not match. */ 1950 CHECK_NOT_MATCH_C ("function()", "bar::function"); 1951 CHECK_NOT_MATCH_C ("function()", "bar::function()"); 1952 1953 /* Explicit global scope doesn't match. */ 1954 CHECK_NOT_MATCH_C ("foo::function()", "::function"); 1955 CHECK_NOT_MATCH_C ("foo::function()", "::function()"); 1956 CHECK_NOT_MATCH_C ("foo::function(int)", "::function()"); 1957 CHECK_NOT_MATCH_C ("foo::function(int)", "::function(int)"); 1958 1959 /* Test ABI tag matching/ignoring. */ 1960 1961 /* If the symbol name has an ABI tag, but the lookup name doesn't, 1962 then the ABI tag in the symbol name is ignored. */ 1963 CHECK_MATCH_C ("function[abi:foo]()", "function"); 1964 CHECK_MATCH_C ("function[abi:foo](int)", "function"); 1965 CHECK_MATCH_C ("function[abi:foo]()", "function ()"); 1966 CHECK_NOT_MATCH_C ("function[abi:foo]()", "function (int)"); 1967 1968 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo]"); 1969 CHECK_MATCH_C ("function[abi:foo](int)", "function[abi:foo]"); 1970 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo] ()"); 1971 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function"); 1972 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function"); 1973 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo]"); 1974 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function[abi:foo]"); 1975 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] ()"); 1976 CHECK_NOT_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] (int)"); 1977 1978 CHECK_MATCH_C ("function [abi:foo][abi:bar] ( )", "function [abi:foo]"); 1979 1980 /* If the symbol name does not have an ABI tag, while the lookup 1981 name has one, then there's no match. */ 1982 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]()"); 1983 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]"); 1984 } 1985 1986 /* If non-NULL, return STR wrapped in quotes. Otherwise, return a 1987 "<null>" string (with no quotes). */ 1988 1989 static std::string 1990 quote (const char *str) 1991 { 1992 if (str != NULL) 1993 return std::string (1, '\"') + str + '\"'; 1994 else 1995 return "<null>"; 1996 } 1997 1998 /* Check that removing parameter info out of NAME produces EXPECTED. 1999 COMPLETION_MODE indicates whether we're testing normal and 2000 completion mode. FILE and LINE are used to provide better test 2001 location information in case ithe check fails. */ 2002 2003 static void 2004 check_remove_params (const char *file, int line, 2005 const char *name, const char *expected, 2006 bool completion_mode) 2007 { 2008 gdb::unique_xmalloc_ptr<char> result 2009 = cp_remove_params_if_any (name, completion_mode); 2010 2011 if ((expected == NULL) != (result == NULL) 2012 || (expected != NULL 2013 && strcmp (result.get (), expected) != 0)) 2014 { 2015 error (_("%s:%d: make-paramless self-test failed: (completion=%d) " 2016 "\"%s\" -> %s, expected %s"), 2017 file, line, completion_mode, name, 2018 quote (result.get ()).c_str (), quote (expected).c_str ()); 2019 } 2020 } 2021 2022 /* Entry point for cp_remove_params unit tests. */ 2023 2024 static void 2025 test_cp_remove_params () 2026 { 2027 /* Check that removing parameter info out of NAME produces EXPECTED. 2028 Checks both normal and completion modes. */ 2029 #define CHECK(NAME, EXPECTED) \ 2030 do \ 2031 { \ 2032 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, false); \ 2033 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \ 2034 } \ 2035 while (0) 2036 2037 /* Similar, but used when NAME is incomplete -- i.e., is has 2038 unbalanced parentheses. In this case, looking for the exact name 2039 should fail / return empty. */ 2040 #define CHECK_INCOMPL(NAME, EXPECTED) \ 2041 do \ 2042 { \ 2043 check_remove_params (__FILE__, __LINE__, NAME, NULL, false); \ 2044 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \ 2045 } \ 2046 while (0) 2047 2048 CHECK ("function()", "function"); 2049 CHECK_INCOMPL ("function(", "function"); 2050 CHECK ("function() const", "function"); 2051 2052 CHECK ("(anonymous namespace)::A::B::C", 2053 "(anonymous namespace)::A::B::C"); 2054 2055 CHECK ("A::(anonymous namespace)", 2056 "A::(anonymous namespace)"); 2057 2058 CHECK_INCOMPL ("A::(anonymou", "A"); 2059 2060 CHECK ("A::foo<int>()", 2061 "A::foo<int>"); 2062 2063 CHECK_INCOMPL ("A::foo<int>(", 2064 "A::foo<int>"); 2065 2066 CHECK ("A::foo<(anonymous namespace)::B>::func(int)", 2067 "A::foo<(anonymous namespace)::B>::func"); 2068 2069 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::func(in", 2070 "A::foo<(anonymous namespace)::B>::func"); 2071 2072 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::", 2073 "A::foo<(anonymous namespace)::B>"); 2074 2075 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>:", 2076 "A::foo<(anonymous namespace)::B>"); 2077 2078 CHECK ("A::foo<(anonymous namespace)::B>", 2079 "A::foo<(anonymous namespace)::B>"); 2080 2081 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B", 2082 "A::foo"); 2083 2084 /* Shouldn't this parse? Looks like a bug in 2085 cp_demangled_name_to_comp. See PR c++/22411. */ 2086 #if 0 2087 CHECK ("A::foo<void(int)>::func(int)", 2088 "A::foo<void(int)>::func"); 2089 #else 2090 CHECK_INCOMPL ("A::foo<void(int)>::func(int)", 2091 "A::foo"); 2092 #endif 2093 2094 CHECK_INCOMPL ("A::foo<void(int", 2095 "A::foo"); 2096 2097 #undef CHECK 2098 #undef CHECK_INCOMPL 2099 } 2100 2101 } // namespace selftests 2102 2103 #endif /* GDB_SELF_CHECK */ 2104 2105 /* Don't allow just "maintenance cplus". */ 2106 2107 static void 2108 maint_cplus_command (const char *arg, int from_tty) 2109 { 2110 printf_unfiltered (_("\"maintenance cplus\" must be followed " 2111 "by the name of a command.\n")); 2112 help_list (maint_cplus_cmd_list, 2113 "maintenance cplus ", 2114 all_commands, gdb_stdout); 2115 } 2116 2117 /* This is a front end for cp_find_first_component, for unit testing. 2118 Be careful when using it: see the NOTE above 2119 cp_find_first_component. */ 2120 2121 static void 2122 first_component_command (const char *arg, int from_tty) 2123 { 2124 int len; 2125 char *prefix; 2126 2127 if (!arg) 2128 return; 2129 2130 len = cp_find_first_component (arg); 2131 prefix = (char *) alloca (len + 1); 2132 2133 memcpy (prefix, arg, len); 2134 prefix[len] = '\0'; 2135 2136 printf_unfiltered ("%s\n", prefix); 2137 } 2138 2139 /* Implement "info vtbl". */ 2140 2141 static void 2142 info_vtbl_command (const char *arg, int from_tty) 2143 { 2144 struct value *value; 2145 2146 value = parse_and_eval (arg); 2147 cplus_print_vtable (value); 2148 } 2149 2150 void 2151 _initialize_cp_support (void) 2152 { 2153 add_prefix_cmd ("cplus", class_maintenance, 2154 maint_cplus_command, 2155 _("C++ maintenance commands."), 2156 &maint_cplus_cmd_list, 2157 "maintenance cplus ", 2158 0, &maintenancelist); 2159 add_alias_cmd ("cp", "cplus", 2160 class_maintenance, 1, 2161 &maintenancelist); 2162 2163 add_cmd ("first_component", 2164 class_maintenance, 2165 first_component_command, 2166 _("Print the first class/namespace component of NAME."), 2167 &maint_cplus_cmd_list); 2168 2169 add_info ("vtbl", info_vtbl_command, 2170 _("Show the virtual function table for a C++ object.\n\ 2171 Usage: info vtbl EXPRESSION\n\ 2172 Evaluate EXPRESSION and display the virtual function table for the\n\ 2173 resulting object.")); 2174 2175 #ifdef HAVE_WORKING_FORK 2176 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance, 2177 &catch_demangler_crashes, _("\ 2178 Set whether to attempt to catch demangler crashes."), _("\ 2179 Show whether to attempt to catch demangler crashes."), _("\ 2180 If enabled GDB will attempt to catch demangler crashes and\n\ 2181 display the offending symbol."), 2182 NULL, 2183 NULL, 2184 &maintenance_set_cmdlist, 2185 &maintenance_show_cmdlist); 2186 #endif 2187 2188 #if GDB_SELF_TEST 2189 selftests::register_test ("cp_symbol_name_matches", 2190 selftests::test_cp_symbol_name_matches); 2191 selftests::register_test ("cp_remove_params", 2192 selftests::test_cp_remove_params); 2193 #endif 2194 } 2195